xref: /llvm-project/clang/test/AST/ByteCode/eval-order.cpp (revision a07aba5d44204a7ca0d891a3da05af9960081e4c)

// RUN: %clang_cc1 -std=c++1z -verify=ref,both %s -fcxx-exceptions -triple=x86_64-linux-gnu
// RUN: %clang_cc1 -std=c++1z -verify=expected,both %s -fcxx-exceptions -triple=x86_64-linux-gnu -fexperimental-new-constant-interpreter

// both-no-diagnostics
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
}