cxx0x-initializer-aggregates.cpp source code [clang_source_code/test/SemaCXX/cxx0x-initializer-aggregates.cpp]

1	// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s
2
3	struct one { char c[1]; };
4	struct two { char c[2]; };
5
6	namespace aggregate {
7	struct S {
8	int ar[2];
9	struct T {
10	int i1;
11	int i2;
12	} t;
13	struct U {
14	int i1;
15	} u[2];
16	struct V {
17	int var[2];
18	} v;
19	};
20
21	void bracing() {
22	S s1 = { 1, 2, 3 ,4, 5, 6, 7, 8 };
23	S s2{ {1, 2}, {3, 4}, { {5}, {6} }, { {7, 8} } };
24	S s3{ 1, 2, 3, 4, 5, 6 };
25	S s4{ {1, 2}, {3, 4}, {5, 6}, { {7, 8} } };
26	S s5{ {1, 2}, {3, 4}, { {5}, {6} }, {7, 8} };
27	}
28
29	void bracing_new() {
30	new S{ {1, 2}, {3, 4}, { {5}, {6} }, { {7, 8} } };
31	new S{ 1, 2, 3, 4, 5, 6 };
32	new S{ {1, 2}, {3, 4}, {5, 6}, { {7, 8} } };
33	new S{ {1, 2}, {3, 4}, { {5}, {6} }, {7, 8} };
34	}
35
36	void bracing_construct() {
37	(void) S{ {1, 2}, {3, 4}, { {5}, {6} }, { {7, 8} } };
38	(void) S{ 1, 2, 3, 4, 5, 6 };
39	(void) S{ {1, 2}, {3, 4}, {5, 6}, { {7, 8} } };
40	(void) S{ {1, 2}, {3, 4}, { {5}, {6} }, {7, 8} };
41	}
42
43	struct String {
44	String(const char*);
45	};
46
47	struct A {
48	int m1;
49	int m2;
50	};
51
52	void function_call() {
53	void takes_A(A);
54	takes_A({1, 2});
55	}
56
57	struct B {
58	int m1;
59	String m2;
60	};
61
62	void overloaded_call() {
63	one overloaded(A);
64	two overloaded(B);
65
66	static_assert(sizeof(overloaded({1, 2})) == sizeof(one), "bad overload");
67	static_assert(sizeof(overloaded({1, "two"})) == sizeof(two),
68	"bad overload");
69	// String is not default-constructible
70	static_assert(sizeof(overloaded({1})) == sizeof(one), "bad overload");
71	}
72
73	struct C { int a[2]; C():a({1, 2}) { } }; // expected-error {{parenthesized initialization of a member array is a GNU extension}}
74	}
75
76	namespace array_explicit_conversion {
77	typedef int test1[2];
78	typedef int test2[];
79	template<int x> struct A { int a[x]; }; // expected-error {{'a' declared as an array with a negative size}}
80	typedef A<1> test3[];
81	typedef A<-1> test4[];
82	void f() {
83	(void)test1{1};
84	(void)test2{1};
85	(void)test3{{{1}}};
86	(void)test4{{{1}}}; // expected-note {{in instantiation of template class 'array_explicit_conversion::A<-1>' requested here}}
87	}
88	}
89
90	namespace sub_constructor {
91	struct DefaultConstructor { // expected-note 2 {{not viable}}
92	DefaultConstructor(); // expected-note {{not viable}}
93	int x;
94	};
95	struct NoDefaultConstructor1 { // expected-note 2 {{not viable}}
96	NoDefaultConstructor1(int); // expected-note {{not viable}}
97	int x;
98	};
99	struct NoDefaultConstructor2 { // expected-note 4 {{not viable}}
100	NoDefaultConstructor2(int,int); // expected-note 2 {{not viable}}
101	int x;
102	};
103
104	struct Aggr {
105	DefaultConstructor a;
106	NoDefaultConstructor1 b;
107	NoDefaultConstructor2 c;
108	};
109
110	Aggr ok1 { {}, {0} , {0,0} };
111	Aggr ok2 = { {}, {0} , {0,0} };
112	Aggr too_many { {0} , {0} , {0,0} }; // expected-error {{no matching constructor for initialization}}
113	Aggr too_few { {} , {0} , {0} }; // expected-error {{no matching constructor for initialization}}
114	Aggr invalid { {} , {&ok1} , {0,0} }; // expected-error {{no matching constructor for initialization}}
115	NoDefaultConstructor2 array_ok[] = { {0,0} , {0,1} };
116	NoDefaultConstructor2 array_error[] = { {0,0} , {0} }; // expected-error {{no matching constructor for initialization}}
117	}
118
119	namespace multidimensional_array {
120	void g(const int (&)[2][2]) {}
121	void g(const int (&)[2][2][2]) = delete;
122
123	void h() {
124	g({{1,2},{3,4}});
125	}
126	}
127
128	namespace array_addressof {
129	using T = int[5];
130	T *p = &T{1,2,3,4,5}; // expected-error {{taking the address of a temporary object of type 'array_addressof::T' (aka 'int [5]')}}
131	}
132
133	namespace PR24816 {
134	struct { int i; } ne = {{0, 1}}; // expected-error{{excess elements in scalar initializer}}
135	}
136

Clang Project