[Clang] Fix some triviality computations

[royjacobson]

Summary

Fix #63352 and one other similar issue by slightly adjusting the computation for the existance of non
trivial special member functions.

[cor3ntin]

This is a bit confusing but I think it is correct.
LGTM modulo typos.

clang/docs/ReleaseNotes.rst

70

[shafik]

clang/include/clang/AST/DeclCXX.h

1269

These references looks like they need to be updated. Same below and it looks like hasNonTrivialCopyConstructorForCall is missing references all together.

[royjacobson]

clang/include/clang/AST/DeclCXX.h

1269

TBH I don't think those functions actually need references to the standard? Whether the actual member functions are trivial or not is already calculated before. Do you think I can just remove it? :)

[royjacobson]

Update release note

[philnik]

clang/include/clang/AST/DeclCXX.h

1269

I think it makes sense to call out that these functions represent something from the standard. There are other functions with similar names, which don't have an equivalent in the C++ standard, like hasTrivialDestructorForCall.

[shafik]

clang/include/clang/AST/DeclCXX.h

1269

The point of having the reference is so folks can understand the logic behind why someone choose to implement the functionality as they did.

I also prefer quoting the critical text since the paragraphs, sometimes the stable name and wording can change and at least having text can allow us to track which standard it came from and hopefully which change changed the text and understand if it effects our compliance or not.

It can be a lot of work to figure this out from scratch if you don't know where to look.

[cor3ntin]

@royjacobson Are you still working on that? It seems it's only missing updates to a comment

[cor3ntin]

@royjacobson ^

[royjacobson]

In D154893#4646405, @cor3ntin wrote:

@royjacobson ^

I did not have a lot of time for Clang the last few months unfortunately. I might take a look at this again next month when I'll have a bit more time.

[royjacobson]

I, uh, got preoccupied by some recent events. Don't think I'll have the time for this unfortunately.

clang/docs/ReleaseNotes.rst

- Clang won't search for coroutine_traits in std::experimental namespace any more.
   Clang will only search for std::coroutine_traits for coroutines then.
 - Clang no longer allows dereferencing of a ``void *`` as an extension. Clang 16
   converted this to a default-error as ``-Wvoid-ptr-dereference``, as well as a
   SFINAE error. This flag is still valid however, as it disables the equivalent
   warning in C.
 
 ABI Changes in This Version
 ---------------------------
-- A bug in evaluating the ineligibility of some special member functions has been fixed. This can
-  make some classes trivially copyable that were not trivially copyable before. (`#62555 <https://github.com/llvm/llvm-project/issues/62555>`_)
+- Two bug in evaluating the ineligibility of some special member functions has been fixed. This can
+  make some classes trivially copyable that were not trivially copyable before.
+  (`#62555 <https://github.com/llvm/llvm-project/issues/62555>`_, `#63352 <https://github.com/llvm/llvm-project/issues/63352>`_)
 
 What's New in Clang |release|?
 ==============================
 Some of the major new features and improvements to Clang are listed
 here. Generic improvements to Clang as a whole or to its underlying
 infrastructure are described first, followed by language-specific
 sections with improvements to Clang's support for those languages.
 

clang/include/clang/AST/DeclCXX.h

 //===- DeclCXX.h - Classes for representing C++ declarations --*- C++ -*-=====//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
bool hasTrivialCopyConstructor() const {
     return data().HasTrivialSpecialMembers & SMF_CopyConstructor;
   }
 
   bool hasTrivialCopyConstructorForCall() const {
     return data().HasTrivialSpecialMembersForCall & SMF_CopyConstructor;
   }
 
   /// Determine whether this class has a non-trivial copy constructor
   /// (C++ [class.copy]p6, C++11 [class.copy]p12)
   bool hasNonTrivialCopyConstructor() const {
     return data().DeclaredNonTrivialSpecialMembers & SMF_CopyConstructor ||
-           !hasTrivialCopyConstructor();
+           (needsImplicitCopyConstructor() && !hasTrivialCopyConstructor());
   }
 
   bool hasNonTrivialCopyConstructorForCall() const {
     return (data().DeclaredNonTrivialSpecialMembersForCall &
             SMF_CopyConstructor) ||
-           !hasTrivialCopyConstructorForCall();
+           (needsImplicitCopyConstructor() &&
+            !hasTrivialCopyConstructorForCall());
   }
 
   /// Determine whether this class has a trivial move constructor
   /// (C++11 [class.copy]p12)
   bool hasTrivialMoveConstructor() const {
     return hasMoveConstructor() &&
            (data().HasTrivialSpecialMembers & SMF_MoveConstructor);
   }
public:
   bool hasTrivialCopyAssignment() const {
     return data().HasTrivialSpecialMembers & SMF_CopyAssignment;
   }
 
   /// Determine whether this class has a non-trivial copy assignment
   /// operator (C++ [class.copy]p11, C++11 [class.copy]p25)
   bool hasNonTrivialCopyAssignment() const {
     return data().DeclaredNonTrivialSpecialMembers & SMF_CopyAssignment ||
-           !hasTrivialCopyAssignment();
+           (needsImplicitCopyAssignment() && !hasTrivialCopyAssignment());
   }
 
   /// Determine whether this class has a trivial move assignment operator
   /// (C++11 [class.copy]p25)
   bool hasTrivialMoveAssignment() const {
     return hasMoveAssignment() &&
            (data().HasTrivialSpecialMembers & SMF_MoveAssignment);
   }

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

struct ExplicitTemplateArgs {
     ExplicitTemplateArgs(ExplicitTemplateArgs&&) = default;
     ExplicitTemplateArgs(ExplicitTemplateArgs<false>&&) requires B {};
 };
 
 static_assert(__is_trivially_copyable(ExplicitTemplateArgs<false>));
 static_assert(__is_trivially_copyable(ExplicitTemplateArgs<true>));
 
 }
+
+
+namespace GH63352 {
+template <bool B> class C1 { C1(const C1&) requires B; };
+template <bool B> class C2 { C2(C2&&) requires B; };
+template <bool B> class C3 { C3& operator=(const C3&) requires B; };
+template <bool B> class C4 { C4& operator=(C4&&) requires B; };
+
+static_assert(__is_trivially_copyable(C1<false>));
+static_assert(__is_trivially_copyable(C2<false>));
+static_assert(__is_trivially_copyable(C3<false>));
+static_assert(__is_trivially_copyable(C4<false>));
+}