Clang Project

clang_source_code/test/SemaTemplate/class-template-decl.cpp
1// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify %s
2
3template<typename T> class A;
4
5extern "C++" {
6  template<typename T> class B;
7}
8
9namespace N {
10  template<typename T> class C;
11}
12
13extern "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
17extern "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
24template<class U> class A; // expected-note{{previous template declaration is here}}
25
26template<int N> class A; // expected-error{{template parameter has a different kind in template redeclaration}}
27
28template<int N> class NonTypeTemplateParm;
29
30typedef int INT;
31
32template<INT M> class NonTypeTemplateParm; // expected-note{{previous non-type template parameter with type 'INT' (aka 'int') is here}}
33
34template<long> class NonTypeTemplateParm; // expected-error{{template non-type parameter has a different type 'long' in template redeclaration}}
35
36template<template<typename T> class X> class TemplateTemplateParm;
37
38template<template<class> class Y> class TemplateTemplateParm; // expected-note{{previous template declaration is here}} \
39      // expected-note{{previous template template parameter is here}}
40
41template<typename> class TemplateTemplateParm; // expected-error{{template parameter has a different kind in template redeclaration}}
42
43template<template<typename T, int> class X> class TemplateTemplateParm; // expected-error{{too many template parameters in template template parameter redeclaration}}
44
45template<typename T>
46struct test {}; // expected-note{{previous definition}}
47
48template<typename T>
49struct test : T {}; // expected-error{{redefinition}}
50
51class X {
52public:
53  template<typename T> class C;
54};
55
56void f() {
57  template<typename T> class X; // expected-error{{expression}}
58}
59
60template<typename T> class X1 var; // expected-error {{variable has incomplete type 'class X1'}} \
61                                   // expected-note {{forward declaration of 'X1'}}
62
63namespace M {
64}
65
66template<typename T> class M::C3 { }; // expected-error{{out-of-line definition of 'C3' does not match any declaration in namespace 'M'}}
67
68namespace 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
86namespace 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
106namespace 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
149extern "C" template <typename T> // expected-error{{templates must have C++ linkage}}
150void DontCrashOnThis() { // expected-note@-1 {{extern "C" language linkage specification begins here}}
151  T &pT = T();
152  pT;
153}
154
155namespace 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
CodeThinker, Enjoy your reading code