1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | // RUN: %clang_cc1 -fsyntax-only -verify %s template<typename T, typename U> struct X0 : T::template apply<U> { X0(U u) : T::template apply<U>(u) { } }; template<typename T, typename U> struct X1 : T::apply<U> { }; // expected-error{{use 'template' keyword to treat 'apply' as a dependent template name}} template<typename T> struct X2 : vector<T> { }; // expected-error{{unknown template name 'vector'}} namespace PR6031 { template<typename T> struct A; template <class X> struct C { }; template <class TT> struct II { typedef typename A<TT>::type type; }; template <class TT> struct FI : II<TT> { C<typename FI::type> a; }; template <class TT> struct FI2 { C<typename FI2::type> a; // expected-error{{no type named 'type' in 'FI2<TT>'}} }; template<typename T> struct Base { class Nested { }; template<typename U> struct MemberTemplate { }; int a; }; template<typename T> struct HasDepBase : Base<T> { int foo() { class HasDepBase::Nested nested; typedef typename HasDepBase::template MemberTemplate<T>::type type; return HasDepBase::a; } }; template<typename T> struct NoDepBase { int foo() { class NoDepBase::Nested nested; // expected-error{{no class named 'Nested' in 'NoDepBase<T>'}} typedef typename NoDepBase::template MemberTemplate<T>::type type; // expected-error{{no member named 'MemberTemplate' in 'NoDepBase<T>'}} \ // FIXME: expected-error{{unqualified-id}} return NoDepBase::a; // expected-error{{no member named 'a' in 'NoDepBase<T>'}} } }; } namespace Ambig { template<typename T> struct Base1 { typedef int type; // expected-note{{member found by ambiguous name lookup}} }; struct Base2 { typedef float type; // expected-note{{member found by ambiguous name lookup}} }; template<typename T> struct Derived : Base1<T>, Base2 { typedef typename Derived::type type; // expected-error{{member 'type' found in multiple base classes of different types}} type *foo(float *fp) { return fp; } }; Derived<int> di; // expected-note{{instantiation of}} } namespace PR6081 { template<typename T> struct A { }; template<typename T> class B : public A<T> { public: template< class X > void f0(const X & k) { this->template f1<int>()(k); } }; template<typename T> class C { public: template< class X > void f0(const X & k) { this->template f1<int>()(k); // expected-error{{no member named 'f1' in 'C<T>'}} \ // FIXME: expected-error{{unqualified-id}} \ // expected-error{{function-style cast or type construction}} \ // expected-error{{expected expression}} } }; } namespace PR6413 { template <typename T> class Base_A { }; class Base_B { }; template <typename T> class Derived : public virtual Base_A<T> , public virtual Base_B { }; } namespace PR5812 { template <class T> struct Base { Base* p; }; template <class T> struct Derived: public Base<T> { typename Derived::Base* p; // meaning Derived::Base<T> }; Derived<int> di; } |