[ConstraintSystem] Fix closure parameter destructuring

Detect and fix closure parameter destructuring where
it's not currently allowed e.g. free standing closures
with contextual type `let _: ((Int, Int)) -> Void = { $0 + $1 }`

Author: xedin

lib/Sema/CSFix.cpp

@@ -343,6 +343,18 @@ AllowInvalidInitRef::create(RefKind kind, ConstraintSystem &cs, Type baseTy,
       cs, kind, baseTy, init, isStaticallyDerived, baseRange, locator);
 }
 
+bool AllowClosureParamDestructuring::diagnose(Expr *root, bool asNote) const {
+  return false;
+}
+
+AllowClosureParamDestructuring *
+AllowClosureParamDestructuring::create(ConstraintSystem &cs,
+                                       FunctionType *contextualType,
+                                       ConstraintLocator *locator) {
+  return new (cs.getAllocator())
+      AllowClosureParamDestructuring(cs, contextualType, locator);
+}
+
 bool AddMissingArguments::diagnose(Expr *root, bool asNote) const {
   MissingArgumentsFailure failure(root, getConstraintSystem(), Fn,
                                   NumSynthesized, getLocator());

lib/Sema/CSFix.h

@@ -105,7 +105,7 @@ enum class FixKind : uint8_t {
   /// fix this issue by pretending that member exists and matches
   /// given arguments/result types exactly.
   DefineMemberBasedOnUse,
-	
+
   /// Allow access to type member on instance or instance member on type
   AllowTypeOrInstanceMember,
 
@@ -126,6 +126,9 @@ enum class FixKind : uint8_t {
   /// If there are fewer arguments than parameters, let's fix that up
   /// by adding new arguments to the list represented as type variables.
   AddMissingArguments,
+
+  /// Allow single tuple closure parameter destructuring into N arguments.
+  AllowClosureParameterDestructuring,
 };
 
 class ConstraintFix {
@@ -618,6 +621,27 @@ class AllowInvalidInitRef final : public ConstraintFix {
                                      ConstraintLocator *locator);
 };
 
+class AllowClosureParamDestructuring final : public ConstraintFix {
+  FunctionType *ContextualType;
+
+  AllowClosureParamDestructuring(ConstraintSystem &cs,
+                                 FunctionType *contextualType,
+                                 ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::AllowClosureParameterDestructuring, locator),
+        ContextualType(contextualType) {}
+
+public:
+  std::string getName() const override {
+    return "allow closure parameter destructuring";
+  }
+
+  bool diagnose(Expr *root, bool asNote = false) const override;
+
+  static AllowClosureParamDestructuring *create(ConstraintSystem &cs,
+                                                FunctionType *contextualType,
+                                                ConstraintLocator *locator);
+};
+
 class AddMissingArguments final
     : public ConstraintFix,
       private llvm::TrailingObjects<AddMissingArguments,

lib/Sema/CSSimplify.cpp

@@ -1288,8 +1288,8 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
           return elt.getKind() != ConstraintLocator::OptionalPayload;
         });
 
+    auto &ctx = getASTContext();
     if (last != path.rend()) {
-      auto &ctx = getASTContext();
       if (last->getKind() == ConstraintLocator::ApplyArgToParam) {
         if (isSingleTupleParam(ctx, func2Params) &&
             canImplodeParams(func1Params)) {
@@ -1310,6 +1310,20 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
         }
       }
     }
+
+    if (shouldAttemptFixes()) {
+      auto *anchor = locator.trySimplifyToExpr();
+      if (anchor && isa<ClosureExpr>(anchor) &&
+          isSingleTupleParam(ctx, func2Params) &&
+          canImplodeParams(func1Params)) {
+        auto *fix = AllowClosureParamDestructuring::create(
+            *this, func2, getConstraintLocator(anchor));
+        if (recordFix(fix))
+          return getTypeMatchFailure(argumentLocator);
+
+        implodeParams(func1Params);
+      }
+    }
   }
 
   // https://bugs.swift.org/browse/SR-6796
@@ -5779,6 +5793,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::AllowTypeOrInstanceMember:
   case FixKind::AllowInvalidPartialApplication:
   case FixKind::AllowInvalidInitRef:
+  case FixKind::AllowClosureParameterDestructuring:
     llvm_unreachable("handled elsewhere");
   }