1 // RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify %s
2 
3 template<typename T> class A;
4 
5 extern "C++" {
6   template<typename T> class B;
7 }
8 
9 namespace N {
10   template<typename T> class C;
11 }
12 
13 extern "C" { // expected-note {{extern "C" language linkage specification begins here}}
14   template<typename T> class D; // expected-error{{templates must have C++ linkage}}
15 }
16 
17 extern "C" { // expected-note 2 {{extern "C" language linkage specification begins here}}
18   class PR17968 {
19     template<typename T> class D; // expected-error{{templates must have C++ linkage}}
20     template<typename T> void f(); // expected-error{{templates must have C++ linkage}}
21   };
22 }
23 
24 template<class U> class A; // expected-note{{previous template declaration is here}}
25 
26 template<int N> class A; // expected-error{{template parameter has a different kind in template redeclaration}}
27 
28 template<int N> class NonTypeTemplateParm;
29 
30 typedef int INT;
31 
32 template<INT M> class NonTypeTemplateParm; // expected-note{{previous non-type template parameter with type 'INT' (aka 'int') is here}}
33 
34 template<long> class NonTypeTemplateParm; // expected-error{{template non-type parameter has a different type 'long' in template redeclaration}}
35 
36 template<template<typename T> class X> class TemplateTemplateParm;
37 
38 template<template<class> class Y> class TemplateTemplateParm; // expected-note{{previous template declaration is here}} \
39       // expected-note{{previous template template parameter is here}}
40 
41 template<typename> class TemplateTemplateParm; // expected-error{{template parameter has a different kind in template redeclaration}}
42 
43 template<template<typename T, int> class X> class TemplateTemplateParm; // expected-error{{too many template parameters in template template parameter redeclaration}}
44 
45 template<typename T>
46 struct test {}; // expected-note{{previous definition}}
47 
48 template<typename T>
49 struct test : T {}; // expected-error{{redefinition}}
50 
51 class X {
52 public:
53   template<typename T> class C;
54 };
55 
56 void f() {
57   template<typename T> class X; // expected-error{{expression}}
58 }
59 
60 template<typename T> class X1 var; // expected-error {{variable has incomplete type 'class X1'}} \
61                                    // expected-note {{forward declaration of 'X1'}}
62 
63 namespace M {
64 }
65 
66 template<typename T> class M::C3 { }; // expected-error{{out-of-line definition of 'C3' does not match any declaration in namespace 'M'}}
67 
68 namespace PR8001 {
69   template<typename T1>
70   struct Foo {
71     template<typename T2> class Bar;
72     typedef Bar<T1> Baz;
73 
74    template<typename T2>
75    struct Bar {
76      Bar() {}
77    };
78   };
79 
80   void pr8001() {
81     Foo<int>::Baz x;
82     Foo<int>::Bar<int> y(x);
83   }
84 }
85 
86 namespace rdar9676205 {
87   template <unsigned, class _Tp> class tuple_element;
88 
89   template <class _T1, class _T2> class pair;
90 
91   template <class _T1, class _T2>
92   class tuple_element<0, pair<_T1, _T2> >
93   {
94     template <class _Tp>
95     struct X
96     {
97       template <class _Up, bool = X<_Up>::value>
98       struct Y
99         : public X<_Up>,
100           public Y<_Up>
101       { };
102     };
103   };
104 }
105 
106 namespace redecl {
107   int A; // expected-note {{here}}
108   template<typename T> struct A; // expected-error {{different kind of symbol}}
109 
110   int B; // expected-note {{here}}
111   template<typename T> struct B { // expected-error {{different kind of symbol}}
112   };
113 
114   template<typename T> struct F;
115   template<typename T> struct K;
116 
117   int G, H; // expected-note {{here}}
118 
119   struct S {
120     int C; // expected-note {{here}}
121     template<typename T> struct C; // expected-error {{different kind of symbol}}
122 
123     int D; // expected-note {{here}}
124     template<typename T> struct D { // expected-error {{different kind of symbol}}
125     };
126 
127     int E;
128     template<typename T> friend struct E { // expected-error {{cannot define a type in a friend}}
129     };
130 
131     int F;
132     template<typename T> friend struct F; // ok, redecl::F
133 
134     template<typename T> struct G; // ok
135 
136     template<typename T> friend struct H; // expected-error {{different kind of symbol}}
137 
138     int I, J, K;
139 
140     struct U {
141       template<typename T> struct I; // ok
142       template<typename T> struct J { // ok
143       };
144       template<typename T> friend struct K; // ok, redecl::K
145     };
146   };
147 }
148 
149 extern "C" template <typename T> // expected-error{{templates must have C++ linkage}}
150 void DontCrashOnThis() { // expected-note@-1 {{extern "C" language linkage specification begins here}}
151   T &pT = T();
152   pT;
153 }
154 
155 namespace abstract_dependent_class {
156   template<typename T> struct A {
157     virtual A<T> *clone() = 0; // expected-note {{pure virtual}}
158   };
159   template<typename T> A<T> *A<T>::clone() { return new A<T>; } // expected-error {{abstract class type 'A<T>'}}
160 }
161