[CSOptimizer] Allow literal arguments to match parameters that conform to ExpressibleBy{Integer, Float}Literal

`scoreCandidateMatch` needs to reflect the fact that literal can
assume any type that conforms to `ExpressibleBy{Integer, Float}Literal`
protocol but since such bindings are non-default and alway produce
a worse solution vs. default literal types if all of the arguments
are literals let's use only exact matches otherwise there is a chance
of "over-favoring" and creating more work for ranking.

Author: xedin

lib/Sema/CSOptimizer.cpp

@@ -481,6 +481,22 @@ static Constraint *determineBestChoicesInContext(
       }
 
       if (options.contains(MatchFlag::Literal)) {
+        // Integer and floating-point literals can match any parameter
+        // type that conforms to `ExpressibleBy{Integer, Float}Literal`
+        // protocol but since that would constitute a non-default binding
+        // the score has to be slightly lowered.
+        if (!paramType->hasTypeParameter()) {
+          if (candidateType->isInt() &&
+              TypeChecker::conformsToKnownProtocol(
+                  paramType, KnownProtocolKind::ExpressibleByIntegerLiteral))
+            return 0.2;
+
+          if (candidateType->isDouble() &&
+              TypeChecker::conformsToKnownProtocol(
+                  paramType, KnownProtocolKind::ExpressibleByFloatLiteral))
+            return 0.2;
+        }
+
         return 0;
       }
 
@@ -634,7 +650,10 @@ static Constraint *determineBestChoicesInContext(
           if (!matchings)
             return;
 
-          bool favorExactMatchesOnly = false;
+          // If all of the arguments are literals, let's prioritize exact
+          // matches to filter out non-default literal bindings which otherwise
+          // could cause "over-favoring".
+          bool favorExactMatchesOnly = onlyLiteralCandidates;
           // Preserves old behavior where for unary calls to members
           // the solver would not consider choices that didn't match on
           // the number of parameters (regardless of defaults) and only
@@ -812,7 +831,7 @@ static Constraint *determineBestChoicesInContext(
                                [&resultTy](const auto &param) {
                                  return param.getPlainType()->isEqual(resultTy);
                                }))
-                score += 0.001;
+                score += 0.1;
             }
 
             favoredChoices.push_back({choice, score});

test/Constraints/old_hack_related_ambiguities.swift

@@ -237,3 +237,12 @@ do {
     assert(s.isEmpty, "") // Ok
   }
 }
+
+extension Double {
+    public static func * (left: Float, right: Double) -> Double { 0 }
+}
+
+func test_non_default_literal_use(arg: Float) {
+    let v = arg * 2.0 // shouldn't use `(Float, Double) -> Double` overload
+    let _: Float = v // Ok
+}