[ConstraintSystem] Accept trailing closure if the last parameter is defaulted

If the last parameter is defaulted, there might be
an attempt to use a trailing closure with previous
parameter that accepts a function type e.g.

```swift
func foo(_: () -> Int, _ x: Int = 0) {}
foo { 42 }
```

Resolves: rdar://problem/55102498

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -430,19 +430,38 @@ matchCallArguments(SmallVectorImpl<AnyFunctionType::Param> &args,
 
   // If we have a trailing closure, it maps to the last parameter.
   if (hasTrailingClosure && numParams > 0) {
-    const auto &param = params[numParams - 1];
+    unsigned lastParamIdx = numParams - 1;
+    bool lastAcceptsTrailingClosure =
+        acceptsTrailingClosure(params[lastParamIdx]);
+
+    // If the last parameter is defaulted, this might be
+    // an attempt to use a trailing closure with previous
+    // parameter that accepts a function type e.g.
     //
+    // func foo(_: () -> Int, _ x: Int = 0) {}
+    // foo { 42 }
+    if (!lastAcceptsTrailingClosure && numParams > 1 &&
+        paramInfo.hasDefaultArgument(lastParamIdx)) {
+      auto paramType = params[lastParamIdx - 1].getPlainType();
+      // If the parameter before defaulted last accepts.
+      if (paramType->is<AnyFunctionType>()) {
+        lastAcceptsTrailingClosure = true;
+        lastParamIdx -= 1;
+      }
+    }
+
     bool isExtraClosure = false;
     // If there is no suitable last parameter to accept the trailing closure,
     // notify the listener and bail if we need to.
-    if (!acceptsTrailingClosure(param)) {
+    if (!lastAcceptsTrailingClosure) {
       if (numArgs > numParams) {
         // Argument before the trailing closure.
         unsigned prevArg = numArgs - 2;
         auto &arg = args[prevArg];
         // If the argument before trailing closure matches
         // last parameter, this is just a special case of
         // an extraneous argument.
+        const auto param = params[numParams - 1];
         if (param.hasLabel() && param.getLabel() == arg.getLabel()) {
           isExtraClosure = true;
           if (listener.extraArgument(numArgs - 1))
@@ -451,7 +470,7 @@ matchCallArguments(SmallVectorImpl<AnyFunctionType::Param> &args,
       }
 
       if (!isExtraClosure &&
-          listener.trailingClosureMismatch(numParams - 1, numArgs - 1))
+          listener.trailingClosureMismatch(lastParamIdx, numArgs - 1))
         return true;
     }
 
@@ -460,7 +479,7 @@ matchCallArguments(SmallVectorImpl<AnyFunctionType::Param> &args,
     ++numClaimedArgs;
     // Let's claim the trailing closure unless it's an extra argument.
     if (!isExtraClosure)
-      parameterBindings[numParams - 1].push_back(numArgs - 1);
+      parameterBindings[lastParamIdx].push_back(numArgs - 1);
   }
 
   // Mark through the parameters, binding them to their arguments.

test/Constraints/closures.swift

@@ -907,3 +907,10 @@ do {
 // via the 'T -> U => T -> ()' implicit conversion.
 let badResult = { (fn: () -> ()) in fn }
 // expected-error@-1 {{expression resolves to an unused function}}
+
+// rdar://problem/55102498 - closure's result type can't be inferred if the last parameter has a default value
+func test_trailing_closure_with_defaulted_last() {
+  func foo<T>(fn: () -> T, value: Int = 0) {}
+  foo { 42 } // Ok
+  foo(fn: { 42 }) // Ok
+}