[ConstraintSystem] Ensure we prefer f(_: Any) to f(_: Any?) when both work.

...unless the argument is an `Any?`, in which case we prefer `f(_: Any?)`.

This change also results in our selecting f<T>(_: T) over f(_:
Any). Coercing with 'as Any' makes it possible to explicitly select
the Any overload. Previously there was no way to select the generic
overload.

Author: rudkx

lib/Sema/CSRanking.cpp

@@ -656,7 +656,8 @@ static bool isDeclAsSpecializedAs(TypeChecker &tc, DeclContext *dc,
           Type objType2 = paramType2->lookThroughAllOptionalTypes(optionals2);
           auto numOptionals2 = optionals2.size();
 
-          if (numOptionals1 > numOptionals2 && objType2->is<TypeVariableType>())
+          if (numOptionals1 > numOptionals2 &&
+              (objType2->is<TypeVariableType>() || objType2->isAny()))
             return false;
 
           // Check whether the first parameter is a subtype of the second.

lib/Sema/CSSimplify.cpp

@@ -683,6 +683,9 @@ matchCallArguments(ConstraintSystem &cs, ConstraintKind kind,
       }
     }
 
+    if (!argType->isAny())
+      cs.increaseScore(ScoreKind::SK_EmptyExistentialConversion);
+
     return cs.getTypeMatchSuccess();
   }
 

test/Constraints/overload.swift

@@ -251,6 +251,38 @@ func coalesce() {
 
 // Ensure that we do not select the (T?, T) -> T version of ??, which
 // would result in a warning about RHS never being selected.
-func rdar19748710(_ value: Int?) -> Int? {
+func rdar19748710_0(_ value: Int?) -> Int? {
   return value ?? value
 }
+
+// Again, ensure we do not select (T?, T) -> T, despite forcing the result.
+func rdar19748710_1(_ value: Int?) -> Int? {
+  return (value ?? value)!
+}
+
+// FIXME: We choose to inject the LHS, which really doesn't seem like
+// the reasonable choice here. It seems more predictable and safe to
+// either inject the result of ??, or treat this as an error since the
+// current behavior will result in .some(nil) being force-unwrapped
+// rather than the RHS value. The diagnostic is problematic, too,
+// since it claims 'Int?' is a non-optional type.
+func rdar19748710_2(_ value: Int?) -> Int? {
+  return (value ?? value)!! // expected-warning {{left side of nil coalescing operator '??' has non-optional type 'Int?', so the right side is never used}}
+}
+
+// Ensure that we select the more closely matching function between
+// the two _g overloads.
+func giveAny() -> Any { fatalError() }
+func giveAnyOptional() -> Any? { fatalError() }
+func takeAny(_ a: Any?) -> Any? { fatalError() }
+func takeAny(_ a: Any) -> Any { fatalError() }
+
+func testAnyOptional() {
+  let r = takeAny(giveAnyOptional())
+  let _ = r!
+}
+
+func testAny() {
+  let r = takeAny(giveAny())
+  let _ = r! // expected-error {{cannot force unwrap value of non-optional type 'Any'}}
+}

test/Constraints/overload_silgen.swift

@@ -0,0 +1,10 @@
+// RUN: %target-swift-emit-silgen %s | %FileCheck %s
+
+// CHECK: sil hidden @$S15overload_silgen8anyToIntySiypF
+// CHECK: end sil function '$S15overload_silgen8anyToIntySiypF'
+func anyToInt(_: Any) -> Int { fatalError() }
+
+// CHECK: sil hidden @$S15overload_silgen8anyToIntySiSgypSgF
+// CHECK: function_ref @$S15overload_silgen8anyToIntySiypF
+// CHECK: end sil function '$S15overload_silgen8anyToIntySiSgypSgF'
+func anyToInt(_ value: Any?) -> Int? { return anyToInt(value!) }

validation-test/Sema/OverridesAndOverloads.swift

@@ -328,7 +328,8 @@ Overloads.test("generic methods are worse than non-generic") {
   }
 
   Base().foo(C1());     expectEqual("foo(C1)", which)
-  Base().foo(Token1()); expectEqual("foo(Any)", which)
+  Base().foo(Token1()); expectEqual("foo(T)", which)
+  Base().foo(Token1() as Any); expectEqual("foo(Any)", which)
 
   Base().bar(C1());     expectEqual("bar(C1)", which)
   Base().bar(Token1()); expectEqual("bar(T)", which)