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