Add `__reference_binds_to_temporary` trait for checking safe reference initialization.

[EricWF]

Summary

The STL types std::pair and std::tuple can both store reference types. However their constructors cannot adequately check if the initialization of reference types is safe. For example:

std::tuple<std::tuple<int> const&> t = 42;
// The stored reference is already dangling.

Libc++ has a best effort attempts in tuple to diagnose this, but they're not able to handle all valid cases (If I'm not mistaken). For example initialization of a reference from the result of a class's conversion operator. Libc++ would benefit from having a builtin traits which can provide a much better implementation.

This patch introduce the __reference_binds_to_temporary(T, U) trait that determines whether a reference of type T bound to an expression of type U would bind to a materialized temporary object.

Note that the trait simply returns false if T is not a reference type instead of reporting it as an error.

static_assert(__is_constructible(int const&, long));
static_assert(__reference_binds_to_temporary(int const&, long));

[majnemer]

include/clang/Basic/TokenKinds.def

418 ↗

(On Diff #88341)

Should this trait be grouped here?

[rsmith]

I don't like this name; it sounds too much like you're asking whether a certain direct-initialization is possible, which is what __is_constructible does. I also don't like the idea of combining an "is this type direct-initializable from this list of arguments" check with a reference-specific side-check; it seems better to expose the underlying check itself and allow the user to figure out how they want to combine the checks.

Perhaps we could introduce a __reference_binds_to_temporary(T, U) trait, where T is required to be a reference type, that determines whether a reference of type T bound to an expression of type U would bind to a materialized temporary object (or subobject thereof)?

[EricWF]

In D29930#676858, @rsmith wrote:

I don't like this name; it sounds too much like you're asking whether a certain direct-initialization is possible, which is what __is_constructible does. I also don't like the idea of combining an "is this type direct-initializable from this list of arguments" check with a reference-specific side-check; it seems better to expose the underlying check itself and allow the user to figure out how they want to combine the checks.

Perhaps we could introduce a __reference_binds_to_temporary(T, U) trait, where T is required to be a reference type, that determines whether a reference of type T bound to an expression of type U would bind to a materialized temporary object (or subobject thereof)?

That all sounds great to me. Thanks for the comments @rsmith. I'll update it tomorrow with the changes.

[EricWF]

Address all of @rsmith's comments.

[EricWF]

Remove test code that snuck in.

[EricWF]

@rsmith gentle ping.

[EricWF]

@rsmith Ping.

[rsmith]

lib/Sema/SemaExprCXX.cpp

4567 ↗

(On Diff #88795)

"alongside" is a single word.

test/SemaCXX/type-traits.cpp

2102–2116 ↗

(On Diff #88795)

Please also check things like:

`__reference_binds_to_temporary(const int&, ConvertsToRef<long, long&>)`

(That is, a user-defined conversion to a reference type followed by converting and materializing a temporary.)

[EricWF]

test/SemaCXX/type-traits.cpp

2102–2116 ↗

(On Diff #88795)

Isn't that exactly what the test on the specified line does? LongRef is ConvertsToRef<long, long&>

[EricWF]

• Address spelling errors pointed out during review.

[rsmith]

Please also document this trait in docs/LanguageExtensions.rst.

include/clang/Basic/TypeTraits.h

91 ↗

(On Diff #123741)

Looks like you reformatted (and reindented) this whole file. If you meant to do that, please commit it as a separate change.

lib/Parse/ParseDeclCXX.cpp

1407–1432 ↗

(On Diff #123741)

This list should only contain keywords that libstdc++ or libc++ has at one point defined as class templates; your trait should not be added here.

lib/Parse/ParseExpr.cpp

903 ↗

(On Diff #123741)

Likewise.

[EricWF]

@rsmith The trait is already documented in LanguageExtensions.rst, so I'll assumed you missed that and are not trying to suggest more documentation is needed.

include/clang/Basic/TypeTraits.h

91 ↗

(On Diff #123741)

Woops!

lib/Parse/ParseDeclCXX.cpp

1410 ↗

(On Diff #123741)

Woops, Clang-format seems to chewed this up.

[EricWF]

Address inline comments.

[rsmith]

In D29930#974039, @EricWF wrote:

@rsmith The trait is already documented in LanguageExtensions.rst, so I'll assumed you missed that and are not trying to suggest more documentation is needed.

Yes, sorry, not sure how I missed that! :)

cfe/trunk/docs/LanguageExtensions.rst

* ``__is_trivially_constructible(type, argtypes...)``: Determines whether a
   that initialization.  This trait is required to implement the C++11 standard
   library.
 * ``__is_destructible`` (MSVC 2013)
 * ``__is_nothrow_destructible`` (MSVC 2013)
 * ``__is_nothrow_assignable`` (MSVC 2013, clang)
 * ``__is_constructible`` (MSVC 2013, clang)
 * ``__is_nothrow_constructible`` (MSVC 2013, clang)
 * ``__is_assignable`` (MSVC 2015, clang)
+* ``__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.
 
 Blocks
 ======
 
 The syntax and high level language feature description is in
 :doc:`BlockLanguageSpec<BlockLanguageSpec>`. Implementation and ABI details for
 the clang implementation are in :doc:`Block-ABI-Apple<Block-ABI-Apple>`.
 

cfe/trunk/include/clang/Basic/TokenKinds.def

 TYPE_TRAIT_1(__is_union, IsUnion, KEYCXX)
 TYPE_TRAIT_1(__has_unique_object_representations,
              HasUniqueObjectRepresentations, KEYCXX)
 
 // Clang-only C++ Type Traits
 TYPE_TRAIT_N(__is_trivially_constructible, IsTriviallyConstructible, KEYCXX)
 TYPE_TRAIT_1(__is_trivially_copyable, IsTriviallyCopyable, KEYCXX)
 TYPE_TRAIT_2(__is_trivially_assignable, IsTriviallyAssignable, KEYCXX)
+TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 KEYWORD(__underlying_type           , KEYCXX)
 
 // Embarcadero Expression Traits
 KEYWORD(__is_lvalue_expr            , KEYCXX)
 KEYWORD(__is_rvalue_expr            , KEYCXX)
 
 // Embarcadero Unary Type Traits
 TYPE_TRAIT_1(__is_arithmetic, IsArithmetic, KEYCXX)

cfe/trunk/include/clang/Basic/TypeTraits.h

enum TypeTrait {
     BTT_IsBaseOf,
     BTT_IsConvertible,
     BTT_IsConvertibleTo,
     BTT_IsSame,
     BTT_TypeCompatible,
     BTT_IsAssignable,
     BTT_IsNothrowAssignable,
     BTT_IsTriviallyAssignable,
-    BTT_Last = BTT_IsTriviallyAssignable,
+    BTT_ReferenceBindsToTemporary,
+    BTT_Last = BTT_ReferenceBindsToTemporary,
     TT_IsConstructible,
     TT_IsNothrowConstructible,
     TT_IsTriviallyConstructible
   };
 
   /// \brief Names for the array type traits.
   enum ArrayTypeTrait {
     ATT_ArrayRank,

cfe/trunk/lib/Sema/SemaExprCXX.cpp

static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
                                     QualType RhsT, SourceLocation KeyLoc);
 
 static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
                               ArrayRef<TypeSourceInfo *> Args,
                               SourceLocation RParenLoc) {
   if (Kind <= UTT_Last)
     return EvaluateUnaryTypeTrait(S, Kind, KWLoc, Args[0]->getType());
 
-  if (Kind <= BTT_Last)
+  // Evaluate BTT_ReferenceBindsToTemporary alongside the IsConstructible
+  // traits to avoid duplication.
+  if (Kind <= BTT_Last && Kind != BTT_ReferenceBindsToTemporary)
     return EvaluateBinaryTypeTrait(S, Kind, Args[0]->getType(),
                                    Args[1]->getType(), RParenLoc);
 
   switch (Kind) {
+  case clang::BTT_ReferenceBindsToTemporary:
   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 (!T->isReferenceType())
+        return false;
+
+      return !Init.isDirectReferenceBinding();
+    }
+
     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.
       if (T.getNonReferenceType().hasNonTrivialObjCLifetime())
         return false;

cfe/trunk/test/SemaCXX/type-traits.cpp

void constructible_checks() {
   { int arr[F(__is_nothrow_constructible(Abstract))]; }
 
   // PR20228
   { int arr[T(__is_constructible(VariadicCtor,
                                  int, int, int, int, int, int, int, int, int))]; }
 
   // PR25513
   { int arr[F(__is_constructible(int(int)))]; }
+  { int arr[T(__is_constructible(int const &, long))]; }
 
   { int arr[T(__is_constructible(ACompleteType))]; }
   { int arr[T(__is_nothrow_constructible(ACompleteType))]; }
   { int arr[F(__is_constructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
   { int arr[F(__is_nothrow_constructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
   { int arr[F(__is_constructible(AnIncompleteType[]))]; }
   { int arr[F(__is_nothrow_constructible(AnIncompleteType[]))]; }
   { int arr[F(__is_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
void is_trivially_constructible_test() {
   { int arr[T(__is_trivially_constructible(ACompleteType))]; }
   { int arr[F(__is_trivially_constructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
   { int arr[F(__is_trivially_constructible(AnIncompleteType[]))]; }
   { int arr[F(__is_trivially_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
   { int arr[F(__is_trivially_constructible(void))]; }
   { int arr[F(__is_trivially_constructible(const volatile void))]; }
 }
 
+template <class T, class RefType = T &>
+struct ConvertsToRef {
+  operator RefType() const { return static_cast<RefType>(obj); }
+  mutable T obj = 42;
+};
+
+void reference_binds_to_temporary_checks() {
+  { int arr[F((__reference_binds_to_temporary(int &, int &)))]; }
+  { int arr[F((__reference_binds_to_temporary(int &, int &&)))]; }
+
+  { int arr[F((__reference_binds_to_temporary(int const &, int &)))]; }
+  { int arr[F((__reference_binds_to_temporary(int const &, int const &)))]; }
+  { int arr[F((__reference_binds_to_temporary(int const &, int &&)))]; }
+
+  { int arr[F((__reference_binds_to_temporary(int &, long &)))]; } // doesn't construct
+  { int arr[T((__reference_binds_to_temporary(int const &, long &)))]; }
+  { int arr[T((__reference_binds_to_temporary(int const &, long &&)))]; }
+  { int arr[T((__reference_binds_to_temporary(int &&, long &)))]; }
+
+  using LRef = ConvertsToRef<int, int &>;
+  using RRef = ConvertsToRef<int, int &&>;
+  using CLRef = ConvertsToRef<int, const int &>;
+  using LongRef = ConvertsToRef<long, long &>;
+  { int arr[T((__is_constructible(int &, LRef)))]; }
+  { int arr[F((__reference_binds_to_temporary(int &, LRef)))]; }
+
+  { int arr[T((__is_constructible(int &&, RRef)))]; }
+  { int arr[F((__reference_binds_to_temporary(int &&, RRef)))]; }
+
+  { int arr[T((__is_constructible(int const &, CLRef)))]; }
+  { int arr[F((__reference_binds_to_temporary(int &&, CLRef)))]; }
+
+  { int arr[T((__is_constructible(int const &, LongRef)))]; }
+  { 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 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)];