1// RUN: %clang_cc1 -verify -std=c++11 %s
2
3namespace RedeclAliasTypedef {
4  typedef int T;
5  using T = int;
6  using T = int;
7  typedef T T;
8  using T = T;
9  typedef int T;
10}
11
12namespace IllegalTypeIds {
13  using A = void(int n = 0); // expected-error {{default arguments can only be specified for parameters in a function declaration}}
14  using B = inline void(int n); // expected-error {{type name does not allow function specifier}}
15  using C = virtual void(int n); // expected-error {{type name does not allow function specifier}}
16  using D = explicit void(int n); // expected-error {{type name does not allow function specifier}}
17  using E = void(int n) throw(); // expected-error {{exception specifications are not allowed in type aliases}}
18  using F = void(*)(int n) &&; // expected-error {{pointer to function type cannot have '&&' qualifier}}
19  using G = __thread void(int n); // expected-error {{type name does not allow storage class to be specified}}
20  using H = constexpr int; // expected-error {{type name does not allow constexpr specifier}}
21
22  using Y = void(int n); // ok
23  using Z = void(int n) &&; // ok
24}
25
26namespace IllegalSyntax {
27  using ::T = void(int n); // expected-error {{name defined in alias declaration must be an identifier}}
28  using operator int = void(int n); // expected-error {{name defined in alias declaration must be an identifier}}
29  using typename U = void; // expected-error {{name defined in alias declaration must be an identifier}}
30  using typename ::V = void(int n); // expected-error {{name defined in alias declaration must be an identifier}}
31  using typename ::operator bool = void(int n); // expected-error {{name defined in alias declaration must be an identifier}}
32}
33
34namespace VariableLengthArrays {
35  using T = int[42]; // ok
36
37  int n = 32;
38  using T = int[n]; // expected-error {{variable length array declaration not allowed at file scope}}
39
40  const int m = 42;
41  using U = int[m]; // expected-note {{previous definition}}
42  using U = int[42]; // ok
43  using U = int; // expected-error {{type alias redefinition with different types ('int' vs 'int [42]')}}
44
45  void f() {
46    int n = 42;
47    goto foo; // expected-error {{cannot jump}}
48    using T = int[n]; // expected-note {{bypasses initialization of VLA type alias}}
49  foo: ;
50  }
51}
52
53namespace RedeclFunc {
54  int f(int, char**);
55  using T = int;
56  T f(int, char **); // ok
57}
58
59namespace LookupFilter {
60  namespace N { struct S; }
61  using namespace N;
62  using S = S*; // ok
63}
64
65namespace InFunctions {
66  template<typename...T> void f0() {
67    using U = T*; // expected-error {{declaration type contains unexpanded parameter pack 'T'}}
68    U u;
69  }
70  template void f0<int, char>();
71
72  void f1() {
73    using T = int;
74  }
75  void f2() {
76    using T = int[-1]; // expected-error {{array size is negative}}
77  }
78
79  template<typename...T> void f3() { // expected-note {{template parameter is declared here}}
80    using T = int; // expected-error {{declaration of 'T' shadows template parameter}}
81  }
82}
83
84namespace ClassNameRedecl {
85  class C0 {
86    using C0 = int; // expected-error {{member 'C0' has the same name as its class}}
87  };
88  class C1 {
89    using C1 = C1; // expected-error {{member 'C1' has the same name as its class}}
90  };
91  class C2 {
92    using C0 = C1; // ok
93  };
94  template<typename...T> class C3 {
95    using f = T; // expected-error {{declaration type contains unexpanded parameter pack 'T'}}
96  };
97  template<typename T> class C4 { // expected-note {{template parameter is declared here}}
98    using T = int; // expected-error {{declaration of 'T' shadows template parameter}}
99  };
100  class C5 {
101    class c; // expected-note {{previous definition}}
102    using c = int; // expected-error {{typedef redefinition with different types}}
103    class d;
104    using d = d; // ok
105  };
106  class C6 {
107    class c { using C6 = int; }; // ok
108  };
109}
110
111class CtorDtorName {
112  using X = CtorDtorName;
113  X(); // expected-error {{expected member name}}
114  ~X(); // expected-error {{destructor cannot be declared using a type alias}}
115};
116
117namespace TagName {
118  using S = struct { int n; };
119  using T = class { int n; };
120  using U = enum { a, b, c };
121  using V = struct V { int n; };
122}
123
124namespace CWG1044 {
125  using T = T; // expected-error {{unknown type name 'T'}}
126}
127
128namespace StdExample {
129  template<typename T, typename U> struct pair;
130
131  using handler_t = void (*)(int);
132  extern handler_t ignore;
133  extern void (*ignore)(int);
134  // FIXME: we know we're parsing a type here; don't recover as if we were
135  // using operator*.
136  using cell = pair<void*, cell*>; // expected-error {{use of undeclared identifier 'cell'}} \
137                                      expected-error {{expected expression}}
138}
139
140namespace Access {
141  class C0 {
142    using U = int; // expected-note {{declared private here}}
143  };
144  C0::U v; // expected-error {{'U' is a private member}}
145  class C1 {
146  public:
147    using U = int;
148  };
149  C1::U w; // ok
150}
151
152namespace VoidArg {
153  using V = void;
154  V f(int); // ok
155  V g(V); // ok (DR577)
156}
157