1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
// RUN: %clang_cc1 -std=c++1y %s -verify
namespace in_class_init {
union U { char c; double d = 4.0; };
constexpr U u1 = U();
constexpr U u2 {};
constexpr U u3 { 'x' };
static_assert(u1.d == 4.0, "");
static_assert(u2.d == 4.0, "");
static_assert(u3.c == 'x', "");
struct A {
int n = 5;
int m = n * 3;
union {
char c;
double d = 4.0;
};
};
constexpr A a1 {};
constexpr A a2 { 8 };
constexpr A a3 { 1, 2, { 3 } };
constexpr A a4 { 1, 2, { .d = 3.0 } };
static_assert(a1.d == 4.0, "");
static_assert(a2.m == 24, "");
static_assert(a2.d == 4.0, "");
static_assert(a3.c == 3, "");
static_assert(a3.d == 4.0, ""); // expected-error {{constant expression}} expected-note {{active member 'c'}}
static_assert(a4.d == 3.0, "");
struct B {
int n;
constexpr int f() { return n * 5; }
int m = f();
};
B b1 {};
constexpr B b2 { 2 };
B b3 { 1, 2 };
static_assert(b2.m == 10, "");
struct C {
int k;
union {
int l = k; // expected-error {{invalid use of non-static}}
};
};
}
namespace nested_aggregate_init {
struct A {
int n = 5;
int b = n * 3;
};
struct B {
constexpr B(int k) : d(1.23), k(k) {}
// Within this aggregate, both this object's 'this' and the temporary's
// 'this' are used.
constexpr int f() const { return A{k}.b; }
double d;
int k;
};
static_assert(B(6).f() == 18, "");
}
namespace use_self {
struct FibTree {
int n;
FibTree *l = // expected-note {{declared here}}
n > 1 ? new FibTree{n-1} : &fib0; // expected-error {{default member initializer for 'l' needed}}
FibTree *r = // expected-note {{declared here}}
n > 2 ? new FibTree{n-2} : &fib0; // expected-error {{default member initializer for 'r' needed}}
int v = l->v + r->v;
static FibTree fib0;
};
FibTree FibTree::fib0{0, nullptr, nullptr, 1};
int fib(int n) { return FibTree{n}.v; }
}
namespace nested_union {
union Test1 {
union {
int inner { 42 };
};
int outer;
};
static_assert(Test1{}.inner == 42, "");
struct Test2 {
union {
struct {
int inner : 32 { 42 }; // expected-warning {{C++20 extension}}
int inner_no_init;
};
int outer;
};
};
static_assert(Test2{}.inner == 42, "");
static_assert(Test2{}.inner_no_init == 0, "");
struct Int { int x; };
struct Test3 {
int x;
union {
struct { // expected-note {{in implicit initialization}}
const int& y; // expected-note {{uninitialized reference member is here}}
int inner : 32 { 42 }; // expected-warning {{C++20 extension}}
};
int outer;
};
};
Test3 test3 = {1}; // expected-error {{reference member of type 'const int &' uninitialized}}
constexpr char f(Test3) { return 1; } // expected-note {{candidate function}}
constexpr char f(Int) { return 2; } // expected-note {{candidate function}}
// FIXME: This shouldn't be ambiguous; either we should reject the declaration
// of Test3, or we should exclude f(Test3) as a candidate.
static_assert(f({1}) == 2, ""); // expected-error {{call to 'f' is ambiguous}}
}
|
