__has_trivial_copy should map to __is_trivially_copyable

[zahen]

Summary

Found during clang 15 RC1 testing due to the new diagnostic added by @royjacobson since clang 14. Uncertain if this fix meets the bar to also be applied to the release branch.

If accepted, I'll need someone with commit access to submit on my behalf.

[royjacobson]

LGTM, thank you for this patch!
I'll wait until Monday to let others have a look and then we can backport, I think it's useful and it's small enough to not be a problem.

Could you add name+email for the commit message?

[aaron.ballman]

LGTM!

[erichkeane]

Did @royjacobson 's patch make it to the 15.0 branch? If so, Roy: After this is committed, can you file to get this merged into the 15.x branch? This seems trivial enough (HAH!) of a fix that it is zero risk, and also keeps it from being all that embarassing here.

[zahen]

In D131730#3718921, @erichkeane wrote:

Did @royjacobson 's patch make it to the 15.0 branch? If so, Roy: After this is committed, can you file to get this merged into the 15.x branch? This seems trivial enough (HAH!) of a fix that it is zero risk, and also keeps it from being all that embarrassing here.

Yes this is definitely in 15. During RC testing the diagnostic fired. The test build where I followed the suggestion and replaced has_trivial_copy with is_trivially_constructible didn't go very well.

[zahen]

In D131730#3718430, @royjacobson wrote:

Could you add name+email for the commit message?

Zachary Henkel
[e-mail]
Github Username: ZacharyHenkel

[royjacobson]

Added a backport request here - https://github.com/llvm/llvm-project/issues/57140

clang/docs/LanguageExtensions.rst

* ``__has_nothrow_copy`` (GNU, Microsoft):
   Deprecated, use ``__is_nothrow_constructible`` instead.
 * ``__has_nothrow_constructor`` (GNU, Microsoft):
   Deprecated, use ``__is_nothrow_constructible`` instead.
 * ``__has_trivial_assign`` (GNU, Microsoft, Embarcadero):
   Deprecated, use ``__is_trivially_assignable`` instead.
 * ``__has_trivial_move_assign`` (GNU, Microsoft):
   Deprecated, use ``__is_trivially_assignable`` instead.
 * ``__has_trivial_copy`` (GNU, Microsoft):
-  Deprecated, use ``__is_trivially_constructible`` instead.
+  Deprecated, use ``__is_trivially_copyable`` instead.
 * ``__has_trivial_constructor`` (GNU, Microsoft):
   Deprecated, use ``__is_trivially_constructible`` instead.
 * ``__has_trivial_move_constructor`` (GNU, Microsoft):
   Deprecated, use ``__is_trivially_constructible`` instead.
 * ``__has_trivial_destructor`` (GNU, Microsoft, Embarcadero):
   Deprecated, use ``__is_trivially_destructible`` instead.
 * ``__has_unique_object_representations`` (C++, GNU)
 * ``__has_virtual_destructor`` (C++, GNU, Microsoft, Embarcadero)

clang/lib/Sema/SemaExprCXX.cpp

switch (Kind) {
     case UTT_HasNothrowConstructor:
       Replacement = TT_IsNothrowConstructible;
       break;
     case UTT_HasTrivialAssign:
     case UTT_HasTrivialMoveAssign:
       Replacement = BTT_IsTriviallyAssignable;
       break;
     case UTT_HasTrivialCopy:
+      Replacement = UTT_IsTriviallyCopyable;
+      break;
     case UTT_HasTrivialDefaultConstructor:
     case UTT_HasTrivialMoveConstructor:
       Replacement = TT_IsTriviallyConstructible;
       break;
     case UTT_HasTrivialDestructor:
       Replacement = UTT_IsTriviallyDestructible;
       break;
     default:

clang/test/SemaCXX/deprecated-builtins.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 struct A {};
 
 void f() {
     bool a;
 
     a = __has_nothrow_assign(A);  // expected-warning-re {{__has_nothrow_assign {{.*}} use __is_nothrow_assignable}}
     a = __has_nothrow_move_assign(A);  // expected-warning-re {{__has_nothrow_move_assign {{.*}} use __is_nothrow_assignable}}
     a = __has_nothrow_copy(A);  // expected-warning-re {{__has_nothrow_copy {{.*}} use __is_nothrow_constructible}}
     a = __has_nothrow_constructor(A);  // expected-warning-re {{__has_nothrow_constructor {{.*}} use __is_nothrow_constructible}}
     a = __has_trivial_assign(A);  // expected-warning-re {{__has_trivial_assign {{.*}} use __is_trivially_assignable}}
     a = __has_trivial_move_assign(A);  // expected-warning-re {{__has_trivial_move_assign {{.*}} use __is_trivially_assignable}}
-    a = __has_trivial_copy(A);  // expected-warning-re {{__has_trivial_copy {{.*}} use __is_trivially_constructible}}
+    a = __has_trivial_copy(A);  // expected-warning-re {{__has_trivial_copy {{.*}} use __is_trivially_copyable}}
     a = __has_trivial_constructor(A);  // expected-warning-re {{__has_trivial_constructor {{.*}} use __is_trivially_constructible}}
     a = __has_trivial_move_constructor(A);  // expected-warning-re {{__has_trivial_move_constructor {{.*}} use __is_trivially_constructible}}
     a = __has_trivial_destructor(A);  // expected-warning-re {{__has_trivial_destructor {{.*}} use __is_trivially_destructible}}
 
 }