================
@@ -164,52 +171,290 @@ struct SatisfactionStackRAII {
SatisfactionStackRAII(Sema &SemaRef, const NamedDecl *ND,
const llvm::FoldingSetNodeID &FSNID)
: SemaRef(SemaRef) {
- if (ND) {
+ if (ND) {
SemaRef.PushSatisfactionStackEntry(ND, FSNID);
Inserted = true;
- }
+ }
}
~SatisfactionStackRAII() {
- if (Inserted)
- SemaRef.PopSatisfactionStackEntry();
+ if (Inserted)
+ SemaRef.PopSatisfactionStackEntry();
}
};
} // namespace
-static bool
-DiagRecursiveConstraintEval(Sema &S, llvm::FoldingSetNodeID &ID,
- const NamedDecl *Templ, const Expr *E,
- const MultiLevelTemplateArgumentList &MLTAL) {
+static bool DiagRecursiveConstraintEval(
+ Sema &S, llvm::FoldingSetNodeID &ID, const NamedDecl *Templ, const Expr *E,
+ const MultiLevelTemplateArgumentList *MLTAL = nullptr) {
E->Profile(ID, S.Context, /*Canonical=*/true);
- for (const auto &List : MLTAL)
- for (const auto &TemplateArg : List.Args)
- TemplateArg.Profile(ID, S.Context);
-
- // Note that we have to do this with our own collection, because there are
- // times where a constraint-expression check can cause us to need to evaluate
- // other constriants that are unrelated, such as when evaluating a recovery
- // expression, or when trying to determine the constexpr-ness of special
- // members. Otherwise we could just use the
- // Sema::InstantiatingTemplate::isAlreadyBeingInstantiated function.
+ if (MLTAL) {
+ for (const auto &List : *MLTAL)
+ for (const auto &TemplateArg : List.Args)
+ S.Context.getCanonicalTemplateArgument(TemplateArg)
+ .Profile(ID, S.Context);
+ }
if (S.SatisfactionStackContains(Templ, ID)) {
S.Diag(E->getExprLoc(), diag::err_constraint_depends_on_self)
<< const_cast<Expr *>(E) << E->getSourceRange();
return true;
}
-
return false;
}
-static ExprResult EvaluateAtomicConstraint(
- Sema &S, const Expr *AtomicExpr, const NamedDecl *Template,
- SourceLocation TemplateNameLoc, const MultiLevelTemplateArgumentList
&MLTAL,
- ConstraintSatisfaction &Satisfaction) {
+// Figure out the to-translation-unit depth for this function declaration for
+// the purpose of seeing if they differ by constraints. This isn't the same as
+// getTemplateDepth, because it includes already instantiated parents.
+static unsigned
+CalculateTemplateDepthForConstraints(Sema &S, const NamedDecl *ND,
+ bool SkipForSpecialization = false) {
+ MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
+ ND, ND->getLexicalDeclContext(), /*Final=*/false,
+ /*Innermost=*/std::nullopt,
+ /*RelativeToPrimary=*/true,
+ /*Pattern=*/nullptr,
+ /*ForConstraintInstantiation=*/true, SkipForSpecialization);
+ return MLTAL.getNumLevels();
+}
+
+namespace {
+class AdjustConstraintDepth : public TreeTransform<AdjustConstraintDepth> {
+ unsigned TemplateDepth = 0;
+
+public:
+ using inherited = TreeTransform<AdjustConstraintDepth>;
+ AdjustConstraintDepth(Sema &SemaRef, unsigned TemplateDepth)
+ : inherited(SemaRef), TemplateDepth(TemplateDepth) {}
+
+ using inherited::TransformTemplateTypeParmType;
+ QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
+ TemplateTypeParmTypeLoc TL, bool) {
+ const TemplateTypeParmType *T = TL.getTypePtr();
+
+ TemplateTypeParmDecl *NewTTPDecl = nullptr;
+ if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl())
+ NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
+ TransformDecl(TL.getNameLoc(), OldTTPDecl));
+
+ QualType Result = getSema().Context.getTemplateTypeParmType(
+ T->getDepth() + TemplateDepth, T->getIndex(), T->isParameterPack(),
+ NewTTPDecl);
+ TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
+ NewTL.setNameLoc(TL.getNameLoc());
+ return Result;
+ }
+
+ bool AlreadyTransformed(QualType T) {
+ if (T.isNull())
+ return true;
+
+ if (T->isInstantiationDependentType() || T->isVariablyModifiedType() ||
+ T->containsUnexpandedParameterPack())
+ return false;
+ return true;
+ }
+};
+} // namespace
+
+namespace {
+
+class HashParameterMapping : public RecursiveASTVisitor<HashParameterMapping> {
+ using inherited = RecursiveASTVisitor<HashParameterMapping>;
+ friend inherited;
+
+ Sema &SemaRef;
+ const MultiLevelTemplateArgumentList &TemplateArgs;
+ llvm::FoldingSetNodeID &ID;
+ llvm::SmallVector<TemplateArgument, 10> UsedTemplateArgs;
+
+ UnsignedOrNone OuterPackSubstIndex;
+
+ TemplateArgument getPackSubstitutedTemplateArgument(TemplateArgument Arg) {
+ assert(*SemaRef.ArgPackSubstIndex < Arg.pack_size());
+ Arg = Arg.pack_begin()[*SemaRef.ArgPackSubstIndex];
+ if (Arg.isPackExpansion())
+ Arg = Arg.getPackExpansionPattern();
+ return Arg;
+ }
+
+ bool shouldVisitTemplateInstantiations() const { return true; }
+
+public:
+ HashParameterMapping(Sema &SemaRef,
+ const MultiLevelTemplateArgumentList &TemplateArgs,
+ llvm::FoldingSetNodeID &ID,
+ UnsignedOrNone OuterPackSubstIndex)
+ : SemaRef(SemaRef), TemplateArgs(TemplateArgs), ID(ID),
+ OuterPackSubstIndex(OuterPackSubstIndex) {}
+
+ bool VisitTemplateTypeParmType(TemplateTypeParmType *T) {
+ // A lambda expression can introduce template parameters that don't have
+ // corresponding template arguments yet.
+ if (T->getDepth() >= TemplateArgs.getNumLevels())
+ return true;
+
+ TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex());
+
+ if (T->isParameterPack() && SemaRef.ArgPackSubstIndex) {
+ assert(Arg.getKind() == TemplateArgument::Pack &&
+ "Missing argument pack");
+
+ Arg = getPackSubstitutedTemplateArgument(Arg);
+ }
+
+ UsedTemplateArgs.push_back(
+ SemaRef.Context.getCanonicalTemplateArgument(Arg));
+ return true;
+ }
+
+ bool VisitDeclRefExpr(DeclRefExpr *E) {
+ NamedDecl *D = E->getDecl();
+ NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D);
+ if (!NTTP)
+ return TraverseDecl(D);
+
+ TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition());
+ if (NTTP->isParameterPack() && SemaRef.ArgPackSubstIndex) {
+ assert(Arg.getKind() == TemplateArgument::Pack &&
+ "Missing argument pack");
+ Arg = getPackSubstitutedTemplateArgument(Arg);
+ }
+
+ UsedTemplateArgs.push_back(
+ SemaRef.Context.getCanonicalTemplateArgument(Arg));
+ return true;
+ }
+
+ bool VisitTypedefType(TypedefType *TT) {
+ return inherited::TraverseType(TT->desugar());
+ }
+
+ bool TraverseDecl(Decl *D) {
+ if (auto *VD = dyn_cast<ValueDecl>(D))
+ return TraverseType(VD->getType());
+
+ return inherited::TraverseDecl(D);
+ }
+
+ bool TraverseTypeLoc(TypeLoc TL, bool TraverseQualifier = true) {
+ // We don't care about TypeLocs. So traverse Types instead.
+ return TraverseType(TL.getType(), TraverseQualifier);
+ }
+
+ bool TraverseTemplateArgument(const TemplateArgument &Arg) {
+ if (!Arg.containsUnexpandedParameterPack() || Arg.isPackExpansion()) {
+ // Act as if we are fully expanding this pack, if it is a PackExpansion.
+ Sema::ArgPackSubstIndexRAII _1(SemaRef, std::nullopt);
+ llvm::SaveAndRestore<UnsignedOrNone> _2(OuterPackSubstIndex,
+ std::nullopt);
+ return inherited::TraverseTemplateArgument(Arg);
+ }
+
+ Sema::ArgPackSubstIndexRAII _1(SemaRef, OuterPackSubstIndex);
+ return inherited::TraverseTemplateArgument(Arg);
+ }
+
+ void VisitConstraint(const NormalizedConstraintWithParamMapping &Constraint)
{
+ if (!Constraint.hasParameterMapping()) {
+ for (auto List : TemplateArgs)
+ for (const TemplateArgument &Arg : List.Args)
+ SemaRef.Context.getCanonicalTemplateArgument(Arg).Profile(
+ ID, SemaRef.Context);
+ return;
+ }
+
+ llvm::ArrayRef<TemplateArgumentLoc> Mapping =
+ Constraint.getParameterMapping();
+ for (auto &ArgLoc : Mapping) {
+ TemplateArgument Canonical =
+ SemaRef.Context.getCanonicalTemplateArgument(ArgLoc.getArgument());
+ // We don't want sugars to impede the profile of cache.
+ UsedTemplateArgs.push_back(Canonical);
+ TraverseTemplateArgument(Canonical);
+ }
+
+ // llvm::SmallSet<llvm::FoldingSetNodeID, 10> ArgHash;
+ for (auto &Used : UsedTemplateArgs) {
+ llvm::FoldingSetNodeID R;
+ Used.Profile(R, SemaRef.Context);
+ ID.AddNodeID(R);
+ // ArgHash.insert(R);
+ }
+
+ // for (const llvm::FoldingSetNodeID &V : ArgHash)
+ // ID.AddNodeID(V);
+ }
+};
+
+class CalculateConstraintSatisfaction {
+ Sema &S;
+ const NamedDecl *Template;
+ SourceLocation TemplateNameLoc;
+ UnsignedOrNone PackSubstitutionIndex;
+
+ ConstraintSatisfaction &Satisfaction;
+
+private:
+ ExprResult
+ EvaluateAtomicConstraint(const Expr *AtomicExpr,
+ const MultiLevelTemplateArgumentList &MLTAL);
+
+ UnsignedOrNone EvaluateFoldExpandedConstraintSize(
+ const FoldExpandedConstraint &FE,
+ const MultiLevelTemplateArgumentList &MLTAL);
+
+ // XXX: It is SLOW! Use it very carefully.
+ std::optional<MultiLevelTemplateArgumentList>
SubstitutionInTemplateArguments(
+ const NormalizedConstraintWithParamMapping &Constraint,
+ MultiLevelTemplateArgumentList MLTAL,
+ llvm::SmallVector<TemplateArgument> &SubstitutedOuterMost);
+
+ ExprResult CalculateSlow(const AtomicConstraint &Constraint,
+ const MultiLevelTemplateArgumentList &MLTAL);
+
+ ExprResult Calculate(const AtomicConstraint &Constraint,
----------------
zyn0217 wrote:
Nit: I was thinking if we can have a better name; having Calculate inside a
Calculate* class sounds... tautological?
https://github.com/llvm/llvm-project/pull/141776
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
