[clang][JumpDiagnostics] refactor helper

[nickdesaulniers]

Summary

Posting to phab for separate review from
https://reviews.llvm.org/D155342#4507805

Will squash this into D155342 if it's the intended change.

[nickdesaulniers]

prefer D155525

clang/lib/Sema/JumpDiagnostics.cpp

class JumpScopeChecker {
   };
 
   SmallVector<GotoScope, 48> Scopes;
   llvm::DenseMap<Stmt*, unsigned> LabelAndGotoScopes;
   SmallVector<Stmt*, 16> Jumps;
 
   SmallVector<Stmt*, 4> IndirectJumps;
   SmallVector<LabelDecl *, 4> IndirectJumpTargets;
-  SmallVector<AttributedStmt *, 4> MustTailStmts;
+  SmallVector<Stmt *, 4> MustTailStmts;
 
 public:
   JumpScopeChecker(Stmt *Body, Sema &S);
 private:
   void BuildScopeInformation(Decl *D, unsigned &ParentScope);
   void BuildScopeInformation(VarDecl *D, const BlockDecl *BDecl,
                              unsigned &ParentScope);
   void BuildScopeInformation(CompoundLiteralExpr *CLE, unsigned &ParentScope);
   void BuildScopeInformation(Stmt *S, unsigned &origParentScope);
 
   void VerifyJumps();
   void VerifyIndirectJumps();
   void VerifyMustTailStmts();
   void NoteJumpIntoScopes(ArrayRef<unsigned> ToScopes);
   void DiagnoseIndirectOrAsmJump(Stmt *IG, unsigned IGScope, LabelDecl *Target,
                                  unsigned TargetScope);
   void CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc,
                  unsigned JumpDiag, unsigned JumpDiagWarning,
                  unsigned JumpDiagCXX98Compat);
   void CheckGotoStmt(GotoStmt *GS);
   const Attr *GetMustTailAttr(AttributedStmt *AS);
 
   unsigned GetDeepestCommonScope(unsigned A, unsigned B);
+  void RecordJumpScope(Stmt *S, unsigned Scope, SmallVectorImpl<Stmt*> *Jumps);
 };
 } // end anonymous namespace
 
 #define CHECK_PERMISSIVE(x) (assert(Permissive || !(x)), (Permissive && (x)))
 
 JumpScopeChecker::JumpScopeChecker(Stmt *Body, Sema &s)
     : S(s), Permissive(s.hasAnyUnrecoverableErrorsInThisFunction()) {
   // Add a scope entry for function scope.
case Stmt::ObjCForCollectionStmtClass: {
     auto *CS = cast<ObjCForCollectionStmt>(S);
     unsigned Diag = diag::note_protected_by_objc_fast_enumeration;
     unsigned NewParentScope = Scopes.size();
     Scopes.push_back(GotoScope(ParentScope, Diag, 0, S->getBeginLoc()));
     BuildScopeInformation(CS->getBody(), NewParentScope);
     return;
   }
 
-  case Stmt::IndirectGotoStmtClass:
+  case Stmt::IndirectGotoStmtClass: {
     // "goto *&&lbl;" is a special case which we treat as equivalent
     // to a normal goto.  In addition, we don't calculate scope in the
     // operand (to avoid recording the address-of-label use), which
     // works only because of the restricted set of expressions which
     // we detect as constant targets.
-    if (cast<IndirectGotoStmt>(S)->getConstantTarget()) {
-      LabelAndGotoScopes[S] = ParentScope;
-      Jumps.push_back(S);
-      return;
-    }
-
-    LabelAndGotoScopes[S] = ParentScope;
-    IndirectJumps.push_back(S);
+    bool isConst = cast<IndirectGotoStmt>(S)->getConstantTarget();
+    if (isConst)
+      RecordJumpScope(S, ParentScope, &Jumps);
+    else
+      RecordJumpScope(S, ParentScope, &IndirectJumps);
     break;
+  }
 
   case Stmt::SwitchStmtClass:
     // Evaluate the C++17 init stmt and condition variable
     // before entering the scope of the switch statement.
     if (Stmt *Init = cast<SwitchStmt>(S)->getInit()) {
       BuildScopeInformation(Init, ParentScope);
       ++StmtsToSkip;
     }
     if (VarDecl *Var = cast<SwitchStmt>(S)->getConditionVariable()) {
       BuildScopeInformation(Var, ParentScope);
       ++StmtsToSkip;
     }
-    [[fallthrough]];
+    RecordJumpScope(S, ParentScope, &Jumps);
+    break;
 
   case Stmt::GotoStmtClass:
-  case Stmt::GCCAsmStmtClass:
-    if (auto *GS = dyn_cast<GCCAsmStmt>(S))
-      if (!GS->isAsmGoto())
-        break;
     // Remember both what scope a goto is in as well as the fact that we have
     // it.  This makes the second scan not have to walk the AST again.
-    LabelAndGotoScopes[S] = ParentScope;
-    Jumps.push_back(S);
+    RecordJumpScope(S, ParentScope, &Jumps);
+    break;
+
+  case Stmt::GCCAsmStmtClass:
+    if (cast<GCCAsmStmt>(S)->isAsmGoto())
+      RecordJumpScope(S, ParentScope, &Jumps);
     break;
 
   case Stmt::IfStmtClass: {
     IfStmt *IS = cast<IfStmt>(S);
     if (!(IS->isConstexpr() || IS->isConsteval() ||
           IS->isObjCAvailabilityCheck()))
       break;
 
void JumpScopeChecker::BuildScopeInformation(Stmt *S,
   }
 
   case Stmt::CaseStmtClass:
   case Stmt::DefaultStmtClass:
   case Stmt::LabelStmtClass:
     LabelAndGotoScopes[S] = ParentScope;
     break;
 
-  case Stmt::AttributedStmtClass: {
-    AttributedStmt *AS = cast<AttributedStmt>(S);
-    if (GetMustTailAttr(AS)) {
-      LabelAndGotoScopes[AS] = ParentScope;
-      MustTailStmts.push_back(AS);
-    }
+  case Stmt::AttributedStmtClass:
+    if (GetMustTailAttr(cast<AttributedStmt>(S)))
+      RecordJumpScope(S, ParentScope, &MustTailStmts);
     break;
-  }
 
   default:
     if (auto *ED = dyn_cast<OMPExecutableDirective>(S)) {
       if (!ED->isStandaloneDirective()) {
         unsigned NewParentScope = Scopes.size();
         Scopes.emplace_back(ParentScope,
                             diag::note_omp_protected_structured_block,
                             diag::note_omp_exits_structured_block,
if (GS->getLabel()->isMSAsmLabel()) {
     S.Diag(GS->getGotoLoc(), diag::err_goto_ms_asm_label)
         << GS->getLabel()->getIdentifier();
     S.Diag(GS->getLabel()->getLocation(), diag::note_goto_ms_asm_label)
         << GS->getLabel()->getIdentifier();
   }
 }
 
 void JumpScopeChecker::VerifyMustTailStmts() {
-  for (AttributedStmt *AS : MustTailStmts) {
+  for (Stmt *AS : MustTailStmts) {
     for (unsigned I = LabelAndGotoScopes[AS]; I; I = Scopes[I].ParentScope) {
       if (Scopes[I].OutDiag) {
         S.Diag(AS->getBeginLoc(), diag::err_musttail_scope);
         S.Diag(Scopes[I].Loc, Scopes[I].OutDiag);
       }
     }
   }
 }
 
 const Attr *JumpScopeChecker::GetMustTailAttr(AttributedStmt *AS) {
   ArrayRef<const Attr *> Attrs = AS->getAttrs();
   const auto *Iter =
       llvm::find_if(Attrs, [](const Attr *A) { return isa<MustTailAttr>(A); });
   return Iter != Attrs.end() ? *Iter : nullptr;
 }
 
+void JumpScopeChecker::RecordJumpScope(Stmt *S, unsigned Scope,
+                                       SmallVectorImpl<Stmt*> *Jumps) {
+  LabelAndGotoScopes[S] = Scope;
+  Jumps->push_back(S);
+}
+
 void Sema::DiagnoseInvalidJumps(Stmt *Body) {
   (void)JumpScopeChecker(Body, *this);
 }