mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-19 19:45:40 -04:00
db2630fb04
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. llvm-svn: 166385
84 lines
2.1 KiB
C++
84 lines
2.1 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -verify %s -pedantic
|
|
template<typename T>
|
|
struct S {
|
|
S() { }
|
|
};
|
|
|
|
template<typename T>
|
|
struct vector {
|
|
void push_back(const T&) { int a[sizeof(T) ? -1: -1]; } // expected-error {{array with a negative size}}
|
|
};
|
|
|
|
class ExprEngine {
|
|
public:
|
|
typedef vector<S<void *> >CheckersOrdered;
|
|
CheckersOrdered Checkers;
|
|
|
|
template <typename CHECKER>
|
|
void registerCheck(CHECKER *check) {
|
|
Checkers.push_back(S<void *>()); // expected-note {{in instantiation of member function 'vector<S<void *> >::push_back' requested here}}
|
|
}
|
|
};
|
|
|
|
class RetainReleaseChecker { };
|
|
|
|
void f(ExprEngine& Eng) {
|
|
Eng.registerCheck(new RetainReleaseChecker); // expected-note {{in instantiation of function template specialization 'ExprEngine::registerCheck<RetainReleaseChecker>' requested here}}
|
|
}
|
|
|
|
// PR 5838
|
|
namespace test1 {
|
|
template<typename T> struct A {
|
|
int a;
|
|
};
|
|
|
|
template<typename T> struct B : A<float>, A<T> {
|
|
void f() {
|
|
a = 0; // should not be ambiguous
|
|
}
|
|
};
|
|
template struct B<int>;
|
|
|
|
struct O {
|
|
int a;
|
|
template<typename T> struct B : A<T> {
|
|
void f() {
|
|
a = 0; // expected-error {{'test1::O::a' is not a member of class 'test1::O::B<int>'}}
|
|
}
|
|
};
|
|
};
|
|
template struct O::B<int>; // expected-note {{in instantiation}}
|
|
}
|
|
|
|
// PR7248
|
|
namespace test2 {
|
|
template <class T> struct A {
|
|
void foo() {
|
|
T::bar(); // expected-error {{type 'int' cannot}}
|
|
}
|
|
};
|
|
|
|
template <class T> class B {
|
|
void foo(A<T> a) {
|
|
a.test2::template A<T>::foo(); // expected-note {{in instantiation}}
|
|
}
|
|
};
|
|
|
|
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
|
|
}
|