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

Author: AnthonyLatsis

lib/Sema/TypeCheckPattern.cpp

@@ -1204,17 +1204,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;
 
@@ -1225,63 +1233,51 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
       } else {
         P = sub;
       }
+
       return P;
-    };
+    }
 
-    // The context type must be a tuple.
-    TupleType *tupleTy = type->getAs<TupleType>();
-    if (!tupleTy && !hadError) {
-      if (canDecayToParen)
-        return decayToParen();
+    if (!tupleTy) {
       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();
-      
+    if (tupleTy->getNumElements() != TP->getNumElements()) {
       diags.diagnose(TP->getStartLoc(), diag::tuple_pattern_length_mismatch,
                      type);
-      hadError = true;
+
+      return nullptr;
     }
 
     // Coerce each tuple element to the respective type.
-    P->setType(type);
-
     for (unsigned i = 0, e = TP->getNumElements(); i != e; ++i) {
-      TuplePatternElt &elt = TP->getElement(i);
+      TuplePatternElt &patternElt = TP->getElement(i);
+      const auto &typeElt = tupleTy->getElement(i);
 
-      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;
+      if (!patternElt.getLabel().empty() &&
+          patternElt.getLabel() != typeElt.getName()) {
+        diags.diagnose(patternElt.getLabelLoc(),
+                       diag::tuple_pattern_label_mismatch,
+                       patternElt.getLabel(), typeElt.getName());
+        return nullptr;
       }
 
-      auto sub = coercePatternToType(
-          pattern.forSubPattern(elt.getPattern(), /*retainTopLevel=*/false),
-          CoercionType, subOptions);
+      auto *sub =
+          coercePatternToType(pattern.forSubPattern(patternElt.getPattern(),
+                                                    /*retainTopLevel=*/false),
+                              typeElt.getType(), subOptions);
       if (!sub)
         return nullptr;
 
-      if (!hadError)
-        elt.setPattern(sub);
+      patternElt.setPattern(sub);
     }
 
-    if (hadError)
-      return nullptr;
-
+    P->setType(type);
     return P;
   }