[CSSimplify] Avoid resolving extraneous (trailing) closures

If a (trailing) closure is determined to be an extraneous argument
for one of the overload choices it needs to be marked as hole as
eagerly as possible and prevented from being resolved because
otherwise it's going to be disconnected from the rest of the
constraint system and resolution might not be able to find all of
the referenced variables. This could result either in crashes
or superfluous diagnostics.

Resolves: rdar://141012049

Author: xedin

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}}
+}