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

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–4569

"alongside" is a single word.

test/SemaCXX/type-traits.cpp

2102–2116

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

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

92

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

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

850

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

92

Woops!

lib/Parse/ParseDeclCXX.cpp

1410

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! :)

docs/LanguageExtensions.rst

   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>`.
 

include/clang/Basic/TokenKinds.def

 TYPE_TRAIT_1(__is_sealed, IsSealed, KEYMS)
 
 // MSVC12.0 / VS2013 Type Traits
 TYPE_TRAIT_1(__is_destructible, IsDestructible, KEYMS)
 TYPE_TRAIT_1(__is_nothrow_destructible, IsNothrowDestructible, KEYMS)
 TYPE_TRAIT_2(__is_nothrow_assignable, IsNothrowAssignable, KEYCXX)
 TYPE_TRAIT_N(__is_constructible, IsConstructible, KEYCXX)
 TYPE_TRAIT_N(__is_nothrow_constructible, IsNothrowConstructible, KEYCXX)
 
 // MSVC14.0 / VS2015 Type Traits
 TYPE_TRAIT_2(__is_assignable, IsAssignable, KEYCXX)
 
 // GNU and MS Type Traits
 TYPE_TRAIT_1(__has_nothrow_assign, HasNothrowAssign, KEYCXX)
 TYPE_TRAIT_1(__has_nothrow_move_assign, HasNothrowMoveAssign, KEYCXX)
 TYPE_TRAIT_1(__has_nothrow_copy, HasNothrowCopy, KEYCXX)
 TYPE_TRAIT_1(__has_nothrow_constructor, HasNothrowConstructor, KEYCXX)

 TYPE_TRAIT_1(__is_polymorphic, IsPolymorphic, KEYCXX)
 TYPE_TRAIT_1(__is_trivial, IsTrivial, KEYCXX)
 TYPE_TRAIT_1(__is_union, IsUnion, 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)

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,
     ATT_ArrayExtent
   };
 
   /// \brief Names for the "expression or type" traits.
   enum UnaryExprOrTypeTrait {
     UETT_SizeOf,
     UETT_AlignOf,
     UETT_VecStep,
     UETT_OpenMPRequiredSimdAlign,
   };
 }
 
 #endif

lib/Parse/ParseDeclCXX.cpp

                   tok::kw___is_enum,
                   tok::kw___is_floating_point,
                   tok::kw___is_final,
                   tok::kw___is_function,
                   tok::kw___is_fundamental,
                   tok::kw___is_integral,
                   tok::kw___is_interface_class,
                   tok::kw___is_literal,
                   tok::kw___is_lvalue_expr,
                   tok::kw___is_lvalue_reference,
                   tok::kw___is_member_function_pointer,
                   tok::kw___is_member_object_pointer,
                   tok::kw___is_member_pointer,
                   tok::kw___is_nothrow_assignable,
                   tok::kw___is_nothrow_constructible,
                   tok::kw___is_nothrow_destructible,
                   tok::kw___is_object,
                   tok::kw___is_pod,
                   tok::kw___is_pointer,
                   tok::kw___is_polymorphic,
                   tok::kw___is_reference,
                   tok::kw___is_rvalue_expr,
                   tok::kw___is_rvalue_reference,
                   tok::kw___is_same,
                   tok::kw___is_scalar,
                   tok::kw___is_sealed,
                   tok::kw___is_signed,
                   tok::kw___is_standard_layout,
                   tok::kw___is_trivial,
                   tok::kw___is_trivially_assignable,
                   tok::kw___is_trivially_constructible,
                   tok::kw___is_trivially_copyable,
                   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))
     // 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 {

lib/Parse/ParseExpr.cpp

#define REVERTIBLE_TYPE_TRAIT(Name)                         \
           REVERTIBLE_TYPE_TRAIT(__is_trivial);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_copyable);
           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);
 #undef REVERTIBLE_TYPE_TRAIT
 #undef RTT_JOIN
         }
 
         // If we find that this is in fact the name of a type trait,
         // update the token kind in place and parse again to treat it as
         // the appropriate kind of type trait.
         llvm::SmallDenseMap<IdentifierInfo *, tok::TokenKind>::iterator Known

lib/Sema/SemaExprCXX.cpp

                                     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 along side 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

 
     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;
+
+      assert(isa<MaterializeTemporaryExpr>(Result.get())
+                     == !Init.isDirectReferenceBinding());
+      return !Init.isDirectReferenceBinding();
+    }
+
     if (Kind == clang::TT_IsNothrowConstructible)
       return S.canThrow(Result.get()) == CT_Cannot;
 
     if (Kind == clang::TT_IsTriviallyConstructible) {
       // Under Objective-C ARC, if the destination has non-trivial Objective-C
       // lifetime, this is a non-trivial construction.
       if (S.getLangOpts().ObjCAutoRefCount &&
           hasNontrivialObjCLifetime(T.getNonReferenceType()))

test/SemaCXX/type-traits.cpp

   { 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))]; }
 }
 
 // Instantiation of __is_trivially_constructible
 template<typename T, typename ...Args>
 struct is_trivially_constructible {
   static const bool value = __is_trivially_constructible(T, Args...);
 };
 

                                             NonTrivialDefault&&>::value))]; }
 
   { int arr[F((is_trivially_constructible<int, int*>::value))]; }
   { int arr[F((is_trivially_constructible<NonTrivialDefault>::value))]; }
   { int arr[F((is_trivially_constructible<ThreeArgCtor, int*, char*, int&>::value))]; }
   { int arr[F((is_trivially_constructible<Abstract>::value))]; } // PR19178
 }
 
+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)))]; }
+
+}
+
 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)];