Unrevert r166268, reverted in r166272, with a fix for the issue which Nick
found: if an overloaded operator& is present before a template definition,
the expression &T::foo is represented as a CXXOperatorCallExpr, not as a
UnaryOperator, so we didn't notice that it's permitted to reference a non-static
data member of an unrelated class.
While investigating this, I discovered another problem in this area: we are
treating template default arguments as unevaluated contexts during substitution,
resulting in performing incorrect checks for uses of non-static data members in
C++11. That is not fixed by this patch (I'll look into this soon; it's related
to the failure to correctly instantiate constexpr function templates), but was
resulting in this bug not firing in C++11 mode (except with -Wc++98-compat).
Original message:
PR14124: When performing template instantiation of a qualified-id outside of a
class, diagnose if the qualified-id instantiates to a non-static class member.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@166385 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/test/SemaCXX/decltype-overloaded-functions.cpp b/test/SemaCXX/decltype-overloaded-functions.cpp
index 2ed4465..c1d01fc 100644
--- a/test/SemaCXX/decltype-overloaded-functions.cpp
+++ b/test/SemaCXX/decltype-overloaded-functions.cpp
@@ -1,16 +1,16 @@
// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
-void f(); // expected-note{{possible target for call}}
-void f(int); // expected-note{{possible target for call}}
+void f(); // expected-note{{possible target for call}}
+void f(int); // expected-note{{possible target for call}}
decltype(f) a; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} expected-error {{variable has incomplete type 'decltype(f())' (aka 'void')}}
template<typename T> struct S {
- decltype(T::f) * f; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} expected-error {{call to non-static member function without an object argument}}
+ decltype(T::f) * f; // expected-error {{call to non-static member function without an object argument}}
};
struct K {
- void f(); // expected-note{{possible target for call}}
- void f(int); // expected-note{{possible target for call}}
+ void f();
+ void f(int);
};
S<K> b; // expected-note{{in instantiation of template class 'S<K>' requested here}}
diff --git a/test/SemaCXX/warn-assignment-condition.cpp b/test/SemaCXX/warn-assignment-condition.cpp
index 04f2e79..09084e3 100644
--- a/test/SemaCXX/warn-assignment-condition.cpp
+++ b/test/SemaCXX/warn-assignment-condition.cpp
@@ -133,14 +133,14 @@
namespace rdar9027658 {
template <typename T>
-void f() {
- if ((T::g == 3)) { } // expected-warning {{equality comparison with extraneous parentheses}} \
+void f(T t) {
+ if ((t.g == 3)) { } // expected-warning {{equality comparison with extraneous parentheses}} \
// expected-note {{use '=' to turn this equality comparison into an assignment}} \
// expected-note {{remove extraneous parentheses around the comparison to silence this warning}}
}
struct S { int g; };
void test() {
- f<S>(); // expected-note {{in instantiation}}
+ f(S()); // expected-note {{in instantiation}}
}
}
diff --git a/test/SemaTemplate/instantiate-member-expr.cpp b/test/SemaTemplate/instantiate-member-expr.cpp
index a31569a..6ba94b2 100644
--- a/test/SemaTemplate/instantiate-member-expr.cpp
+++ b/test/SemaTemplate/instantiate-member-expr.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s -pedantic
template<typename T>
struct S {
S() { }
@@ -66,3 +66,18 @@
template class B<int>;
}
+
+namespace PR14124 {
+ template<typename T> struct S {
+ int value;
+ };
+ template<typename T> void f() { S<T>::value; } // expected-error {{invalid use of non-static data member 'value'}}
+ template void f<int>(); // expected-note {{in instantiation of}}
+
+ struct List { List *next; };
+ template<typename T, T *(T::*p) = &T::next> struct A {};
+ A<List> a; // ok
+ void operator&(struct Whatever);
+ template<typename T, T *(T::*p) = &T::next> struct B {};
+ B<List> b; // still ok
+}