[Analysis][CFG] Fix CFG building for standalone `CaseStmt`s.

[courbet]

Summary

One is supposed ot be able to create a CFG for any statement, as per the
comment on CFGBuilder::buildCFG:

"The AST can represent an arbitrary statement. Examples include a single
expression or a function body (compound statement)"

When building a CFG from a CaseStmt, we currently have a crash:

clang/lib/Analysis/CFG.cpp:4242: clang::CFGBlock *(anonymous
namespace)::CFGBuilder::VisitCaseStmt(clang::CaseStmt *): Assertion
`SwitchTerminatedBlock' failed.

Add a unit test to show this, and avoid updating the parent SwitchStmt
block when none exists.

[courbet]

remove accidental paste

clang/lib/Analysis/CFG.cpp

while (isa<CaseStmt>(Sub)) {
       CFGBlock *currentBlock = createBlock(false);
       currentBlock->setLabel(CS);
 
       if (TopBlock)
         addSuccessor(LastBlock, currentBlock);
       else
         TopBlock = currentBlock;
 
-      addSuccessor(SwitchTerminatedBlock,
-                   shouldAddCase(switchExclusivelyCovered, switchCond,
-                                 CS, *Context)
-                   ? currentBlock : nullptr);
+      if (SwitchTerminatedBlock)
+        addSuccessor(
+            SwitchTerminatedBlock,
+            shouldAddCase(switchExclusivelyCovered, switchCond, CS, *Context)
+                ? currentBlock
+                : nullptr);
 
       LastBlock = currentBlock;
       CS = cast<CaseStmt>(Sub);
       Sub = CS->getSubStmt();
     }
 
     addStmt(Sub);
   }
 
   CFGBlock *CaseBlock = Block;
   if (!CaseBlock)
     CaseBlock = createBlock();
 
   // Cases statements partition blocks, so this is the top of the basic block we
   // were processing (the "case XXX:" is the label).
   CaseBlock->setLabel(CS);
 
   if (badCFG)
     return nullptr;
 
   // Add this block to the list of successors for the block with the switch
   // statement.
-  assert(SwitchTerminatedBlock);
-  addSuccessor(SwitchTerminatedBlock, CaseBlock,
-               shouldAddCase(switchExclusivelyCovered, switchCond,
-                             CS, *Context));
+  if (SwitchTerminatedBlock)
+    addSuccessor(
+        SwitchTerminatedBlock, CaseBlock,
+        shouldAddCase(switchExclusivelyCovered, switchCond, CS, *Context));
 
   // We set Block to NULL to allow lazy creation of a new block (if necessary)
   Block = nullptr;
 
   if (TopBlock) {
     addSuccessor(LastBlock, CaseBlock);
     Succ = TopBlock;
   } else {

clang/unittests/Analysis/CFGTest.cpp

while (const CFGBlock *B = BackwardWorklist.dequeue())
       BackwardNodes.push_back(B);
 
     EXPECT_EQ(BackwardNodes.size(), ReferenceOrder.size());
     EXPECT_TRUE(std::equal(ReferenceOrder.begin(), ReferenceOrder.end(),
                            BackwardNodes.begin()));
   }
 }
 
+// It is valid to create a CFG for a single statement. Creating a CFG for an
+// isolated `CaseStmt` should not crash.`
+TEST(CFG, SwitchCase) {
+  const char *Code = "void f(int i) {\n"
+                     "  switch (i) {\n"
+                     "    case 0:\n"
+                     "      return;\n"
+                     "  }\n"
+                     "}\n";
+  std::vector<std::string> Args = {"-std=c++11",
+                                   "-fno-delayed-template-parsing"};
+  std::unique_ptr<ASTUnit> AST = tooling::buildASTFromCodeWithArgs(Code, Args);
+  ASSERT_NE(AST, nullptr);
+
+  auto Matches = ast_matchers::match(ast_matchers::caseStmt().bind("case"),
+                                     AST->getASTContext());
+  auto *Case = ast_matchers::selectFirst<CaseStmt>("case", Matches);
+  std::unique_ptr<CFG> Cfg =
+      CFG::buildCFG(nullptr, const_cast<CaseStmt *>(Case),
+                    &AST->getASTContext(), CFG::BuildOptions{});
+}
+
 } // namespace
 } // namespace analysis
 } // namespace clang