[clang] adds copy-constructible type-trait builtins

[cjdb]

Summary

• __is_copy_constructible
• __is_nothrow_copy_constructible
• __is_trivially_copy_constructible

This is information that the compiler already has, and should be exposed
so that the library doesn't need to reimplement the exact same
functionality.

Unlike their default-constructible cousins, the copy-construcitble
traits can't be implemented using __is_constructible, etc., because we
can't form references to void, and references are a fundamental part
of copy constructors.

This was originally a part of D116280.

Depends on D135177.

[cjdb]

Restarts CI

[cjdb]

rewords commit message

[erichkeane]

Please make sure these are going to be OK with libc++ here. "Triviality" is a bit of a hard nut, the standards have re-defined what they mean quite a few times, so this ends up being pretty worthless if it doesn't match the 'version' of this check that the library is trying to look at.

clang/include/clang/Basic/TokenKinds.def

534

So this one is a whole 'thing'. The Clang definition of 'trivially copy constructible' is a few DRs behind. We should probably discuss this with libcxx to make sure use of this wouldn't be broken.

[philnik]

TBH I don't think adding these builtins is worth the extra maintenance cost. libc++'s implementation is already really simple, and actually uses __is_constructible, contrary to the statement in the summary. This is the whole implementation currently:

template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_copy_constructible
    : public integral_constant<
          bool,
          __is_constructible(_Tp, __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};

#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value;
#endif

I don't think adding an extra #if __has_builtin(...) is worth it in this case, since we already use builtins for most of it. IMO the effort would be better spent adding a builtin for add_const; that would probably make the implementation about as efficient as adding a builtin specifically for is_copy_constructible. It would effectively just be __is_constructible(_Tp, __add_lvalue_reference(__add_const(_Tp))). The trivially and nothrow versions look very similar, just with __is_trivially_constructible and __is_nothrow_constructible respectively.

[cjdb]

clang/include/clang/Basic/TokenKinds.def

534

I'd prefer to get those DRs in before finalising D135238 and subsequent ones. Do you know the DR numbers I should be looking at, or should I just poke npaperbot?

[erichkeane]

clang/include/clang/Basic/TokenKinds.def

534

Not off the top of my head, Aaron and I both poked at it at one point trying to get trivially constructible right at one point, but I think we both gave up due to the ABI/versioning concerns.

[royjacobson]

clang/include/clang/Basic/TokenKinds.def

534

Maybe DR1734? Although it's about the trivially copyable trait, not trivially copy constructible.

[erichkeane]

clang/include/clang/Basic/TokenKinds.def

534

Yeah, I think that was the DR, that number sounds familiar.

[cjdb]

clang/include/clang/Basic/TokenKinds.def

534

The __is_trivially_* traits were, in part, what inspired the Great Split of D116208. I could remove them for now and revisit once I rip my hair out over these DRs, if that would substantially improve the chances of these commits landing (other commentary notwithstanding).

[ldionne]

clang/include/clang/Basic/TokenKinds.def

534

I am not sure I see a problem with the "triviality" part of this -- we already use a compiler builtin for std::is_trivially_constructible, so I would expect either this patch is fine, or we already have a latent bug in libc++.

I think I can echo @philnik's comment about this not necessarily providing the biggest benefit since our implementation of std::is_trivially_copy_constructible is a fairly trivial wrapper on top of __is_trivially_constructible, but I wouldn't object to the patch on that basis. I think it would probably be possible to instead provide a set of basis builtin operations that we can then build all of the library type traits on top of -- that would provide the highest bang-for-our-buck ratio.

At the same time, there's something kind of enticing in the consistency of defining every single type trait as a builtin, without exception. If that's the end goal, I think that would also be neat and we'd likely regroup all of our type traits under a single header, since each of them would literally be a one liner.

There's also the question of whether GCC provides these builtins -- if they don't and if they don't have plans to, then we'd actually need to add complexity in libc++ to support both, which we would be unlikely to do given that there's probably not a huge compile-time performance benefit.

TLDR, I think the two questions that can help gauge how much interest there will be from libc++ to use this are:

1. Is the plan to provide *all* the type traits as builtins?
2. Will GCC implement them?

That being said, libc++ might not be the only potential user of these builtins, so I wouldn't necessarily make it a hard requirement to satisfy us.

[cjdb]

clang/include/clang/Basic/TokenKinds.def

534

I think I can echo @philnik's comment about this not necessarily providing the biggest benefit since our implementation of std::is_trivially_copy_constructible is a fairly trivial wrapper on top of __is_trivially_constructible, but I wouldn't object to the patch on that basis.

I haven't had time to do anything properly in the way of benchmarking, but after looking at @philnik's quoted code, I see that I'd naively addressed __is_constructible(T, T const&), forgetting that __add_lvalue_reference would've fixed that issue.

1. Is the plan to provide *all* the type traits as builtins?

Yes, with the possible exception of enable_if and add_const etc. (see D116203 for why the qualifier ones aren't already in). The hardest ones will probably be common_type, common_reference, *invocable*, and *swappable*. The former two depend on technology that doesn't exist in Clang yet, and the latter two are likely hard due there not being prior art.

2. Will GCC implement them?

@jwakely do you know if there can be cross-compiler synergy here?

[jwakely]

clang/include/clang/Basic/TokenKinds.def

534

Which traits are you asking about, just the __is_{,trivially,nothrow}_copy_constructible ones? Or all type traits?

Either way, I think the answer is no. We already use __is_{,trivially,nothrow}_constructible for the copy-constructible traits, and it works fine. I'm not aware of any problems with it. So I don't see any benefit in adding these ones. As already mentioned, it creates *more* code to maintain when using these traits, because we still have to support older versions of other compilers that don't have all the new traits yet.

We've added traits for a few more things recently (__remove_cv, __remove_cvref, __remove_reference) but they can only be used in limited ways (you can't use them directly to implement std::remove_cv_t for example, because they don't mangle to the same thing, which is observable). So I'm sceptical about the benefits of implementing *every* trait as a built-in. There are some which are bottlenecks and worth doing, and some which aren't.

[cjdb]

clang/include/clang/Basic/TokenKinds.def

534

Which traits are you asking about, just the __is_{,trivially,nothrow}_copy_constructible ones? Or all type traits?

Either way, I think the answer is no. We already use __is_{,trivially,nothrow}_constructible for the copy-constructible traits, and it works fine. I'm not aware of any problems with it. So I don't see any benefit in adding these ones. As already mentioned, it creates *more* code to maintain when using these traits, because we still have to support older versions of other compilers that don't have all the new traits yet.

Thanks for filling in the knowledge-gap here. I think libc++ only supports the most recent two releases of Clang (and I think only the latest release of GCC), so that library code would have an expiration date of around most eighteen months. So I'm clearer on the libstdc++ side of things, how far back do you normally support?

We've added traits for a few more things recently (__remove_cv, __remove_cvref, __remove_reference) but they can only be used in limited ways (you can't use them directly to implement std::remove_cv_t for example, because they don't mangle to the same thing, which is observable).

Interesting. Is this a libstdc++ backwards-compat issue, or does it burrow into the Itanium ABI, which has mangling conventions for builtin type transformers?

[cjdb]

Abandoning, since this doesn't have consensus.

[cjdb]

runs 'arc diff git merge-base HEAD origin --update D135238' to try and get CI happy

clang/docs/LanguageExtensions.rst

* ``__is_unsigned`` (C++, Embarcadero):
   enumeration types if the underlying type was unsigned.
 * ``__is_void`` (C++, Embarcadero)
 * ``__is_volatile`` (C++, Embarcadero)
 * ``__reference_binds_to_temporary(T, U)`` (Clang):  Determines whether a
   reference of type ``T`` bound to an expression of type ``U`` would bind to a
   materialized temporary object. If ``T`` is not a reference type the result
   is false. Note this trait will also return false when the initialization of
   ``T`` from ``U`` is ill-formed.
+  Deprecated, use ``__reference_constructs_from_temporary``.
+* ``__reference_constructs_from_temporary(T, U)`` (C++)
+  Returns true if a reference ``T`` can be constructed from a temporary of type
+  a non-cv-qualified ``U``.
 * ``__underlying_type`` (C++, GNU, Microsoft)
 
 In addition, the following expression traits are supported:
 
 * ``__is_lvalue_expr(e)`` (Embarcadero):
   Returns true if ``e`` is an lvalue expression.
   Deprecated, use ``__is_lvalue_reference(decltype((e)))`` instead.
 * ``__is_rvalue_expr(e)`` (Embarcadero):

clang/include/clang/Basic/TokenKinds.def

 TYPE_TRAIT_1(__is_trivially_equality_comparable, IsTriviallyEqualityComparable, KEYCXX)
 TYPE_TRAIT_1(__is_bounded_array, IsBoundedArray, KEYCXX)
 TYPE_TRAIT_1(__is_unbounded_array, IsUnboundedArray, KEYCXX)
 TYPE_TRAIT_1(__is_nullptr, IsNullPointer, KEYCXX)
 TYPE_TRAIT_1(__is_scoped_enum, IsScopedEnum, KEYCXX)
 TYPE_TRAIT_1(__is_referenceable, IsReferenceable, KEYCXX)
 TYPE_TRAIT_1(__can_pass_in_regs, CanPassInRegs, KEYCXX)
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
+TYPE_TRAIT_2(__reference_constructs_from_temporary, ReferenceConstructsFromTemporary, KEYCXX)
 
 // Embarcadero Expression Traits
 EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
 EXPRESSION_TRAIT(__is_rvalue_expr, IsRValueExpr, KEYCXX)
 
 // Embarcadero Unary Type Traits
 TYPE_TRAIT_1(__is_arithmetic, IsArithmetic, KEYCXX)
 TYPE_TRAIT_1(__is_floating_point, IsFloatingPoint, KEYCXX)

clang/lib/Lex/PPMacroExpansion.cpp

EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
           if (II->getName().startswith("__builtin_") ||
               II->getName().startswith("__is_") ||
               II->getName().startswith("__has_"))
             return true;
           return llvm::StringSwitch<bool>(II->getName())
               .Case("__array_rank", true)
               .Case("__array_extent", true)
               .Case("__reference_binds_to_temporary", true)
+              .Case("__reference_constructs_from_temporary", true)
 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) .Case("__" #Trait, true)
 #include "clang/Basic/TransformTypeTraits.def"
               .Default(false);
         } else {
           return llvm::StringSwitch<bool>(II->getName())
               // Report builtin templates as being builtins.
               .Case("__make_integer_seq", getLangOpts().CPlusPlus)
               .Case("__type_pack_element", getLangOpts().CPlusPlus)

clang/lib/Parse/ParseDeclCXX.cpp

#include "clang/Basic/TransformTypeTraits.def"
           tok::kw___is_trivially_equality_comparable,
           tok::kw___is_trivially_assignable,
           tok::kw___is_trivially_constructible,
           tok::kw___is_trivially_copyable,
           tok::kw___is_unbounded_array,
           tok::kw___is_union,
           tok::kw___is_unsigned,
           tok::kw___is_void,
-          tok::kw___is_volatile))
+          tok::kw___is_volatile,
+          tok::kw___reference_binds_to_temporary,
+          tok::kw___reference_constructs_from_temporary))
     // GNU libstdc++ 4.2 and libc++ use certain intrinsic names as the
     // name of struct templates, but some are keywords in GCC >= 4.3
     // and Clang. Therefore, when we see the token sequence "struct
     // X", make X into a normal identifier rather than a keyword, to
     // allow libstdc++ 4.2 and libc++ to work properly.
     TryKeywordIdentFallback(true);
 
   struct PreserveAtomicIdentifierInfoRAII {

clang/lib/Parse/ParseExpr.cpp

#define REVERTIBLE_TYPE_TRAIT(Name)                         \
           REVERTIBLE_TYPE_TRAIT(__is_trivially_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_copyable);
           REVERTIBLE_TYPE_TRAIT(__is_unbounded_array);
           REVERTIBLE_TYPE_TRAIT(__is_union);
           REVERTIBLE_TYPE_TRAIT(__is_unsigned);
           REVERTIBLE_TYPE_TRAIT(__is_void);
           REVERTIBLE_TYPE_TRAIT(__is_volatile);
+          REVERTIBLE_TYPE_TRAIT(__reference_binds_to_temporary);
+          REVERTIBLE_TYPE_TRAIT(__reference_constructs_from_temporary);
 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait)                                     \
   REVERTIBLE_TYPE_TRAIT(RTT_JOIN(__, Trait));
 #include "clang/Basic/TransformTypeTraits.def"
 #undef REVERTIBLE_TYPE_TRAIT
 #undef RTT_JOIN
         }
 
         // If we find that this is in fact the name of a type trait,

clang/lib/Sema/SemaExprCXX.cpp

 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/AlignedAllocation.h"
 #include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Basic/TypeTraits.h"
+#include "clang/Basic/TokenKinds.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/EnterExpressionEvaluationContext.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
static bool EvaluateBooleanTypeTrait(Sema &S, TypeTrait Kind,
                                      SourceLocation RParenLoc,
                                      bool IsDependent) {
   if (IsDependent)
     return false;
 
   if (Kind <= UTT_Last)
     return EvaluateUnaryTypeTrait(S, Kind, KWLoc, Args[0]->getType());
 
-  // Evaluate BTT_ReferenceBindsToTemporary alongside the IsConstructible
-  // traits to avoid duplication.
-  if (Kind <= BTT_Last && Kind != BTT_ReferenceBindsToTemporary)
+  // Evaluate ReferenceBindsToTemporary and ReferenceConstructsFromTemporary
+  // alongside the IsConstructible traits to avoid duplication.
+  if (Kind <= BTT_Last && Kind != BTT_ReferenceBindsToTemporary && Kind != BTT_ReferenceConstructsFromTemporary)
     return EvaluateBinaryTypeTrait(S, Kind, Args[0]->getType(),
                                    Args[1]->getType(), RParenLoc);
 
   switch (Kind) {
   case clang::BTT_ReferenceBindsToTemporary:
+  case clang::BTT_ReferenceConstructsFromTemporary:
   case clang::TT_IsConstructible:
   case clang::TT_IsNothrowConstructible:
   case clang::TT_IsTriviallyConstructible: {
     // C++11 [meta.unary.prop]:
     //   is_trivially_constructible is defined as:
     //
     //     is_constructible<T, Args...>::value is true and the variable
     //     definition for is_constructible, as defined below, is known to call
case clang::TT_IsTriviallyConstructible: {
 
     ExprResult Result = Init.Perform(S, To, InitKind, ArgExprs);
     if (Result.isInvalid() || SFINAE.hasErrorOccurred())
       return false;
 
     if (Kind == clang::TT_IsConstructible)
       return true;
 
-    if (Kind == clang::BTT_ReferenceBindsToTemporary) {
+    if (Kind == clang::BTT_ReferenceBindsToTemporary || Kind == clang::BTT_ReferenceConstructsFromTemporary) {
       if (!T->isReferenceType())
         return false;
 
-      return !Init.isDirectReferenceBinding();
+      if (!Init.isDirectReferenceBinding())
+        return true;
+
+      if (Kind == clang::BTT_ReferenceBindsToTemporary)
+        return false;
+
+      QualType U = Args[1]->getType();
+      if (U->isReferenceType())
+        return false;
+
+      QualType TPtr = S.BuiltinAddPointer(S.BuiltinRemoveReference(T, UnaryTransformType::RemoveCVRef, {}), {});
+      QualType UPtr = S.BuiltinAddPointer(S.BuiltinRemoveReference(U, UnaryTransformType::RemoveCVRef, {}), {});
+      return EvaluateBinaryTypeTrait(S, TypeTrait::BTT_IsConvertibleTo, UPtr, TPtr, RParenLoc);
     }
 
     if (Kind == clang::TT_IsNothrowConstructible)
       return S.canThrow(Result.get()) == CT_Cannot;
 
     if (Kind == clang::TT_IsTriviallyConstructible) {
       // Under Objective-C ARC and Weak, if the destination has non-trivial
       // Objective-C lifetime, this is a non-trivial construction.

clang/test/SemaCXX/type-traits.cpp

void reference_binds_to_temporary_checks() {
   { int arr[T((__reference_binds_to_temporary(int const &, LongRef)))]; }
 
   // Test that it doesn't accept non-reference types as input.
   { int arr[F((__reference_binds_to_temporary(int, long)))]; }
 
   { int arr[T((__reference_binds_to_temporary(const int &, long)))]; }
 }
 
+void reference_constructs_from_temporary_checks() {
+  static_assert(!__reference_constructs_from_temporary(int &, int &), "");
+  static_assert(!__reference_constructs_from_temporary(int &, int &&), "");
+
+  static_assert(!__reference_constructs_from_temporary(int const &, int &), "");
+  static_assert(!__reference_constructs_from_temporary(int const &, int const &), "");
+  static_assert(!__reference_constructs_from_temporary(int const &, int &&), "");
+
+  static_assert(!__reference_constructs_from_temporary(int &, long &), ""); // doesn't construct
+
+  static_assert(__reference_constructs_from_temporary(int const &, long &), "");
+  static_assert(__reference_constructs_from_temporary(int const &, long &&), "");
+  static_assert(__reference_constructs_from_temporary(int &&, long &), "");
+
+  using LRef = ConvertsToRef<int, int &>;
+  using RRef = ConvertsToRef<int, int &&>;
+  using CLRef = ConvertsToRef<int, const int &>;
+  using LongRef = ConvertsToRef<long, long &>;
+  static_assert(__is_constructible(int &, LRef), "");
+  static_assert(!__reference_constructs_from_temporary(int &, LRef), "");
+
+  static_assert(__is_constructible(int &&, RRef), "");
+  static_assert(!__reference_constructs_from_temporary(int &&, RRef), "");
+
+  static_assert(__is_constructible(int const &, CLRef), "");
+  static_assert(!__reference_constructs_from_temporary(int &&, CLRef), "");
+
+  static_assert(__is_constructible(int const &, LongRef), "");
+  static_assert(__reference_constructs_from_temporary(int const &, LongRef), "");
+
+  // Test that it doesn't accept non-reference types as input.
+  static_assert(!__reference_constructs_from_temporary(int, long), "");
+
+  static_assert(__reference_constructs_from_temporary(const int &, long), "");
+
+  // Additional checks
+  static_assert(__reference_constructs_from_temporary(POD const&, Derives), "");
+  static_assert(__reference_constructs_from_temporary(int&&, int), "");
+  static_assert(__reference_constructs_from_temporary(const int&, int), "");
+  static_assert(!__reference_constructs_from_temporary(int&&, int&&), "");
+  static_assert(!__reference_constructs_from_temporary(const int&, int&&), "");
+  static_assert(__reference_constructs_from_temporary(int&&, long&&), "");
+  static_assert(__reference_constructs_from_temporary(int&&, long), "");
+}
+
 void array_rank() {
   int t01[T(__array_rank(IntAr) == 1)];
   int t02[T(__array_rank(ConstIntArAr) == 2)];
 }
 
 void array_extent() {
   int t01[T(__array_extent(IntAr, 0) == 10)];
   int t02[T(__array_extent(ConstIntArAr, 0) == 4)];

clang/www/cxx_status.html

<tr>
       <td><a href="https://wg21.link/P0533R9">P0533R9</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>Type trait to determine if a reference binds to a temporary</td>
       <td><a href="https://wg21.link/P2255R2">P2255R2</a></td>
       <td class="partial" align="center">
         <details><summary>Partial</summary>
-          Clang provides a <tt>__reference_binds_to_temporary</tt> type trait
-          builtin, with which the library facility can be partially implemented.
-          Both <tt>__reference_constructs_from_temporary</tt> and
-          <tt>__reference_converts_from_temporary</tt> builtins should be
+          Clang provides <tt>__reference_constructs_from_temporary</tt> type
+          trait builtin, with which <tt>std::reference_constructs_from_temporary</tt>
+          implemented. <tt>__reference_converts_from_temporary</tt> needs to be
           provided, following the normal cross-vendor convention to implement
           traits requiring compiler support directly.
         </details></td>
       </td>
     </tr>
     <!-- July 2022 papers -->
     <tr>
       <td>The Equality Operator You Are Looking For</td>