[clang] [clang][NFC] Rename stale TypeSourceInfo DI variables (PR #166082)
via cfe-commits
cfe-commits at lists.llvm.org
Sun Nov 2 11:08:05 PST 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
Author: Chanho Lee (teddygood)
<details>
<summary>Changes</summary>
This patch renames stale variable names where `TypeSourceInfo` objects were still using the old `DI` (`DeclaratorInfo`) naming convention.
Specifically, variables of type `TypeSourceInfo` have been updated from `DI` to `TSI` to improve code clarity and maintain consistency with the current naming.
Fixes #<!-- -->165346
---
Patch is 42.14 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/166082.diff
10 Files Affected:
- (modified) clang/include/clang/Sema/Sema.h (+1-1)
- (modified) clang/lib/AST/ASTContext.cpp (+6-6)
- (modified) clang/lib/Sema/SemaDeclObjC.cpp (+5-5)
- (modified) clang/lib/Sema/SemaTemplate.cpp (+9-9)
- (modified) clang/lib/Sema/SemaTemplateDeductionGuide.cpp (+17-17)
- (modified) clang/lib/Sema/SemaTemplateInstantiate.cpp (+19-21)
- (modified) clang/lib/Sema/SemaTemplateInstantiateDecl.cpp (+90-96)
- (modified) clang/lib/Sema/SemaType.cpp (+4-3)
- (modified) clang/lib/Sema/TreeTransform.h (+45-49)
- (modified) clang/lib/Sema/TypeLocBuilder.h (+3-3)
``````````diff
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 52904c72d1cfc..f4e911010d201 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -11668,7 +11668,7 @@ class Sema final : public SemaBase {
ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc);
DeclResult ActOnVarTemplateSpecialization(
- Scope *S, Declarator &D, TypeSourceInfo *DI, LookupResult &Previous,
+ Scope *S, Declarator &D, TypeSourceInfo *TSI, LookupResult &Previous,
SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,
StorageClass SC, bool IsPartialSpecialization);
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index 687cd46773f43..831f8cab6e43d 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -3108,9 +3108,9 @@ TypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T,
TypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T,
SourceLocation L) const {
- TypeSourceInfo *DI = CreateTypeSourceInfo(T);
- DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L);
- return DI;
+ TypeSourceInfo *TSI = CreateTypeSourceInfo(T);
+ TSI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L);
+ return TSI;
}
const ASTRecordLayout &
@@ -5891,11 +5891,11 @@ TypeSourceInfo *ASTContext::getTemplateSpecializationTypeInfo(
QualType TST = getTemplateSpecializationType(
Keyword, Name, SpecifiedArgs.arguments(), CanonicalArgs, Underlying);
- TypeSourceInfo *DI = CreateTypeSourceInfo(TST);
- DI->getTypeLoc().castAs<TemplateSpecializationTypeLoc>().set(
+ TypeSourceInfo *TSI = CreateTypeSourceInfo(TST);
+ TSI->getTypeLoc().castAs<TemplateSpecializationTypeLoc>().set(
ElaboratedKeywordLoc, QualifierLoc, TemplateKeywordLoc, NameLoc,
SpecifiedArgs);
- return DI;
+ return TSI;
}
QualType ASTContext::getTemplateSpecializationType(
diff --git a/clang/lib/Sema/SemaDeclObjC.cpp b/clang/lib/Sema/SemaDeclObjC.cpp
index 3df9f9c1d68c7..53ff818a2af53 100644
--- a/clang/lib/Sema/SemaDeclObjC.cpp
+++ b/clang/lib/Sema/SemaDeclObjC.cpp
@@ -4730,13 +4730,13 @@ ParmVarDecl *SemaObjC::ActOnMethodParmDeclaration(Scope *S,
bool MethodDefinition) {
ASTContext &Context = getASTContext();
QualType ArgType;
- TypeSourceInfo *DI;
+ TypeSourceInfo *TSI;
if (!ArgInfo.Type) {
ArgType = Context.getObjCIdType();
- DI = nullptr;
+ TSI = nullptr;
} else {
- ArgType = SemaRef.GetTypeFromParser(ArgInfo.Type, &DI);
+ ArgType = SemaRef.GetTypeFromParser(ArgInfo.Type, &TSI);
}
LookupResult R(SemaRef, ArgInfo.Name, ArgInfo.NameLoc,
Sema::LookupOrdinaryName,
@@ -4753,14 +4753,14 @@ ParmVarDecl *SemaObjC::ActOnMethodParmDeclaration(Scope *S,
}
}
SourceLocation StartLoc =
- DI ? DI->getTypeLoc().getBeginLoc() : ArgInfo.NameLoc;
+ TSI ? TSI->getTypeLoc().getBeginLoc() : ArgInfo.NameLoc;
// Temporarily put parameter variables in the translation unit. This is what
// ActOnParamDeclarator does in the case of C arguments to the Objective-C
// method too.
ParmVarDecl *Param = SemaRef.CheckParameter(
Context.getTranslationUnitDecl(), StartLoc, ArgInfo.NameLoc, ArgInfo.Name,
- ArgType, DI, SC_None);
+ ArgType, TSI, SC_None);
Param->setObjCMethodScopeInfo(ParamIndex);
Param->setObjCDeclQualifier(
CvtQTToAstBitMask(ArgInfo.DeclSpec.getObjCDeclQualifier()));
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 2cc65935def53..983a7842ef450 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -949,11 +949,11 @@ static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef,
switch (Arg.getKind()) {
case ParsedTemplateArgument::Type: {
- TypeSourceInfo *DI;
- QualType T = SemaRef.GetTypeFromParser(Arg.getAsType(), &DI);
- if (!DI)
- DI = SemaRef.Context.getTrivialTypeSourceInfo(T, Arg.getNameLoc());
- return TemplateArgumentLoc(TemplateArgument(T), DI);
+ TypeSourceInfo *TSI;
+ QualType T = SemaRef.GetTypeFromParser(Arg.getAsType(), &TSI);
+ if (!TSI)
+ TSI = SemaRef.Context.getTrivialTypeSourceInfo(T, Arg.getNameLoc());
+ return TemplateArgumentLoc(TemplateArgument(T), TSI);
}
case ParsedTemplateArgument::NonType: {
@@ -4329,7 +4329,7 @@ void Sema::CheckDeductionGuideTemplate(FunctionTemplateDecl *TD) {
}
DeclResult Sema::ActOnVarTemplateSpecialization(
- Scope *S, Declarator &D, TypeSourceInfo *DI, LookupResult &Previous,
+ Scope *S, Declarator &D, TypeSourceInfo *TSI, LookupResult &Previous,
SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,
StorageClass SC, bool IsPartialSpecialization) {
// D must be variable template id.
@@ -4455,8 +4455,8 @@ DeclResult Sema::ActOnVarTemplateSpecialization(
VarTemplatePartialSpecializationDecl *Partial =
VarTemplatePartialSpecializationDecl::Create(
Context, VarTemplate->getDeclContext(), TemplateKWLoc,
- TemplateNameLoc, TemplateParams, VarTemplate, DI->getType(), DI, SC,
- CTAI.CanonicalConverted);
+ TemplateNameLoc, TemplateParams, VarTemplate, TSI->getType(), TSI,
+ SC, CTAI.CanonicalConverted);
Partial->setTemplateArgsAsWritten(TemplateArgs);
if (!PrevPartial)
@@ -4474,7 +4474,7 @@ DeclResult Sema::ActOnVarTemplateSpecialization(
// this explicit specialization or friend declaration.
Specialization = VarTemplateSpecializationDecl::Create(
Context, VarTemplate->getDeclContext(), TemplateKWLoc, TemplateNameLoc,
- VarTemplate, DI->getType(), DI, SC, CTAI.CanonicalConverted);
+ VarTemplate, TSI->getType(), TSI, SC, CTAI.CanonicalConverted);
Specialization->setTemplateArgsAsWritten(TemplateArgs);
if (!PrevDecl)
diff --git a/clang/lib/Sema/SemaTemplateDeductionGuide.cpp b/clang/lib/Sema/SemaTemplateDeductionGuide.cpp
index ad50600f6399c..c1e2015f76fb1 100644
--- a/clang/lib/Sema/SemaTemplateDeductionGuide.cpp
+++ b/clang/lib/Sema/SemaTemplateDeductionGuide.cpp
@@ -632,33 +632,33 @@ struct ConvertConstructorToDeductionGuideTransform {
ParmVarDecl *OldParam, MultiLevelTemplateArgumentList &Args,
llvm::SmallVectorImpl<TypedefNameDecl *> &MaterializedTypedefs,
bool TransformingOuterPatterns) {
- TypeSourceInfo *OldDI = OldParam->getTypeSourceInfo();
- TypeSourceInfo *NewDI;
- if (auto PackTL = OldDI->getTypeLoc().getAs<PackExpansionTypeLoc>()) {
+ TypeSourceInfo *OldTSI = OldParam->getTypeSourceInfo();
+ TypeSourceInfo *NewTSI;
+ if (auto PackTL = OldTSI->getTypeLoc().getAs<PackExpansionTypeLoc>()) {
// Expand out the one and only element in each inner pack.
Sema::ArgPackSubstIndexRAII SubstIndex(SemaRef, 0u);
- NewDI =
+ NewTSI =
SemaRef.SubstType(PackTL.getPatternLoc(), Args,
OldParam->getLocation(), OldParam->getDeclName());
- if (!NewDI)
+ if (!NewTSI)
return nullptr;
- NewDI =
- SemaRef.CheckPackExpansion(NewDI, PackTL.getEllipsisLoc(),
+ NewTSI =
+ SemaRef.CheckPackExpansion(NewTSI, PackTL.getEllipsisLoc(),
PackTL.getTypePtr()->getNumExpansions());
} else
- NewDI = SemaRef.SubstType(OldDI, Args, OldParam->getLocation(),
- OldParam->getDeclName());
- if (!NewDI)
+ NewTSI = SemaRef.SubstType(OldTSI, Args, OldParam->getLocation(),
+ OldParam->getDeclName());
+ if (!NewTSI)
return nullptr;
// Extract the type. This (for instance) replaces references to typedef
// members of the current instantiations with the definitions of those
// typedefs, avoiding triggering instantiation of the deduced type during
// deduction.
- NewDI = ExtractTypeForDeductionGuide(
- SemaRef, MaterializedTypedefs, NestedPattern,
- TransformingOuterPatterns ? &Args : nullptr)
- .transform(NewDI);
+ NewTSI = ExtractTypeForDeductionGuide(
+ SemaRef, MaterializedTypedefs, NestedPattern,
+ TransformingOuterPatterns ? &Args : nullptr)
+ .transform(NewTSI);
// Resolving a wording defect, we also inherit default arguments from the
// constructor.
@@ -666,7 +666,7 @@ struct ConvertConstructorToDeductionGuideTransform {
if (OldParam->hasDefaultArg()) {
// We don't care what the value is (we won't use it); just create a
// placeholder to indicate there is a default argument.
- QualType ParamTy = NewDI->getType();
+ QualType ParamTy = NewTSI->getType();
NewDefArg = new (SemaRef.Context)
OpaqueValueExpr(OldParam->getDefaultArgRange().getBegin(),
ParamTy.getNonLValueExprType(SemaRef.Context),
@@ -675,13 +675,13 @@ struct ConvertConstructorToDeductionGuideTransform {
: VK_PRValue);
}
// Handle arrays and functions decay.
- auto NewType = NewDI->getType();
+ auto NewType = NewTSI->getType();
if (NewType->isArrayType() || NewType->isFunctionType())
NewType = SemaRef.Context.getDecayedType(NewType);
ParmVarDecl *NewParam = ParmVarDecl::Create(
SemaRef.Context, DC, OldParam->getInnerLocStart(),
- OldParam->getLocation(), OldParam->getIdentifier(), NewType, NewDI,
+ OldParam->getLocation(), OldParam->getIdentifier(), NewType, NewTSI,
OldParam->getStorageClass(), NewDefArg.get());
NewParam->setScopeInfo(OldParam->getFunctionScopeDepth(),
OldParam->getFunctionScopeIndex());
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 7f858050db13e..5fceacd0c00eb 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -3156,25 +3156,25 @@ Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
const MultiLevelTemplateArgumentList &TemplateArgs,
int indexAdjustment, UnsignedOrNone NumExpansions,
bool ExpectParameterPack, bool EvaluateConstraint) {
- TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
- TypeSourceInfo *NewDI = nullptr;
+ TypeSourceInfo *OldTSI = OldParm->getTypeSourceInfo();
+ TypeSourceInfo *NewTSI = nullptr;
- TypeLoc OldTL = OldDI->getTypeLoc();
+ TypeLoc OldTL = OldTSI->getTypeLoc();
if (PackExpansionTypeLoc ExpansionTL = OldTL.getAs<PackExpansionTypeLoc>()) {
// We have a function parameter pack. Substitute into the pattern of the
// expansion.
- NewDI = SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
- OldParm->getLocation(), OldParm->getDeclName());
- if (!NewDI)
+ NewTSI = SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
+ OldParm->getLocation(), OldParm->getDeclName());
+ if (!NewTSI)
return nullptr;
- if (NewDI->getType()->containsUnexpandedParameterPack()) {
+ if (NewTSI->getType()->containsUnexpandedParameterPack()) {
// We still have unexpanded parameter packs, which means that
// our function parameter is still a function parameter pack.
// Therefore, make its type a pack expansion type.
- NewDI = CheckPackExpansion(NewDI, ExpansionTL.getEllipsisLoc(),
- NumExpansions);
+ NewTSI = CheckPackExpansion(NewTSI, ExpansionTL.getEllipsisLoc(),
+ NumExpansions);
} else if (ExpectParameterPack) {
// We expected to get a parameter pack but didn't (because the type
// itself is not a pack expansion type), so complain. This can occur when
@@ -3182,18 +3182,18 @@ Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
// pack expansion.
Diag(OldParm->getLocation(),
diag::err_function_parameter_pack_without_parameter_packs)
- << NewDI->getType();
+ << NewTSI->getType();
return nullptr;
}
} else {
- NewDI = SubstType(OldDI, TemplateArgs, OldParm->getLocation(),
- OldParm->getDeclName());
+ NewTSI = SubstType(OldTSI, TemplateArgs, OldParm->getLocation(),
+ OldParm->getDeclName());
}
- if (!NewDI)
+ if (!NewTSI)
return nullptr;
- if (NewDI->getType()->isVoidType()) {
+ if (NewTSI->getType()->isVoidType()) {
Diag(OldParm->getLocation(), diag::err_param_with_void_type);
return nullptr;
}
@@ -3205,7 +3205,7 @@ Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
// here, when the instantiated versions of those referenced parameters are in
// scope.
if (TemplateTypeParmDecl *TTP =
- GetContainedInventedTypeParmVisitor().Visit(OldDI->getType())) {
+ GetContainedInventedTypeParmVisitor().Visit(OldTSI->getType())) {
if (const TypeConstraint *TC = TTP->getTypeConstraint()) {
auto *Inst = cast_or_null<TemplateTypeParmDecl>(
FindInstantiatedDecl(TTP->getLocation(), TTP, TemplateArgs));
@@ -3219,12 +3219,10 @@ Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
}
}
- ParmVarDecl *NewParm = CheckParameter(Context.getTranslationUnitDecl(),
- OldParm->getInnerLocStart(),
- OldParm->getLocation(),
- OldParm->getIdentifier(),
- NewDI->getType(), NewDI,
- OldParm->getStorageClass());
+ ParmVarDecl *NewParm = CheckParameter(
+ Context.getTranslationUnitDecl(), OldParm->getInnerLocStart(),
+ OldParm->getLocation(), OldParm->getIdentifier(), NewTSI->getType(),
+ NewTSI, OldParm->getStorageClass());
if (!NewParm)
return nullptr;
diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
index 28925cca8f956..681bfe0d8cbf8 100644
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -1506,17 +1506,17 @@ TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
bool IsTypeAlias) {
bool Invalid = false;
- TypeSourceInfo *DI = D->getTypeSourceInfo();
- if (DI->getType()->isInstantiationDependentType() ||
- DI->getType()->isVariablyModifiedType()) {
- DI = SemaRef.SubstType(DI, TemplateArgs,
- D->getLocation(), D->getDeclName());
- if (!DI) {
+ TypeSourceInfo *TSI = D->getTypeSourceInfo();
+ if (TSI->getType()->isInstantiationDependentType() ||
+ TSI->getType()->isVariablyModifiedType()) {
+ TSI = SemaRef.SubstType(TSI, TemplateArgs, D->getLocation(),
+ D->getDeclName());
+ if (!TSI) {
Invalid = true;
- DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
+ TSI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
}
} else {
- SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
+ SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), TSI->getType());
}
// HACK: 2012-10-23 g++ has a bug where it gets the value kind of ?: wrong.
@@ -1525,7 +1525,7 @@ Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
// semantics. See LWG issue 2141 for more information on the bug. The bugs
// are fixed in g++ and libstdc++ 4.9.0 (2014-04-22).
if (SemaRef.getPreprocessor().NeedsStdLibCxxWorkaroundBefore(2014'04'22)) {
- const DecltypeType *DT = DI->getType()->getAs<DecltypeType>();
+ const DecltypeType *DT = TSI->getType()->getAs<DecltypeType>();
CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
if (DT && RD && isa<ConditionalOperator>(DT->getUnderlyingExpr()) &&
DT->isReferenceType() &&
@@ -1534,18 +1534,18 @@ Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
D->getIdentifier() && D->getIdentifier()->isStr("type") &&
SemaRef.getSourceManager().isInSystemHeader(D->getBeginLoc()))
// Fold it to the (non-reference) type which g++ would have produced.
- DI = SemaRef.Context.getTrivialTypeSourceInfo(
- DI->getType().getNonReferenceType());
+ TSI = SemaRef.Context.getTrivialTypeSourceInfo(
+ TSI->getType().getNonReferenceType());
}
// Create the new typedef
TypedefNameDecl *Typedef;
if (IsTypeAlias)
Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(),
- D->getLocation(), D->getIdentifier(), DI);
+ D->getLocation(), D->getIdentifier(), TSI);
else
Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(),
- D->getLocation(), D->getIdentifier(), DI);
+ D->getLocation(), D->getIdentifier(), TSI);
if (Invalid)
Typedef->setInvalidDecl();
@@ -1554,7 +1554,7 @@ Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
TagDecl *oldTag = oldTagType->getDecl();
if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) {
- TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
+ TagDecl *newTag = TSI->getType()->castAs<TagType>()->getDecl();
assert(!newTag->hasNameForLinkage());
newTag->setTypedefNameForAnonDecl(Typedef);
}
@@ -1719,15 +1719,15 @@ Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D,
ArrayRef<BindingDecl*> *Bindings) {
// Do substitution on the type of the declaration
- TypeSourceInfo *DI = SemaRef.SubstType(
+ TypeSourceInfo *TSI = SemaRef.SubstType(
D->getTypeSourceInfo(), TemplateArgs, D->getTypeSpecStartLoc(),
- D->getDeclName(), /*AllowDeducedTST*/true);
- if (!DI)
+ D->getDeclName(), /*AllowDeducedTST*/ true);
+ if (!TSI)
return nullptr;
- if (DI->getType()->isFunctionType()) {
+ if (TSI->getType()->isFunctionType()) {
SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
- << D->isStaticDataMember() << DI->getType();
+ << D->isStaticDataMember() << TSI->getType();
return nullptr;
}
@@ -1739,12 +1739,12 @@ Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D,
VarDecl *Var;
if (Bindings)
Var = DecompositionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
- D->getLocation(), DI->getType(), DI,
+ D->getLocation(), TSI->getType(), TSI,
D->getStorageClass(), *Bindings);
else
Var = VarDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
- D->getLocation(), D->getIdentifier(), DI->getType(),
- DI, D->getStorageClass());
+ D->getLocation(), D->getIdentifier(), TSI->getType(),
+ TSI, D->getStorageClass());
// In ARC, infer 'retaining' for variables of retainable type.
if (SemaRef.getLangOpts().ObjCAutoRefCount &&
@@ -1810,15 +1810,15 @@ Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
bool Invalid = false;
- TypeSourceInfo *DI = D->getTypeSourceInfo();
- if (DI->getType()->isInstantiationDependentType() ||
- DI->getType()->isVariablyModifiedType()) {
- DI = SemaRef.SubstType(DI, TemplateArgs,
- D->getLocation(), D->getDeclName());
- if (!DI) {
- DI = D->getTypeSourceInfo();
+ TypeSourceInfo *TSI = D->getTypeSourceInfo();
+ if (TSI->getType()->isInstantiationDependentType() ||
+ TSI->getType()->isVariablyModifiedType()) {
+ TSI = SemaRef.SubstType(TSI, TemplateArgs, D->getLocation(),
+ D->getDeclName());
+ if (!TSI) {
+ ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/166082
More information about the cfe-commits
mailing list