1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
2 
3 // This test concerns the identity of dependent types within the
4 // canonical type system. This corresponds to C++ [temp.type], which
5 // specifies type equivalence within a template.
6 //
7 // FIXME: template template parameters
8 
9 namespace N {
10   template<typename T>
11   struct X2 {
12     template<typename U>
13     struct apply {
14       typedef U* type;
15     };
16   };
17 }
18 
19 namespace Nalias = N;
20 
21 template<typename T>
22 struct X0 { };
23 
24 using namespace N;
25 
26 template<typename T, typename U>
27 struct X1 {
28   typedef T type;
29   typedef U U_type;
30 
31   void f0(T); // expected-note{{previous}}
32   void f0(U);
33   void f0(type); // expected-error{{redeclar}}
34 
35   void f1(T*); // expected-note{{previous}}
36   void f1(U*);
37   void f1(type*); // expected-error{{redeclar}}
38 
39   void f2(X0<T>*); // expected-note{{previous}}
40   void f2(X0<U>*);
41   void f2(X0<type>*); // expected-error{{redeclar}}
42 
43   void f3(X0<T>*); // expected-note{{previous}}
44   void f3(X0<U>*);
45   void f3(::X0<type>*); // expected-error{{redeclar}}
46 
47   void f4(typename T::template apply<U>*); // expected-note{{previous}}
48   void f4(typename U::template apply<U>*);
49   void f4(typename type::template apply<T>*);
50   void f4(typename type::template apply<U_type>*); // expected-error{{redeclar}}
51 
52   void f5(typename T::template apply<U>::type*); // expected-note{{previous}}
53   void f5(typename U::template apply<U>::type*);
54   void f5(typename U::template apply<T>::type*);
55   void f5(typename type::template apply<T>::type*);
56   void f5(typename type::template apply<U_type>::type*); // expected-error{{redeclar}}
57 
58   void f6(typename N::X2<T>::template apply<U> *); // expected-note{{previous}}
59   void f6(typename N::X2<U>::template apply<U> *);
60   void f6(typename N::X2<U>::template apply<T> *);
61   void f6(typename ::N::X2<type>::template apply<U_type> *); // expected-error{{redeclar}}
62 
63   void f7(typename N::X2<T>::template apply<U> *); // expected-note{{previous}}
64   void f7(typename N::X2<U>::template apply<U> *);
65   void f7(typename N::X2<U>::template apply<T> *);
66   void f7(typename X2<type>::template apply<U_type> *); // expected-error{{redeclar}}
67 
68   void f8(typename N::X2<T>::template apply<U> *); // expected-note{{previous}}
69   void f8(typename N::X2<U>::template apply<U> *);
70   void f8(typename N::X2<U>::template apply<T> *);
71   void f8(typename ::Nalias::X2<type>::template apply<U_type> *); // expected-error{{redeclar}}
72 };
73 
74 namespace PR6851 {
75   template <bool v>
76   struct S;
77 
78   struct N {
79     template <bool w>
80     S< S<w>::cond && 1 > foo();
81   };
82 
83   struct Arrow { Arrow *operator->(); int n; };
84   template<typename T> struct M {
85     Arrow a;
86     auto f() -> M<decltype(a->n)>;
87   };
88 
89   struct Alien;
90   bool operator&&(const Alien&, const Alien&);
91 
92   template <bool w>
foo()93   S< S<w>::cond && 1 > N::foo() { }
94 
95   template<typename T>
f()96   auto M<T>::f() -> M<decltype(a->n)> {}
97 }
98 
99 namespace PR7460 {
100   template <typename T>
101   struct TemplateClass2
102   {
103     enum { SIZE = 100 };
104     static T member[SIZE];
105   };
106 
107   template <typename T>
108   T TemplateClass2<T>::member[TemplateClass2<T>::SIZE];
109 }
110 
111 namespace PR18275 {
112   template<typename T> struct A {
113     void f(const int);
114     void g(int);
115     void h(const T);
116     void i(T);
117   };
118 
119   template<typename T>
f(int x)120   void A<T>::f(int x) { x = 0; }
121 
122   template<typename T>
g(const int x)123   void A<T>::g(const int x) {  // expected-note {{declared const here}}
124     x = 0; // expected-error {{cannot assign to variable 'x'}}
125   }
126 
127   template<typename T>
h(T)128   void A<T>::h(T) {} // FIXME: Should reject this. Type is different from prior decl if T is an array type.
129 
130   template<typename T>
i(const T)131   void A<T>::i(const T) {} // FIXME: Should reject this. Type is different from prior decl if T is an array type.
132 
133   template struct A<int>;
134   template struct A<int[1]>;
135 }
136 
137 namespace PR21289 {
138   template<typename T> using X = int;
139   template<typename T, decltype(sizeof(0))> using Y = int;
140   template<typename ...Ts> struct S {};
f()141   template<typename ...Ts> void f() {
142     // This is a dependent type. It is *not* S<int>, even though it canonically
143     // contains no template parameters.
144     using Type = S<X<Ts>...>;
145     Type s;
146     using Type = S<int, int, int>;
147   }
g()148   void g() { f<void, void, void>(); }
149 
h(S<int>)150   template<typename ...Ts> void h(S<int>) {}
151   // Pending a core issue, it's not clear if these are redeclarations, but they
152   // are probably intended to be... even though substitution can succeed for one
153   // of them but fail for the other!
h(S<X<Ts>...>)154   template<typename ...Ts> void h(S<X<Ts>...>) {} // expected-note {{previous}}
h(S<Y<Ts,sizeof (Ts)>...>)155   template<typename ...Ts> void h(S<Y<Ts, sizeof(Ts)>...>) {} // expected-error {{redefinition}}
156 }
157