maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert "Clang: fix AST representation of expanded template arguments." 

This reverts commit 1d1a56929b.
This commit is contained in:
Matheus Izvekov 2022-08-26 13:09:55 +02:00
parent 3e39b27101
commit 4a56470d0d
No known key found for this signature in database
GPG Key ID: 22C080C6DC4E70F8
15 changed files with 29 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
clang/include/clang/AST/ASTContext.h
View File

@ -1614,8 +1614,7 @@ public:
QualType Wrapped);
QualType getSubstTemplateTypeParmType(const TemplateTypeParmType *Replaced,
QualType Replacement,
Optional<unsigned> PackIndex) const;
QualType Replacement) const;
QualType getSubstTemplateTypeParmPackType(
const TemplateTypeParmType *Replaced,
const TemplateArgument &ArgPack);

1
clang/include/clang/AST/JSONNodeDumper.h
View File

@ -220,7 +220,6 @@ public:
void VisitUnaryTransformType(const UnaryTransformType *UTT);
void VisitTagType(const TagType *TT);
void VisitTemplateTypeParmType(const TemplateTypeParmType *TTPT);
void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *STTPT);
void VisitAutoType(const AutoType *AT);
void VisitTemplateSpecializationType(const TemplateSpecializationType *TST);
void VisitInjectedClassNameType(const InjectedClassNameType *ICNT);

1
clang/include/clang/AST/TextNodeDumper.h
View File

@ -317,7 +317,6 @@ public:
void VisitUnaryTransformType(const UnaryTransformType *T);
void VisitTagType(const TagType *T);
void VisitTemplateTypeParmType(const TemplateTypeParmType *T);
void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T);
void VisitAutoType(const AutoType *T);
void VisitDeducedTemplateSpecializationType(
const DeducedTemplateSpecializationType *T);

31
clang/include/clang/AST/Type.h
View File

@ -1793,18 +1793,6 @@ protected:
unsigned NumArgs;
};
class SubstTemplateTypeParmTypeBitfields {
friend class SubstTemplateTypeParmType;
unsigned : NumTypeBits;
/// Represents the index within a pack if this represents a substitution
/// from a pack expansion.
/// Positive non-zero number represents the index + 1.
/// Zero means this is not substituted from an expansion.
unsigned PackIndex;
};
class SubstTemplateTypeParmPackTypeBitfields {
friend class SubstTemplateTypeParmPackType;
@ -1887,7 +1875,6 @@ protected:
ElaboratedTypeBitfields ElaboratedTypeBits;
VectorTypeBitfields VectorTypeBits;
SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
SubstTemplateTypeParmTypeBitfields SubstTemplateTypeParmTypeBits;
TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
DependentTemplateSpecializationTypeBitfields
DependentTemplateSpecializationTypeBits;
@ -4991,12 +4978,9 @@ class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
// The original type parameter.
const TemplateTypeParmType *Replaced;
SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon,
Optional<unsigned> PackIndex)
SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
: Type(SubstTemplateTypeParm, Canon, Canon->getDependence()),
Replaced(Param) {
SubstTemplateTypeParmTypeBits.PackIndex = PackIndex ? *PackIndex + 1 : 0;
}
Replaced(Param) {}
public:
/// Gets the template parameter that was substituted for.
@ -5010,25 +4994,18 @@ public:
return getCanonicalTypeInternal();
}
Optional<unsigned> getPackIndex() const {
if (SubstTemplateTypeParmTypeBits.PackIndex == 0)
return None;
return SubstTemplateTypeParmTypeBits.PackIndex - 1;
}
bool isSugared() const { return true; }
QualType desugar() const { return getReplacementType(); }
void Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, getReplacedParameter(), getReplacementType(), getPackIndex());
Profile(ID, getReplacedParameter(), getReplacementType());
}
static void Profile(llvm::FoldingSetNodeID &ID,
const TemplateTypeParmType *Replaced,
QualType Replacement, Optional<unsigned> PackIndex) {
QualType Replacement) {
ID.AddPointer(Replaced);
ID.AddPointer(Replacement.getAsOpaquePtr());
ID.AddInteger(PackIndex ? *PackIndex - 1 : 0);
}
static bool classof(const Type *T) {

5
clang/include/clang/AST/TypeProperties.td
View File

@ -734,15 +734,12 @@ let Class = SubstTemplateTypeParmType in {
def : Property<"replacementType", QualType> {
let Read = [{ node->getReplacementType() }];
}
def : Property<"PackIndex", Optional<UInt32>> {
let Read = [{ node->getPackIndex() }];
}
def : Creator<[{
// The call to getCanonicalType here existed in ASTReader.cpp, too.
return ctx.getSubstTemplateTypeParmType(
cast<TemplateTypeParmType>(replacedParameter),
ctx.getCanonicalType(replacementType), PackIndex);
ctx.getCanonicalType(replacementType));
}]>;
}

7
clang/lib/AST/ASTContext.cpp
View File

@ -4747,20 +4747,19 @@ QualType ASTContext::getBTFTagAttributedType(const BTFTypeTagAttr *BTFAttr,
/// Retrieve a substitution-result type.
QualType
ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm,
QualType Replacement,
Optional<unsigned> PackIndex) const {
QualType Replacement) const {
assert(Replacement.isCanonical()
&& "replacement types must always be canonical");
llvm::FoldingSetNodeID ID;
SubstTemplateTypeParmType::Profile(ID, Parm, Replacement, PackIndex);
SubstTemplateTypeParmType::Profile(ID, Parm, Replacement);
void *InsertPos = nullptr;
SubstTemplateTypeParmType *SubstParm
= SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
if (!SubstParm) {
SubstParm = new (*this, TypeAlignment)
SubstTemplateTypeParmType(Parm, Replacement, PackIndex);
SubstTemplateTypeParmType(Parm, Replacement);
Types.push_back(SubstParm);
SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
}

3
clang/lib/AST/ASTImporter.cpp
View File

@ -1530,8 +1530,7 @@ ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
return ToReplacementTypeOrErr.takeError();
return Importer.getToContext().getSubstTemplateTypeParmType(
*ReplacedOrErr, ToReplacementTypeOrErr->getCanonicalType(),
T->getPackIndex());
*ReplacedOrErr, ToReplacementTypeOrErr->getCanonicalType());
}
ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(

2
clang/lib/AST/ASTStructuralEquivalence.cpp
View File

@ -1062,8 +1062,6 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
if (!IsStructurallyEquivalent(Context, Subst1->getReplacementType(),
Subst2->getReplacementType()))
return false;
if (Subst1->getPackIndex() != Subst2->getPackIndex())
return false;
break;
}

6
clang/lib/AST/JSONNodeDumper.cpp
View File

@ -683,12 +683,6 @@ void JSONNodeDumper::VisitTemplateTypeParmType(
JOS.attribute("decl", createBareDeclRef(TTPT->getDecl()));
}
void JSONNodeDumper::VisitSubstTemplateTypeParmType(
const SubstTemplateTypeParmType *STTPT) {
if (auto PackIndex = STTPT->getPackIndex())
JOS.attribute("pack_index", *PackIndex);
}
void JSONNodeDumper::VisitAutoType(const AutoType *AT) {
JOS.attribute("undeduced", !AT->isDeduced());
switch (AT->getKeyword()) {

6
clang/lib/AST/TextNodeDumper.cpp
View File

@ -1570,12 +1570,6 @@ void TextNodeDumper::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
dumpDeclRef(T->getDecl());
}
void TextNodeDumper::VisitSubstTemplateTypeParmType(
const SubstTemplateTypeParmType *T) {
if (auto PackIndex = T->getPackIndex())
OS << " pack_index " << *PackIndex;
}
void TextNodeDumper::VisitAutoType(const AutoType *T) {
if (T->isDecltypeAuto())
OS << " decltype(auto)";

2
clang/lib/AST/Type.cpp
View File

@ -1167,7 +1167,7 @@ public:
return QualType(T, 0);
return Ctx.getSubstTemplateTypeParmType(T->getReplacedParameter(),
replacementType, T->getPackIndex());
replacementType);
}
// FIXME: Non-trivial to implement, but important for C++

13
clang/lib/Sema/SemaTemplateInstantiate.cpp
View File

@ -1813,7 +1813,6 @@ TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
return NewT;
}
Optional<unsigned> PackIndex;
if (T->isParameterPack()) {
assert(Arg.getKind() == TemplateArgument::Pack &&
"Missing argument pack");
@ -1831,7 +1830,6 @@ TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
}
Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
PackIndex = getSema().ArgumentPackSubstitutionIndex;
}
assert(Arg.getKind() == TemplateArgument::Type &&
@ -1840,8 +1838,8 @@ TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
QualType Replacement = Arg.getAsType();
// TODO: only do this uniquing once, at the start of instantiation.
QualType Result = getSema().Context.getSubstTemplateTypeParmType(
T, Replacement, PackIndex);
QualType Result
= getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
SubstTemplateTypeParmTypeLoc NewTL
= TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
@ -1879,10 +1877,11 @@ TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
TemplateArgument Arg = TL.getTypePtr()->getArgumentPack();
Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
QualType Result = Arg.getAsType();
QualType Result = getSema().Context.getSubstTemplateTypeParmType(
TL.getTypePtr()->getReplacedParameter(), Arg.getAsType(),
getSema().ArgumentPackSubstitutionIndex);
Result = getSema().Context.getSubstTemplateTypeParmType(
TL.getTypePtr()->getReplacedParameter(),
Result);
SubstTemplateTypeParmTypeLoc NewTL
= TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

8
clang/lib/Sema/TreeTransform.h
View File

@ -4852,8 +4852,7 @@ QualType TreeTransform<Derived>::RebuildQualifiedType(QualType T,
Replacement = SemaRef.Context.getQualifiedType(
Replacement.getUnqualifiedType(), Qs);
T = SemaRef.Context.getSubstTemplateTypeParmType(
SubstTypeParam->getReplacedParameter(), Replacement,
SubstTypeParam->getPackIndex());
SubstTypeParam->getReplacedParameter(), Replacement);
} else if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->isDeduced()) {
// 'auto' types behave the same way as template parameters.
QualType Deduced = AutoTy->getDeducedType();
@ -6410,8 +6409,9 @@ QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
// Always canonicalize the replacement type.
Replacement = SemaRef.Context.getCanonicalType(Replacement);
QualType Result = SemaRef.Context.getSubstTemplateTypeParmType(
T->getReplacedParameter(), Replacement, T->getPackIndex());
QualType Result
= SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(),
Replacement);
// Propagate type-source information.
SubstTemplateTypeParmTypeLoc NewTL

16
clang/test/AST/ast-dump-template-decls.cpp
View File

@ -136,13 +136,13 @@ template <typename... Cs> struct foo {
};
using t1 = foo<int, short>::bind<char, float>;
// CHECK: TemplateSpecializationType 0x{{[^ ]*}} 'Y<char, float, int, short>' sugar Y
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'char' sugar pack_index 0
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'char' sugar
// CHECK-NEXT: TemplateTypeParmType 0x{{[^ ]*}} 'Bs' dependent contains_unexpanded_pack depth 0 index 0 pack
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'float' sugar pack_index 1
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'float' sugar
// CHECK-NEXT: TemplateTypeParmType 0x{{[^ ]*}} 'Bs' dependent contains_unexpanded_pack depth 0 index 0 pack
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'int' sugar pack_index 2
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'int' sugar
// CHECK-NEXT: TemplateTypeParmType 0x{{[^ ]*}} 'Bs' dependent contains_unexpanded_pack depth 0 index 0 pack
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'short' sugar pack_index 3
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'short' sugar
// CHECK-NEXT: TemplateTypeParmType 0x{{[^ ]*}} 'Bs' dependent contains_unexpanded_pack depth 0 index 0 pack
template <typename... T> struct D {
@ -152,13 +152,13 @@ using t2 = D<float, char>::B<int, short>;
// CHECK: TemplateSpecializationType 0x{{[^ ]*}} 'B<int, short>' sugar alias B
// CHECK: FunctionProtoType 0x{{[^ ]*}} 'int (int (*)(float, int), int (*)(char, short))' cdecl
// CHECK: FunctionProtoType 0x{{[^ ]*}} 'int (float, int)' cdecl
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'float' sugar pack_index 0
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'float' sugar
// CHECK-NEXT: TemplateTypeParmType 0x{{[^ ]*}} 'T' dependent contains_unexpanded_pack depth 0 index 0 pack
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'int' sugar pack_index 0
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'int' sugar
// CHECK-NEXT: TemplateTypeParmType 0x{{[^ ]*}} 'U' dependent contains_unexpanded_pack depth 0 index 0 pack
// CHECK: FunctionProtoType 0x{{[^ ]*}} 'int (char, short)' cdecl
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'char' sugar pack_index 1
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'char' sugar
// CHECK-NEXT: TemplateTypeParmType 0x{{[^ ]*}} 'T' dependent contains_unexpanded_pack depth 0 index 0 pack
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'short' sugar pack_index 1
// CHECK: SubstTemplateTypeParmType 0x{{[^ ]*}} 'short' sugar
// CHECK-NEXT: TemplateTypeParmType 0x{{[^ ]*}} 'U' dependent contains_unexpanded_pack depth 0 index 0 pack
} // namespace PR56099

38
clang/unittests/AST/ASTImporterTest.cpp
View File

@ -4793,44 +4793,6 @@ TEST_P(ASTImporterOptionSpecificTestBase,
ToD2->getDeclContext(), ToD2->getTemplateParameters()->getParam(0)));
}
TEST_P(ASTImporterOptionSpecificTestBase, ImportSubstTemplateTypeParmType) {
constexpr auto Code = R"(
template <class A1, class... A2> struct A {
using B = A1(A2...);
};
template struct A<void, char, float, int, short>;
)";
Decl *FromTU = getTuDecl(Code, Lang_CXX11, "input.cpp");
auto *FromClass = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
FromTU, classTemplateSpecializationDecl());
auto testType = [&](ASTContext &Ctx, const char *Name,
llvm::Optional<unsigned> PackIndex) {
const auto *Subst = selectFirst<SubstTemplateTypeParmType>(
"sttp", match(substTemplateTypeParmType(
hasReplacementType(hasCanonicalType(asString(Name))))
.bind("sttp"),
Ctx));
const char *ExpectedTemplateParamName = PackIndex ? "A2" : "A1";
ASSERT_TRUE(Subst);
ASSERT_EQ(Subst->getReplacedParameter()->getIdentifier()->getName(),
ExpectedTemplateParamName);
ASSERT_EQ(Subst->getPackIndex(), PackIndex);
};
auto tests = [&](ASTContext &Ctx) {
testType(Ctx, "void", None);
testType(Ctx, "char", 0);
testType(Ctx, "float", 1);
testType(Ctx, "int", 2);
testType(Ctx, "short", 3);
};
tests(FromTU->getASTContext());
ClassTemplateSpecializationDecl *ToClass = Import(FromClass, Lang_CXX11);
tests(ToClass->getASTContext());
}
const AstTypeMatcher<SubstTemplateTypeParmPackType>
substTemplateTypeParmPackType;