[CSOptimizer] Prevent candidate inference from unresolved generic parameters and ternary expressions

We need to have a notion of "complete" binding set before
we can allow inference from generic parameters and ternary,
otherwise we'd make a favoring decision that might not be
correct i.e. `v ?? (<<cond>> ? nil : o)` where `o` is `Int`.
`getBindingsFor` doesn't currently infer transitive bindings
which means that for a ternary we'd only have a single
binding - `Int` which could lead to favoring overload of
`??` and has non-optional parameter on the right-hand side.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -496,6 +496,10 @@ class TypeVariableType::Implementation {
   /// function call.
   bool isFunctionResult() const;
 
+  /// Determine whether this type variable represents a type of the ternary
+  /// operator.
+  bool isTernary() const;
+
   /// Retrieve the representative of the equivalence class to which this
   /// type variable belongs.
   ///

lib/Sema/CSOptimizer.cpp

@@ -857,6 +857,18 @@ static void determineBestChoicesInContext(
       if (auto *typeVar = argType->getAs<TypeVariableType>()) {
         auto bindingSet = cs.getBindingsFor(typeVar);
 
+        // We need to have a notion of "complete" binding set before
+        // we can allow inference from generic parameters and ternary,
+        // otherwise we'd make a favoring decision that might not be
+        // correct i.e. `v ?? (<<cond>> ? nil : o)` where `o` is `Int`.
+        // `getBindingsFor` doesn't currently infer transitive bindings
+        // which means that for a ternary we'd only have a single
+        // binding - `Int` which could lead to favoring overload of
+        // `??` and has non-optional parameter on the right-hand side.
+        if (typeVar->getImpl().getGenericParameter() ||
+            typeVar->getImpl().isTernary())
+          continue;
+
         auto restoreOptionality = [](Type type, unsigned numOptionals) {
           for (unsigned i = 0; i != numOptionals; ++i)
             type = type->wrapInOptionalType();

lib/Sema/TypeCheckConstraints.cpp

@@ -212,6 +212,10 @@ bool TypeVariableType::Implementation::isFunctionResult() const {
   return locator && locator->isLastElement<LocatorPathElt::FunctionResult>();
 }
 
+bool TypeVariableType::Implementation::isTernary() const {
+  return locator && locator->directlyAt<TernaryExpr>();
+}
+
 void *operator new(size_t bytes, ConstraintSystem& cs,
                    size_t alignment) {
   return cs.getAllocator().Allocate(bytes, alignment);

test/Constraints/nil-coalescing-favoring.swift

@@ -42,3 +42,23 @@ extension Array where Element == UInt8 {
     fatalError()
   }
 }
+
+func test_no_incorrect_favoring(v: Int?, o: Int) {
+  func ternary<T>(_: T, _: T) -> T { fatalError() }
+
+  func nilCoelesing<T>(_: T?, _: T) -> T { fatalError() }
+  func nilCoelesing<T>(_: T?, _: T?) -> T? { fatalError() }
+
+  let t1 = v ?? (true ? nil : v)
+  let t2 = v ?? ternary(nil, o)
+
+  let s1 = nilCoelesing(v, (true ? nil : v))
+  let s2 = nilCoelesing(v, ternary(nil, o))
+
+  func sameType<T>(_: T, as: T.Type) {}
+
+  sameType(t1, as: Int?.self)
+  sameType(t2, as: Int?.self)
+  sameType(s1, as: Int?.self)
+  sameType(s2, as: Int?.self)
+}