[clang] [Clang] Fix spurious "satisfaction of constraint ... depends on itself" from nested synthesized comparisons (PR #223289)
via cfe-commits
cfe-commits at lists.llvm.org
Sun Sep 13 19:44:45 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
Author: Hsin (GEJXD)
<details>
<summary>Changes</summary>
Fixes #<!-- -->223220
This re-lands #<!-- -->221707 with a minimal fix for the regression it introduced,
which made comparing two `std::map` objects fail with:
```text
error: satisfaction of constraint 'requires { { __t < __u } -> __boolean_testable; { __u < __t } -> __boolean_testable; }' depends on itself
```
## Root cause
`TemplateInstantiator::instantiateMissingDeclsToScopeForConcepts` (added by
#<!-- -->221707) resolves a missing declaration by walking the
`LocalInstantiationScope` chain. After #<!-- -->221707 this walk returns mappings for
*all* declaration kinds, including function parameters.
When the constraint of one specialization of a function template is checked
while another specialization of the *same* template is still being checked
(`std::__detail::__synth3way_t` reached from `std::pair`'s rewritten
`operator<=>` inside `std::map`'s), the parameters of the inner
specialization are looked up through the outer scope chain and find the outer
specialization's parameter mapping. The inner constraint expression then
substitutes the outer (pair-typed) parameters, so the check re-enters an
identical constraint check and is reported as "depends on itself" (the
constraint-satisfaction stack contains the same constraint ID twice).
## Fix
In the outer-scope walk, skip `ParmVarDecl`s and fall through to on-demand
instantiation (CWG2770), which always builds a parameter bound to the
*current* specialization. Non-parameter declarations (e.g. the typedefs that
#<!-- -->221707 intended to make visible in the current scope; see #GH198052,
#GH209632) still reuse outer-scope mappings as before.
This matches the intent stated in the original change ("we don't want clashes
of instantiated function parameters").
## Regression test
`clang/test/SemaTemplate/concepts-nested-synth.cpp` reproduces the
`std::__detail::__synth3way_t` structure instantiated from the `operator<=>`
of `std::map` and `std::pair` with no standard library, exercising the exact
nested-constraint path:
- `Map::operator<=>` returns `synth_t<Pair<const K, V>>` → outer
`Synth::operator()<Pair,...>` constraint check active
- inside its requirement, `lhs < rhs` resolves through `Pair`'s rewritten
`operator<=>` whose return type instantiates `synth_t<K, K>` → inner
`Synth::operator()<K, K>` check nested in the outer one
## Validation
- Fails on the re-landed commit ("depends on itself"), passes with the fix
- `check-clang` (full clang test suite): 0 failures
- `git clang-format` and `git diff --check`: clean
---
Patch is 28.26 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/223289.diff
8 Files Affected:
- (modified) clang/docs/ReleaseNotes.md (+9)
- (modified) clang/include/clang/Sema/Sema.h (+7-19)
- (modified) clang/include/clang/Sema/Template.h (+2)
- (modified) clang/lib/Sema/SemaConcept.cpp (+32-144)
- (modified) clang/lib/Sema/SemaTemplateInstantiate.cpp (+87-35)
- (modified) clang/test/SemaCXX/cxx2c-fold-exprs.cpp (+25)
- (modified) clang/test/SemaTemplate/concepts-lambda.cpp (+16)
- (added) clang/test/SemaTemplate/concepts-nested-synth.cpp (+82)
``````````diff
diff --git a/clang/docs/ReleaseNotes.md b/clang/docs/ReleaseNotes.md
index 043a0ddae2a6c..f55d5570da375 100644
--- a/clang/docs/ReleaseNotes.md
+++ b/clang/docs/ReleaseNotes.md
@@ -589,6 +589,15 @@ features cannot lower the translation-unit ABI level;
- Fixed a crash when module directive export module foo not following a
semicolon and there are no rest pp-tokens in current module file. (#GH187771)
+- Fixed concept evaluation bugs where some declarations were not added to
+ the current instantiation scope. (#GH198052), (#GH209632)
+
+- Fixed a regression where the constraint of one specialization of a function
+ template could reuse the function parameters of an outer (still active)
+ specialization of the same template, causing a spurious
+ "satisfaction of constraint ... depends on itself" error for synthesized
+ three-way comparisons such as ``std::map``'s ``operator<=>``. (#GH223220)
+
- Fixed a crash when a lambda parameter pack was given a default argument that
is a pack expansion referencing an enclosing function's parameter pack (e.g.
`[](Types... = args...) {}`). Clang now diagnoses the illegal default
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 4ff4c669a6b70..fc8da0ed56005 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -15129,11 +15129,17 @@ class Sema final : public SemaBase {
const NamedDecl *D1, ArrayRef<AssociatedConstraint> AC1,
const NamedDecl *D2, ArrayRef<AssociatedConstraint> AC2);
+private:
+ friend class ConstraintSatisfactionChecker;
+ friend class SubstituteParameterMappings;
+
+ UnsignedOrNone EvaluateFoldExpandedConstraintSize(
+ const Expr *Pattern, const MultiLevelTemplateArgumentList &MLTAL);
+
/// Cache the satisfaction of an atomic constraint.
/// The key is based on the unsubstituted expression and the parameter
/// mapping. This lets us not substituting the mapping more than once,
/// which is (very!) expensive.
- /// FIXME: this should be private.
llvm::DenseMap<llvm::FoldingSetNodeID,
UnsubstitutedConstraintSatisfactionCacheResult>
UnsubstitutedConstraintSatisfactionCache;
@@ -15145,7 +15151,6 @@ class Sema final : public SemaBase {
llvm::DenseMap<llvm::FoldingSetNodeID, TemplateArgumentLoc>
*CurrentCachedTemplateArgs = nullptr;
-private:
/// Caches pairs of template-like decls whose associated constraints were
/// checked for subsumption and whether or not the first's constraints did in
/// fact subsume the second's.
@@ -15166,23 +15171,6 @@ class Sema final : public SemaBase {
// The current stack of constraint satisfactions, so we can exit-early.
llvm::SmallVector<SatisfactionStackEntryTy, 10> SatisfactionStack;
- /// Used by SetupConstraintCheckingTemplateArgumentsAndScope to set up the
- /// LocalInstantiationScope of the current non-lambda function. For lambdas,
- /// use LambdaScopeForCallOperatorInstantiationRAII.
- bool
- SetupConstraintScope(FunctionDecl *FD,
- std::optional<ArrayRef<TemplateArgument>> TemplateArgs,
- const MultiLevelTemplateArgumentList &MLTAL,
- LocalInstantiationScope &Scope);
-
- /// Used during constraint checking, sets up the constraint template argument
- /// lists, and calls SetupConstraintScope to set up the
- /// LocalInstantiationScope to have the proper set of ParVarDecls configured.
- std::optional<MultiLevelTemplateArgumentList>
- SetupConstraintCheckingTemplateArgumentsAndScope(
- FunctionDecl *FD, std::optional<ArrayRef<TemplateArgument>> TemplateArgs,
- LocalInstantiationScope &Scope);
-
///@}
//
diff --git a/clang/include/clang/Sema/Template.h b/clang/include/clang/Sema/Template.h
index 50e950e56c6ca..818528744511d 100644
--- a/clang/include/clang/Sema/Template.h
+++ b/clang/include/clang/Sema/Template.h
@@ -540,6 +540,8 @@ enum class TemplateSubstitutionKind : char {
llvm::PointerUnion<Decl *, DeclArgumentPack *> *
getInstantiationOfIfExists(const Decl *D);
+ LocalInstantiationScope *getOuterScope() const { return Outer; }
+
void InstantiatedLocal(const Decl *D, Decl *Inst);
void InstantiatedLocalPackArg(const Decl *D, VarDecl *Inst);
void MakeInstantiatedLocalArgPack(const Decl *D);
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index ee17f826dc32c..0122e920e5d89 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -549,7 +549,9 @@ class HashParameterMapping : public RecursiveASTVisitor<HashParameterMapping> {
}
}
};
+} // namespace
+namespace clang {
class ConstraintSatisfactionChecker {
Sema &S;
const NamedDecl *Template;
@@ -652,10 +654,6 @@ class ConstraintSatisfactionChecker {
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,
@@ -700,7 +698,7 @@ class ConstraintSatisfactionChecker {
const MultiLevelTemplateArgumentList &MLTAL);
};
-} // namespace
+} // namespace clang
ExprResult ConstraintSatisfactionChecker::EvaluateAtomicConstraint(
const Expr *AtomicExpr, const MultiLevelTemplateArgumentList &MLTAL) {
@@ -948,31 +946,6 @@ ExprResult ConstraintSatisfactionChecker::Evaluate(
return PMCache.cache(EvaluateSlow(Constraint, MLTAL));
}
-UnsignedOrNone
-ConstraintSatisfactionChecker::EvaluateFoldExpandedConstraintSize(
- const FoldExpandedConstraint &FE,
- const MultiLevelTemplateArgumentList &MLTAL) {
-
- Expr *Pattern = const_cast<Expr *>(FE.getPattern());
-
- SmallVector<UnexpandedParameterPack, 2> Unexpanded;
- S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
- assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
- bool Expand = true;
- bool RetainExpansion = false;
- UnsignedOrNone NumExpansions(std::nullopt);
- if (S.CheckParameterPacksForExpansion(
- Pattern->getExprLoc(), Pattern->getSourceRange(), Unexpanded, MLTAL,
- /*FailOnPackProducingTemplates=*/false, Expand, RetainExpansion,
- NumExpansions, /*Diagnose=*/false) ||
- !Expand || RetainExpansion)
- return std::nullopt;
-
- if (NumExpansions && S.getLangOpts().BracketDepth < *NumExpansions)
- return std::nullopt;
- return NumExpansions;
-}
-
ExprResult ConstraintSatisfactionChecker::EvaluateSlow(
const FoldExpandedConstraint &Constraint,
const MultiLevelTemplateArgumentList &MLTAL) {
@@ -993,9 +966,15 @@ ExprResult ConstraintSatisfactionChecker::EvaluateSlow(
return ExprError();
}
- ExprResult Out;
- UnsignedOrNone NumExpansions =
- EvaluateFoldExpandedConstraintSize(Constraint, *SubstitutedArgs);
+ UnsignedOrNone NumExpansions(std::nullopt);
+ {
+ Sema::InstantiatingTemplate InstTemplate(
+ S, TemplateNameLoc,
+ Sema::InstantiatingTemplate::ConstraintSubstitution{},
+ const_cast<NamedDecl *>(Template), Constraint.getSourceRange());
+ NumExpansions = S.EvaluateFoldExpandedConstraintSize(
+ Constraint.getPattern(), *SubstitutedArgs);
+ }
if (!NumExpansions)
return ExprEmpty();
@@ -1004,6 +983,7 @@ ExprResult ConstraintSatisfactionChecker::EvaluateSlow(
return ExprEmpty();
}
+ ExprResult Out;
for (unsigned I = 0; I < *NumExpansions; I++) {
Sema::ArgPackSubstIndexRAII SubstIndex(S, I);
Satisfaction.IsSatisfied = false;
@@ -1412,98 +1392,6 @@ SubstituteConceptsInConstraintExpression(Sema &S, const NamedDecl *D,
MLTAL);
}
-bool Sema::SetupConstraintScope(
- FunctionDecl *FD, std::optional<ArrayRef<TemplateArgument>> TemplateArgs,
- const MultiLevelTemplateArgumentList &MLTAL,
- LocalInstantiationScope &Scope) {
- assert(!isLambdaCallOperator(FD) &&
- "Use LambdaScopeForCallOperatorInstantiationRAII to handle lambda "
- "instantiations");
- if (FD->isTemplateInstantiation() && FD->getPrimaryTemplate()) {
- FunctionTemplateDecl *PrimaryTemplate = FD->getPrimaryTemplate();
- InstantiatingTemplate Inst(
- *this, FD->getPointOfInstantiation(),
- Sema::InstantiatingTemplate::ConstraintsCheck{}, PrimaryTemplate,
- TemplateArgs ? *TemplateArgs : ArrayRef<TemplateArgument>{},
- SourceRange());
- if (Inst.isInvalid())
- return true;
-
- // addInstantiatedParametersToScope creates a map of 'uninstantiated' to
- // 'instantiated' parameters and adds it to the context. For the case where
- // this function is a template being instantiated NOW, we also need to add
- // the list of current template arguments to the list so that they also can
- // be picked out of the map.
- if (auto *SpecArgs = FD->getTemplateSpecializationArgs()) {
- MultiLevelTemplateArgumentList JustTemplArgs(FD, SpecArgs->asArray(),
- /*Final=*/false);
- if (addInstantiatedParametersToScope(
- FD, PrimaryTemplate->getTemplatedDecl(), Scope, JustTemplArgs))
- return true;
- }
-
- // If this is a member function, make sure we get the parameters that
- // reference the original primary template.
- if (FunctionTemplateDecl *FromMemTempl =
- PrimaryTemplate->getInstantiatedFromMemberTemplate()) {
- if (addInstantiatedParametersToScope(FD, FromMemTempl->getTemplatedDecl(),
- Scope, MLTAL))
- return true;
- }
-
- return false;
- }
-
- if (FD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization ||
- FD->getTemplatedKind() == FunctionDecl::TK_DependentNonTemplate) {
- FunctionDecl *InstantiatedFrom =
- FD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization
- ? FD->getInstantiatedFromMemberFunction()
- : FD->getInstantiatedFromDecl();
-
- InstantiatingTemplate Inst(
- *this, FD->getPointOfInstantiation(),
- Sema::InstantiatingTemplate::ConstraintsCheck{}, InstantiatedFrom,
- TemplateArgs ? *TemplateArgs : ArrayRef<TemplateArgument>{},
- SourceRange());
- if (Inst.isInvalid())
- return true;
-
- // Case where this was not a template, but instantiated as a
- // child-function.
- if (addInstantiatedParametersToScope(FD, InstantiatedFrom, Scope, MLTAL))
- return true;
- }
-
- return false;
-}
-
-// This function collects all of the template arguments for the purposes of
-// constraint-instantiation and checking.
-std::optional<MultiLevelTemplateArgumentList>
-Sema::SetupConstraintCheckingTemplateArgumentsAndScope(
- FunctionDecl *FD, std::optional<ArrayRef<TemplateArgument>> TemplateArgs,
- LocalInstantiationScope &Scope) {
- MultiLevelTemplateArgumentList MLTAL;
-
- // Collect the list of template arguments relative to the 'primary' template.
- // We need the entire list, since the constraint is completely uninstantiated
- // at this point.
- MLTAL =
- getTemplateInstantiationArgs(FD, FD->getLexicalDeclContext(),
- /*Final=*/false, /*Innermost=*/std::nullopt,
- /*RelativeToPrimary=*/true,
- /*Pattern=*/nullptr,
- /*ForConstraintInstantiation=*/true);
- // Lambdas are handled by LambdaScopeForCallOperatorInstantiationRAII.
- if (isLambdaCallOperator(FD))
- return MLTAL;
- if (SetupConstraintScope(FD, TemplateArgs, MLTAL, Scope))
- return std::nullopt;
-
- return MLTAL;
-}
-
bool Sema::CheckFunctionConstraints(const FunctionDecl *FD,
ConstraintSatisfaction &Satisfaction,
SourceLocation UsageLoc,
@@ -1543,12 +1431,12 @@ bool Sema::CheckFunctionConstraints(const FunctionDecl *FD,
ContextRAII SavedContext{*this, CtxToSave};
LocalInstantiationScope Scope(*this, !ForOverloadResolution);
- std::optional<MultiLevelTemplateArgumentList> MLTAL =
- SetupConstraintCheckingTemplateArgumentsAndScope(
- const_cast<FunctionDecl *>(FD), {}, Scope);
-
- if (!MLTAL)
- return true;
+ MultiLevelTemplateArgumentList MLTAL =
+ getTemplateInstantiationArgs(FD, FD->getLexicalDeclContext(),
+ /*Final=*/false, /*Innermost=*/std::nullopt,
+ /*RelativeToPrimary=*/true,
+ /*Pattern=*/nullptr,
+ /*ForConstraintInstantiation=*/true);
Qualifiers ThisQuals;
CXXRecordDecl *Record = nullptr;
@@ -1559,11 +1447,11 @@ bool Sema::CheckFunctionConstraints(const FunctionDecl *FD,
CXXThisScopeRAII ThisScope(*this, Record, ThisQuals, Record != nullptr);
LambdaScopeForCallOperatorInstantiationRAII LambdaScope(
- *this, const_cast<FunctionDecl *>(FD), *MLTAL, Scope,
+ *this, const_cast<FunctionDecl *>(FD), MLTAL, Scope,
ForOverloadResolution);
return CheckConstraintSatisfaction(
- FD, FD->getTrailingRequiresClause(), *MLTAL,
+ FD, FD->getTrailingRequiresClause(), MLTAL,
SourceRange(UsageLoc.isValid() ? UsageLoc : FD->getLocation()),
Satisfaction);
}
@@ -1796,12 +1684,12 @@ bool Sema::CheckFunctionTemplateConstraints(
Sema::ContextRAII savedContext(*this, Decl);
LocalInstantiationScope Scope(*this);
- std::optional<MultiLevelTemplateArgumentList> MLTAL =
- SetupConstraintCheckingTemplateArgumentsAndScope(Decl, TemplateArgs,
- Scope);
-
- if (!MLTAL)
- return true;
+ MultiLevelTemplateArgumentList MLTAL =
+ getTemplateInstantiationArgs(Decl, Decl->getLexicalDeclContext(),
+ /*Final=*/false, /*Innermost=*/std::nullopt,
+ /*RelativeToPrimary=*/true,
+ /*Pattern=*/nullptr,
+ /*ForConstraintInstantiation=*/true);
Qualifiers ThisQuals;
CXXRecordDecl *Record = nullptr;
@@ -1811,10 +1699,10 @@ bool Sema::CheckFunctionTemplateConstraints(
}
CXXThisScopeRAII ThisScope(*this, Record, ThisQuals, Record != nullptr);
- LambdaScopeForCallOperatorInstantiationRAII LambdaScope(*this, Decl, *MLTAL,
+ LambdaScopeForCallOperatorInstantiationRAII LambdaScope(*this, Decl, MLTAL,
Scope);
- return CheckConstraintSatisfaction(Template, TemplateAC, *MLTAL,
+ return CheckConstraintSatisfaction(Template, TemplateAC, MLTAL,
PointOfInstantiation, Satisfaction);
}
@@ -2087,7 +1975,7 @@ void Sema::DiagnoseUnsatisfiedConstraint(
ConstraintExpr->getBeginLoc(), First);
}
-namespace {
+namespace clang {
class SubstituteParameterMappings {
Sema &SemaRef;
@@ -2125,6 +2013,8 @@ class SubstituteParameterMappings {
bool substitute(NormalizedConstraint &N);
};
+} // namespace clang
+
void SubstituteParameterMappings::buildParameterMapping(
NormalizedConstraintWithParamMapping &N) {
TemplateParameterList *TemplateParams =
@@ -2418,8 +2308,6 @@ bool SubstituteParameterMappings::substitute(NormalizedConstraint &N) {
llvm_unreachable("Unknown ConstraintKind enum");
}
-} // namespace
-
NormalizedConstraint *NormalizedConstraint::fromAssociatedConstraints(
Sema &S, const NamedDecl *D, ArrayRef<AssociatedConstraint> ACs) {
assert(ACs.size() != 0);
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index ffbe8bb0506bc..fe27b9ea1f323 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -1324,11 +1324,10 @@ namespace {
bool BailOutOnIncomplete;
std::optional<llvm::FoldingSetNodeID> TemplateArgsHashValue;
+ llvm::DenseMap<llvm::FoldingSetNodeID, TemplateArgumentLoc>
+ *CurrentCachedTemplateArgs = nullptr;
- // CWG2770: Function parameters should be instantiated when they are
- // needed by a satisfaction check of an atomic constraint or
- // (recursively) by another function parameter.
- bool maybeInstantiateFunctionParameterToScope(ParmVarDecl *OldParm);
+ bool instantiateMissingDeclsToScopeForConcepts(Decl *D);
public:
typedef TreeTransform<TemplateInstantiator> inherited;
@@ -1358,12 +1357,14 @@ namespace {
inline static struct ForConstraintSubstitution_t {
} ForConstraintSubstitution;
- TemplateInstantiator(ForParameterMappingSubstitution_t, Sema &SemaRef,
- SourceLocation Loc,
- const MultiLevelTemplateArgumentList &TemplateArgs)
+ TemplateInstantiator(
+ ForParameterMappingSubstitution_t, Sema &SemaRef, SourceLocation Loc,
+ const MultiLevelTemplateArgumentList &TemplateArgs,
+ llvm::DenseMap<llvm::FoldingSetNodeID, TemplateArgumentLoc> *Cache)
: inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
- EvaluateLambdaConstraint(true), BailOutOnIncomplete(false) {
- if (!SemaRef.CurrentCachedTemplateArgs)
+ EvaluateLambdaConstraint(true), BailOutOnIncomplete(false),
+ CurrentCachedTemplateArgs(Cache) {
+ if (!Cache)
return;
auto &V = TemplateArgsHashValue.emplace();
for (auto &Level : TemplateArgs)
@@ -1410,22 +1411,18 @@ namespace {
ArrayRef<UnexpandedParameterPack> Unexpanded,
bool FailOnPackProducingTemplates,
bool &ShouldExpand, bool &RetainExpansion,
- UnsignedOrNone &NumExpansions) {
- if (SemaRef.CurrentInstantiationScope &&
- (SemaRef.inConstraintSubstitution() ||
- SemaRef.inParameterMappingSubstitution())) {
- for (UnexpandedParameterPack ParmPack : Unexpanded) {
- NamedDecl *VD = ParmPack.first.dyn_cast<NamedDecl *>();
- if (auto *PVD = dyn_cast_if_present<ParmVarDecl>(VD);
- PVD && maybeInstantiateFunctionParameterToScope(PVD))
- return true;
- }
+ UnsignedOrNone &NumExpansions,
+ bool Diagnose = true) {
+ for (UnexpandedParameterPack ParmPack : Unexpanded) {
+ if (instantiateMissingDeclsToScopeForConcepts(
+ dyn_cast<NamedDecl *>(ParmPack.first)))
+ return true;
}
return getSema().CheckParameterPacksForExpansion(
EllipsisLoc, PatternRange, Unexpanded, TemplateArgs,
FailOnPackProducingTemplates, ShouldExpand, RetainExpansion,
- NumExpansions);
+ NumExpansions, Diagnose);
}
void ExpandingFunctionParameterPack(ParmVarDecl *Pack) {
@@ -1637,7 +1634,7 @@ namespace {
TemplateArgumentLoc &Output,
bool Uneval = false) {
const TemplateArgument &Arg = Input.getArgument();
- if (auto *Cache = SemaRef.CurrentCachedTemplateArgs;
+ if (auto *Cache = CurrentCachedTemplateArgs;
Cache && TemplateArgsHashValue) {
llvm::FoldingSetNodeID ID = *TemplateArgsHashValue;
ID.AddInteger(SemaRef.ArgPackSubstIndex.toInternalRepresentation());
@@ -1980,11 +1977,7 @@ Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
// template parameter.
}
- if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(D);
- PVD && SemaRef.CurrentInstantiationScope &&
- (SemaRef.inConstraintSubstitution() ||
- SemaRef.inParameterMappingSubstitution()) &&
- maybeInstantiateFunctionParameterToScope(PVD))
+ if (instantiateMissingDeclsToScopeForConcepts(D))
return nullptr;
if (isa<CXXExpansionStmtDecl>(D)) {
@@ -1996,9 +1989,47 @@ Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
}
-bool TemplateInstantiator::mayb...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/223289
More information about the cfe-commits
mailing list