https://github.com/ilya-biryukov updated
https://github.com/llvm/llvm-project/pull/106730
>From e2d345d490d73f46d969b9a5945d9bfe11e148f9 Mon Sep 17 00:00:00 2001
From: Ilya Biryukov <ibiryu...@google.com>
Date: Fri, 23 Aug 2024 17:27:26 +0200
Subject: [PATCH 1/2] [Clang] Add builtins that deduplicate and sort types
The two new additions are:
- `__builtin_dedup_pack` removes duplicates from list of types.
- `__builtin_sort_pack` sorts types by mangled name.
The added builtins are special in that they produce an unexpanded pack
in the spirit of CWG #YYY proposal.
Produced packs can be used directly in template argument lists and get
immediately expanded as soon as results of the computation are
available.
It allows easily combining them, e.g.:
```cpp
template <class ...T>
struct Normalize {
using result = std::tuple<
__builtin_sort_pack<
__builtin_dedup_pack<int, double, T...>...
>...>;
}
;
```
Limitations:
- only supported in template arguments (e.g. no bases, etc),
- can only be used inside the templates, even if non-dependent,
- the builtins cannot be assigned to template template parameters.
The actual implementation proceeds as follows:
- When the compiler encounters a `__builtin_dedup_pack` or other type-producing
builtin with dependent arguments, it creates a dependent
`TemplateSpecializationType`.
- During substitution, if the template arguments are non-dependent, we
will produce: a new type `SubstBuiltinTemplatePackType`, which stores
an argument pack that needs to be substituted. This type is similar to
the existing `SubstTemplateParmPack` in that it carries the argument
pack that needs to be expanded further. The relevant code is shared.
- On top of that, we also wrap the resulting type into
`TemplateSpecializationType`, but this time only as a sugar.
- To actually expand those packs, we collect the produced
`SubstBuiltinTemplatePackType` inside `CollectUnexpandedPacks`.
Because we know the size of the produces packs only after the initial
substitution, places that do the actual expansion will need to have a
second run over the substituted type to finalize the expansions (in
this patch we only support this for template arguments, see
`ExpandTemplateArgument`).
TODO before commiting:
- produce an error when builtins packs are used outside templates,
- add release notes and documentation,
- update tests in FindTarget (and any other tooling-related bits)
---
.../clangd/unittests/FindTargetTests.cpp | 6 +
clang/include/clang/AST/ASTContext.h | 4 +
clang/include/clang/AST/DeclTemplate.h | 3 +
clang/include/clang/AST/RecursiveASTVisitor.h | 30 ++-
clang/include/clang/AST/Type.h | 88 ++++++--
clang/include/clang/AST/TypeLoc.h | 22 +-
clang/include/clang/AST/TypeProperties.td | 19 +-
clang/include/clang/Basic/BuiltinTemplates.td | 6 +
.../clang/Basic/DiagnosticSemaKinds.td | 6 +
clang/include/clang/Basic/TypeNodes.td | 4 +-
clang/include/clang/Sema/Sema.h | 6 +-
.../clang/Serialization/TypeBitCodes.def | 1 +
clang/lib/AST/ASTContext.cpp | 32 ++-
clang/lib/AST/ASTImporter.cpp | 8 +
clang/lib/AST/ASTStructuralEquivalence.cpp | 8 +
clang/lib/AST/DeclTemplate.cpp | 16 +-
clang/lib/AST/ItaniumMangle.cpp | 9 +
clang/lib/AST/MicrosoftMangle.cpp | 5 +
clang/lib/AST/Type.cpp | 82 +++++--
clang/lib/AST/TypePrinter.cpp | 10 +
clang/lib/Parse/ParseTemplate.cpp | 14 ++
clang/lib/Sema/SemaTemplate.cpp | 76 +++++++
clang/lib/Sema/SemaTemplateDeduction.cpp | 6 +
clang/lib/Sema/SemaTemplateInstantiate.cpp | 48 ++++
clang/lib/Sema/SemaTemplateVariadic.cpp | 83 ++++++-
clang/lib/Sema/SemaType.cpp | 19 ++
clang/lib/Sema/TreeTransform.h | 209 ++++++++++++------
clang/lib/Serialization/ASTReader.cpp | 5 +
clang/lib/Serialization/ASTWriter.cpp | 6 +
.../test/Import/builtin-template/Inputs/S.cpp | 7 +
clang/test/Import/builtin-template/test.cpp | 10 +-
clang/test/PCH/dedup_types.cpp | 20 ++
.../test/SemaTemplate/dedup-types-builtin.cpp | 81 +++++++
.../test/SemaTemplate/sort-types-builtin.cpp | 42 ++++
clang/tools/libclang/CIndex.cpp | 1 +
35 files changed, 864 insertions(+), 128 deletions(-)
create mode 100644 clang/test/PCH/dedup_types.cpp
create mode 100644 clang/test/SemaTemplate/dedup-types-builtin.cpp
create mode 100644 clang/test/SemaTemplate/sort-types-builtin.cpp
diff --git a/clang-tools-extra/clangd/unittests/FindTargetTests.cpp
b/clang-tools-extra/clangd/unittests/FindTargetTests.cpp
index 602f61d9ecb41..125b9002d1d22 100644
--- a/clang-tools-extra/clangd/unittests/FindTargetTests.cpp
+++ b/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_pack]]<Templ, Types...>;
+ )cpp";
+ EXPECT_DECLS("TemplateSpecializationTypeLoc", );
}
TEST_F(TargetDeclTest, MemberOfTemplate) {
diff --git a/clang/include/clang/AST/ASTContext.h
b/clang/include/clang/AST/ASTContext.h
index e107db458742e..8f2fd924c4a71 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -25,6 +25,7 @@
#include "clang/AST/RawCommentList.h"
#include "clang/AST/SYCLKernelInfo.h"
#include "clang/AST/TemplateName.h"
+#include "clang/AST/Type.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/PartialDiagnostic.h"
#include "clang/Basic/SourceLocation.h"
@@ -229,6 +230,8 @@ class ASTContext : public RefCountedBase<ASTContext> {
SubstTemplateTypeParmTypes;
mutable llvm::FoldingSet<SubstTemplateTypeParmPackType>
SubstTemplateTypeParmPackTypes;
+ mutable llvm::FoldingSet<SubstBuiltinTemplatePackType>
+ SubstBuiltinTemplatePackTypes;
mutable llvm::ContextualFoldingSet<TemplateSpecializationType, ASTContext&>
TemplateSpecializationTypes;
mutable llvm::FoldingSet<ParenType> ParenTypes{GeneralTypesLog2InitSize};
@@ -1814,6 +1817,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
QualType getSubstTemplateTypeParmPackType(Decl *AssociatedDecl,
unsigned Index, bool Final,
const TemplateArgument &ArgPack);
+ QualType getSubstBuiltinTemplatePack(const TemplateArgument &ArgPack);
QualType
getTemplateTypeParmType(unsigned Depth, unsigned Index,
diff --git a/clang/include/clang/AST/DeclTemplate.h
b/clang/include/clang/AST/DeclTemplate.h
index a8100b642e04c..aaeae39e1c201 100644
--- a/clang/include/clang/AST/DeclTemplate.h
+++ b/clang/include/clang/AST/DeclTemplate.h
@@ -1790,6 +1790,9 @@ class BuiltinTemplateDecl : public TemplateDecl {
BuiltinTemplateKind getBuiltinTemplateKind() const { return BTK; }
};
+bool isPackProducingBuiltinTemplate(const TemplateDecl *D);
+bool isPackProducingBuiltinTemplateName(TemplateName N);
+
/// Provides information about an explicit instantiation of a variable or class
/// template.
struct ExplicitInstantiationInfo {
diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h
b/clang/include/clang/AST/RecursiveASTVisitor.h
index 3edc8684d0a19..969bdffb8319b 100644
--- a/clang/include/clang/AST/RecursiveASTVisitor.h
+++ b/clang/include/clang/AST/RecursiveASTVisitor.h
@@ -490,6 +490,8 @@ template <typename Derived> class RecursiveASTVisitor {
bool TraverseTemplateArgumentLocsHelper(const TemplateArgumentLoc *TAL,
unsigned Count);
bool TraverseArrayTypeLocHelper(ArrayTypeLoc TL);
+ bool TraverseSubstPackTypeHelper(SubstPackType *T);
+ bool TraverseSubstPackTypeLocHelper(SubstPackTypeLoc TL);
bool TraverseRecordHelper(RecordDecl *D);
bool TraverseCXXRecordHelper(CXXRecordDecl *D);
bool TraverseDeclaratorHelper(DeclaratorDecl *D);
@@ -1128,9 +1130,10 @@ DEF_TRAVERSE_TYPE(TemplateTypeParmType, {})
DEF_TRAVERSE_TYPE(SubstTemplateTypeParmType, {
TRY_TO(TraverseType(T->getReplacementType()));
})
-DEF_TRAVERSE_TYPE(SubstTemplateTypeParmPackType, {
- TRY_TO(TraverseTemplateArgument(T->getArgumentPack()));
-})
+DEF_TRAVERSE_TYPE(SubstTemplateTypeParmPackType,
+ { TRY_TO(TraverseSubstPackTypeHelper(T)); })
+DEF_TRAVERSE_TYPE(SubstBuiltinTemplatePackType,
+ { TRY_TO(TraverseSubstPackTypeHelper(T)); })
DEF_TRAVERSE_TYPE(TemplateSpecializationType, {
TRY_TO(TraverseTemplateName(T->getTemplateName()));
@@ -1426,9 +1429,26 @@ DEF_TRAVERSE_TYPELOC(TemplateTypeParmType, {})
DEF_TRAVERSE_TYPELOC(SubstTemplateTypeParmType, {
TRY_TO(TraverseType(TL.getTypePtr()->getReplacementType()));
})
-DEF_TRAVERSE_TYPELOC(SubstTemplateTypeParmPackType, {
+
+template <typename Derived>
+bool RecursiveASTVisitor<Derived>::TraverseSubstPackTypeLocHelper(
+ SubstPackTypeLoc TL) {
TRY_TO(TraverseTemplateArgument(TL.getTypePtr()->getArgumentPack()));
-})
+ return true;
+}
+
+template <typename Derived>
+bool RecursiveASTVisitor<Derived>::TraverseSubstPackTypeHelper(
+ SubstPackType *T) {
+ TRY_TO(TraverseTemplateArgument(T->getArgumentPack()));
+ return true;
+}
+
+DEF_TRAVERSE_TYPELOC(SubstTemplateTypeParmPackType,
+ { TRY_TO(TraverseSubstPackTypeLocHelper(TL)); })
+
+DEF_TRAVERSE_TYPELOC(SubstBuiltinTemplatePackType,
+ { TRY_TO(TraverseSubstPackTypeLocHelper(TL)); })
// FIXME: use the loc for the template name?
DEF_TRAVERSE_TYPELOC(TemplateSpecializationType, {
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index 773796a55eaa1..0fb1531e1762f 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -2182,21 +2182,35 @@ class alignas(TypeAlignment) Type : public
ExtQualsTypeCommonBase {
unsigned PackIndex : 15;
};
- class SubstTemplateTypeParmPackTypeBitfields {
- friend class SubstTemplateTypeParmPackType;
+ class SubstPackTypeBitfields {
+ friend class SubstPackType;
LLVM_PREFERRED_TYPE(TypeBitfields)
unsigned : NumTypeBits;
- // The index of the template parameter this substitution represents.
- unsigned Index : 16;
-
/// The number of template arguments in \c Arguments, which is
/// expected to be able to hold at least 1024 according to [implimits].
/// However as this limit is somewhat easy to hit with template
/// metaprogramming we'd prefer to keep it as large as possible.
unsigned NumArgs : 16;
};
+ // FIXME: idiomatically, we want to have exact numbers, but that
+ // ends up generating incorrect code (writes to
+ // SubstTemplateTypeParmPackTypeBitfields.Index also update
+ // bits in NumArgs).
+ // enum { NumSubstPackTypeBits = NumTypeBits + 16 };
+ static_assert(NumTypeBits + 16 <= 48);
+ enum { NumSubstPackTypeBits = 48 };
+
+ class SubstTemplateTypeParmPackTypeBitfields {
+ friend class SubstTemplateTypeParmPackType;
+
+ LLVM_PREFERRED_TYPE(SubstPackTypeBitfields)
+ unsigned : NumSubstPackTypeBits;
+
+ // The index of the template parameter this substitution represents.
+ unsigned Index : 16;
+ };
class TemplateSpecializationTypeBitfields {
friend class TemplateSpecializationType;
@@ -2287,6 +2301,7 @@ class alignas(TypeAlignment) Type : public
ExtQualsTypeCommonBase {
VectorTypeBitfields VectorTypeBits;
TemplateTypeParmTypeBitfields TemplateTypeParmTypeBits;
SubstTemplateTypeParmTypeBitfields SubstTemplateTypeParmTypeBits;
+ SubstPackTypeBitfields SubstPackTypeBits;
SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
DependentTemplateSpecializationTypeBitfields
@@ -6484,6 +6499,57 @@ class SubstTemplateTypeParmType final
}
};
+/// Represents the result of substituting a set of types as a template argument
+/// that needs to be expanded later.
+///
+/// These types are always dependent and produced depending on the situations:
+/// - SubstTemplateTypeParmPack represents a pack expansion that had to be
+/// delayed,
+/// - TODO: represents a pack expansion represented by a builtin.
+class SubstPackType : public Type, public llvm::FoldingSetNode {
+ friend class ASTContext;
+
+ /// A pointer to the set of template arguments that this
+ /// parameter pack is instantiated with.
+ const TemplateArgument *Arguments;
+
+protected:
+ SubstPackType(TypeClass Derived, QualType Canon,
+ const TemplateArgument &ArgPack);
+
+public:
+ unsigned getNumArgs() const { return SubstPackTypeBits.NumArgs; }
+
+ TemplateArgument getArgumentPack() const;
+
+ void Profile(llvm::FoldingSetNodeID &ID);
+ static void Profile(llvm::FoldingSetNodeID &ID,
+ const TemplateArgument &ArgPack);
+
+ static bool classof(const Type *T) {
+ return T->getTypeClass() == SubstTemplateTypeParmPack ||
+ T->getTypeClass() == SubstBuiltinTemplatePack;
+ }
+};
+
+/// Represents the result of substituting a builtin template as a pack.
+class SubstBuiltinTemplatePackType : public SubstPackType {
+ friend class ASTContext;
+
+ SubstBuiltinTemplatePackType(QualType Canon, const TemplateArgument
&ArgPack);
+
+public:
+ bool isSugared() const { return false; }
+ QualType desugar() const { return QualType(this, 0); }
+
+ /// Mark that we reuse the Profile. We do not introduce new fields.
+ using SubstPackType::Profile;
+
+ static bool classof(const Type *T) {
+ return T->getTypeClass() == SubstBuiltinTemplatePack;
+ }
+};
+
/// Represents the result of substituting a set of types for a template
/// type parameter pack.
///
@@ -6496,7 +6562,7 @@ class SubstTemplateTypeParmType final
/// that pack expansion (e.g., when all template parameters have corresponding
/// arguments), this type will be replaced with the \c
SubstTemplateTypeParmType
/// at the current pack substitution index.
-class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode
{
+class SubstTemplateTypeParmPackType : public SubstPackType {
friend class ASTContext;
/// A pointer to the set of template arguments that this
@@ -6528,15 +6594,9 @@ class SubstTemplateTypeParmPackType : public Type,
public llvm::FoldingSetNode {
// sugared: it doesn't need to be resugared later.
bool getFinal() const;
- unsigned getNumArgs() const {
- return SubstTemplateTypeParmPackTypeBits.NumArgs;
- }
-
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }
- TemplateArgument getArgumentPack() const;
-
void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID, const Decl *AssociatedDecl,
unsigned Index, bool Final,
@@ -6766,9 +6826,7 @@ class TemplateSpecializationType : public Type, public
llvm::FoldingSetNode {
TemplateSpecializationTypeBits.NumArgs};
}
- bool isSugared() const {
- return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
- }
+ bool isSugared() const;
QualType desugar() const {
return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
diff --git a/clang/include/clang/AST/TypeLoc.h
b/clang/include/clang/AST/TypeLoc.h
index 92661b8b13fe0..4574b59c98af7 100644
--- a/clang/include/clang/AST/TypeLoc.h
+++ b/clang/include/clang/AST/TypeLoc.h
@@ -859,12 +859,22 @@ class SubstTemplateTypeParmTypeLoc :
SubstTemplateTypeParmType> {
};
- /// Wrapper for substituted template type parameters.
-class SubstTemplateTypeParmPackTypeLoc :
- public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
- SubstTemplateTypeParmPackTypeLoc,
- SubstTemplateTypeParmPackType> {
-};
+/// Abstract type representing delayed type pack expansions.
+class SubstPackTypeLoc
+ : public InheritingConcreteTypeLoc<TypeSpecTypeLoc, SubstPackTypeLoc,
+ SubstPackType> {};
+
+/// Wrapper for substituted template type parameters.
+class SubstTemplateTypeParmPackTypeLoc
+ : public InheritingConcreteTypeLoc<SubstPackTypeLoc,
+ SubstTemplateTypeParmPackTypeLoc,
+ SubstTemplateTypeParmPackType> {};
+
+/// Wrapper for substituted template type parameters.
+class SubstBuiltinTemplatePackTypeLoc
+ : public InheritingConcreteTypeLoc<SubstPackTypeLoc,
+ SubstBuiltinTemplatePackTypeLoc,
+ SubstBuiltinTemplatePackType> {};
struct AttributedLocInfo {
const Attr *TypeAttr;
diff --git a/clang/include/clang/AST/TypeProperties.td
b/clang/include/clang/AST/TypeProperties.td
index f4b8ce0994ba8..ee7160a1bd994 100644
--- a/clang/include/clang/AST/TypeProperties.td
+++ b/clang/include/clang/AST/TypeProperties.td
@@ -826,6 +826,12 @@ let Class = PackExpansionType in {
}]>;
}
+let Class = SubstPackType in {
+ def : Property<"replacementPack", TemplateArgument> {
+ let Read = [{ node->getArgumentPack() }];
+ }
+}
+
let Class = SubstTemplateTypeParmPackType in {
def : Property<"associatedDecl", DeclRef> {
let Read = [{ node->getAssociatedDecl() }];
@@ -833,12 +839,7 @@ let Class = SubstTemplateTypeParmPackType in {
def : Property<"Index", UInt32> {
let Read = [{ node->getIndex() }];
}
- def : Property<"Final", Bool> {
- let Read = [{ node->getFinal() }];
- }
- def : Property<"replacementPack", TemplateArgument> {
- let Read = [{ node->getArgumentPack() }];
- }
+ def : Property<"Final", Bool> { let Read = [{ node->getFinal() }]; }
def : Creator<[{
return ctx.getSubstTemplateTypeParmPackType(
@@ -846,6 +847,12 @@ let Class = SubstTemplateTypeParmPackType in {
}]>;
}
+let Class = SubstBuiltinTemplatePackType in {
+ def : Creator<[{
+ return ctx.getSubstBuiltinTemplatePack(replacementPack);
+ }]>;
+}
+
let Class = BuiltinType in {
def : Property<"kind", BuiltinTypeKind> {
let Read = [{ node->getKind() }];
diff --git a/clang/include/clang/Basic/BuiltinTemplates.td
b/clang/include/clang/Basic/BuiltinTemplates.td
index d46ce063d2f7e..5774a52c0af5e 100644
--- a/clang/include/clang/Basic/BuiltinTemplates.td
+++ b/clang/include/clang/Basic/BuiltinTemplates.td
@@ -50,3 +50,9 @@ def __builtin_common_type : BuiltinTemplate<
Template<[Class<"TypeMember">], "HasTypeMember">,
Class<"HasNoTypeMember">,
Class<"Ts", /*is_variadic=*/1>]>;
+
+// template <class ...Args>
+def __builtin_dedup_pack : BuiltinTemplate<[Class<"Args", /*is_variadic=*/1>]>;
+
+// template <class ...Args>
+def __builtin_sort_pack : BuiltinTemplate<[Class<"Args", /*is_variadic=*/1>]>;
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td
b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index e1b9ed0647bb9..fefdc4e780030 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -3145,6 +3145,12 @@ 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_pack and
+// __builtin_sort_pack
+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">;
diff --git a/clang/include/clang/Basic/TypeNodes.td
b/clang/include/clang/Basic/TypeNodes.td
index 7e550ca2992f3..eed052f721daf 100644
--- a/clang/include/clang/Basic/TypeNodes.td
+++ b/clang/include/clang/Basic/TypeNodes.td
@@ -96,7 +96,9 @@ def BTFTagAttributedType : TypeNode<Type>, NeverCanonical;
def HLSLAttributedResourceType : TypeNode<Type>;
def TemplateTypeParmType : TypeNode<Type>, AlwaysDependent, LeafType;
def SubstTemplateTypeParmType : TypeNode<Type>, NeverCanonical;
-def SubstTemplateTypeParmPackType : TypeNode<Type>, AlwaysDependent;
+def SubstPackType : TypeNode<Type, 1>;
+def SubstTemplateTypeParmPackType : TypeNode<SubstPackType>, AlwaysDependent;
+def SubstBuiltinTemplatePackType : TypeNode<SubstPackType>, AlwaysDependent;
def TemplateSpecializationType : TypeNode<Type>, NeverCanonicalUnlessDependent;
def DeducedType : TypeNode<Type, 1>;
def AutoType : TypeNode<DeducedType>;
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index c02e827773341..936baac595efc 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -228,7 +228,9 @@ void threadSafetyCleanup(BeforeSet *Cache);
// FIXME: No way to easily map from TemplateTypeParmTypes to
// TemplateTypeParmDecls, so we have this horrible PointerUnion.
-typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType *, NamedDecl
*>,
+typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType *, NamedDecl *,
+ const TemplateSpecializationType *,
+ const SubstBuiltinTemplatePackType *>,
SourceLocation>
UnexpandedParameterPack;
@@ -13491,8 +13493,6 @@ class Sema final : public SemaBase {
~ArgPackSubstIndexRAII() { Self.ArgPackSubstIndex = OldSubstIndex; }
};
- friend class ArgumentPackSubstitutionRAII;
-
void pushCodeSynthesisContext(CodeSynthesisContext Ctx);
void popCodeSynthesisContext();
diff --git a/clang/include/clang/Serialization/TypeBitCodes.def
b/clang/include/clang/Serialization/TypeBitCodes.def
index 3c78b87805010..3363662bc76f8 100644
--- a/clang/include/clang/Serialization/TypeBitCodes.def
+++ b/clang/include/clang/Serialization/TypeBitCodes.def
@@ -68,5 +68,6 @@ TYPE_BIT_CODE(PackIndexing, PACK_INDEXING, 56)
TYPE_BIT_CODE(CountAttributed, COUNT_ATTRIBUTED, 57)
TYPE_BIT_CODE(ArrayParameter, ARRAY_PARAMETER, 58)
TYPE_BIT_CODE(HLSLAttributedResource, HLSLRESOURCE_ATTRIBUTED, 59)
+TYPE_BIT_CODE(SubstBuiltinTemplatePack, SUBST_BUILTIN_TEMPLATE_PACK, 60)
#undef TYPE_BIT_CODE
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index 1ed16748dff1a..b3920dfbd1419 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -4217,6 +4217,7 @@ QualType ASTContext::getVariableArrayDecayedType(QualType
type) const {
case Type::DependentTemplateSpecialization:
case Type::TemplateTypeParm:
case Type::SubstTemplateTypeParmPack:
+ case Type::SubstBuiltinTemplatePack:
case Type::Auto:
case Type::DeducedTemplateSpecialization:
case Type::PackExpansion:
@@ -5511,7 +5512,6 @@ QualType
ASTContext::getSubstTemplateTypeParmType(QualType Replacement,
return QualType(SubstParm, 0);
}
-/// Retrieve a
QualType
ASTContext::getSubstTemplateTypeParmPackType(Decl *AssociatedDecl,
unsigned Index, bool Final,
@@ -5550,6 +5550,35 @@ ASTContext::getSubstTemplateTypeParmPackType(Decl
*AssociatedDecl,
return QualType(SubstParm, 0);
}
+QualType
+ASTContext::getSubstBuiltinTemplatePack(const TemplateArgument &ArgPack) {
+#ifndef NDEBUG
+ for (const auto &P : ArgPack.pack_elements())
+ assert(P.getKind() == TemplateArgument::Type && "Pack contains a
non-type");
+#endif
+
+ llvm::FoldingSetNodeID ID;
+ SubstBuiltinTemplatePackType::Profile(ID, ArgPack);
+
+ void *InsertPos = nullptr;
+ if (auto *T =
+ SubstBuiltinTemplatePackTypes.FindNodeOrInsertPos(ID, InsertPos))
+ return QualType(T, 0);
+
+ QualType Canon;
+ {
+ TemplateArgument CanonArgPack = getCanonicalTemplateArgument(ArgPack);
+ if (!CanonArgPack.structurallyEquals(ArgPack))
+ Canon = getSubstBuiltinTemplatePack(CanonArgPack);
+ }
+
+ auto *PackType = new (*this, alignof(SubstBuiltinTemplatePackType))
+ SubstBuiltinTemplatePackType(Canon, ArgPack);
+ Types.push_back(PackType);
+ SubstBuiltinTemplatePackTypes.InsertNode(PackType, InsertPos);
+ return QualType(PackType, 0);
+}
+
/// Retrieve the template type parameter type for a template
/// parameter or parameter pack with the given depth, index, and (optionally)
/// name.
@@ -13916,6 +13945,7 @@ static QualType getCommonNonSugarTypeNode(ASTContext
&Ctx, const Type *X,
SUGAR_FREE_TYPE(ObjCInterface)
SUGAR_FREE_TYPE(Record)
SUGAR_FREE_TYPE(SubstTemplateTypeParmPack)
+ SUGAR_FREE_TYPE(SubstBuiltinTemplatePack)
SUGAR_FREE_TYPE(UnresolvedUsing)
SUGAR_FREE_TYPE(HLSLAttributedResource)
#undef SUGAR_FREE_TYPE
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index b481ad5df667e..0e9cdc0b7037b 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -1648,6 +1648,14 @@ ExpectedType
ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
*ReplacedOrErr, T->getIndex(), T->getFinal(), *ToArgumentPack);
}
+ExpectedType ASTNodeImporter::VisitSubstBuiltinTemplatePackType(
+ const SubstBuiltinTemplatePackType *T) {
+ Expected<TemplateArgument> ToArgumentPack = import(T->getArgumentPack());
+ if (!ToArgumentPack)
+ return ToArgumentPack.takeError();
+ return Importer.getToContext().getSubstBuiltinTemplatePack(*ToArgumentPack);
+}
+
ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
const TemplateSpecializationType *T) {
auto ToTemplateOrErr = import(T->getTemplateName());
diff --git a/clang/lib/AST/ASTStructuralEquivalence.cpp
b/clang/lib/AST/ASTStructuralEquivalence.cpp
index 499854a75abc6..e419fce6507a8 100644
--- a/clang/lib/AST/ASTStructuralEquivalence.cpp
+++ b/clang/lib/AST/ASTStructuralEquivalence.cpp
@@ -1286,6 +1286,14 @@ static bool
IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
break;
}
+ case Type::SubstBuiltinTemplatePack: {
+ const auto *Subst1 = cast<SubstBuiltinTemplatePackType>(T1);
+ const auto *Subst2 = cast<SubstBuiltinTemplatePackType>(T2);
+ if (!IsStructurallyEquivalent(Context, Subst1->getArgumentPack(),
+ Subst2->getArgumentPack()))
+ return false;
+ break;
+ }
case Type::SubstTemplateTypeParmPack: {
const auto *Subst1 = cast<SubstTemplateTypeParmPackType>(T1);
const auto *Subst2 = cast<SubstTemplateTypeParmPackType>(T2);
diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp
index d058831b9f6bf..13758d250c875 100644
--- a/clang/lib/AST/DeclTemplate.cpp
+++ b/clang/lib/AST/DeclTemplate.cpp
@@ -274,6 +274,19 @@ void *allocateDefaultArgStorageChain(const ASTContext &C) {
return new (C) char[sizeof(void*) * 2];
}
+bool isPackProducingBuiltinTemplate(const TemplateDecl *D) {
+ auto *BD = llvm::dyn_cast<BuiltinTemplateDecl>(D);
+ return BD &&
+ (BD->getBuiltinTemplateKind() == clang::BTK__builtin_sort_pack ||
+ BD->getBuiltinTemplateKind() == clang::BTK__builtin_dedup_pack);
+}
+
+bool isPackProducingBuiltinTemplateName(TemplateName N) {
+ if (N.getKind() == TemplateName::DeducedTemplate)
+ return false;
+ auto *T = N.getTemplateDeclAndDefaultArgs().first;
+ return T && isPackProducingBuiltinTemplate(T);
+}
} // namespace clang
//===----------------------------------------------------------------------===//
@@ -306,8 +319,9 @@ bool TemplateDecl::hasAssociatedConstraints() const {
bool TemplateDecl::isTypeAlias() const {
switch (getKind()) {
case TemplateDecl::TypeAliasTemplate:
- case TemplateDecl::BuiltinTemplate:
return true;
+ case TemplateDecl::BuiltinTemplate:
+ return !isPackProducingBuiltinTemplate(this);
default:
return false;
};
diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp
index 33a8728728574..6e27d22fc8deb 100644
--- a/clang/lib/AST/ItaniumMangle.cpp
+++ b/clang/lib/AST/ItaniumMangle.cpp
@@ -2476,6 +2476,7 @@ bool
CXXNameMangler::mangleUnresolvedTypeOrSimpleId(QualType Ty,
case Type::CountAttributed:
llvm_unreachable("type is illegal as a nested name specifier");
+ case Type::SubstBuiltinTemplatePack:
case Type::SubstTemplateTypeParmPack:
// FIXME: not clear how to mangle this!
// template <class T...> class A {
@@ -3926,6 +3927,14 @@ void CXXNameMangler::mangleType(const
SubstTemplateTypeParmPackType *T) {
Out << "_SUBSTPACK_";
}
+void CXXNameMangler::mangleType(const SubstBuiltinTemplatePackType *T) {
+ // FIXME: not clear how to mangle this!
+ // template <class T...> class A {
+ // template <class U...> void foo(__builtin_dedup_pack<T...>(*)(U) x...);
+ // };
+ Out << "_SUBSTPACK_";
+}
+
// <type> ::= P <type> # pointer-to
void CXXNameMangler::mangleType(const PointerType *T) {
Out << 'P';
diff --git a/clang/lib/AST/MicrosoftMangle.cpp
b/clang/lib/AST/MicrosoftMangle.cpp
index add737b762ccc..8888987cd35a2 100644
--- a/clang/lib/AST/MicrosoftMangle.cpp
+++ b/clang/lib/AST/MicrosoftMangle.cpp
@@ -3376,6 +3376,11 @@ void MicrosoftCXXNameMangler::mangleType(const
SubstTemplateTypeParmPackType *T,
Error(Range.getBegin(), "substituted parameter pack") << Range;
}
+void MicrosoftCXXNameMangler::mangleType(const SubstBuiltinTemplatePackType *T,
+ Qualifiers, SourceRange Range) {
+ Error(Range.getBegin(), "substituted builtin template pack") << Range;
+}
+
// <type> ::= <pointer-type>
// <pointer-type> ::= E? <pointer-cvr-qualifiers> <cvr-qualifiers> <type>
// # the E is required for 64-bit non-static pointers
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index 31e4bcd7535ea..bae6e7d7b19d2 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -4369,17 +4369,47 @@ void
SubstTemplateTypeParmType::Profile(llvm::FoldingSetNodeID &ID,
ID.AddBoolean(Final);
}
+SubstPackType::SubstPackType(TypeClass Derived, QualType Canon,
+ const TemplateArgument &ArgPack)
+ : Type(Derived, Canon,
+ TypeDependence::DependentInstantiation |
+ TypeDependence::UnexpandedPack),
+ Arguments(ArgPack.pack_begin()) {
+#ifndef NDEBUG
+ for (const auto &P : ArgPack.pack_elements()) {
+ assert(P.getKind() == TemplateArgument::Type &&
+ "non-type argument to SubstPackType?");
+ }
+#endif
+ SubstPackTypeBits.NumArgs = ArgPack.pack_size();
+}
+
+TemplateArgument SubstPackType::getArgumentPack() const {
+ return TemplateArgument(llvm::ArrayRef(Arguments, getNumArgs()));
+}
+
+void SubstPackType::Profile(llvm::FoldingSetNodeID &ID) {
+ Profile(ID, getArgumentPack());
+}
+
+void SubstPackType::Profile(llvm::FoldingSetNodeID &ID,
+ const TemplateArgument &ArgPack) {
+ ID.AddInteger(ArgPack.pack_size());
+ for (const auto &P : ArgPack.pack_elements())
+ ID.AddPointer(P.getAsType().getAsOpaquePtr());
+}
+
SubstTemplateTypeParmPackType::SubstTemplateTypeParmPackType(
QualType Canon, Decl *AssociatedDecl, unsigned Index, bool Final,
const TemplateArgument &ArgPack)
- : Type(SubstTemplateTypeParmPack, Canon,
- TypeDependence::DependentInstantiation |
- TypeDependence::UnexpandedPack),
- Arguments(ArgPack.pack_begin()),
+ : SubstPackType(SubstTemplateTypeParmPack, Canon, ArgPack),
AssociatedDeclAndFinal(AssociatedDecl, Final) {
- SubstTemplateTypeParmPackTypeBits.Index = Index;
- SubstTemplateTypeParmPackTypeBits.NumArgs = ArgPack.pack_size();
assert(AssociatedDecl != nullptr);
+
+ SubstTemplateTypeParmPackTypeBits.Index = Index;
+ assert(getNumArgs() == ArgPack.pack_size() &&
+ "Parent bitfields in SubstPackType were overwritten."
+ "Check NumSubstPackTypeBits.");
}
Decl *SubstTemplateTypeParmPackType::getAssociatedDecl() const {
@@ -4399,10 +4429,6 @@ IdentifierInfo
*SubstTemplateTypeParmPackType::getIdentifier() const {
return getReplacedParameter()->getIdentifier();
}
-TemplateArgument SubstTemplateTypeParmPackType::getArgumentPack() const {
- return TemplateArgument(llvm::ArrayRef(Arguments, getNumArgs()));
-}
-
void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, getAssociatedDecl(), getIndex(), getFinal(), getArgumentPack());
}
@@ -4414,11 +4440,13 @@ void
SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID,
ID.AddPointer(AssociatedDecl);
ID.AddInteger(Index);
ID.AddBoolean(Final);
- ID.AddInteger(ArgPack.pack_size());
- for (const auto &P : ArgPack.pack_elements())
- ID.AddPointer(P.getAsType().getAsOpaquePtr());
+ SubstPackType::Profile(ID, ArgPack);
}
+SubstBuiltinTemplatePackType::SubstBuiltinTemplatePackType(
+ QualType Canon, const TemplateArgument &ArgPack)
+ : SubstPackType(SubstBuiltinTemplatePack, Canon, ArgPack) {}
+
bool TemplateSpecializationType::anyDependentTemplateArguments(
const TemplateArgumentListInfo &Args,
ArrayRef<TemplateArgument> Converted) {
@@ -4442,17 +4470,28 @@ bool
TemplateSpecializationType::anyInstantiationDependentTemplateArguments(
return false;
}
+static TypeDependence GetTemplateSpecializationTypeDep(QualType Underlying,
+ TemplateName T) {
+ TypeDependence D = Underlying.isNull()
+ ? TypeDependence::DependentInstantiation
+ : toSemanticDependence(Underlying->getDependence());
+ D |= toTypeDependence(T.getDependence()) & TypeDependence::UnexpandedPack;
+ if (isPackProducingBuiltinTemplateName(T)) {
+ if (Underlying.isNull()) // Dependent, will produce a pack on substitution.
+ D |= TypeDependence::UnexpandedPack;
+ else
+ D |= (Underlying->getDependence() & TypeDependence::UnexpandedPack);
+ }
+ return D;
+}
+
TemplateSpecializationType::TemplateSpecializationType(
TemplateName T, bool IsAlias, ArrayRef<TemplateArgument> Args,
QualType Underlying)
: Type(TemplateSpecialization,
Underlying.isNull() ? QualType(this, 0)
: Underlying.getCanonicalType(),
- (Underlying.isNull()
- ? TypeDependence::DependentInstantiation
- : toSemanticDependence(Underlying->getDependence())) |
- (toTypeDependence(T.getDependence()) &
- TypeDependence::UnexpandedPack)),
+ GetTemplateSpecializationTypeDep(Underlying, T)),
Template(T) {
TemplateSpecializationTypeBits.NumArgs = Args.size();
TemplateSpecializationTypeBits.TypeAlias = IsAlias;
@@ -4498,6 +4537,12 @@ QualType TemplateSpecializationType::getAliasedType()
const {
return *reinterpret_cast<const QualType *>(template_arguments().end());
}
+bool clang::TemplateSpecializationType::isSugared() const {
+ return !isDependentType() || isCurrentInstantiation() || isTypeAlias() ||
+ (isPackProducingBuiltinTemplateName(Template) &&
+
llvm::isa<SubstBuiltinTemplatePackType>(*getCanonicalTypeInternal()));
+}
+
void TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Ctx) {
Profile(ID, Template, template_arguments(),
@@ -4910,6 +4955,7 @@ bool Type::canHaveNullability(bool ResultIfUnknown) const
{
case Type::UnaryTransform:
case Type::TemplateTypeParm:
case Type::SubstTemplateTypeParmPack:
+ case Type::SubstBuiltinTemplatePack:
case Type::DependentName:
case Type::DependentTemplateSpecialization:
case Type::Auto:
diff --git a/clang/lib/AST/TypePrinter.cpp b/clang/lib/AST/TypePrinter.cpp
index cba1a2d98d660..7a501bc976add 100644
--- a/clang/lib/AST/TypePrinter.cpp
+++ b/clang/lib/AST/TypePrinter.cpp
@@ -233,6 +233,7 @@ bool TypePrinter::canPrefixQualifiers(const Type *T,
case Type::Elaborated:
case Type::TemplateTypeParm:
case Type::SubstTemplateTypeParmPack:
+ case Type::SubstBuiltinTemplatePack:
case Type::DeducedTemplateSpecialization:
case Type::TemplateSpecialization:
case Type::InjectedClassName:
@@ -1627,6 +1628,15 @@ void TypePrinter::printSubstTemplateTypeParmAfter(
printAfter(T->getReplacementType(), OS);
}
+void TypePrinter::printSubstBuiltinTemplatePackBefore(
+ const SubstBuiltinTemplatePackType *T, raw_ostream &OS) {
+ IncludeStrongLifetimeRAII Strong(Policy);
+ OS << "type-pack";
+}
+
+void TypePrinter::printSubstBuiltinTemplatePackAfter(
+ const SubstBuiltinTemplatePackType *T, raw_ostream &OS) {}
+
void TypePrinter::printSubstTemplateTypeParmPackBefore(
const SubstTemplateTypeParmPackType *T,
raw_ostream &OS) {
diff --git a/clang/lib/Parse/ParseTemplate.cpp
b/clang/lib/Parse/ParseTemplate.cpp
index dbe5e94747c67..d6cb5ef252915 100644
--- a/clang/lib/Parse/ParseTemplate.cpp
+++ b/clang/lib/Parse/ParseTemplate.cpp
@@ -13,7 +13,9 @@
#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"
@@ -21,6 +23,7 @@
#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;
@@ -1476,6 +1479,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 && isPackProducingBuiltinTemplate(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);
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 94f4c1c46c1fb..ca8afbd07787d 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/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;
@@ -3331,6 +3343,65 @@ checkBuiltinTemplateIdType(Sema &SemaRef,
BuiltinTemplateDecl *BTD,
QualType HasNoTypeMember = Converted[2].getAsType();
return HasNoTypeMember;
}
+ case BTK__builtin_dedup_pack: {
+ assert(Converted.size() == 1 && "__builtin_dedup_pack 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 QualType();
+ 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 Context.getSubstBuiltinTemplatePack(
+ TemplateArgument::CreatePackCopy(Context, OutArgs));
+ }
+ case BTK__builtin_sort_pack: {
+ 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 QualType();
+
+ 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]);
+
+ return Context.getSubstBuiltinTemplatePack(
+ TemplateArgument::CreatePackCopy(Context, SortedArguments));
+ }
}
llvm_unreachable("unexpected BuiltinTemplateDecl!");
}
@@ -6095,6 +6166,11 @@ bool
UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
return false;
}
+bool UnnamedLocalNoLinkageFinder::VisitSubstBuiltinTemplatePackType(
+ const SubstBuiltinTemplatePackType *) {
+ return false;
+}
+
bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
const TemplateSpecializationType*)
{
return false;
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp
b/clang/lib/Sema/SemaTemplateDeduction.cpp
index ee1ef84fa4fbd..47312940feab8 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -1787,6 +1787,7 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
case Type::TemplateTypeParm:
case Type::SubstTemplateTypeParmPack:
+ case Type::SubstBuiltinTemplatePack:
llvm_unreachable("Type nodes handled above");
case Type::Auto:
@@ -6839,6 +6840,11 @@ MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
OnlyDeduced, Depth, Used);
break;
}
+ case Type::SubstBuiltinTemplatePack: {
+ MarkUsedTemplateParameters(Ctx, cast<SubstPackType>(T)->getArgumentPack(),
+ OnlyDeduced, Depth, Used);
+ break;
+ }
case Type::InjectedClassName:
T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType();
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp
b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index fb490bcac6e91..efa852445f1f2 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -10,6 +10,7 @@
//===----------------------------------------------------------------------===/
#include "TreeTransform.h"
+#include "TypeLocBuilder.h"
#include "clang/AST/ASTConcept.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
@@ -21,9 +22,11 @@
#include "clang/AST/Expr.h"
#include "clang/AST/ExprConcepts.h"
#include "clang/AST/PrettyDeclStackTrace.h"
+#include "clang/AST/TemplateName.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLoc.h"
#include "clang/AST/TypeVisitor.h"
+#include "clang/Basic/Builtins.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Sema/DeclSpec.h"
@@ -37,6 +40,7 @@
#include "clang/Sema/TemplateInstCallback.h"
#include "llvm/ADT/STLForwardCompat.h"
#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/SaveAndRestore.h"
#include "llvm/Support/TimeProfiler.h"
@@ -1476,6 +1480,21 @@ namespace {
}
}
+ MultiLevelTemplateArgumentList ForgetSubstitution() {
+ MultiLevelTemplateArgumentList New;
+ New.addOuterRetainedLevels(this->TemplateArgs.getNumLevels());
+
+ MultiLevelTemplateArgumentList Old =
+ const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
+ const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs) =
+ std::move(New);
+ return Old;
+ }
+ void RememberSubstitution(MultiLevelTemplateArgumentList Old) {
+ const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs) =
+ std::move(Old);
+ }
+
TemplateArgument
getTemplateArgumentPackPatternForRewrite(const TemplateArgument &TA) {
if (TA.getKind() != TemplateArgument::Pack)
@@ -1666,6 +1685,21 @@ namespace {
return inherited::TransformTemplateArgument(Input, Output, Uneval);
}
+ using TreeTransform::TransformTemplateSpecializationType;
+ QualType
+ TransformTemplateSpecializationType(TypeLocBuilder &TLB,
+ TemplateSpecializationTypeLoc TL) {
+ auto *T = TL.getTypePtr();
+ if (!getSema().ArgPackSubstIndex || !T->isSugared() ||
+ !isPackProducingBuiltinTemplateName(T->getTemplateName()))
+ return TreeTransform::TransformTemplateSpecializationType(TLB, TL);
+ // Look through sugar to get to the SubstBuiltinTemplatePackType that we
+ // need to substitute into.
+ QualType R = TransformType(T->desugar());
+ TLB.pushTrivial(getSema().getASTContext(), R, TL.getBeginLoc());
+ return R;
+ }
+
UnsignedOrNone ComputeSizeOfPackExprWithoutSubstitution(
ArrayRef<TemplateArgument> PackArgs) {
// Don't do this when rewriting template parameters for CTAD:
@@ -1715,6 +1749,9 @@ namespace {
TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
SubstTemplateTypeParmPackTypeLoc TL,
bool SuppressObjCLifetime);
+ QualType
+ TransformSubstBuiltinTemplatePackType(TypeLocBuilder &TLB,
+ SubstBuiltinTemplatePackTypeLoc TL);
CXXRecordDecl::LambdaDependencyKind
ComputeLambdaDependency(LambdaScopeInfo *LSI) {
@@ -2666,6 +2703,17 @@ QualType
TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
getPackIndex(Pack), Arg, TL.getNameLoc());
}
+QualType TemplateInstantiator::TransformSubstBuiltinTemplatePackType(
+ TypeLocBuilder &TLB, SubstBuiltinTemplatePackTypeLoc TL) {
+ if (!getSema().ArgPackSubstIndex)
+ return TreeTransform::TransformSubstBuiltinTemplatePackType(TLB, TL);
+ auto &Sema = getSema();
+ TemplateArgument Result = getPackSubstitutedTemplateArgument(
+ Sema, TL.getTypePtr()->getArgumentPack());
+ TLB.pushTrivial(Sema.getASTContext(), Result.getAsType(), TL.getBeginLoc());
+ return Result.getAsType();
+}
+
static concepts::Requirement::SubstitutionDiagnostic *
createSubstDiag(Sema &S, TemplateDeductionInfo &Info,
Sema::EntityPrinter Printer) {
diff --git a/clang/lib/Sema/SemaTemplateVariadic.cpp
b/clang/lib/Sema/SemaTemplateVariadic.cpp
index 5f0e968ff18c4..94920d27dcd61 100644
--- a/clang/lib/Sema/SemaTemplateVariadic.cpp
+++ b/clang/lib/Sema/SemaTemplateVariadic.cpp
@@ -9,10 +9,15 @@
//===----------------------------------------------------------------------===/
#include "TypeLocBuilder.h"
+#include "clang/AST/DeclTemplate.h"
+#include "clang/AST/DependenceFlags.h"
#include "clang/AST/DynamicRecursiveASTVisitor.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprObjC.h"
+#include "clang/AST/TemplateBase.h"
+#include "clang/AST/Type.h"
#include "clang/AST/TypeLoc.h"
+#include "clang/Basic/SourceLocation.h"
#include "clang/Sema/Lookup.h"
#include "clang/Sema/ParsedAttr.h"
#include "clang/Sema/ParsedTemplate.h"
@@ -20,7 +25,9 @@
#include "clang/Sema/Sema.h"
#include "clang/Sema/SemaInternal.h"
#include "clang/Sema/Template.h"
+#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/SaveAndRestore.h"
+#include <memory>
#include <optional>
using namespace clang;
@@ -65,6 +72,39 @@ class CollectUnexpandedParameterPacksVisitor
Unexpanded.push_back({T, Loc});
}
+ bool addUnexpanded(const SubstBuiltinTemplatePackType *T) {
+ // TODO: source location
+ Unexpanded.push_back({T, SourceLocation()});
+ return true;
+ }
+
+ bool addUnexpanded(const TemplateSpecializationType *T) {
+ assert(T->isCanonicalUnqualified() &&
+ isPackProducingBuiltinTemplateName(T->getTemplateName()));
+ Unexpanded.push_back({T, SourceLocation()});
+ return true;
+ }
+
+ /// Returns true iff it handled the traversal. On false, the callers must
+ /// traverse themselves.
+ bool TryTraverseSpecializationProducingPacks(
+ const TemplateSpecializationType *T) {
+ if (!isPackProducingBuiltinTemplateName(T->getTemplateName()))
+ return false;
+ // Canonical types are inputs to the initial substitution. Report them
and
+ // do not recurse any further.
+ if (T->isCanonicalUnqualified()) {
+ addUnexpanded(T);
+ return true;
+ }
+ // For sugared types, do not use the default traversal as it would be
+ // looking at (now irrelevant) template arguments. Instead, look at the
+ // result of substitution, it usually contains SubstPackType that needs
to
+ // be expanded further.
+ DynamicRecursiveASTVisitor::TraverseType(T->desugar());
+ return true;
+ }
+
public:
explicit CollectUnexpandedParameterPacksVisitor(
SmallVectorImpl<UnexpandedParameterPack> &Unexpanded)
@@ -123,6 +163,21 @@ class CollectUnexpandedParameterPacksVisitor
return DynamicRecursiveASTVisitor::TraverseTemplateName(Template);
}
+ bool TraverseTemplateSpecializationTypeLoc(
+ TemplateSpecializationTypeLoc T) override {
+ if (TryTraverseSpecializationProducingPacks(T.getTypePtr()))
+ return true;
+ return DynamicRecursiveASTVisitor::TraverseTemplateSpecializationTypeLoc(
+ T);
+ }
+
+ bool
+ TraverseTemplateSpecializationType(TemplateSpecializationType *T) override
{
+ if (TryTraverseSpecializationProducingPacks(T))
+ return true;
+ return DynamicRecursiveASTVisitor::TraverseTemplateSpecializationType(T);
+ }
+
/// Suppress traversal into Objective-C container literal
/// elements that are pack expansions.
bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *E) override {
@@ -310,6 +365,14 @@ class CollectUnexpandedParameterPacksVisitor
return DynamicRecursiveASTVisitor::TraverseLambdaCapture(Lambda, C,
Init);
}
+ bool TraverseSubstBuiltinTemplatePackType(
+ SubstBuiltinTemplatePackType *T) override {
+ addUnexpanded(T);
+ // Do not call into base implementation to supress traversal of the
+ // substituted types.
+ return true;
+ }
+
#ifndef NDEBUG
bool TraverseFunctionParmPackExpr(FunctionParmPackExpr *) override {
ContainsIntermediatePacks = true;
@@ -717,7 +780,7 @@ QualType Sema::CheckPackExpansion(QualType Pattern,
SourceRange PatternRange,
if (!Pattern->containsUnexpandedParameterPack() &&
!Pattern->getContainedDeducedType()) {
Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
- << PatternRange;
+ << PatternRange;
return QualType();
}
@@ -768,12 +831,24 @@ bool Sema::CheckParameterPacksForExpansion(
IdentifierInfo *Name;
bool IsVarDeclPack = false;
FunctionParmPackExpr *BindingPack = nullptr;
+ std::optional<unsigned> NumPrecomputedArguments;
- if (const TemplateTypeParmType *TTP =
- ParmPack.first.dyn_cast<const TemplateTypeParmType *>()) {
+ if (auto *TTP = ParmPack.first.dyn_cast<const TemplateTypeParmType *>()) {
Depth = TTP->getDepth();
Index = TTP->getIndex();
Name = TTP->getIdentifier();
+ } else if (auto *TST =
+ ParmPack.first
+ .dyn_cast<const TemplateSpecializationType *>()) {
+ assert(isPackProducingBuiltinTemplateName(TST->getTemplateName()));
+ // Delay expansion, substitution is required to know the size.
+ ShouldExpand = false;
+ continue;
+ } else if (auto *S =
+ ParmPack.first
+ .dyn_cast<const SubstBuiltinTemplatePackType *>()) {
+ Name = nullptr;
+ NumPrecomputedArguments = S->getNumArgs();
} else {
NamedDecl *ND = cast<NamedDecl *>(ParmPack.first);
if (isa<VarDecl>(ND))
@@ -813,6 +888,8 @@ bool Sema::CheckParameterPacksForExpansion(
}
} else if (BindingPack) {
NewPackSize = BindingPack->getNumExpansions();
+ } else if (NumPrecomputedArguments) {
+ NewPackSize = *NumPrecomputedArguments;
} else {
// If we don't have a template argument at this depth/index, then we
// cannot expand the pack expansion. Make a note of this, but we still
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 294daef70c339..f85656ddf98f8 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -4341,6 +4341,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 && isPackProducingBuiltinTemplateName(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;
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index 8b4b79c6ec039..936371e530f34 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -30,14 +30,19 @@
#include "clang/AST/StmtOpenACC.h"
#include "clang/AST/StmtOpenMP.h"
#include "clang/AST/StmtSYCL.h"
+#include "clang/AST/TemplateBase.h"
+#include "clang/AST/Type.h"
+#include "clang/AST/TypeLoc.h"
#include "clang/Basic/DiagnosticParse.h"
#include "clang/Basic/OpenMPKinds.h"
+#include "clang/Basic/UnsignedOrNone.h"
#include "clang/Sema/Designator.h"
#include "clang/Sema/EnterExpressionEvaluationContext.h"
#include "clang/Sema/Lookup.h"
#include "clang/Sema/Ownership.h"
#include "clang/Sema/ParsedTemplate.h"
#include "clang/Sema/ScopeInfo.h"
+#include "clang/Sema/Sema.h"
#include "clang/Sema/SemaDiagnostic.h"
#include "clang/Sema/SemaInternal.h"
#include "clang/Sema/SemaObjC.h"
@@ -45,7 +50,9 @@
#include "clang/Sema/SemaOpenMP.h"
#include "clang/Sema/SemaPseudoObject.h"
#include "clang/Sema/SemaSYCL.h"
+#include "clang/Sema/Template.h"
#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/ErrorHandling.h"
#include <algorithm>
#include <optional>
@@ -314,6 +321,27 @@ class TreeTransform {
/// This routine is meant to be overridden by the template instantiator.
void RememberPartiallySubstitutedPack(TemplateArgument Arg) { }
+ /// "Forget" the template substitution to allow transforming the AST without
+ /// any template instantiations. This is used to expand template packs when
+ /// their size is not known in advance (e.g. for builtins that produce type
+ /// packs).
+ MultiLevelTemplateArgumentList ForgetSubstitution() { return {}; }
+ void RememberSubstitution(MultiLevelTemplateArgumentList) {}
+
+private:
+ struct ForgetSubstitutionRAII {
+ Derived &Self;
+ MultiLevelTemplateArgumentList Old;
+
+ public:
+ ForgetSubstitutionRAII(Derived &Self) : Self(Self) {
+ Old = Self.ForgetSubstitution();
+ }
+
+ ~ForgetSubstitutionRAII() { Self.RememberSubstitution(std::move(Old)); }
+ };
+
+public:
/// Note to the derived class when a function parameter pack is
/// being expanded.
void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { }
@@ -656,6 +684,13 @@ class TreeTransform {
TemplateArgumentListInfo &Outputs,
bool Uneval = false);
+ /// Expands \p In into a list of arguments and writes them into \p Outputs.
+ /// \p In must be a pack expansion.
+ /// Returns true iff an error occurred.
+ bool ExpandTemplateArgument(TemplateArgumentLoc In,
+ TemplateArgumentListInfo &Outputs, bool Uneval,
+ bool TryExpandingSubstPacks = false);
+
/// Fakes up a TemplateArgumentLoc for a given TemplateArgument.
void InventTemplateArgumentLoc(const TemplateArgument &Arg,
TemplateArgumentLoc &ArgLoc);
@@ -5054,95 +5089,128 @@ bool
TreeTransform<Derived>::TransformTemplateArguments(
}
if (In.getArgument().isPackExpansion()) {
- // We have a pack expansion, for which we will be substituting into
- // the pattern.
- SourceLocation Ellipsis;
- UnsignedOrNone OrigNumExpansions = std::nullopt;
- TemplateArgumentLoc Pattern
- = getSema().getTemplateArgumentPackExpansionPattern(
- In, Ellipsis, OrigNumExpansions);
-
- SmallVector<UnexpandedParameterPack, 2> Unexpanded;
- getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
- assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
-
- // Determine whether the set of unexpanded parameter packs can and should
- // be expanded.
- bool Expand = true;
- bool RetainExpansion = false;
- UnsignedOrNone NumExpansions = OrigNumExpansions;
- if (getDerived().TryExpandParameterPacks(Ellipsis,
- Pattern.getSourceRange(),
- Unexpanded,
- Expand,
- RetainExpansion,
- NumExpansions))
+ if (ExpandTemplateArgument(In, Outputs, Uneval, true))
return true;
+ continue;
+ }
- if (!Expand) {
- // The transform has determined that we should perform a simple
- // transformation on the pack expansion, producing another pack
- // expansion.
- TemplateArgumentLoc OutPattern;
- Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
- if (getDerived().TransformTemplateArgument(Pattern, OutPattern,
Uneval))
- return true;
+ // The simple case:
+ if (getDerived().TransformTemplateArgument(In, Out, Uneval))
+ return true;
- Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
- NumExpansions);
- if (Out.getArgument().isNull())
- return true;
+ Outputs.addArgument(Out);
+ }
- Outputs.addArgument(Out);
- continue;
- }
+ return false;
+}
- // The transform has determined that we should perform an elementwise
- // expansion of the pattern. Do so.
- for (unsigned I = 0; I != *NumExpansions; ++I) {
- Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
+template <typename Derived>
+bool TreeTransform<Derived>::ExpandTemplateArgument(
+ TemplateArgumentLoc In, TemplateArgumentListInfo &Outputs, bool Uneval,
+ bool TryExpandingSubstPacks) {
+ assert(In.getArgument().isPackExpansion());
+ // We have a pack expansion, for which we will be substituting into the
+ // pattern.
+ SourceLocation Ellipsis;
+ UnsignedOrNone OrigNumExpansions = std::nullopt;
+ TemplateArgumentLoc Pattern =
+ getSema().getTemplateArgumentPackExpansionPattern(In, Ellipsis,
+ OrigNumExpansions);
- if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
- return true;
+ SmallVector<UnexpandedParameterPack, 2> Unexpanded;
+ getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
+ if (!TryExpandingSubstPacks) {
+ // Only do something if there is an opportunity for late expansion.
+ bool SawPackTypes = llvm::any_of(Unexpanded, [](UnexpandedParameterPack P)
{
+ return P.first.dyn_cast<const SubstBuiltinTemplatePackType *>();
+ });
+ if (!SawPackTypes) {
+ Outputs.addArgument(In);
+ return false;
+ }
+ }
+ assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
- if (Out.getArgument().containsUnexpandedParameterPack()) {
- Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
- OrigNumExpansions);
- if (Out.getArgument().isNull())
- return true;
- }
+ // Determine whether the set of unexpanded parameter packs can and should
+ // be expanded.
+ bool Expand = true;
+ bool RetainExpansion = false;
+ UnsignedOrNone NumExpansions = OrigNumExpansions;
+ if (getDerived().TryExpandParameterPacks(Ellipsis, Pattern.getSourceRange(),
+ Unexpanded, Expand, RetainExpansion,
+ NumExpansions))
+ return true;
- Outputs.addArgument(Out);
- }
+ TemplateArgumentLoc Out;
+ if (!Expand) {
+ // No opportunity for late expansion, return as is.
+ if (!TryExpandingSubstPacks) {
+ Outputs.addArgument(In);
+ return false;
+ }
+ // The transform has determined that we should perform a simple
+ // transformation on the pack expansion, producing another pack
+ // expansion.
+ TemplateArgumentLoc OutPattern;
+ std::optional<Sema::ArgPackSubstIndexRAII> SubstIndex(
+ std::in_place, getSema(), std::nullopt);
+ if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
+ return true;
- // If we're supposed to retain a pack expansion, do so by temporarily
- // forgetting the partially-substituted parameter pack.
- if (RetainExpansion) {
- ForgetPartiallySubstitutedPackRAII Forget(getDerived());
+ Out =
+ getDerived().RebuildPackExpansion(OutPattern, Ellipsis, NumExpansions);
+ if (Out.getArgument().isNull())
+ return true;
+ SubstIndex.reset();
+
+ // Some packs only know their lengths after substitution. We might be able
+ // to expand those here.
+ if (TryExpandingSubstPacks &&
+ OutPattern.getArgument().containsUnexpandedParameterPack()) {
+ // FIXME: assert that containsUnexpandedParameterPack is always true?
+ // FIMXE: no need to call RebuildPackExpansion?
+ ForgetSubstitutionRAII FS(getDerived());
+ return ExpandTemplateArgument(Out, Outputs, Uneval,
+ /*TryExpandingSubstPacks=*/false);
+ }
- if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
- return true;
+ Outputs.addArgument(Out);
+ return false;
+ }
- Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
- OrigNumExpansions);
- if (Out.getArgument().isNull())
- return true;
+ // The transform has determined that we should perform an elementwise
+ // expansion of the pattern. Do so.
+ for (unsigned I = 0; I != *NumExpansions; ++I) {
+ Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
- Outputs.addArgument(Out);
- }
+ if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
+ return true;
- continue;
+ if (Out.getArgument().containsUnexpandedParameterPack()) {
+ Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
OrigNumExpansions);
+ if (Out.getArgument().isNull())
+ return true;
}
- // The simple case:
- if (getDerived().TransformTemplateArgument(In, Out, Uneval))
+ Outputs.addArgument(Out);
+ }
+
+ // If we're supposed to retain a pack expansion, do so by temporarily
+ // forgetting the partially-substituted parameter pack.
+ if (RetainExpansion) {
+ ForgetPartiallySubstitutedPackRAII Forget(getDerived());
+
+ if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
+ return true;
+
+ Out = getDerived().RebuildPackExpansion(Out, Ellipsis, OrigNumExpansions);
+ if (Out.getArgument().isNull())
return true;
Outputs.addArgument(Out);
}
return false;
-
}
//===----------------------------------------------------------------------===//
@@ -7115,6 +7183,11 @@ QualType
TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
return Result;
}
+template <typename Derived>
+QualType TreeTransform<Derived>::TransformSubstBuiltinTemplatePackType(
+ TypeLocBuilder &TLB, SubstBuiltinTemplatePackTypeLoc TL) {
+ return TransformTypeSpecType(TLB, TL);
+}
template<typename Derived>
QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
diff --git a/clang/lib/Serialization/ASTReader.cpp
b/clang/lib/Serialization/ASTReader.cpp
index a17d6229ee3a1..bb75e9aa07ef9 100644
--- a/clang/lib/Serialization/ASTReader.cpp
+++ b/clang/lib/Serialization/ASTReader.cpp
@@ -7364,6 +7364,11 @@ void
TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
TL.setNameLoc(readSourceLocation());
}
+void TypeLocReader::VisitSubstBuiltinTemplatePackTypeLoc(
+ SubstBuiltinTemplatePackTypeLoc TL) {
+ TL.setNameLoc(readSourceLocation());
+}
+
void TypeLocReader::VisitTemplateSpecializationTypeLoc(
TemplateSpecializationTypeLoc TL) {
TL.setTemplateKeywordLoc(readSourceLocation());
diff --git a/clang/lib/Serialization/ASTWriter.cpp
b/clang/lib/Serialization/ASTWriter.cpp
index cccf53de25882..eabd3aa6cd2cd 100644
--- a/clang/lib/Serialization/ASTWriter.cpp
+++ b/clang/lib/Serialization/ASTWriter.cpp
@@ -618,6 +618,11 @@ void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
addSourceLocation(TL.getNameLoc());
}
+void TypeLocWriter::VisitSubstBuiltinTemplatePackTypeLoc(
+ SubstBuiltinTemplatePackTypeLoc TL) {
+ addSourceLocation(TL.getNameLoc());
+}
+
void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
TemplateSpecializationTypeLoc TL) {
addSourceLocation(TL.getTemplateKeywordLoc());
@@ -1056,6 +1061,7 @@ void ASTWriter::WriteBlockInfoBlock() {
RECORD(TYPE_PACK_EXPANSION);
RECORD(TYPE_ATTRIBUTED);
RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
+ RECORD(TYPE_SUBST_BUILTIN_TEMPLATE_PACK);
RECORD(TYPE_AUTO);
RECORD(TYPE_UNARY_TRANSFORM);
RECORD(TYPE_ATOMIC);
diff --git a/clang/test/Import/builtin-template/Inputs/S.cpp
b/clang/test/Import/builtin-template/Inputs/S.cpp
index d5c9a9ae0309d..8068865b1c6a1 100644
--- a/clang/test/Import/builtin-template/Inputs/S.cpp
+++ b/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_pack<Types...>...>;
+
+template <class ...Ts>
+struct TypeList {};
diff --git a/clang/test/Import/builtin-template/test.cpp
b/clang/test/Import/builtin-template/test.cpp
index 590efad0c71dc..bc5e76e718ef1 100644
--- a/clang/test/Import/builtin-template/test.cpp
+++ b/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_pack{{$}}
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
}
diff --git a/clang/test/PCH/dedup_types.cpp b/clang/test/PCH/dedup_types.cpp
new file mode 100644
index 0000000000000..d4b19b4411169
--- /dev/null
+++ b/clang/test/PCH/dedup_types.cpp
@@ -0,0 +1,20 @@
+// RUN: %clang_cc1 -std=c++14 -x c++-header %s -emit-pch -o %t.pch
+// RUN: %clang_cc1 -std=c++14 -x c++ /dev/null -include-pch %t.pch
+
+// RUN: %clang_cc1 -std=c++14 -x c++-header %s -emit-pch
-fpch-instantiate-templates -o %t.pch
+// RUN: %clang_cc1 -std=c++14 -x c++ /dev/null -include-pch %t.pch
+
+template <template <class...> class Templ, class...Types>
+using TypePackDedup = Templ<__builtin_dedup_pack<Types...>...>;
+
+template <class ...Ts>
+struct TypeList {};
+
+template <int i>
+struct X {};
+
+void fn1() {
+ 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/dedup-types-builtin.cpp
b/clang/test/SemaTemplate/dedup-types-builtin.cpp
new file mode 100644
index 0000000000000..55de8a7398e6c
--- /dev/null
+++ b/clang/test/SemaTemplate/dedup-types-builtin.cpp
@@ -0,0 +1,81 @@
+// RUN: %clang_cc1 %s -verify
+
+template <typename...> struct TypeList;
+
+// FIXME: better error message, note for the location of the builtin.
+static_assert(__is_same( // expected-error {{static assertion contains an
unexpanded parameter pack}}
+ TypeList<__builtin_dedup_pack<int, int*, int, double, float>>,
+ TypeList<int, int*, double, float>));
+
+template <template<typename ...> typename Templ, typename ...Types>
+struct Dependent {
+ using empty_list = Templ<__builtin_dedup_pack<>...>;
+ using same = Templ<__builtin_dedup_pack<Types...>...>;
+ using twice = Templ<__builtin_dedup_pack<Types..., Types...>...>;
+ using dep_only_types = TypeList<__builtin_dedup_pack<Types...>...>;
+ using dep_only_template = Templ<__builtin_dedup_pack<int, double, int>...>;
+};
+
+// Check the reverse condition to make sure we see an error and not
accidentally produced dependent expression.
+static_assert(!__is_same(Dependent<TypeList>::empty_list, TypeList<>)); //
expected-error {{static assertion failed}}
+static_assert(!__is_same(Dependent<TypeList>::same, TypeList<>)); //
expected-error {{static assertion failed}}
+static_assert(!__is_same(Dependent<TypeList>::twice, TypeList<>)); //
expected-error {{static assertion failed}}
+static_assert(!__is_same(Dependent<TypeList>::dep_only_types, TypeList<>)); //
expected-error {{static assertion failed}}
+static_assert(!__is_same(Dependent<TypeList>::dep_only_template, TypeList<int,
double>)); // expected-error {{static assertion failed}}
+static_assert(!__is_same(Dependent<TypeList, int*, double*, int*>::empty_list,
TypeList<>)); // expected-error {{static assertion failed}}
+static_assert(!__is_same(Dependent<TypeList, int*, double*, int*>::same,
TypeList<int*, double*>)); // expected-error {{static assertion failed}}
+static_assert(!__is_same(Dependent<TypeList, int*, double*, int*>::twice,
TypeList<int*, double*>)); // expected-error {{static assertion failed}}
+static_assert(!__is_same(Dependent<TypeList, int*, double*,
int*>::dep_only_types, TypeList<int*, double*>)); // expected-error {{static
assertion failed}}
+static_assert(!__is_same(Dependent<TypeList, int*, double*,
int*>::dep_only_template, TypeList<int, double>)); // expected-error {{static
assertion failed}}
+
+
+template <class ...T>
+using Twice = TypeList<T..., T...>;
+
+// FIXME: move this test into a template, add a test that doing expansions
outside of templates is an error.
+static_assert(!__is_same(Twice<__builtin_dedup_pack<int, double, int>...>,
TypeList<int, double, int, double>));
+
+template <int...> struct IntList;
+// Wrong kinds of template arguments.
+// FIXME: make the error message below point at this file.
+IntList<__builtin_dedup_pack<int>...>* wrong_template; // expected-error@*
{{template argument for non-type template parameter must be an expression}}
+ // expected-note@-4
{{template parameter is declared here}}
+TypeList<__builtin_dedup_pack<1, 2, 3>...>* wrong_template_args; //
expected-error {{template argument for template type parameter must be a type}}
+ //
expected-note@* {{template parameter from hidden source}}
+__builtin_dedup_pack<> not_enough_args; // expected-error {{declaration type
contains an unexpanded parameter pack}}
+ // expected-note@* {{template
declaration from hidden source}}
+__builtin_dedup_pack missing_template_args; // expected-error {{use of
template '__builtin_dedup_pack' requires template arguments}}
+
+// Make sure various canonical / non-canonical type representations do not
affect results
+// of the deduplication and the qualifiers do end up creating different types
when C++ requires it.
+using Int = int;
+using CInt = const Int;
+using IntArray = Int[10];
+using CIntArray = Int[10];
+using IntPtr = int*;
+using CIntPtr = const int*;
+
+template <class>
+struct Foo {
+ static_assert(
+ !__is_same( // expected-error {{static assertion failed}}
+ // expected-note@* {{in instantiation of template class
'Foo<int>'}}
+ TypeList<__builtin_dedup_pack<
+ Int, int,
+ const int, const Int, CInt, const CInt,
+ IntArray, Int[10], int[10],
+ const IntArray, const int[10], CIntArray, const CIntArray,
+ IntPtr, int*,
+ const IntPtr, int* const,
+ CIntPtr, const int*,
+ const IntPtr*, int*const*,
+ CIntPtr*, const int**,
+ const CIntPtr*, const int* const*
+ >...>,
+ TypeList<int, const int, int[10], const int [10], int*, int* const,
const int*, int*const *, const int**, const int*const*>),
+ "");
+};
+
+template struct Foo<int>;
+
+// FIXME: tests for locations of template arguments, ideally we should point
into the original locations of the template arguments.
diff --git a/clang/test/SemaTemplate/sort-types-builtin.cpp
b/clang/test/SemaTemplate/sort-types-builtin.cpp
new file mode 100644
index 0000000000000..7f23cd98d7dfa
--- /dev/null
+++ b/clang/test/SemaTemplate/sort-types-builtin.cpp
@@ -0,0 +1,42 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template <class ...>
+struct Types;
+
+// We check for negative condition and an error to make sure we don't
accidentally produce a dependent expression.
+template <class>
+struct CheckSimpleTypes {
+ static_assert(!__is_same( // expected-error {{static assertion failed}}
+ // expected-note@* {{in instantiation of template
class 'CheckSimpleTypes}}
+ Types<__builtin_sort_pack<int, double, int, double>...>,
+ Types<double, double, int, int>));
+};
+template struct CheckSimpleTypes<int>;
+
+__builtin_sort_pack<int, double> err1; // expected-error {{contains an
unexpanded}}
+Types<__builtin_sort_pack<int, double>*> err2; // expected-error {{contains an
unexpanded}}
+Types<const __builtin_sort_pack<int, double>> *err3; // expected-error
{{contains an unexpanded}}
+
+template <template <class...> class Inner>
+struct Wrapper {
+ using result = Inner<int,int,int>*;
+};
+Types<Wrapper<__builtin_sort_pack>::result> *err11; // expected-error {{use
of template '__builtin_sort_pack' requires template arguments}} \
+ // expected-note@*
{{template declaration from hidden source}}
+// Check we properly defer evaluations for dependent inputs.
+// It is important for performance to avoid repeated sorting (mangling is
expensive).
+template <class T>
+struct CheckDependent {
+ template <class U>
+ struct Inner {
+ using S1 = Types<__builtin_sort_pack<T, U>...>;
+ using S2 = Types<__builtin_sort_pack<U, T>...>;
+ using S3 = Types<__builtin_sort_pack<double, T>...>;
+ using S4 = Types<__builtin_sort_pack<U, int>...>;
+ };
+};
+
+using IntDouble = CheckDependent<int>::Inner<double>;
+static_assert(!__is_same(Types<double, int>,
CheckDependent<int>::Inner<double>::S1)); //expected-error {{static assertion
failed}}
+static_assert(!__is_same(Types<double, int>,
CheckDependent<int>::Inner<double>::S2)); //expected-error {{static assertion
failed}}
+static_assert(!__is_same(Types<double, int>,
CheckDependent<int>::Inner<double>::S3)); //expected-error {{static assertion
failed}}
+static_assert(!__is_same(Types<double, int>,
CheckDependent<int>::Inner<double>::S4)); //expected-error {{static assertion
failed}}
diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp
index fa5df3b5a06e6..f68cc6e52917e 100644
--- a/clang/tools/libclang/CIndex.cpp
+++ b/clang/tools/libclang/CIndex.cpp
@@ -1945,6 +1945,7 @@ DEFAULT_TYPELOC_IMPL(Record, TagType)
DEFAULT_TYPELOC_IMPL(Enum, TagType)
DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type)
DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type)
+DEFAULT_TYPELOC_IMPL(SubstBuiltinTemplatePack, Type)
DEFAULT_TYPELOC_IMPL(Auto, Type)
DEFAULT_TYPELOC_IMPL(BitInt, Type)
DEFAULT_TYPELOC_IMPL(DependentBitInt, Type)
>From ab2dac87d171d733c242e44e68324d8cbcf781d0 Mon Sep 17 00:00:00 2001
From: Ilya Biryukov <ibiryu...@google.com>
Date: Tue, 13 May 2025 16:01:48 +0200
Subject: [PATCH 2/2] Update formatting
---
clang/lib/AST/DeclTemplate.cpp | 5 ++---
1 file changed, 2 insertions(+), 3 deletions(-)
diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp
index 13758d250c875..602361665b4dc 100644
--- a/clang/lib/AST/DeclTemplate.cpp
+++ b/clang/lib/AST/DeclTemplate.cpp
@@ -276,9 +276,8 @@ void *allocateDefaultArgStorageChain(const ASTContext &C) {
bool isPackProducingBuiltinTemplate(const TemplateDecl *D) {
auto *BD = llvm::dyn_cast<BuiltinTemplateDecl>(D);
- return BD &&
- (BD->getBuiltinTemplateKind() == clang::BTK__builtin_sort_pack ||
- BD->getBuiltinTemplateKind() == clang::BTK__builtin_dedup_pack);
+ return BD && (BD->getBuiltinTemplateKind() == clang::BTK__builtin_sort_pack
||
+ BD->getBuiltinTemplateKind() ==
clang::BTK__builtin_dedup_pack);
}
bool isPackProducingBuiltinTemplateName(TemplateName N) {
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
