Clang Project

clang_source_code/test/SemaCXX/alias-template.cpp
1// RUN: %clang_cc1 -verify -std=c++14 -fcxx-exceptions %s
2
3namespace RedeclAliasTypedef {
4  template<typename U> using T = int;
5  template<typename U> using T = int;
6  template<typename U> using T = T<U>;
7}
8
9namespace IllegalTypeIds {
10  template<typename U> using A = void(int n = 0); // expected-error {{default arguments can only be specified for parameters in a function declaration}}
11  template<typename U> using B = inline void(int n); // expected-error {{type name does not allow function specifier}}
12  template<typename U> using C = virtual void(int n); // expected-error {{type name does not allow function specifier}}
13  template<typename U> using D = explicit void(int n); // expected-error {{type name does not allow function specifier}}
14  template<typename U> using E = void(int n) throw(); // expected-error {{exception specifications are not allowed in type aliases}}
15  template<typename U> using F = void(*)(int n) &&; // expected-error {{pointer to function type cannot have '&&' qualifier}}
16  template<typename U> using G = __thread void(int n); // expected-error {{type name does not allow storage class to be specified}}
17  template<typename U> using H = constexpr int; // expected-error {{type name does not allow constexpr specifier}}
18
19  template<typename U> using Y = void(int n); // ok
20  template<typename U> using Z = void(int n) &&; // ok
21}
22
23namespace IllegalSyntax {
24  template<typename Z> using ::T = void(int n); // expected-error {{name defined in alias declaration must be an identifier}}
25  template<typename Z> using operator int = void(int n); // expected-error {{name defined in alias declaration must be an identifier}}
26  template<typename Z> using typename U = void; // expected-error {{name defined in alias declaration must be an identifier}}
27  template<typename Z> using typename ::V = void(int n); // expected-error {{name defined in alias declaration must be an identifier}}
28  template<typename Z> using typename ::operator bool = void(int n); // expected-error {{name defined in alias declaration must be an identifier}}
29}
30
31namespace VariableLengthArrays {
32  template<typename Z> using T = int[42]; // ok
33
34  int n = 32;
35  template<typename Z> using T = int[n]; // expected-error {{variable length array declaration not allowed at file scope}}
36
37  const int m = 42;
38  template<typename Z> using U = int[m];
39  template<typename Z> using U = int[42]; // expected-note {{previous definition}} 
40  template<typename Z> using U = int; // expected-error {{type alias template redefinition with different types ('int' vs 'int [42]')}}
41}
42
43namespace RedeclFunc {
44  int f(int, char**);
45  template<typename Z> using T = int;
46  T<char> f(int, char **); // ok
47}
48
49namespace LookupFilter {
50  namespace N { template<typename U> using S = int; }
51  using namespace N;
52  template<typename U> using S = S<U>*; // ok
53}
54
55namespace InFunctions {
56  template<typename...T> struct S0 {
57    template<typename Z> using U = T*; // expected-error {{declaration type contains unexpanded parameter pack 'T'}}
58    U<char> u;
59  };
60
61  template<typename Z> using T1 = int;
62  template<typename Z> using T2 = int[-1]; // expected-error {{array size is negative}}
63  template<typename...T> struct S3 { // expected-note {{template parameter is declared here}}
64    template<typename Z> using T = int; // expected-error {{declaration of 'T' shadows template parameter}}
65  };
66  template<typename Z> using Z = Z;
67}
68
69namespace ClassNameRedecl {
70  class C0 {
71    template<typename U> using C0 = int; // expected-error {{member 'C0' has the same name as its class}}
72  };
73  class C1 {
74    template<typename U> using C1 = C1; // expected-error {{member 'C1' has the same name as its class}}
75  };
76  class C2 {
77    template<typename U> using C0 = C1; // ok
78  };
79  template<typename...T> class C3 {
80    template<typename U> using f = T; // expected-error {{declaration type contains unexpanded parameter pack 'T'}}
81  };
82  template<typename T> class C4 { // expected-note {{template parameter is declared here}}
83    template<typename U> using T = int; // expected-error {{declaration of 'T' shadows template parameter}}
84  };
85  class C5 {
86    class c; // expected-note {{previous definition}}
87    template<typename U> using c = int; // expected-error {{redefinition of 'c' as different kind of symbol}}
88    class d; // expected-note {{previous definition}}
89    template<typename U> using d = d; // expected-error {{redefinition of 'd' as different kind of symbol}}
90  };
91  class C6 {
92    class c { template<typename U> using C6 = int; }; // ok
93  };
94}
95
96class CtorDtorName {
97  template<typename T> using X = CtorDtorName;
98  X<int>(); // expected-error {{expected member name}}
99  ~X<int>(); // expected-error {{destructor cannot be declared using a type alias}}
100};
101
102namespace TagName {
103  template<typename Z> using S = struct { int n; }; // expected-error {{cannot be defined}}
104  template<typename Z> using T = class { int n; }; // expected-error {{cannot be defined}}
105  template<typename Z> using U = enum { a, b, c }; // expected-error {{cannot be defined}}
106  template<typename Z> using V = struct V { int n; }; // expected-error {{'TagName::V' cannot be defined in a type alias template}}
107}
108
109namespace StdExample {
110  template<typename T, typename U> struct pair;
111
112  template<typename T> using handler_t = void (*)(T);
113  extern handler_t<int> ignore;
114  extern void (*ignore)(int);
115  // FIXME: we recover as if cell is an undeclared variable. the diagnostics are terrible!
116  template<typename T> using cell = pair<T*, cell<T>*>; // expected-error {{use of undeclared identifier 'cell'}} \
117                                                           expected-error {{'T' does not refer to a value}} \
118                                                           expected-note {{declared here}} \
119                                                           expected-error {{expected ';' after alias declaration}}
120}
121
122namespace Access {
123  class C0 {
124    template<typename Z> using U = int; // expected-note {{declared private here}}
125  };
126  C0::U<int> v; // expected-error {{'U' is a private member}}
127  class C1 {
128  public:
129    template<typename Z> using U = int;
130  };
131  C1::U<int> w; // ok
132}
133
134namespace VoidArg {
135  template<typename Z> using V = void;
136  V<int> f(int); // ok
137  V<char> g(V<double>); // ok (DR577)
138}
139
140namespace Curried {
141  template<typename T, typename U> struct S;
142  template<typename T> template<typename U> using SS = S<T, U>; // expected-error {{extraneous template parameter list in alias template declaration}}
143}
144
145// PR12647
146namespace SFINAE {
147  template<bool> struct enable_if; // expected-note 2{{here}}
148  template<> struct enable_if<true> { using type = void; };
149
150  template<typename T> struct is_enum { static constexpr bool value = __is_enum(T); };
151
152  template<typename T> using EnableIf = typename enable_if<T::value>::type; // expected-error {{undefined template}}
153  template<typename T> using DisableIf = typename enable_if<!T::value>::type; // expected-error {{undefined template}}
154
155  template<typename T> EnableIf<is_enum<T>> f();
156  template<typename T> DisableIf<is_enum<T>> f();
157
158  enum E { e };
159
160  int main() {
161    f<int>();
162    f<E>();
163  }
164
165  template<typename T, typename U = EnableIf<is_enum<T>>> struct fail1 {}; // expected-note {{here}}
166  template<typename T> struct fail2 : DisableIf<is_enum<T>> {}; // expected-note {{here}}
167
168  fail1<int> f1; // expected-note {{here}}
169  fail2<E> f2; // expected-note {{here}}
170}
171
172namespace PR24212 {
173struct X {};
174template <int I>
175struct S {
176  template <int J>
177  using T = X[J];
178  using U = T<I>;
179};
180static_assert(__is_same(S<3>::U, X[2]), ""); // expected-error {{static_assert failed}}
181}
182
183namespace PR39623 {
184template <class T>
185using void_t = void;
186
187template <class T, class = void_t<typename T::wait_what>>
188int sfinae_me() { return 0; } // expected-note{{candidate template ignored: substitution failure}}
189
190int g = sfinae_me<int>(); // expected-error{{no matching function for call to 'sfinae_me'}}
191}
192
193namespace NullExceptionDecl {
194template<int... I> auto get = []() { try { } catch(...) {}; return I; }; // expected-error{{initializer contains unexpanded parameter pack 'I'}}
195}
196
CodeThinker, Enjoy your reading code