[Clang] Add builtin templates to deduplicate and sort types in template arguments

The two new additions are:
- `__builtin_dedup_types` allows to efficiently remove duplicate
  types from template arguments.
- `__builtin_sort_types` allows to sort a list of types by their mangled
  names.

They are multivalued templates that can only be used directly in the
template argument lists and get immediately expanded as soon as results
of the computation are available. It allows easily combining them, e.g.:

```cpp
std::tuple<
  __builtin_sort_types<
    __builtin_dedup_types<int, double, T...>>> tuple_;
```

Compiler will warn when those builtin templates are used outside of
template arguments:
```cpp
// These are disallowed.
__builtin_sort_types<int, int> var;
template<class T = __builtin_sort_types<int, int>>
struct Type {};
template<template<class...> T = __builtin_sort_types>
struct Type {};
```

Another helper `__builtin_expand_types` just returns the list of its
arguments unchanged and is useful to simplify the implementation of
other multivalued builtin templates as a holder for the results of that
computation.

We have observed that deduplication code is quite common in our internal
codebase and this builtin allows to have significant savings (up to 25% of
compile time on targets that already take 3 minutes to compile).
The same builtin is also used widely enough in the codebase that we
expect a savings from a long tail of uses, too, although it is hard to
put an estimate on this number in advance.

Author: ilya-biryukov

clang-tools-extra/clangd/unittests/FindTargetTests.cpp

@@ -731,6 +731,12 @@ TEST_F(TargetDeclTest, BuiltinTemplates) {
     using type_pack_element = [[__type_pack_element]]<N, Pack...>;
   )cpp";
   EXPECT_DECLS("TemplateSpecializationTypeLoc", );
+
+  Code = R"cpp(
+    template <template <class...> class Templ, class... Types>
+    using dedup_types = [[__builtin_dedup_types]]<Templ, Types...>;
+  )cpp";
+  EXPECT_DECLS("TemplateSpecializationTypeLoc", );
 }
 
 TEST_F(TargetDeclTest, MemberOfTemplate) {

clang/include/clang/AST/DeclTemplate.h

@@ -1796,6 +1796,9 @@ class BuiltinTemplateDecl : public TemplateDecl {
   BuiltinTemplateKind getBuiltinTemplateKind() const { return BTK; }
 };
 
+bool isMultivaluedBuiltinTemplate(TemplateDecl *D);
+bool isMultivaluedBuiltinTemplateName(TemplateName N);
+
 /// Provides information about an explicit instantiation of a variable or class
 /// template.
 struct ExplicitInstantiationInfo {

clang/include/clang/Basic/BuiltinTemplates.td

@@ -50,3 +50,17 @@ def __builtin_common_type : BuiltinTemplate<
    Template<[Class<"TypeMember">], "HasTypeMember">,
    Class<"HasNoTypeMember">,
    Class<"Ts", /*is_variadic=*/1>]>;
+
+
+// template <class ...Args>
+def __builtin_expand_types : BuiltinTemplate<
+  [Class<"Args", /*is_variadic=*/1>]>;
+
+// template <class ...Args>
+def __builtin_dedup_types : BuiltinTemplate<
+  [Class<"Args", /*is_variadic=*/1>]>;
+
+// template <class ...Args>
+def __builtin_sort_types : BuiltinTemplate<
+  [Class<"Args", /*is_variadic=*/1>]>;
+

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -3147,6 +3147,10 @@ def err_integer_sequence_integral_element_type : Error<
 def err_type_pack_element_out_of_bounds : Error<
   "a parameter pack may not be accessed at an out of bounds index">;
 
+// Multivalued builtin templates, e.g. __builtin_dedup_types and __builtin_sort_types
+def err_multivalued_builtin_template_outside_template_args : Error<
+  "%0 can only be used directly inside a template argument list and cannot have type qualifiers">;
+
 // Objective-C++
 def err_objc_decls_may_only_appear_in_global_scope : Error<
   "Objective-C declarations may only appear in global scope">;

clang/lib/AST/DeclTemplate.cpp

@@ -273,6 +273,20 @@ void *allocateDefaultArgStorageChain(const ASTContext &C) {
   return new (C) char[sizeof(void*) * 2];
 }
 
+bool isMultivaluedBuiltinTemplate(TemplateDecl *D) {
+  auto *BD = llvm::dyn_cast<BuiltinTemplateDecl>(D);
+  return BD &&
+         (BD->getBuiltinTemplateKind() == clang::BTK__builtin_sort_types ||
+          BD->getBuiltinTemplateKind() == clang::BTK__builtin_expand_types ||
+          BD->getBuiltinTemplateKind() == clang::BTK__builtin_dedup_types);
+}
+
+bool isMultivaluedBuiltinTemplateName(TemplateName N) {
+  if (N.getKind() == TemplateName::DeducedTemplate)
+    return false;
+  auto *T = N.getAsTemplateDecl();
+  return T && isMultivaluedBuiltinTemplate(T);
+}
 } // namespace clang
 
 //===----------------------------------------------------------------------===//

clang/lib/Parse/ParseTemplate.cpp

@@ -13,14 +13,17 @@
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/Basic/Builtins.h"
 #include "clang/Basic/DiagnosticParse.h"
+#include "clang/Basic/DiagnosticSema.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/EnterExpressionEvaluationContext.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/SemaDiagnostic.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/TimeProfiler.h"
 using namespace clang;
 
@@ -1469,6 +1472,17 @@ ParsedTemplateArgument Parser::ParseTemplateTemplateArgument() {
     }
   }
 
+  // We do not allow to reference builtin templates that produce multiple
+  // values, they would not have a well-defined semantics outside template
+  // arguments.
+  if (auto *T = !Result.isInvalid()
+                    ? Result.getAsTemplate().get().getAsTemplateDecl()
+                    : nullptr;
+      T && isMultivaluedBuiltinTemplate(T)) {
+    Actions.diagnoseMissingTemplateArguments(Result.getAsTemplate().get(),
+                                             Result.getLocation());
+  }
+
   // If this is a pack expansion, build it as such.
   if (EllipsisLoc.isValid() && !Result.isInvalid())
     Result = Actions.ActOnPackExpansion(Result, EllipsisLoc);

clang/lib/Sema/SemaTemplate.cpp

@@ -17,7 +17,12 @@
 #include "clang/AST/DynamicRecursiveASTVisitor.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/AST/Mangle.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/TemplateBase.h"
 #include "clang/AST/TemplateName.h"
+#include "clang/AST/Type.h"
+#include "clang/AST/TypeOrdering.h"
 #include "clang/AST/TypeVisitor.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/DiagnosticSema.h"
@@ -36,9 +41,16 @@
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallBitVector.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/SaveAndRestore.h"
+#include "llvm/Support/raw_ostream.h"
 
 #include <optional>
 using namespace clang;
@@ -3320,6 +3332,78 @@ checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD,
     }
     return HasNoTypeMember;
   }
+  case BTK__builtin_dedup_types: {
+    assert(Converted.size() == 1 && "__builtin_dedup_types should be given "
+                                    "a parameter pack");
+    TemplateArgument Ts = Converted[0];
+    // Delay the computation until we can compute the final result. We choose
+    // not to remove the duplicates upfront before substitution to keep the code
+    // simple.
+    if (Ts.isDependent())
+      return Context.getCanonicalTemplateSpecializationType(TemplateName(BTD),
+                                                            Converted);
+    assert(Ts.getKind() == clang::TemplateArgument::Pack);
+    llvm::SmallVector<TemplateArgument> OutArgs;
+    llvm::SmallDenseSet<QualType> Seen;
+    // Synthesize a new template argument list, removing duplicates.
+    for (auto T : Ts.getPackAsArray()) {
+      assert(T.getKind() == clang::TemplateArgument::Type);
+      if (!Seen.insert(T.getAsType().getCanonicalType()).second)
+        continue;
+      OutArgs.push_back(T);
+    }
+    // Return __builtin_expand_types, it will handle the final expansion.
+    return Context.getCanonicalTemplateSpecializationType(
+        TemplateName(Context.get__builtin_expand_typesDecl()), OutArgs);
+  }
+  case BTK__builtin_sort_types: {
+    assert(Converted.size() == 1);
+    assert(Converted[0].getKind() == TemplateArgument::Pack);
+    // Delay if we have any dependencies, the mangled names may change after
+    // subsistution or may not be well-defined for dependent types.
+    if (Converted[0].isDependent())
+      return Context.getCanonicalTemplateSpecializationType(TemplateName(BTD),
+                                                            Converted);
+
+    auto InputArgs = Converted[0].getPackAsArray();
+    std::unique_ptr<MangleContext> Mangler(
+        SemaRef.getASTContext().createMangleContext());
+
+    // Prepare our sort keys, i.e. the mangled names.
+    llvm::SmallVector<std::string> MangledNames(InputArgs.size());
+    for (unsigned I = 0; I < InputArgs.size(); ++I) {
+      llvm::raw_string_ostream OS(MangledNames[I]);
+      Mangler->mangleCanonicalTypeName(
+          InputArgs[I].getAsType().getCanonicalType(), OS);
+    }
+
+    // Sort array of indices into the InputArgs/MangledNames.
+    llvm::SmallVector<unsigned> Indexes(InputArgs.size());
+    for (unsigned I = 0; I < InputArgs.size(); ++I) {
+      Indexes[I] = I;
+    }
+    llvm::stable_sort(Indexes, [&](unsigned L, unsigned R) {
+      return MangledNames[L] < MangledNames[R];
+    });
+
+    llvm::SmallVector<TemplateArgument> SortedArguments;
+    SortedArguments.reserve(InputArgs.size());
+    for (unsigned I : Indexes)
+      SortedArguments.push_back(InputArgs[I]);
+
+    // Use __builtin_expand_types to indicate we now have the final results.
+    return Context.getCanonicalTemplateSpecializationType(
+        TemplateName(Context.get__builtin_expand_typesDecl()), SortedArguments);
+  }
+  case BTK__builtin_expand_types: {
+    assert(Converted.size() == 1);
+    assert(Converted[0].getKind() == TemplateArgument::Pack);
+    auto InputArgs = Converted[0].getPackAsArray();
+    // Just return he inputs as is, the code processing template argument lists
+    // recognizes our builtin and does the actual expansion.
+    return Context.getCanonicalTemplateSpecializationType(TemplateName(BTD),
+                                                          InputArgs);
+  }
   }
   llvm_unreachable("unexpected BuiltinTemplateDecl!");
 }
@@ -5501,6 +5585,70 @@ static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc,
   return true;
 }
 
+/// If there is a top-level __builtin_expand_types, it gets expanded and
+/// replaced with its underlying arguments.
+static void
+TryExpandBuiltinTemplateArgumentWrapper(Sema &S,
+                                        TemplateArgumentListInfo &ArgList) {
+  auto &Context = S.getASTContext();
+  llvm::ArrayRef<TemplateArgumentLoc> Args = ArgList.arguments();
+
+  // These builtins are rare, so defer doing anything until we actually see one.
+  llvm::SmallVector<unsigned> ExpandableIndices;
+  for (unsigned I = 0; I < Args.size(); ++I) {
+    auto A = Args[I].getArgument();
+    if (A.getKind() != TemplateArgument::Type)
+      continue;
+    auto *TST = A.getAsType()
+                    .getDesugaredType(Context)
+                    ->getAs<TemplateSpecializationType>();
+    if (!TST)
+      continue;
+    auto TName = TST->getTemplateName();
+    if (TName.getKind() == TemplateName::DeducedTemplate)
+      continue;
+    auto *T = dyn_cast_or_null<BuiltinTemplateDecl>(TName.getAsTemplateDecl());
+    if (!T || T->getBuiltinTemplateKind() != clang::BTK__builtin_expand_types)
+      continue;
+    ExpandableIndices.push_back(I);
+  }
+  if (ExpandableIndices.empty())
+    return;
+
+  // We know that some expansion needs to take place, so prepare to do it.
+  TemplateArgumentListInfo ExpandedArgList;
+  unsigned NextUnprocessedArg = 0;
+  auto CopyUpTo = [&](unsigned J) {
+    for (; NextUnprocessedArg < J; ++NextUnprocessedArg) {
+      ExpandedArgList.addArgument(ArgList[NextUnprocessedArg]);
+    }
+  };
+
+  // Do the actual expansion by looping over the indices we identified before.
+  for (unsigned NextExpandable : ExpandableIndices) {
+    CopyUpTo(NextExpandable);
+    // FIXME: attemp to carry around source location information.
+    auto ToExpand = Args[NextExpandable]
+                        .getArgument()
+                        .getAsType()
+                        .getDesugaredType(Context)
+                        ->getAs<TemplateSpecializationType>()
+                        ->template_arguments();
+    for (TemplateArgument A : ToExpand) {
+      assert(A.getKind() == TemplateArgument::Type);
+      ExpandedArgList.addArgument(TemplateArgumentLoc(
+          A, Context.getTrivialTypeSourceInfo(A.getAsType())));
+    }
+    NextUnprocessedArg = NextExpandable + 1;
+  }
+
+  // Carry over any leftovers.
+  CopyUpTo(ArgList.size());
+  assert(NextUnprocessedArg == ArgList.size());
+
+  ArgList = std::move(ExpandedArgList);
+}
+
 /// Check that the given template argument list is well-formed
 /// for specializing the given template.
 bool Sema::CheckTemplateArgumentList(
@@ -5517,6 +5665,10 @@ bool Sema::CheckTemplateArgumentList(
   // template.
   TemplateArgumentListInfo NewArgs = TemplateArgs;
 
+  // Process any immediate pack expansions from builtin templates.
+  // E.g. from __builtin_sort_types.
+  TryExpandBuiltinTemplateArgumentWrapper(*this, NewArgs);
+
   TemplateParameterList *Params = GetTemplateParameterList(Template);
 
   SourceLocation RAngleLoc = NewArgs.getRAngleLoc();

clang/lib/Sema/SemaType.cpp

@@ -4327,6 +4327,25 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
     }
   }
 
+  // Some builtin templates can be used in very limited ways, i.e. they must be
+  // used in template arguments and cannot have any qualifiers or form
+  // complicated types. Diagnose any misuses.
+  if (auto *TST = declSpecType.getDesugaredType(Context)
+                      ->getAs<TemplateSpecializationType>();
+      TST && isMultivaluedBuiltinTemplateName(TST->getTemplateName())) {
+    if (D.getNumTypeObjects() != 0 || D.getDeclSpec().getTypeQualifiers() ||
+        D.getContext() != DeclaratorContext::TemplateArg) {
+      // Use non-desugared type in diagnostics for better error messages.
+      S.Diag(D.getDeclSpec().getBeginLoc(),
+             diag::err_multivalued_builtin_template_outside_template_args)
+          << declSpecType->getAs<TemplateSpecializationType>()
+                 ->getTemplateName();
+      // No need to change anything after reporting an error, we should be able
+      // to recover going forward by never actually expanding the builtin to its
+      // template arguments.
+    }
+  }
+
   // Determine whether we should infer _Nonnull on pointer types.
   std::optional<NullabilityKind> inferNullability;
   bool inferNullabilityCS = false;

clang/test/Import/builtin-template/Inputs/S.cpp

@@ -14,3 +14,10 @@ using TypePackElement = __type_pack_element<i, T...>;
 
 template <int i>
 struct X;
+
+
+template <template <class...> class Templ, class...Types>
+using TypePackDedup = Templ<__builtin_dedup_types<Types...>>;
+
+template <class ...Ts>
+struct TypeList {};

clang/test/Import/builtin-template/test.cpp

@@ -1,9 +1,11 @@
 // RUN: clang-import-test -dump-ast -import %S/Inputs/S.cpp -expression %s -Xcc -DSEQ | FileCheck --check-prefix=CHECK-SEQ %s
 // RUN: clang-import-test -dump-ast -import %S/Inputs/S.cpp -expression %s -Xcc -DPACK | FileCheck --check-prefix=CHECK-PACK %s
-// RUN: clang-import-test -dump-ast -import %S/Inputs/S.cpp -expression %s -Xcc -DPACK -Xcc -DSEQ | FileCheck --check-prefixes=CHECK-SEQ,CHECK-PACK %s
+// RUN: clang-import-test -dump-ast -import %S/Inputs/S.cpp -expression %s -Xcc -DDEDUP | FileCheck --check-prefix=CHECK-DEDUP %s
+// RUN: clang-import-test -dump-ast -import %S/Inputs/S.cpp -expression %s -Xcc -DPACK -Xcc -DSEQ -Xcc -DDEDUP | FileCheck --check-prefixes=CHECK-SEQ,CHECK-PACK,CHECK-DEDUP %s
 
 // 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 __builtin_dedup_types{{$}}
 
 void expr() {
 #ifdef SEQ
@@ -20,4 +22,10 @@ void expr() {
   static_assert(__is_same(TypePackElement<0, X<0>, X<1>>, X<0>), "");
   static_assert(__is_same(TypePackElement<1, X<0>, X<1>>, X<1>), "");
 #endif
+
+#ifdef DEDUP
+  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
 }