blob: 6cff4206faa40245d7690a2ca29657b6d9671e3f [file] [log] [blame]
Richard Smith762bb9d2011-10-13 22:29:44 +00001// RUN: %clang_cc1 -verify -std=c++11 %s
Richard Smith3e4c6c42011-05-05 21:57:07 +00002
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 // FIXME: this is illegal; we incorrectly accept it for typedefs too.
16 template<typename U> using F = void(*)(int n) &&; // expected-err
17 template<typename U> using G = __thread void(int n); // expected-error {{type name does not allow storage class to be specified}}
18
19 template<typename U> using H = void(int n); // ok
20 template<typename U> using I = 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]; // expected-note {{previous definition}}
39 template<typename Z> using U = int[42]; // ok
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 // FIXME: this diagnostic is pretty poor
72 template<typename U> using C0 = int; // expected-error {{name defined in alias declaration must be an identifier}}
73 };
74 class C1 {
75 // FIXME: this diagnostic is pretty poor
76 template<typename U> using C1 = C1; // expected-error {{name defined in alias declaration must be an identifier}}
77 };
78 class C2 {
79 template<typename U> using C0 = C1; // ok
80 };
81 template<typename...T> class C3 {
82 template<typename U> using f = T; // expected-error {{declaration type contains unexpanded parameter pack 'T'}}
83 };
84 template<typename T> class C4 { // expected-note {{template parameter is declared here}}
85 template<typename U> using T = int; // expected-error {{declaration of 'T' shadows template parameter}}
86 };
87 class C5 {
88 class c; // expected-note {{previous definition}}
89 template<typename U> using c = int; // expected-error {{redefinition of 'c' as different kind of symbol}}
90 class d; // expected-note {{previous definition}}
91 template<typename U> using d = d; // expected-error {{redefinition of 'd' as different kind of symbol}}
92 };
93 class C6 {
94 class c { template<typename U> using C6 = int; }; // ok
95 };
96}
97
98class CtorDtorName {
99 template<typename T> using X = CtorDtorName;
100 X<int>(); // expected-error {{expected member name}}
101 ~X<int>(); // expected-error {{destructor cannot be declared using a type alias}}
102};
103
104namespace TagName {
105 template<typename Z> using S = struct { int n; }; // expected-error {{can not be defined}}
106 template<typename Z> using T = class { int n; }; // expected-error {{can not be defined}}
107 template<typename Z> using U = enum { a, b, c }; // expected-error {{can not be defined}}
108 template<typename Z> using V = struct V { int n; }; // expected-error {{redefinition of 'V' as different kind of symbol}} \
109 expected-error {{'TagName::V' can not be defined in a type alias template}} \
110 expected-note {{previous definition is here}}
111}
112
113namespace StdExample {
114 template<typename T, typename U> struct pair;
115
116 template<typename T> using handler_t = void (*)(T);
117 extern handler_t<int> ignore;
118 extern void (*ignore)(int);
119 // FIXME: we recover as if cell is an undeclared variable. the diagnostics are terrible!
120 template<typename T> using cell = pair<T*, cell<T>*>; // expected-error {{use of undeclared identifier 'cell'}} \
121 expected-error {{'T' does not refer to a value}} \
122 expected-note {{declared here}} \
123 expected-error {{expected ';' after alias declaration}}
124}
125
126namespace Access {
127 class C0 {
128 template<typename Z> using U = int; // expected-note {{declared private here}}
129 };
130 C0::U<int> v; // expected-error {{'U' is a private member}}
131 class C1 {
132 public:
133 template<typename Z> using U = int;
134 };
135 C1::U<int> w; // ok
136}
137
138namespace VoidArg {
139 template<typename Z> using V = void;
140 V<int> f(int); // ok
141 V<char> g(V<double>); // expected-error {{empty parameter list defined with a type alias of 'void' not allowed}}
142}
143
144namespace Curried {
145 template<typename T, typename U> struct S;
146 template<typename T> template<typename U> using SS = S<T, U>; // expected-error {{extraneous template parameter list in alias template declaration}}
147}