P0848R3 Conditionally Trivial Special Member Functions

[gwllx]

The EDG implementation of C++20's conditionally trivial special member functions has a number of issues related in particular to ineligible user-provided overloads. The "eligible special member function" criteria is often not evaluated when deciding on triviality.

I noticed this while looking into an issue with std::optional in libstdc++, where e.g. std::optional<int> is not trivially copy/move-constructible or trivially copyable in EDG due to the use of constrained overloads in its base class: gcc/libstdc++-v3/include/std/optional#L546-554.

A reproducer for this case is given in item 1 below. The others are related fallout from investigating this, and I think a fix would/should encompass them too.

1. An ineligible user-provided copy/move function makes derived and containing classes non-trivial

template <typename T> struct B {
  B(const B&); // ineligible: less constrained
  B(const B&) requires true = default;
};
struct S : B<int> {};
struct X { B<int> x; };
static_assert(__is_trivially_copyable(B<int>));           // OK
static_assert(__is_trivially_constructible(S, const S&)); // EDG fails
static_assert(__is_trivially_copyable(S));                // EDG fails
static_assert(__is_trivially_constructible(X, const X&)); // EDG fails

https://godbolt.org/z/7E1eqxeE6

src/class_decl.c#check_special_member_functions sets makes_copy_construction_nontrivial without checking eligibility and this gets copied to the derived/containing class.

2. __is_trivially_copyable fails if an ineligible overload has an exception specification

template <typename T> struct S {
  S(const S&) noexcept; // also with noexcept(false)
  S(const S&) requires true = default;
};
static_assert(__is_trivially_copyable(S<int>)); // EDG fails

https://godbolt.org/z/nj6MzedqY

3. __is_trivially_copyable checks only one nontrivial assignment operator

template <typename T> concept C1 = true;
template <typename T> concept C2 = C1<T> && true; // more constrained
template <typename T> struct S {
  S(const S&) = default;
  S(S&&) = default;
  S& operator=(S&&);                     // eligible, nontrivial
  S& operator=(const S&) requires C1<T>; // ineligible
  S& operator=(const S&) requires C2<T> = default;
};
static_assert(!__is_trivially_copyable(S<int>)); // EDG fails

https://godbolt.org/z/W9WhffcM9

4. A user-provided non-const copy ctor makes derived copy ctors nontrivial

In this case EDG emulates the gcc behaviour (but I believe that is a bug: Bug 87051), even in clang and microsoft modes.

struct S {
  S(const S &) = default;
  S(S &);
};
struct X : S {};
static_assert(__is_trivially_constructible(X, const X&)); // EDG + gcc fail
static_assert(__is_trivially_copyable(X));                // EDG + gcc fail

https://godbolt.org/z/9bYWaY178