Don't warn about an unreachable fallthrough annotation in a template function

[ahmedasadi]

Summary

Clang currently doesn't warn about unreachable code in template functions, as it may not be unreachable in all instantiations.

Do the same for unreachable fallthrough annotations.

[rsmith]

This needs a test case, but the change itself looks fine to me.

[ahmedasadi]

Added a test case.

[rsmith]

LGTM, do you need someone to commit for you?

[ahmedasadi]

Thanks for reviewing. Yes, I need someone to commit for me.

cfe/trunk/lib/Sema/AnalysisBasedWarnings.cpp

void fillReachableBlocks(CFG *Cfg) {
                                            E = P->succ_end();
              I != E; ++I) {
           if (*I && ReachableBlocks.insert(*I).second)
             BlockQueue.push_back(*I);
         }
       }
     }
 
-    bool checkFallThroughIntoBlock(const CFGBlock &B, int &AnnotatedCnt) {
+    bool checkFallThroughIntoBlock(const CFGBlock &B, int &AnnotatedCnt,
+                                   bool IsTemplateInstantiation) {
       assert(!ReachableBlocks.empty() && "ReachableBlocks empty");
 
       int UnannotatedCnt = 0;
       AnnotatedCnt = 0;
 
       std::deque<const CFGBlock*> BlockQueue(B.pred_begin(), B.pred_end());
       while (!BlockQueue.empty()) {
         const CFGBlock *P = BlockQueue.front();
bool checkFallThroughIntoBlock(const CFGBlock &B, int &AnnotatedCnt,
           continue; // Case label is preceded with a normal label, good.
 
         if (!ReachableBlocks.count(P)) {
           for (CFGBlock::const_reverse_iterator ElemIt = P->rbegin(),
                                                 ElemEnd = P->rend();
                ElemIt != ElemEnd; ++ElemIt) {
             if (Optional<CFGStmt> CS = ElemIt->getAs<CFGStmt>()) {
               if (const AttributedStmt *AS = asFallThroughAttr(CS->getStmt())) {
+                // Don't issue a warning for an unreachable fallthrough
+                // attribute in template instantiations as it may not be
+                // unreachable in all instantiations of the template.
+                if (!IsTemplateInstantiation)
                   S.Diag(AS->getLocStart(),
                          diag::warn_fallthrough_attr_unreachable);
                 markFallthroughVisited(AS);
                 ++AnnotatedCnt;
                 break;
               }
               // Don't care about other unreachable statements.
             }
           }
           // If there are no unreachable statements, this may be a special
static void DiagnoseSwitchLabelsFallthrough(Sema &S, AnalysisDeclContext &AC,
   for (const CFGBlock *B : llvm::reverse(*Cfg)) {
     const Stmt *Label = B->getLabel();
 
     if (!Label || !isa<SwitchCase>(Label))
       continue;
 
     int AnnotatedCnt;
 
-    if (!FM.checkFallThroughIntoBlock(*B, AnnotatedCnt))
+    bool IsTemplateInstantiation = false;
+    if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(AC.getDecl()))
+      IsTemplateInstantiation = Function->isTemplateInstantiation();
+    if (!FM.checkFallThroughIntoBlock(*B, AnnotatedCnt,
+                                      IsTemplateInstantiation))
       continue;
 
     S.Diag(Label->getLocStart(),
         PerFunction ? diag::warn_unannotated_fallthrough_per_function
                     : diag::warn_unannotated_fallthrough);
 
     if (!AnnotatedCnt) {
       SourceLocation L = Label->getLocStart();

cfe/trunk/test/SemaCXX/P30636.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wimplicit-fallthrough %s
+// expected-no-diagnostics
+
+template<bool param>
+int fallthrough_template(int i)
+{
+  switch (i) {
+    case 1:
+      if (param)
+        return 3;
+      [[clang::fallthrough]]; // no warning here, for an unreachable annotation (in the fallthrough_template<true> case) in a template function
+    case 2:
+      return 4;
+    default:
+      return 5;
+  }
+}
+                                      
+template int fallthrough_template<true>(int);
+