[CSSimplify] Increase score for closure argument when in a call autoclosure context to avoid ambiguity

Author: LucianoPAlmeida

lib/Sema/CSSimplify.cpp

@@ -1347,6 +1347,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_FunctionConversion);
+        }
+
         // 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
@@ -2211,6 +2222,20 @@ 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
+    //
+    if (func1Param.isAutoClosure() &&
+        (!func2Param.isAutoClosure() &&
+         func2Param.getPlainType()->is<FunctionType>())) {
+      increaseScore(SK_FunctionConversion);
+    }
+
     // Variadic bit must match.
     if (func1Param.isVariadic() != func2Param.isVariadic()) {
       if (!(shouldAttemptFixes() && func2Param.isVariadic()))