[NFC] Sema: Tidy up tuple pattern handling in coercePatternToType

Author: AnthonyLatsis

lib/Sema/TypeCheckPattern.cpp

@@ -1165,17 +1165,25 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
   // TODO: permit implicit conversions?
   case PatternKind::Tuple: {
     TuplePattern *TP = cast<TuplePattern>(P);
-    bool hadError = type->hasError();
-    
+
+    TupleType *tupleTy = type->getAs<TupleType>();
+
     // Sometimes a paren is just a paren. If the tuple pattern has a single
     // element, we can reduce it to a paren pattern.
-    bool canDecayToParen = TP->getNumElements() == 1;
-    auto decayToParen = [&]() -> Pattern * {
-      assert(canDecayToParen);
-      Pattern *sub = TP->getElement(0).getPattern();
-      sub = TypeChecker::coercePatternToType(
-          pattern.forSubPattern(sub, /*retainTopLevel=*/false), type,
-          subOptions);
+    //
+    // FIXME: This condition is rather loose, e.g. it makes the following compile:
+    // switch 0 {
+    //   case (int: 0): break
+    //   default: break
+    // }
+    // Do we really want/need to support this?
+    //
+    if (TP->getNumElements() == 1 &&
+        (!tupleTy || tupleTy->getNumElements() != 1)) {
+      auto *sub = TypeChecker::coercePatternToType(
+          pattern.forSubPattern(TP->getElement(0).getPattern(),
+                                /*retainTopLevel=*/false),
+          type, subOptions);
       if (!sub)
         return nullptr;
 
@@ -1186,63 +1194,50 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
       } else {
         P = sub;
       }
-      return P;
-    };
+    } else {
+      if (!tupleTy) {
+        diags.diagnose(TP->getStartLoc(),
+                       diag::tuple_pattern_in_non_tuple_context, type);
 
-    // The context type must be a tuple.
-    TupleType *tupleTy = type->getAs<TupleType>();
-    if (!tupleTy && !hadError) {
-      if (canDecayToParen)
-        return decayToParen();
-      diags.diagnose(TP->getStartLoc(),
-                     diag::tuple_pattern_in_non_tuple_context, type);
-      hadError = true;
-    }
+        return nullptr;
+      }
 
-    // The number of elements must match exactly.
-    if (!hadError && tupleTy->getNumElements() != TP->getNumElements()) {
-      if (canDecayToParen)
-        return decayToParen();
-      
-      diags.diagnose(TP->getStartLoc(), diag::tuple_pattern_length_mismatch,
-                     type);
-      hadError = true;
-    }
+      // The number of elements must match exactly.
+      if (tupleTy->getNumElements() != TP->getNumElements()) {
+        diags.diagnose(TP->getStartLoc(), diag::tuple_pattern_length_mismatch,
+                       type);
 
-    // Coerce each tuple element to the respective type.
-    P->setType(type);
+        return nullptr;
+      }
 
-    for (unsigned i = 0, e = TP->getNumElements(); i != e; ++i) {
-      TuplePatternElt &elt = TP->getElement(i);
+      // Coerce each tuple element to the respective type.
+      for (unsigned i = 0, e = TP->getNumElements(); i != e; ++i) {
+        TuplePatternElt &patternElt = TP->getElement(i);
+        const auto &typeElt = tupleTy->getElement(i);
+
+        // If the tuple pattern had a label for the tuple element, it must match
+        // the label for the tuple type being matched.
+        if (!patternElt.getLabel().empty() &&
+            patternElt.getLabel() != typeElt.getName()) {
+          diags.diagnose(patternElt.getLabelLoc(),
+                         diag::tuple_pattern_label_mismatch,
+                         patternElt.getLabel(), typeElt.getName());
+          return nullptr;
+        }
 
-      Type CoercionType;
-      if (hadError)
-        CoercionType = ErrorType::get(Context);
-      else
-        CoercionType = tupleTy->getElement(i).getType();
-      
-      // If the tuple pattern had a label for the tuple element, it must match
-      // the label for the tuple type being matched.
-      if (!hadError && !elt.getLabel().empty() &&
-          elt.getLabel() != tupleTy->getElement(i).getName()) {
-        diags.diagnose(elt.getLabelLoc(), diag::tuple_pattern_label_mismatch,
-                       elt.getLabel(), tupleTy->getElement(i).getName());
-        hadError = true;
-      }
+        auto *sub =
+            coercePatternToType(pattern.forSubPattern(patternElt.getPattern(),
+                                                      /*retainTopLevel=*/false),
+                                typeElt.getType(), subOptions);
+        if (!sub)
+          return nullptr;
 
-      auto sub = coercePatternToType(
-          pattern.forSubPattern(elt.getPattern(), /*retainTopLevel=*/false),
-          CoercionType, subOptions);
-      if (!sub)
-        return nullptr;
+        patternElt.setPattern(sub);
+      }
 
-      if (!hadError)
-        elt.setPattern(sub);
+      P->setType(type);
     }
 
-    if (hadError)
-      return nullptr;
-
     return P;
   }