| // RUN: %clang_cc1 -std=c++1z -verify %s -fcxx-exceptions -triple=x86_64-linux-gnu |
| |
| namespace BaseClassAggregateInit { |
| struct A { |
| int a, b, c; |
| constexpr A(int n) : a(n), b(3 * n), c(b - 1) {} // expected-note {{outside the range of representable}} |
| constexpr A() : A(10) {}; |
| }; |
| struct B : A {}; |
| struct C { int q; }; |
| struct D : B, C { int k; }; |
| |
| constexpr D d1 = { 1, 2, 3 }; |
| static_assert(d1.a == 1 && d1.b == 3 && d1.c == 2 && d1.q == 2 && d1.k == 3); |
| |
| constexpr D d2 = { 14 }; |
| static_assert(d2.a == 14 && d2.b == 42 && d2.c == 41 && d2.q == 0 && d2.k == 0); |
| |
| constexpr D d3 = { A(5), C{2}, 1 }; |
| static_assert(d3.a == 5 && d3.b == 15 && d3.c == 14 && d3.q == 2 && d3.k == 1); |
| |
| constexpr D d4 = {}; |
| static_assert(d4.a == 10 && d4.b == 30 && d4.c == 29 && d4.q == 0 && d4.k == 0); |
| |
| constexpr D d5 = { __INT_MAX__ }; // expected-error {{must be initialized by a constant expression}} |
| // expected-note-re@-1 {{in call to 'A({{.*}})'}} |
| } |
| |
| namespace NoexceptFunctionTypes { |
| template<typename T> constexpr bool f() noexcept(true) { return true; } |
| constexpr bool (*fp)() = f<int>; |
| static_assert(f<int>()); |
| static_assert(fp()); |
| |
| template<typename T> struct A { |
| constexpr bool f() noexcept(true) { return true; } |
| constexpr bool g() { return f(); } |
| constexpr bool operator()() const noexcept(true) { return true; } |
| }; |
| static_assert(A<int>().f()); |
| static_assert(A<int>().g()); |
| static_assert(A<int>()()); |
| } |
| |
| namespace Cxx17CD_NB_GB19 { |
| const int &r = 0; |
| constexpr int n = r; |
| } |
| |
| namespace PR37585 { |
| template <class T> struct S { static constexpr bool value = true; }; |
| template <class T> constexpr bool f() { return true; } |
| template <class T> constexpr bool v = true; |
| |
| void test() { |
| if constexpr (true) {} |
| else if constexpr (f<int>()) {} |
| else if constexpr (S<int>::value) {} |
| else if constexpr (v<int>) {} |
| } |
| } |
| |
| // Check that assignment operators evaluate their operands right-to-left. |
| namespace EvalOrder { |
| template<typename T> struct lvalue { |
| T t; |
| constexpr T &get() { return t; } |
| }; |
| |
| struct UserDefined { |
| int n = 0; |
| constexpr UserDefined &operator=(const UserDefined&) { return *this; } |
| constexpr UserDefined &operator+=(const UserDefined&) { return *this; } |
| constexpr void operator<<(const UserDefined&) const {} |
| constexpr void operator>>(const UserDefined&) const {} |
| constexpr void operator+(const UserDefined&) const {} |
| constexpr void operator[](int) const {} |
| }; |
| constexpr UserDefined ud; |
| |
| struct NonMember {}; |
| constexpr void operator+=(NonMember, NonMember) {} |
| constexpr void operator<<(NonMember, NonMember) {} |
| constexpr void operator>>(NonMember, NonMember) {} |
| constexpr void operator+(NonMember, NonMember) {} |
| constexpr NonMember nm; |
| |
| constexpr void f(...) {} |
| |
| // Helper to ensure that 'a' is evaluated before 'b'. |
| struct seq_checker { |
| bool done_a = false; |
| bool done_b = false; |
| |
| template <typename T> constexpr T &&a(T &&v) { |
| done_a = true; |
| return (T &&)v; |
| } |
| template <typename T> constexpr T &&b(T &&v) { |
| if (!done_a) |
| throw "wrong"; |
| done_b = true; |
| return (T &&)v; |
| } |
| |
| constexpr bool ok() { return done_a && done_b; } |
| }; |
| |
| // SEQ(expr), where part of the expression is tagged A(...) and part is |
| // tagged B(...), checks that A is evaluated before B. |
| #define A sc.a |
| #define B sc.b |
| #define SEQ(...) static_assert([](seq_checker sc) { void(__VA_ARGS__); return sc.ok(); }({})) |
| |
| // Longstanding sequencing rules. |
| SEQ((A(1), B(2))); |
| SEQ((A(true) ? B(2) : throw "huh?")); |
| SEQ((A(false) ? throw "huh?" : B(2))); |
| SEQ(A(true) && B(true)); |
| SEQ(A(false) || B(true)); |
| |
| // From P0145R3: |
| |
| // Rules 1 and 2 have no effect ('b' is not an expression). |
| |
| // Rule 3: a->*b |
| SEQ(A(ud).*B(&UserDefined::n)); |
| SEQ(A(&ud)->*B(&UserDefined::n)); |
| |
| // Rule 4: a(b1, b2, b3) |
| SEQ(A(f)(B(1), B(2), B(3))); |
| |
| // Rule 5: b = a, b @= a |
| SEQ(B(lvalue<int>().get()) = A(0)); |
| SEQ(B(lvalue<UserDefined>().get()) = A(ud)); |
| SEQ(B(lvalue<int>().get()) += A(0)); |
| SEQ(B(lvalue<UserDefined>().get()) += A(ud)); |
| SEQ(B(lvalue<NonMember>().get()) += A(nm)); |
| |
| // Rule 6: a[b] |
| constexpr int arr[3] = {}; |
| SEQ(A(arr)[B(0)]); |
| SEQ(A(+arr)[B(0)]); |
| SEQ(A(0)[B(arr)]); |
| SEQ(A(0)[B(+arr)]); |
| SEQ(A(ud)[B(0)]); |
| |
| // Rule 7: a << b |
| SEQ(A(1) << B(2)); |
| SEQ(A(ud) << B(ud)); |
| SEQ(A(nm) << B(nm)); |
| |
| // Rule 8: a >> b |
| SEQ(A(1) >> B(2)); |
| SEQ(A(ud) >> B(ud)); |
| SEQ(A(nm) >> B(nm)); |
| |
| // No particular order of evaluation is specified in other cases, but we in |
| // practice evaluate left-to-right. |
| // FIXME: Technically we're expected to check for undefined behavior due to |
| // unsequenced read and modification and treat it as non-constant due to UB. |
| SEQ(A(1) + B(2)); |
| SEQ(A(ud) + B(ud)); |
| SEQ(A(nm) + B(nm)); |
| SEQ(f(A(1), B(2))); |
| |
| #undef SEQ |
| #undef A |
| #undef B |
| } |
| |
| namespace LambdaCallOp { |
| constexpr void get_lambda(void (*&p)()) { p = []{}; } |
| constexpr void call_lambda() { |
| void (*p)() = nullptr; |
| get_lambda(p); |
| p(); |
| } |
| } |