Clang Project

clang_source_code/test/SemaTemplate/temp_explicit.cpp
1// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat %s
2// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat -std=c++98 %s
3// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++11 %s
4//
5// Tests explicit instantiation of templates.
6template<typename T, typename U = T> class X0 { };
7
8namespace N {
9  template<typename T, typename U = T> class X1 { };
10}
11
12// Check the syntax of explicit instantiations.
13template class X0<int, float>;
14template class X0<int>; // expected-note{{previous}}
15
16template class N::X1<int>;
17template class ::N::X1<int, float>;
18
19using namespace N;
20
21// Check for some bogus syntax that probably means that the user
22// wanted to write an explicit specialization, but forgot the '<>'
23// after 'template'.
24template class X0<double> { }; // expected-error{{explicit specialization}}
25
26// Check for explicit instantiations that come after other kinds of
27// instantiations or declarations.
28template class X0<int, int>; // expected-error{{duplicate}}
29
30template<> class X0<char> { }; // expected-note{{previous}}
31template class X0<char>; // expected-warning{{has no effect}}
32
33void foo(X0<short>) { }
34template class X0<short>;
35
36// Check that explicit instantiations actually produce definitions. We
37// determine whether this happens by placing semantic errors in the
38// definition of the template we're instantiating.
39template<typename T> struct X2; // expected-note{{declared here}}
40
41template struct X2<float>; // expected-error{{undefined template}}
42
43template<typename T>
44struct X2 {
45  void f0(T*); // expected-error{{pointer to a reference}}
46};
47
48template struct X2<int>; // okay
49template struct X2<int&>; // expected-note{{in instantiation of}}
50
51// Check that explicit instantiations instantiate member classes.
52template<typename T> struct X3 {
53  struct Inner {
54    void f(T*); // expected-error{{pointer to a reference}}
55  };
56};
57
58void f1(X3<int&>); // okay, Inner, not instantiated
59
60template struct X3<int&>; // expected-note{{instantiation}}
61
62template<typename T> struct X4 {
63  struct Inner {
64    struct VeryInner {
65      void f(T*); // expected-error 2{{pointer to a reference}}
66    };
67  };
68};
69
70void f2(X4<int&>); // okay, Inner, not instantiated
71void f3(X4<int&>::Inner); // okay, Inner::VeryInner, not instantiated
72
73template struct X4<int&>; // expected-note{{instantiation}}
74template struct X4<float&>; // expected-note{{instantiation}}
75
76// Check explicit instantiation of member classes
77namespace N2 {
78
79template<typename T>
80struct X5 {
81  struct Inner1 {
82    void f(T&);
83  };
84
85  struct Inner2 { // expected-note {{here}}
86    struct VeryInner {
87      void g(T*); // expected-error 2{{pointer to a reference}}
88    };
89  };
90};
91
92}
93
94template struct N2::X5<void>::Inner2;
95
96using namespace N2;
97template struct X5<int&>::Inner2; // expected-note{{instantiation}}
98
99void f4(X5<float&>::Inner2);
100template struct X5<float&>::Inner2; // expected-note{{instantiation}}
101
102namespace N3 {
103  template struct N2::X5<int>::Inner2;
104#if __cplusplus <= 199711L
105// expected-warning@-2 {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
106#else
107// expected-error@-4 {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
108#endif
109}
110
111struct X6 {
112  struct Inner { // expected-note{{here}}
113    void f();
114  };
115};
116
117template struct X6::Inner; // expected-error{{non-templated}}
118
119// PR5559
120template <typename T>
121struct Foo;
122
123template <>
124struct Foo<int> // expected-note{{header not required for explicitly-specialized}}
125{
126    template <typename U>
127    struct Bar
128    {};
129};
130
131template <> // expected-warning{{extraneous template parameter list}}
132template <>
133struct Foo<int>::Bar<void>
134{};
135
136namespace N1 {
137
138  template<typename T> struct X7 { }; // expected-note{{here}}
139
140  namespace Inner {
141    template<typename T> struct X8 { };
142  }
143
144  template struct X7<int>;
145  template struct Inner::X8<int>;
146}
147
148template<typename T> struct X9 { }; // expected-note{{here}}
149
150template struct ::N1::Inner::X8<float>;
151
152namespace N2 {
153  using namespace N1;
154
155  template struct X7<double>;
156#if __cplusplus <= 199711L
157// expected-warning@-2 {{explicit instantiation of 'N1::X7' must occur in namespace 'N1'}}
158#else
159// expected-error@-4 {{explicit instantiation of 'N1::X7' must occur in namespace 'N1'}}
160#endif
161
162  template struct X9<float>;
163#if __cplusplus <= 199711L
164// expected-warning@-2 {{explicit instantiation of 'X9' must occur at global scope}}
165#else
166// expected-error@-4 {{explicit instantiation of 'X9' must occur at global scope}}
167#endif
168}
169
CodeThinker, Enjoy your reading code