[CSOptimizer] A narrow fix for nil coalescing operator optimization

`??` is overloaded on optionality of the second parameter,
prevent ranking the argument candidates for this parameter
if there are candidates that come from failable initializer
overloads because non-optional candidates are always going
to be better and that can skew the selection.

Resolves: rdar://156853018

Author: xedin

lib/Sema/CSOptimizer.cpp

@@ -970,6 +970,8 @@ static void determineBestChoicesInContext(
 
     bool hasArgumentCandidates = false;
     bool isOperator = isOperatorDisjunction(disjunction);
+    bool isNilCoalescingOperator =
+        isOperator && isOperatorNamed(disjunction, "??");
 
     for (unsigned i = 0, n = argFuncType->getNumParams(); i != n; ++i) {
       const auto &param = argFuncType->getParams()[i];
@@ -1603,6 +1605,20 @@ static void determineBestChoicesInContext(
             double bestCandidateScore = 0;
             llvm::BitVector mismatches(argumentCandidates[argIdx].size());
 
+            // `??` is overloaded on optionality of the second parameter,
+            // prevent ranking the argument candidates for this parameter
+            // if there are candidates that come from failable initializer
+            // overloads because non-optional candidates are always going
+            // to be better and that can skew the selection.
+            if (isNilCoalescingOperator && argIdx == 1) {
+              if (llvm::any_of(argumentCandidates[argIdx],
+                               [](const auto &candidate) {
+                                 return candidate.fromInitializerCall &&
+                                        candidate.type->getOptionalObjectType();
+                               }))
+                continue;
+            }
+
             for (unsigned candidateIdx :
                  indices(argumentCandidates[argIdx])) {
               // If one of the candidates matched exactly there is no reason

test/Constraints/optional.swift

@@ -618,3 +618,37 @@ func testPassingOptionalChainAsWrongArgument() {
     test.fn(arr?.first) // expected-error {{cannot convert value of type 'Int?' to expected argument type 'String?'}}
   }
 }
+
+// Make sure that optimizer doesn't select ??(T?, T) -> T
+protocol Syntax {
+  init?(_: some Syntax)
+}
+
+protocol SubSyntax: Syntax {}
+
+extension SubSyntax {
+  init(_: String) throws { fatalError() }
+}
+
+extension Optional : Syntax where Wrapped == Int {
+  init?(_: some Syntax) { self = .some(42) }
+}
+
+do {
+  struct TestSyntax : SubSyntax {
+    init?(_: some Syntax) {
+    }
+  }
+
+  struct S {
+    var value: Int
+  }
+
+
+  func context(from: TestSyntax?, root: some Syntax) {
+  }
+
+  func test(v: some Syntax, other: [S]) {
+    context(from: TestSyntax(v) ?? TestSyntax(other.first?.value), root: v) // Ok (no warnings)
+  }
+}