[CSOptimizer] Fix scoring while matching against partially resolved parameter types

When matching candidate like `[Int]` against `Array<Element>`
we need to conservatively assume that if the nominals match
the argument is a viable exact match because otherwise it's
possible to skip some of the valid matches when other overload
choice have generic parameters at the same parameter position.

Author: xedin

lib/Sema/CSOptimizer.cpp

@@ -1354,13 +1354,25 @@ static void determineBestChoicesInContext(
       // types match i.e. Array<Element> as a parameter.
       //
       // This is slightly better than all of the conformances matching
-      // because the parameter is concrete and could split the graph.      
+      // because the parameter is concrete and could split the system.
       if (paramType->hasTypeParameter()) {
         auto *candidateDecl = candidateType->getAnyNominal();
         auto *paramDecl = paramType->getAnyNominal();
 
-        if (candidateDecl && paramDecl && candidateDecl == paramDecl)
-          return 0.8;
+        // Conservatively we need to make sure that this is not worse
+        // than matching against a generic parameter with or without
+        // requirements.
+        if (candidateDecl && paramDecl && candidateDecl == paramDecl) {
+          // If the candidate it not yet fully resolved, let's lower the
+          // score slightly to avoid over-favoring generic overload choices.
+          if (candidateType->hasTypeVariable())
+            return 0.8;
+
+          // If the candidate is fully resolved we need to treat this
+          // as we would generic parameter otherwise there is a risk
+          // of skipping some of the valid choices.
+          return choice->isOperator() ? 0.9 : 1.0;
+        }
       }
 
       return 0;

validation-test/Sema/custom_array_literal_with_operators.swift

@@ -0,0 +1,39 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol ScalarOrArray {
+}
+
+protocol SpecialValue: ScalarOrArray {
+}
+
+extension Array: ScalarOrArray where Element: SpecialValue {
+}
+
+struct CustomArray : ScalarOrArray {
+}
+
+extension CustomArray : ExpressibleByArrayLiteral {
+  public init(arrayLiteral elements: Int32...) {
+    self.init()
+  }
+}
+
+extension Int32: SpecialValue {
+}
+
+func +<T: ScalarOrArray>(_: T, _: CustomArray) -> CustomArray {}
+func +<T: ScalarOrArray>(_: CustomArray, _: T) -> CustomArray {}
+func +(_: CustomArray, _: CustomArray) -> CustomArray {}
+
+extension Sequence where Element == Int {
+  var asInt32: [Int32] { [] }
+}
+
+extension Array where Element == Int {
+  var asInt32: [Int32] { [] }
+}
+
+func test(v: Int32, b: [Int]) -> [Int32] {
+  let result = [1, v - v] + b.asInt32
+  return result // Ok
+}