// };
CanQual<RecordType> RT = BaseT->getAs<RecordType>();
- assert(RT && "base is not a record type");
+
+ // Base might be a dependent member type, in which case we
+ // obviously can't look into it.
+ if (!RT) continue;
+
CXXRecordDecl *BaseRecord = cast<CXXRecordDecl>(RT->getDecl());
if (BaseRecord->isDefinition() &&
HasDependentTypeAsBase(Context, BaseRecord, T))
QualType QT = GetTypeForQualifier(Context, Qualifier);
CanQualType T = Context.getCanonicalType(QT);
-
+
// And now, just walk the non-dependent type hierarchy, trying to
// find the given type as a literal base class.
CXXRecordDecl *Record = cast<CXXRecordDecl>(MD->getParent());
- if (Context.getCanonicalType(Context.getTypeDeclType(Record)) == T)
+ if (Context.getCanonicalType(Context.getTypeDeclType(Record)) == T ||
+ HasDependentTypeAsBase(Context, Record, T)) {
+ ThisType = MD->getThisType(Context);
return true;
+ }
- return HasDependentTypeAsBase(Context, Record, T);
+ return false;
}
/// ActOnDependentIdExpression - Handle a dependent declaration name
// PR4365.
template<class T> class Q;
template<class T> class R : Q<T> {T current;};
+
+
+namespace test0 {
+ template <class T> class Base {
+ void instance_foo();
+ static void static_foo();
+ class Inner {
+ void instance_foo();
+ static void static_foo();
+ };
+ };
+
+ template <class T> class Derived1 : Base<T> {
+ void test0() {
+ Base<T>::static_foo();
+ Base<T>::instance_foo();
+ }
+
+ void test1() {
+ Base<T>::Inner::static_foo();
+ Base<T>::Inner::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
+ }
+
+ static void test2() {
+ Base<T>::static_foo();
+ Base<T>::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
+ }
+
+ static void test3() {
+ Base<T>::Inner::static_foo();
+ Base<T>::Inner::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
+ }
+ };
+
+ template <class T> class Derived2 : Base<T>::Inner {
+ void test0() {
+ Base<T>::static_foo();
+ Base<T>::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
+ }
+
+ void test1() {
+ Base<T>::Inner::static_foo();
+ Base<T>::Inner::instance_foo();
+ }
+
+ static void test2() {
+ Base<T>::static_foo();
+ Base<T>::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
+ }
+
+ static void test3() {
+ Base<T>::Inner::static_foo();
+ Base<T>::Inner::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
+ }
+ };
+
+ void test0() {
+ Derived1<int> d1;
+ d1.test0();
+ d1.test1(); // expected-note {{in instantiation of member function}}
+ d1.test2(); // expected-note {{in instantiation of member function}}
+ d1.test3(); // expected-note {{in instantiation of member function}}
+
+ Derived2<int> d2;
+ d2.test0(); // expected-note {{in instantiation of member function}}
+ d2.test1();
+ d2.test2(); // expected-note {{in instantiation of member function}}
+ d2.test3(); // expected-note {{in instantiation of member function}}
+ }
+}