// 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();
  }
}

// This used to crash due to an assertion failure,
// see gh#67690
namespace {
  struct C {
    int x;
  };

  template <const C *p> void f() {
    const auto &[c] = *p;
    &c; // expected-warning {{expression result unused}}
  }
}