Fixup the destructuring diagnostics

Use the isInvalid() bit on the TypeRepr to signal that a closure
parameter is potentially a tuple destructure.  This has two benefits
1) Parse is no longer using the isInvalid() bit on Decl
2) Invalidating the type repr itself means that we no longer spuriously
diagnose variable patterns in destructures as missing types.

Author: CodaFi

Diff for: lib/Parse/ParseExpr.cpp

@@ -2656,11 +2656,10 @@ parseClosureSignatureIfPresent(SmallVectorImpl<CaptureListEntry> &captureList,
   // to detect any tuple splat or destructuring as early as
   // possible and give a proper fix-it. See SE-0110 for more details.
   auto isTupleDestructuring = [](ParamDecl *param) -> bool {
-    if (!param->isInvalid())
+    auto *typeRepr = param->getTypeRepr();
+    if (!(typeRepr && typeRepr->isInvalid()))
       return false;
-    if (auto *typeRepr = param->getTypeRepr())
-      return !param->hasName() && isa<TupleTypeRepr>(typeRepr);
-    return false;
+    return !param->hasName() && isa<TupleTypeRepr>(typeRepr);
   };
 
   for (unsigned i = 0, e = params->size(); i != e; ++i) {

Diff for: lib/Parse/ParsePattern.cpp

@@ -361,8 +361,9 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
         // on is most likely argument destructuring, we are going
         // to diagnose that after all of the parameters are parsed.
         if (param.Type) {
-          // Mark current parameter as invalid so it is possible
+          // Mark current parameter type as invalid so it is possible
           // to diagnose it as destructuring of the closure parameter list.
+          param.Type->setInvalid();
           param.isInvalid = true;
           if (!isClosure) {
             // Unnamed parameters must be written as "_: Type".
@@ -521,7 +522,7 @@ mapParsedParameters(Parser &parser,
         // or typealias with underlying function type.
         param->setAutoClosure(attrs.has(TypeAttrKind::TAK_autoclosure));
       }
-    } if (paramInfo.SpecifierLoc.isValid()) {
+    } else if (paramInfo.SpecifierLoc.isValid()) {
       StringRef specifier;
       switch (paramInfo.SpecifierKind) {
       case ParamDecl::Specifier::InOut:
@@ -698,7 +699,7 @@ Parser::parseSingleParameterClause(ParameterContextKind paramContext,
   // Parse the parameter clause.
   status |= parseParameterClause(leftParenLoc, params, rightParenLoc,
                                  defaultArgs, paramContext);
-  
+
   // Turn the parameter clause into argument and body patterns.
   auto paramList = mapParsedParameters(*this, leftParenLoc, params,
                                        rightParenLoc, namePieces, paramContext);

Diff for: test/Constraints/tuple_arguments.swift

@@ -1468,8 +1468,6 @@ let _ = sr4745.enumerated().map { (count, element) in "\(count): \(element)" }
 // SR-4738
 
 let sr4738 = (1, (2, 3))
-// expected-error@+2{{use of undeclared type 'y'}}
-// expected-error@+1{{use of undeclared type 'z'}}
 [sr4738].map { (x, (y, z)) -> Int in x + y + z }
 // expected-error@-1 {{closure tuple parameter does not support destructuring}} {{20-26=arg1}} {{38-38=let (y, z) = arg1; }}
 
@@ -1478,10 +1476,8 @@ let r31892961_1 = [1: 1, 2: 2]
 r31892961_1.forEach { (k, v) in print(k + v) }
 
 let r31892961_2 = [1, 2, 3]
-// expected-error@+1{{use of undeclared type 'val'}}
 let _: [Int] = r31892961_2.enumerated().map { ((index, val)) in
   // expected-error@-1 {{closure tuple parameter does not support destructuring}} {{48-60=arg0}} {{3-3=\n  let (index, val) = arg0\n  }}
-  // expected-error@-2 {{use of undeclared type 'index'}}
   val + 1
 }
 
@@ -1690,6 +1686,7 @@ class Mappable<T> {
 
 let x = Mappable(())
 _ = x.map { (_: Void) in return () }
+_ = x.map { (_: ()) in () }
 
 // https://bugs.swift.org/browse/SR-9470
 do {
@@ -1756,3 +1753,4 @@ func noescapeSplat() {
     takesEscaping(t.0)
   }
 }
+