p4.cpp source code [clang_source_code/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p4.cpp]

1	// RUN: %clang_cc1 -fsyntax-only -verify %s
2	// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
3
4	// C++03 [namespace.udecl]p4:
5	// A using-declaration used as a member-declaration shall refer to a
6	// member of a base class of the class being defined, shall refer to
7	// a member of an anonymous union that is a member of a base class
8	// of the class being defined, or shall refer to an enumerator for
9	// an enumeration type that is a member of a base class of the class
10	// being defined.
11
12	// There is no directly analogous paragraph in C++0x, and the feature
13	// works sufficiently differently there that it needs a separate test.
14
15	namespace test0 {
16	namespace NonClass {
17	typedef int type;
18	struct hiding {};
19	int hiding;
20	static union { double union_member; };
21	enum tagname { enumerator };
22	}
23
24	class Test0 {
25	using NonClass::type; // expected-error {{not a class}}
26	using NonClass::hiding; // expected-error {{not a class}}
27	using NonClass::union_member; // expected-error {{not a class}}
28	using NonClass::enumerator; // expected-error {{not a class}}
29	};
30	}
31
32	struct Opaque0 {};
33
34	namespace test1 {
35	struct A {
36	typedef int type;
37	struct hiding {}; // expected-note {{previous use is here}}
38	Opaque0 hiding;
39	union { double union_member; };
40	enum tagname { enumerator };
41	};
42
43	struct B : A {
44	using A::type;
45	using A::hiding;
46	using A::union_member;
47	using A::enumerator;
48	using A::tagname;
49
50	void test0() {
51	type t = 0;
52	}
53
54	void test1() {
55	typedef struct A::hiding local;
56	struct hiding _ = local();
57	}
58
59	void test2() {
60	union hiding _; // expected-error {{tag type that does not match previous}}
61	}
62
63	void test3() {
64	char array[sizeof(union_member) == sizeof(double) ? 1 : -1];
65	}
66
67	void test4() {
68	enum tagname _ = enumerator;
69	}
70
71	void test5() {
72	Opaque0 _ = hiding;
73	}
74	};
75	}
76
77	namespace test2 {
78	struct A {
79	typedef int type;
80	struct hiding {}; // expected-note {{previous use is here}}
81	int hiding;
82	union { double union_member; };
83	enum tagname { enumerator };
84	};
85
86	template <class T> struct B : A {
87	using A::type;
88	using A::hiding;
89	using A::union_member;
90	using A::enumerator;
91	using A::tagname;
92
93	void test0() {
94	type t = 0;
95	}
96
97	void test1() {
98	typedef struct A::hiding local;
99	struct hiding _ = local();
100	}
101
102	void test2() {
103	union hiding _; // expected-error {{tag type that does not match previous}}
104	}
105
106	void test3() {
107	char array[sizeof(union_member) == sizeof(double) ? 1 : -1];
108	}
109
110	void test4() {
111	enum tagname _ = enumerator;
112	}
113
114	void test5() {
115	Opaque0 _ = hiding;
116	}
117	};
118	}
119
120	namespace test3 {
121	struct hiding {};
122
123	template <class T> struct A {
124	typedef int type; // expected-note {{target of using declaration}}
125	struct hiding {};
126	Opaque0 hiding; // expected-note {{target of using declaration}}
127	union { double union_member; }; // expected-note {{target of using declaration}}
128	enum tagname { enumerator }; // expected-note 2 {{target of using declaration}}
129	};
130
131	template <class T> struct B : A<T> {
132	using A<T>::type; // expected-error {{dependent using declaration resolved to type without 'typename'}}
133	using A<T>::hiding;
134	using A<T>::union_member;
135	using A<T>::enumerator;
136	using A<T>::tagname; // expected-error {{dependent using declaration resolved to type without 'typename'}}
137
138	// FIXME: re-enable these when the various bugs involving tags are fixed
139	#if 0
140	void test1() {
141	typedef struct A<T>::hiding local;
142	struct hiding _ = local();
143	}
144
145	void test2() {
146	typedef struct A<T>::hiding local;
147	union hiding _ = local();
148	}
149	#endif
150
151	void test3() {
152	char array[sizeof(union_member) == sizeof(double) ? 1 : -1];
153	}
154
155	#if 0
156	void test4() {
157	enum tagname _ = enumerator;
158	}
159	#endif
160
161	void test5() {
162	Opaque0 _ = hiding;
163	}
164	};
165
166	template struct B<int>; // expected-note {{in instantiation}}
167
168	template <class T> struct C : A<T> {
169	using typename A<T>::type;
170	using typename A<T>::hiding; // expected-note {{declared here}} \
171	// expected-error {{'typename' keyword used on a non-type}}
172	using typename A<T>::union_member; // expected-error {{'typename' keyword used on a non-type}}
173	using typename A<T>::enumerator; // expected-error {{'typename' keyword used on a non-type}}
174
175	void test6() {
176	type t = 0;
177	}
178
179	void test7() {
180	Opaque0 _ = hiding; // expected-error {{does not refer to a value}}
181	}
182	};
183
184	template struct C<int>; // expected-note {{in instantiation}}
185	}
186
187	namespace test4 {
188	struct Base {
189	int foo();
190	};
191
192	struct Unrelated {
193	int foo();
194	};
195
196	struct Subclass : Base {
197	};
198
199	namespace InnerNS {
200	int foo();
201	}
202
203	// We should be able to diagnose these without instantiation.
204	template <class T> struct C : Base {
205	using InnerNS::foo; // expected-error {{not a class}}
206	using Base::bar; // expected-error {{no member named 'bar'}}
207	using Unrelated::foo; // expected-error {{not a base class}}
208	using C::foo; // legal in C++03
209	using Subclass::foo; // legal in C++03
210	#if __cplusplus >= 201103L
211	// expected-error@-3 {{refers to its own class}}
212	// expected-error@-3 {{refers into 'Subclass::', which is not a base class}}
213	#endif
214
215	int bar();
216	#if __cplusplus < 201103L
217	// expected-note@-2 {{target of using declaration}}
218	#endif
219	using C::bar; // expected-error {{refers to its own class}}
220	};
221	}
222
223	namespace test5 {
224	struct B;
225	struct A {
226	A(const B&);
227	B &operator=(const B&);
228	};
229	struct B : A {
230	#if __cplusplus >= 201103L
231	using A::A;
232	#endif
233	using A::operator=;
234	};
235	void test(B b) {
236	B b2(b);
237	b2 = b;
238	}
239	}
240

Clang Project