[DNM] Parser attempt to Fallthrough Problem

include/swift/AST/Stmt.h

@@ -17,12 +17,13 @@
 #ifndef SWIFT_AST_STMT_H
 #define SWIFT_AST_STMT_H
 
+#include "swift/AST/ASTNode.h"
 #include "swift/AST/Availability.h"
 #include "swift/AST/AvailabilitySpec.h"
-#include "swift/AST/ASTNode.h"
 #include "swift/AST/IfConfigClause.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/Basic/NullablePtr.h"
+#include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Support/TrailingObjects.h"
 
 namespace swift {
@@ -943,16 +944,20 @@ class CaseStmt final : public Stmt,
 
   llvm::PointerIntPair<Stmt *, 1, bool> BodyAndHasBoundDecls;
 
+  Optional<MutableArrayRef<VarDecl *>> CaseBodyVariables;
+
   CaseStmt(SourceLoc CaseLoc, ArrayRef<CaseLabelItem> CaseLabelItems,
            bool HasBoundDecls, SourceLoc UnknownAttrLoc, SourceLoc ColonLoc,
-           Stmt *Body, Optional<bool> Implicit);
+           Stmt *Body, Optional<MutableArrayRef<VarDecl *>> CaseBodyVariables,
+           Optional<bool> Implicit);
 
 public:
-  static CaseStmt *create(ASTContext &C, SourceLoc CaseLoc,
-                          ArrayRef<CaseLabelItem> CaseLabelItems,
-                          bool HasBoundDecls, SourceLoc UnknownAttrLoc,
-                          SourceLoc ColonLoc, Stmt *Body,
-                          Optional<bool> Implicit = None);
+  static CaseStmt *
+  create(ASTContext &C, SourceLoc CaseLoc,
+         ArrayRef<CaseLabelItem> CaseLabelItems, bool HasBoundDecls,
+         SourceLoc UnknownAttrLoc, SourceLoc ColonLoc, Stmt *Body,
+         Optional<MutableArrayRef<VarDecl *>> CaseBodyVariables,
+         Optional<bool> Implicit = None);
 
   ArrayRef<CaseLabelItem> getCaseLabelItems() const {
     return {getTrailingObjects<CaseLabelItem>(), Bits.CaseStmt.NumPatterns};
@@ -990,6 +995,17 @@ class CaseStmt final : public Stmt,
     return UnknownAttrLoc.isValid();
   }
 
+  Optional<ArrayRef<VarDecl *>> getCaseBodyVariables() const {
+    if (!CaseBodyVariables)
+      return None;
+    ArrayRef<VarDecl *> a = *CaseBodyVariables;
+    return a;
+  }
+
+  Optional<MutableArrayRef<VarDecl *>> getCaseBodyVariables() {
+    return CaseBodyVariables;
+  }
+
   static bool classof(const Stmt *S) { return S->getKind() == StmtKind::Case; }
 };
 

lib/AST/ASTDumper.cpp

@@ -1619,6 +1619,24 @@ class PrintStmt : public StmtVisitor<PrintStmt> {
     printCommon(S, "case_stmt");
     if (S->hasUnknownAttr())
       OS << " @unknown";
+
+    if (auto caseBodyVars = S->getCaseBodyVariables()) {
+      OS << '\n';
+      OS.indent(Indent + 2);
+      PrintWithColorRAII(OS, ParenthesisColor) << '(';
+      PrintWithColorRAII(OS, StmtColor) << "case_body_variables";
+      OS << '\n';
+      for (auto *vd : *caseBodyVars) {
+        OS.indent(2);
+        // TODO: Printing a var decl does an Indent ... dump(vd) ... '\n'. We
+        // should see if we can factor this dumping so that the caller of
+        // printRec(VarDecl) has more control over the printing.
+        printRec(vd);
+      }
+      OS.indent(Indent + 2);
+      PrintWithColorRAII(OS, ParenthesisColor) << ')';
+    }
+
     for (const auto &LabelItem : S->getCaseLabelItems()) {
       OS << '\n';
       OS.indent(Indent + 2);

lib/AST/NameLookup.cpp

@@ -2322,8 +2322,14 @@ void FindLocalVal::visitCaseStmt(CaseStmt *S) {
       }
     }
   }
-  if (!inPatterns && !items.empty())
-    checkPattern(items[0].getPattern(), DeclVisibilityKind::LocalVariable);
+
+  if (!inPatterns && !items.empty()) {
+    if (auto caseBodyVars = S->getCaseBodyVariables()) {
+      for (auto *vd : *caseBodyVars) {
+        checkValueDecl(vd, DeclVisibilityKind::LocalVariable);
+      }
+    }
+  }
   visit(S->getBody());
 }
 

lib/AST/Stmt.cpp

@@ -387,10 +387,13 @@ SourceLoc CaseLabelItem::getEndLoc() const {
 
 CaseStmt::CaseStmt(SourceLoc CaseLoc, ArrayRef<CaseLabelItem> CaseLabelItems,
                    bool HasBoundDecls, SourceLoc UnknownAttrLoc,
-                   SourceLoc ColonLoc, Stmt *Body, Optional<bool> Implicit)
+                   SourceLoc ColonLoc, Stmt *Body,
+                   Optional<MutableArrayRef<VarDecl *>> CaseBodyVariables,
+                   Optional<bool> Implicit)
     : Stmt(StmtKind::Case, getDefaultImplicitFlag(Implicit, CaseLoc)),
       UnknownAttrLoc(UnknownAttrLoc), CaseLoc(CaseLoc), ColonLoc(ColonLoc),
-      BodyAndHasBoundDecls(Body, HasBoundDecls) {
+      BodyAndHasBoundDecls(Body, HasBoundDecls),
+      CaseBodyVariables(CaseBodyVariables) {
   Bits.CaseStmt.NumPatterns = CaseLabelItems.size();
   assert(Bits.CaseStmt.NumPatterns > 0 &&
          "case block must have at least one pattern");
@@ -403,15 +406,21 @@ CaseStmt::CaseStmt(SourceLoc CaseLoc, ArrayRef<CaseLabelItem> CaseLabelItems,
   }
 }
 
-CaseStmt *CaseStmt::create(ASTContext &C, SourceLoc CaseLoc,
-                           ArrayRef<CaseLabelItem> CaseLabelItems,
-                           bool HasBoundDecls, SourceLoc UnknownAttrLoc,
-                           SourceLoc ColonLoc, Stmt *Body,
-                           Optional<bool> Implicit) {
+CaseStmt *
+CaseStmt::create(ASTContext &C, SourceLoc CaseLoc,
+                 ArrayRef<CaseLabelItem> CaseLabelItems, bool HasBoundDecls,
+                 SourceLoc UnknownAttrLoc, SourceLoc ColonLoc, Stmt *Body,
+                 Optional<MutableArrayRef<VarDecl *>> CaseBodyVariables,
+                 Optional<bool> Implicit) {
+  assert((!HasBoundDecls || (CaseBodyVariables.hasValue() &&
+                             CaseBodyVariables.getValue().size())) &&
+         "If we have bound decls, we must also have a non-empty case body "
+         "variable array");
   void *Mem = C.Allocate(totalSizeToAlloc<CaseLabelItem>(CaseLabelItems.size()),
                          alignof(CaseStmt));
-  return ::new (Mem) CaseStmt(CaseLoc, CaseLabelItems, HasBoundDecls,
-                              UnknownAttrLoc, ColonLoc, Body, Implicit);
+  return ::new (Mem)
+      CaseStmt(CaseLoc, CaseLabelItems, HasBoundDecls, UnknownAttrLoc, ColonLoc,
+               Body, CaseBodyVariables, Implicit);
 }
 
 SwitchStmt *SwitchStmt::create(LabeledStmtInfo LabelInfo, SourceLoc SwitchLoc,

lib/Parse/ParseStmt.cpp

@@ -2273,10 +2273,11 @@ Parser::parseStmtCases(SmallVectorImpl<ASTNode> &cases, bool IsActive) {
   return Status;
 }
 
-static ParserStatus parseStmtCase(Parser &P, SourceLoc &CaseLoc,
-                                  SmallVectorImpl<CaseLabelItem> &LabelItems,
-                                  SmallVectorImpl<VarDecl *> &BoundDecls,
-                                  SourceLoc &ColonLoc) {
+static ParserStatus
+parseStmtCase(Parser &P, SourceLoc &CaseLoc,
+              SmallVectorImpl<CaseLabelItem> &LabelItems,
+              SmallVectorImpl<VarDecl *> &BoundDecls, SourceLoc &ColonLoc,
+              Optional<MutableArrayRef<VarDecl *>> &CaseBodyDecls) {
   SyntaxParsingContext CaseContext(P.SyntaxContext,
                                    SyntaxKind::SwitchCaseLabel);
   ParserStatus Status;
@@ -2292,13 +2293,28 @@ static ParserStatus parseStmtCase(Parser &P, SourceLoc &CaseLoc,
       GuardedPattern PatternResult;
       parseGuardedPattern(P, PatternResult, Status, BoundDecls,
                           GuardedPatternContext::Case, isFirst);
-      LabelItems.push_back(
-          CaseLabelItem(PatternResult.ThePattern, PatternResult.WhereLoc,
-                        PatternResult.Guard));
+      LabelItems.emplace_back(PatternResult.ThePattern, PatternResult.WhereLoc,
+                              PatternResult.Guard);
       isFirst = false;
       if (!P.consumeIf(tok::comma))
         break;
     }
+
+    // Grab the first case label item pattern and use it to initialize the case
+    // body var decls.
+    SmallVector<VarDecl *, 4> tmp;
+    LabelItems.front().getPattern()->collectVariables(tmp);
+    auto Result = P.Context.AllocateUninitialized<VarDecl *>(tmp.size());
+    for (unsigned i : indices(tmp)) {
+      auto *vOld = tmp[i];
+      auto *vNew = new (P.Context) VarDecl(
+          /*IsStatic*/ false, vOld->getSpecifier(), false /*IsCaptureList*/,
+          vOld->getNameLoc(), vOld->getName(), vOld->getDeclContext());
+      vNew->setHasNonPatternBindingInit();
+      vNew->setImplicit();
+      Result[i] = vNew;
+    }
+    CaseBodyDecls.emplace(Result);
   }
 
   ColonLoc = P.Tok.getLoc();
@@ -2389,9 +2405,10 @@ ParserResult<CaseStmt> Parser::parseStmtCase(bool IsActive) {
 
   SourceLoc CaseLoc;
   SourceLoc ColonLoc;
+  Optional<MutableArrayRef<VarDecl *>> CaseBodyDecls;
   if (Tok.is(tok::kw_case)) {
-    Status |=
-        ::parseStmtCase(*this, CaseLoc, CaseLabelItems, BoundDecls, ColonLoc);
+    Status |= ::parseStmtCase(*this, CaseLoc, CaseLabelItems, BoundDecls,
+                              ColonLoc, CaseBodyDecls);
   } else if (Tok.is(tok::kw_default)) {
     Status |= parseStmtCaseDefault(*this, CaseLoc, CaseLabelItems, ColonLoc);
   } else {
@@ -2400,6 +2417,18 @@ ParserResult<CaseStmt> Parser::parseStmtCase(bool IsActive) {
 
   assert(!CaseLabelItems.empty() && "did not parse any labels?!");
 
+  // Add a scope so that the parser can find our body bound decls if it emits
+  // optimized accesses.
+  Optional<Scope> BodyScope;
+  if (CaseBodyDecls) {
+    BodyScope.emplace(this, ScopeKind::CaseVars);
+    for (auto *v : *CaseBodyDecls) {
+      setLocalDiscriminator(v);
+      if (v->hasName())
+        addToScope(v);
+    }
+  }
+
   SmallVector<ASTNode, 8> BodyItems;
 
   SourceLoc StartOfBody = Tok.getLoc();
@@ -2420,10 +2449,10 @@ ParserResult<CaseStmt> Parser::parseStmtCase(bool IsActive) {
                              PreviousLoc, /*implicit=*/true);
   }
 
-  return makeParserResult(
-      Status, CaseStmt::create(Context, CaseLoc, CaseLabelItems,
-                               !BoundDecls.empty(), UnknownAttrLoc, ColonLoc,
-                               Body));
+  auto *CaseStmt =
+      CaseStmt::create(Context, CaseLoc, CaseLabelItems, !BoundDecls.empty(),
+                       UnknownAttrLoc, ColonLoc, Body, CaseBodyDecls);
+  return makeParserResult(Status, CaseStmt);
 }
 
 /// stmt-pound-assert: