[CSSimplify] Fix trailing closure vs. defaulted parameter matching

If current parameter cannot accept a trailing closure, let's match
current closure argument to it only if there is absolutely no
possible other choice e.g. no other parameters (defaulted or not)
that could accept the closure via a less restrictive backward scan.

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -467,6 +467,35 @@ static bool matchCallArgumentsImpl(
         return;
       }
 
+      // Let's consider current closure to be extraneous if:
+      //
+      // - current parameter has a default value and doesn't accept a trailing
+      //   closure; and
+      // - no other free parameter after this one accepts a trailing closure via
+      //   forward or backward scan. This check makes sure that it's safe to
+      //   reject and push it to the next parameter without affecting backward
+      //   scan logic.
+      //
+      // In other words - let's push the closure argument through defaulted
+      // parameters until it can be considered extraneous if no parameters
+      // could possibly match it.
+      if (!paramInfo.acceptsUnlabeledTrailingClosureArgument(paramIdx) &&
+          !parameterRequiresArgument(params, paramInfo, paramIdx)) {
+        if (llvm::none_of(
+                range(paramIdx + 1, params.size()), [&](unsigned idx) {
+                  return parameterBindings[idx].empty() &&
+                         (paramInfo.acceptsUnlabeledTrailingClosureArgument(
+                              idx) ||
+                          backwardScanAcceptsTrailingClosure(params[idx]));
+                })) {
+          haveUnfulfilledParams = true;
+          return;
+        }
+
+        // If one or more parameters can match the closure, let's check
+        // whether backward scan is applicable here.
+      }
+
       // If this parameter does not require an argument, consider applying a
       // backward-match rule that skips this parameter if doing so is the only
       // way to successfully match arguments to parameters.

test/Constraints/callAsFunction.swift

@@ -8,15 +8,21 @@
 protocol View {}
 struct EmptyView: View {}
 
+enum Align {
+case top, center, bottom
+}
+
 struct MyLayout {
+  init(alignment: Align? = .center, spacing: Double? = 0.0) {}
+
   func callAsFunction<V: View>(content: () -> V) -> MyLayout { .init() }
   func callAsFunction<V: View>(answer: () -> Int,
                                content: () -> V) -> MyLayout { .init() }
 }
 
 struct Test {
   var body1: MyLayout {
-    MyLayout() {
+    MyLayout(spacing: 1.0) {
       EmptyView() // Ok
     }
   }
@@ -28,6 +34,33 @@ struct Test {
       EmptyView() // Ok
     }
   }
+
+  var body3: MyLayout {
+    MyLayout(alignment: .top) {
+      let x = 42
+      return x
+    } content: {
+      EmptyView() // Ok
+    }
+  }
+
+  var body4: MyLayout {
+    MyLayout(spacing: 1.0) {
+      let x = 42
+      return x
+    } content: {
+      _ = 42
+      return EmptyView() // Ok
+    }
+  }
+
+  var body5: MyLayout {
+    MyLayout(alignment: .bottom, spacing: 1.0) {
+      42
+    } content: {
+      EmptyView() // Ok
+    }
+  }
 }
 
 // rdar://92912878 - filtering prevents disambiguation of `.callAsFunction`
@@ -51,3 +84,14 @@ func test_no_filtering_of_overloads() {
     }
   }
 }
+
+func test_default_arguments_do_not_interfere() {
+  struct S {
+    init(a: Int? = 42, b: String = "") {}
+    func callAsFunction(_: () -> Void) -> S { S() }
+  }
+
+  _ = S { _ = 42 }
+  _ = S(a: 42) { _ = 42 }
+  _ = S(b: "") { _ = 42 }
+}