[clang] [clang][NFC] Un-constify `MultiLevelTemplateArgumentList` (PR #104687)
Vlad Serebrennikov via cfe-commits
cfe-commits at lists.llvm.org
Sat Aug 17 17:03:03 PDT 2024
https://github.com/Endilll created https://github.com/llvm/llvm-project/pull/104687
As highlighted in https://github.com/llvm/llvm-project/pull/93493#issuecomment-2135880330, `MultiLevelTemplateArgumentList` (henceforth MLTAL) has to modify its arguments despite referring to them via `ArrayRef`, which is immutable and propagates `const` to its elements. This is required for (at least) pack expansion, and this use case was checked by @erichkeane who deemed it valid.
The ultimate goal of this PR is to remove `const_cast` from `MultiLevelTemplateArgumentList::setArgument()`. Said removal is known to get very viral through the template engine, though, and this is at least the third attempt to do this that I'm aware of. Previous two attempts were done locally by me and @mizvekov, but we both gave up eventually.
Changes in this patch are everything in-between said removal and four new "bad" `const_cast` that were inserted before this PR gets even worse than it already is.
The first "bad" `const_cast` was added to `BuiltinFunctionStart` in `SemaChecking.cpp:303`. There we acquire a pointer to `const FunctionDecl` from an `APValue`, and pass it to `Sema::checkAddressOfFunctionIsAvailable()` as a pointer to non-const `FunctionDecl`, which checks whether constrains are satisfied, and off we go. I found out that `APValue` is likely to be a can of worms no smaller that MLTAL, so I stopped out of pity to myself and sympathy to the reviewers.
The second "bad" `const_cast` was added to, somewhat surprisingly to me, `SourceLocation` unittests (`ConceptSpecializationExprConceptReferenceRangeVerifier::getRange()`, `SourceLocationTest.cpp:1098`). The test there is concerned with associated constrains of a variable template declaration, and off we go again. Changes there involve changing a signature of a virtual function that is overloaded ≈10 times. I decided that testing code is not important enough to add this many changes to this PR, so I slapped `const_cast` on it and proceeded to publish this PR.
The third and the fourth "bad" `const_cast`s were added to `Sema::getTemplateInstantiationArgs`. There we use a peculiar TU-local type `Response` https://github.com/llvm/llvm-project/blob/69f76c782b554a004078af6909c19a11e3846415/clang/lib/Sema/SemaTemplateInstantiate.cpp#L55-L56 that has several data members, but all of its member functions are `static` and return a new `Response` object instead of e.g. `Decl *`. I didn't see a obvious and localized way to deal with it, so I had to add two bad `const_cast`s on the usage side (`SemaTemplateInstantiate.cpp`, lines 492 and 535).
On top of the usual ways to review this PR, per-commit view of this PR limits the number of rabbit holes you need to consider. A breadth-first view into the changes, if you like. Unfortunately, it was somewhat of an afterthought, so chunks are not even, they don't always build, and sometimes they add "bad" `const_cast`s that are removed in subsequent commits. I hope it helps.
I'd like to highlight that headers don't give you the full picture of changes to function signatures, because this affects a number of TU-local functions. One more type I'd like to bring your attention to is `Sema::TemplateCompareNewDeclInfo`. This type has a converting constructor from `NamedDecl *`, and was often passed as a temporary that binds to a `const` reference on the callee side. As we know, non-const references do not bind to temporaries, so I converted those cases into pass-by-value instead.
> Oh well, sorry I wasn't around to advise against it[.](https://github.com/llvm/llvm-project/pull/93493#issuecomment-2135891181)
@mizvekov Sorry, I'm bad at following advice sometimes 😁
>From 4c67e7d449f04914d2a93ec1c73559ceb4b6e716 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sat, 17 Aug 2024 16:53:48 +0300
Subject: [PATCH 01/13] Step 1
---
clang/include/clang/AST/Decl.h | 1 +
clang/include/clang/AST/DeclTemplate.h | 10 ++++++++++
clang/include/clang/Sema/Sema.h | 6 +++---
clang/include/clang/Sema/Template.h | 2 +-
clang/lib/AST/Decl.cpp | 5 +++++
clang/lib/Sema/SemaConcept.cpp | 4 ++--
clang/lib/Sema/SemaTemplate.cpp | 10 +++++-----
clang/lib/Sema/SemaTemplateDeduction.cpp | 6 +++---
clang/lib/Sema/SemaTemplateInstantiate.cpp | 4 ++--
clang/lib/Sema/SemaTemplateInstantiateDecl.cpp | 12 ++++++------
10 files changed, 38 insertions(+), 22 deletions(-)
diff --git a/clang/include/clang/AST/Decl.h b/clang/include/clang/AST/Decl.h
index 6d84bd03de810a..f79d62f225d9ec 100644
--- a/clang/include/clang/AST/Decl.h
+++ b/clang/include/clang/AST/Decl.h
@@ -2913,6 +2913,7 @@ class FunctionDecl : public DeclaratorDecl,
/// If this function declaration is not a function template specialization,
/// returns NULL.
const TemplateArgumentList *getTemplateSpecializationArgs() const;
+ TemplateArgumentList *getTemplateSpecializationArgs();
/// Retrieve the template argument list as written in the sources,
/// if any.
diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h
index 687715a22e9fd3..8915113ea85bd0 100644
--- a/clang/include/clang/AST/DeclTemplate.h
+++ b/clang/include/clang/AST/DeclTemplate.h
@@ -275,12 +275,22 @@ class TemplateArgumentList final
return llvm::ArrayRef(data(), size());
}
+ /// Produce this as a mutable array ref.
+ MutableArrayRef<TemplateArgument> asMutableArray() {
+ return llvm::MutableArrayRef(data(), size());
+ }
+
/// Retrieve the number of template arguments in this
/// template argument list.
unsigned size() const { return NumArguments; }
/// Retrieve a pointer to the template argument list.
const TemplateArgument *data() const {
+ return const_cast<TemplateArgumentList *>(this)->data();
+ }
+
+ /// Retrieve a pointer to the template argument list.
+ TemplateArgument *data() {
return getTrailingObjects<TemplateArgument>();
}
};
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 299a916b9abf8d..3dd6bd31c4e469 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -11638,7 +11638,7 @@ class Sema final : public SemaBase {
TemplateArgumentLoc SubstDefaultTemplateArgumentIfAvailable(
TemplateDecl *Template, SourceLocation TemplateLoc,
SourceLocation RAngleLoc, Decl *Param,
- ArrayRef<TemplateArgument> SugaredConverted,
+ MutableArrayRef<TemplateArgument> SugaredConverted,
ArrayRef<TemplateArgument> CanonicalConverted, bool &HasDefaultArg);
/// Returns the top most location responsible for the definition of \p N.
@@ -13676,7 +13676,7 @@ class Sema final : public SemaBase {
/// Usually this should not be used, and template argument deduction should be
/// used in its place.
FunctionDecl *InstantiateFunctionDeclaration(
- FunctionTemplateDecl *FTD, const TemplateArgumentList *Args,
+ FunctionTemplateDecl *FTD, TemplateArgumentList *Args,
SourceLocation Loc,
CodeSynthesisContext::SynthesisKind CSC =
CodeSynthesisContext::ExplicitTemplateArgumentSubstitution);
@@ -13705,7 +13705,7 @@ class Sema final : public SemaBase {
bool AtEndOfTU = false);
VarTemplateSpecializationDecl *BuildVarTemplateInstantiation(
VarTemplateDecl *VarTemplate, VarDecl *FromVar,
- const TemplateArgumentList *PartialSpecArgs,
+ TemplateArgumentList *PartialSpecArgs,
const TemplateArgumentListInfo &TemplateArgsInfo,
SmallVectorImpl<TemplateArgument> &Converted,
SourceLocation PointOfInstantiation,
diff --git a/clang/include/clang/Sema/Template.h b/clang/include/clang/Sema/Template.h
index 0340c23fd170d6..4890bb8a044efd 100644
--- a/clang/include/clang/Sema/Template.h
+++ b/clang/include/clang/Sema/Template.h
@@ -76,7 +76,7 @@ enum class TemplateSubstitutionKind : char {
class MultiLevelTemplateArgumentList {
/// The template argument list at a certain template depth
- using ArgList = ArrayRef<TemplateArgument>;
+ using ArgList = MutableArrayRef<TemplateArgument>;
struct ArgumentListLevel {
llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal;
ArgList Args;
diff --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp
index 90caf81757ac96..8c688218cee2be 100644
--- a/clang/lib/AST/Decl.cpp
+++ b/clang/lib/AST/Decl.cpp
@@ -4162,6 +4162,11 @@ FunctionDecl::getTemplateSpecializationInfo() const {
const TemplateArgumentList *
FunctionDecl::getTemplateSpecializationArgs() const {
+ return const_cast<FunctionDecl *>(this)->getTemplateSpecializationArgs();
+}
+
+TemplateArgumentList *
+FunctionDecl::getTemplateSpecializationArgs() {
if (FunctionTemplateSpecializationInfo *Info
= TemplateOrSpecialization
.dyn_cast<FunctionTemplateSpecializationInfo*>()) {
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index de24bbe7eb99ce..b051b5f2b9ae1d 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -586,7 +586,7 @@ static bool CheckConstraintSatisfaction(
ArrayRef<TemplateArgument> TemplateArgs =
TemplateArgsLists.getNumSubstitutedLevels() > 0
? TemplateArgsLists.getOutermost()
- : ArrayRef<TemplateArgument> {};
+ : MutableArrayRef<TemplateArgument> {};
Sema::InstantiatingTemplate Inst(S, TemplateIDRange.getBegin(),
Sema::InstantiatingTemplate::ConstraintsCheck{},
const_cast<NamedDecl *>(Template), TemplateArgs, TemplateIDRange);
@@ -769,7 +769,7 @@ bool Sema::SetupConstraintScope(
// 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(),
+ MultiLevelTemplateArgumentList JustTemplArgs(FD, SpecArgs->asMutableArray(),
/*Final=*/false);
if (addInstantiatedParametersToScope(
FD, PrimaryTemplate->getTemplatedDecl(), Scope, JustTemplArgs))
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 25585f683752ac..9005fbcea6536f 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -4190,7 +4190,7 @@ Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc,
// the set of specializations, based on the closest partial specialization
// that it represents. That is,
VarDecl *InstantiationPattern = Template->getTemplatedDecl();
- const TemplateArgumentList *PartialSpecArgs = nullptr;
+ TemplateArgumentList *PartialSpecArgs = nullptr;
bool AmbiguousPartialSpec = false;
typedef PartialSpecMatchResult MatchResult;
SmallVector<MatchResult, 4> Matched;
@@ -4764,7 +4764,7 @@ bool Sema::CheckTemplateTypeArgument(
static bool SubstDefaultTemplateArgument(
Sema &SemaRef, TemplateDecl *Template, SourceLocation TemplateLoc,
SourceLocation RAngleLoc, TemplateTypeParmDecl *Param,
- ArrayRef<TemplateArgument> SugaredConverted,
+ MutableArrayRef<TemplateArgument> SugaredConverted,
ArrayRef<TemplateArgument> CanonicalConverted,
TemplateArgumentLoc &Output) {
Output = Param->getDefaultArgument();
@@ -4824,7 +4824,7 @@ static bool SubstDefaultTemplateArgument(
static bool SubstDefaultTemplateArgument(
Sema &SemaRef, TemplateDecl *Template, SourceLocation TemplateLoc,
SourceLocation RAngleLoc, NonTypeTemplateParmDecl *Param,
- ArrayRef<TemplateArgument> SugaredConverted,
+ MutableArrayRef<TemplateArgument> SugaredConverted,
ArrayRef<TemplateArgument> CanonicalConverted,
TemplateArgumentLoc &Output) {
Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc, Param, Template,
@@ -4874,7 +4874,7 @@ static bool SubstDefaultTemplateArgument(
static TemplateName SubstDefaultTemplateArgument(
Sema &SemaRef, TemplateDecl *Template, SourceLocation TemplateLoc,
SourceLocation RAngleLoc, TemplateTemplateParmDecl *Param,
- ArrayRef<TemplateArgument> SugaredConverted,
+ MutableArrayRef<TemplateArgument> SugaredConverted,
ArrayRef<TemplateArgument> CanonicalConverted,
NestedNameSpecifierLoc &QualifierLoc) {
Sema::InstantiatingTemplate Inst(
@@ -4909,7 +4909,7 @@ static TemplateName SubstDefaultTemplateArgument(
TemplateArgumentLoc Sema::SubstDefaultTemplateArgumentIfAvailable(
TemplateDecl *Template, SourceLocation TemplateLoc,
SourceLocation RAngleLoc, Decl *Param,
- ArrayRef<TemplateArgument> SugaredConverted,
+ MutableArrayRef<TemplateArgument> SugaredConverted,
ArrayRef<TemplateArgument> CanonicalConverted, bool &HasDefaultArg) {
HasDefaultArg = false;
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index 35bc8cd713f06c..6807a4162c2c2f 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -3070,7 +3070,7 @@ template <typename TemplateDeclT>
static TemplateDeductionResult
CheckDeducedArgumentConstraints(Sema &S, TemplateDeclT *Template,
ArrayRef<TemplateArgument> SugaredDeducedArgs,
- ArrayRef<TemplateArgument> CanonicalDeducedArgs,
+ MutableArrayRef<TemplateArgument> CanonicalDeducedArgs,
TemplateDeductionInfo &Info) {
llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
Template->getAssociatedConstraints(AssociatedConstraints);
@@ -3524,7 +3524,7 @@ TemplateDeductionResult Sema::SubstituteExplicitTemplateArguments(
ExtParameterInfoBuilder ExtParamInfos;
MultiLevelTemplateArgumentList MLTAL(FunctionTemplate,
- SugaredExplicitArgumentList->asArray(),
+ SugaredExplicitArgumentList->asMutableArray(),
/*Final=*/true);
// Instantiate the types of each of the function parameters given the
@@ -3877,7 +3877,7 @@ TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(
Owner = FD->getLexicalDeclContext();
}
MultiLevelTemplateArgumentList SubstArgs(
- FunctionTemplate, CanonicalDeducedArgumentList->asArray(),
+ FunctionTemplate, CanonicalDeducedArgumentList->asMutableArray(),
/*Final=*/false);
Specialization = cast_or_null<FunctionDecl>(
SubstDecl(FD, Owner, SubstArgs));
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 9a6cd2cd0ab751..a7514fb386766a 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -181,7 +181,7 @@ HandleVarTemplateSpec(const VarTemplateSpecializationDecl *VarTemplSpec,
Specialized.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
if (!SkipForSpecialization)
Result.addOuterTemplateArguments(
- Partial, VarTemplSpec->getTemplateInstantiationArgs().asArray(),
+ Partial, VarTemplSpec->getTemplateInstantiationArgs().asMutableArray(),
/*Final=*/false);
if (Partial->isMemberSpecialization())
return Response::Done();
@@ -189,7 +189,7 @@ HandleVarTemplateSpec(const VarTemplateSpecializationDecl *VarTemplSpec,
VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
if (!SkipForSpecialization)
Result.addOuterTemplateArguments(
- Tmpl, VarTemplSpec->getTemplateInstantiationArgs().asArray(),
+ Tmpl, VarTemplSpec->getTemplateInstantiationArgs().asMutableArray(),
/*Final=*/false);
if (Tmpl->isMemberSpecialization())
return Response::Done();
diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
index a58854acb21fa5..47ba9f2a07e69c 100644
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -497,7 +497,7 @@ static void instantiateOMPDeclareVariantAttr(
if (!VariantFTD->isThisDeclarationADefinition())
return;
Sema::TentativeAnalysisScope Trap(S);
- const TemplateArgumentList *TAL = TemplateArgumentList::CreateCopy(
+ TemplateArgumentList *TAL = TemplateArgumentList::CreateCopy(
S.Context, TemplateArgs.getInnermost());
auto *SubstFD = S.InstantiateFunctionDeclaration(VariantFTD, TAL,
@@ -1112,7 +1112,7 @@ Decl *TemplateDeclInstantiator::InstantiateTypeAliasTemplateDecl(
Sema::InstantiatingTemplate InstTemplate(
SemaRef, D->getBeginLoc(), D,
D->getTemplateDepth() >= TemplateArgs.getNumLevels()
- ? ArrayRef<TemplateArgument>()
+ ? MutableArrayRef<TemplateArgument>()
: (TemplateArgs.begin() + TemplateArgs.getNumLevels() - 1 -
D->getTemplateDepth())
->Args);
@@ -4901,7 +4901,7 @@ bool TemplateDeclInstantiator::SubstDefaultedFunction(FunctionDecl *New,
}
FunctionDecl *Sema::InstantiateFunctionDeclaration(
- FunctionTemplateDecl *FTD, const TemplateArgumentList *Args,
+ FunctionTemplateDecl *FTD, TemplateArgumentList *Args,
SourceLocation Loc, CodeSynthesisContext::SynthesisKind CSC) {
FunctionDecl *FD = FTD->getTemplatedDecl();
@@ -4911,7 +4911,7 @@ FunctionDecl *Sema::InstantiateFunctionDeclaration(
return nullptr;
ContextRAII SavedContext(*this, FD);
- MultiLevelTemplateArgumentList MArgs(FTD, Args->asArray(),
+ MultiLevelTemplateArgumentList MArgs(FTD, Args->asMutableArray(),
/*Final=*/false);
return cast_or_null<FunctionDecl>(SubstDecl(FD, FD->getParent(), MArgs));
@@ -5252,7 +5252,7 @@ void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
VarTemplateSpecializationDecl *Sema::BuildVarTemplateInstantiation(
VarTemplateDecl *VarTemplate, VarDecl *FromVar,
- const TemplateArgumentList *PartialSpecArgs,
+ TemplateArgumentList *PartialSpecArgs,
const TemplateArgumentListInfo &TemplateArgsInfo,
SmallVectorImpl<TemplateArgument> &Converted,
SourceLocation PointOfInstantiation, LateInstantiatedAttrVec *LateAttrs,
@@ -5280,7 +5280,7 @@ VarTemplateSpecializationDecl *Sema::BuildVarTemplateInstantiation(
assert(PartialSpecArgs);
IsMemberSpec = PartialSpec->isMemberSpecialization();
MultiLevelList.addOuterTemplateArguments(
- PartialSpec, PartialSpecArgs->asArray(), /*Final=*/false);
+ PartialSpec, PartialSpecArgs->asMutableArray(), /*Final=*/false);
} else {
assert(VarTemplate == FromVar->getDescribedVarTemplate());
IsMemberSpec = VarTemplate->isMemberSpecialization();
>From 0dd4119df526ea11880dea8741d2dadbd08a739a Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sat, 17 Aug 2024 16:53:55 +0300
Subject: [PATCH 02/13] Step 2
---
clang/include/clang/AST/DeclTemplate.h | 44 +++++++++++------
clang/lib/AST/DeclTemplate.cpp | 8 +++-
clang/lib/Sema/SemaTemplateInstantiate.cpp | 55 ++++++++++------------
3 files changed, 62 insertions(+), 45 deletions(-)
diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h
index 8915113ea85bd0..adf3ec56b9bac8 100644
--- a/clang/include/clang/AST/DeclTemplate.h
+++ b/clang/include/clang/AST/DeclTemplate.h
@@ -929,7 +929,8 @@ class RedeclarableTemplateDecl : public TemplateDecl,
/// Although the C++ standard has no notion of the "injected" template
/// arguments for a template, the notion is convenient when
/// we need to perform substitutions inside the definition of a template.
- ArrayRef<TemplateArgument> getInjectedTemplateArgs();
+ MutableArrayRef<TemplateArgument> getInjectedTemplateArgs();
+ ArrayRef<TemplateArgument> getInjectedTemplateArgs() const;
using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;
@@ -1829,7 +1830,7 @@ class ClassTemplateSpecializationDecl : public CXXRecordDecl,
/// The template argument list deduced for the class template
/// partial specialization itself.
- const TemplateArgumentList *TemplateArgs;
+ TemplateArgumentList *TemplateArgs;
};
/// The template that this specialization specializes
@@ -1841,7 +1842,7 @@ class ClassTemplateSpecializationDecl : public CXXRecordDecl,
SpecializationOrInstantiationInfo ExplicitInfo = nullptr;
/// The template arguments used to describe this specialization.
- const TemplateArgumentList *TemplateArgs;
+ TemplateArgumentList *TemplateArgs;
/// The point where this template was instantiated (if any)
SourceLocation PointOfInstantiation;
@@ -1891,9 +1892,12 @@ class ClassTemplateSpecializationDecl : public CXXRecordDecl,
/// Retrieve the template arguments of the class template
/// specialization.
- const TemplateArgumentList &getTemplateArgs() const {
+ TemplateArgumentList &getTemplateArgs() {
return *TemplateArgs;
}
+ const TemplateArgumentList &getTemplateArgs() const {
+ return const_cast<ClassTemplateSpecializationDecl *>(this)->getTemplateArgs();
+ }
void setTemplateArgs(TemplateArgumentList *Args) {
TemplateArgs = Args;
@@ -1986,19 +1990,22 @@ class ClassTemplateSpecializationDecl : public CXXRecordDecl,
/// a class template partial specialization, this function will return the
/// deduced template arguments for the class template partial specialization
/// itself.
- const TemplateArgumentList &getTemplateInstantiationArgs() const {
- if (const auto *PartialSpec =
+ TemplateArgumentList &getTemplateInstantiationArgs() {
+ if (auto *PartialSpec =
SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
return *PartialSpec->TemplateArgs;
return getTemplateArgs();
}
+ const TemplateArgumentList &getTemplateInstantiationArgs() const {
+ return const_cast<ClassTemplateSpecializationDecl *>(this)->getTemplateInstantiationArgs();
+ }
/// Note that this class template specialization is actually an
/// instantiation of the given class template partial specialization whose
/// template arguments have been deduced.
void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec,
- const TemplateArgumentList *TemplateArgs) {
+ TemplateArgumentList *TemplateArgs) {
assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
"Already set to a class template partial specialization!");
auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
@@ -2611,7 +2618,7 @@ class VarTemplateSpecializationDecl : public VarDecl,
/// The template argument list deduced for the variable template
/// partial specialization itself.
- const TemplateArgumentList *TemplateArgs;
+ TemplateArgumentList *TemplateArgs;
};
/// The template that this specialization specializes.
@@ -2623,7 +2630,7 @@ class VarTemplateSpecializationDecl : public VarDecl,
SpecializationOrInstantiationInfo ExplicitInfo = nullptr;
/// The template arguments used to describe this specialization.
- const TemplateArgumentList *TemplateArgs;
+ TemplateArgumentList *TemplateArgs;
/// The point where this template was instantiated (if any).
SourceLocation PointOfInstantiation;
@@ -2675,7 +2682,10 @@ class VarTemplateSpecializationDecl : public VarDecl,
/// Retrieve the template arguments of the variable template
/// specialization.
- const TemplateArgumentList &getTemplateArgs() const { return *TemplateArgs; }
+ TemplateArgumentList &getTemplateArgs() { return *TemplateArgs; }
+ const TemplateArgumentList &getTemplateArgs() const {
+ return const_cast<VarTemplateSpecializationDecl *>(this)->getTemplateArgs();
+ }
/// Determine the kind of specialization that this
/// declaration represents.
@@ -2751,19 +2761,22 @@ class VarTemplateSpecializationDecl : public VarDecl,
/// from a variable template partial specialization, this function will the
/// return deduced template arguments for the variable template partial
/// specialization itself.
- const TemplateArgumentList &getTemplateInstantiationArgs() const {
+ TemplateArgumentList &getTemplateInstantiationArgs() {
if (const auto *PartialSpec =
SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
return *PartialSpec->TemplateArgs;
return getTemplateArgs();
}
+ const TemplateArgumentList &getTemplateInstantiationArgs() const {
+ return const_cast<VarTemplateSpecializationDecl *>(this)->getTemplateArgs();
+ }
/// Note that this variable template specialization is actually an
/// instantiation of the given variable template partial specialization whose
/// template arguments have been deduced.
void setInstantiationOf(VarTemplatePartialSpecializationDecl *PartialSpec,
- const TemplateArgumentList *TemplateArgs) {
+ TemplateArgumentList *TemplateArgs) {
assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&
"Already set to a variable template partial specialization!");
auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
@@ -3217,10 +3230,13 @@ class ImplicitConceptSpecializationDecl final
CreateDeserialized(const ASTContext &C, GlobalDeclID ID,
unsigned NumTemplateArgs);
- ArrayRef<TemplateArgument> getTemplateArguments() const {
- return ArrayRef<TemplateArgument>(getTrailingObjects<TemplateArgument>(),
+ MutableArrayRef<TemplateArgument> getTemplateArguments() {
+ return MutableArrayRef<TemplateArgument>(getTrailingObjects<TemplateArgument>(),
NumTemplateArgs);
}
+ ArrayRef<TemplateArgument> getTemplateArguments() const {
+ return const_cast<ImplicitConceptSpecializationDecl *>(this)->getTemplateArguments();
+ }
void setTemplateArguments(ArrayRef<TemplateArgument> Converted);
static bool classofKind(Kind K) { return K == ImplicitConceptSpecialization; }
diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp
index 976b3a3e1ecedb..2a9f9d6e71645e 100644
--- a/clang/lib/AST/DeclTemplate.cpp
+++ b/clang/lib/AST/DeclTemplate.cpp
@@ -396,7 +396,7 @@ void RedeclarableTemplateDecl::addSpecializationImpl(
SETraits::getDecl(Entry));
}
-ArrayRef<TemplateArgument> RedeclarableTemplateDecl::getInjectedTemplateArgs() {
+MutableArrayRef<TemplateArgument> RedeclarableTemplateDecl::getInjectedTemplateArgs() {
TemplateParameterList *Params = getTemplateParameters();
auto *CommonPtr = getCommonPtr();
if (!CommonPtr->InjectedArgs) {
@@ -409,7 +409,11 @@ ArrayRef<TemplateArgument> RedeclarableTemplateDecl::getInjectedTemplateArgs() {
CommonPtr->InjectedArgs);
}
- return llvm::ArrayRef(CommonPtr->InjectedArgs, Params->size());
+ return llvm::MutableArrayRef(CommonPtr->InjectedArgs, Params->size());
+}
+
+ArrayRef<TemplateArgument> RedeclarableTemplateDecl::getInjectedTemplateArgs() const {
+ return const_cast<RedeclarableTemplateDecl *>(this)->getInjectedTemplateArgs();
}
//===----------------------------------------------------------------------===//
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index a7514fb386766a..92a2d2d1c983c1 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -159,7 +159,7 @@ bool isLambdaEnclosedByTypeAliasDecl(
// Add template arguments from a variable template instantiation.
Response
-HandleVarTemplateSpec(const VarTemplateSpecializationDecl *VarTemplSpec,
+HandleVarTemplateSpec(VarTemplateSpecializationDecl *VarTemplSpec,
MultiLevelTemplateArgumentList &Result,
bool SkipForSpecialization) {
// For a class-scope explicit specialization, there are no template arguments
@@ -221,7 +221,7 @@ Response HandlePartialClassTemplateSpec(
// Add template arguments from a class template instantiation.
Response
-HandleClassTemplateSpec(const ClassTemplateSpecializationDecl *ClassTemplSpec,
+HandleClassTemplateSpec(ClassTemplateSpecializationDecl *ClassTemplSpec,
MultiLevelTemplateArgumentList &Result,
bool SkipForSpecialization) {
if (!ClassTemplSpec->isClassScopeExplicitSpecialization()) {
@@ -232,8 +232,8 @@ HandleClassTemplateSpec(const ClassTemplateSpecializationDecl *ClassTemplSpec,
if (!SkipForSpecialization)
Result.addOuterTemplateArguments(
- const_cast<ClassTemplateSpecializationDecl *>(ClassTemplSpec),
- ClassTemplSpec->getTemplateInstantiationArgs().asArray(),
+ ClassTemplSpec,
+ ClassTemplSpec->getTemplateInstantiationArgs().asMutableArray(),
/*Final=*/false);
// If this class template specialization was instantiated from a
@@ -253,7 +253,7 @@ HandleClassTemplateSpec(const ClassTemplateSpecializationDecl *ClassTemplSpec,
return Response::UseNextDecl(ClassTemplSpec);
}
-Response HandleFunction(Sema &SemaRef, const FunctionDecl *Function,
+Response HandleFunction(Sema &SemaRef, FunctionDecl *Function,
MultiLevelTemplateArgumentList &Result,
const FunctionDecl *Pattern, bool RelativeToPrimary,
bool ForConstraintInstantiation) {
@@ -269,11 +269,11 @@ Response HandleFunction(Sema &SemaRef, const FunctionDecl *Function,
// don't get any template arguments from this function but might get
// some from an enclosing template.
return Response::UseNextDecl(Function);
- } else if (const TemplateArgumentList *TemplateArgs =
+ } else if (TemplateArgumentList *TemplateArgs =
Function->getTemplateSpecializationArgs()) {
// Add the template arguments for this specialization.
Result.addOuterTemplateArguments(const_cast<FunctionDecl *>(Function),
- TemplateArgs->asArray(),
+ TemplateArgs->asMutableArray(),
/*Final=*/false);
if (RelativeToPrimary &&
@@ -329,20 +329,20 @@ Response HandleFunction(Sema &SemaRef, const FunctionDecl *Function,
return Response::UseNextDecl(Function);
}
-Response HandleFunctionTemplateDecl(const FunctionTemplateDecl *FTD,
+Response HandleFunctionTemplateDecl(FunctionTemplateDecl *FTD,
MultiLevelTemplateArgumentList &Result) {
if (!isa<ClassTemplateSpecializationDecl>(FTD->getDeclContext())) {
Result.addOuterTemplateArguments(
- const_cast<FunctionTemplateDecl *>(FTD),
- const_cast<FunctionTemplateDecl *>(FTD)->getInjectedTemplateArgs(),
+ FTD,
+ FTD->getInjectedTemplateArgs(),
/*Final=*/false);
NestedNameSpecifier *NNS = FTD->getTemplatedDecl()->getQualifier();
- while (const Type *Ty = NNS ? NNS->getAsType() : nullptr) {
+ while (Type *Ty = NNS ? NNS->getAsType() : nullptr) {
if (NNS->isInstantiationDependent()) {
- if (const auto *TSTy = Ty->getAs<TemplateSpecializationType>()) {
- ArrayRef<TemplateArgument> Arguments = TSTy->template_arguments();
+ if (auto *TSTy = Ty->getAs<TemplateSpecializationType>()) {
+ MutableArrayRef<TemplateArgument> Arguments = TSTy->template_arguments();
// Prefer template arguments from the injected-class-type if possible.
// For example,
// ```cpp
@@ -367,11 +367,9 @@ Response HandleFunctionTemplateDecl(const FunctionTemplateDecl *FTD,
else if (auto *Specialization =
dyn_cast<ClassTemplateSpecializationDecl>(RD))
Arguments =
- Specialization->getTemplateInstantiationArgs().asArray();
+ Specialization->getTemplateInstantiationArgs().asMutableArray();
}
- Result.addOuterTemplateArguments(
- const_cast<FunctionTemplateDecl *>(FTD), Arguments,
- /*Final=*/false);
+ Result.addOuterTemplateArguments(FTD, Arguments, /*Final=*/false);
}
}
@@ -449,10 +447,10 @@ Response HandleRecordDecl(Sema &SemaRef, const CXXRecordDecl *Rec,
}
Response HandleImplicitConceptSpecializationDecl(
- const ImplicitConceptSpecializationDecl *CSD,
+ ImplicitConceptSpecializationDecl *CSD,
MultiLevelTemplateArgumentList &Result) {
Result.addOuterTemplateArguments(
- const_cast<ImplicitConceptSpecializationDecl *>(CSD),
+ CSD,
CSD->getTemplateArguments(),
/*Final=*/false);
return Response::UseNextDecl(CSD);
@@ -466,7 +464,7 @@ Response HandleGenericDeclContext(const Decl *CurDecl) {
MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
const NamedDecl *ND, const DeclContext *DC, bool Final,
- std::optional<ArrayRef<TemplateArgument>> Innermost, bool RelativeToPrimary,
+ std::optional<MutableArrayRef<TemplateArgument>> Innermost, bool RelativeToPrimary,
const FunctionDecl *Pattern, bool ForConstraintInstantiation,
bool SkipForSpecialization) {
assert((ND || DC) && "Can't find arguments for a decl if one isn't provided");
@@ -474,14 +472,13 @@ MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
MultiLevelTemplateArgumentList Result;
using namespace TemplateInstArgsHelpers;
- const Decl *CurDecl = ND;
+ Decl *CurDecl = ND;
if (!CurDecl)
CurDecl = Decl::castFromDeclContext(DC);
if (Innermost) {
- Result.addOuterTemplateArguments(const_cast<NamedDecl *>(ND), *Innermost,
- Final);
+ Result.addOuterTemplateArguments(ND, *Innermost, Final);
// Populate placeholder template arguments for TemplateTemplateParmDecls.
// This is essential for the case e.g.
//
@@ -497,27 +494,27 @@ MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
while (!CurDecl->isFileContextDecl()) {
Response R;
- if (const auto *VarTemplSpec =
+ if (auto *VarTemplSpec =
dyn_cast<VarTemplateSpecializationDecl>(CurDecl)) {
R = HandleVarTemplateSpec(VarTemplSpec, Result, SkipForSpecialization);
} else if (const auto *PartialClassTemplSpec =
dyn_cast<ClassTemplatePartialSpecializationDecl>(CurDecl)) {
R = HandlePartialClassTemplateSpec(PartialClassTemplSpec, Result,
SkipForSpecialization);
- } else if (const auto *ClassTemplSpec =
+ } else if (auto *ClassTemplSpec =
dyn_cast<ClassTemplateSpecializationDecl>(CurDecl)) {
R = HandleClassTemplateSpec(ClassTemplSpec, Result,
SkipForSpecialization);
- } else if (const auto *Function = dyn_cast<FunctionDecl>(CurDecl)) {
+ } else if (auto *Function = dyn_cast<FunctionDecl>(CurDecl)) {
R = HandleFunction(*this, Function, Result, Pattern, RelativeToPrimary,
ForConstraintInstantiation);
} else if (const auto *Rec = dyn_cast<CXXRecordDecl>(CurDecl)) {
R = HandleRecordDecl(*this, Rec, Result, Context,
ForConstraintInstantiation);
- } else if (const auto *CSD =
+ } else if (auto *CSD =
dyn_cast<ImplicitConceptSpecializationDecl>(CurDecl)) {
R = HandleImplicitConceptSpecializationDecl(CSD, Result);
- } else if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(CurDecl)) {
+ } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(CurDecl)) {
R = HandleFunctionTemplateDecl(FTD, Result);
} else if (const auto *CTD = dyn_cast<ClassTemplateDecl>(CurDecl)) {
R = Response::ChangeDecl(CTD->getLexicalDeclContext());
@@ -3247,7 +3244,7 @@ bool Sema::SubstDefaultArgument(
TemplateArgs.getInnermost());
NewTemplateArgs = getTemplateInstantiationArgs(
FD, FD->getDeclContext(), /*Final=*/false,
- CurrentTemplateArgumentList->asArray(), /*RelativeToPrimary=*/true);
+ CurrentTemplateArgumentList->asMutableArray(), /*RelativeToPrimary=*/true);
}
}
>From 27275d5441cf3b37c6a033bd26093c020906656e Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sat, 17 Aug 2024 17:03:34 +0300
Subject: [PATCH 03/13] Step 3
---
clang/include/clang/AST/ExprConcepts.h | 5 ++++-
clang/include/clang/Sema/Sema.h | 2 +-
clang/lib/Sema/SemaConcept.cpp | 4 ++--
clang/lib/Sema/SemaTemplateDeduction.cpp | 2 +-
4 files changed, 8 insertions(+), 5 deletions(-)
diff --git a/clang/include/clang/AST/ExprConcepts.h b/clang/include/clang/AST/ExprConcepts.h
index 29913fd84c58b4..76ab0bbbccd46f 100644
--- a/clang/include/clang/AST/ExprConcepts.h
+++ b/clang/include/clang/AST/ExprConcepts.h
@@ -78,9 +78,12 @@ class ConceptSpecializationExpr final : public Expr {
const ConstraintSatisfaction *Satisfaction, bool Dependent,
bool ContainsUnexpandedParameterPack);
- ArrayRef<TemplateArgument> getTemplateArguments() const {
+ MutableArrayRef<TemplateArgument> getTemplateArguments() {
return SpecDecl->getTemplateArguments();
}
+ ArrayRef<TemplateArgument> getTemplateArguments() const {
+ return const_cast<ConceptSpecializationExpr *>(this)->getTemplateArguments();
+ }
ConceptReference *getConceptReference() const { return ConceptRef; }
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 3dd6bd31c4e469..1a54209e51c023 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -13073,7 +13073,7 @@ class Sema final : public SemaBase {
/// arguments on an enclosing class template.
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(
const NamedDecl *D, const DeclContext *DC = nullptr, bool Final = false,
- std::optional<ArrayRef<TemplateArgument>> Innermost = std::nullopt,
+ std::optional<MutableArrayRef<TemplateArgument>> Innermost = std::nullopt,
bool RelativeToPrimary = false, const FunctionDecl *Pattern = nullptr,
bool ForConstraintInstantiation = false,
bool SkipForSpecialization = false);
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index b051b5f2b9ae1d..8f76691356cb70 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -1485,7 +1485,7 @@ substituteParameterMappings(Sema &S, NormalizedConstraint &N,
}
static bool substituteParameterMappings(Sema &S, NormalizedConstraint &N,
- const ConceptSpecializationExpr *CSE) {
+ ConceptSpecializationExpr *CSE) {
MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
CSE->getNamedConcept(), CSE->getNamedConcept()->getLexicalDeclContext(),
/*Final=*/false, CSE->getTemplateArguments(),
@@ -1575,7 +1575,7 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, NamedDecl *D, const Expr *E) {
return NormalizedConstraint(S.Context, std::move(*LHS), std::move(*RHS),
BO.isAnd() ? CCK_Conjunction : CCK_Disjunction);
- } else if (auto *CSE = dyn_cast<const ConceptSpecializationExpr>(E)) {
+ } else if (auto *CSE = dyn_cast<ConceptSpecializationExpr>(const_cast<Expr *>(E))) {
const NormalizedConstraint *SubNF;
{
Sema::InstantiatingTemplate Inst(
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index 6807a4162c2c2f..ef3b04c7ff4b09 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -3075,7 +3075,7 @@ CheckDeducedArgumentConstraints(Sema &S, TemplateDeclT *Template,
llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
Template->getAssociatedConstraints(AssociatedConstraints);
- std::optional<ArrayRef<TemplateArgument>> Innermost;
+ std::optional<MutableArrayRef<TemplateArgument>> Innermost;
// If we don't need to replace the deduced template arguments,
// we can add them immediately as the inner-most argument list.
if (!DeducedArgsNeedReplacement(Template))
>From 08bf81f6900ca8f47452090ebe183efd222fcafc Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sat, 17 Aug 2024 17:35:29 +0300
Subject: [PATCH 04/13] Step 4
---
clang/include/clang/AST/NestedNameSpecifier.h | 7 +++-
clang/include/clang/AST/Type.h | 7 +++-
clang/include/clang/Sema/Sema.h | 37 ++++++++++---------
clang/lib/Sema/SemaConcept.cpp | 12 +++---
clang/lib/Sema/SemaTemplateDeduction.cpp | 2 +-
clang/lib/Sema/SemaTemplateInstantiate.cpp | 36 +++++++++---------
.../lib/Sema/SemaTemplateInstantiateDecl.cpp | 2 +-
7 files changed, 56 insertions(+), 47 deletions(-)
diff --git a/clang/include/clang/AST/NestedNameSpecifier.h b/clang/include/clang/AST/NestedNameSpecifier.h
index a1d9e30e660d14..7a8611947c30cf 100644
--- a/clang/include/clang/AST/NestedNameSpecifier.h
+++ b/clang/include/clang/AST/NestedNameSpecifier.h
@@ -193,13 +193,16 @@ class NestedNameSpecifier : public llvm::FoldingSetNode {
CXXRecordDecl *getAsRecordDecl() const;
/// Retrieve the type stored in this nested name specifier.
- const Type *getAsType() const {
+ Type *getAsType() {
if (Prefix.getInt() == StoredTypeSpec ||
Prefix.getInt() == StoredTypeSpecWithTemplate)
- return (const Type *)Specifier;
+ return static_cast<Type *>(Specifier);
return nullptr;
}
+ const Type *getAsType() const {
+ return const_cast<NestedNameSpecifier *>(this)->getAsType();
+ }
NestedNameSpecifierDependence getDependence() const;
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index 27618604192c51..bacbdabf0e0242 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -6545,10 +6545,13 @@ class TemplateSpecializationType : public Type, public llvm::FoldingSetNode {
/// Retrieve the name of the template that we are specializing.
TemplateName getTemplateName() const { return Template; }
- ArrayRef<TemplateArgument> template_arguments() const {
- return {reinterpret_cast<const TemplateArgument *>(this + 1),
+ MutableArrayRef<TemplateArgument> template_arguments() {
+ return {reinterpret_cast<TemplateArgument *>(this + 1),
TemplateSpecializationTypeBits.NumArgs};
}
+ ArrayRef<TemplateArgument> template_arguments() const {
+ return const_cast<TemplateSpecializationType *>(this)->template_arguments();
+ }
bool isSugared() const {
return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 1a54209e51c023..8a3d6a406bc1a9 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -12800,7 +12800,7 @@ class Sema final : public SemaBase {
union {
/// The list of template arguments we are substituting, if they
/// are not part of the entity.
- const TemplateArgument *TemplateArgs;
+ TemplateArgument *TemplateArgs;
/// The list of argument expressions in a synthesized call.
const Expr *const *CallArgs;
@@ -12819,10 +12819,13 @@ class Sema final : public SemaBase {
CXXSpecialMemberKind SpecialMember;
};
- ArrayRef<TemplateArgument> template_arguments() const {
+ MutableArrayRef<TemplateArgument> template_arguments() {
assert(Kind != DeclaringSpecialMember);
return {TemplateArgs, NumTemplateArgs};
}
+ ArrayRef<TemplateArgument> template_arguments() const {
+ return const_cast<CodeSynthesisContext *>(this)->template_arguments();
+ }
/// The template deduction info object associated with the
/// substitution or checking of explicit or deduced template arguments.
@@ -12873,21 +12876,21 @@ class Sema final : public SemaBase {
/// Note that we are instantiating a type alias template declaration.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
TypeAliasTemplateDecl *Entity,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
SourceRange InstantiationRange = SourceRange());
/// Note that we are instantiating a default argument in a
/// template-id.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
TemplateParameter Param, TemplateDecl *Template,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
SourceRange InstantiationRange = SourceRange());
/// Note that we are substituting either explicitly-specified or
/// deduced template arguments during function template argument deduction.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
FunctionTemplateDecl *FunctionTemplate,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
CodeSynthesisContext::SynthesisKind Kind,
sema::TemplateDeductionInfo &DeductionInfo,
SourceRange InstantiationRange = SourceRange());
@@ -12896,7 +12899,7 @@ class Sema final : public SemaBase {
/// argument deduction for a class template declaration.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
TemplateDecl *Template,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
sema::TemplateDeductionInfo &DeductionInfo,
SourceRange InstantiationRange = SourceRange());
@@ -12905,7 +12908,7 @@ class Sema final : public SemaBase {
/// specialization.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
ClassTemplatePartialSpecializationDecl *PartialSpec,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
sema::TemplateDeductionInfo &DeductionInfo,
SourceRange InstantiationRange = SourceRange());
@@ -12914,7 +12917,7 @@ class Sema final : public SemaBase {
/// specialization.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
VarTemplatePartialSpecializationDecl *PartialSpec,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
sema::TemplateDeductionInfo &DeductionInfo,
SourceRange InstantiationRange = SourceRange());
@@ -12922,28 +12925,28 @@ class Sema final : public SemaBase {
/// parameter.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
ParmVarDecl *Param,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
SourceRange InstantiationRange = SourceRange());
/// Note that we are substituting prior template arguments into a
/// non-type parameter.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
NamedDecl *Template, NonTypeTemplateParmDecl *Param,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
SourceRange InstantiationRange);
/// Note that we are substituting prior template arguments into a
/// template template parameter.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
NamedDecl *Template, TemplateTemplateParmDecl *Param,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
SourceRange InstantiationRange);
/// Note that we are checking the default template argument
/// against the template parameter for a given template-id.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
TemplateDecl *Template, NamedDecl *Param,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
SourceRange InstantiationRange);
struct ConstraintsCheck {};
@@ -12952,7 +12955,7 @@ class Sema final : public SemaBase {
/// constraints).
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
ConstraintsCheck, NamedDecl *Template,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
SourceRange InstantiationRange);
struct ConstraintSubstitution {};
@@ -13026,7 +13029,7 @@ class Sema final : public SemaBase {
Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,
SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
Decl *Entity, NamedDecl *Template = nullptr,
- ArrayRef<TemplateArgument> TemplateArgs = std::nullopt,
+ MutableArrayRef<TemplateArgument> TemplateArgs = std::nullopt,
sema::TemplateDeductionInfo *DeductionInfo = nullptr);
InstantiatingTemplate(const InstantiatingTemplate &) = delete;
@@ -14458,7 +14461,7 @@ class Sema final : public SemaBase {
bool CheckInstantiatedFunctionTemplateConstraints(
SourceLocation PointOfInstantiation, FunctionDecl *Decl,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
ConstraintSatisfaction &Satisfaction);
/// \brief Emit diagnostics explaining why a constraint expression was deemed
@@ -14526,7 +14529,7 @@ class Sema final : public SemaBase {
/// function.
bool
SetupConstraintScope(FunctionDecl *FD,
- std::optional<ArrayRef<TemplateArgument>> TemplateArgs,
+ std::optional<MutableArrayRef<TemplateArgument>> TemplateArgs,
const MultiLevelTemplateArgumentList &MLTAL,
LocalInstantiationScope &Scope);
@@ -14535,7 +14538,7 @@ class Sema final : public SemaBase {
/// LocalInstantiationScope to have the proper set of ParVarDecls configured.
std::optional<MultiLevelTemplateArgumentList>
SetupConstraintCheckingTemplateArgumentsAndScope(
- FunctionDecl *FD, std::optional<ArrayRef<TemplateArgument>> TemplateArgs,
+ FunctionDecl *FD, std::optional<MutableArrayRef<TemplateArgument>> TemplateArgs,
LocalInstantiationScope &Scope);
///@}
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index 8f76691356cb70..48319354ca2b9f 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -583,7 +583,7 @@ static bool CheckConstraintSatisfaction(
return false;
}
- ArrayRef<TemplateArgument> TemplateArgs =
+ MutableArrayRef<TemplateArgument> TemplateArgs =
TemplateArgsLists.getNumSubstitutedLevels() > 0
? TemplateArgsLists.getOutermost()
: MutableArrayRef<TemplateArgument> {};
@@ -750,7 +750,7 @@ bool Sema::addInstantiatedCapturesToScope(
}
bool Sema::SetupConstraintScope(
- FunctionDecl *FD, std::optional<ArrayRef<TemplateArgument>> TemplateArgs,
+ FunctionDecl *FD, std::optional<MutableArrayRef<TemplateArgument>> TemplateArgs,
const MultiLevelTemplateArgumentList &MLTAL,
LocalInstantiationScope &Scope) {
if (FD->isTemplateInstantiation() && FD->getPrimaryTemplate()) {
@@ -758,7 +758,7 @@ bool Sema::SetupConstraintScope(
InstantiatingTemplate Inst(
*this, FD->getPointOfInstantiation(),
Sema::InstantiatingTemplate::ConstraintsCheck{}, PrimaryTemplate,
- TemplateArgs ? *TemplateArgs : ArrayRef<TemplateArgument>{},
+ TemplateArgs ? *TemplateArgs : MutableArrayRef<TemplateArgument>{},
SourceRange());
if (Inst.isInvalid())
return true;
@@ -804,7 +804,7 @@ bool Sema::SetupConstraintScope(
InstantiatingTemplate Inst(
*this, FD->getPointOfInstantiation(),
Sema::InstantiatingTemplate::ConstraintsCheck{}, InstantiatedFrom,
- TemplateArgs ? *TemplateArgs : ArrayRef<TemplateArgument>{},
+ TemplateArgs ? *TemplateArgs : MutableArrayRef<TemplateArgument>{},
SourceRange());
if (Inst.isInvalid())
return true;
@@ -822,7 +822,7 @@ bool Sema::SetupConstraintScope(
// constraint-instantiation and checking.
std::optional<MultiLevelTemplateArgumentList>
Sema::SetupConstraintCheckingTemplateArgumentsAndScope(
- FunctionDecl *FD, std::optional<ArrayRef<TemplateArgument>> TemplateArgs,
+ FunctionDecl *FD, std::optional<MutableArrayRef<TemplateArgument>> TemplateArgs,
LocalInstantiationScope &Scope) {
MultiLevelTemplateArgumentList MLTAL;
@@ -1081,7 +1081,7 @@ bool Sema::EnsureTemplateArgumentListConstraints(
bool Sema::CheckInstantiatedFunctionTemplateConstraints(
SourceLocation PointOfInstantiation, FunctionDecl *Decl,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
ConstraintSatisfaction &Satisfaction) {
// In most cases we're not going to have constraints, so check for that first.
FunctionTemplateDecl *Template = Decl->getPrimaryTemplate();
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index ef3b04c7ff4b09..e7cacedb079793 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -3766,7 +3766,7 @@ static TemplateDeductionResult instantiateExplicitSpecifierDeferred(
Sema &S, FunctionDecl *Specialization,
const MultiLevelTemplateArgumentList &SubstArgs,
TemplateDeductionInfo &Info, FunctionTemplateDecl *FunctionTemplate,
- ArrayRef<TemplateArgument> DeducedArgs) {
+ MutableArrayRef<TemplateArgument> DeducedArgs) {
auto GetExplicitSpecifier = [](FunctionDecl *D) {
return isa<CXXConstructorDecl>(D)
? cast<CXXConstructorDecl>(D)->getExplicitSpecifier()
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 92a2d2d1c983c1..61c4891f4abcf1 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -106,7 +106,7 @@ getPrimaryTemplateOfGenericLambda(const FunctionDecl *LambdaCallOperator) {
struct EnclosingTypeAliasTemplateDetails {
TypeAliasTemplateDecl *Template = nullptr;
TypeAliasTemplateDecl *PrimaryTypeAliasDecl = nullptr;
- ArrayRef<TemplateArgument> AssociatedTemplateArguments;
+ MutableArrayRef<TemplateArgument> AssociatedTemplateArguments;
explicit operator bool() noexcept { return Template; }
};
@@ -341,7 +341,7 @@ Response HandleFunctionTemplateDecl(FunctionTemplateDecl *FTD,
while (Type *Ty = NNS ? NNS->getAsType() : nullptr) {
if (NNS->isInstantiationDependent()) {
- if (auto *TSTy = Ty->getAs<TemplateSpecializationType>()) {
+ if (auto *TSTy = const_cast<TemplateSpecializationType *>(Ty->getAs<TemplateSpecializationType>())) {
MutableArrayRef<TemplateArgument> Arguments = TSTy->template_arguments();
// Prefer template arguments from the injected-class-type if possible.
// For example,
@@ -472,13 +472,13 @@ MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
MultiLevelTemplateArgumentList Result;
using namespace TemplateInstArgsHelpers;
- Decl *CurDecl = ND;
+ Decl *CurDecl = const_cast<NamedDecl *>(ND);
if (!CurDecl)
CurDecl = Decl::castFromDeclContext(DC);
if (Innermost) {
- Result.addOuterTemplateArguments(ND, *Innermost, Final);
+ Result.addOuterTemplateArguments(const_cast<NamedDecl *>(ND), *Innermost, Final);
// Populate placeholder template arguments for TemplateTemplateParmDecls.
// This is essential for the case e.g.
//
@@ -489,7 +489,7 @@ MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
// has a depth of 0.
if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl))
HandleDefaultTempArgIntoTempTempParam(TTP, Result);
- CurDecl = Response::UseNextDecl(CurDecl).NextDecl;
+ CurDecl = const_cast<Decl *>(Response::UseNextDecl(CurDecl).NextDecl);
}
while (!CurDecl->isFileContextDecl()) {
@@ -532,7 +532,7 @@ MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
if (R.ClearRelativeToPrimary)
RelativeToPrimary = false;
assert(R.NextDecl);
- CurDecl = R.NextDecl;
+ CurDecl = const_cast<Decl *>(R.NextDecl);
}
return Result;
@@ -581,7 +581,7 @@ bool Sema::CodeSynthesisContext::isInstantiationRecord() const {
Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,
SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
- Decl *Entity, NamedDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
+ Decl *Entity, NamedDecl *Template, MutableArrayRef<TemplateArgument> TemplateArgs,
sema::TemplateDeductionInfo *DeductionInfo)
: SemaRef(SemaRef) {
// Don't allow further instantiation if a fatal error and an uncompilable
@@ -629,7 +629,7 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateParameter Param,
- TemplateDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
+ TemplateDecl *Template, MutableArrayRef<TemplateArgument> TemplateArgs,
SourceRange InstantiationRange)
: InstantiatingTemplate(
SemaRef,
@@ -640,7 +640,7 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema &SemaRef, SourceLocation PointOfInstantiation,
FunctionTemplateDecl *FunctionTemplate,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
CodeSynthesisContext::SynthesisKind Kind,
sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
: InstantiatingTemplate(SemaRef, Kind, PointOfInstantiation,
@@ -654,7 +654,7 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema &SemaRef, SourceLocation PointOfInstantiation,
TemplateDecl *Template,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
: InstantiatingTemplate(
SemaRef,
@@ -665,7 +665,7 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema &SemaRef, SourceLocation PointOfInstantiation,
ClassTemplatePartialSpecializationDecl *PartialSpec,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
: InstantiatingTemplate(
SemaRef,
@@ -676,7 +676,7 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema &SemaRef, SourceLocation PointOfInstantiation,
VarTemplatePartialSpecializationDecl *PartialSpec,
- ArrayRef<TemplateArgument> TemplateArgs,
+ MutableArrayRef<TemplateArgument> TemplateArgs,
sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
: InstantiatingTemplate(
SemaRef,
@@ -686,7 +686,7 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema &SemaRef, SourceLocation PointOfInstantiation, ParmVarDecl *Param,
- ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
+ MutableArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
: InstantiatingTemplate(
SemaRef,
CodeSynthesisContext::DefaultFunctionArgumentInstantiation,
@@ -695,7 +695,7 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
- NonTypeTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
+ NonTypeTemplateParmDecl *Param, MutableArrayRef<TemplateArgument> TemplateArgs,
SourceRange InstantiationRange)
: InstantiatingTemplate(
SemaRef,
@@ -705,7 +705,7 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
- TemplateTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
+ TemplateTemplateParmDecl *Param, MutableArrayRef<TemplateArgument> TemplateArgs,
SourceRange InstantiationRange)
: InstantiatingTemplate(
SemaRef,
@@ -715,7 +715,7 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema &SemaRef, SourceLocation PointOfInstantiation,
- TypeAliasTemplateDecl *Entity, ArrayRef<TemplateArgument> TemplateArgs,
+ TypeAliasTemplateDecl *Entity, MutableArrayRef<TemplateArgument> TemplateArgs,
SourceRange InstantiationRange)
: InstantiatingTemplate(
SemaRef, CodeSynthesisContext::TypeAliasTemplateInstantiation,
@@ -724,7 +724,7 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateDecl *Template,
- NamedDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
+ NamedDecl *Param, MutableArrayRef<TemplateArgument> TemplateArgs,
SourceRange InstantiationRange)
: InstantiatingTemplate(
SemaRef, CodeSynthesisContext::DefaultTemplateArgumentChecking,
@@ -762,7 +762,7 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema &SemaRef, SourceLocation PointOfInstantiation,
ConstraintsCheck, NamedDecl *Template,
- ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
+ MutableArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
: InstantiatingTemplate(
SemaRef, CodeSynthesisContext::ConstraintsCheck,
PointOfInstantiation, InstantiationRange, Template, nullptr,
diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
index 47ba9f2a07e69c..7234b50187b784 100644
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -4906,7 +4906,7 @@ FunctionDecl *Sema::InstantiateFunctionDeclaration(
FunctionDecl *FD = FTD->getTemplatedDecl();
sema::TemplateDeductionInfo Info(Loc);
- InstantiatingTemplate Inst(*this, Loc, FTD, Args->asArray(), CSC, Info);
+ InstantiatingTemplate Inst(*this, Loc, FTD, Args->asMutableArray(), CSC, Info);
if (Inst.isInvalid())
return nullptr;
>From 838f2fb86069d335a1a6c082d2e2953e1e8f48cc Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sat, 17 Aug 2024 18:09:48 +0300
Subject: [PATCH 05/13] Step 5
---
clang/include/clang/AST/Type.h | 4 ++++
clang/lib/AST/Type.cpp | 4 ++++
clang/lib/Sema/SemaTemplateInstantiate.cpp | 2 +-
3 files changed, 9 insertions(+), 1 deletion(-)
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index bacbdabf0e0242..6f2bdeebc81315 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -2813,6 +2813,9 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
/// There are some specializations of this member template listed
/// immediately following this class.
template <typename T> const T *getAs() const;
+ template <typename T> T *getAs() {
+ return const_cast<T *>(const_cast<const Type *>(this)->getAs<T>());
+ }
/// Member-template getAsAdjusted<specific type>. Look through specific kinds
/// of sugar (parens, attributes, etc) for an instance of \<specific type>.
@@ -2993,6 +2996,7 @@ template <> const UsingType *Type::getAs() const;
/// existing sugar until it reaches a TemplateSpecializationType or a
/// non-sugared type.
template <> const TemplateSpecializationType *Type::getAs() const;
+template <> TemplateSpecializationType *Type::getAs();
/// This will check for an AttributedType by removing any existing sugar
/// until it reaches an AttributedType or a non-sugared type.
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index e89ce2e4b38445..6d0a283b05a0bc 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -587,6 +587,10 @@ template <> const TemplateSpecializationType *Type::getAs() const {
return getAsSugar<TemplateSpecializationType>(this);
}
+template <> TemplateSpecializationType *Type::getAs() {
+ return const_cast<TemplateSpecializationType *>(getAsSugar<TemplateSpecializationType>(this));
+}
+
template <> const AttributedType *Type::getAs() const {
return getAsSugar<AttributedType>(this);
}
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 61c4891f4abcf1..73b33a6500e70f 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -341,7 +341,7 @@ Response HandleFunctionTemplateDecl(FunctionTemplateDecl *FTD,
while (Type *Ty = NNS ? NNS->getAsType() : nullptr) {
if (NNS->isInstantiationDependent()) {
- if (auto *TSTy = const_cast<TemplateSpecializationType *>(Ty->getAs<TemplateSpecializationType>())) {
+ if (auto *TSTy = Ty->getAs<TemplateSpecializationType>()) {
MutableArrayRef<TemplateArgument> Arguments = TSTy->template_arguments();
// Prefer template arguments from the injected-class-type if possible.
// For example,
>From b3d2126bb986ab47c7603adbceda20deea95c7a8 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sat, 17 Aug 2024 18:54:47 +0300
Subject: [PATCH 06/13] Step 6
---
clang/include/clang/Sema/Sema.h | 4 ++--
clang/lib/Sema/SemaConcept.cpp | 4 ++--
clang/lib/Sema/SemaTemplateInstantiate.cpp | 6 +++---
3 files changed, 7 insertions(+), 7 deletions(-)
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 8a3d6a406bc1a9..a6e79d22759ad0 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -13075,7 +13075,7 @@ class Sema final : public SemaBase {
/// encountering a lambda generic call operator, and continue looking for
/// arguments on an enclosing class template.
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(
- const NamedDecl *D, const DeclContext *DC = nullptr, bool Final = false,
+ NamedDecl *D, const DeclContext *DC = nullptr, bool Final = false,
std::optional<MutableArrayRef<TemplateArgument>> Innermost = std::nullopt,
bool RelativeToPrimary = false, const FunctionDecl *Pattern = nullptr,
bool ForConstraintInstantiation = false,
@@ -14439,7 +14439,7 @@ class Sema final : public SemaBase {
// Calculates whether the friend function depends on an enclosing template for
// the purposes of [temp.friend] p9.
- bool FriendConstraintsDependOnEnclosingTemplate(const FunctionDecl *FD);
+ bool FriendConstraintsDependOnEnclosingTemplate(FunctionDecl *FD);
/// \brief Ensure that the given template arguments satisfy the constraints
/// associated with the given template, emitting a diagnostic if they do not.
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index 48319354ca2b9f..f53ee433ab0b5b 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -910,7 +910,7 @@ bool Sema::CheckFunctionConstraints(const FunctionDecl *FD,
// 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,
+CalculateTemplateDepthForConstraints(Sema &S, NamedDecl *ND,
bool SkipForSpecialization = false) {
MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
ND, ND->getLexicalDeclContext(), /*Final=*/false,
@@ -1031,7 +1031,7 @@ bool Sema::AreConstraintExpressionsEqual(const NamedDecl *Old,
return ID1 == ID2;
}
-bool Sema::FriendConstraintsDependOnEnclosingTemplate(const FunctionDecl *FD) {
+bool Sema::FriendConstraintsDependOnEnclosingTemplate(FunctionDecl *FD) {
assert(FD->getFriendObjectKind() && "Must be a friend!");
// The logic for non-templates is handled in ASTContext::isSameEntity, so we
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 73b33a6500e70f..b86f29ab08ccff 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -463,7 +463,7 @@ Response HandleGenericDeclContext(const Decl *CurDecl) {
} // namespace
MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
- const NamedDecl *ND, const DeclContext *DC, bool Final,
+ NamedDecl *ND, const DeclContext *DC, bool Final,
std::optional<MutableArrayRef<TemplateArgument>> Innermost, bool RelativeToPrimary,
const FunctionDecl *Pattern, bool ForConstraintInstantiation,
bool SkipForSpecialization) {
@@ -472,13 +472,13 @@ MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
MultiLevelTemplateArgumentList Result;
using namespace TemplateInstArgsHelpers;
- Decl *CurDecl = const_cast<NamedDecl *>(ND);
+ Decl *CurDecl = ND;
if (!CurDecl)
CurDecl = Decl::castFromDeclContext(DC);
if (Innermost) {
- Result.addOuterTemplateArguments(const_cast<NamedDecl *>(ND), *Innermost, Final);
+ Result.addOuterTemplateArguments(ND, *Innermost, Final);
// Populate placeholder template arguments for TemplateTemplateParmDecls.
// This is essential for the case e.g.
//
>From 4445cf2b9da181b17aaf1faf4e19fe88e39b149a Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sat, 17 Aug 2024 20:02:47 +0300
Subject: [PATCH 07/13] Step 7
---
clang/include/clang/Sema/Sema.h | 13 ++++++++-----
clang/lib/Sema/SemaConcept.cpp | 4 ++--
clang/lib/Sema/SemaTemplate.cpp | 4 ++--
3 files changed, 12 insertions(+), 9 deletions(-)
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index a6e79d22759ad0..964d400ca9749d 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -11837,13 +11837,13 @@ class Sema final : public SemaBase {
// the named decl, or the important information we need about it in order to
// do constraint comparisons.
class TemplateCompareNewDeclInfo {
- const NamedDecl *ND = nullptr;
+ NamedDecl *ND = nullptr;
const DeclContext *DC = nullptr;
const DeclContext *LexicalDC = nullptr;
SourceLocation Loc;
public:
- TemplateCompareNewDeclInfo(const NamedDecl *ND) : ND(ND) {}
+ TemplateCompareNewDeclInfo(NamedDecl *ND) : ND(ND) {}
TemplateCompareNewDeclInfo(const DeclContext *DeclCtx,
const DeclContext *LexicalDeclCtx,
SourceLocation Loc)
@@ -11858,7 +11858,10 @@ class Sema final : public SemaBase {
// for constraint comparison, so make sure we can check that.
bool isInvalid() const { return !ND && !DC; }
- const NamedDecl *getDecl() const { return ND; }
+ NamedDecl *getDecl() { return ND; }
+ const NamedDecl *getDecl() const {
+ return const_cast<TemplateCompareNewDeclInfo *>(this)->getDecl();
+ }
bool ContainsDecl(const NamedDecl *ND) const { return this->ND == ND; }
@@ -11898,7 +11901,7 @@ class Sema final : public SemaBase {
/// otherwise.
bool TemplateParameterListsAreEqual(
const TemplateCompareNewDeclInfo &NewInstFrom, TemplateParameterList *New,
- const NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain,
+ NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain,
TemplateParameterListEqualKind Kind,
SourceLocation TemplateArgLoc = SourceLocation());
@@ -14432,7 +14435,7 @@ class Sema final : public SemaBase {
// for figuring out the relative 'depth' of the constraint. The depth of the
// 'primary template' and the 'instantiated from' templates aren't necessarily
// the same, such as a case when one is a 'friend' defined in a class.
- bool AreConstraintExpressionsEqual(const NamedDecl *Old,
+ bool AreConstraintExpressionsEqual(NamedDecl *Old,
const Expr *OldConstr,
const TemplateCompareNewDeclInfo &New,
const Expr *NewConstr);
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index f53ee433ab0b5b..9ccda9e4528e28 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -950,7 +950,7 @@ namespace {
} // namespace
static const Expr *SubstituteConstraintExpressionWithoutSatisfaction(
- Sema &S, const Sema::TemplateCompareNewDeclInfo &DeclInfo,
+ Sema &S, Sema::TemplateCompareNewDeclInfo DeclInfo,
const Expr *ConstrExpr) {
MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
DeclInfo.getDecl(), DeclInfo.getLexicalDeclContext(), /*Final=*/false,
@@ -1002,7 +1002,7 @@ static const Expr *SubstituteConstraintExpressionWithoutSatisfaction(
return SubstConstr.get();
}
-bool Sema::AreConstraintExpressionsEqual(const NamedDecl *Old,
+bool Sema::AreConstraintExpressionsEqual(NamedDecl *Old,
const Expr *OldConstr,
const TemplateCompareNewDeclInfo &New,
const Expr *NewConstr) {
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 9005fbcea6536f..467f2b92fcacb7 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -7514,7 +7514,7 @@ Sema::BuildExpressionFromNonTypeTemplateArgument(const TemplateArgument &Arg,
static bool MatchTemplateParameterKind(
Sema &S, NamedDecl *New,
const Sema::TemplateCompareNewDeclInfo &NewInstFrom, NamedDecl *Old,
- const NamedDecl *OldInstFrom, bool Complain,
+ NamedDecl *OldInstFrom, bool Complain,
Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc) {
// Check the actual kind (type, non-type, template).
if (Old->getKind() != New->getKind()) {
@@ -7684,7 +7684,7 @@ void DiagnoseTemplateParameterListArityMismatch(Sema &S,
bool Sema::TemplateParameterListsAreEqual(
const TemplateCompareNewDeclInfo &NewInstFrom, TemplateParameterList *New,
- const NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain,
+ NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain,
TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc) {
if (Old->size() != New->size() && Kind != TPL_TemplateTemplateArgumentMatch) {
if (Complain)
>From e0933e7a14652810c12d9929cb837684bd5124f9 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sat, 17 Aug 2024 20:51:08 +0300
Subject: [PATCH 08/13] Step 8
---
clang/include/clang/AST/Decl.h | 2 +-
clang/include/clang/AST/DeclTemplate.h | 8 ++---
clang/include/clang/Sema/Sema.h | 12 +++----
clang/include/clang/Sema/SemaConcept.h | 10 +++---
clang/lib/AST/DeclTemplate.cpp | 8 ++---
clang/lib/Sema/SemaCodeComplete.cpp | 10 +++---
clang/lib/Sema/SemaConcept.cpp | 44 ++++++++++++++----------
clang/lib/Sema/SemaDecl.cpp | 4 +--
clang/lib/Sema/SemaOverload.cpp | 4 +--
clang/lib/Sema/SemaTemplate.cpp | 4 +--
clang/lib/Sema/SemaTemplateDeduction.cpp | 8 ++---
11 files changed, 60 insertions(+), 54 deletions(-)
diff --git a/clang/include/clang/AST/Decl.h b/clang/include/clang/AST/Decl.h
index f79d62f225d9ec..7bff07aeb44947 100644
--- a/clang/include/clang/AST/Decl.h
+++ b/clang/include/clang/AST/Decl.h
@@ -2621,7 +2621,7 @@ class FunctionDecl : public DeclaratorDecl,
///
/// Use this instead of getTrailingRequiresClause for concepts APIs that
/// accept an ArrayRef of constraint expressions.
- void getAssociatedConstraints(SmallVectorImpl<const Expr *> &AC) const {
+ void getAssociatedConstraints(SmallVectorImpl<Expr *> &AC) {
if (auto *TRC = getTrailingRequiresClause())
AC.push_back(TRC);
}
diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h
index adf3ec56b9bac8..2ec49427e30bed 100644
--- a/clang/include/clang/AST/DeclTemplate.h
+++ b/clang/include/clang/AST/DeclTemplate.h
@@ -192,7 +192,7 @@ class TemplateParameterList final
///
/// The constraints in the resulting list are to be treated as if in a
/// conjunction ("and").
- void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const;
+ void getAssociatedConstraints(llvm::SmallVectorImpl<Expr *> &AC);
bool hasAssociatedConstraints() const;
@@ -428,7 +428,7 @@ class TemplateDecl : public NamedDecl {
/// including constraint-expressions derived from the requires-clause,
/// trailing requires-clause (for functions and methods) and constrained
/// template parameters.
- void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const;
+ void getAssociatedConstraints(llvm::SmallVectorImpl<Expr *> &AC);
bool hasAssociatedConstraints() const;
@@ -2143,7 +2143,7 @@ class ClassTemplatePartialSpecializationDecl
///
/// The constraints in the resulting list are to be treated as if in a
/// conjunction ("and").
- void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
+ void getAssociatedConstraints(llvm::SmallVectorImpl<Expr *> &AC) {
TemplateParams->getAssociatedConstraints(AC);
}
@@ -2915,7 +2915,7 @@ class VarTemplatePartialSpecializationDecl
///
/// The constraints in the resulting list are to be treated as if in a
/// conjunction ("and").
- void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
+ void getAssociatedConstraints(llvm::SmallVectorImpl<Expr *> &AC) {
TemplateParams->getAssociatedConstraints(AC);
}
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 964d400ca9749d..4ce3f766e41d37 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -14352,7 +14352,7 @@ class Sema final : public SemaBase {
/// A diagnostic is emitted if it is not, false is returned, and
/// PossibleNonPrimary will be set to true if the failure might be due to a
/// non-primary expression being used as an atomic constraint.
- bool CheckConstraintExpression(const Expr *CE, Token NextToken = Token(),
+ bool CheckConstraintExpression(Expr *CE, Token NextToken = Token(),
bool *PossibleNonPrimary = nullptr,
bool IsTrailingRequiresClause = false);
@@ -14481,7 +14481,7 @@ class Sema final : public SemaBase {
bool First = true);
const NormalizedConstraint *getNormalizedAssociatedConstraints(
- NamedDecl *ConstrainedDecl, ArrayRef<const Expr *> AssociatedConstraints);
+ NamedDecl *ConstrainedDecl, ArrayRef<Expr *> AssociatedConstraints);
/// \brief Check whether the given declaration's associated constraints are
/// at least as constrained than another declaration's according to the
@@ -14491,8 +14491,8 @@ class Sema final : public SemaBase {
/// at least constrained than D2, and false otherwise.
///
/// \returns true if an error occurred, false otherwise.
- bool IsAtLeastAsConstrained(NamedDecl *D1, MutableArrayRef<const Expr *> AC1,
- NamedDecl *D2, MutableArrayRef<const Expr *> AC2,
+ bool IsAtLeastAsConstrained(NamedDecl *D1, MutableArrayRef<Expr *> AC1,
+ NamedDecl *D2, MutableArrayRef<Expr *> AC2,
bool &Result);
/// If D1 was not at least as constrained as D2, but would've been if a pair
@@ -14500,8 +14500,8 @@ class Sema final : public SemaBase {
/// repeated in two separate places in code.
/// \returns true if such a diagnostic was emitted, false otherwise.
bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(
- NamedDecl *D1, ArrayRef<const Expr *> AC1, NamedDecl *D2,
- ArrayRef<const Expr *> AC2);
+ NamedDecl *D1, ArrayRef<Expr *> AC1, NamedDecl *D2,
+ ArrayRef<Expr *> AC2);
private:
/// Caches pairs of template-like decls whose associated constraints were
diff --git a/clang/include/clang/Sema/SemaConcept.h b/clang/include/clang/Sema/SemaConcept.h
index 4b1abccb7741a1..1079be3236e7e2 100644
--- a/clang/include/clang/Sema/SemaConcept.h
+++ b/clang/include/clang/Sema/SemaConcept.h
@@ -163,9 +163,9 @@ struct NormalizedConstraint {
private:
static std::optional<NormalizedConstraint>
- fromConstraintExprs(Sema &S, NamedDecl *D, ArrayRef<const Expr *> E);
+ fromConstraintExprs(Sema &S, NamedDecl *D, ArrayRef<Expr *> E);
static std::optional<NormalizedConstraint>
- fromConstraintExpr(Sema &S, NamedDecl *D, const Expr *E);
+ fromConstraintExpr(Sema &S, NamedDecl *D, Expr *E);
};
struct alignas(ConstraintAlignment) NormalizedConstraintPair {
@@ -191,7 +191,7 @@ struct alignas(ConstraintAlignment) FoldExpandedConstraint {
const NormalizedConstraint *getNormalizedAssociatedConstraints(
Sema &S, NamedDecl *ConstrainedDecl,
- ArrayRef<const Expr *> AssociatedConstraints);
+ ArrayRef<Expr *> AssociatedConstraints);
template <typename AtomicSubsumptionEvaluator>
bool subsumes(const NormalForm &PDNF, const NormalForm &QCNF,
@@ -237,8 +237,8 @@ bool subsumes(const NormalForm &PDNF, const NormalForm &QCNF,
}
template <typename AtomicSubsumptionEvaluator>
-bool subsumes(Sema &S, NamedDecl *DP, ArrayRef<const Expr *> P, NamedDecl *DQ,
- ArrayRef<const Expr *> Q, bool &Subsumes,
+bool subsumes(Sema &S, NamedDecl *DP, ArrayRef<Expr *> P, NamedDecl *DQ,
+ ArrayRef<Expr *> Q, bool &Subsumes,
const AtomicSubsumptionEvaluator &E) {
// C++ [temp.constr.order] p2
// In order to determine if a constraint P subsumes a constraint Q, P is
diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp
index 2a9f9d6e71645e..67afe600d1ef70 100644
--- a/clang/lib/AST/DeclTemplate.cpp
+++ b/clang/lib/AST/DeclTemplate.cpp
@@ -225,14 +225,14 @@ static bool AdoptTemplateParameterList(TemplateParameterList *Params,
}
void TemplateParameterList::
-getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
+getAssociatedConstraints(llvm::SmallVectorImpl<Expr *> &AC) {
if (HasConstrainedParameters)
for (const NamedDecl *Param : *this) {
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
if (const auto *TC = TTP->getTypeConstraint())
AC.push_back(TC->getImmediatelyDeclaredConstraint());
} else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
- if (const Expr *E = NTTP->getPlaceholderTypeConstraint())
+ if (Expr *E = NTTP->getPlaceholderTypeConstraint())
AC.push_back(E);
}
}
@@ -277,10 +277,10 @@ TemplateDecl::TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L,
void TemplateDecl::anchor() {}
void TemplateDecl::
-getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
+getAssociatedConstraints(llvm::SmallVectorImpl<Expr *> &AC) {
TemplateParams->getAssociatedConstraints(AC);
if (auto *FD = dyn_cast_or_null<FunctionDecl>(getTemplatedDecl()))
- if (const Expr *TRC = FD->getTrailingRequiresClause())
+ if (Expr *TRC = FD->getTrailingRequiresClause())
AC.push_back(TRC);
}
diff --git a/clang/lib/Sema/SemaCodeComplete.cpp b/clang/lib/Sema/SemaCodeComplete.cpp
index 88d4732c7d5c6a..c6c4aaec4ffb51 100644
--- a/clang/lib/Sema/SemaCodeComplete.cpp
+++ b/clang/lib/Sema/SemaCodeComplete.cpp
@@ -5569,19 +5569,19 @@ class ConceptInfo {
// Gets all the type constraint expressions that might apply to the type
// variables associated with DC (as returned by getTemplatedEntity()).
- static SmallVector<const Expr *, 1>
+ static SmallVector<Expr *, 1>
constraintsForTemplatedEntity(DeclContext *DC) {
- SmallVector<const Expr *, 1> Result;
+ SmallVector<Expr *, 1> Result;
if (DC == nullptr)
return Result;
// Primary templates can have constraints.
- if (const auto *TD = cast<Decl>(DC)->getDescribedTemplate())
+ if (auto *TD = cast<Decl>(DC)->getDescribedTemplate())
TD->getAssociatedConstraints(Result);
// Partial specializations may have constraints.
- if (const auto *CTPSD =
+ if (auto *CTPSD =
dyn_cast<ClassTemplatePartialSpecializationDecl>(DC))
CTPSD->getAssociatedConstraints(Result);
- if (const auto *VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl>(DC))
+ if (auto *VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl>(DC))
VTPSD->getAssociatedConstraints(Result);
return Result;
}
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index 9ccda9e4528e28..cbfc5a6e38dbc6 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -38,11 +38,11 @@ namespace {
class LogicalBinOp {
SourceLocation Loc;
OverloadedOperatorKind Op = OO_None;
- const Expr *LHS = nullptr;
- const Expr *RHS = nullptr;
+ Expr *LHS = nullptr;
+ Expr *RHS = nullptr;
public:
- LogicalBinOp(const Expr *E) {
+ LogicalBinOp(Expr *E) {
if (auto *BO = dyn_cast<BinaryOperator>(E)) {
Op = BinaryOperator::getOverloadedOperator(BO->getOpcode());
LHS = BO->getLHS();
@@ -63,8 +63,14 @@ class LogicalBinOp {
bool isOr() const { return Op == OO_PipePipe; }
explicit operator bool() const { return isAnd() || isOr(); }
- const Expr *getLHS() const { return LHS; }
- const Expr *getRHS() const { return RHS; }
+ Expr *getLHS() { return LHS; }
+ const Expr *getLHS() const {
+ return const_cast<LogicalBinOp *>(this)->getLHS();
+ }
+ Expr *getRHS() { return RHS; }
+ const Expr *getRHS() const {
+ return const_cast<LogicalBinOp *>(this)->getRHS();
+ }
OverloadedOperatorKind getOp() const { return Op; }
ExprResult recreateBinOp(Sema &SemaRef, ExprResult LHS) const {
@@ -89,7 +95,7 @@ class LogicalBinOp {
};
}
-bool Sema::CheckConstraintExpression(const Expr *ConstraintExpression,
+bool Sema::CheckConstraintExpression(Expr *ConstraintExpression,
Token NextToken, bool *PossibleNonPrimary,
bool IsTrailingRequiresClause) {
// C++2a [temp.constr.atomic]p1
@@ -180,7 +186,7 @@ struct SatisfactionStackRAII {
template <typename ConstraintEvaluator>
static ExprResult
-calculateConstraintSatisfaction(Sema &S, const Expr *ConstraintExpr,
+calculateConstraintSatisfaction(Sema &S, Expr *ConstraintExpr,
ConstraintSatisfaction &Satisfaction,
const ConstraintEvaluator &Evaluator);
@@ -323,7 +329,7 @@ calculateConstraintSatisfaction(Sema &S, const CXXFoldExpr *FE,
template <typename ConstraintEvaluator>
static ExprResult
-calculateConstraintSatisfaction(Sema &S, const Expr *ConstraintExpr,
+calculateConstraintSatisfaction(Sema &S, Expr *ConstraintExpr,
ConstraintSatisfaction &Satisfaction,
const ConstraintEvaluator &Evaluator) {
ConstraintExpr = ConstraintExpr->IgnoreParenImpCasts();
@@ -1040,7 +1046,7 @@ bool Sema::FriendConstraintsDependOnEnclosingTemplate(FunctionDecl *FD) {
assert(FD->getDescribedFunctionTemplate() &&
"Non-function templates don't need to be checked");
- SmallVector<const Expr *, 3> ACs;
+ SmallVector<Expr *, 3> ACs;
FD->getDescribedFunctionTemplate()->getAssociatedConstraints(ACs);
unsigned OldTemplateDepth = CalculateTemplateDepthForConstraints(*this, FD);
@@ -1056,7 +1062,7 @@ bool Sema::EnsureTemplateArgumentListConstraints(
TemplateDecl *TD, const MultiLevelTemplateArgumentList &TemplateArgsLists,
SourceRange TemplateIDRange) {
ConstraintSatisfaction Satisfaction;
- llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
+ llvm::SmallVector<Expr *, 3> AssociatedConstraints;
TD->getAssociatedConstraints(AssociatedConstraints);
if (CheckConstraintSatisfaction(TD, AssociatedConstraints, TemplateArgsLists,
TemplateIDRange, Satisfaction))
@@ -1087,7 +1093,7 @@ bool Sema::CheckInstantiatedFunctionTemplateConstraints(
FunctionTemplateDecl *Template = Decl->getPrimaryTemplate();
// Note - code synthesis context for the constraints check is created
// inside CheckConstraintsSatisfaction.
- SmallVector<const Expr *, 3> TemplateAC;
+ SmallVector<Expr *, 3> TemplateAC;
Template->getAssociatedConstraints(TemplateAC);
if (TemplateAC.empty()) {
Satisfaction.IsSatisfied = true;
@@ -1380,7 +1386,7 @@ void Sema::DiagnoseUnsatisfiedConstraint(
const NormalizedConstraint *
Sema::getNormalizedAssociatedConstraints(
- NamedDecl *ConstrainedDecl, ArrayRef<const Expr *> AssociatedConstraints) {
+ NamedDecl *ConstrainedDecl, ArrayRef<Expr *> AssociatedConstraints) {
// In case the ConstrainedDecl comes from modules, it is necessary to use
// the canonical decl to avoid different atomic constraints with the 'same'
// declarations.
@@ -1405,7 +1411,7 @@ Sema::getNormalizedAssociatedConstraints(
const NormalizedConstraint *clang::getNormalizedAssociatedConstraints(
Sema &S, NamedDecl *ConstrainedDecl,
- ArrayRef<const Expr *> AssociatedConstraints) {
+ ArrayRef<Expr *> AssociatedConstraints) {
return S.getNormalizedAssociatedConstraints(ConstrainedDecl,
AssociatedConstraints);
}
@@ -1535,7 +1541,7 @@ NormalizedConstraint &NormalizedConstraint::getRHS() const {
std::optional<NormalizedConstraint>
NormalizedConstraint::fromConstraintExprs(Sema &S, NamedDecl *D,
- ArrayRef<const Expr *> E) {
+ ArrayRef<Expr *> E) {
assert(E.size() != 0);
auto Conjunction = fromConstraintExpr(S, D, E[0]);
if (!Conjunction)
@@ -1551,7 +1557,7 @@ NormalizedConstraint::fromConstraintExprs(Sema &S, NamedDecl *D,
}
std::optional<NormalizedConstraint>
-NormalizedConstraint::fromConstraintExpr(Sema &S, NamedDecl *D, const Expr *E) {
+NormalizedConstraint::fromConstraintExpr(Sema &S, NamedDecl *D, Expr *E) {
assert(E != nullptr);
// C++ [temp.constr.normal]p1.1
@@ -1575,7 +1581,7 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, NamedDecl *D, const Expr *E) {
return NormalizedConstraint(S.Context, std::move(*LHS), std::move(*RHS),
BO.isAnd() ? CCK_Conjunction : CCK_Disjunction);
- } else if (auto *CSE = dyn_cast<ConceptSpecializationExpr>(const_cast<Expr *>(E))) {
+ } else if (auto *CSE = dyn_cast<ConceptSpecializationExpr>(E)) {
const NormalizedConstraint *SubNF;
{
Sema::InstantiatingTemplate Inst(
@@ -1735,9 +1741,9 @@ NormalForm clang::makeDNF(const NormalizedConstraint &Normalized) {
}
bool Sema::IsAtLeastAsConstrained(NamedDecl *D1,
- MutableArrayRef<const Expr *> AC1,
+ MutableArrayRef<Expr *> AC1,
NamedDecl *D2,
- MutableArrayRef<const Expr *> AC2,
+ MutableArrayRef<Expr *> AC2,
bool &Result) {
if (const auto *FD1 = dyn_cast<FunctionDecl>(D1)) {
auto IsExpectedEntity = [](const FunctionDecl *FD) {
@@ -1797,7 +1803,7 @@ bool Sema::IsAtLeastAsConstrained(NamedDecl *D1,
}
bool Sema::MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,
- ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2) {
+ ArrayRef<Expr *> AC1, NamedDecl *D2, ArrayRef<Expr *> AC2) {
if (isSFINAEContext())
// No need to work here because our notes would be discarded.
return false;
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 9c15b5fa571a39..527bdaf9dfe834 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -18770,7 +18770,7 @@ static void SetEligibleMethods(Sema &S, CXXRecordDecl *Record,
if (FunctionDecl *MF = OrigMethod->getInstantiatedFromMemberFunction())
OrigMethod = cast<CXXMethodDecl>(MF);
- const Expr *Constraints = OrigMethod->getTrailingRequiresClause();
+ Expr *Constraints = OrigMethod->getTrailingRequiresClause();
bool AnotherMethodIsMoreConstrained = false;
for (size_t j = 0; j < Methods.size(); j++) {
if (i == j || !SatisfactionStatus[j])
@@ -18783,7 +18783,7 @@ static void SetEligibleMethods(Sema &S, CXXRecordDecl *Record,
CSM))
continue;
- const Expr *OtherConstraints = OtherMethod->getTrailingRequiresClause();
+ Expr *OtherConstraints = OtherMethod->getTrailingRequiresClause();
if (!OtherConstraints)
continue;
if (!Constraints) {
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index 52f640eb96b73b..e45abdc45045bb 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -11088,12 +11088,12 @@ MaybeDiagnoseAmbiguousConstraints(Sema &S, ArrayRef<OverloadCandidate> Cands) {
// source-level construct. This behavior is quite confusing and we should try
// to help the user figure out what happened.
- SmallVector<const Expr *, 3> FirstAC, SecondAC;
+ SmallVector<Expr *, 3> FirstAC, SecondAC;
FunctionDecl *FirstCand = nullptr, *SecondCand = nullptr;
for (auto I = Cands.begin(), E = Cands.end(); I != E; ++I) {
if (!I->Function)
continue;
- SmallVector<const Expr *, 3> AC;
+ SmallVector<Expr *, 3> AC;
if (auto *Template = I->Function->getPrimaryTemplate())
Template->getAssociatedConstraints(AC);
else
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 467f2b92fcacb7..9f3dffc031b7e2 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -3864,7 +3864,7 @@ static void checkMoreSpecializedThanPrimary(Sema &S, PartialSpecDecl *Partial) {
}
S.NoteTemplateLocation(*Template);
- SmallVector<const Expr *, 3> PartialAC, TemplateAC;
+ SmallVector<Expr *, 3> PartialAC, TemplateAC;
Template->getAssociatedConstraints(TemplateAC);
Partial->getAssociatedConstraints(PartialAC);
S.MaybeEmitAmbiguousAtomicConstraintsDiagnostic(Partial, PartialAC, Template,
@@ -7167,7 +7167,7 @@ bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
// C++20[temp.func.order]p2
// [...] If both deductions succeed, the partial ordering selects the
// more constrained template (if one exists) as determined below.
- SmallVector<const Expr *, 3> ParamsAC, TemplateAC;
+ SmallVector<Expr *, 3> ParamsAC, TemplateAC;
Params->getAssociatedConstraints(ParamsAC);
// C++2a[temp.arg.template]p3
// [...] In this comparison, if P is unconstrained, the constraints on A
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index e7cacedb079793..7ac62d3e67717a 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -3072,7 +3072,7 @@ CheckDeducedArgumentConstraints(Sema &S, TemplateDeclT *Template,
ArrayRef<TemplateArgument> SugaredDeducedArgs,
MutableArrayRef<TemplateArgument> CanonicalDeducedArgs,
TemplateDeductionInfo &Info) {
- llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
+ llvm::SmallVector<Expr *, 3> AssociatedConstraints;
Template->getAssociatedConstraints(AssociatedConstraints);
std::optional<MutableArrayRef<TemplateArgument>> Innermost;
@@ -5717,7 +5717,7 @@ FunctionTemplateDecl *Sema::getMoreSpecializedTemplate(
!Context.hasSameType(FD1->getReturnType(), FD2->getReturnType()))
return nullptr;
- llvm::SmallVector<const Expr *, 3> AC1, AC2;
+ llvm::SmallVector<Expr *, 3> AC1, AC2;
FT1->getAssociatedConstraints(AC1);
FT2->getAssociatedConstraints(AC2);
bool AtLeastAsConstrained1, AtLeastAsConstrained2;
@@ -5822,7 +5822,7 @@ FunctionDecl *Sema::getMoreConstrainedFunction(FunctionDecl *FD1,
if (FunctionDecl *P = FD2->getTemplateInstantiationPattern(false))
F2 = P;
- llvm::SmallVector<const Expr *, 1> AC1, AC2;
+ llvm::SmallVector<Expr *, 1> AC1, AC2;
F1->getAssociatedConstraints(AC1);
F2->getAssociatedConstraints(AC2);
bool AtLeastAsConstrained1, AtLeastAsConstrained2;
@@ -6057,7 +6057,7 @@ getMoreSpecialized(Sema &S, QualType T1, QualType T2, TemplateLikeDecl *P1,
if (!TemplateArgumentListAreEqual(S.getASTContext())(P1, P2))
return nullptr;
- llvm::SmallVector<const Expr *, 3> AC1, AC2;
+ llvm::SmallVector<Expr *, 3> AC1, AC2;
P1->getAssociatedConstraints(AC1);
P2->getAssociatedConstraints(AC2);
bool AtLeastAsConstrained1, AtLeastAsConstrained2;
>From 849d51fe51e712616f2456203898b6abb573f5a3 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sat, 17 Aug 2024 21:05:03 +0300
Subject: [PATCH 09/13] Step 9
---
clang/include/clang/Sema/Sema.h | 8 ++++----
clang/lib/Sema/SemaConcept.cpp | 16 ++++++++--------
clang/lib/Sema/SemaOverload.cpp | 2 +-
3 files changed, 13 insertions(+), 13 deletions(-)
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 4ce3f766e41d37..4747cfbb77a538 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -14372,7 +14372,7 @@ class Sema final : public SemaBase {
/// \returns true if an error occurred and satisfaction could not be checked,
/// false otherwise.
bool CheckConstraintSatisfaction(
- const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
+ const NamedDecl *Template, ArrayRef<Expr *> ConstraintExprs,
const MultiLevelTemplateArgumentList &TemplateArgLists,
SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction) {
llvm::SmallVector<Expr *, 4> Converted;
@@ -14404,7 +14404,7 @@ class Sema final : public SemaBase {
/// \returns true if an error occurred and satisfaction could not be checked,
/// false otherwise.
bool CheckConstraintSatisfaction(
- const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
+ const NamedDecl *Template, ArrayRef<Expr *> ConstraintExprs,
llvm::SmallVectorImpl<Expr *> &ConvertedConstraints,
const MultiLevelTemplateArgumentList &TemplateArgList,
SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction);
@@ -14415,7 +14415,7 @@ class Sema final : public SemaBase {
/// occurred and satisfaction could not be determined.
///
/// \returns true if an error occurred, false otherwise.
- bool CheckConstraintSatisfaction(const Expr *ConstraintExpr,
+ bool CheckConstraintSatisfaction(Expr *ConstraintExpr,
ConstraintSatisfaction &Satisfaction);
/// Check whether the given function decl's trailing requires clause is
@@ -14424,7 +14424,7 @@ class Sema final : public SemaBase {
/// an error occurred and satisfaction could not be determined.
///
/// \returns true if an error occurred, false otherwise.
- bool CheckFunctionConstraints(const FunctionDecl *FD,
+ bool CheckFunctionConstraints(FunctionDecl *FD,
ConstraintSatisfaction &Satisfaction,
SourceLocation UsageLoc = SourceLocation(),
bool ForOverloadResolution = false);
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index cbfc5a6e38dbc6..19d934b9dd16a4 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -192,8 +192,8 @@ calculateConstraintSatisfaction(Sema &S, Expr *ConstraintExpr,
template <typename ConstraintEvaluator>
static ExprResult
-calculateConstraintSatisfaction(Sema &S, const Expr *LHS,
- OverloadedOperatorKind Op, const Expr *RHS,
+calculateConstraintSatisfaction(Sema &S, Expr *LHS,
+ OverloadedOperatorKind Op, Expr *RHS,
ConstraintSatisfaction &Satisfaction,
const ConstraintEvaluator &Evaluator) {
size_t EffectiveDetailEndIndex = Satisfaction.Details.size();
@@ -439,7 +439,7 @@ DiagRecursiveConstraintEval(Sema &S, llvm::FoldingSetNodeID &ID,
static ExprResult calculateConstraintSatisfaction(
Sema &S, const NamedDecl *Template, SourceLocation TemplateNameLoc,
- const MultiLevelTemplateArgumentList &MLTAL, const Expr *ConstraintExpr,
+ const MultiLevelTemplateArgumentList &MLTAL, Expr *ConstraintExpr,
ConstraintSatisfaction &Satisfaction) {
struct ConstraintEvaluator {
@@ -574,7 +574,7 @@ static ExprResult calculateConstraintSatisfaction(
}
static bool CheckConstraintSatisfaction(
- Sema &S, const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
+ Sema &S, const NamedDecl *Template, ArrayRef<Expr *> ConstraintExprs,
llvm::SmallVectorImpl<Expr *> &Converted,
const MultiLevelTemplateArgumentList &TemplateArgsLists,
SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction) {
@@ -599,7 +599,7 @@ static bool CheckConstraintSatisfaction(
if (Inst.isInvalid())
return true;
- for (const Expr *ConstraintExpr : ConstraintExprs) {
+ for (Expr *ConstraintExpr : ConstraintExprs) {
ExprResult Res = calculateConstraintSatisfaction(
S, Template, TemplateIDRange.getBegin(), TemplateArgsLists,
ConstraintExpr, Satisfaction);
@@ -622,7 +622,7 @@ static bool CheckConstraintSatisfaction(
}
bool Sema::CheckConstraintSatisfaction(
- const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
+ const NamedDecl *Template, ArrayRef<Expr *> ConstraintExprs,
llvm::SmallVectorImpl<Expr *> &ConvertedConstraints,
const MultiLevelTemplateArgumentList &TemplateArgsLists,
SourceRange TemplateIDRange, ConstraintSatisfaction &OutSatisfaction) {
@@ -690,7 +690,7 @@ bool Sema::CheckConstraintSatisfaction(
return false;
}
-bool Sema::CheckConstraintSatisfaction(const Expr *ConstraintExpr,
+bool Sema::CheckConstraintSatisfaction(Expr *ConstraintExpr,
ConstraintSatisfaction &Satisfaction) {
struct ConstraintEvaluator {
@@ -847,7 +847,7 @@ Sema::SetupConstraintCheckingTemplateArgumentsAndScope(
return MLTAL;
}
-bool Sema::CheckFunctionConstraints(const FunctionDecl *FD,
+bool Sema::CheckFunctionConstraints(FunctionDecl *FD,
ConstraintSatisfaction &Satisfaction,
SourceLocation UsageLoc,
bool ForOverloadResolution) {
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index e45abdc45045bb..f7183402e3f95b 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -10966,7 +10966,7 @@ static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD,
if (FD->getTrailingRequiresClause()) {
ConstraintSatisfaction Satisfaction;
- if (S.CheckFunctionConstraints(FD, Satisfaction, Loc))
+ if (S.CheckFunctionConstraints(const_cast<FunctionDecl *>(FD), Satisfaction, Loc))
return false;
if (!Satisfaction.IsSatisfied) {
if (Complain) {
>From 78298953c506fd6b2477681772b75febea147103 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sat, 17 Aug 2024 21:27:53 +0300
Subject: [PATCH 10/13] Step 10
---
clang/include/clang/Sema/Sema.h | 4 ++--
clang/lib/Sema/SemaChecking.cpp | 2 +-
clang/lib/Sema/SemaExpr.cpp | 2 +-
clang/lib/Sema/SemaInit.cpp | 2 +-
clang/lib/Sema/SemaLookup.cpp | 2 +-
clang/lib/Sema/SemaOverload.cpp | 12 ++++++------
6 files changed, 12 insertions(+), 12 deletions(-)
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 4747cfbb77a538..e46af5797abdc8 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -10391,7 +10391,7 @@ class Sema final : public SemaBase {
// Emit as a 'note' the specific overload candidate
void NoteOverloadCandidate(
- const NamedDecl *Found, const FunctionDecl *Fn,
+ const NamedDecl *Found, FunctionDecl *Fn,
OverloadCandidateRewriteKind RewriteKind = OverloadCandidateRewriteKind(),
QualType DestType = QualType(), bool TakingAddress = false);
@@ -10404,7 +10404,7 @@ class Sema final : public SemaBase {
/// optionally emitting a diagnostic if the address can't be taken.
///
/// Returns false if taking the address of the function is illegal.
- bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
+ bool checkAddressOfFunctionIsAvailable(FunctionDecl *Function,
bool Complain = false,
SourceLocation Loc = SourceLocation());
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index ee143381cf4f79..1947931194a0a6 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -300,7 +300,7 @@ static bool BuiltinFunctionStart(Sema &S, CallExpr *TheCall) {
return true;
}
- return !S.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
+ return !S.checkAddressOfFunctionIsAvailable(const_cast<FunctionDecl *>(FD), /*Complain=*/true,
TheCall->getBeginLoc());
}
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index f495658fe58641..b2d2b105403bb6 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -16579,7 +16579,7 @@ ExprResult Sema::ActOnEmbedExpr(SourceLocation EmbedKeywordLoc,
}
static bool maybeDiagnoseAssignmentToFunction(Sema &S, QualType DstType,
- const Expr *SrcExpr) {
+ Expr *SrcExpr) {
if (!DstType->isFunctionPointerType() ||
!SrcExpr->getType()->isFunctionType())
return false;
diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp
index 2666e60c0dd67c..d1ba3a8ea232d1 100644
--- a/clang/lib/Sema/SemaInit.cpp
+++ b/clang/lib/Sema/SemaInit.cpp
@@ -6271,7 +6271,7 @@ InitializationSequence::InitializationSequence(
/// Tries to get a FunctionDecl out of `E`. If it succeeds and we can take the
/// address of that function, this returns true. Otherwise, it returns false.
-static bool isExprAnUnaddressableFunction(Sema &S, const Expr *E) {
+static bool isExprAnUnaddressableFunction(Sema &S, Expr *E) {
auto *DRE = dyn_cast<DeclRefExpr>(E);
if (!DRE || !isa<FunctionDecl>(DRE->getDecl()))
return false;
diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp
index 7a6a64529f52ec..93fabb31a99d56 100644
--- a/clang/lib/Sema/SemaLookup.cpp
+++ b/clang/lib/Sema/SemaLookup.cpp
@@ -3718,7 +3718,7 @@ Sema::LookupLiteralOperator(Scope *S, LookupResult &R,
// operator template, but not both.
if (FoundRaw && FoundTemplate) {
Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call) << R.getLookupName();
- for (const NamedDecl *D : R)
+ for (NamedDecl *D : R)
NoteOverloadCandidate(D, D->getUnderlyingDecl()->getAsFunction());
return LOLR_Error;
}
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index f7183402e3f95b..e9f7383439f7d1 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -10949,7 +10949,7 @@ static bool isFunctionAlwaysEnabled(const ASTContext &Ctx,
/// we in overload resolution?
/// \param Loc - The location of the statement we're complaining about. Ignored
/// if we're not complaining, or if we're in overload resolution.
-static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD,
+static bool checkAddressOfFunctionIsAvailable(Sema &S, FunctionDecl *FD,
bool Complain,
bool InOverloadResolution,
SourceLocation Loc) {
@@ -10966,7 +10966,7 @@ static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD,
if (FD->getTrailingRequiresClause()) {
ConstraintSatisfaction Satisfaction;
- if (S.CheckFunctionConstraints(const_cast<FunctionDecl *>(FD), Satisfaction, Loc))
+ if (S.CheckFunctionConstraints(FD, Satisfaction, Loc))
return false;
if (!Satisfaction.IsSatisfied) {
if (Complain) {
@@ -11012,13 +11012,13 @@ static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD,
}
static bool checkAddressOfCandidateIsAvailable(Sema &S,
- const FunctionDecl *FD) {
+ FunctionDecl *FD) {
return checkAddressOfFunctionIsAvailable(S, FD, /*Complain=*/true,
/*InOverloadResolution=*/true,
/*Loc=*/SourceLocation());
}
-bool Sema::checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
+bool Sema::checkAddressOfFunctionIsAvailable(FunctionDecl *Function,
bool Complain,
SourceLocation Loc) {
return ::checkAddressOfFunctionIsAvailable(*this, Function, Complain,
@@ -11048,7 +11048,7 @@ static bool shouldSkipNotingLambdaConversionDecl(const FunctionDecl *Fn) {
}
// Notes the location of an overload candidate.
-void Sema::NoteOverloadCandidate(const NamedDecl *Found, const FunctionDecl *Fn,
+void Sema::NoteOverloadCandidate(const NamedDecl *Found, FunctionDecl *Fn,
OverloadCandidateRewriteKind RewriteKind,
QualType DestType, bool TakingAddress) {
if (TakingAddress && !checkAddressOfCandidateIsAvailable(*this, Fn))
@@ -14024,7 +14024,7 @@ static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
// If the user passes in a function that we can't take the address of, we
// generally end up emitting really bad error messages. Here, we attempt to
// emit better ones.
- for (const Expr *Arg : Args) {
+ for (Expr *Arg : Args) {
if (!Arg->getType()->isFunctionType())
continue;
if (auto *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts())) {
>From f344e0e82a4bd30645aceb9f9eb596e8d3d16a9c Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 18 Aug 2024 00:22:15 +0300
Subject: [PATCH 11/13] Fix test
---
clang/unittests/AST/SourceLocationTest.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/clang/unittests/AST/SourceLocationTest.cpp b/clang/unittests/AST/SourceLocationTest.cpp
index 66daa56aace28a..91964ffb77e567 100644
--- a/clang/unittests/AST/SourceLocationTest.cpp
+++ b/clang/unittests/AST/SourceLocationTest.cpp
@@ -1094,8 +1094,8 @@ class ConceptSpecializationExprConceptReferenceRangeVerifier
protected:
SourceRange getRange(const VarTemplateDecl &Node) override {
assert(Node.hasAssociatedConstraints());
- SmallVector<const Expr *, 3> ACs;
- Node.getAssociatedConstraints(ACs);
+ SmallVector<Expr *, 3> ACs;
+ const_cast<VarTemplateDecl &>(Node).getAssociatedConstraints(ACs);
for (const Expr *Constraint : ACs) {
if (const ConceptSpecializationExpr *CSConstraint =
dyn_cast<ConceptSpecializationExpr>(Constraint)) {
>From 8bda17233317c6e88215669055be8195db4af333 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 18 Aug 2024 01:51:06 +0300
Subject: [PATCH 12/13] Remove a `const_cast` that is no longer needed
---
clang/lib/Sema/SemaTemplateInstantiate.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index b86f29ab08ccff..15f5cac5dd893f 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -272,7 +272,7 @@ Response HandleFunction(Sema &SemaRef, FunctionDecl *Function,
} else if (TemplateArgumentList *TemplateArgs =
Function->getTemplateSpecializationArgs()) {
// Add the template arguments for this specialization.
- Result.addOuterTemplateArguments(const_cast<FunctionDecl *>(Function),
+ Result.addOuterTemplateArguments(Function,
TemplateArgs->asMutableArray(),
/*Final=*/false);
>From 919da31d73a408f16e1c855cb658359b73ad1d28 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Sun, 18 Aug 2024 01:51:25 +0300
Subject: [PATCH 13/13] Remove THE `const_cast`
---
clang/include/clang/Sema/Template.h | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/clang/include/clang/Sema/Template.h b/clang/include/clang/Sema/Template.h
index 4890bb8a044efd..62ff8916e3305d 100644
--- a/clang/include/clang/Sema/Template.h
+++ b/clang/include/clang/Sema/Template.h
@@ -199,8 +199,7 @@ enum class TemplateSubstitutionKind : char {
assert(NumRetainedOuterLevels <= Depth && Depth < getNumLevels());
assert(Index <
TemplateArgumentLists[getNumLevels() - Depth - 1].Args.size());
- const_cast<TemplateArgument &>(
- TemplateArgumentLists[getNumLevels() - Depth - 1].Args[Index]) = Arg;
+ TemplateArgumentLists[getNumLevels() - Depth - 1].Args[Index] = Arg;
}
/// Add a new outmost level to the multi-level template argument
More information about the cfe-commits
mailing list