[Clang] Implement P0848 (Conditionally Trivial Special Member Functions)

[royjacobson]

Summary

This patch implements P0848 in Clang.

During the instantiation of a C++ class, in Sema::ActOnFields, we evaluate constraints for all the SMFs and compare the constraints to compute the eligibility. We defer the computation of the type's [copy-]trivial bits from addedMember to the eligibility computation, like we did for destructors in D126194. canPassInRegisters is modified as well to better respect the ineligibility of functions.

Note: Because of the non-implementation of DR1734 and DR1496, I treat deleted member functions as 'eligible' for the purpose of [copy-]triviallity. This is unfortunate, but I couldn't think of a way to make this make sense otherwise.

[h-vetinari]

clang/www/cxx_status.html

929–930

Should be class="unreleased", I believe

[royjacobson]

The implementation is more or less complete, but I still need to add an AST test for canPassInRegisters.

clang/www/cxx_status.html

929–930

Thanks, nice catch!

[royjacobson]

Implementation ready for CR.

[cor3ntin]

clang/lib/Sema/SemaDecl.cpp

18038–18044

18091

That could be a separate (static) function

18112

You should probably be explicit about the type here.

18135–18136

Is that codepath ever taken?
I wonder if there is a way to do that that is not n^2. Maybe not.

[cor3ntin]

Thanks for working on that!
The patch looks very good overall

[BRevzin]

clang/test/AST/conditionally-trivial-smfs.cpp

40

It's possible that I just don't understand what these tests actually mean but... where is the test for DefaultConstructorCheck<2> having a deleted default constructor, or DefaultConstructorCheck<3> having a non-defaulted one?

It'd also be worthwhile to have at least one test with constaints that subsume each other instead of being mutually exclusive.

[royjacobson]

Address Corentin's feedback.

[royjacobson]

clang/lib/Sema/SemaDecl.cpp

18135–18136

It's not, I didn't mean to leave it there. Thanks for the catch :)

Generally finding a maximal set in a partial ordering is O(n^2) in the worst case which is when no two objects are comparable.

We could optimize this a bit for some cases: We can group the functions by their kind, and we can skip comparing functions if we already know that they are not maximal. But since the number of SMFs expected in a class is very (1-3) small, I didn't think those possible improvements are worth the extra complexity.

Another possible optimization is we could short-circuit this evaluation if we know that a type is not trivially [copyable], since that's the only outcome we really care about, but then the AST is left in a very awkward state.

clang/test/AST/conditionally-trivial-smfs.cpp

40

Should I check this? Except destructors, the other SMFs are found during overload resolution using the usual lookup that already takes into account delete/default/constraints etc.

This patch is about making sure that we set the triviality attributes correctly according to the eligible functions, so this is what I added tests for.

Most of this testing is done in the sema test, but I need this AST test as well to make sure we get the canPassInRegisters attribute correctly - we're doing some custom processing over the functions without the usual type attributes because there are some weird compatibility edge cases.

[BRevzin]

clang/test/AST/conditionally-trivial-smfs.cpp

40

One of the motivations for the paper is to ensure that like given:

template <class T>
struct optional {
    optional(optional const&) requires copyable<T> && trivially_copyableT> = default;
    optional(optional const&) requires copyable<T>;
};

optional<string> is copyable (but not trivially copyable), optional<int> is trivially copyable, and optional<unique_ptr<int>> isn't copyable. I'm not sure what in here checks if that works.

[royjacobson]

clang/test/AST/conditionally-trivial-smfs.cpp

40

That's more-or-less the check in constrained-special-member-functions.cpp:50, I think.

Didn't acknowledge it in my first response - but yeah, I need some more complicated subsumption test cases

[royjacobson]

Add a test case with more subsumption

[h-vetinari]

clang/docs/ReleaseNotes.rst

157–176

Is that lack of compliance worth a note in cxx_status?

[cor3ntin]

clang/lib/Sema/SemaDecl.cpp

18045

18063

18135–18136

Thanks, I guess this is fine, I cannot really think of a better way either

[cor3ntin]

@aaron.ballman @erichkeane I think this should be on your radar, it would be great to have it in 15. I did review it and I think it looks good but there are enough dragons here that i'd rather have more eye balls on it.

[erichkeane]

I believe the calculation of the constraints here means this isn't conforming with concepts. I believe this means we have to delay calculating the constraint differences until this property is actually queried, and cannot do it early like this has.

clang/lib/Sema/SemaDecl.cpp

18049

I don't think you'd want to compare with equality here, it ends up not desugaring/etc. I believe ASTContext::HasSameType should be what you want.

18051

Probably same here.

18074

This seems problematic, doesn't it? Checking this constraint will (once I figure out how to get deferred instantiation to work) cause instantiation, which can cause issues with incomplete types/CRTP/etc.

I think the result is that we cannot 'calculate' this until it is queried, else we will cause incorrect errors.

[royjacobson]

clang/lib/Sema/SemaDecl.cpp

18045

It's in an anonymous namespace. Is it a Clang convention to use static functions instead? I saw both used in Sema, I think

18049

Good catch! added a test for this.

18074

Making this queried on demand is a relatively big change to how we handle type triviality, so I want to be sure we actually need to do this to be conformant.

When I started working on this I checked what GCC does and it instantiates those constraints during class completion as well. For example this CRTP case: https://godbolt.org/z/EdoYf96zq. MSVC seem to do it as well.

So maybe it's OK to check the constraints of SMFs specifically?

18135–18136

Ok, did another look on this and it's because AnotherMethodIsMoreConstrained is the output of IsAtLeastAsConstrained, so that's why the extra check. Added it back :)

[royjacobson]

Fixed the tests, fixed the type comparison checks.

[cor3ntin]

clang/lib/Sema/SemaDecl.cpp

18074

I think this is done on completeness already in this patch, unless i misunderstood the code.
I don't think doing it on demand is a great direction, as this does not only affect type traits but also code gen, etc. It would create instanciations in unexpected places. wouldn't it.
Does the standard has wording suggesting it should be done later than on type completeness?

[erichkeane]

clang/lib/Sema/SemaDecl.cpp

18074

The problem, at least for the deferred concepts, is that it breaks in the CRTP as required to implement ranges. So something like this: https://godbolt.org/z/hPqrcqhx5 breaks.

I'm currently working to 'fix' that, so if this patch causes us to 'check' constraints early, it'll go back to breaking that example. The example that Roy showed seems to show that it is actually checking 'delayed' right now (that is, on demand) in GCC/MSVC. I don't know of the consequence/standardeeze that causes that though.

[cor3ntin]

clang/lib/Sema/SemaDecl.cpp

18074

Thanks,
Follow up stupid question then, do we care about the triviality of dependant types?
I think doing the check on complete non-dependant types might be a better solution than trying to do it lazily on triviality checks?

[erichkeane]

clang/lib/Sema/SemaDecl.cpp

18074

I would think it would be not a problem on non-dependent types. BUT concepts are only allowed on templated functions (note not only on function-templates!) anyway, so I don't think this would be a problem?

[royjacobson]

clang/lib/Sema/SemaDecl.cpp

18074

Erich, I'm a bit confused by your response. I think my example demonstrates that for default constructors (and other SMFs) GCC and MSVC instantiate the constraints on class completion and not on demand. This is what I would like to do as well, if we don't have a good reason not to. (For destructors, performing the checks is even explicit in the standard.)

Not doing this can introduce some REALLY bad edge cases. What does this do if we defer the triviality computation?

c++

template <class T>
struct Base<T> {
  Base() = default;
  Base() requires (!std::is_trivial_v<T>);
};

struct Child : Base<Child> { };

We defer the computation of the constraints on Base, and complete Child somehow, but if Child is complete then std::is_trivial_v<Child> should be well-formed, right? But we get a logical contradiction instead.

[erichkeane]

clang/lib/Sema/SemaDecl.cpp

18074

Erich, I'm a bit confused by your response

It is entirely possible we're talking past eachother, or misunderstanding eachothers examples. I'm totally open to that being part of this issue.

In that example, if we calculate the triviality at 'Base Class completion', Child is not yet complete, right? So the is_trivial_v would be UB. If you instead require sizeof(T), we typically give a diagnostic.

In this case, you'd at MINIMUM have to wait to calculate the requires-clause until after Child is complete. And it isn't clear to me that we're delaying it until then.

That is what I intend to show with: https://godbolt.org/z/1YjsdY73P

As far as doing it 'on demand', I definitely see your circular argument here, but I think the is_trivial_v test is UB if we calculate it at `Base' completion.

[royjacobson]

clang/lib/Sema/SemaDecl.cpp

18074

I'm arguing for checking the constraints at the completion of Base, and for making is_trivial_v/sizeof ill formed in this context.

Your GCC example is a bit misleading, I think. They check the sizeof(T) > 0 constraint at the completion of Base but they just swallow the error and declare the constraint unsatisfied or something. They should've probably issued a diagnostic or something. But if you look at which constructor they choose, they choose the unconstrained one: https://godbolt.org/z/rKj4q5Yx9

[erichkeane]

clang/lib/Sema/SemaDecl.cpp

18074

Hmm. I think based on that example, I agree with you. We can do the instantiation and mark it unviable at the end of Base. I think I'm getting confused by Clang's lack of deferred instantiation in this part.

Thanks for talking this through with me!

I AM concerned about how this will work with my deferred instantiations, so a test that validates that (and has a FIXME that shows it is broken right now) would be appreciated.

[cor3ntin]

clang/lib/Sema/SemaDecl.cpp

18074

I'm arguing for checking the constraints at the completion of Base, and for making is_trivial_v/sizeof ill formed in this context.

Your GCC example is a bit misleading, I think. They check the sizeof(T) > 0 constraint at the completion of Base but they just swallow the error and declare the constraint unsatisfied or something. They should've probably issued a diagnostic or something. But if you look at which constructor they choose, they choose the unconstrained one: https://godbolt.org/z/rKj4q5Yx9

I don't think gcc is wrong per http://eel.is/c++draft/temp.constr.constr#temp.constr.op-5.sentence-3
The constrained overload is sfinea away silently, no diagnostic should be emitted.
It's no different from https://godbolt.org/z/ThMPrhs93 , for example

[royjacobson]

Add a test for the CRTP constraints timings

[royjacobson]

clang/lib/Sema/SemaDecl.cpp

18074

I added the test, could you take a look and tell me if that's what you meant or if you want some changes? @erichkeane
I hope it isn't disruptive to the deferred patch itself, it's a bit concerning indeed but I'm moderately optimistic :)

@cor3ntin thanks for the explanation!

[cor3ntin]

clang/test/SemaCXX/constrained-special-member-functions.cpp

104

Have you rebased since D127593 landed?

[royjacobson]

clang/test/SemaCXX/constrained-special-member-functions.cpp

104

Yes. It's related but it's different DRs. And unfortunately they seem much more ABI breaking to fix - GCC don't implement them, for example

[shafik]

clang/lib/AST/DeclCXX.cpp

899

I think we should spell out Special Member Function instead of using SMF

clang/lib/Sema/SemaDecl.cpp

18050

What happens if we have further parameters with default arguments? Unless I am missing something they are still special member functions but the proposal does not seem to cover them.

[royjacobson]

clang/lib/Sema/SemaDecl.cpp

18050

That's an excellent question.

I'm not sure what to do about default arguments. In a context where the additional parameters matter, you're not using them as constructors anymore, right? So why would this affect the type traits?
On the one hand [over.match.best] is against this idea of comparing constraints when the parameters differ. So also every context where this actually matters the overload resolution would probably be ambiguous anyway?

@BRevzin, what do you think? Is the wording intentional to include copy/move constructors with default arguments as well?

I checked with GCC and they seem to handle default arguments separately: https://godbolt.org/z/1ch3M7MjP

[royjacobson]

Rebase on main and slightly update docs.

[royjacobson]

@erichkeane @cor3ntin

If you have time for review right now, I think it's reasonably ready and I would still like to merge it this week so it can land in Clang15.

[royjacobson]

Rebase on main and re-target LLVM16 in cxx_status

[royjacobson]

Rebase

[royjacobson]

clang/docs/ReleaseNotes.rst

157–176

I'm not very opinionated about this, but I tend to not significant enough. I mean, 7 years later and only MSVC have even bothered to implement them.

clang/lib/Sema/SemaDecl.cpp

18050

FWIW, I filed https://github.com/cplusplus/CWG/issues/110

I'm not on the reflector myself, so I don't know if there's been a follow-up there.

[usaxena95]

I would like to see this land. This also fixes https://github.com/llvm/llvm-project/issues/57046.

Are there any pending concerns of the reviewers which we need to address ? Happy to help in any way to move this patch forward.

CC: @erichkeane @cor3ntin

[cor3ntin]

This looks good to me.

I *think* landing things without doing silent sfinae for incomplete types is okay-ish, but I'd like to here from other folks.

@royjacobson Have you looked into that? Do you know how involved would it be?

Either way, we should make sure that if that bit is dealt with separately, we have an issue or something to track it, maybe a note in cxx_status.

clang/docs/ReleaseNotes.rst

157–176

We might has well, I think it's a good way to not lose track of it.

clang/lib/Sema/SemaDecl.cpp

18050

Yes, i think it's reasonable to not concerns ourselves with default parameters until wg21 decides otherwise

clang/test/SemaCXX/constrained-special-member-functions.cpp

201

Have you been able to investigate that?

[royjacobson]

Add disclaimer to cxx_status about the standing DRs.

[royjacobson]

clang/docs/ReleaseNotes.rst

157–176

Added as a footnote.

clang/test/SemaCXX/constrained-special-member-functions.cpp

201

No, I haven't looked at this - we already have a bunch of those all over the code, see https://github.com/llvm/llvm-project/issues/48857

So I don't think this is about this patch specifically - I just call Sema::CheckFunctionConstraints and inherit its current behavior.

[cor3ntin]

@aaron.ballman I think this looks good, you want to double check?

[aaron.ballman]

clang/lib/AST/DeclCXX.cpp

1443–1447

clang/lib/Frontend/InitPreprocessor.cpp

680

Does any of the not-yet-implemented bits (including from the DRs) impact the ability to use conditionally trivial special member functions? If so, we might want to be careful about aggressively bumping this value. (It's more palatable for us to come back and bump the value later than it is for us to claim we implement something fully when we know we don't -- the goal of the feature test macros is so that users don't have to resort to compiler version checks, which is what users have to use when they fall into that "not fully implemented" space.)

clang/lib/Sema/SemaDecl.cpp

18045

Yeah, we prefer putting types into an anonymous namespace but making functions static: https://llvm.org/docs/CodingStandards.html#anonymous-namespaces

18065

You may want to run the patch through clang-format before you land, just to be sure (https://clang.llvm.org/docs/ClangFormat.html#script-for-patch-reformatting).

clang/test/AST/conditionally-trivial-smfs.cpp

344

Please add a newline to the end of the file.

clang/www/cxx_status.html

929–930

FWIW, the way we've started handling this in recent history is to use "partial" and a details tag instead of a footnote, as in: https://github.com/llvm/llvm-project/blob/main/clang/www/cxx_status.html#L915.

[usaxena95]

Can you please also add consteval related test case (mentioned in https://github.com/llvm/llvm-project/issues/57046#issuecomment-1211665079) to cxx2a-consteval.cpp

[royjacobson]

Address Aaron's comments, add the consteval test.

[royjacobson]

clang/lib/Frontend/InitPreprocessor.cpp

680

I don't think they're very significant, and the benefits of enabling it seem large enough for me - for example, std::expected works with libstdc++ and passes their unit tests but is gated by this macro.

We still have a non-trivial amount of concept bugs to go over, but I support enabling this.

clang/www/cxx_status.html

929–930

It felt a bit too long of an explanation to put in the tiny table box, but I don't feel very strongly about it either way.

[cor3ntin]

clang/lib/Frontend/InitPreprocessor.cpp

680

I think it's better to be conservative, It's the lesser of two not great options.
I'm hoping we can get to fix the issues in the clang 16 cycle , but in the meantime we should not claim conformance if we are not, in fact, conforming.

clang/www/cxx_status.html

929–930

I agree with Aaron.
I think it's better to be consistent, the column resize when the details are expanded.

[aaron.ballman]

clang/lib/Frontend/InitPreprocessor.cpp

680

We still have a non-trivial amount of concept bugs to go over, but I support enabling this.

I think we should specify the updated macro value only after we think concepts have no known major issues with them. (Unknown issues happen and there's not much we can do about them, this is more that we shouldn't specify that we conform to a particular feature test macro when we knowingly still don't have it right yet.)

[erichkeane]

clang/lib/Frontend/InitPreprocessor.cpp

680

Yeah, I don't think we can set this until we can at least compile a basic libstdc++ ranges use, which the deferred instantiation still holds up. That would be my 'bare minimum' test for whether we can set that.

[royjacobson]

clang/lib/Frontend/InitPreprocessor.cpp

680

But we're already defining the __cpp_concepts macro, even with the current known bugs. The version bump, introduced by https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2493r0.html is specifically about the conditionally trivial SMFs paper.

We can decide that we want the version bump to mean 'no more known concept bugs in clang' instead. But that would extend the meaning of the macro and would be confusing to users who want to rely on the documented, intended meaning of the version.

Also I think telling library writers 'this feature works now, but we didn't set its feature test macro' will make them use more compiler version checks, not less.

[erichkeane]

clang/lib/Frontend/InitPreprocessor.cpp

680

The feature test macros aren't supposed to mean "I support the feature from the paper that updated it". They are intended to mean "I support the feature from the paper that updated it AND everything before it".

I don't believe we need to be bug-free, but something as extreme as "we can't compile a large number of uses of concepts because we don't implement a central design consideration" (which, btw, was clarified in Core after the 2019 date IIRC) means we shouldn't be updating this.

[royjacobson]

Remove the __cpp_concepts version bump.

[royjacobson]

clang/lib/Frontend/InitPreprocessor.cpp

680

It seems like I'm in the minority here, so I removed the version change and added a comment with a reference to this discussion to the code.

[aaron.ballman]

clang/lib/Frontend/InitPreprocessor.cpp

680

But we're already defining the __cpp_concepts macro, even with the current known bugs.

FWIW, I consider that a bug. We should have never defined this macro in the first place -- we're not there yet on the base feature.

I don't believe we need to be bug-free, but something as extreme as "we can't compile a large number of uses of concepts because we don't implement a central design consideration" (which, btw, was clarified in Core after the 2019 date IIRC) means we shouldn't be updating this.

+1

[royjacobson]

Clarify ambiguous doc.

[cor3ntin]

I would wait for @aaron.ballman or @erichkeane to sign off on it, but this looks good to me.
Thanks again for working on this!

[aaron.ballman]

LGTM, thank you for this!!

[royjacobson]

Rebase on main.

[haowei]

Hi,

We are seeing build failures on Fuchsia build bots after this change was landed. and we suspect this patch causes clang to miscompile certain code. I filed bug https://github.com/llvm/llvm-project/issues/57351 and included a reproducer. Could you take a look? If it is confirmed to be a bug and take long time to fix, could you revert this change please?

[royjacobson]

Default constructors can be template functions. Update patch to handle them correctly, and add
asserts to LookupSpecialMember that can catch similar problems.

[royjacobson]

I added handling of FunctionTemplateDecls in SemaDecl because they can be default constructors. This caused errors with std::pair for example - it has two enable_ifs constructors to control explicit/implicit construction.

I will try committing again if the pre-commit CI finishes green. Running nm on the provided reproducer from FuchsiaOS resulted in the names list.

[cor3ntin]

clang/test/AST/conditionally-trivial-smfs-1.cpp

1 ↗

(On Diff #455686)

can you rename that file back to clang/test/AST/conditionally-trivial-smfs.cpp ? Thanks!

[royjacobson]

Rename file

[royjacobson]

We call LookupSpecialMember before we compute eligibility, so the assert fails. Remove it.

[royjacobson]

Formatting.

clang/docs/ReleaseNotes.rst

 C++ Language Changes in Clang
 -----------------------------
 
 - Implemented DR692, DR1395 and DR1432. Use the ``-fclang-abi-compat=15`` option
   to get the old partial ordering behavior regarding packs.
 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 - Support capturing structured bindings in lambdas
   (`P1091R3 <https://wg21.link/p1091r3>`_ and `P1381R1 <https://wg21.link/P1381R1>`).
   This fixes issues `GH52720 <https://github.com/llvm/llvm-project/issues/52720>`_,
   `GH54300 <https://github.com/llvm/llvm-project/issues/54300>`_,
   `GH54301 <https://github.com/llvm/llvm-project/issues/54301>`_,
   and `GH49430 <https://github.com/llvm/llvm-project/issues/49430>`_.
 - Consider explicitly defaulted constexpr/consteval special member function
   template instantiation to be constexpr/consteval even though a call to such
   a function cannot appear in a constant expression.
   (C++14 [dcl.constexpr]p6 (CWG DR647/CWG DR1358))
 - Correctly defer dependent immediate function invocations until template instantiation.
   This fixes `GH55601 <https://github.com/llvm/llvm-project/issues/55601>`_.
+- Implemented "Conditionally Trivial Special Member Functions" (`P0848 <https://wg21.link/p0848r3>`_).
+  Note: The handling of deleted functions is not yet compliant, as Clang
+  does not implement `DR1496 <https://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1496>`_
+  and `DR1734 <https://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1734>`_.
 
 
 
 C++2b Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 CUDA/HIP Language Changes in Clang
 ----------------------------------
 
 Objective-C Language Changes in Clang
 -------------------------------------

clang/lib/AST/DeclCXX.cpp

if (SMKind) {
         // aggregates could not have any constructors, clear it even for an
         // explicitly defaulted or deleted constructor.
         // type is technically an aggregate in C++0x since it wouldn't be in 03.
         //
         // Also, a user-declared move assignment operator makes a class non-POD.
         // This is an extension in C++03.
         data().PlainOldData = false;
       }
-      // We delay updating destructor relevant properties until
-      // addedSelectedDestructor.
-      // FIXME: Defer this for the other special member functions as well.
+      // When instantiating a class, we delay updating the destructor and
+      // triviality properties of the class until selecting a destructor and
+      // computing the eligibility of its special member functions. This is
+      // because there might be function constraints that we need to evaluate
+      // and compare later in the instantiation.
       if (!Method->isIneligibleOrNotSelected()) {
         addedEligibleSpecialMemberFunction(Method, SMKind);
       }
     }
 
     return;
   }
 
if (!D->isTrivial() || D->getAccess() != AS_public || D->isDeleted())
       data().HasIrrelevantDestructor = false;
   } else if (D->isCopyAssignmentOperator())
     SMKind |= SMF_CopyAssignment;
   else if (D->isMoveAssignmentOperator())
     SMKind |= SMF_MoveAssignment;
 
   // Update which trivial / non-trivial special members we have.
   // addedMember will have skipped this step for this member.
+  if (!D->isIneligibleOrNotSelected()) {
     if (D->isTrivial())
       data().HasTrivialSpecialMembers |= SMKind;
     else
       data().DeclaredNonTrivialSpecialMembers |= SMKind;
   }
+}
 
 void CXXRecordDecl::setCaptures(ASTContext &Context,
                                 ArrayRef<LambdaCapture> Captures) {
   CXXRecordDecl::LambdaDefinitionData &Data = getLambdaData();
 
   // Copy captures.
   Data.NumCaptures = Captures.size();
   Data.NumExplicitCaptures = 0;

clang/lib/Frontend/InitPreprocessor.cpp

static void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts,
   if (LangOpts.AlignedAllocation && !LangOpts.AlignedAllocationUnavailable)
     Builder.defineMacro("__cpp_aligned_new", "201606L");
   if (LangOpts.RelaxedTemplateTemplateArgs)
     Builder.defineMacro("__cpp_template_template_args", "201611L");
 
   // C++20 features.
   if (LangOpts.CPlusPlus20) {
     //Builder.defineMacro("__cpp_aggregate_paren_init", "201902L");
+    // P0848 is implemented, but we're still waiting for other concepts
+    // issues to be addressed before bumping __cpp_concepts up to 202002L.
+    // Refer to the discussion of this at https://reviews.llvm.org/D128619.
     Builder.defineMacro("__cpp_concepts", "201907L");
     Builder.defineMacro("__cpp_conditional_explicit", "201806L");
     //Builder.defineMacro("__cpp_consteval", "201811L");
     Builder.defineMacro("__cpp_constexpr_dynamic_alloc", "201907L");
     Builder.defineMacro("__cpp_constinit", "201907L");
     Builder.defineMacro("__cpp_impl_coroutine", "201902L");
     Builder.defineMacro("__cpp_designated_initializers", "201707L");
     Builder.defineMacro("__cpp_impl_three_way_comparison", "201907L");
     //Builder.defineMacro("__cpp_modules", "201907L");

clang/lib/Sema/SemaDecl.cpp

Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext),
                               Context.CharTy,
                               Context.getTrivialTypeSourceInfo(Context.CharTy,
                                                                DeclLoc),
                               ObjCIvarDecl::Private, BW,
                               true);
   AllIvarDecls.push_back(Ivar);
 }
 
-namespace {
 /// [class.dtor]p4:
 ///   At the end of the definition of a class, overload resolution is
 ///   performed among the prospective destructors declared in that class with
 ///   an empty argument list to select the destructor for the class, also
 ///   known as the selected destructor.
 ///
 /// We do the overload resolution here, then mark the selected constructor in the AST.
 /// Later CXXRecordDecl::getDestructor() will return the selected constructor.
-void ComputeSelectedDestructor(Sema &S, CXXRecordDecl *Record) {
+static void ComputeSelectedDestructor(Sema &S, CXXRecordDecl *Record) {
   if (!Record->hasUserDeclaredDestructor()) {
     return;
   }
 
   SourceLocation Loc = Record->getLocation();
   OverloadCandidateSet OCS(Loc, OverloadCandidateSet::CSK_Normal);
 
   for (auto *Decl : Record->decls()) {
if (Msg) {
     // It's a bit hacky: At this point we've raised an error but we want the
     // rest of the compiler to continue somehow working. However almost
     // everything we'll try to do with the class will depend on there being a
     // destructor. So let's pretend the first one is selected and hope for the
     // best.
     Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(OCS.begin()->Function));
   }
 }
-} // namespace
+
+/// [class.mem.special]p5
+/// Two special member functions are of the same kind if:
+/// - they are both default constructors,
+/// - they are both copy or move constructors with the same first parameter
+///   type, or
+/// - they are both copy or move assignment operators with the same first
+///   parameter type and the same cv-qualifiers and ref-qualifier, if any.
+static bool AreSpecialMemberFunctionsSameKind(ASTContext &Context,
+                                              CXXMethodDecl *M1,
+                                              CXXMethodDecl *M2,
+                                              Sema::CXXSpecialMember CSM) {
+  if (CSM == Sema::CXXDefaultConstructor)
+    return true;
+  if (!Context.hasSameType(M1->getParamDecl(0)->getType(),
+                           M2->getParamDecl(0)->getType()))
+    return false;
+  if (!Context.hasSameType(M1->getThisType(), M2->getThisType()))
+    return false;
+
+  return true;
+}
+
+/// [class.mem.special]p6:
+/// An eligible special member function is a special member function for which:
+/// - the function is not deleted,
+/// - the associated constraints, if any, are satisfied, and
+/// - no special member function of the same kind whose associated constraints
+///   [CWG2595], if any, are satisfied is more constrained.
+static void SetEligibleMethods(Sema &S, CXXRecordDecl *Record,
+                               ArrayRef<CXXMethodDecl *> Methods,
+                               Sema::CXXSpecialMember CSM) {
+  SmallVector<bool, 4> SatisfactionStatus;
+
+  for (CXXMethodDecl *Method : Methods) {
+    const Expr *Constraints = Method->getTrailingRequiresClause();
+    if (!Constraints)
+      SatisfactionStatus.push_back(true);
+    else {
+      ConstraintSatisfaction Satisfaction;
+      if (S.CheckFunctionConstraints(Method, Satisfaction))
+        SatisfactionStatus.push_back(false);
+      else
+        SatisfactionStatus.push_back(Satisfaction.IsSatisfied);
+    }
+  }
+
+  for (size_t i = 0; i < Methods.size(); i++) {
+    if (!SatisfactionStatus[i])
+      continue;
+    CXXMethodDecl *Method = Methods[i];
+    const Expr *Constraints = Method->getTrailingRequiresClause();
+    bool AnotherMethodIsMoreConstrained = false;
+    for (size_t j = 0; j < Methods.size(); j++) {
+      if (i == j || !SatisfactionStatus[j])
+        continue;
+      CXXMethodDecl *OtherMethod = Methods[j];
+      if (!AreSpecialMemberFunctionsSameKind(S.Context, Method, OtherMethod,
+                                             CSM))
+        continue;
+
+      const Expr *OtherConstraints = OtherMethod->getTrailingRequiresClause();
+      if (!OtherConstraints)
+        continue;
+      if (!Constraints) {
+        AnotherMethodIsMoreConstrained = true;
+        break;
+      }
+      if (S.IsAtLeastAsConstrained(OtherMethod, {OtherConstraints}, Method,
+                                   {Constraints},
+                                   AnotherMethodIsMoreConstrained)) {
+        // There was an error with the constraints comparison. Exit the loop
+        // and don't consider this function eligible.
+        AnotherMethodIsMoreConstrained = true;
+      }
+      if (AnotherMethodIsMoreConstrained)
+        break;
+    }
+    // FIXME: Do not consider deleted methods as eligible after implementing
+    // DR1734 and DR1496.
+    if (!AnotherMethodIsMoreConstrained) {
+      Method->setIneligibleOrNotSelected(false);
+      Record->addedEligibleSpecialMemberFunction(Method, 1 << CSM);
+    }
+  }
+}
+
+static void ComputeSpecialMemberFunctionsEligiblity(Sema &S,
+                                                    CXXRecordDecl *Record) {
+  SmallVector<CXXMethodDecl *, 4> DefaultConstructors;
+  SmallVector<CXXMethodDecl *, 4> CopyConstructors;
+  SmallVector<CXXMethodDecl *, 4> MoveConstructors;
+  SmallVector<CXXMethodDecl *, 4> CopyAssignmentOperators;
+  SmallVector<CXXMethodDecl *, 4> MoveAssignmentOperators;
+
+  for (auto *Decl : Record->decls()) {
+    auto *MD = dyn_cast<CXXMethodDecl>(Decl);
+    if (!MD) {
+      auto *FTD = dyn_cast<FunctionTemplateDecl>(Decl);
+      if (FTD)
+        MD = dyn_cast<CXXMethodDecl>(FTD->getTemplatedDecl());
+    }
+    if (!MD)
+      continue;
+    if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
+      if (CD->isInvalidDecl())
+        continue;
+      if (CD->isDefaultConstructor())
+        DefaultConstructors.push_back(MD);
+      else if (CD->isCopyConstructor())
+        CopyConstructors.push_back(MD);
+      else if (CD->isMoveConstructor())
+        MoveConstructors.push_back(MD);
+    } else if (MD->isCopyAssignmentOperator()) {
+      CopyAssignmentOperators.push_back(MD);
+    } else if (MD->isMoveAssignmentOperator()) {
+      MoveAssignmentOperators.push_back(MD);
+    }
+  }
+
+  SetEligibleMethods(S, Record, DefaultConstructors,
+                     Sema::CXXDefaultConstructor);
+  SetEligibleMethods(S, Record, CopyConstructors, Sema::CXXCopyConstructor);
+  SetEligibleMethods(S, Record, MoveConstructors, Sema::CXXMoveConstructor);
+  SetEligibleMethods(S, Record, CopyAssignmentOperators,
+                     Sema::CXXCopyAssignment);
+  SetEligibleMethods(S, Record, MoveAssignmentOperators,
+                     Sema::CXXMoveAssignment);
+}
 
 void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl,
                        ArrayRef<Decl *> Fields, SourceLocation LBrac,
                        SourceLocation RBrac,
                        const ParsedAttributesView &Attrs) {
   assert(EnclosingDecl && "missing record or interface decl");
 
   // If this is an Objective-C @implementation or category and we have
case Decl::ObjCImplementation:
         ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
       break;
     }
   }
 
   RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
   CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(EnclosingDecl);
 
-  if (CXXRecord && !CXXRecord->isDependentType())
-    ComputeSelectedDestructor(*this, CXXRecord);
-
   // Start counting up the number of named members; make sure to include
   // members of anonymous structs and unions in the total.
   unsigned NumNamedMembers = 0;
   if (Record) {
     for (const auto *I : Record->decls()) {
       if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
         if (IFD->getDeclName())
           ++NumNamedMembers;
if (CXXRecord) {
 
                 Record->setInvalidDecl();
               }
             }
             CXXRecord->completeDefinition(&FinalOverriders);
             Completed = true;
           }
         }
+        ComputeSelectedDestructor(*this, CXXRecord);
+        ComputeSpecialMemberFunctionsEligiblity(*this, CXXRecord);
       }
     }
 
     if (!Completed)
       Record->completeDefinition();
 
     // Handle attributes before checking the layout.
     ProcessDeclAttributeList(S, Record, Attrs);

clang/lib/Sema/SemaDeclCXX.cpp

static bool canPassInRegisters(Sema &S, CXXRecordDecl *D,
   if (CCK == TargetInfo::CCK_ClangABI4OrPS4)
     return !D->hasNonTrivialDestructorForCall() &&
            !D->hasNonTrivialCopyConstructorForCall();
 
   if (CCK == TargetInfo::CCK_MicrosoftWin64) {
     bool CopyCtorIsTrivial = false, CopyCtorIsTrivialForCall = false;
     bool DtorIsTrivialForCall = false;
 
-    // If a class has at least one non-deleted, trivial copy constructor, it
+    // If a class has at least one eligible, trivial copy constructor, it
     // is passed according to the C ABI. Otherwise, it is passed indirectly.
     //
     // Note: This permits classes with non-trivial copy or move ctors to be
     // passed in registers, so long as they *also* have a trivial copy ctor,
     // which is non-conforming.
     if (D->needsImplicitCopyConstructor()) {
       if (!D->defaultedCopyConstructorIsDeleted()) {
         if (D->hasTrivialCopyConstructor())
           CopyCtorIsTrivial = true;
         if (D->hasTrivialCopyConstructorForCall())
           CopyCtorIsTrivialForCall = true;
       }
     } else {
       for (const CXXConstructorDecl *CD : D->ctors()) {
-        if (CD->isCopyConstructor() && !CD->isDeleted()) {
+        if (CD->isCopyConstructor() && !CD->isDeleted() &&
+            !CD->isIneligibleOrNotSelected()) {
           if (CD->isTrivial())
             CopyCtorIsTrivial = true;
           if (CD->isTrivialForCall())
             CopyCtorIsTrivialForCall = true;
         }
       }
     }
 

clang/lib/Sema/SemaLookup.cpp

if (RD->needsImplicitDestructor()) {
         DeclareImplicitDestructor(RD);
       });
     }
     CXXDestructorDecl *DD = RD->getDestructor();
     Result->setMethod(DD);
     Result->setKind(DD && !DD->isDeleted()
                         ? SpecialMemberOverloadResult::Success
                         : SpecialMemberOverloadResult::NoMemberOrDeleted);
+    assert(!DD->isIneligibleOrNotSelected() && "Method is ineligible.");
     return *Result;
   }
 
   // Prepare for overload resolution. Here we construct a synthetic argument
   // if necessary and make sure that implicit functions are declared.
   CanQualType CanTy = Context.getCanonicalType(Context.getTagDeclType(RD));
   DeclarationName Name;
   Expr *Arg = nullptr;
if (CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(Cand->getUnderlyingDecl())) {
       assert(isa<UsingDecl>(Cand.getDecl()) &&
              "illegal Kind of operator = Decl");
     }
   }
 
   OverloadCandidateSet::iterator Best;
   switch (OCS.BestViableFunction(*this, LookupLoc, Best)) {
     case OR_Success:
+      assert(!Best->Function->isIneligibleOrNotSelected() && "Method is ineligible.");
       Result->setMethod(cast<CXXMethodDecl>(Best->Function));
       Result->setKind(SpecialMemberOverloadResult::Success);
       break;
 
     case OR_Deleted:
       Result->setMethod(cast<CXXMethodDecl>(Best->Function));
       Result->setKind(SpecialMemberOverloadResult::NoMemberOrDeleted);
       break;

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(
   if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
     Method = CXXConstructorDecl::Create(
         SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
         InstantiatedExplicitSpecifier, Constructor->UsesFPIntrin(),
         Constructor->isInlineSpecified(), false,
         Constructor->getConstexprKind(), InheritedConstructor(),
         TrailingRequiresClause);
     Method->setRangeEnd(Constructor->getEndLoc());
+    if (Constructor->isDefaultConstructor() ||
+        Constructor->isCopyOrMoveConstructor())
+      Method->setIneligibleOrNotSelected(true);
   } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
     Method = CXXDestructorDecl::Create(
         SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
         Destructor->UsesFPIntrin(), Destructor->isInlineSpecified(), false,
         Destructor->getConstexprKind(), TrailingRequiresClause);
     Method->setIneligibleOrNotSelected(true);
     Method->setRangeEnd(Destructor->getEndLoc());
     Method->setDeclName(SemaRef.Context.DeclarationNames.getCXXDestructorName(
         SemaRef.Context.getCanonicalType(
             SemaRef.Context.getTypeDeclType(Record))));
   } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
     Method = CXXConversionDecl::Create(
         SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
         Conversion->UsesFPIntrin(), Conversion->isInlineSpecified(),
         InstantiatedExplicitSpecifier, Conversion->getConstexprKind(),
         Conversion->getEndLoc(), TrailingRequiresClause);
   } else {
     StorageClass SC = D->isStatic() ? SC_Static : SC_None;
     Method = CXXMethodDecl::Create(
         SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo, SC,
         D->UsesFPIntrin(), D->isInlineSpecified(), D->getConstexprKind(),
         D->getEndLoc(), TrailingRequiresClause);
+    if (D->isMoveAssignmentOperator() || D->isCopyAssignmentOperator())
+      Method->setIneligibleOrNotSelected(true);
   }
 
   if (D->isInlined())
     Method->setImplicitlyInline();
 
   if (QualifierLoc)
     Method->setQualifierInfo(QualifierLoc);
 

clang/test/AST/conditionally-trivial-smfs-2.cpp

+// RUN: %clang_cc1 -std=c++20 -triple x86_64-pc-linux %s -ast-dump | FileCheck %s
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-pc-win32 %s -ast-dump | FileCheck %s
+
+template<class X>
+struct DefaultConstructibleWithTemplate {
+    template<class T = int>
+    DefaultConstructibleWithTemplate();
+};
+
+void f() {
+    DefaultConstructibleWithTemplate<int> x;
+}
+
+// CHECK: | `-ClassTemplateSpecializationDecl {{.*}} struct DefaultConstructibleWithTemplate definition
+// CHECK: |   | |-CXXConstructorDecl {{.*}} DefaultConstructibleWithTemplate 'void ()'

clang/test/AST/conditionally-trivial-smfs.cpp

+// RUN: %clang_cc1 -std=c++20 -triple x86_64-pc-linux -ast-dump=json %s | FileCheck %s --check-prefixes=CHECK,LIN
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-pc-win32 -ast-dump=json %s | FileCheck %s
+
+// This test validates that we compute correct AST properties of classes with
+// conditionally trivial special member functions.
+
+template <int N>
+struct DefaultConstructorCheck {
+  DefaultConstructorCheck() requires(N == 1) = default;
+  DefaultConstructorCheck() requires(N == 2) = delete;
+  DefaultConstructorCheck() requires(N == 3);
+  DefaultConstructorCheck();
+};
+
+
+template struct DefaultConstructorCheck<1>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "canPassInRegisters": true,
+// CHECK-NEXT:          "copyAssign": {
+
+// CHECK:               "defaultCtor": {
+// CHECK-NEXT:            "defaultedIsConstexpr": true,
+// CHECK-NEXT:            "exists": true,
+// CHECK-NEXT:            "isConstexpr": true,
+// CHECK-NEXT:            "trivial": true,
+// CHECK-NEXT:            "userProvided": true
+// CHECK-NEXT:          },
+
+// CHECK:               "hasConstexprNonCopyMoveConstructor": true,
+// CHECK-NEXT:          "hasUserDeclaredConstructor": true,
+// CHECK-NEXT:          "isEmpty": true,
+// CHECK-NEXT:          "isLiteral": true,
+// CHECK-NEXT:          "isStandardLayout": true,
+// CHECK-NEXT:          "isTrivial": true,
+// CHECK-NEXT:          "isTriviallyCopyable": true,
+
+template struct DefaultConstructorCheck<2>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "canPassInRegisters": true,
+// CHECK-NEXT:          "copyAssign": {
+
+// CHECK:               "defaultCtor": {
+// CHECK-NEXT:            "defaultedIsConstexpr": true,
+// CHECK-NEXT:            "exists": true,
+// CHECK-NEXT:            "isConstexpr": true,
+// CHECK-NEXT:            "trivial": true,
+// CHECK-NEXT:            "userProvided": true
+// CHECK-NEXT:          },
+
+// CHECK:               "hasConstexprNonCopyMoveConstructor": true,
+// CHECK-NEXT:          "hasUserDeclaredConstructor": true,
+// CHECK-NEXT:          "isEmpty": true,
+// CHECK-NEXT:          "isLiteral": true,
+// CHECK-NEXT:          "isStandardLayout": true,
+// CHECK-NEXT:          "isTrivial": true,
+// CHECK-NEXT:          "isTriviallyCopyable": true,
+
+
+template struct DefaultConstructorCheck<3>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "canPassInRegisters": true,
+// CHECK-NEXT:          "copyAssign": {
+
+// CHECK:               "defaultCtor": {
+// CHECK-NEXT:            "defaultedIsConstexpr": true,
+// CHECK-NEXT:            "exists": true,
+// CHECK-NEXT:            "isConstexpr": true,
+// CHECK-NEXT:            "nonTrivial": true,
+// CHECK-NEXT:            "userProvided": true
+// CHECK-NEXT:          },
+
+// CHECK:               "hasConstexprNonCopyMoveConstructor": true,
+// CHECK-NEXT:          "hasUserDeclaredConstructor": true,
+// CHECK-NEXT:          "isEmpty": true,
+// CHECK-NEXT:          "isLiteral": true,
+// CHECK-NEXT:          "isStandardLayout": true,
+// CHECK-NEXT:          "isTriviallyCopyable": true,
+
+template <int N>
+struct CopyConstructorCheck {
+  CopyConstructorCheck(const CopyConstructorCheck&) requires(N == 1) = default;
+  CopyConstructorCheck(const CopyConstructorCheck&) requires(N == 2) = delete;
+  CopyConstructorCheck(const CopyConstructorCheck&) requires(N == 3);
+  CopyConstructorCheck(const CopyConstructorCheck&);
+};
+
+
+template struct CopyConstructorCheck<1>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "canPassInRegisters": true,
+// CHECK-NEXT:          "copyAssign": {
+
+// CHECK:               "copyCtor": {
+// CHECK-NEXT:            "hasConstParam": true,
+// CHECK-NEXT:            "implicitHasConstParam": true,
+// CHECK-NEXT:            "trivial": true,
+// CHECK-NEXT:            "userDeclared": true
+// CHECK-NEXT:          },
+
+// CHECK:               "hasUserDeclaredConstructor": true,
+// CHECK-NEXT:          "isEmpty": true,
+// CHECK-NEXT:          "isStandardLayout": true,
+// CHECK-NEXT:          "isTriviallyCopyable": true,
+// CHECK-NEXT:          "moveAssign": {},
+
+template struct CopyConstructorCheck<2>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "copyAssign": {
+
+// CHECK:               "copyCtor": {
+// CHECK-NEXT:            "hasConstParam": true,
+// CHECK-NEXT:            "implicitHasConstParam": true,
+// CHECK-NEXT:            "trivial": true,
+// CHECK-NEXT:            "userDeclared": true
+// CHECK-NEXT:          },
+
+// CHECK:               "hasUserDeclaredConstructor": true,
+// CHECK-NEXT:          "isEmpty": true,
+// CHECK-NEXT:          "isStandardLayout": true,
+// CHECK-NEXT:          "isTriviallyCopyable": true,
+// CHECK-NEXT:          "moveAssign": {},
+
+template struct CopyConstructorCheck<3>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "copyAssign": {
+
+// CHECK:               "copyCtor": {
+// CHECK-NEXT:            "hasConstParam": true,
+// CHECK-NEXT:            "implicitHasConstParam": true,
+// CHECK-NEXT:            "nonTrivial": true,
+// CHECK-NEXT:            "userDeclared": true
+// CHECK-NEXT:          },
+
+// CHECK:               "hasUserDeclaredConstructor": true,
+// CHECK-NEXT:          "isEmpty": true,
+// CHECK-NEXT:          "isStandardLayout": true,
+// CHECK-NEXT:          "moveAssign": {},
+
+template <int N>
+struct MoveConstructorCheck {
+  MoveConstructorCheck(MoveConstructorCheck&&) requires(N == 1) = default;
+  MoveConstructorCheck(MoveConstructorCheck&&) requires(N == 2) = delete;
+  MoveConstructorCheck(MoveConstructorCheck&&) requires(N == 3);
+  MoveConstructorCheck(MoveConstructorCheck&&);
+};
+
+
+template struct MoveConstructorCheck<1>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// LIN-NEXT:            "canPassInRegisters": true,
+// CHECK-NEXT:          "copyAssign": {
+
+// CHECK:               "hasUserDeclaredConstructor": true,
+// CHECK-NEXT:          "isEmpty": true,
+// CHECK-NEXT:          "isStandardLayout": true,
+// CHECK-NEXT:          "isTriviallyCopyable": true,
+// CHECK-NEXT:          "moveAssign": {},
+// CHECK-NEXT:          "moveCtor": {
+// CHECK-NEXT:            "exists": true,
+// CHECK-NEXT:            "trivial": true,
+// CHECK-NEXT:            "userDeclared": true
+// CHECK-NEXT:          }
+
+template struct MoveConstructorCheck<2>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "copyAssign": {
+
+// CHECK:               "hasUserDeclaredConstructor": true,
+// CHECK-NEXT:          "isEmpty": true,
+// CHECK-NEXT:          "isStandardLayout": true,
+// CHECK-NEXT:          "isTriviallyCopyable": true,
+// CHECK-NEXT:          "moveAssign": {},
+// CHECK-NEXT:          "moveCtor": {
+// CHECK-NEXT:            "exists": true,
+// CHECK-NEXT:            "trivial": true,
+// CHECK-NEXT:            "userDeclared": true
+// CHECK-NEXT:          }
+
+template struct MoveConstructorCheck<3>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "copyAssign": {
+
+// CHECK:               "hasUserDeclaredConstructor": true,
+// CHECK-NEXT:          "isEmpty": true,
+// CHECK-NEXT:          "isStandardLayout": true,
+// CHECK-NEXT:          "moveAssign": {},
+// CHECK-NEXT:          "moveCtor": {
+// CHECK-NEXT:            "exists": true,
+// CHECK-NEXT:            "nonTrivial": true,
+// CHECK-NEXT:            "userDeclared": true
+// CHECK-NEXT:          }
+
+template <int N>
+struct CopyAssignmentCheck {
+  CopyAssignmentCheck& operator=(const CopyAssignmentCheck&) requires(N == 1) = default;
+  CopyAssignmentCheck& operator=(const CopyAssignmentCheck&) requires(N == 2) = delete;
+  CopyAssignmentCheck& operator=(const CopyAssignmentCheck&) requires(N == 3);
+  CopyAssignmentCheck& operator=(const CopyAssignmentCheck&);
+};
+
+
+template struct CopyAssignmentCheck<1>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "canPassInRegisters": true,
+// CHECK-NEXT           "copyAssign": {
+// CHECK-NEXT             "hasConstParam": true,
+// CHECK-NEXT             "implicitHasConstParam": true,
+// CHECK-NEXT             "trivial": true,
+// CHECK-NEXT             "userDeclared": true
+// CHECK-NEXT           },
+
+// CHECK:               "hasConstexprNonCopyMoveConstructor": true,
+// CHECK-NEXT           "isAggregate": true,
+// CHECK-NEXT           "isEmpty": true,
+// CHECK-NEXT           "isLiteral": true,
+// CHECK-NEXT           "isStandardLayout": true,
+// CHECK-NEXT           "isTrivial": true,
+// CHECK-NEXT           "isTriviallyCopyable": true,
+// CHECK-NEXT           "moveAssign": {},
+
+template struct CopyAssignmentCheck<2>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "canPassInRegisters": true,
+// CHECK-NEXT           "copyAssign": {
+// CHECK-NEXT             "hasConstParam": true,
+// CHECK-NEXT             "implicitHasConstParam": true,
+// CHECK-NEXT             "trivial": true,
+// CHECK-NEXT             "userDeclared": true
+// CHECK-NEXT           },
+
+// CHECK:               "hasConstexprNonCopyMoveConstructor": true,
+// CHECK-NEXT           "isAggregate": true,
+// CHECK-NEXT           "isEmpty": true,
+// CHECK-NEXT           "isLiteral": true,
+// CHECK-NEXT           "isStandardLayout": true,
+// CHECK-NEXT           "isTrivial": true,
+// CHECK-NEXT           "isTriviallyCopyable": true,
+// CHECK-NEXT           "moveAssign": {},
+
+template struct CopyAssignmentCheck<3>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "canPassInRegisters": true,
+// CHECK-NEXT           "copyAssign": {
+// CHECK-NEXT             "hasConstParam": true,
+// CHECK-NEXT             "implicitHasConstParam": true,
+// CHECK-NEXT             "trivial": true,
+// CHECK-NEXT             "userDeclared": true
+// CHECK-NEXT           },
+
+// CHECK:               "hasConstexprNonCopyMoveConstructor": true,
+// CHECK-NEXT           "isAggregate": true,
+// CHECK-NEXT           "isEmpty": true,
+// CHECK-NEXT           "isLiteral": true,
+// CHECK-NEXT           "isStandardLayout": true,
+// CHECK-NEXT           "moveAssign": {},
+
+template <int N>
+struct MoveAssignmentCheck {
+  MoveAssignmentCheck& operator=(MoveAssignmentCheck&&) requires(N == 1) = default;
+  MoveAssignmentCheck& operator=(MoveAssignmentCheck&&) requires(N == 2) = delete;
+  MoveAssignmentCheck& operator=(MoveAssignmentCheck&&) requires(N == 3);
+  MoveAssignmentCheck& operator=(MoveAssignmentCheck&&);
+};
+
+
+template struct MoveAssignmentCheck<1>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "copyAssign": {
+
+// CHECK:               "hasConstexprNonCopyMoveConstructor": true,
+// CHECK-NEXT:          "isAggregate": true,
+// CHECK-NEXT:          "isEmpty": true,
+// CHECK-NEXT:          "isLiteral": true,
+// CHECK-NEXT:          "isStandardLayout": true,
+// CHECK-NEXT:          "isTrivial": true,
+// CHECK-NEXT:          "isTriviallyCopyable": true,
+// CHECK-NEXT:          "moveAssign": {
+// CHECK-NEXT:            "exists": true,
+// CHECK-NEXT:            "trivial": true,
+// CHECK-NEXT:            "userDeclared": true
+// CHECK-NEXT:          },
+
+template struct MoveAssignmentCheck<2>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "copyAssign": {
+
+// CHECK:               "hasConstexprNonCopyMoveConstructor": true,
+// CHECK-NEXT:          "isAggregate": true,
+// CHECK-NEXT:          "isEmpty": true,
+// CHECK-NEXT:          "isLiteral": true,
+// CHECK-NEXT:          "isStandardLayout": true,
+// CHECK-NEXT:          "isTrivial": true,
+// CHECK-NEXT:          "isTriviallyCopyable": true,
+// CHECK-NEXT:          "moveAssign": {
+// CHECK-NEXT:            "exists": true,
+// CHECK-NEXT:            "trivial": true,
+// CHECK-NEXT:            "userDeclared": true
+// CHECK-NEXT:          },
+
+template struct MoveAssignmentCheck<3>;
+// CHECK:             "kind": "ClassTemplateSpecializationDecl",
+// CHECK:             "definitionData": {
+// CHECK-NEXT:          "canConstDefaultInit": true,
+// CHECK-NEXT:          "copyAssign": {
+
+// CHECK:               "hasConstexprNonCopyMoveConstructor": true,
+// CHECK-NEXT:          "isAggregate": true,
+// CHECK-NEXT:          "isEmpty": true,
+// CHECK-NEXT:          "isLiteral": true,
+// CHECK-NEXT:          "isStandardLayout": true,
+// CHECK-NEXT:          "moveAssign": {
+// CHECK-NEXT:            "exists": true,
+// CHECK-NEXT:            "nonTrivial": true,
+// CHECK-NEXT:            "userDeclared": true
+// CHECK-NEXT:          },

clang/test/SemaCXX/constrained-special-member-functions.cpp

+// RUN: %clang_cc1 -verify -std=c++20 %s
+
+template <int N>
+concept C0 = (N == 0);
+template <int N>
+concept C1 = (N == 1);
+template <int N>
+concept C2 = (N == 2);
+
+// Checks are indexed by:
+// Definition:
+//  1. Explicitly defaulted definition
+//  2. Deleted definition
+//  3. User provided definition
+// We have a less constrained user provided method that should not disable
+// the (copyable) triviality of the type.
+
+// Note that because Clang does not implement DRs 1496 and 1734, we say some
+// classes are trivial when the SMFs are deleted.
+
+template <int N>
+struct DefaultConstructorChecker {
+    DefaultConstructorChecker() requires C0<N> = default;
+    DefaultConstructorChecker() requires C1<N> = delete;
+    DefaultConstructorChecker() requires C2<N>;
+    DefaultConstructorChecker();
+};
+static_assert(__is_trivially_copyable(DefaultConstructorChecker<0>));
+static_assert(__is_trivially_copyable(DefaultConstructorChecker<1>));
+static_assert(__is_trivially_copyable(DefaultConstructorChecker<2>));
+static_assert(__is_trivially_copyable(DefaultConstructorChecker<3>));
+static_assert(__is_trivial(DefaultConstructorChecker<0>));
+// FIXME: DR1496
+static_assert(__is_trivial(DefaultConstructorChecker<1>));
+static_assert(!__is_trivial(DefaultConstructorChecker<2>));
+static_assert(!__is_trivial(DefaultConstructorChecker<3>));
+
+template <int N>
+struct CopyConstructorChecker {
+    CopyConstructorChecker(const CopyConstructorChecker&) requires C0<N> = default;
+    CopyConstructorChecker(const CopyConstructorChecker&) requires C1<N> = delete;
+    CopyConstructorChecker(const CopyConstructorChecker&) requires C2<N>;
+    CopyConstructorChecker(const CopyConstructorChecker&);
+};
+
+static_assert(__is_trivially_copyable(CopyConstructorChecker<0>));
+// FIXME: DR1734
+static_assert(__is_trivially_copyable(CopyConstructorChecker<1>));
+static_assert(!__is_trivially_copyable(CopyConstructorChecker<2>));
+static_assert(!__is_trivially_copyable(CopyConstructorChecker<3>));
+static_assert(!__is_trivial(CopyConstructorChecker<0>));
+static_assert(!__is_trivial(CopyConstructorChecker<1>));
+static_assert(!__is_trivial(CopyConstructorChecker<2>));
+static_assert(!__is_trivial(CopyConstructorChecker<3>));
+
+template <int N>
+struct MoveConstructorChecker {
+    MoveConstructorChecker(MoveConstructorChecker&&) requires C0<N> = default;
+    MoveConstructorChecker(MoveConstructorChecker&&) requires C1<N> = delete;
+    MoveConstructorChecker(MoveConstructorChecker&&) requires C2<N>;
+    MoveConstructorChecker(MoveConstructorChecker&&);
+};
+
+static_assert(__is_trivially_copyable(MoveConstructorChecker<0>));
+// FIXME: DR1734
+static_assert(__is_trivially_copyable(MoveConstructorChecker<1>));
+static_assert(!__is_trivially_copyable(MoveConstructorChecker<2>));
+static_assert(!__is_trivially_copyable(MoveConstructorChecker<3>));
+static_assert(!__is_trivial(MoveConstructorChecker<0>));
+static_assert(!__is_trivial(MoveConstructorChecker<1>));
+static_assert(!__is_trivial(MoveConstructorChecker<2>));
+static_assert(!__is_trivial(MoveConstructorChecker<3>));
+
+template <int N>
+struct MoveAssignmentChecker {
+    MoveAssignmentChecker& operator=(MoveAssignmentChecker&&) requires C0<N> = default;
+    MoveAssignmentChecker& operator=(MoveAssignmentChecker&&) requires C1<N> = delete;
+    MoveAssignmentChecker& operator=(MoveAssignmentChecker&&) requires C2<N>;
+    MoveAssignmentChecker& operator=(MoveAssignmentChecker&&);
+};
+
+static_assert(__is_trivially_copyable(MoveAssignmentChecker<0>));
+// FIXME: DR1734.
+static_assert(__is_trivially_copyable(MoveAssignmentChecker<1>));
+static_assert(!__is_trivially_copyable(MoveAssignmentChecker<2>));
+static_assert(!__is_trivially_copyable(MoveAssignmentChecker<3>));
+static_assert(__is_trivial(MoveAssignmentChecker<0>));
+// FIXME: DR1734.
+static_assert(__is_trivial(MoveAssignmentChecker<1>));
+static_assert(!__is_trivial(MoveAssignmentChecker<2>));
+static_assert(!__is_trivial(MoveAssignmentChecker<3>));
+
+template <int N>
+struct CopyAssignmentChecker {
+    CopyAssignmentChecker& operator=(const CopyAssignmentChecker&) requires C0<N> = default;
+    CopyAssignmentChecker& operator=(const CopyAssignmentChecker&) requires C1<N> = delete;
+    CopyAssignmentChecker& operator=(const CopyAssignmentChecker&) requires C2<N>;
+    CopyAssignmentChecker& operator=(const CopyAssignmentChecker&);
+};
+
+static_assert(__is_trivially_copyable(CopyAssignmentChecker<0>));
+// FIXME: DR1734.
+static_assert(__is_trivially_copyable(CopyAssignmentChecker<1>));
+static_assert(!__is_trivially_copyable(CopyAssignmentChecker<2>));
+static_assert(!__is_trivially_copyable(CopyAssignmentChecker<3>));
+static_assert(__is_trivial(CopyAssignmentChecker<0>));
+// FIXME: DR1734.
+static_assert(__is_trivial(CopyAssignmentChecker<1>));
+static_assert(!__is_trivial(CopyAssignmentChecker<2>));
+static_assert(!__is_trivial(CopyAssignmentChecker<3>));
+
+
+template <int N>
+struct KindComparisonChecker1 {
+    KindComparisonChecker1& operator=(const KindComparisonChecker1&) requires C0<N> = default;
+    KindComparisonChecker1& operator=(KindComparisonChecker1&);
+};
+
+template <int N>
+struct KindComparisonChecker2 {
+    KindComparisonChecker2& operator=(const KindComparisonChecker2&) requires C0<N> = default;
+    const KindComparisonChecker2& operator=(KindComparisonChecker2&) const;
+};
+
+template <int N>
+struct KindComparisonChecker3 {
+    using Alias = KindComparisonChecker3;
+    Alias& operator=(const Alias&) requires C0<N> = default;
+    KindComparisonChecker3& operator=(const KindComparisonChecker3&);
+};
+
+static_assert(!__is_trivial(KindComparisonChecker1<0>));
+static_assert(!__is_trivially_copyable(KindComparisonChecker1<0>));
+
+static_assert(!__is_trivial(KindComparisonChecker2<0>));
+static_assert(!__is_trivially_copyable(KindComparisonChecker2<0>));
+
+static_assert(__is_trivial(KindComparisonChecker3<0>));
+static_assert(__is_trivially_copyable(KindComparisonChecker3<0>));
+
+template <class T>
+concept HasA = requires(T t) {
+    { t.a() };
+};
+
+template <class T>
+concept HasAB = HasA<T> && requires(T t) {
+    { t.b() };
+};
+
+template <class T>
+concept HasAC = HasA<T> && requires(T t) {
+    { t.c() };
+};
+
+template <class T>
+concept HasABC = HasAB<T> && HasAC<T> && requires(T t) {
+    { t.c() };
+};
+
+template <class T>
+struct ComplexConstraints {
+    ComplexConstraints() requires HasABC<T> = default;
+    ComplexConstraints() requires HasAB<T>;
+    ComplexConstraints() requires HasAC<T>;
+    ComplexConstraints() requires HasA<T> = delete;
+    ComplexConstraints();
+};
+
+struct A {
+    void a();
+};
+
+struct AB {
+    void a();
+    void b();
+};
+
+struct ABC {
+    void a();
+    void b();
+    void c();
+};
+
+struct AC {
+    void a();
+    void c();
+};
+
+static_assert(__is_trivial(ComplexConstraints<ABC>), "");
+static_assert(!__is_trivial(ComplexConstraints<AB>), "");
+static_assert(!__is_trivial(ComplexConstraints<AC>), "");
+static_assert(__is_trivial(ComplexConstraints<A>), "");
+static_assert(!__is_trivial(ComplexConstraints<int>), "");
+
+
+// This is evaluated at the completion of CRTPBase, while `T` is not yet completed.
+// This is probably correct behavior.
+// FIXME: We should not throw an error, instead SFINAE should make the constraint
+// silently unsatisfied. See [temp.constr.constr]p5
+template <class T>
+struct CRTPBase {
+  CRTPBase() requires (sizeof(T) > 0); // expected-error {{to an incomplete type}}
+  CRTPBase() = default;
+};
+
+struct Child : CRTPBase<Child> { int x; };
+// expected-note@-1 {{definition of 'Child' is not complete until}}
+// expected-note@-2 {{in instantiation of template class 'CRTPBase<Child>' requested here}}
+static Child c;
+
+
+namespace GH57046 {
+template<unsigned N>
+struct Foo {
+  Foo() requires (N==1) {} // expected-note {{declared here}}
+  Foo() requires (N==2) = default;
+};
+
+template <unsigned N, unsigned M>
+struct S {
+  Foo<M> data;
+  S() requires (N==1) {}
+  consteval S() requires (N==2) = default; // expected-note {{non-constexpr constructor 'Foo' cannot be used in a constant expression}}
+};
+
+void func() {
+  S<2, 1> s1; // expected-error {{is not a constant expression}} expected-note {{in call to 'S()'}}
+  S<2, 2> s2;
+}
+}

clang/www/cxx_status.html

</tr>
       <tr> <!-- from San Diego -->
         <td><a href="https://wg21.link/p1084r2">P1084R2</a></td>
         <td rowspan="2" class="full" align="center">Clang 10</td>
       </tr>
       <tr>
         <td><a href="https://wg21.link/p1141r2">P1141R2</a></td>
       </tr>
       <tr> <!-- from Cologne -->
         <td><a href="https://wg21.link/p0848r3">P0848R3</a></td>
-        <td rowspan="1" class="none" align="center">No</td>
+        <td rowspan="1" class="unreleased" align="center">
+          <details>
+            <summary>Clang 16 (Partial)</summary>
+            Because of other concepts implementation deficits, the __cpp_concepts macro is not yet set to 202002L.
+            Also, the related defect reports <a href="https://wg21.link/cwg1496">DR1496</a> and
+            <a href="https://wg21.link/cwg1734">DR1734</a> are not yet implemented. Accordingly, deleted
+            special member functions are treated as eligible even though they shouldn't be.
+          </details>
+        </td>
         </tr>
       <tr>
         <td><a href="https://wg21.link/p1616r1">P1616R1</a></td>
         <td rowspan="2" class="full" align="center">Clang 10</td>
       </tr>
       <tr>
         <td><a href="https://wg21.link/p1452r2">P1452R2</a></td>
       </tr>
       <tr> <!-- from Belfast -->