Skip to content

Commit e3b1083

Browse files
alexander-shaposhnikovalexander-shaposhnikov
committed
[Clang][Sema] Fix comparison of constraint expressions
This diff switches the approach to comparison of constraint expressions to the new one based on template args substitution. It continues the effort to fix our handling of out-of-line definitions of constrained templates. This is a recommit of 60bee9f. Differential revision: https://reviews.llvm.org/D146178
1 parent a68039c commit e3b1083

File tree

10 files changed

+419
-59
lines changed

10 files changed

+419
-59
lines changed

‎clang/include/clang/AST/DeclTemplate.h

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2309,9 +2309,15 @@ class ClassTemplateDecl : public RedeclarableTemplateDecl {
23092309
return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
23102310
}
23112311

2312+
void setCommonPtr(Common *C) {
2313+
RedeclarableTemplateDecl::Common = C;
2314+
}
2315+
23122316
public:
2317+
23132318
friend class ASTDeclReader;
23142319
friend class ASTDeclWriter;
2320+
friend class TemplateDeclInstantiator;
23152321

23162322
/// Load any lazily-loaded specializations from the external source.
23172323
void LoadLazySpecializations() const;

‎clang/include/clang/Sema/Template.h

Lines changed: 15 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -232,9 +232,21 @@ enum class TemplateSubstitutionKind : char {
232232
/// Replaces the current 'innermost' level with the provided argument list.
233233
/// This is useful for type deduction cases where we need to get the entire
234234
/// list from the AST, but then add the deduced innermost list.
235-
void replaceInnermostTemplateArguments(ArgList Args) {
236-
assert(TemplateArgumentLists.size() > 0 && "Replacing in an empty list?");
237-
TemplateArgumentLists[0].Args = Args;
235+
void replaceInnermostTemplateArguments(Decl *AssociatedDecl, ArgList Args) {
236+
assert((!TemplateArgumentLists.empty() || NumRetainedOuterLevels) &&
237+
"Replacing in an empty list?");
238+
239+
if (!TemplateArgumentLists.empty()) {
240+
assert((TemplateArgumentLists[0].AssociatedDeclAndFinal.getPointer() ||
241+
TemplateArgumentLists[0].AssociatedDeclAndFinal.getPointer() ==
242+
AssociatedDecl) &&
243+
"Trying to change incorrect declaration?");
244+
TemplateArgumentLists[0].Args = Args;
245+
} else {
246+
--NumRetainedOuterLevels;
247+
TemplateArgumentLists.push_back(
248+
{{AssociatedDecl, /*Final=*/false}, Args});
249+
}
238250
}
239251

240252
/// Add an outermost level that we are not substituting. We have no

‎clang/lib/Sema/SemaConcept.cpp

Lines changed: 34 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -721,7 +721,7 @@ CalculateTemplateDepthForConstraints(Sema &S, const NamedDecl *ND,
721721
ND, /*Final=*/false, /*Innermost=*/nullptr, /*RelativeToPrimary=*/true,
722722
/*Pattern=*/nullptr,
723723
/*ForConstraintInstantiation=*/true, SkipForSpecialization);
724-
return MLTAL.getNumSubstitutedLevels();
724+
return MLTAL.getNumLevels();
725725
}
726726

727727
namespace {
@@ -752,27 +752,44 @@ namespace {
752752
};
753753
} // namespace
754754

755+
static const Expr *SubstituteConstraintExpression(Sema &S, const NamedDecl *ND,
756+
const Expr *ConstrExpr) {
757+
MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
758+
ND, /*Final=*/false, /*Innermost=*/nullptr,
759+
/*RelativeToPrimary=*/true,
760+
/*Pattern=*/nullptr, /*ForConstraintInstantiation=*/true,
761+
/*SkipForSpecialization*/ false);
762+
if (MLTAL.getNumSubstitutedLevels() == 0)
763+
return ConstrExpr;
764+
765+
Sema::SFINAETrap SFINAE(S, /*AccessCheckingSFINAE=*/false);
766+
std::optional<Sema::CXXThisScopeRAII> ThisScope;
767+
if (auto *RD = dyn_cast<CXXRecordDecl>(ND->getDeclContext()))
768+
ThisScope.emplace(S, const_cast<CXXRecordDecl *>(RD), Qualifiers());
769+
ExprResult SubstConstr =
770+
S.SubstConstraintExpr(const_cast<clang::Expr *>(ConstrExpr), MLTAL);
771+
if (SFINAE.hasErrorOccurred() || !SubstConstr.isUsable())
772+
return nullptr;
773+
return SubstConstr.get();
774+
}
775+
755776
bool Sema::AreConstraintExpressionsEqual(const NamedDecl *Old,
756777
const Expr *OldConstr,
757778
const NamedDecl *New,
758779
const Expr *NewConstr) {
780+
if (OldConstr == NewConstr)
781+
return true;
759782
if (Old && New && Old != New) {
760-
unsigned Depth1 = CalculateTemplateDepthForConstraints(
761-
*this, Old);
762-
unsigned Depth2 = CalculateTemplateDepthForConstraints(
763-
*this, New);
764-
765-
// Adjust the 'shallowest' verison of this to increase the depth to match
766-
// the 'other'.
767-
if (Depth2 > Depth1) {
768-
OldConstr = AdjustConstraintDepth(*this, Depth2 - Depth1)
769-
.TransformExpr(const_cast<Expr *>(OldConstr))
770-
.get();
771-
} else if (Depth1 > Depth2) {
772-
NewConstr = AdjustConstraintDepth(*this, Depth1 - Depth2)
773-
.TransformExpr(const_cast<Expr *>(NewConstr))
774-
.get();
775-
}
783+
if (const Expr *SubstConstr =
784+
SubstituteConstraintExpression(*this, Old, OldConstr))
785+
OldConstr = SubstConstr;
786+
else
787+
return false;
788+
if (const Expr *SubstConstr =
789+
SubstituteConstraintExpression(*this, New, NewConstr))
790+
NewConstr = SubstConstr;
791+
else
792+
return false;
776793
}
777794

778795
llvm::FoldingSetNodeID ID1, ID2;

‎clang/lib/Sema/SemaOverload.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1294,7 +1294,7 @@ bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old,
12941294
// We check the return type and template parameter lists for function
12951295
// templates first; the remaining checks follow.
12961296
bool SameTemplateParameterList = TemplateParameterListsAreEqual(
1297-
NewTemplate->getTemplateParameters(),
1297+
NewTemplate, NewTemplate->getTemplateParameters(), OldTemplate,
12981298
OldTemplate->getTemplateParameters(), false, TPL_TemplateMatch);
12991299
bool SameReturnType = Context.hasSameType(Old->getDeclaredReturnType(),
13001300
New->getDeclaredReturnType());

‎clang/lib/Sema/SemaTemplateDeduction.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2881,7 +2881,7 @@ CheckDeducedArgumentConstraints(Sema &S, TemplateDeclT *Template,
28812881
// not class-scope explicit specialization, so replace with Deduced Args
28822882
// instead of adding to inner-most.
28832883
if (NeedsReplacement)
2884-
MLTAL.replaceInnermostTemplateArguments(CanonicalDeducedArgs);
2884+
MLTAL.replaceInnermostTemplateArguments(Template, CanonicalDeducedArgs);
28852885

28862886
if (S.CheckConstraintSatisfaction(Template, AssociatedConstraints, MLTAL,
28872887
Info.getLocation(),

‎clang/lib/Sema/SemaTemplateInstantiate.cpp

Lines changed: 31 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -131,6 +131,14 @@ HandleDefaultTempArgIntoTempTempParam(const TemplateTemplateParmDecl *TTP,
131131
return Response::Done();
132132
}
133133

134+
Response HandlePartialClassTemplateSpec(
135+
const ClassTemplatePartialSpecializationDecl *PartialClassTemplSpec,
136+
MultiLevelTemplateArgumentList &Result, bool SkipForSpecialization) {
137+
if (!SkipForSpecialization)
138+
Result.addOuterRetainedLevels(PartialClassTemplSpec->getTemplateDepth());
139+
return Response::Done();
140+
}
141+
134142
// Add template arguments from a class template instantiation.
135143
Response
136144
HandleClassTemplateSpec(const ClassTemplateSpecializationDecl *ClassTemplSpec,
@@ -208,6 +216,21 @@ Response HandleFunction(const FunctionDecl *Function,
208216
return Response::UseNextDecl(Function);
209217
}
210218

219+
Response HandleFunctionTemplateDecl(const FunctionTemplateDecl *FTD,
220+
MultiLevelTemplateArgumentList &Result) {
221+
if (!isa<ClassTemplateSpecializationDecl>(FTD->getDeclContext())) {
222+
NestedNameSpecifier *NNS = FTD->getTemplatedDecl()->getQualifier();
223+
const Type *Ty;
224+
const TemplateSpecializationType *TSTy;
225+
if (NNS && (Ty = NNS->getAsType()) &&
226+
(TSTy = Ty->getAs<TemplateSpecializationType>()))
227+
Result.addOuterTemplateArguments(const_cast<FunctionTemplateDecl *>(FTD),
228+
TSTy->template_arguments(),
229+
/*Final=*/false);
230+
}
231+
return Response::ChangeDecl(FTD->getLexicalDeclContext());
232+
}
233+
211234
Response HandleRecordDecl(const CXXRecordDecl *Rec,
212235
MultiLevelTemplateArgumentList &Result,
213236
ASTContext &Context,
@@ -218,15 +241,10 @@ Response HandleRecordDecl(const CXXRecordDecl *Rec,
218241
"Outer template not instantiated?");
219242
if (ClassTemplate->isMemberSpecialization())
220243
return Response::Done();
221-
if (ForConstraintInstantiation) {
222-
QualType RecordType = Context.getTypeDeclType(Rec);
223-
QualType Injected = cast<InjectedClassNameType>(RecordType)
224-
->getInjectedSpecializationType();
225-
const auto *InjectedType = cast<TemplateSpecializationType>(Injected);
244+
if (ForConstraintInstantiation)
226245
Result.addOuterTemplateArguments(const_cast<CXXRecordDecl *>(Rec),
227-
InjectedType->template_arguments(),
246+
ClassTemplate->getInjectedTemplateArgs(),
228247
/*Final=*/false);
229-
}
230248
}
231249

232250
bool IsFriend = Rec->getFriendObjectKind() ||
@@ -306,6 +324,10 @@ MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
306324
if (const auto *VarTemplSpec =
307325
dyn_cast<VarTemplateSpecializationDecl>(CurDecl)) {
308326
R = HandleVarTemplateSpec(VarTemplSpec, Result, SkipForSpecialization);
327+
} else if (const auto *PartialClassTemplSpec =
328+
dyn_cast<ClassTemplatePartialSpecializationDecl>(CurDecl)) {
329+
R = HandlePartialClassTemplateSpec(PartialClassTemplSpec, Result,
330+
SkipForSpecialization);
309331
} else if (const auto *ClassTemplSpec =
310332
dyn_cast<ClassTemplateSpecializationDecl>(CurDecl)) {
311333
R = HandleClassTemplateSpec(ClassTemplSpec, Result,
@@ -318,6 +340,8 @@ MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
318340
} else if (const auto *CSD =
319341
dyn_cast<ImplicitConceptSpecializationDecl>(CurDecl)) {
320342
R = HandleImplicitConceptSpecializationDecl(CSD, Result);
343+
} else if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(CurDecl)) {
344+
R = HandleFunctionTemplateDecl(FTD, Result);
321345
} else if (!isa<DeclContext>(CurDecl)) {
322346
R = Response::DontClearRelativeToPrimaryNextDecl(CurDecl);
323347
if (CurDecl->getDeclContext()->isTranslationUnit()) {

‎clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

Lines changed: 31 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -1653,33 +1653,12 @@ Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
16531653
<< QualifierLoc.getSourceRange();
16541654
return nullptr;
16551655
}
1656-
1657-
if (PrevClassTemplate) {
1658-
const ClassTemplateDecl *MostRecentPrevCT =
1659-
PrevClassTemplate->getMostRecentDecl();
1660-
TemplateParameterList *PrevParams =
1661-
MostRecentPrevCT->getTemplateParameters();
1662-
1663-
// Make sure the parameter lists match.
1664-
if (!SemaRef.TemplateParameterListsAreEqual(
1665-
D->getTemplatedDecl(), InstParams,
1666-
MostRecentPrevCT->getTemplatedDecl(), PrevParams, true,
1667-
Sema::TPL_TemplateMatch))
1668-
return nullptr;
1669-
1670-
// Do some additional validation, then merge default arguments
1671-
// from the existing declarations.
1672-
if (SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
1673-
Sema::TPC_ClassTemplate))
1674-
return nullptr;
1675-
}
16761656
}
16771657

16781658
CXXRecordDecl *RecordInst = CXXRecordDecl::Create(
16791659
SemaRef.Context, Pattern->getTagKind(), DC, Pattern->getBeginLoc(),
16801660
Pattern->getLocation(), Pattern->getIdentifier(), PrevDecl,
16811661
/*DelayTypeCreation=*/true);
1682-
16831662
if (QualifierLoc)
16841663
RecordInst->setQualifierInfo(QualifierLoc);
16851664

@@ -1689,16 +1668,38 @@ Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
16891668
ClassTemplateDecl *Inst
16901669
= ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
16911670
D->getIdentifier(), InstParams, RecordInst);
1692-
assert(!(isFriend && Owner->isDependentContext()));
1693-
Inst->setPreviousDecl(PrevClassTemplate);
1694-
16951671
RecordInst->setDescribedClassTemplate(Inst);
16961672

16971673
if (isFriend) {
1698-
if (PrevClassTemplate)
1674+
assert(!Owner->isDependentContext());
1675+
Inst->setLexicalDeclContext(Owner);
1676+
RecordInst->setLexicalDeclContext(Owner);
1677+
1678+
if (PrevClassTemplate) {
1679+
Inst->setCommonPtr(PrevClassTemplate->getCommonPtr());
1680+
RecordInst->setTypeForDecl(
1681+
PrevClassTemplate->getTemplatedDecl()->getTypeForDecl());
1682+
const ClassTemplateDecl *MostRecentPrevCT =
1683+
PrevClassTemplate->getMostRecentDecl();
1684+
TemplateParameterList *PrevParams =
1685+
MostRecentPrevCT->getTemplateParameters();
1686+
1687+
// Make sure the parameter lists match.
1688+
if (!SemaRef.TemplateParameterListsAreEqual(
1689+
RecordInst, InstParams, MostRecentPrevCT->getTemplatedDecl(),
1690+
PrevParams, true, Sema::TPL_TemplateMatch))
1691+
return nullptr;
1692+
1693+
// Do some additional validation, then merge default arguments
1694+
// from the existing declarations.
1695+
if (SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
1696+
Sema::TPC_ClassTemplate))
1697+
return nullptr;
1698+
16991699
Inst->setAccess(PrevClassTemplate->getAccess());
1700-
else
1700+
} else {
17011701
Inst->setAccess(D->getAccess());
1702+
}
17021703

17031704
Inst->setObjectOfFriendDecl();
17041705
// TODO: do we want to track the instantiation progeny of this
@@ -1709,15 +1710,15 @@ Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
17091710
Inst->setInstantiatedFromMemberTemplate(D);
17101711
}
17111712

1713+
Inst->setPreviousDecl(PrevClassTemplate);
1714+
17121715
// Trigger creation of the type for the instantiation.
1713-
SemaRef.Context.getInjectedClassNameType(RecordInst,
1714-
Inst->getInjectedClassNameSpecialization());
1716+
SemaRef.Context.getInjectedClassNameType(
1717+
RecordInst, Inst->getInjectedClassNameSpecialization());
17151718

17161719
// Finish handling of friends.
17171720
if (isFriend) {
17181721
DC->makeDeclVisibleInContext(Inst);
1719-
Inst->setLexicalDeclContext(Owner);
1720-
RecordInst->setLexicalDeclContext(Owner);
17211722
return Inst;
17221723
}
17231724

‎clang/test/SemaTemplate/concepts-friends.cpp

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -441,3 +441,27 @@ namespace NTTP {
441441
templ_func<1>(u2);
442442
}
443443
}
444+
445+
446+
namespace FrineOfFriend {
447+
448+
template <typename>
449+
concept Concept = true;
450+
451+
template <Concept> class FriendOfBar;
452+
453+
template <Concept> class Bar {
454+
template <Concept> friend class FriendOfBar;
455+
};
456+
457+
Bar<void> BarInstance;
458+
459+
namespace internal {
460+
void FriendOfFoo(FriendOfBar<void>);
461+
}
462+
463+
template <Concept> class Foo {
464+
friend void internal::FriendOfFoo(FriendOfBar<void>);
465+
};
466+
467+
} // namespace FrineOfFriend

0 commit comments

Comments
 (0)