[clang][JumpDiagnostics] use StmtClass rather than dyn_cast chain NFC

[nickdesaulniers]

Summary

Avoid the anti-pattern of:

if dyn_cast<X>:
  ...
elif dyn_cast<Y>:
  ...
elif dyn_cast<Z>:
  ...

And simply switch on the statement class, as is done elsewhere in this
class. These cases are for classes with no shared inheritance lineage
beyond all inheriting from clang::Stmt.

[gribozavr2]

I'm not sure it is actually an anti-pattern. dyn_cast will transparently handle subclasses, should any be added in the future, but a switch wouldn't.

[rjmccall]

In D155506#4508176, @gribozavr2 wrote:

I'm not sure it is actually an anti-pattern. dyn_cast will transparently handle subclasses, should any be added in the future, but a switch wouldn't.

Yeah, I don't think we have a strong style preference either way, here, given that this can't be an exhaustive switch anyway.

[nickdesaulniers]

no worries then

clang/lib/Sema/JumpDiagnostics.cpp

 }
 
 /// VerifyJumps - Verify each element of the Jumps array to see if they are
 /// valid, emitting diagnostics if not.
 void JumpScopeChecker::VerifyJumps() {
   while (!Jumps.empty()) {
     Stmt *Jump = Jumps.pop_back_val();
 
-    // With a goto,
-    if (GotoStmt *GS = dyn_cast<GotoStmt>(Jump)) {
+    switch (Jump->getStmtClass()) {
+    case Stmt::GotoStmtClass: {
+      auto *GS = cast<GotoStmt>(Jump);
       // The label may not have a statement if it's coming from inline MS ASM.
       if (GS->getLabel()->getStmt()) {
         CheckJump(GS, GS->getLabel()->getStmt(), GS->getGotoLoc(),
                   diag::err_goto_into_protected_scope,
                   diag::ext_goto_into_protected_scope,
                   diag::warn_cxx98_compat_goto_into_protected_scope);
       }
       CheckGotoStmt(GS);
-      continue;
+      break;
     }
-
-    if (auto *G = dyn_cast<GCCAsmStmt>(Jump)) {
+    case Stmt::GCCAsmStmtClass: {
+      auto *G = cast<GCCAsmStmt>(Jump);
       for (AddrLabelExpr *L : G->labels()) {
         LabelDecl *LD = L->getLabel();
         unsigned JumpScope = LabelAndGotoScopes[G];
         unsigned TargetScope = LabelAndGotoScopes[LD->getStmt()];
         if (JumpScope != TargetScope)
           DiagnoseIndirectOrAsmJump(G, JumpScope, LD, TargetScope);
       }
-      continue;
+      break;
     }
-
+    case Stmt::IndirectGotoStmtClass: {
       // We only get indirect gotos here when they have a constant target.
-    if (IndirectGotoStmt *IGS = dyn_cast<IndirectGotoStmt>(Jump)) {
+      auto *IGS = dyn_cast<IndirectGotoStmt>(Jump);
       LabelDecl *Target = IGS->getConstantTarget();
       CheckJump(IGS, Target->getStmt(), IGS->getGotoLoc(),
                 diag::err_goto_into_protected_scope,
                 diag::ext_goto_into_protected_scope,
                 diag::warn_cxx98_compat_goto_into_protected_scope);
-      continue;
+      break;
     }
-
-    SwitchStmt *SS = cast<SwitchStmt>(Jump);
+    case Stmt::SwitchStmtClass: {
+      auto *SS = cast<SwitchStmt>(Jump);
       for (SwitchCase *SC = SS->getSwitchCaseList(); SC;
           SC = SC->getNextSwitchCase()) {
         if (CHECK_PERMISSIVE(!LabelAndGotoScopes.count(SC)))
           continue;
         SourceLocation Loc;
-      if (CaseStmt *CS = dyn_cast<CaseStmt>(SC))
+        if (const auto *CS = dyn_cast<CaseStmt>(SC))
           Loc = CS->getBeginLoc();
-      else if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC))
+        else if (const auto *DS = dyn_cast<DefaultStmt>(SC))
           Loc = DS->getBeginLoc();
         else
           Loc = SC->getBeginLoc();
         CheckJump(SS, SC, Loc, diag::err_switch_into_protected_scope, 0,
-                diag::warn_cxx98_compat_switch_into_protected_scope);
       }
+      break;
+    }
+    default:
+      break;
+    }
   }
 }
 
 /// VerifyIndirectJumps - Verify whether any possible indirect goto jump might
 /// cross a protection boundary.  Unlike direct jumps, indirect goto jumps
 /// count cleanups as protection boundaries: since there's no way to know where
 /// the jump is going, we can't implicitly run the right cleanups the way we
 /// can with direct jumps.  Thus, an indirect/asm jump is "trivial" if it