[clang] adds `__remove_reference` as a compiler built-in

[xbolva00]

Missing description / motivation.

[cjdb]

Merged into D116203.

clang/include/clang/AST/Type.h

 public:
   enum UTTKind {
     EnumUnderlyingType,
     AddCV,
     AddConst,
     AddVolatile,
     RemoveConst,
     RemoveCV,
+    RemoveReference,
     RemoveVolatile,
   };
 
 private:
   /// The untransformed type.
   QualType BaseType;
 
   /// The transformed type if not dependent, otherwise the same as BaseType.

clang/include/clang/Basic/Specifiers.h

enum TypeSpecifierType {
     TST_enum,
     TST_union,
     TST_struct,
     TST_class,     // C++ class type
     TST_interface, // C++ (Microsoft-specific) __interface type
     TST_typename,  // Typedef, C++ class-name or enum name, etc.
     TST_typeofType,
     TST_typeofExpr,
-    TST_decltype,        // C++11 decltype
-    TST_underlyingType,  // __underlying_type for C++11
-    TST_add_const,       // __add_const extension
-    TST_add_cv,          // __add_cv extension
-    TST_add_volatile,    // __add_volatile extension
-    TST_remove_const,    // __remove_const extension
-    TST_remove_cv,       // __remove_cv extension
-    TST_remove_volatile, // __remove_volatile extension
-    TST_auto,            // C++11 auto
-    TST_decltype_auto,   // C++1y decltype(auto)
-    TST_auto_type,       // __auto_type extension
-    TST_unknown_anytype, // __unknown_anytype extension
-    TST_atomic,          // C11 _Atomic,
+    TST_decltype,         // C++11 decltype
+    TST_underlyingType,   // __underlying_type for C++11
+    TST_add_const,        // __add_const extension
+    TST_add_cv,           // __add_cv extension
+    TST_add_volatile,     // __add_volatile extension
+    TST_remove_const,     // __remove_const extension
+    TST_remove_cv,        // __remove_cv extension
+    TST_remove_reference, // __remove_reference extension
+    TST_remove_volatile,  // __remove_volatile extension
+    TST_auto,             // C++11 auto
+    TST_decltype_auto,    // C++1y decltype(auto)
+    TST_auto_type,        // __auto_type extension
+    TST_unknown_anytype,  // __unknown_anytype extension
+    TST_atomic,           // C11 _Atomic,
 #define GENERIC_IMAGE_TYPE(ImgType, Id) TST_##ImgType##_t, // OpenCL image types
 #include "clang/Basic/OpenCLImageTypes.def"
     TST_error // erroneous type
   };
 
   /// Structure that packs information about the type specifiers that
   /// were written in a particular type specifier sequence.
   struct WrittenBuiltinSpecs {

clang/include/clang/Basic/TokenKinds.def

 TYPE_TRAIT_1(__has_unique_object_representations,
              HasUniqueObjectRepresentations, KEYCXX)
 KEYWORD(__underlying_type           , KEYCXX)
 KEYWORD(__add_const, KEYCXX)
 KEYWORD(__add_cv, KEYCXX)
 KEYWORD(__add_volatile, KEYCXX)
 KEYWORD(__remove_const, KEYCXX)
 KEYWORD(__remove_cv, KEYCXX)
+KEYWORD(__remove_reference, KEYCXX)
 KEYWORD(__remove_volatile, KEYCXX)
 
 // Clang-only C++ Type Traits
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 
 // Embarcadero Expression Traits
 EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
 EXPRESSION_TRAIT(__is_rvalue_expr, IsRValueExpr, KEYCXX)

clang/include/clang/Sema/DeclSpec.h

public:
   static const TST TST_decltype = clang::TST_decltype;
   static const TST TST_decltype_auto = clang::TST_decltype_auto;
   static const TST TST_underlyingType = clang::TST_underlyingType;
   static const TST TST_add_const = clang::TST_add_const;
   static const TST TST_add_cv = clang::TST_add_cv;
   static const TST TST_add_volatile = clang::TST_add_volatile;
   static const TST TST_remove_const = clang::TST_remove_const;
   static const TST TST_remove_cv = clang::TST_remove_cv;
+  static const TST TST_remove_reference = clang::TST_remove_reference;
   static const TST TST_remove_volatile = clang::TST_remove_volatile;
   static const TST TST_auto = clang::TST_auto;
   static const TST TST_auto_type = clang::TST_auto_type;
   static const TST TST_unknown_anytype = clang::TST_unknown_anytype;
   static const TST TST_atomic = clang::TST_atomic;
 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
   static const TST TST_##ImgType##_t = clang::TST_##ImgType##_t;
 #include "clang/Basic/OpenCLImageTypes.def"

clang/lib/AST/ItaniumMangle.cpp

switch (T->getUTTKind()) {
         Out << "3av";
         break;
       case UnaryTransformType::RemoveConst:
         Out << "3rc";
         break;
       case UnaryTransformType::RemoveCV:
         Out << "3rcv";
         break;
+      case UnaryTransformType::RemoveReference:
+        Out << "3rr";
+        break;
       case UnaryTransformType::RemoveVolatile:
         Out << "3rv";
         break;
     }
   }
 
   mangleType(T->getBaseType());
 }

clang/lib/AST/JSONNodeDumper.cpp

case UnaryTransformType::AddVolatile:
     JOS.attribute("transformedKind", "add_volatile");
     break;
   case UnaryTransformType::RemoveConst:
     JOS.attribute("transformedKind", "remove_const");
     break;
   case UnaryTransformType::RemoveCV:
     JOS.attribute("transformedKind", "remove_cv");
     break;
+  case UnaryTransformType::RemoveReference:
+    JOS.attribute("transformedKind", "remove_reference");
+    break;
   case UnaryTransformType::RemoveVolatile:
     JOS.attribute("transformedKind", "remove_volatile");
     break;
   }
 }
 
 void JSONNodeDumper::VisitTagType(const TagType *TT) {
   JOS.attribute("decl", createBareDeclRef(TT->getDecl()));

clang/lib/AST/TypePrinter.cpp

void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
 
   switch (T->getUTTKind()) {
     case UnaryTransformType::EnumUnderlyingType:
     case UnaryTransformType::AddConst:
     case UnaryTransformType::AddCV:
     case UnaryTransformType::AddVolatile:
     case UnaryTransformType::RemoveConst:
     case UnaryTransformType::RemoveCV:
+    case UnaryTransformType::RemoveReference:
     case UnaryTransformType::RemoveVolatile: {
-      constexpr std::array<const char *, 7> Transformation = {
-          "__underlying_type", "__add_const",    "__add_cv",
-          "__add_volatile",    "__remove_const", "__remove_cv",
-          "__remove_volatile"};
+      constexpr std::array<const char *, 8> Transformation = {
+          "__underlying_type",  "__add_const",      "__add_cv",
+          "__add_volatile",     "__remove_const",   "__remove_cv",
+          "__remove_reference", "__remove_volatile"};
       OS << Transformation[T->getUTTKind()] << '(';
       print(T->getBaseType(), OS, StringRef());
       OS << ')';
       spaceBeforePlaceHolder(OS);
       return;
     }
   }
 
   printBefore(T->getBaseType(), OS);
 }
 
 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
                                            raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
   switch (T->getUTTKind()) {
     case UnaryTransformType::EnumUnderlyingType:
     case UnaryTransformType::AddConst:
     case UnaryTransformType::AddCV:
     case UnaryTransformType::AddVolatile:
     case UnaryTransformType::RemoveConst:
     case UnaryTransformType::RemoveCV:
+    case UnaryTransformType::RemoveReference:
     case UnaryTransformType::RemoveVolatile:
       return;
   }
 
   printAfter(T->getBaseType(), OS);
 }
 
 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {

clang/lib/Format/FormatToken.cpp

bool FormatToken::isSimpleTypeSpecifier() const {
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
   case tok::kw___add_const:
   case tok::kw___add_cv:
   case tok::kw___add_volatile:
   case tok::kw___remove_const:
   case tok::kw___remove_cv:
+  case tok::kw___remove_reference:
   case tok::kw___remove_volatile:
   case tok::annot_typename:
   case tok::kw_char8_t:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_typeof:
   case tok::kw_decltype:
   case tok::kw__Atomic:

clang/lib/Lex/PPMacroExpansion.cpp

EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
               .Case("__array_extent", true)
               .Case("__reference_binds_to_temporary", true)
               .Case("__underlying_type", true)
               .Case("__add_const", true)
               .Case("__add_cv", true)
               .Case("__add_volatile", true)
               .Case("__remove_const", true)
               .Case("__remove_cv", true)
+              .Case("__remove_reference", true)
               .Case("__remove_volatile", true)
               .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)
               // Likewise for some builtin preprocessor macros.

clang/lib/Parse/ParseDecl.cpp

case tok::kw___underlying_type:
       ParseUnderlyingTypeSpecifier(DS);
       continue;
 
     case tok::kw___add_const:
     case tok::kw___add_cv:
     case tok::kw___add_volatile:
     case tok::kw___remove_const:
     case tok::kw___remove_cv:
+    case tok::kw___remove_reference:
     case tok::kw___remove_volatile:
       ParseTypeTransformTypeSpecifier(DS);
       continue;
 
     case tok::kw__Atomic:
       // C11 6.7.2.4/4:
       //   If the _Atomic keyword is immediately followed by a left parenthesis,
       //   it is interpreted as a type specifier (with a type name), not as a
DeclSpec::TST Parser::TypeTransformTokToDeclSpec() {
   case tok::kw___add_cv:
     return DeclSpec::TST_add_cv;
   case tok::kw___add_volatile:
     return DeclSpec::TST_add_volatile;
   case tok::kw___remove_const:
     return DeclSpec::TST_remove_const;
   case tok::kw___remove_cv:
     return DeclSpec::TST_remove_cv;
+  case tok::kw___remove_reference:
+    return DeclSpec::TST_remove_reference;
   case tok::kw___remove_volatile:
     return DeclSpec::TST_remove_volatile;
   }
 
   __builtin_unreachable();
 }
 
 void Parser::ParseTypeTransformTypeSpecifier(DeclSpec &DS) {

clang/lib/Parse/ParseDeclCXX.cpp

if (TagType == DeclSpec::TST_struct && Tok.isNot(tok::identifier) &&
           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___remove_const, tok::kw___remove_cv,
-          tok::kw___remove_volatile))
+          tok::kw___remove_reference, tok::kw___remove_volatile))
     // 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/Sema/DeclSpec.cpp

case TST_typeofExpr:
       return false;
 
     case TST_underlyingType:
     case TST_add_const:
     case TST_add_cv:
     case TST_add_volatile:
     case TST_remove_const:
     case TST_remove_cv:
+    case TST_remove_reference:
     case TST_remove_volatile:
     case TST_typename:
     case TST_typeofType: {
       QualType QT = DS.getRepAsType().get();
       if (QT.isNull())
         return false;
 
       if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT))
const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
   case DeclSpec::TST_add_cv:
     return "__add_cv";
   case DeclSpec::TST_add_volatile:
     return "__add_volatile";
   case DeclSpec::TST_remove_const:
     return "__remove_const";
   case DeclSpec::TST_remove_cv:
     return "__remove_cv";
+  case DeclSpec::TST_remove_reference:
+    return "__remove_reference";
   case DeclSpec::TST_remove_volatile:
     return "__remove_volatile";
   case DeclSpec::TST_unknown_anytype: return "__unknown_anytype";
   case DeclSpec::TST_atomic: return "_Atomic";
   case DeclSpec::TST_BFloat16: return "__bf16";
 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
   case DeclSpec::TST_##ImgType##_t: \
     return #ImgType "_t";

clang/lib/Sema/SemaDecl.cpp

bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const {
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
   case tok::kw___add_const:
   case tok::kw___add_cv:
   case tok::kw___add_volatile:
   case tok::kw___remove_const:
   case tok::kw___remove_cv:
+  case tok::kw___remove_reference:
   case tok::kw___remove_volatile:
   case tok::kw___auto_type:
     return true;
 
   case tok::annot_typename:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_typeof:
static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D,
   case DeclSpec::TST_typename:
   case DeclSpec::TST_typeofType:
   case DeclSpec::TST_underlyingType:
   case DeclSpec::TST_add_const:
   case DeclSpec::TST_add_cv:
   case DeclSpec::TST_add_volatile:
   case DeclSpec::TST_remove_const:
   case DeclSpec::TST_remove_cv:
+  case DeclSpec::TST_remove_reference:
   case DeclSpec::TST_remove_volatile:
   case DeclSpec::TST_atomic: {
     // Grab the type from the parser.
     TypeSourceInfo *TSI = nullptr;
     QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
     if (T.isNull() || !T->isInstantiationDependentType()) break;
 
     // Make sure there's a type source info.  This isn't really much

clang/lib/Sema/SemaTemplateVariadic.cpp

bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
   case TST_typename:
   case TST_typeofType:
   case TST_underlyingType:
   case TST_add_const:
   case TST_add_cv:
   case TST_add_volatile:
   case TST_remove_const:
   case TST_remove_cv:
+  case TST_remove_reference:
   case TST_remove_volatile:
   case TST_atomic: {
     QualType T = DS.getRepAsType().get();
     if (!T.isNull() && T->containsUnexpandedParameterPack())
       return true;
     break;
   }
 

clang/lib/Sema/SemaType.cpp

TSTToUnaryTransformType(DeclSpec::TST SwitchTST) {
   case TST_add_cv:
     return UnaryTransformType::AddCV;
   case TST_add_volatile:
     return UnaryTransformType::AddVolatile;
   case TST_remove_const:
     return UnaryTransformType::RemoveConst;
   case TST_remove_cv:
     return UnaryTransformType::RemoveCV;
+  case TST_remove_reference:
+    return UnaryTransformType::RemoveReference;
   case TST_remove_volatile:
     return UnaryTransformType::RemoveVolatile;
   case TST_underlyingType:
     return UnaryTransformType::EnumUnderlyingType;
   default:
     llvm_unreachable("attempted to parse a non-unary transform builtin");
   }
 }
case DeclSpec::TST_decltype: {
     break;
   }
   case DeclSpec::TST_underlyingType:
   case DeclSpec::TST_add_const:
   case DeclSpec::TST_add_cv:
   case DeclSpec::TST_add_volatile:
   case DeclSpec::TST_remove_const:
   case DeclSpec::TST_remove_cv:
+  case DeclSpec::TST_remove_reference:
   case DeclSpec::TST_remove_volatile:
     Result = S.GetTypeFromParser(DS.getRepAsType());
     assert(!Result.isNull() && "Didn't get a type for the transformation?");
     Result = S.BuildUnaryTransformType(
         Result, TSTToUnaryTransformType(DS.getTypeSpecType()),
         DS.getTypeSpecTypeLoc());
     if (Result.isNull()) {
       if (DS.getTypeSpecType() == DeclSpec::TST_underlyingType)
if (!BaseType->isDependentType() && !BaseType->isEnumeralType()) {
         DiagnoseUseOfDecl(ED, Loc);
 
         Underlying = ED->getIntegerType();
         assert(!Underlying.isNull());
       }
       return Context.getUnaryTransformType(BaseType, Underlying,
                                         UnaryTransformType::EnumUnderlyingType);
     }
+  case UnaryTransformType::RemoveReference: {
+    QualType Underlying = BaseType.getNonReferenceType();
+    return Context.getUnaryTransformType(BaseType, Underlying,
+                                         UnaryTransformType::RemoveReference);
+  }
   case UnaryTransformType::AddConst:
   case UnaryTransformType::AddCV:
   case UnaryTransformType::AddVolatile:
   case UnaryTransformType::RemoveConst:
   case UnaryTransformType::RemoveCV:
   case UnaryTransformType::RemoveVolatile: {
     SplitQualType Split = BaseType.getSplitUnqualifiedType();
     Qualifiers Quals = BaseType.getQualifiers();

clang/test/SemaCXX/remove_cvref.cpp

 // RUN: %clang_cc1 -std=c++11 %s
 
-template <class T>
+template<class T>
+struct check_remove_reference {
+  constexpr check_remove_reference() {
+    static_assert(__is_same(__remove_reference(T&), T), "");
+    static_assert(__is_same(__remove_reference(const T&), const T), "");
+    static_assert(__is_same(__remove_reference(volatile T&), volatile T), "");
+    static_assert(__is_same(__remove_reference(const volatile T&), const volatile T), "");
+
+    static_assert(__is_same(__remove_reference(T&&), T), "");
+    static_assert(__is_same(__remove_reference(const T&&), const T), "");
+    static_assert(__is_same(__remove_reference(volatile T&&), volatile T), "");
+    static_assert(__is_same(__remove_reference(const volatile T&&), const volatile T), "");
+  }
+};
+
+template<> struct check_remove_reference<void> {};
+template<class T> struct check_remove_reference<T&> {};
+template<class T> struct check_remove_reference<T&&> {};
+
+template <class T>
 constexpr bool check_remove_qualifiers() {
   static_assert(__is_same(__remove_const(const T), T), "");
   static_assert(__is_same(__remove_const(volatile T), volatile T), "");
   static_assert(__is_same(__remove_const(const volatile T), volatile T), "");
 
   static_assert(__is_same(__remove_volatile(const T), const T), "");
   static_assert(__is_same(__remove_volatile(volatile T), T), "");
   static_assert(__is_same(__remove_volatile(const volatile T), const T), "");
 
   static_assert(__is_same(__remove_cv(const T), T), "");
   static_assert(__is_same(__remove_cv(volatile T), T), "");
   static_assert(__is_same(__remove_cv(const volatile T), T), "");
+
+  check_remove_reference<T>();
+
   return true;
 }
 
 static_assert(check_remove_qualifiers<void>(), "");
 static_assert(check_remove_qualifiers<int>(), "");
 static_assert(check_remove_qualifiers<int *>(), "");
 static_assert(check_remove_qualifiers<const int *>(), "");
 static_assert(check_remove_qualifiers<volatile int *>(), "");
 static_assert(check_remove_qualifiers<const volatile int *>(), "");
 static_assert(check_remove_qualifiers<int &>(), "");
 static_assert(check_remove_qualifiers<const int &>(), "");
 static_assert(check_remove_qualifiers<volatile int &>(), "");
 static_assert(check_remove_qualifiers<const volatile int &>(), "");
+static_assert(check_remove_qualifiers<int &&>(), "");
+static_assert(check_remove_qualifiers<const int &&>(), "");
+static_assert(check_remove_qualifiers<volatile int &&>(), "");
+static_assert(check_remove_qualifiers<const volatile int &&>(), "");
 static_assert(check_remove_qualifiers<int()>(), "");
 static_assert(check_remove_qualifiers<int (*)()>(), "");
 static_assert(check_remove_qualifiers<int (&)()>(), "");
 
 struct S {};
 static_assert(check_remove_qualifiers<S>(), "");
 static_assert(check_remove_qualifiers<int S::*>(), "");
 static_assert(check_remove_qualifiers<const int S::*>(), "");