Simple hack to do unreachable code analysis on template patterns.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@148774 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Sema/AnalysisBasedWarnings.cpp b/lib/Sema/AnalysisBasedWarnings.cpp
index e2d1e8c..5f1d8cc 100644
--- a/lib/Sema/AnalysisBasedWarnings.cpp
+++ b/lib/Sema/AnalysisBasedWarnings.cpp
@@ -782,8 +782,7 @@
return;
// For code in dependent contexts, we'll do this at instantiation time.
- if (cast<DeclContext>(D)->isDependentContext())
- return;
+ bool Dependent = cast<DeclContext>(D)->isDependentContext();
if (Diags.hasErrorOccurred() || Diags.hasFatalErrorOccurred()) {
// Flush out any possibly unreachable diagnostics.
@@ -826,7 +825,7 @@
// Construct the analysis context with the specified CFG build options.
// Emit delayed diagnostics.
- if (!fscope->PossiblyUnreachableDiags.empty()) {
+ if (!fscope->PossiblyUnreachableDiags.empty() && !Dependent) {
bool analyzed = false;
// Register the expressions with the CFGBuilder.
@@ -874,7 +873,7 @@
// Warning: check missing 'return'
- if (P.enableCheckFallThrough) {
+ if (P.enableCheckFallThrough && !Dependent) {
const CheckFallThroughDiagnostics &CD =
(isa<BlockDecl>(D) ? CheckFallThroughDiagnostics::MakeForBlock()
: CheckFallThroughDiagnostics::MakeForFunction(D));
@@ -895,7 +894,7 @@
}
// Check for thread safety violations
- if (P.enableThreadSafetyAnalysis) {
+ if (P.enableThreadSafetyAnalysis && !Dependent) {
SourceLocation FL = AC.getDecl()->getLocation();
thread_safety::ThreadSafetyReporter Reporter(S, FL);
thread_safety::runThreadSafetyAnalysis(AC, Reporter);
diff --git a/test/SemaCXX/array-bounds.cpp b/test/SemaCXX/array-bounds.cpp
index c1b3701..8d0b1e4 100644
--- a/test/SemaCXX/array-bounds.cpp
+++ b/test/SemaCXX/array-bounds.cpp
@@ -73,17 +73,21 @@
(*array_ptr)[3] = 1; // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}}
}
+// FIXME: we should see the next note only 3 times and the following warning once, not twice
+// since it is independent of the template parameter 'I'.
template <int I> struct S {
- char arr[I]; // expected-note 2 {{declared here}}
+ char arr[I]; // expected-note 4 {{declared here}}
};
template <int I> void f() {
S<3> s;
- s.arr[4] = 0; // expected-warning {{array index 4 is past the end of the array (which contains 3 elements)}}
- s.arr[I] = 0; // expected-warning {{array index 5 is past the end of the array (which contains 3 elements)}}
+ s.arr[4] = 0; // expected-warning 2 {{array index 4 is past the end of the array (which contains 3 elements)}}
+ s.arr[I] = 0; // expected-warning {{array index 5 is past the end of the array (which contains 3 elements)}} \
+ expected-warning {{array index 3 is past the end of the array (which contains 3 elements)}}
}
void test_templates() {
f<5>(); // expected-note {{in instantiation}}
+ f<3>(); // expected-note {{in instantiation}}
}
#define SIZE 10
diff --git a/test/SemaCXX/warn-unreachable.cpp b/test/SemaCXX/warn-unreachable.cpp
index f36300a..3d36875 100644
--- a/test/SemaCXX/warn-unreachable.cpp
+++ b/test/SemaCXX/warn-unreachable.cpp
@@ -98,6 +98,24 @@
test_unreachable_templates<TestUnreachableB>();
}
+// Do warn about non-dependent unreachable code in templates
+// Warn even if the template is never instantiated
+
+template<typename T> void test_non_dependent_unreachable_templates() {
+ TestUnreachableA::foo();
+ isUnreachable(); // expected-warning {{will never be executed}}
+}
+
+// Warn only once even if the template is instantiated multiple times
+
+template<typename T> void test_non_dependent_unreachable_templates2() {
+ TestUnreachableA::foo();
+ isUnreachable(); // expected-warning {{will never be executed}}
+}
+
+template void test_non_dependent_unreachable_templates2<int>();
+template void test_non_dependent_unreachable_templates2<long>();
+
// Do warn about explict template specializations, as they represent
// actual concrete functions that somebody wrote.
@@ -106,4 +124,3 @@
halt();
dead(); // expected-warning {{will never be executed}}
}
-