Added nested transparent blocks to handle case and default labels exp…

…licitly.

plugins/cpp/parser/src/clangastvisitor.h

@@ -477,7 +477,9 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
       scope = std::make_unique<NestedOneWayScope>(&_scopeStack, cs, cs->getHandlerBlock());
     else if (clang::CompoundStmt* cs = llvm::dyn_cast<clang::CompoundStmt>(s_))
       scope = std::make_unique<NestedCompoundScope>(&_scopeStack, cs);
-    else if (!llvm::isa<clang::SwitchCase>(s_))
+    else if (clang::SwitchCase* sc = llvm::dyn_cast<clang::SwitchCase>(s_))
+      scope = std::make_unique<NestedTransparentScope>(&_scopeStack, sc);
+    else
       // This is why we can't do this in the indidvidual handler functions:
       // There is no Traverse* function equivalent to a general 'else' case
       // when the current statement is neither of the above specified ones.
@@ -489,9 +491,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
       // statement would essentially be duplicated on the scope stack,
       // which would disrupt the meaning of actual scopes in the code.
       scope = std::make_unique<NestedStatementScope>(&_scopeStack, s_);
-
-    if (scope)
-      CountBumpiness(*scope);
+    CountBumpiness(*scope);
 
     return Base::TraverseStmt(s_);
   }

plugins/cpp/parser/src/nestedscope.cpp

@@ -37,21 +37,29 @@ namespace parser
   }
 
 
-  NestedScope::State NestedCompoundScope::CheckNext(clang::Stmt*) const
+  NestedScope::State NestedTransparentScope::CheckNext(clang::Stmt*) const
   {
-    // Anything inside a compound statement block is standalone,
+    // Anything inside a transparent statement block is standalone,
     // we do not expect any particular type of statement to be nested in it.
     return State::Standalone;
   }
 
-  NestedCompoundScope::NestedCompoundScope(
+  NestedTransparentScope::NestedTransparentScope(
     NestedStack* stack_,
     clang::Stmt* stmt_
   ) :
     NestedScope(stack_, stmt_)
+  {}
+
+
+  NestedCompoundScope::NestedCompoundScope(
+    NestedStack* stack_,
+    clang::Stmt* stmt_
+  ) :
+    NestedTransparentScope(stack_, stmt_)
   {
-    // A compound statement block only counts as a real scope when it is
-    // not the expected body of any other statement (e.g. if, while, ...)
+    // A compound statement block only counts as a non-transparent scope
+    // when it is not the expected body of any other statement.
     if (_state == State::Standalone)
       ++_depth;
   }

plugins/cpp/parser/src/nestedscope.h

@@ -56,11 +56,17 @@ namespace parser
     virtual ~NestedScope();
   };
 
-  class NestedCompoundScope : public NestedScope
+  class NestedTransparentScope : public NestedScope
   {
   protected:
     virtual State CheckNext(clang::Stmt* stmt_) const override;
 
+  public:
+    NestedTransparentScope(NestedStack* stack_, clang::Stmt* stmt_);
+  };
+
+  class NestedCompoundScope : public NestedTransparentScope
+  {
   public:
     NestedCompoundScope(NestedStack* stack_, clang::Stmt* stmt_);
   };