[Statement checker] Always wire up case vars with bindSwitchCasePatternVars

bindSwitchCasePatternVars() was introduced as a simpler way to wire up
the "parent" links for case variables with same-named case variables
from the previous case item, and is used in the function builders code
to handle switch statements. It duplicated some logic from the
statement checker that did the same thing using a more complicated
algorithm.

Switch (ha ha) the logic in the statement checker over to using
bindSwitchCasePatternVars(), fixing a bug involving unresolved
patterns along the way, and remove the old code that incrementally
wired up the parent links. The resulting code is simpler and is
unified across the various code paths.

Author: DougGregor

include/swift/AST/Stmt.h

@@ -814,13 +814,13 @@ class CaseLabelItem {
     Default,
   };
 
-  Pattern *CasePattern;
+  llvm::PointerIntPair<Pattern *, 1, bool> CasePatternAndResolved;
   SourceLoc WhereLoc;
   llvm::PointerIntPair<Expr *, 1, Kind> GuardExprAndKind;
 
   CaseLabelItem(Kind kind, Pattern *casePattern, SourceLoc whereLoc,
                 Expr *guardExpr)
-    : CasePattern(casePattern), WhereLoc(whereLoc),
+    : CasePatternAndResolved(casePattern, false), WhereLoc(whereLoc),
       GuardExprAndKind(guardExpr, kind) {}
 
 public:
@@ -848,9 +848,19 @@ class CaseLabelItem {
   SourceLoc getEndLoc() const;
   SourceRange getSourceRange() const;
 
-  Pattern *getPattern() { return CasePattern; }
-  const Pattern *getPattern() const { return CasePattern; }
-  void setPattern(Pattern *CasePattern) { this->CasePattern = CasePattern; }
+  Pattern *getPattern() {
+    return CasePatternAndResolved.getPointer();
+  }
+  const Pattern *getPattern() const {
+    return CasePatternAndResolved.getPointer();
+  }
+  bool isPatternResolved() const {
+    return CasePatternAndResolved.getInt();
+  }
+  void setPattern(Pattern *CasePattern, bool resolved) {
+    this->CasePatternAndResolved.setPointer(CasePattern);
+    this->CasePatternAndResolved.setInt(resolved);
+  }
 
   /// Return the guard expression if present, or null if the case label has
   /// no guard.

lib/AST/ASTWalker.cpp

@@ -1628,7 +1628,7 @@ Stmt *Traversal::visitSwitchStmt(SwitchStmt *S) {
 Stmt *Traversal::visitCaseStmt(CaseStmt *S) {
   for (auto &CLI : S->getMutableCaseLabelItems()) {
     if (auto *newPattern = doIt(CLI.getPattern()))
-      CLI.setPattern(newPattern);
+      CLI.setPattern(newPattern, /*resolved=*/CLI.isPatternResolved());
     else
       return nullptr;
     if (CLI.getGuardExpr()) {

lib/AST/Stmt.cpp

@@ -392,16 +392,16 @@ SourceLoc RepeatWhileStmt::getEndLoc() const { return Cond->getEndLoc(); }
 
 SourceRange CaseLabelItem::getSourceRange() const {
   if (auto *E = getGuardExpr())
-    return { CasePattern->getStartLoc(), E->getEndLoc() };
-  return CasePattern->getSourceRange();
+    return { getPattern()->getStartLoc(), E->getEndLoc() };
+  return getPattern()->getSourceRange();
 }
 SourceLoc CaseLabelItem::getStartLoc() const {
-  return CasePattern->getStartLoc();
+  return getPattern()->getStartLoc();
 }
 SourceLoc CaseLabelItem::getEndLoc() const {
   if (auto *E = getGuardExpr())
     return E->getEndLoc();
-  return CasePattern->getEndLoc();
+  return getPattern()->getEndLoc();
 }
 
 CaseStmt::CaseStmt(CaseParentKind parentKind, SourceLoc itemIntroducerLoc,

lib/Sema/CSApply.cpp

@@ -8262,7 +8262,7 @@ ExprWalker::rewriteTarget(SolutionApplicationTarget target) {
                                          target.getDeclContext());
     if (auto coercedPattern = TypeChecker::coercePatternToType(
             contextualPattern, patternType, patternOptions)) {
-      (*caseLabelItem)->setPattern(coercedPattern);
+      (*caseLabelItem)->setPattern(coercedPattern, /*resolved=*/true);
     } else {
       return None;
     }
@@ -8584,7 +8584,8 @@ SolutionApplicationTarget SolutionApplicationTarget::walk(ASTWalker &walker) {
   case Kind::caseLabelItem:
     if (auto newPattern =
             caseLabelItem.caseLabelItem->getPattern()->walk(walker)) {
-      caseLabelItem.caseLabelItem->setPattern(newPattern);
+      caseLabelItem.caseLabelItem->setPattern(
+          newPattern, caseLabelItem.caseLabelItem->isPatternResolved());
     }
     if (auto guardExpr = caseLabelItem.caseLabelItem->getGuardExpr()) {
       if (auto newGuardExpr = guardExpr->walk(walker))

lib/Sema/CSGen.cpp

@@ -2660,12 +2660,14 @@ namespace {
 
           // Okay, resolve the pattern.
           Pattern *pattern = LabelItem.getPattern();
-          pattern = TypeChecker::resolvePattern(pattern, CS.DC,
-                                         /*isStmtCondition*/false);
-          if (!pattern) return false;
+          if (!LabelItem.isPatternResolved()) {
+            pattern = TypeChecker::resolvePattern(pattern, CS.DC,
+                                           /*isStmtCondition*/false);
+            if (!pattern) return false;
 
-          // Save that aside while we explore the type.
-          LabelItem.setPattern(pattern);
+            // Save that aside while we explore the type.
+            LabelItem.setPattern(pattern, /*resolved=*/true);
+          }
 
           // Require the pattern to have a particular shape: a number
           // of is-patterns applied to an irrefutable pattern.
@@ -2704,7 +2706,7 @@ namespace {
           if (!pattern)
             return false;
 
-          LabelItem.setPattern(pattern);
+          LabelItem.setPattern(pattern, /*resolved=*/true);
           return LabelItem.isSyntacticallyExhaustive();
         }
 
@@ -4229,14 +4231,17 @@ bool ConstraintSystem::generateConstraints(
     CaseStmt *caseStmt, DeclContext *dc, Type subjectType,
     ConstraintLocator *locator) {
   // Pre-bind all of the pattern variables within the case.
-  bindSwitchCasePatternVars(caseStmt);
+  bindSwitchCasePatternVars(dc, caseStmt);
 
   for (auto &caseLabelItem : caseStmt->getMutableCaseLabelItems()) {
     // Resolve the pattern.
-    auto *pattern = TypeChecker::resolvePattern(
-        caseLabelItem.getPattern(), dc, /*isStmtCondition=*/false);
-    if (!pattern)
-      return true;
+    auto *pattern = caseLabelItem.getPattern();
+    if (!caseLabelItem.isPatternResolved()) {
+      pattern = TypeChecker::resolvePattern(
+          pattern, dc, /*isStmtCondition=*/false);
+      if (!pattern)
+        return true;
+    }
 
     // Generate constraints for the pattern, including one-way bindings for
     // any variables that show up in this pattern, because those variables