[clang] Add __decay<T> as a builtin template

[troyj]

Summary

__decay(T) exists as a builtin, but does not use template syntax like the other builtin templates __make_integer_seq and __type_pack_element. With template syntax, users can write portable code that uses __decay<T> when it's available but falls back to a __decay<T> in a local namespace when it's not available. Template aliasing can provide the same behavior, but at the cost of longer compile time. It is faster to compile a direct use of a builtin than a use via an alias. This compile time difference is measurable in large TUs that make heavy use of templates. Currently the only performant alternative is to use preprocessor macros in the user's code.

[royjacobson]

I worry about this mangling issue https://github.com/llvm/llvm-project/issues/54993.
For std::make_index_sequence that wasn't that big of a deal, since nobody really uses that as return type of (template) functions, but my guess is that enough people do things like

template<class T>
decay_t<T> copy(T t);

that this might become a problem here.

Also, it would be nice to have some numbers for the 'measurably faster' claim :)

[troyj]

Also, it would be nice to have some numbers for the 'measurably faster' claim :)

Sure. Here's an example of a library change that started using builtins for __make_integer_seq and __type_pack_element https://github.com/facebook/fatal/commit/58102a3f7e66ad122d7d3335c446399b09d5085e where there was a 1.8% speedup for a file that spent 70 seconds in the front end. It also reduced the peak memory usage of the front end by 0.5%. We have reason to believe that a __decay builtin would produce similar benefit. Unfortunately, all of the intrinsics in https://reviews.llvm.org/D116203 were implemented with parentheses syntax instead of as builtin templates, which makes it more difficult. Ideally, we'd like to see all of these implemented as builtin templates, but __decay is the first one that we're proposing.

I'm not familiar with the mangling issue that you mentioned. I'll look into it more.

[cjdb]

In D137458#3909343, @troyj wrote:

Also, it would be nice to have some numbers for the 'measurably faster' claim :)

Sure. Here's an example of a library change that started using builtins for __make_integer_seq and __type_pack_element https://github.com/facebook/fatal/commit/58102a3f7e66ad122d7d3335c446399b09d5085e where there was a 1.8% speedup for a file that spent 70 seconds in the front end. It also reduced the peak memory usage of the front end by 0.5%. We have reason to believe that a __decay builtin would produce similar benefit. Unfortunately, all of the intrinsics in https://reviews.llvm.org/D116203 were implemented with parentheses syntax instead of as builtin templates, which makes it more difficult. Ideally, we'd like to see all of these implemented as builtin templates, but __decay is the first one that we're proposing.

I'm not familiar with the mangling issue that you mentioned. I'll look into it more.

Is there a reason that parentheses are insufficient? @aaron.ballman and I talked about whether or not using angle-brackets would be a better option at one point and concluded that there wasn't any benefit.

clang/include/clang/AST/ASTContext.h

   IdentifierInfo *NSCopyingName = nullptr;
 
   /// The identifier '__make_integer_seq'.
   mutable IdentifierInfo *MakeIntegerSeqName = nullptr;
 
   /// The identifier '__type_pack_element'.
   mutable IdentifierInfo *TypePackElementName = nullptr;
 
+  /// The identifier '__decay'
+  mutable IdentifierInfo *DecayName = nullptr;
+
   QualType ObjCConstantStringType;
   mutable RecordDecl *CFConstantStringTagDecl = nullptr;
   mutable TypedefDecl *CFConstantStringTypeDecl = nullptr;
 
   mutable QualType ObjCSuperType;
 
   QualType ObjCNSStringType;
 

 
   ImportDecl *FirstLocalImport = nullptr;
   ImportDecl *LastLocalImport = nullptr;
 
   TranslationUnitDecl *TUDecl = nullptr;
   mutable ExternCContextDecl *ExternCContext = nullptr;
   mutable BuiltinTemplateDecl *MakeIntegerSeqDecl = nullptr;
   mutable BuiltinTemplateDecl *TypePackElementDecl = nullptr;
+  mutable BuiltinTemplateDecl *DecayDecl = nullptr;
 
   /// The associated SourceManager object.
   SourceManager &SourceMgr;
 
   /// The language options used to create the AST associated with
   ///  this ASTContext object.
   LangOptions &LangOpts;
 

     if (TUDecl)
       NewTUDecl->setPreviousDecl(TUDecl);
     TUDecl = NewTUDecl;
   }
 
   ExternCContextDecl *getExternCContextDecl() const;
   BuiltinTemplateDecl *getMakeIntegerSeqDecl() const;
   BuiltinTemplateDecl *getTypePackElementDecl() const;
+  BuiltinTemplateDecl *getDecayDecl() const;
 
   // Builtin Types.
   CanQualType VoidTy;
   CanQualType BoolTy;
   CanQualType CharTy;
   CanQualType WCharTy;  // [C++ 3.9.1p5].
   CanQualType WideCharTy; // Same as WCharTy in C++, integer type in C99.
   CanQualType WIntTy;   // [C99 7.24.1], integer type unchanged by default promotions.

   }
 
   IdentifierInfo *getTypePackElementName() const {
     if (!TypePackElementName)
       TypePackElementName = &Idents.get("__type_pack_element");
     return TypePackElementName;
   }
 
+  IdentifierInfo *getDecayName() const {
+    if (!DecayName)
+      DecayName = &Idents.get("__decay");
+    return DecayName;
+  }
+
   /// Retrieve the Objective-C "instancetype" type, if already known;
   /// otherwise, returns a NULL type;
   QualType getObjCInstanceType() {
     return getTypeDeclType(getObjCInstanceTypeDecl());
   }
 
   /// Retrieve the typedef declaration corresponding to the Objective-C
   /// "instancetype" type.

clang/include/clang/Basic/Builtins.h

 } // namespace Builtin
 
 /// Kinds of BuiltinTemplateDecl.
 enum BuiltinTemplateKind : int {
   /// This names the __make_integer_seq BuiltinTemplateDecl.
   BTK__make_integer_seq,
 
   /// This names the __type_pack_element BuiltinTemplateDecl.
-  BTK__type_pack_element
+  BTK__type_pack_element,
+
+  /// This names the __decay BuiltinTemplateDecl.
+  BTK__decay
 };
 
 } // end namespace clang
 #endif

clang/include/clang/Serialization/ASTBitCodes.h

   /// The internal '__NSConstantString' typedef.
   PREDEF_DECL_CF_CONSTANT_STRING_ID = 15,
 
   /// The internal '__NSConstantString' tag type.
   PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID = 16,
 
   /// The internal '__type_pack_element' template.
   PREDEF_DECL_TYPE_PACK_ELEMENT_ID = 17,
+
+  /// The internal '__decay' template.
+  PREDEF_DECL_DECAY_ID = 18,
 };
 
 /// The number of declaration IDs that are predefined.
 ///
 /// For more information about predefined declarations, see the
 /// \c PredefinedDeclIDs type and the PREDEF_DECL_*_ID constants.
 const unsigned int NUM_PREDEF_DECL_IDS = 18;
 

clang/lib/AST/ASTContext.cpp

 BuiltinTemplateDecl *
 ASTContext::getTypePackElementDecl() const {
   if (!TypePackElementDecl)
     TypePackElementDecl = buildBuiltinTemplateDecl(BTK__type_pack_element,
                                                    getTypePackElementName());
   return TypePackElementDecl;
 }
 
+BuiltinTemplateDecl *ASTContext::getDecayDecl() const {
+  if (!DecayDecl)
+    DecayDecl = buildBuiltinTemplateDecl(BTK__decay, getDecayName());
+  return DecayDecl;
+}
+
 RecordDecl *ASTContext::buildImplicitRecord(StringRef Name,
                                             RecordDecl::TagKind TK) const {
   SourceLocation Loc;
   RecordDecl *NewDecl;
   if (getLangOpts().CPlusPlus)
     NewDecl = CXXRecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc,
                                     Loc, &Idents.get(Name));
   else

clang/lib/AST/ASTImporter.cpp

   Decl* ToD = nullptr;
   switch (D->getBuiltinTemplateKind()) {
   case BuiltinTemplateKind::BTK__make_integer_seq:
     ToD = Importer.getToContext().getMakeIntegerSeqDecl();
     break;
   case BuiltinTemplateKind::BTK__type_pack_element:
     ToD = Importer.getToContext().getTypePackElementDecl();
     break;
+  case BuiltinTemplateKind::BTK__decay:
+    ToD = Importer.getToContext().getDecayDecl();
+    break;
   }
   assert(ToD && "BuiltinTemplateDecl of unsupported kind!");
   Importer.MapImported(D, ToD);
   return ToD;
 }
 
 Error ASTNodeImporter::ImportDefinition(
     ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, ImportDefinitionKind Kind) {

clang/lib/AST/DeclTemplate.cpp

 
   // template <std::size_t Index, typename ...T>
   NamedDecl *Params[] = {Index, Ts};
   return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
                                        llvm::makeArrayRef(Params),
                                        SourceLocation(), nullptr);
 }
 
+static TemplateParameterList *createDecayParameterList(const ASTContext &C,
+                                                       DeclContext *DC) {
+  // typename
+  auto *T = TemplateTypeParmDecl::Create(
+      C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/0,
+      /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false,
+      /*HasTypeConstraint=*/false);
+
+  NamedDecl *Params[] = {T};
+  return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
+                                       llvm::makeArrayRef(Params),
+                                       SourceLocation(), nullptr);
+}
+
 static TemplateParameterList *createBuiltinTemplateParameterList(
     const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK) {
   switch (BTK) {
   case BTK__make_integer_seq:
     return createMakeIntegerSeqParameterList(C, DC);
   case BTK__type_pack_element:
     return createTypePackElementParameterList(C, DC);
+  case BTK__decay:
+    return createDecayParameterList(C, DC);
   }
 
   llvm_unreachable("unhandled BuiltinTemplateKind!");
 }
 
 void BuiltinTemplateDecl::anchor() {}
 
 BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,

clang/lib/Lex/PPMacroExpansion.cpp

 #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)
+              .Case("__decay", getLangOpts().CPlusPlus)
               // Likewise for some builtin preprocessor macros.
               // FIXME: This is inconsistent; we usually suggest detecting
               // builtin macros via #ifdef. Don't add more cases here.
               .Case("__is_target_arch", true)
               .Case("__is_target_vendor", true)
               .Case("__is_target_os", true)
               .Case("__is_target_environment", true)
               .Case("__is_target_variant_os", true)

clang/lib/Sema/SemaLookup.cpp

     if (II) {
       if (getLangOpts().CPlusPlus && NameKind == Sema::LookupOrdinaryName) {
         if (II == getASTContext().getMakeIntegerSeqName()) {
           R.addDecl(getASTContext().getMakeIntegerSeqDecl());
           return true;
         } else if (II == getASTContext().getTypePackElementName()) {
           R.addDecl(getASTContext().getTypePackElementDecl());
           return true;
+        } else if (II == getASTContext().getDecayName()) {
+          R.addDecl(getASTContext().getDecayDecl());
+          return true;
         }
       }
 
       // Check if this is an OpenCL Builtin, and if so, insert its overloads.
       if (getLangOpts().OpenCL && getLangOpts().DeclareOpenCLBuiltins) {
         auto Index = isOpenCLBuiltin(II->getName());
         if (Index.first) {
           InsertOCLBuiltinDeclarationsFromTable(*this, R, II, Index.first - 1,

clang/lib/Sema/SemaTemplate.cpp

     }
 
     // The first template argument will be reused as the template decl that
     // our synthetic template arguments will be applied to.
     return SemaRef.CheckTemplateIdType(Converted[0].getAsTemplate(),
                                        TemplateLoc, SyntheticTemplateArgs);
   }
 
-  case BTK__type_pack_element:
+  case BTK__type_pack_element: {
     // Specializations of
     //    __type_pack_element<Index, T_1, ..., T_N>
     // are treated like T_Index.
     assert(Converted.size() == 2 &&
       "__type_pack_element should be given an index and a parameter pack");
 
     TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
     if (IndexArg.isDependent() || Ts.isDependent())

                    diag::err_type_pack_element_out_of_bounds);
       return QualType();
     }
 
     // We simply return the type at index `Index`.
     int64_t N = Index.getExtValue();
     return Ts.getPackAsArray()[N].getAsType();
   }
+
+  case BTK__decay:
+    assert(Converted.size() == 1 && "__decay should be given a single type");
+    TemplateArgument Ty = Converted[0];
+    return SemaRef.BuiltinDecay(Ty.getAsType(), TemplateArgs[0].getLocation());
+  }
   llvm_unreachable("unexpected BuiltinTemplateDecl!");
 }
 
 /// Determine whether this alias template is "enable_if_t".
 /// libc++ >=14 uses "__enable_if_t" in C++11 mode.
 static bool isEnableIfAliasTemplate(TypeAliasTemplateDecl *AliasTemplate) {
   return AliasTemplate->getName().equals("enable_if_t") ||
          AliasTemplate->getName().equals("__enable_if_t");

clang/lib/Serialization/ASTReader.cpp

   case PREDEF_DECL_CF_CONSTANT_STRING_ID:
     return Context.getCFConstantStringDecl();
 
   case PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID:
     return Context.getCFConstantStringTagDecl();
 
   case PREDEF_DECL_TYPE_PACK_ELEMENT_ID:
     return Context.getTypePackElementDecl();
+
+  case PREDEF_DECL_DECAY_ID:
+    return Context.getDecayDecl();
   }
   llvm_unreachable("PredefinedDeclIDs unknown enum value");
 }
 
 Decl *ASTReader::GetExistingDecl(DeclID ID) {
   assert(ContextObj && "reading decl with no AST context");
   if (ID < NUM_PREDEF_DECL_IDS) {
     Decl *D = getPredefinedDecl(*ContextObj, (PredefinedDeclIDs)ID);

clang/lib/Serialization/ASTWriter.cpp

   RegisterPredefDecl(Context.MakeIntegerSeqDecl,
                      PREDEF_DECL_MAKE_INTEGER_SEQ_ID);
   RegisterPredefDecl(Context.CFConstantStringTypeDecl,
                      PREDEF_DECL_CF_CONSTANT_STRING_ID);
   RegisterPredefDecl(Context.CFConstantStringTagDecl,
                      PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID);
   RegisterPredefDecl(Context.TypePackElementDecl,
                      PREDEF_DECL_TYPE_PACK_ELEMENT_ID);
+  RegisterPredefDecl(Context.DecayDecl, PREDEF_DECL_DECAY_ID);
 
   // Build a record containing all of the tentative definitions in this file, in
   // TentativeDefinitions order.  Generally, this record will be empty for
   // headers.
   RecordData TentativeDefinitions;
   AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions);
 
   // Build a record containing all of the file scoped decls in this file.

clang/test/SemaCXX/libstdcxx_transform_type_traits_hack.cpp

 using I = Same<__remove_reference_t<T>, __remove_reference_t<T>>;
 
 template <class T>
 using __remove_cvref = int; // expected-warning{{keyword '__remove_cvref' will be made available as an identifier here}}
 template <class T>
 using J = Same<__remove_cvref<T>, __remove_cvref<T>>;
 
 template <class T>
-using __decay = int; // expected-warning{{keyword '__decay' will be made available as an identifier here}}
-template <class T>
-using K = Same<__decay<T>, __decay<T>>;
-
-template <class T>
 using __make_signed = int; // expected-warning{{keyword '__make_signed' will be made available as an identifier here}}
 template <class T>
 using L = Same<__make_signed<T>, __make_signed<T>>;
 
 template <class T>
 using __make_unsigned = int; // expected-warning{{keyword '__make_unsigned' will be made available as an identifier here}}
 template <class T>
 using M = Same<__make_unsigned<T>, __make_unsigned<T>>;

clang/test/SemaCXX/type-traits.cpp

   static_assert(__is_same(decay_t<const volatile S &&>, S), "");
   static_assert(__is_same(decay_t<int S::*const volatile>, int S::*), "");
   static_assert(__is_same(decay_t<int (S::*const volatile)()>, int(S::*)()), "");
   static_assert(__is_same(decay_t<int S::*const volatile &>, int S::*), "");
   static_assert(__is_same(decay_t<int (S::*const volatile &)()>, int(S::*)()), "");
   static_assert(__is_same(decay_t<int S::*const volatile &&>, int S::*), "");
 }
 
+void check_decay_template() {
+  static_assert(__is_same(__decay<void>, void), "");
+  static_assert(__is_same(__decay<const volatile void>, void), "");
+  static_assert(__is_same(__decay<int>, int), "");
+  static_assert(__is_same(__decay<const int>, int), "");
+  static_assert(__is_same(__decay<volatile int>, int), "");
+  static_assert(__is_same(__decay<const volatile int>, int), "");
+  static_assert(__is_same(__decay<int *>, int *), "");
+  static_assert(__is_same(__decay<int *const volatile>, int *), "");
+  static_assert(__is_same(__decay<int *const volatile __restrict>, int *), "");
+  static_assert(__is_same(__decay<int const *const volatile>, int const *), "");
+  static_assert(__is_same(__decay<int const *const volatile _Nonnull>, int const *), "");
+  static_assert(__is_same(__decay<int &>, int), "");
+  static_assert(__is_same(__decay<int const volatile &>, int), "");
+  static_assert(__is_same(__decay<int &&>, int), "");
+  static_assert(__is_same(__decay<int const volatile &&>, int), "");
+  static_assert(__is_same(__decay<int()>, int (*)()), "");
+  static_assert(__is_same(__decay<int (*)()>, int (*)()), "");
+  static_assert(__is_same(__decay<int (*const)()>, int (*)()), "");
+  static_assert(__is_same(__decay<int (*volatile)()>, int (*)()), "");
+  static_assert(__is_same(__decay<int (*const volatile)()>, int (*)()), "");
+  static_assert(__is_same(__decay<int (&)()>, int (*)()), "");
+  static_assert(__is_same(__decay<IntAr>, int *), "");
+  static_assert(__is_same(__decay<IntArNB>, int *), "");
+
+  static_assert(__is_same(__decay<S>, S), "");
+  static_assert(__is_same(__decay<S &>, S), "");
+  static_assert(__is_same(__decay<S &&>, S), "");
+  static_assert(__is_same(__decay<const S>, S), "");
+  static_assert(__is_same(__decay<const S &>, S), "");
+  static_assert(__is_same(__decay<const S &&>, S), "");
+  static_assert(__is_same(__decay<volatile S>, S), "");
+  static_assert(__is_same(__decay<volatile S &>, S), "");
+  static_assert(__is_same(__decay<volatile S &&>, S), "");
+  static_assert(__is_same(__decay<const volatile S>, S), "");
+  static_assert(__is_same(__decay<const volatile S &>, S), "");
+  static_assert(__is_same(__decay<const volatile S &&>, S), "");
+  static_assert(__is_same(__decay<int S::*const volatile>, int S::*), "");
+  static_assert(__is_same(__decay<int (S::*const volatile)()>, int(S::*)()), "");
+  static_assert(__is_same(__decay<int S::*const volatile &>, int S::*), "");
+  static_assert(__is_same(__decay<int (S::*const volatile &)()>, int(S::*)()), "");
+  static_assert(__is_same(__decay<int S::*const volatile &&>, int S::*), "");
+}
+
 template <class T> struct CheckAbominableFunction {};
 template <class M>
 struct CheckAbominableFunction<M S::*> {
   static void checks() {
     static_assert(__is_same(add_lvalue_reference_t<M>, M), "");
     static_assert(__is_same(add_pointer_t<M>, M), "");
     static_assert(__is_same(add_rvalue_reference_t<M>, M), "");
     static_assert(__is_same(decay_t<M>, M), "");