fixup! [Clang] Add __type_list_dedup builtin to deduplicate types in template arguments

ilya-biryukov · ilya-biryukov · commit 52482d31ef06 · 2024-09-13T14:50:51.000+02:00
Rename type_list_dedup to __builtin_type_pack_dedup
diff --git a/clang-tools-extra/clangd/unittests/FindTargetTests.cpp b/clang-tools-extra/clangd/unittests/FindTargetTests.cpp
@@ -734,7 +734,7 @@ TEST_F(TargetDeclTest, BuiltinTemplates) {
 
   Code = R"cpp(
     template <template <class...> class Templ, class... Types>
-    using type_list_dedup = [[__type_list_dedup]]<Templ, Types...>;
+    using __builtin_type_pack_dedup = [[__builtin_type_pack_dedup]]<Templ, Types...>;
   )cpp";
   EXPECT_DECLS("TemplateSpecializationTypeLoc", );
 }
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
@@ -403,8 +403,8 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// The identifier '__type_pack_element'.
   mutable IdentifierInfo *TypePackElementName = nullptr;
 
-  /// The identifier '__type_list_dedup'.
-  mutable IdentifierInfo *TypeListDedupName = nullptr;
+  /// The identifier '__builtin_type_pack_dedup'.
+  mutable IdentifierInfo *TypePackDedupName = nullptr;
 
   QualType ObjCConstantStringType;
   mutable RecordDecl *CFConstantStringTagDecl = nullptr;
@@ -613,7 +613,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
   mutable ExternCContextDecl *ExternCContext = nullptr;
   mutable BuiltinTemplateDecl *MakeIntegerSeqDecl = nullptr;
   mutable BuiltinTemplateDecl *TypePackElementDecl = nullptr;
-  mutable BuiltinTemplateDecl *TypeListDedupDecl = nullptr;
+  mutable BuiltinTemplateDecl *TypePackDedupDecl = nullptr;
 
   /// The associated SourceManager object.
   SourceManager &SourceMgr;
@@ -1121,7 +1121,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
   ExternCContextDecl *getExternCContextDecl() const;
   BuiltinTemplateDecl *getMakeIntegerSeqDecl() const;
   BuiltinTemplateDecl *getTypePackElementDecl() const;
-  BuiltinTemplateDecl *getTypeListDedupDecl() const;
+  BuiltinTemplateDecl *getTypePackDedupDecl() const;
 
   // Builtin Types.
   CanQualType VoidTy;
@@ -2013,10 +2013,10 @@ class ASTContext : public RefCountedBase<ASTContext> {
     return TypePackElementName;
   }
 
-  IdentifierInfo *getTypeListDedupName() const {
-    if (!TypeListDedupName)
-      TypeListDedupName = &Idents.get("__type_list_dedup");
-    return TypeListDedupName;
+  IdentifierInfo *getTypePackDedupName() const {
+    if (!TypePackDedupName)
+      TypePackDedupName = &Idents.get("__builtin_type_pack_dedup");
+    return TypePackDedupName;
   }
 
   /// Retrieve the Objective-C "instancetype" type, if already known;
diff --git a/clang/include/clang/AST/DeclID.h b/clang/include/clang/AST/DeclID.h
@@ -83,8 +83,8 @@ enum PredefinedDeclIDs {
   /// The internal '__type_pack_element' template.
   PREDEF_DECL_TYPE_PACK_ELEMENT_ID,
 
-  /// The internal '__type_list_dedup' template.
-  PREDEF_DECL_TYPE_LIST_DEDUP_ID,
+  /// The internal '__builtin_type_pack_dedup' template.
+  PREDEF_DECL___builtin_type_pack_dedup_ID,
 
   /// The number of declaration IDs that are predefined.
   NUM_PREDEF_DECL_IDS
diff --git a/clang/include/clang/Basic/Builtins.h b/clang/include/clang/Basic/Builtins.h
@@ -311,8 +311,8 @@ enum BuiltinTemplateKind : int {
   /// This names the __type_pack_element BuiltinTemplateDecl.
   BTK__type_pack_element,
 
-  /// This names the __type_list_dedup BuiltinTemplateDecl.
-  BTK__type_list_dedup,
+  /// This names the __builtin_type_pack_dedup BuiltinTemplateDecl.
+  BTK__type_pack_dedup,
 };
 
 } // end namespace clang
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
@@ -1170,11 +1170,11 @@ ASTContext::getTypePackElementDecl() const {
   return TypePackElementDecl;
 }
 
-BuiltinTemplateDecl *ASTContext::getTypeListDedupDecl() const {
-  if (!TypeListDedupDecl)
-    TypeListDedupDecl =
-        buildBuiltinTemplateDecl(BTK__type_list_dedup, getTypeListDedupName());
-  return TypeListDedupDecl;
+BuiltinTemplateDecl *ASTContext::getTypePackDedupDecl() const {
+  if (!TypePackDedupDecl)
+    TypePackDedupDecl =
+        buildBuiltinTemplateDecl(BTK__type_pack_dedup, getTypePackDedupName());
+  return TypePackDedupDecl;
 }
 
 RecordDecl *ASTContext::buildImplicitRecord(StringRef Name,
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
@@ -5467,8 +5467,8 @@ ExpectedDecl ASTNodeImporter::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
   case BuiltinTemplateKind::BTK__type_pack_element:
     ToD = Importer.getToContext().getTypePackElementDecl();
     break;
-  case BuiltinTemplateKind::BTK__type_list_dedup:
-    ToD = Importer.getToContext().getTypeListDedupDecl();
+  case BuiltinTemplateKind::BTK__type_pack_dedup:
+    ToD = Importer.getToContext().getTypePackDedupDecl();
     break;
   }
   assert(ToD && "BuiltinTemplateDecl of unsupported kind!");
diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp
@@ -1609,7 +1609,7 @@ createTypePackElementParameterList(const ASTContext &C, DeclContext *DC) {
 }
 
 static TemplateParameterList *
-createTypeListDedupParameterList(const ASTContext &C, DeclContext *DC) {
+createTypePackDedupParameterList(const ASTContext &C, DeclContext *DC) {
   // template <typename ...> typename Templ
   auto *InnerTs = TemplateTypeParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/0,
@@ -1644,8 +1644,8 @@ static TemplateParameterList *createBuiltinTemplateParameterList(
     return createMakeIntegerSeqParameterList(C, DC);
   case BTK__type_pack_element:
     return createTypePackElementParameterList(C, DC);
-  case BTK__type_list_dedup:
-    return createTypeListDedupParameterList(C, DC);
+  case BTK__type_pack_dedup:
+    return createTypePackDedupParameterList(C, DC);
   }
 
   llvm_unreachable("unhandled BuiltinTemplateKind!");
diff --git a/clang/lib/Lex/PPMacroExpansion.cpp b/clang/lib/Lex/PPMacroExpansion.cpp
@@ -1836,7 +1836,7 @@ void Preprocessor::ExpandBuiltinMacro(Token &Tok) {
               // Report builtin templates as being builtins.
               .Case("__make_integer_seq", getLangOpts().CPlusPlus)
               .Case("__type_pack_element", getLangOpts().CPlusPlus)
-              .Case("__type_list_dedup", getLangOpts().CPlusPlus)
+              .Case("__builtin_type_pack_dedup", 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.
diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp
@@ -933,8 +933,8 @@ bool Sema::LookupBuiltin(LookupResult &R) {
           R.addDecl(getASTContext().getTypePackElementDecl());
           return true;
         }
-        if (II == getASTContext().getTypeListDedupName()) {
-          R.addDecl(getASTContext().getTypeListDedupDecl());
+        if (II == getASTContext().getTypePackDedupName()) {
+          R.addDecl(getASTContext().getTypePackDedupDecl());
           return true;
         }
       }
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
@@ -3161,9 +3161,9 @@ checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD,
     int64_t N = Index.getExtValue();
     return Ts.getPackAsArray()[N].getAsType();
   }
-  case BTK__type_list_dedup: {
+  case BTK__type_pack_dedup: {
     assert(Converted.size() == 2 &&
-           "__type_list_dedup should be given a template and a parameter pack");
+           "__builtin_type_pack_dedup should be given a template and a parameter pack");
     TemplateArgument Template = Converted[0];
     TemplateArgument Ts = Converted[1];
     if (Template.isDependent() || Ts.isDependent())
diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp
@@ -7898,10 +7898,10 @@ Decl *ASTReader::getPredefinedDecl(PredefinedDeclIDs ID) {
       return Context.TypePackElementDecl;
     NewLoaded = Context.getTypePackElementDecl();
     break;
-  case PREDEF_DECL_TYPE_LIST_DEDUP_ID:
-    if (Context.TypeListDedupDecl)
-      return Context.TypeListDedupDecl;
-    NewLoaded = Context.getTypeListDedupDecl();
+  case PREDEF_DECL___builtin_type_pack_dedup_ID:
+    if (Context.TypePackDedupDecl)
+      return Context.TypePackDedupDecl;
+    NewLoaded = Context.getTypePackDedupDecl();
     break;
   case NUM_PREDEF_DECL_IDS:
     llvm_unreachable("Invalid decl ID");
diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp
@@ -5052,7 +5052,7 @@ void ASTWriter::PrepareWritingSpecialDecls(Sema &SemaRef) {
                      PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID);
   RegisterPredefDecl(Context.TypePackElementDecl,
                      PREDEF_DECL_TYPE_PACK_ELEMENT_ID);
-  RegisterPredefDecl(Context.TypeListDedupDecl, PREDEF_DECL_TYPE_LIST_DEDUP_ID);
+  RegisterPredefDecl(Context.TypePackDedupDecl, PREDEF_DECL___builtin_type_pack_dedup_ID);
 
   const TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
 
diff --git a/clang/test/Import/builtin-template/Inputs/S.cpp b/clang/test/Import/builtin-template/Inputs/S.cpp
@@ -17,7 +17,7 @@ struct X;
 
 
 template <template <class...> class Templ, class...Types>
-using TypeListDedup = __type_list_dedup<Templ, Types...>;
+using TypePackDedup = __builtin_type_pack_dedup<Templ, Types...>;
 
 template <class ...Ts>
 struct TypeList {};
diff --git a/clang/test/Import/builtin-template/test.cpp b/clang/test/Import/builtin-template/test.cpp
@@ -5,7 +5,7 @@
 
 // CHECK-SEQ:  BuiltinTemplateDecl {{.+}} <<invalid sloc>> <invalid sloc> implicit __make_integer_seq{{$}}
 // CHECK-PACK: BuiltinTemplateDecl {{.+}} <<invalid sloc>> <invalid sloc> implicit __type_pack_element{{$}}
-// CHECK-DEDUP: BuiltinTemplateDecl {{.+}} <<invalid sloc>> <invalid sloc> implicit __type_list_dedup{{$}}
+// CHECK-DEDUP: BuiltinTemplateDecl {{.+}} <<invalid sloc>> <invalid sloc> implicit __builtin_type_pack_dedup{{$}}
 
 void expr() {
 #ifdef SEQ
@@ -24,8 +24,8 @@ void expr() {
 #endif
 
 #ifdef DEDUP
-  static_assert(__is_same(TypeListDedup<TypeList>, TypeList<>), "");
-  static_assert(__is_same(TypeListDedup<TypeList, int, double, int>, TypeList<int, double>), "");
-  static_assert(__is_same(TypeListDedup<TypeList, X<0>, X<1>, X<1>, X<2>, X<0>>, TypeList<X<0>, X<1>, X<2>>), "");
+  static_assert(__is_same(TypePackDedup<TypeList>, TypeList<>), "");
+  static_assert(__is_same(TypePackDedup<TypeList, int, double, int>, TypeList<int, double>), "");
+  static_assert(__is_same(TypePackDedup<TypeList, X<0>, X<1>, X<1>, X<2>, X<0>>, TypeList<X<0>, X<1>, X<2>>), "");
 #endif
 }
diff --git a/clang/test/PCH/type_pack_dedup.cpp b/clang/test/PCH/type_pack_dedup.cpp
@@ -5,7 +5,7 @@
 // RUN: %clang_cc1 -std=c++14 -x c++ /dev/null -include-pch %t.pch
 
 template <template <class...> class Templ, class...Types>
-using TypeListDedup = __type_list_dedup<Templ, Types...>;
+using TypePackDedup = __builtin_type_pack_dedup<Templ, Types...>;
 
 template <class ...Ts>
 struct TypeList {};
@@ -14,7 +14,7 @@ template <int i>
 struct X {};
 
 void fn1() {
-  TypeList<int, double> l1 = TypeListDedup<TypeList, int, double, int>{};
-  TypeList<> l2 = TypeListDedup<TypeList>{};
-  TypeList<X<0>, X<1>> x1 = TypeListDedup<TypeList, X<0>, X<1>, X<0>, X<1>>{};
+  TypeList<int, double> l1 = TypePackDedup<TypeList, int, double, int>{};
+  TypeList<> l2 = TypePackDedup<TypeList>{};
+  TypeList<X<0>, X<1>> x1 = TypePackDedup<TypeList, X<0>, X<1>, X<0>, X<1>>{};
 }
diff --git a/clang/test/SemaTemplate/temp-param-list-dedup.cpp b/clang/test/SemaTemplate/temp-param-list-dedup.cpp
@@ -3,16 +3,16 @@
 template <typename...> struct TypeList;
 
 static_assert(__is_same(
-  __type_list_dedup<TypeList, int, int*, int, double, float>,
+  __builtin_type_pack_dedup<TypeList, int, int*, int, double, float>,
   TypeList<int, int*, double, float>));
 
 template <template<typename ...> typename Templ, typename ...Types>
 struct Dependent {
-  using empty_list = __type_list_dedup<Templ>;
-  using same = __type_list_dedup<Templ, Types...>;
-  using twice = __type_list_dedup<Templ, Types..., Types...>;
-  using dep_only_types = __type_list_dedup<TypeList, Types...>;
-  using dep_only_template = __type_list_dedup<Templ, int, double, int>;
+  using empty_list = __builtin_type_pack_dedup<Templ>;
+  using same = __builtin_type_pack_dedup<Templ, Types...>;
+  using twice = __builtin_type_pack_dedup<Templ, Types..., Types...>;
+  using dep_only_types = __builtin_type_pack_dedup<TypeList, Types...>;
+  using dep_only_template = __builtin_type_pack_dedup<Templ, int, double, int>;
 }; 
 
 static_assert(__is_same(Dependent<TypeList>::empty_list, TypeList<>));
@@ -31,26 +31,26 @@ static_assert(__is_same(Dependent<TypeList, int*, double*, int*>::dep_only_templ
 template <class ...T>
 using Twice = TypeList<T..., T...>;
 
-static_assert(__is_same(__type_list_dedup<Twice, int, double, int>, TypeList<int, double, int, double>));
+static_assert(__is_same(__builtin_type_pack_dedup<Twice, int, double, int>, TypeList<int, double, int, double>));
 
 
 template <int...> struct IntList;
 // Wrong kinds of template arguments.
-__type_list_dedup<IntList>* wrong_template; // expected-error {{template template argument has different template parameters than its corresponding template template parameter}}
+__builtin_type_pack_dedup<IntList>* wrong_template; // expected-error {{template template argument has different template parameters than its corresponding template template parameter}}
                                             // expected-note@-3 {{template parameter has a different kind in template argument}}
-__type_list_dedup<TypeList, 1, 2, 3>* wrong_template_args; // expected-error  {{template argument for template type parameter must be a type}}
+__builtin_type_pack_dedup<TypeList, 1, 2, 3>* wrong_template_args; // expected-error  {{template argument for template type parameter must be a type}}
                                                            // expected-note@* {{previous template template parameter is here}}
                                                            // expected-note@* {{template parameter from hidden source}}
-__type_list_dedup<> not_enough_args; // expected-error {{too few template arguments for template '__type_list_dedup'}}
+__builtin_type_pack_dedup<> not_enough_args; // expected-error {{too few template arguments for template '__builtin_type_pack_dedup'}}
                                      // expected-note@* {{template declaration from hidden source}}
-__type_list_dedup missing_template_args; // expected-error {{use of template '__type_list_dedup' requires template arguments}}
+__builtin_type_pack_dedup missing_template_args; // expected-error {{use of template '__builtin_type_pack_dedup' requires template arguments}}
                                          // expected-note@* {{template declaration from hidden source}}
 
 // Direct recursive use will fail because the signature of template parameters does not match.
 // The intention for this test is to anticipate a failure mode where compiler may start running the deduplication recursively, going into
 // an infinite loop without diagnosing an error.
 // Currently, the type checking prevents us from it, but if the builtin becomes more generic, we need to be aware of it.
-__type_list_dedup<__type_list_dedup, int, int, double>; // expected-error {{template template argument has different template parameters than its corresponding template template parameter}}
+__builtin_type_pack_dedup<__builtin_type_pack_dedup, int, int, double>; // expected-error {{template template argument has different template parameters than its corresponding template template parameter}}
                                                         // expected-note@* {{template parameter has a different kind in template argument}}
                                                         // expected-note@* {{previous template template parameter is here}}
 

Original file line number	Diff line number	Diff line change
`@@ -734,7 +734,7 @@ TEST_F(TargetDeclTest, BuiltinTemplates) {`
`734`	`734`
`735`	`735`	`Code = R"cpp(`
`736`	`736`	`template <template <class...> class Templ, class... Types>`
`737`		`- using type_list_dedup = [[__type_list_dedup]]<Templ, Types...>;`
	`737`	`+ using __builtin_type_pack_dedup = [[__builtin_type_pack_dedup]]<Templ, Types...>;`
`738`	`738`	`)cpp";`
`739`	`739`	`EXPECT_DECLS("TemplateSpecializationTypeLoc", );`
`740`	`740`	`}`
Original file line number	Diff line number	Diff line change
`@@ -933,8 +933,8 @@ bool Sema::LookupBuiltin(LookupResult &R) {`
`933`	`933`	`R.addDecl(getASTContext().getTypePackElementDecl());`
`934`	`934`	`return true;`
`935`	`935`	`}`
`936`		`- if (II == getASTContext().getTypeListDedupName()) {`
`937`		`- R.addDecl(getASTContext().getTypeListDedupDecl());`
	`936`	`+ if (II == getASTContext().getTypePackDedupName()) {`
	`937`	`+ R.addDecl(getASTContext().getTypePackDedupDecl());`
`938`	`938`	`return true;`
`939`	`939`	`}`
`940`	`940`	`}`