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
f()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 {
BarPR8001::Foo::Bar76 Bar() {}
77 };
78 };
79
pr8001()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}}
DontCrashOnThis()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 };
clone()159 template<typename T> A<T> *A<T>::clone() { return new A<T>; } // expected-error {{abstract class type 'A<T>'}}
160 }
161