Merge pull request #36076 from LucianoPAlmeida/SR-2705-ranking-autoclosure

[SR-2705][Sema] Always favor non-autoclosure parameter function overload

Author: LucianoPAlmeida

include/swift/Sema/ConstraintSystem.h

@@ -802,8 +802,10 @@ enum ScoreKind {
   SK_KeyPathSubscript,
   /// A conversion from a string, array, or inout to a pointer.
   SK_ValueToPointerConversion,
+  /// A closure/function conversion to an autoclosure parameter.
+  SK_FunctionToAutoClosureConversion,
 
-  SK_LastScoreKind = SK_ValueToPointerConversion,
+  SK_LastScoreKind = SK_FunctionToAutoClosureConversion,
 };
 
 /// The number of score kinds.

lib/Sema/CSRanking.cpp

@@ -81,6 +81,9 @@ static StringRef getScoreKindName(ScoreKind kind) {
 
   case SK_ValueToPointerConversion:
     return "value-to-pointer conversion";
+
+  case SK_FunctionToAutoClosureConversion:
+    return "function to autoclosure parameter";
   }
 }
 

lib/Sema/CSSimplify.cpp

@@ -1378,6 +1378,17 @@ ConstraintSystem::TypeMatchResult constraints::matchCallArguments(
         auto *fnType = paramTy->castTo<FunctionType>();
         auto *argExpr = getArgumentExpr(locator.getAnchor(), argIdx);
 
+        // If this is a call to a function with a closure argument and the
+        // parameter is an autoclosure, let's just increment the score here
+        // so situations like bellow are not ambiguous.
+        //    func f<T>(_: () -> T) {}
+        //    func f<T>(_: @autoclosure () -> T) {}
+        //
+        //    f { } // OK
+        if (isExpr<ClosureExpr>(argExpr)) {
+          cs.increaseScore(SK_FunctionToAutoClosureConversion);
+        }
+
         // If the argument is not marked as @autoclosure or
         // this is Swift version >= 5 where forwarding is not allowed,
         // argument would always be wrapped into an implicit closure
@@ -2242,6 +2253,26 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
     auto func1Param = func1Params[i];
     auto func2Param = func2Params[i];
 
+    // Increase the score if matching an autoclosure parameter to an function
+    // type, so we enforce that non-autoclosure overloads are preferred.
+    //
+    //   func autoclosure(f: () -> Int) { }
+    //   func autoclosure(f: @autoclosure () -> Int) { }
+    //
+    //   let _ = autoclosure as (() -> (Int)) -> () // non-autoclosure preferred
+    //
+    auto isAutoClosureFunctionMatch = [](AnyFunctionType::Param &param1,
+                                         AnyFunctionType::Param &param2) {
+      return param1.isAutoClosure() &&
+             (!param2.isAutoClosure() &&
+              param2.getPlainType()->is<FunctionType>());
+    };
+
+    if (isAutoClosureFunctionMatch(func1Param, func2Param) ||
+        isAutoClosureFunctionMatch(func2Param, func1Param)) {
+      increaseScore(SK_FunctionToAutoClosureConversion);
+    }
+
     // Variadic bit must match.
     if (func1Param.isVariadic() != func2Param.isVariadic()) {
       if (!(shouldAttemptFixes() && func2Param.isVariadic()))

test/Constraints/sr2705.swift

@@ -0,0 +1,43 @@
+// RUN: %target-swift-emit-silgen %s -verify | %FileCheck %s
+
+func f<T>(_: () -> T) {}
+func f<T>(_: @autoclosure () -> T) {}
+
+// CHECK: function_ref @$s6sr27051fyyxyXElF
+f { } // OK
+
+func f1<T>(_: () -> T, _: () -> T) {}
+func f1<T>(_: @autoclosure () -> T, _: @autoclosure () -> T) {}
+
+// CHECK: function_ref @$s6sr27052f1yyxyXE_xyXEtlF 
+f1({}, {}) // OK
+
+func f2<T>(_: () -> T, _: () -> T) { }
+func f2<T>(_: () -> T, _: @autoclosure () -> T) { }
+
+// CHECK: function_ref @$s6sr27052f2yyxyXE_xyXEtlF 
+f2({}, {}) // OK
+
+func f3(_: () -> Int) {}
+func f3(_: @autoclosure () -> Int) {}
+
+// CHECK: function_ref @$s6sr27052f3yySiyXEF 
+f3 { 0 } // OK
+ 
+func autoclosure(f: () -> Int) { }
+func autoclosure(f: @autoclosure () -> Int) { }
+func autoclosure(f: Int) { }
+
+// CHECK: function_ref @$s6sr270511autoclosure1fySiyXE_tF
+autoclosure(f: { 0 }) // OK
+
+// CHECK: function_ref @$s6sr27052fnyySiyXEF 
+let _ = autoclosure as (() -> (Int)) -> () // OK
+
+func test(_: (@autoclosure () -> Int) -> Void) {}
+func test(_: (() -> Int) -> Void) {}
+
+func fn(_: () -> Int) {}
+
+// CHECK: function_ref @$s6sr27054testyyySiyXEXEF
+test(fn) // OK