[CSSimplify] Avoid resolving extraneous (trailing) closures

lib/Sema/CSSimplify.cpp

@@ -1620,6 +1620,21 @@ static ConstraintSystem::TypeMatchResult matchCallArguments(
             cs, contextualType, extraArguments,
             cs.getConstraintLocator(locator));
 
+        for (const auto &extraArg : extraArguments) {
+          auto argument = argList->get(extraArg.first);
+          auto argType = extraArg.second.getPlainType();
+
+          // Prevent closure resolution by binding it to a placeholder
+          // because the main issue here is invalid overload and
+          // errors produced from the closure body are going to be
+          // superfluous.
+          if (isExpr<ClosureExpr>(argument.getExpr())) {
+            cs.recordTypeVariablesAsHoles(argType);
+          } else {
+            cs.recordAnyTypeVarAsPotentialHole(argType);
+          }
+        }
+
         if (cs.recordFix(fix, /*impact=*/extraArguments.size() * 5))
           return cs.getTypeMatchFailure(locator);
       }
@@ -11371,6 +11386,12 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFallbackTypeConstraint(
     return SolutionKind::Unsolved;
   }
 
+  // Propagate placeholders into an inferred closure type. Without this
+  // we'd produce superfluous diagnostics about parameter/result types.
+  if (defaultableType->isPlaceholder() && locator.directlyAt<ClosureExpr>()) {
+    recordTypeVariablesAsHoles(fallbackType);
+  }
+
   // Otherwise, any type is fine.
   return SolutionKind::Solved;
 }

validation-test/Sema/type_checker_crashers_fixed/rdar141012049.swift

@@ -0,0 +1,15 @@
+// RUN: %target-typecheck-verify-swift
+
+func test(_ v: [Int]) {
+  let result = v.filter { }.flatMap(\.wrong) {
+    // expected-error@-1 {{type for closure argument list expects 1 argument, which cannot be implicitly ignored}}
+    // expected-error@-2 {{cannot convert value of type '()' to closure result type 'Bool'}}
+    // expected-error@-3 {{value of type 'Int' has no member 'wrong'}}
+    // expected-error@-4 {{extra trailing closure passed in call}}
+    print(result)
+  }
+
+  let otherResult = v.filter { _ in false }.flatMap(\.wrong, { $0 }, 42)
+  // expected-error@-1 {{value of type 'Int' has no member 'wrong'}}
+  // expected-error@-2 {{extra arguments at positions #2, #3 in call}}
+}