Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/SemaTemplateInstantiate_8cpp_source.html below:

clang: lib/Sema/SemaTemplateInstantiate.cpp Source File

;

*NextDecl =

;

ClearRelativeToPrimary =

;

Response Done() {

Response ChangeDecl(

*ND) {

Response ChangeDecl(

*Ctx) {

Response UseNextDecl(

*CurDecl) {

Response DontClearRelativeToPrimaryNextDecl(

*CurDecl) {

Response R = Response::UseNextDecl(CurDecl);

R.ClearRelativeToPrimary =

;

getPrimaryTemplateOfGenericLambda(

*LambdaCallOperator) {

LambdaCallOperator;

(

*FTD = dyn_cast_if_present<FunctionTemplateDecl>(

FTD && FTD->getInstantiatedFromMemberTemplate()) {

FTD->getInstantiatedFromMemberTemplate()->getTemplatedDecl();

}

(

*Prev = cast<CXXMethodDecl>(LambdaCallOperator)

->getInstantiatedFromMemberFunction())

LambdaCallOperator = Prev;

LambdaCallOperator;

EnclosingTypeAliasTemplateDetails {

()

{

Template; }

EnclosingTypeAliasTemplateDetails

getEnclosingTypeAliasTemplateDecl(

&SemaRef) {

TypeAliasTemplateInstantiation)

EnclosingTypeAliasTemplateDetails Result;

*TATD = cast<TypeAliasTemplateDecl>(CSC.Entity),

*Next = TATD->getInstantiatedFromMemberTemplate();

CSC.template_arguments(),

Result.PrimaryTypeAliasDecl = Next;

Next = Next->getInstantiatedFromMemberTemplate();

isLambdaEnclosedByTypeAliasDecl(

Visitor(

*CallOperator) : CallOperator(CallOperator) {}

VisitLambdaExpr(

*LE)

{

getPrimaryTemplateOfGenericLambda(LE->getCallOperator()) !=

!Visitor(getPrimaryTemplateOfGenericLambda(LambdaCallOperator))

.TraverseType(Underlying);

SkipForSpecialization) {

Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);

!isa<VarTemplatePartialSpecializationDecl>(VarTemplSpec))

Response::Done();

llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>

(!SkipForSpecialization)

Result.addOuterTemplateArguments(

(Partial->isMemberSpecialization())

Response::Done();

(!SkipForSpecialization)

Result.addOuterTemplateArguments(

Response::Done();

Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);

(

I = 0, N = TTP->

() + 1; I != N; ++I)

Result.addOuterTemplateArguments(std::nullopt);

Response::Done();

Response HandlePartialClassTemplateSpec(

(!SkipForSpecialization)

Response::Done();

SkipForSpecialization) {

!isa<ClassTemplatePartialSpecializationDecl>(ClassTemplSpec))

Response::Done();

(!SkipForSpecialization)

Result.addOuterTemplateArguments(

Response::Done();

(

*InstFromPartialTempl =

Response::ChangeDecl(

InstFromPartialTempl->getLexicalDeclContext());

Response::UseNextDecl(ClassTemplSpec);

ForConstraintInstantiation,

ForDefaultArgumentSubstitution) {

(!RelativeToPrimary &&

->getTemplateSpecializationKindForInstantiation() ==

Response::Done();

(!RelativeToPrimary &&

Response::UseNextDecl(

);

->getTemplateSpecializationArgs()) {

TemplateArgs->asArray(),

(RelativeToPrimary &&

(

->getTemplateSpecializationKind() ==

(

->getFriendObjectKind() &&

!

->getPrimaryTemplate()->getFriendObjectKind())))

Response::UseNextDecl(

);

assert(

->getPrimaryTemplate() &&

);

(!ForDefaultArgumentSubstitution &&

->getPrimaryTemplate()->isMemberSpecialization())

Response::Done();

(!ForConstraintInstantiation &&

Response::Done();

}

(

->getDescribedFunctionTemplate()) {

(ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&

);

((

->getFriendObjectKind() ||

->isLocalExternDecl()) &&

->getNonTransparentDeclContext()->isFileContext() &&

Response::ChangeDecl(

->getLexicalDeclContext());

(ForConstraintInstantiation &&

->getFriendObjectKind())

Response::ChangeDecl(

->getLexicalDeclContext());

Response::UseNextDecl(

);

Response HandleFunctionTemplateDecl(

&SemaRef,

(!isa<ClassTemplateSpecializationDecl>(FTD->

())) {

Result.addOuterTemplateArguments(

(

*Ty = NNS ? NNS->

() :

) {

(TSTy->isCurrentInstantiation()) {

*RD = TSTy->getCanonicalTypeInternal()->getAsCXXRecordDecl();

Arguments = CTD->getInjectedTemplateArgs(SemaRef.

);

dyn_cast<ClassTemplateSpecializationDecl>(RD))

Result.addOuterTemplateArguments(

TSTy->getTemplateName().getAsTemplateDecl(), Arguments,

ForConstraintInstantiation) {

(ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&

);

(ClassTemplate->isMemberSpecialization())

Response::Done();

(ForConstraintInstantiation)

Result.addOuterTemplateArguments(

ClassTemplate->getInjectedTemplateArgs(SemaRef.

),

Response::Done();

(ForConstraintInstantiation && IsFriend &&

Response::ChangeDecl(LCD);

(

TypeAlias = getEnclosingTypeAliasTemplateDecl(SemaRef);

ForConstraintInstantiation && TypeAlias) {

TypeAlias.PrimaryTypeAliasDecl)) {

Result.addOuterTemplateArguments(TypeAlias.Template,

TypeAlias.AssociatedTemplateArguments,

Response::ChangeDecl(TypeAlias.Template->getDeclContext());

Response::UseNextDecl(Rec);

Response HandleImplicitConceptSpecializationDecl(

Result.addOuterTemplateArguments(

Response::UseNextDecl(CSD);

Response HandleGenericDeclContext(

*CurDecl) {

Response::UseNextDecl(CurDecl);

*Pattern,

ForConstraintInstantiation,

SkipForSpecialization,

ForDefaultArgumentSubstitution) {

assert((ND || DC) &&

);

*CurDecl = ND;

.addOuterTemplateArguments(

*

(ND), *Innermost,

(

*TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl))

HandleDefaultTempArgIntoTempTempParam(TTP,

);

CurDecl = Response::UseNextDecl(CurDecl).NextDecl;

(

*VarTemplSpec =

dyn_cast<VarTemplateSpecializationDecl>(CurDecl)) {

R = HandleVarTemplateSpec(VarTemplSpec,

, SkipForSpecialization);

}

(

*PartialClassTemplSpec =

dyn_cast<ClassTemplatePartialSpecializationDecl>(CurDecl)) {

R = HandlePartialClassTemplateSpec(PartialClassTemplSpec,

,

SkipForSpecialization);

}

(

*ClassTemplSpec =

dyn_cast<ClassTemplateSpecializationDecl>(CurDecl)) {

R = HandleClassTemplateSpec(ClassTemplSpec,

,

SkipForSpecialization);

}

(

*

= dyn_cast<FunctionDecl>(CurDecl)) {

R = HandleFunction(*

,

,

, Pattern, RelativeToPrimary,

ForConstraintInstantiation,

ForDefaultArgumentSubstitution);

}

(

*Rec = dyn_cast<CXXRecordDecl>(CurDecl)) {

ForConstraintInstantiation);

}

(

*CSD =

dyn_cast<ImplicitConceptSpecializationDecl>(CurDecl)) {

R = HandleImplicitConceptSpecializationDecl(CSD,

);

}

(

*FTD = dyn_cast<FunctionTemplateDecl>(CurDecl)) {

R = HandleFunctionTemplateDecl(*

, FTD,

);

}

(

*CTD = dyn_cast<ClassTemplateDecl>(CurDecl)) {

R = Response::ChangeDecl(CTD->getLexicalDeclContext());

}

(!isa<DeclContext>(CurDecl)) {

R = Response::DontClearRelativeToPrimaryNextDecl(CurDecl);

(

*TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl)) {

R = HandleDefaultTempArgIntoTempTempParam(TTP,

);

R = HandleGenericDeclContext(CurDecl);

(R.ClearRelativeToPrimary)

RelativeToPrimary =

;

CurDecl = R.NextDecl;

llvm_unreachable(

);

AlreadyInstantiating = !Inst.Entity ?

:

.insert({Inst.Entity->getCanonicalDecl(), Inst.Kind})

PointOfInstantiation, InstantiationRange, Entity) {}

PointOfInstantiation, InstantiationRange, Entity) {}

Template, TemplateArgs) {}

TemplateArgs, &DeductionInfo) {

PointOfInstantiation, InstantiationRange, Template, nullptr,

TemplateArgs, &DeductionInfo) {}

PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,

TemplateArgs, &DeductionInfo) {}

PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,

TemplateArgs, &DeductionInfo) {}

PointOfInstantiation, InstantiationRange, Param, nullptr,

PointOfInstantiation, InstantiationRange, Param, Template,

PointOfInstantiation, InstantiationRange, Param, Template,

PointOfInstantiation, InstantiationRange,

Entity,

nullptr, TemplateArgs) {}

PointOfInstantiation, InstantiationRange, Param, Template,

PointOfInstantiation, InstantiationRange,

nullptr,

nullptr,

{}, &DeductionInfo) {}

PointOfInstantiation, InstantiationRange,

nullptr,

PointOfInstantiation, InstantiationRange,

nullptr,

nullptr,

{}, &DeductionInfo) {}

PointOfInstantiation, InstantiationRange, Template, nullptr,

PointOfInstantiation, InstantiationRange, Template, nullptr,

{}, &DeductionInfo) {}

PointOfInstantiation, InstantiationRange, Template) {}

PointOfInstantiation, InstantiationRange, Template) {}

PointOfInstantiation, InstantiationRange, Entity) {}

ArgLoc, InstantiationRange, PArg) {}

(!Ctx.isInstantiationRecord())

(!Active.isInstantiationRecord()) {

);

(!AlreadyInstantiating) {

{Active.Entity->getCanonicalDecl(), Active.Kind});

llvm::raw_string_ostream

(

);

llvm::ListSeparator Comma;

(

*Arg : Args) {

Arg->IgnoreParens()->printPretty(

,

,

Sema::InstantiatingTemplate::CheckInstantiationDepth(

diag::err_template_recursion_depth_exceeded)

<< InstantiationRange;

.

(PointOfInstantiation, diag::note_template_recursion_depth)

SkipStart = Limit / 2 + Limit % 2;

InstantiationIdx = 0;

++Active, ++InstantiationIdx) {

(InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {

(InstantiationIdx == SkipStart) {

diag::note_instantiation_contexts_suppressed)

(Active->Kind) {

*

= Active->Entity;

DiagID = diag::note_template_member_class_here;

(isa<ClassTemplateSpecializationDecl>(

))

DiagID = diag::note_template_class_instantiation_here;

.

(Active->PointOfInstantiation, DiagID)

<<

<< Active->InstantiationRange;

(

->getPrimaryTemplate())

DiagID = diag::note_function_template_spec_here;

DiagID = diag::note_template_member_function_here;

.

(Active->PointOfInstantiation, DiagID)

<< Active->InstantiationRange;

}

(

*VD = dyn_cast<VarDecl>(

)) {

VD->isStaticDataMember()?

diag::note_template_static_data_member_def_here

: diag::note_template_variable_def_here)

<< Active->InstantiationRange;

}

(

*ED = dyn_cast<EnumDecl>(

)) {

diag::note_template_enum_def_here)

<< Active->InstantiationRange;

}

(

*FD = dyn_cast<FieldDecl>(

)) {

diag::note_template_nsdmi_here)

<< FD << Active->InstantiationRange;

diag::note_template_class_instantiation_here)

<< CTD << Active->InstantiationRange;

*Template = cast<TemplateDecl>(Active->Template);

llvm::raw_svector_ostream

(TemplateArgsStr);

diag::note_default_arg_instantiation_here)

<< Active->InstantiationRange;

diag::note_explicit_template_arg_substitution_here)

Active->TemplateArgs,

Active->NumTemplateArgs)

<< Active->InstantiationRange;

dyn_cast<FunctionTemplateDecl>(Active->Entity)) {

diag::note_function_template_deduction_instantiation_here)

Active->TemplateArgs,

Active->NumTemplateArgs)

<< Active->InstantiationRange;

IsVar = isa<VarTemplateDecl>(Active->Entity) ||

isa<VarTemplateSpecializationDecl>(Active->Entity);

IsTemplate =

;

(

*

= dyn_cast<TemplateDecl>(Active->Entity)) {

Params =

->getTemplateParameters();

}

(

*

= dyn_cast<ClassTemplatePartialSpecializationDecl>(

Params =

->getTemplateParameters();

}

(

*

= dyn_cast<VarTemplatePartialSpecializationDecl>(

Params =

->getTemplateParameters();

llvm_unreachable(

);

diag::note_deduced_template_arg_substitution_here)

<< IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)

Active->NumTemplateArgs)

<< Active->InstantiationRange;

*Param = cast<ParmVarDecl>(Active->Entity);

llvm::raw_svector_ostream

(TemplateArgsStr);

diag::note_default_function_arg_instantiation_here)

<< Active->InstantiationRange;

*Parm = cast<NamedDecl>(Active->Entity);

(!Parm->

().empty())

Name = std::string(

) + Parm->

().str() +

;

(

*Template = dyn_cast<TemplateDecl>(Active->Template))

TemplateParams = Template->getTemplateParameters();

cast<ClassTemplatePartialSpecializationDecl>(Active->Template)

->getTemplateParameters();

diag::note_prior_template_arg_substitution)

<< isa<TemplateTemplateParmDecl>(Parm)

Active->TemplateArgs,

Active->NumTemplateArgs)

<< Active->InstantiationRange;

(

*Template = dyn_cast<TemplateDecl>(Active->Template))

TemplateParams = Template->getTemplateParameters();

cast<ClassTemplatePartialSpecializationDecl>(Active->Template)

->getTemplateParameters();

diag::note_template_default_arg_checking)

Active->TemplateArgs,

Active->NumTemplateArgs)

<< Active->InstantiationRange;

diag::note_evaluating_exception_spec_here)

<< cast<FunctionDecl>(Active->Entity);

diag::note_template_exception_spec_instantiation_here)

<< cast<FunctionDecl>(Active->Entity)

<< Active->InstantiationRange;

diag::note_template_requirement_instantiation_here)

<< Active->InstantiationRange;

diag::note_template_requirement_params_instantiation_here)

<< Active->InstantiationRange;

diag::note_nested_requirement_here)

<< Active->InstantiationRange;

diag::note_in_declaration_of_implicit_special_member)

<< cast<CXXRecordDecl>(Active->Entity)

<< llvm::to_underlying(Active->SpecialMember);

diag::note_in_declaration_of_implicit_equality_comparison);

*FD = dyn_cast<FunctionDecl>(Active->Entity);

*MD = cast<CXXMethodDecl>(FD);

diag::note_member_synthesized_at)

<< MD->isExplicitlyDefaulted()

.getNonReferenceType()

.getUnqualifiedType();

diag::note_comparison_synthesized_at)

diag::note_rewriting_operator_as_spaceship);

diag::note_in_binding_decl_init)

<< cast<BindingDecl>(Active->Entity);

diag::note_due_to_dllexported_class)

<< cast<CXXRecordDecl>(Active->Entity) << !

().CPlusPlus11;

diag::note_building_builtin_dump_struct_call)

*

,

(Active->CallArgs, Active->NumCallArgs));

diag::note_lambda_substitution_here);

DiagID = 0;

(!Active->Entity) {

diag::note_nested_requirement_here)

<< Active->InstantiationRange;

(isa<ConceptDecl>(Active->Entity))

DiagID = diag::note_concept_specialization_here;

(isa<TemplateDecl>(Active->Entity))

DiagID = diag::note_checking_constraints_for_template_id_here;

(isa<VarTemplatePartialSpecializationDecl>(Active->Entity))

DiagID = diag::note_checking_constraints_for_var_spec_id_here;

(isa<ClassTemplatePartialSpecializationDecl>(Active->Entity))

DiagID = diag::note_checking_constraints_for_class_spec_id_here;

assert(isa<FunctionDecl>(Active->Entity));

DiagID = diag::note_checking_constraints_for_function_here;

llvm::raw_svector_ostream

(TemplateArgsStr);

(!isa<FunctionDecl>(Active->Entity)) {

.

(Active->PointOfInstantiation, DiagID) <<

.str()

<< Active->InstantiationRange;

diag::note_constraint_substitution_here)

<< Active->InstantiationRange;

diag::note_constraint_normalization_here)

<< cast<NamedDecl>(Active->Entity) << Active->InstantiationRange;

diag::note_parameter_mapping_substitution_here)

<< Active->InstantiationRange;

diag::note_building_deduction_guide_here);

diag::note_template_type_alias_instantiation_here)

<< cast<TypeAliasTemplateDecl>(Active->Entity)

<< Active->InstantiationRange;

diag::note_template_arg_template_params_mismatch);

.

(ParamLoc, diag::note_template_prev_declaration)

<<

<< Active->InstantiationRange;

std::optional<TemplateDeductionInfo *>(

);

Active != ActiveEnd;

(Active->Kind) {

(isa<TypeAliasTemplateDecl>(Active->Entity))

std::nullopt;

std::nullopt;

assert(Active->DeductionInfo &&

);

Active->DeductionInfo;

std::nullopt;

(Active->SavedInNonInstantiationSFINAEContext)

std::optional<TemplateDeductionInfo *>(

);

std::nullopt;

TemplateInstantiator :

<TemplateInstantiator> {

EvaluateConstraints =

;

IsIncomplete =

;

BailOutOnIncomplete;

TemplateInstantiator(

&SemaRef,

BailOutOnIncomplete =

)

: inherited(SemaRef), TemplateArgs(TemplateArgs),

(

),

Entity(Entity), BailOutOnIncomplete(BailOutOnIncomplete) {}

setEvaluateConstraints(

B) {

EvaluateConstraints = B;

getEvaluateConstraints() {

EvaluateConstraints;

getIsIncomplete()

{

IsIncomplete; }

this->Entity = Entity;

TransformTemplateDepth(

Depth) {

Index = getSema().ArgumentPackSubstitutionIndex;

std::nullopt;

&ShouldExpand,

&RetainExpansion,

std::optional<unsigned> &NumExpansions) {

getSema().CheckParameterPacksForExpansion(EllipsisLoc,

PatternRange, Unexpanded,

ExpandingFunctionParameterPack(

*Pack) {

Depth, Index;

Result = TemplateArgs(Depth, Index);

IsIncomplete =

;

(BailOutOnIncomplete)

Depth, Index;

transformAttrs(

*Old,

*New) {

(NewDecls.size() != 1 || !NewDecls.front()->isParameterPack())) {

(

*New : NewDecls)

Old, cast<VarDecl>(New));

assert(NewDecls.size() == 1 &&

);

*New = NewDecls.front();

*NewMD = dyn_cast<CXXMethodDecl>(New);

*OldMD = dyn_cast<CXXMethodDecl>(Old);

(

*NewTD = NewMD->getDescribedFunctionTemplate())

NewTD->setInstantiatedFromMemberTemplate(

OldMD->getDescribedFunctionTemplate());

NewMD->setInstantiationOfMemberFunction(OldMD,

(

*DC = dyn_cast<DeclContext>(Old);

DC && DC->isDependentContext() && DC->isFunctionOrMethod())

*FirstQualifierInScope =

,

AllowInjectedClassName =

);

AnnotateAttr *TransformAnnotateAttr(

AnnotateAttr *AA);

CXXAssumeAttr *TransformCXXAssumeAttr(

CXXAssumeAttr *AA);

LoopHintAttr *TransformLoopHintAttr(

LoopHintAttr *LH);

NoInlineAttr *TransformStmtNoInlineAttr(

*OrigS,

NoInlineAttr *A);

AlwaysInlineAttr *

TransformStmtAlwaysInlineAttr(

*OrigS,

*InstS,

AlwaysInlineAttr *A);

CodeAlignAttr *TransformCodeAlignAttr(

CodeAlignAttr *CA);

TransformSubstNonTypeTemplateParmPackExpr(

TransformSubstNonTypeTemplateParmExpr(

inherited::TransformFunctionProtoType(TLB, TL);

= inherited::TransformInjectedClassNameType(TLB, TL);

(

.isNull() &&

inherited::TransformType(ICT->getInjectedSpecializationType());

Uneval =

) {

std::vector<TemplateArgument> TArgs;

inherited::TransformTemplateArgument(Input, Output, Uneval);

<

Fn>

Fn TransformExceptionSpec);

TransformFunctionTypeParam(

*OldParm,

indexAdjustment,

std::optional<unsigned> NumExpansions,

ExpectParameterPack);

inherited::TransformTemplateTypeParmType;

SuppressObjCLifetime);

BuildSubstTemplateTypeParmType(

*AssociatedDecl,

Index, std::optional<unsigned> PackIndex,

inherited::TransformSubstTemplateTypeParmPackType;

SuppressObjCLifetime);

(

->getSubstitutionFlag() !=

SubstTemplateTypeParmTypeFlag::ExpandPacksInPlace)

inherited::TransformSubstTemplateTypeParmType(TLB, TL);

assert(

->getPackIndex());

->getReplacedParameter()->getDepth(),

->getIndex());

inherited::TransformSubstTemplateTypeParmType(TLB, TL);

(

TypeAlias =

TemplateInstArgsHelpers::getEnclosingTypeAliasTemplateDecl(

&& TemplateInstArgsHelpers::isLambdaEnclosedByTypeAliasDecl(

TypeAliasDeclDepth =

.Template->getTemplateDepth();

CXXRecordDecl::LambdaDependencyKind::LDK_AlwaysDependent;

CXXRecordDecl::LambdaDependencyKind::LDK_AlwaysDependent;

inherited::ComputeLambdaDependency(LSI);

inherited::TransformLambdaExpr(

);

inherited::TransformBlockExpr(

);

assert(PVD &&

);

(!PVD->hasDefaultArg())

*UninstExpr = PVD->getUninstantiatedDefaultArg();

PVD->setDefaultArg(ErrorResult.

());

inherited::RebuildLambdaExpr(StartLoc, EndLoc, LSI);

inherited::TransformLambdaBody(

, Body);

TransReq = inherited::TransformRequiresExpr(

);

assert(TransReq.

() !=

&&

);

(

->getBody()->isDependentContext()) {

(Trap.hasErrorOccurred())

TransformRequiresExprRequirements(

SatisfactionDetermined =

;

(!SatisfactionDetermined) {

(

*TypeReq = dyn_cast<concepts::TypeRequirement>(Req))

TransReq = TransformTypeRequirement(TypeReq);

(

*ExprReq = dyn_cast<concepts::ExprRequirement>(Req))

TransReq = TransformExprRequirement(ExprReq);

TransReq = TransformNestedRequirement(

cast<concepts::NestedRequirement>(Req));

SatisfactionDetermined =

;

Transformed.push_back(TransReq);

(!OrigTPL || !OrigTPL->

())

OrigTPL;

Owner, TemplateArgs);

DeclInstantiator.setEvaluateConstraints(EvaluateConstraints);

DeclInstantiator.SubstTemplateParams(OrigTPL);

transformNonTypeTemplateParmRef(

*AssociatedDecl,

std::optional<unsigned> PackIndex);

TemplateInstantiator::AlreadyTransformed(

) {

getSema().MarkDeclarationsReferencedInType(

,

);

TTP->getPosition())) {

IsIncomplete =

;

BailOutOnIncomplete ? nullptr :

;

(TTP->isParameterPack()) {

);

);

*Inst = getSema().SubstDecl(

, getSema().

, TemplateArgs);

getSema().CurrentInstantiationScope->InstantiatedLocal(

, Inst);

TemplateInstantiator::TransformExceptionSpec(

inherited::TransformExceptionSpec(

, ESI, Exceptions, Changed);

TemplateInstantiator::TransformFirstQualifierInScope(

*

,

);

cast_or_null<NamedDecl>(TransformDecl(

,

));

->getDecl();

getSema().Diag(

, diag::err_nested_name_spec_non_tag) <<

;

cast_or_null<NamedDecl>(TransformDecl(

,

));

TemplateInstantiator::RebuildExceptionDecl(

*ExceptionDecl,

StartLoc, NameLoc, Name);

getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);

*TemplateInstantiator::RebuildObjCExceptionDecl(

*ExceptionDecl,

*Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo,

);

getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);

TemplateInstantiator::RebuildElaboratedType(

KeywordLoc,

TagLocation,

)) {

.

(TagLocation, diag::err_use_with_wrong_tag)

inherited::RebuildElaboratedType(KeywordLoc, Keyword, QualifierLoc,

);

TemplateInstantiator::TransformTemplateName(

AllowInjectedClassName) {

= dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) {

TTP->getPosition())) {

IsIncomplete =

;

);

);

[AssociatedDecl, Final] =

std::optional<unsigned> PackIndex;

);

getSema().Context.getSubstTemplateTemplateParmPack(

Arg, AssociatedDecl, TTP->

(), Final);

PackIndex = getPackIndex(Arg);

assert(!Template.

() &&

);

getSema().Context.getSubstTemplateTemplateParm(

Template, AssociatedDecl, TTP->

(), PackIndex);

= Name.getAsSubstTemplateTemplateParmPack()) {

(SubstPack->getFinal())

getSema().Context.getSubstTemplateTemplateParm(

Template, SubstPack->getAssociatedDecl(), SubstPack->getIndex(),

getPackIndex(Pack));

inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,

FirstQualifierInScope,

AllowInjectedClassName);

getSema().BuildPredefinedExpr(

->getLocation(),

->getIdentKind());

TemplateInstantiator::TransformTemplateParmRefExpr(

*

,

IsIncomplete =

;

BailOutOnIncomplete ?

() :

;

);

);

std::optional<unsigned> PackIndex;

);

(TargetType.

())

->getLocation(), Arg, AssociatedDecl, NTTP->

());

PackIndex = getPackIndex(Arg);

transformNonTypeTemplateParmRef(AssociatedDecl, NTTP,

->getLocation(),

TemplateInstantiator::TransformAnnotateAttr(

AnnotateAttr *AA) {

(

*Arg : AA->args()) {

Res = getDerived().TransformExpr(Arg);

Args.push_back(Res.

());

AnnotateAttr::CreateImplicit(getSema().

, AA->getAnnotation(),

Args.data(), Args.size(), AA->getRange());

CXXAssumeAttr *

TemplateInstantiator::TransformCXXAssumeAttr(

CXXAssumeAttr *AA) {

Res = getDerived().TransformExpr(AA->getAssumption());

Res = getSema().ActOnFinishFullExpr(Res.

(),

(!(Res.

()->

() & ExprDependence::TypeValueInstantiation)) {

Res = getSema().BuildCXXAssumeExpr(Res.

(), AA->getAttrName(),

CXXAssumeAttr::CreateImplicit(getSema().

, Res.

(),

TemplateInstantiator::TransformLoopHintAttr(

LoopHintAttr *LH) {

*TransformedExpr = getDerived().TransformExpr(LH->getValue()).get();

(TransformedExpr == LH->getValue())

LH->getSemanticSpelling() ==

LoopHintAttr::Pragma_unroll))

LoopHintAttr::OptionType Option = LH->getOption();

LoopHintAttr::LoopHintState State = LH->getState();

llvm::APSInt ValueAPS =

(ValueAPS.isZero() || ValueAPS.isOne()) {

Option = LoopHintAttr::Unroll;

State = LoopHintAttr::Disable;

LoopHintAttr::CreateImplicit(getSema().

, Option, State,

TransformedExpr, *LH);

NoInlineAttr *TemplateInstantiator::TransformStmtNoInlineAttr(

*OrigS,

*InstS,

NoInlineAttr *A) {

AlwaysInlineAttr *TemplateInstantiator::TransformStmtAlwaysInlineAttr(

*OrigS,

*InstS,

AlwaysInlineAttr *A) {

CodeAlignAttr *

TemplateInstantiator::TransformCodeAlignAttr(

CodeAlignAttr *CA) {

*TransformedExpr = getDerived().TransformExpr(CA->getAlignment()).get();

getSema().BuildCodeAlignAttr(*CA, TransformedExpr);

TemplateInstantiator::transformNonTypeTemplateParmRef(

std::optional<unsigned> PackIndex) {

SubstParamType = [&] {

= cast<PackExpansionType>(

)->getPattern();

refParam =

;

*argExpr =

.getAsExpr();

paramType = SubstParamType();

(paramType.

())

VD = cast_or_null<ValueDecl>(

paramType =

.getNonTypeTemplateArgumentType();

assert(!paramType.

() &&

);

assert(!paramType->

() &&

);

paramType =

.getNonTypeTemplateArgumentType();

*resultExpr = result.

();

AssociatedDecl, parm->

(), PackIndex, refParam);

TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(

transformNonTypeTemplateParmRef(

->getAssociatedDecl(),

->getParameterPack(),

->getParameterPackLocation(), Arg, getPackIndex(Pack));

TemplateInstantiator::TransformSubstNonTypeTemplateParmExpr(

SubstReplacement =

->getReplacement();

(!isa<ConstantExpr>(SubstReplacement.

()))

SubstReplacement = TransformExpr(

->getReplacement());

SugaredConverted, CanonicalConverted,

transformNonTypeTemplateParmRef(

->getAssociatedDecl(),

SugaredConverted,

->getPackIndex());

getSema().BuildDeclarationNameExpr(

(), NameInfo, PD);

RebuildVarDeclRefExpr(VD,

->

());

Vars.reserve(

->getNumExpansions());

Vars.push_back(

);

->getParameterPackLocation(), Vars);

getSema().MarkFunctionParmPackReferenced(PackExpr);

TemplateInstantiator::TransformFunctionParmPackRefExpr(

*

,

llvm::PointerUnion<Decl *, DeclArgumentPack *> *

= getSema().CurrentInstantiationScope->findInstantiationOf(PD);

assert(

&&

);

*TransformedDecl;

(DeclArgumentPack *Pack =

->dyn_cast<DeclArgumentPack *>()) {

getSema().MarkFunctionParmPackReferenced(PackExpr);

TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];

TransformedDecl = cast<Decl *>(*

);

RebuildVarDeclRefExpr(cast<VarDecl>(TransformedDecl),

->

());

TemplateInstantiator::TransformDeclRefExpr(

*

) {

TransformTemplateParmRefExpr(

, NTTP);

(

*PD = dyn_cast<VarDecl>(

))

TransformFunctionParmPackRefExpr(

, PD);

BD = cast_or_null<BindingDecl>(TransformDecl(BD->getLocation(), BD));

dyn_cast_if_present<ResolvedUnexpandedPackExpr>(BD->getBinding()))

TransformResolvedUnexpandedPackExpr(RP);

inherited::TransformDeclRefExpr(

);

TemplateInstantiator::TransformCXXDefaultArgExpr(

assert(!cast<FunctionDecl>(

->getParam()->getDeclContext())->

getDescribedFunctionTemplate() &&

);

->getUsedLocation(), cast<FunctionDecl>(

->getParam()->getDeclContext()),

<

Fn>

Fn TransformExceptionSpec) {

std::optional<LocalInstantiationScope>

;

(!Current || !Current->isLambdaOrBlock())

inherited::TransformFunctionProtoType(

TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);

*TemplateInstantiator::TransformFunctionTypeParam(

std::optional<unsigned> NumExpansions,

ExpectParameterPack) {

OldParm, TemplateArgs, indexAdjustment, NumExpansions,

ExpectParameterPack, EvaluateConstraints);

TemplateInstantiator::BuildSubstTemplateTypeParmType(

*AssociatedDecl,

Index, std::optional<unsigned> PackIndex,

(SuppressObjCLifetime) {

RQs = Replacement.getQualifiers();

= getSema().Context.getSubstTemplateTypeParmType(

Replacement, AssociatedDecl, Index, PackIndex);

TemplateInstantiator::TransformTemplateTypeParmType(

&TLB,

SuppressObjCLifetime) {

IsIncomplete =

;

(BailOutOnIncomplete)

);

);

[AssociatedDecl, Final] =

std::optional<unsigned> PackIndex;

(

->isParameterPack()) {

);

= getSema().Context.getSubstTemplateTypeParmPackType(

AssociatedDecl,

->getIndex(), Final, Arg);

PackIndex = getPackIndex(Arg);

);

BuildSubstTemplateTypeParmType(TLB, SuppressObjCLifetime, Final,

AssociatedDecl,

->getIndex(),

NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(

TransformDecl(TL.

(), OldTTPDecl));

->isParameterPack(), NewTTPDecl);

TemplateInstantiator::TransformResolvedUnexpandedPackExpr(

->getNumExprs() &&

);

TransformExpr(

inherited::TransformResolvedUnexpandedPackExpr(

);

TemplateInstantiator::TransformSubstTemplateTypeParmPackType(

SuppressObjCLifetime) {

*NewReplaced = TransformDecl(TL.

(),

->getAssociatedDecl());

(NewReplaced !=

->getAssociatedDecl())

= getSema().Context.getSubstTemplateTypeParmPackType(

NewReplaced,

->getIndex(),

->getFinal(),

->getArgumentPack());

BuildSubstTemplateTypeParmType(

TLB, SuppressObjCLifetime,

->getFinal(), NewReplaced,

->getIndex(),

ErrorLoc = PDA.first;

llvm::raw_svector_ostream

(Entity);

.backupStr(Entity), ErrorLoc,

.backupStr(Message)};

llvm::raw_svector_ostream

(Entity);

.backupStr(Entity),

Location,

StringRef()};

TemplateInstantiator::TransformRequiresTypeParams(

(getDerived().TransformFunctionTypeParams(

KWLoc, Params,

,

, PTypes,

&TransParams, PInfos, &ErrorIdx) ||

Trap.hasErrorOccurred()) {

, Info, [&](llvm::raw_ostream &

) {

<< *FailedDecl; })));

getDerived().RebuildRequiresExpr(KWLoc, Body, RE->

(),

TransReqs, RBraceLoc);

(AlwaysRebuild())

RebuildTypeRequirement(

(TypeInst.isInvalid())

(!TransType || Trap.hasErrorOccurred())

[&] (llvm::raw_ostream&

) {

RebuildTypeRequirement(TransType);

llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *>

(ExprInst.isInvalid())

(!TransExprRes.

() && !Trap.hasErrorOccurred() &&

(TransExprRes.

() || Trap.hasErrorOccurred())

TransExpr = TransExprRes.

();

std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq;

(RetReq.isEmpty())

TransRetReq.emplace();

(RetReq.isSubstitutionFailure())

TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());

(RetReq.isTypeConstraint()) {

RetReq.getTypeConstraintTemplateParameterList();

(TPLInst.isInvalid())

(!TPL || Trap.hasErrorOccurred())

[&] (llvm::raw_ostream&

) {

RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint()

TransRetReq.emplace(TPL);

assert(TransRetReq &&

);

(

*

= TransExpr.dyn_cast<

*>())

std::move(*TransRetReq));

RebuildExprRequirement(

cast<concepts::Requirement::SubstitutionDiagnostic *>(TransExpr),

TemplateInstantiator::TransformNestedRequirement(

(AlwaysRebuild())

(!getEvaluateConstraints()) {

(TransConstraint.

() || !TransConstraint.

())

(ConstrInst.isInvalid())

, {Req->getConstraintExpr()},

, TemplateArgs,

TransConstraint =

[0];

assert(!Trap.hasErrorOccurred() &&

);

(TransConstraint.

() &&

(TransConstraint.

() || !TransConstraint.

() ||

llvm::raw_svector_ostream

(Entity);

AllowDeducedTST) {

);

TemplateInstantiator Instantiator(*

, Args,

, Entity);

AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(

)

: Instantiator.TransformType(

);

);

TemplateInstantiator Instantiator(*

, Args,

, Entity);

*IsIncompleteSubstitution) {

);

TemplateInstantiator Instantiator(

*

, TemplateArgs,

, Entity,

IsIncompleteSubstitution !=

);

QT = Instantiator.TransformType(

);

(IsIncompleteSubstitution && Instantiator.getIsIncomplete())

*IsIncompleteSubstitution =

;

TL =

->getTypeLoc().IgnoreParens();

(!

)

;

EvaluateConstraints) {

);

TemplateInstantiator Instantiator(*

, Args,

, Entity);

Instantiator.setEvaluateConstraints(EvaluateConstraints);

= Instantiator.TransformFunctionProtoType(

TLB, Proto, ThisContext, ThisTypeQuals,

&Changed) {

; });

= Instantiator.TransformType(TLB, TL);

Changed =

;

Instantiator.TransformExceptionSpec(

, ESI, ExceptionStorage,

ESI, ExceptionStorage, Args))

GetContainedInventedTypeParmVisitor :

<GetContainedInventedTypeParmVisitor,

TemplateTypeParmDecl *> {

<GetContainedInventedTypeParmVisitor,

Visit(

.getTypePtr());

(!

->getDecl() || !

->getDecl()->isImplicit())

->getDecl();

Visit(

->getNamedType());

Visit(

->getPointeeTypeAsWritten());

Visit(

->getElementType());

Visit(

->getElementType());

Visit(

->getElementType());

VisitFunctionType(

);

Visit(

->getInnerType());

Visit(

->getModifiedType());

Visit(

->getUnderlyingType());

Visit(

->getOriginalType());

Visit(

->getPattern());

ExpandPackedTypeConstraints

ExpandPackedTypeConstraints(

: inherited(SemaRef), TemplateArgs(TemplateArgs) {}

inherited::TransformTemplateTypeParmType;

(!

->isParameterPack()) {

std::optional<unsigned> PackIndex;

TL.

(),

->getDecl(),

->getIndex(), PackIndex,

SubstTemplateTypeParmTypeFlag::ExpandPacksInPlace);

(

->getPackIndex()) {

inherited::TransformSubstTemplateTypeParmType(TLB, TL);

inherited::TransformTemplateArguments(Args.begin(), Args.end(), Out);

EvaluateConstraints) {

(!EvaluateConstraints) {

ShouldExpandExplicitTemplateArgs =

llvm::any_of(TemplArgInfo->

(), [](

&Arg) {

return Arg.getArgument().containsUnexpandedParameterPack();

(ShouldExpandExplicitTemplateArgs) {

(ExpandPackedTypeConstraints(*

, TemplateArgs)

(

*FE = dyn_cast<CXXFoldExpr>(ConstraintExpr)) {

assert(FE->getLHS());

ConstraintExpr = FE->getLHS();

*CSE = cast<ConceptSpecializationExpr>(ConstraintExpr);

assert(!CSE->getTemplateArguments().empty() &&

);

ConstrainedType = CSE->getTemplateArguments()[0].getAsType();

assert(!ConstrainedType.

() &&

);

Inst, ConstrainedType,

indexAdjustment, std::optional<unsigned> NumExpansions,

ExpectParameterPack,

EvaluateConstraint) {

NewDI =

(ExpansionTL.getPatternLoc(), TemplateArgs,

}

(ExpectParameterPack) {

diag::err_function_parameter_pack_without_parameter_packs)

GetContainedInventedTypeParmVisitor().Visit(OldDI->

())) {

*Inst = cast_or_null<TemplateTypeParmDecl>(

(Inst && !Inst->getTypeConstraint()) {

);

TemplateInstantiator Instantiator(*

, TemplateArgs,

,

Instantiator.TransformFunctionTypeParams(

, Params,

, ExtParamInfos, ParamTypes, OutParams, ParamInfos);

(Param->

(), diag::err_recursive_default_argument) << FD;

std::unique_ptr<LocalInstantiationScope> LIS;

LIS = std::make_unique<LocalInstantiationScope>(*

);

(addInstantiatedParametersToScope(FD, PatternFD, *LIS, TemplateArgs))

(

.isInvalid())

= InitSeq.Perform(*

, Entity, Kind, ResultE);

(

.isInvalid())

(

.isInvalid())

(

&

: Pattern->

()) {

(!

.getType()->isDependentType()) {

(RD->isInvalidDecl())

(

.isPackExpansion()) {

ShouldExpand =

;

RetainExpansion =

;

std::optional<unsigned> NumExpansions;

.getSourceRange(),

TemplateArgs, ShouldExpand,

(

I = 0; I != *NumExpansions; ++I) {

.getSourceRange().getBegin(),

.getSourceRange(),

.getAccessSpecifierAsWritten(),

InstantiatedBases.push_back(InstantiatedBase);

EllipsisLoc =

.getEllipsisLoc();

.getSourceRange().getBegin(),

.getSourceRange().getBegin(),

.getSourceRange(),

.getAccessSpecifierAsWritten(),

InstantiatedBases.push_back(InstantiatedBase);

Pattern, PatternDef, TSK, Complain))

llvm::TimeTraceScope TimeScope(

, [&]() {

llvm::TimeTraceMetadata M;

llvm::raw_string_ostream

(M.Detail);

(llvm::isTimeTraceVerbose()) {

Pattern = PatternDef;

MSInfo->setPointOfInstantiation(PointOfInstantiation);

= dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {

Spec->setTemplateSpecializationKind(TSK);

Spec->setPointOfInstantiation(PointOfInstantiation);

);

SavePendingParsedClassStateRAII SavedPendingParsedClassState(*

);

MightHaveConstexprVirtualFunctions =

;

(

->getDeclContext() != Pattern)

(isa<BlockDecl>(

) ||

(isa<CXXRecordDecl>(

) && cast<CXXRecordDecl>(

)->isLambda()))

(

->isInvalidDecl()) {

(

*Field = dyn_cast<FieldDecl>(NewMember)) {

Fields.push_back(Field);

}

(

*

= dyn_cast<EnumDecl>(NewMember)) {

->isCompleteDefinition()) {

assert(MSInfo &&

);

}

(

*SA = dyn_cast<StaticAssertDecl>(NewMember)) {

(SA->isFailed()) {

}

(

*MD = dyn_cast<CXXMethodDecl>(NewMember)) {

MightHaveConstexprVirtualFunctions =

;

(ParsingClassDepth == 0)

(LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),

= LateAttrs.end(); I !=

; ++I) {

*ND = cast<NamedDecl>(I->NewDecl);

*ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());

ND->isCXXInstanceMember());

I->NewDecl->addAttr(NewAttr);

->first,

->second)) {

->first,

->second)) {

SavedContext.

();

(MightHaveConstexprVirtualFunctions)

Pattern, PatternDef, TSK,

))

Pattern = PatternDef;

MSInfo->setPointOfInstantiation(PointOfInstantiation);

);

SavedContext.

();

);

(PointOfInstantiation,

diag::err_default_member_initializer_not_yet_parsed)

<< OutermostClass << Pattern;

(Pattern->getEndLoc(),

diag::note_default_member_initializer_not_yet_parsed);

(PointOfInstantiation, diag::err_default_member_initializer_cycle)

);

PointOfInstantiation, Instantiation,

};

assert((!

|| !isa<ParenListExpr>(

)) &&

);

L->DefaultMemberInitializerInstantiated(Instantiation);

PartialSpecMatchResult {

!CTPSD->getMostRecentDecl()->isMemberSpecialization())

PrimaryHasMatchedPackOnParmToNonPackOnArg) {

(!isa<ClassTemplatePartialSpecializationDecl *>(Specialized)) {

!Partial->getMostRecentDecl()->isMemberSpecialization())

(Matched.empty() && PrimaryHasMatchedPackOnParmToNonPackOnArg)

Matched = std::move(ExtraMatched);

(Matched.size() >= 1) {

(Matched.size() == 1) {

PEnd = Matched.end();

->Partial, Best->Partial, PointOfInstantiation) ==

Ambiguous =

;

PEnd = Matched.end();

->Partial, Best->Partial,

PointOfInstantiation) != Best->Partial) {

S.

(PointOfInstantiation,

diag::err_partial_spec_ordering_ambiguous)

<< ClassTemplateSpec;

PEnd = Matched.end();

S.

(

->Partial->getLocation(), diag::note_partial_spec_match)

->Partial->getTemplateParameters(), *

->Args);

(

*PartialSpec =

(PartialSpec->getInstantiatedFromMember()) {

(PartialSpec->isMemberSpecialization())

PartialSpec = PartialSpec->getInstantiatedFromMember();

Pattern = PartialSpec;

PrimaryHasMatchedPackOnParmToNonPackOnArg) {

ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(

*

, PointOfInstantiation, ClassTemplateSpec, TSK,

PrimaryHasMatchedPackOnParmToNonPackOnArg);

PointOfInstantiation, ClassTemplateSpec, Pattern.

(),

);

(

*

: Instantiation->

()) {

SuppressNew =

;

(

*

= dyn_cast<FunctionDecl>(

)) {

->getInstantiatedFromMemberFunction()) {

(

->isIneligibleOrNotSelected())

(

->getTrailingRequiresClause()) {

(

->hasAttr<ExcludeFromExplicitInstantiationAttr>())

->getTemplateSpecializationKind();

PointOfInstantiation, TSK,

, PrevTSK,

->getPointOfInstantiation(), SuppressNew) ||

->setTemplateSpecializationKind(TSK, PointOfInstantiation);

std::make_pair(

, PointOfInstantiation));

}

(

*Var = dyn_cast<VarDecl>(

)) {

(isa<VarTemplateSpecializationDecl>(Var))

(Var->

<ExcludeFromExplicitInstantiationAttr>())

assert(MSInfo &&

);

}

(

*

= dyn_cast<CXXRecordDecl>(

)) {

(

->hasAttr<ExcludeFromExplicitInstantiationAttr>())

(

->isInjectedClassName() ||

->getPreviousDecl() ||

assert(MSInfo &&

);

assert(Pattern &&

);

(!

->getDefinition()) {

->getTemplateSpecializationKind() ==

->setTemplateSpecializationKind(TSK);

Pattern = cast_or_null<CXXRecordDecl>(

->getDefinition());

}

(

*

= dyn_cast<EnumDecl>(

)) {

assert(MSInfo &&

);

PointOfInstantiation, TSK,

,

(

->getDefinition())

*Pattern =

->getTemplateInstantiationPattern();

assert(Pattern &&

);

}

(

*Field = dyn_cast<FieldDecl>(

)) {

ClassPattern->

(Field->getDeclName());

TemplateInstantiator Instantiator(*

, TemplateArgs,

Instantiator.TransformStmt(S);

TemplateInstantiator Instantiator(*

, TemplateArgs,

, Entity);

Instantiator.TransformTemplateArgument(Input, Output);

TemplateInstantiator Instantiator(*

, TemplateArgs,

(),

Instantiator.TransformTemplateArguments(Args.begin(), Args.end(), Out);

TemplateInstantiator Instantiator(*

, TemplateArgs,

Instantiator.TransformExpr(

);

TemplateInstantiator Instantiator(*

, TemplateArgs,

(),

Instantiator.setEvaluateConstraints(

);

Instantiator.TransformExpr(

);

CXXDirectInit) {

TemplateInstantiator Instantiator(*

, TemplateArgs,

(),

Instantiator.TransformInitializer(

, CXXDirectInit);

TemplateInstantiator Instantiator(*

, TemplateArgs,

Instantiator.TransformExprs(Exprs.data(), Exprs.size(),

TemplateInstantiator Instantiator(*

, TemplateArgs, NNS.

(),

Instantiator.TransformNestedNameSpecifierLoc(NNS);

TemplateInstantiator Instantiator(*

, TemplateArgs, NameInfo.

(),

Instantiator.TransformDeclarationNameInfo(NameInfo);

TemplateInstantiator Instantiator(*

, TemplateArgs,

,

SS.

(QualifierLoc);

Instantiator.TransformTemplateName(SS, Name,

);

(

*PV = dyn_cast<ParmVarDecl>(

)) {

(

*FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {

i = PV->getFunctionScopeIndex();

(i < FD->getNumParams() && FD->getParamDecl(i) == PV)

llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *

Current = Current->Outer) {

*CheckD =

;

LocalDeclsMap::iterator

= Current->LocalDecls.find(CheckD);

(

!= Current->LocalDecls.end())

&

->second;

(

*Tag = dyn_cast<TagDecl>(CheckD))

CheckD = Tag->getPreviousDecl();

(!Current->CombineWithOuterScope)

(isa<NonTypeTemplateParmDecl>(

) || isa<TemplateTypeParmDecl>(

) ||

isa<TemplateTemplateParmDecl>(

))

(RD->isLocalClass())

(isa<EnumDecl>(

))

(isa<TypedefNameDecl>(

) &&

assert(isa<LabelDecl>(

) &&

);

llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[

];

(Stored.isNull()) {

(Current->CombineWithOuterScope && Current->Outer) {

Current = Current->Outer;

assert(!Current->LocalDecls.contains(

) &&

);

}

(

*Pack = dyn_cast<DeclArgumentPack *>(Stored)) {

Pack->push_back(cast<VarDecl>(Inst));

assert(cast<Decl *>(Stored) == Inst &&

);

Pack->push_back(Inst);

Current && Current->CombineWithOuterScope; Current = Current->Outer)

assert(!Current->LocalDecls.contains(

) &&

);

llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[

];

ArgumentPacks.push_back(Pack);

(llvm::is_contained(*Pack,

))

NumExplicitArgs) {

assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&

);

assert((!PartiallySubstitutedPack

|| NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&

);

PartiallySubstitutedPack = Pack;

ArgsInPartiallySubstitutedPack = ExplicitArgs;

NumArgsInPartiallySubstitutedPack = NumExplicitArgs;

*NumExplicitArgs)

{

*ExplicitArgs =

;

(NumExplicitArgs)

*NumExplicitArgs = 0;

Current = Current->Outer) {

(Current->PartiallySubstitutedPack) {

*ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;

(NumExplicitArgs)

*NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;

Current->PartiallySubstitutedPack;

(!Current->CombineWithOuterScope)

This file provides AST data structures related to concepts.

Defines the clang::ASTContext interface.

This file provides some common utility functions for processing Lambda related AST Constructs.

Defines the C++ template declaration subclasses.

Defines Expressions and AST nodes for C++2a concepts.

static void print(llvm::raw_ostream &OS, const T &V, ASTContext &ASTCtx, QualType Ty)

Defines the clang::LangOptions interface.

llvm::MachO::Record Record

MatchFinder::MatchResult MatchResult

static const Decl * getCanonicalParmVarDecl(const Decl *D)

static ActionResult< CXXRecordDecl * > getPatternForClassTemplateSpecialization(Sema &S, SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool PrimaryHasMatchedPackOnParmToNonPackOnArg)

Get the instantiation pattern to use to instantiate the definition of a given ClassTemplateSpecializa...

static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T)

static concepts::Requirement::SubstitutionDiagnostic * createSubstDiag(Sema &S, TemplateDeductionInfo &Info, Sema::EntityPrinter Printer)

static std::string convertCallArgsToString(Sema &S, llvm::ArrayRef< const Expr * > Args)

static TemplateArgument getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg)

Defines the clang::TypeLoc interface and its subclasses.

C Language Family Type Representation.

virtual void HandleTagDeclDefinition(TagDecl *D)

HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.

virtual bool HandleTopLevelDecl(DeclGroupRef D)

HandleTopLevelDecl - Handle the specified top-level declaration.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

TranslationUnitDecl * getTranslationUnitDecl() const

QualType getTagDeclType(const TagDecl *Decl) const

Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.

bool hasSameType(QualType T1, QualType T2) const

Determine whether the given types T1 and T2 are equivalent.

QualType getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, unsigned Index, std::optional< unsigned > PackIndex, SubstTemplateTypeParmTypeFlag Flag=SubstTemplateTypeParmTypeFlag::None) const

Retrieve a substitution-result type.

QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const

Return the unique reference to the type for the specified type declaration.

QualType getQualifiedType(SplitQualType split) const

Un-split a SplitQualType.

const clang::PrintingPolicy & getPrintingPolicy() const

const TargetInfo & getTargetInfo() const

Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.

Represents an array type, per C99 6.7.5.2 - Array Declarators.

Attr - This represents one attribute.

An attributed type is a type to which a type attribute has been applied.

A binding in a decomposition declaration.

BlockExpr - Adaptor class for mixing a BlockDecl with expressions.

Represents a base class of a C++ class.

A default argument (C++ [dcl.fct.default]).

Represents a static or instance method of a struct/union/class.

Represents a C++ struct/union/class.

Decl * getLambdaContextDecl() const

Retrieve the declaration that provides additional context for a lambda, when the normal declaration c...

const FunctionDecl * isLocalClass() const

If the class is a local class [class.local], returns the enclosing function declaration.

CXXRecordDecl * getInstantiatedFromMemberClass() const

If this record is an instantiation of a member class, retrieves the member class from which it was in...

bool isLambda() const

Determine whether this class describes a lambda function object.

CXXRecordDecl * getDefinition() const

unsigned getNumBases() const

Retrieves the number of base classes of this class.

const CXXRecordDecl * getTemplateInstantiationPattern() const

Retrieve the record declaration from which this record could be instantiated.

TemplateSpecializationKind getTemplateSpecializationKind() const

Determine whether this particular class is a specialization or instantiation of a class template or m...

ClassTemplateDecl * getDescribedClassTemplate() const

Retrieves the class template that is described by this class declaration.

MemberSpecializationInfo * getMemberSpecializationInfo() const

If this class is an instantiation of a member class of a class template specialization,...

CXXMethodDecl * getLambdaCallOperator() const

Retrieve the lambda call operator of the closure type if this is a closure type.

CXXRecordDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

void setTemplateSpecializationKind(TemplateSpecializationKind TSK)

Set the kind of specialization or template instantiation this is.

Represents a C++ nested-name-specifier or a global scope specifier.

void Adopt(NestedNameSpecifierLoc Other)

Adopt an existing nested-name-specifier (with source-range information).

Declaration of a class template.

ClassTemplateDecl * getMostRecentDecl()

CXXRecordDecl * getTemplatedDecl() const

Get the underlying class declarations of the template.

llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations() const

Retrieve the set of partial specializations of this class template.

ClassTemplateDecl * getInstantiatedFromMemberTemplate() const

Represents a class template specialization, which refers to a class template with a given set of temp...

TemplateSpecializationKind getSpecializationKind() const

Determine the kind of specialization that this declaration represents.

ClassTemplateDecl * getSpecializedTemplate() const

Retrieve the template that this specialization specializes.

bool isClassScopeExplicitSpecialization() const

Is this an explicit specialization at class scope (within the class that owns the primary template)?...

llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const

Retrieve the class template or class template partial specialization which was specialized by this.

const TemplateArgumentList & getTemplateArgs() const

Retrieve the template arguments of the class template specialization.

const TemplateArgumentList & getTemplateInstantiationArgs() const

Retrieve the set of template arguments that should be used to instantiate members of the class templa...

void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)

Note that this class template specialization is actually an instantiation of the given class template...

NamedDecl * getFoundDecl() const

The result of a constraint satisfaction check, containing the necessary information to diagnose an un...

bool HasSubstitutionFailure()

static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)

The results of name lookup within a DeclContext.

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

bool isFileContext() const

bool isDependentContext() const

Determines whether this context is dependent on a template parameter.

lookup_result lookup(DeclarationName Name) const

lookup - Find the declarations (if any) with the given Name in this context.

RecordDecl * getOuterLexicalRecordContext()

Retrieve the outermost lexically enclosing record context.

decl_range decls() const

decls_begin/decls_end - Iterate over the declarations stored in this context.

A reference to a declared variable, function, enum, etc.

Decl - This represents one declaration (or definition), e.g.

TemplateDecl * getDescribedTemplate() const

If this is a declaration that describes some template, this method returns that template declaration.

FriendObjectKind getFriendObjectKind() const

Determines whether this declaration is the object of a friend declaration and, if so,...

bool isParameterPack() const

Whether this declaration is a parameter pack.

void setInvalidDecl(bool Invalid=true)

setInvalidDecl - Indicates the Decl had a semantic error.

bool isFileContextDecl() const

static Decl * castFromDeclContext(const DeclContext *)

unsigned getTemplateDepth() const

Determine the number of levels of template parameter surrounding this declaration.

DeclContext * getNonTransparentDeclContext()

Return the non transparent context.

bool isInvalidDecl() const

SourceLocation getLocation() const

void setLocation(SourceLocation L)

bool isDefinedOutsideFunctionOrMethod() const

isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...

DeclContext * getDeclContext()

void setDeclContext(DeclContext *DC)

setDeclContext - Set both the semantic and lexical DeclContext to DC.

DeclContext * getLexicalDeclContext()

getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).

virtual Decl * getCanonicalDecl()

Retrieves the "canonical" declaration of the given declaration.

void setVisibleDespiteOwningModule()

Set that this declaration is globally visible, even if it came from a module that is not visible.

The name of a declaration.

NestedNameSpecifier * getQualifier() const

Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...

SourceLocation getInnerLocStart() const

Return start of source range ignoring outer template declarations.

SourceLocation getOuterLocStart() const

Return start of source range taking into account any outer template declarations.

SourceLocation getBeginLoc() const LLVM_READONLY

TypeSourceInfo * getTypeSourceInfo() const

Information about one declarator, including the parsed type information and the identifier.

Represents an extended vector type where either the type or size is dependent.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

bool hasFatalErrorOccurred() const

unsigned getTemplateBacktraceLimit() const

Retrieve the maximum number of template instantiation notes to emit along with a given diagnostic.

Recursive AST visitor that supports extension via dynamic dispatch.

Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...

RAII object that enters a new expression evaluation context.

MemberSpecializationInfo * getMemberSpecializationInfo() const

If this enumeration is an instantiation of a member enumeration of a class template specialization,...

void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())

For an enumeration member that was instantiated from a member enumeration of a templated class,...

EnumDecl * getInstantiatedFromMemberEnum() const

Returns the enumeration (declared within the template) from which this enumeration type was instantia...

EnumDecl * getDefinition() const

This represents one expression.

ExprValueKind getValueKind() const

getValueKind - The value kind that this expression produces.

bool isTypeDependent() const

Determines whether the type of this expression depends on.

llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const

EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.

bool isLValue() const

isLValue - True if this expression is an "l-value" according to the rules of the current language.

bool isInstantiationDependent() const

Whether this expression is instantiation-dependent, meaning that it depends in some way on.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

bool hasPlaceholderType() const

Returns whether this expression has a placeholder type.

ExprDependence getDependence() const

Represents a member of a struct/union/class.

Expr * getInClassInitializer() const

Get the C++11 default member initializer for this member, or null if one has not been set.

bool hasInClassInitializer() const

Determine whether this member has a C++11 default member initializer.

InClassInitStyle getInClassInitStyle() const

Get the kind of (C++11) default member initializer that this field has.

const RecordDecl * getParent() const

Returns the parent of this field declaration, which is the struct in which this field is defined.

static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)

Create a code modification hint that replaces the given source range with the given code string.

Represents a function declaration or definition.

ArrayRef< ParmVarDecl * > parameters() const

FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const

Retrieve the function declaration from which this function could be instantiated, if it is an instant...

FunctionTemplateDecl * getPrimaryTemplate() const

Retrieve the primary template that this function template specialization either specializes or was in...

bool isConstexpr() const

Whether this is a (C++11) constexpr function or constexpr constructor.

bool isVirtualAsWritten() const

Whether this function is marked as virtual explicitly.

Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...

VarDecl *const * iterator

Iterators over the parameters which the parameter pack expanded into.

static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, VarDecl *ParamPack, SourceLocation NameLoc, ArrayRef< VarDecl * > Params)

Represents a prototype with parameter type info, e.g.

ExtProtoInfo getExtProtoInfo() const

Declaration of a template function.

FunctionDecl * getTemplatedDecl() const

Get the underlying function declaration of the template.

ArrayRef< ParmVarDecl * > getParams() const

Interesting information about a specific parameter that can't simply be reflected in parameter's type...

FunctionType - C99 6.7.5.3 - Function Declarators.

QualType getReturnType() const

One of these records is kept for each identifier that is lexed.

ArrayRef< TemplateArgument > getTemplateArguments() const

const TypeClass * getTypePtr() const

Describes the kind of initialization being performed, along with location information for tokens rela...

static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)

Create a copy initialization.

Describes the sequence of initializations required to initialize a given object or reference with a s...

Describes an entity that is being initialized.

static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)

Create the initialization entity for a parameter.

Wrapper for source info for injected class names of class templates.

The injected class name of a C++ class template or class template partial specialization.

A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...

A stack-allocated class that identifies which local variable declaration instantiations are present i...

void SetPartiallySubstitutedPack(NamedDecl *Pack, const TemplateArgument *ExplicitArgs, unsigned NumExplicitArgs)

Note that the given parameter pack has been partially substituted via explicit specification of templ...

NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const

Retrieve the partially-substitued template parameter pack.

bool isLocalPackExpansion(const Decl *D)

Determine whether D is a pack expansion created in this scope.

static void deleteScopes(LocalInstantiationScope *Scope, LocalInstantiationScope *Outermost)

deletes the given scope, and all outer scopes, down to the given outermost scope.

void InstantiatedLocal(const Decl *D, Decl *Inst)

void InstantiatedLocalPackArg(const Decl *D, VarDecl *Inst)

void MakeInstantiatedLocalArgPack(const Decl *D)

llvm::PointerUnion< Decl *, DeclArgumentPack * > * findInstantiationOf(const Decl *D)

Find the instantiation of the declaration D within the current instantiation scope.

Sugar type that represents a type that was qualified by a qualifier written as a macro invocation.

A pointer to member type per C++ 8.3.3 - Pointers to members.

Provides information a specialization of a member of a class template, which may be a member function...

void setTemplateSpecializationKind(TemplateSpecializationKind TSK)

Set the template specialization kind.

TemplateSpecializationKind getTemplateSpecializationKind() const

Determine what kind of template specialization this is.

SourceLocation getPointOfInstantiation() const

Retrieve the first point of instantiation of this member.

void setPointOfInstantiation(SourceLocation POI)

Set the first point of instantiation.

Describes a module or submodule.

Data structure that captures multiple levels of template argument lists for use in template instantia...

bool hasTemplateArgument(unsigned Depth, unsigned Index) const

Determine whether there is a non-NULL template argument at the given depth and index.

const ArgList & getInnermost() const

Retrieve the innermost template argument list.

std::pair< Decl *, bool > getAssociatedDecl(unsigned Depth) const

A template-like entity which owns the whole pattern being substituted.

unsigned getNumLevels() const

Determine the number of levels in this template argument list.

unsigned getNumSubstitutedLevels() const

Determine the number of substituted levels in this template argument list.

unsigned getNewDepth(unsigned OldDepth) const

Determine how many of the OldDepth outermost template parameter lists would be removed by substitutin...

void setArgument(unsigned Depth, unsigned Index, TemplateArgument Arg)

Clear out a specific template argument.

bool isRewrite() const

Determine whether we are rewriting template parameters rather than substituting for them.

This represents a decl that may have a name.

IdentifierInfo * getIdentifier() const

Get the identifier that names this declaration, if there is one.

StringRef getName() const

Get the name of identifier for this declaration as a StringRef.

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const

Appends a human-readable name for this declaration into the given stream.

virtual void printName(raw_ostream &OS, const PrintingPolicy &Policy) const

Pretty-print the unqualified name of this declaration.

A C++ nested-name-specifier augmented with source location information.

SourceLocation getBeginLoc() const

Retrieve the location of the beginning of this nested-name-specifier.

Represents a C++ nested name specifier, such as "\::std::vector<int>::".

bool isInstantiationDependent() const

Whether this nested name specifier involves a template parameter.

NestedNameSpecifier * getPrefix() const

Return the prefix of this nested name specifier.

const Type * getAsType() const

Retrieve the type stored in this nested name specifier.

NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.

QualType getExpansionType(unsigned I) const

Retrieve a particular expansion type within an expanded parameter pack.

unsigned getPosition() const

Get the position of the template parameter within its parameter list.

bool isExpandedParameterPack() const

Whether this parameter is a non-type template parameter pack that has a known list of different types...

bool isParameterPack() const

Whether this parameter is a non-type template parameter pack.

unsigned getIndex() const

Get the index of the template parameter within its parameter list.

unsigned getDepth() const

Get the nesting depth of the template parameter.

Represents a pack expansion of types.

Sugar for parentheses used when specifying types.

Represents a parameter to a function.

unsigned getFunctionScopeIndex() const

Returns the index of this parameter in its prototype or method scope.

void setDefaultArg(Expr *defarg)

SourceLocation getExplicitObjectParamThisLoc() const

void setUnparsedDefaultArg()

Specify that this parameter has an unparsed default argument.

bool hasUnparsedDefaultArg() const

Determines whether this parameter has a default argument that has not yet been parsed.

void setUninstantiatedDefaultArg(Expr *arg)

void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)

bool hasUninstantiatedDefaultArg() const

bool hasInheritedDefaultArg() const

void setExplicitObjectParameterLoc(SourceLocation Loc)

Expr * getUninstantiatedDefaultArg()

unsigned getFunctionScopeDepth() const

void setHasInheritedDefaultArg(bool I=true)

PointerType - C99 6.7.5.1 - Pointer Declarators.

[C99 6.4.2.2] - A predefined identifier such as func.

PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...

A (possibly-)qualified type.

QualType getNonLValueExprType(const ASTContext &Context) const

Determine the type of a (typically non-lvalue) expression with the specified result type.

void addConst()

Add the const type qualifier to this QualType.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

QualType getNonReferenceType() const

If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...

The collection of all-type qualifiers we support.

void removeObjCLifetime()

Represents a struct/union/class.

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

bool isMemberSpecialization() const

Determines whether this template was a specialization of a member template.

Base for LValueReferenceType and RValueReferenceType.

Represents the body of a requires-expression.

C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...

SourceLocation getLParenLoc() const

SourceLocation getRParenLoc() const

Scope - A scope is a transient data structure that is used while parsing the program.

SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)

Emit a diagnostic.

RAII object used to change the argument pack substitution index within a Sema object.

RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...

For a defaulted function, the kind of defaulted function that it is.

DefaultedComparisonKind asComparison() const

bool isSpecialMember() const

bool isComparison() const

CXXSpecialMemberKind asSpecialMember() const

A helper class for building up ExtParameterInfos.

RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...

Sema - This implements semantic analysis and AST building for C.

llvm::DenseSet< Module * > LookupModulesCache

Cache of additional modules that should be used for name lookup within the current template instantia...

bool SubstTypeConstraint(TemplateTypeParmDecl *Inst, const TypeConstraint *TC, const MultiLevelTemplateArgumentList &TemplateArgs, bool EvaluateConstraint)

SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts

List of active code synthesis contexts.

LocalInstantiationScope * CurrentInstantiationScope

The current instantiation scope used to store local variables.

TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)

Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.

DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD)

Determine the kind of defaulting that would be done for a given function.

bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef< UnexpandedParameterPack > Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, bool &RetainExpansion, std::optional< unsigned > &NumExpansions)

Determine whether we could expand a pack expansion with the given set of parameter packs into separat...

TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)

ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, std::optional< unsigned > NumExpansions, bool ExpectParameterPack, bool EvaluateConstraints=true)

void ActOnFinishCXXNonNestedClass()

NamedDecl * FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, bool FindingInstantiatedContext=false)

Find the instantiation of the given declaration within the current instantiation.

void ActOnFinishDelayedMemberInitializers(Decl *Record)

bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation, NamedDecl *Instantiation, bool InstantiatedFromMember, const NamedDecl *Pattern, const NamedDecl *PatternDef, TemplateSpecializationKind TSK, bool Complain=true)

Determine whether we would be unable to instantiate this template (because it either has no definitio...

void InstantiateClassTemplateSpecializationMembers(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK)

Instantiate the definitions of all of the members of the given class template specialization,...

ClassTemplatePartialSpecializationDecl * getMoreSpecializedPartialSpecialization(ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc)

Returns the more specialized class template partial specialization according to the rules of partial ...

llvm::DenseSet< std::pair< Decl *, unsigned > > InstantiatingSpecializations

Specializations whose definitions are currently being instantiated.

void deduceOpenCLAddressSpace(ValueDecl *decl)

ExprResult SubstInitializer(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs, bool CXXDirectInit)

llvm::function_ref< void(llvm::raw_ostream &)> EntityPrinter

void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)

concepts::Requirement::SubstitutionDiagnostic * createSubstDiagAt(SourceLocation Location, EntityPrinter Printer)

create a Requirement::SubstitutionDiagnostic with only a SubstitutedEntity and DiagLoc using ASTConte...

@ CTAK_Specified

The template argument was specified in the code or was instantiated with some deduced template argume...

bool SubstExprs(ArrayRef< Expr * > Exprs, bool IsCall, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< Expr * > &Outputs)

Substitute the given template arguments into a list of expressions, expanding pack expansions if requ...

StmtResult SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs)

bool InNonInstantiationSFINAEContext

Whether we are in a SFINAE context that is not associated with template instantiation.

ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)

DiagnosticsEngine & getDiagnostics() const

TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, std::optional< unsigned > NumExpansions)

Construct a pack expansion type from the pattern of the pack expansion.

ExprResult BuildExpressionFromNonTypeTemplateArgument(const TemplateArgument &Arg, SourceLocation Loc)

ExprResult SubstConstraintExprWithoutSatisfaction(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)

ASTContext & getASTContext() const

TypeSourceInfo * SubstType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, bool AllowDeducedTST=false)

Perform substitution on the type T with a given set of template arguments.

void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)

Instantiate the definition of the given variable from its template.

void ActOnStartCXXInClassMemberInitializer()

Enter a new C++ default initializer scope.

PrintingPolicy getPrintingPolicy() const

Retrieve a suitable printing policy for diagnostics.

bool SubstTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentListInfo &Outputs)

bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)

Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...

bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, CheckTemplateArgumentInfo &CTAI, CheckTemplateArgumentKind CTAK)

Check that the given template argument corresponds to the given template parameter.

void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)

const LangOptions & getLangOpts() const

bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, QualType ConstrainedType, SourceLocation EllipsisLoc)

Attach a type-constraint to a template parameter.

void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)

Collect the set of unexpanded parameter packs within the given template argument.

bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)

Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...

void InstantiateClassMembers(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)

Instantiates the definitions of all of the member of the given class, which is an instantiation of a ...

void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD, bool ConstexprOnly=false)

MarkVirtualMembersReferenced - Will mark all members of the given CXXRecordDecl referenced.

DeclarationNameInfo SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, const MultiLevelTemplateArgumentList &TemplateArgs)

Do template substitution on declaration name info.

void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)

Note that the vtable for the given class was used at the given location.

std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks

The template instantiation callbacks to trace or track instantiations (objects can be chained).

void PrintInstantiationStack()

Prints the current instantiation stack through a series of notes.

void popCodeSynthesisContext()

bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true, bool PrimaryHasMatchedPackOnParmToNonPackOnArg=false)

bool usesPartialOrExplicitSpecialization(SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec)

void pushCodeSynthesisContext(CodeSynthesisContext Ctx)

bool CheckLoopHintExpr(Expr *E, SourceLocation Loc, bool AllowZero)

std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const

Determines whether we are currently in a context where template argument substitution failures are no...

CXXBaseSpecifier * CheckBaseSpecifier(CXXRecordDecl *Class, SourceRange SpecifierRange, bool Virtual, AccessSpecifier Access, TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)

Check the validity of a C++ base class specifier.

UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations

A mapping from parameters with unparsed default arguments to the set of instantiations of each parame...

bool SubstParmTypes(SourceLocation Loc, ArrayRef< ParmVarDecl * > Params, const FunctionProtoType::ExtParameterInfo *ExtParamInfos, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< QualType > &ParamTypes, SmallVectorImpl< ParmVarDecl * > *OutParams, ExtParameterInfoBuilder &ParamInfos)

Substitute the given template arguments into the given set of parameters, producing the set of parame...

int ArgumentPackSubstitutionIndex

The current index into pack expansion arguments that will be used for substitution of parameter packs...

DeclContext * CurContext

CurContext - This is the current declaration context of parsing.

MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false, bool ForDefaultArgumentSubstitution=false)

Retrieve the template argument list(s) that should be used to instantiate the definition of the given...

std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations

The queue of implicit template instantiations that are required and must be performed within the curr...

ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, const IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)

bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)

Check whether the given function decl's trailing requires clause is satisfied, if any.

bool CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, TemplateSpecializationKind ActOnExplicitInstantiationNewTSK, NamedDecl *PrevDecl, TemplateSpecializationKind PrevTSK, SourceLocation PrevPtOfInstantiation, bool &SuppressNew)

Diagnose cases where we have an explicit template specialization before/after an explicit template in...

ExprResult CheckPlaceholderExpr(Expr *E)

Check for operands with placeholder types and complain if found.

unsigned NonInstantiationEntries

The number of CodeSynthesisContexts that are not template instantiations and, therefore,...

bool CheckNoInlineAttr(const Stmt *OrigSt, const Stmt *CurSt, const AttributeCommonInfo &A)

void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, ExprResult Init)

This is invoked after parsing an in-class initializer for a non-static C++ class member,...

bool CheckAlwaysInlineAttr(const Stmt *OrigSt, const Stmt *CurSt, const AttributeCommonInfo &A)

ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr)

BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed.

bool InstantiateInClassInitializer(SourceLocation PointOfInstantiation, FieldDecl *Instantiation, FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)

Instantiate the definition of a field from the given pattern.

bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)

Instantiate the definition of a class from a given pattern.

bool SubstTemplateArgument(const TemplateArgumentLoc &Input, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentLoc &Output, SourceLocation Loc={}, const DeclarationName &Entity={})

void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)

Instantiate the definition of the given function from its template.

bool SubstDefaultArgument(SourceLocation Loc, ParmVarDecl *Param, const MultiLevelTemplateArgumentList &TemplateArgs, bool ForCallExpr=false)

Substitute the given template arguments into the default argument.

ExprResult SubstConstraintExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)

bool hasUncompilableErrorOccurred() const

Whether uncompilable error has occurred.

@ ConstantEvaluated

The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...

@ PotentiallyEvaluated

The current expression is potentially evaluated at run time, which means that code may be generated t...

unsigned LastEmittedCodeSynthesisContextDepth

The depth of the context stack at the point when the most recent error or warning was produced.

NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)

void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)

bool RebuildingImmediateInvocation

Whether the AST is currently being rebuilt to correct immediate invocations.

void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record)

Perform semantic checks on a class definition that has been completing, introducing implicitly-declar...

SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts

A stack of expression evaluation contexts.

SourceManager & SourceMgr

DiagnosticsEngine & Diags

bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier * > Bases)

Performs the actual work of attaching the given base class specifiers to a C++ class.

SmallVector< Module *, 16 > CodeSynthesisContextLookupModules

Extra modules inspected when performing a lookup during a template instantiation.

ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)

TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, ArrayRef< TemplateArgument > TemplateArgs, sema::TemplateDeductionInfo &Info)

void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)

Run some code with "sufficient" stack space.

ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())

Attempts to produce a RecoveryExpr after some AST node cannot be created.

bool InstantiateEnum(SourceLocation PointOfInstantiation, EnumDecl *Instantiation, EnumDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)

Instantiate the definition of an enum from a given pattern.

void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)

std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)

Produces a formatted string that describes the binding of template parameters to template arguments.

ExprResult BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, QualType ParamType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)

Given a non-type template argument that refers to a declaration and the type of its corresponding non...

bool SubstBaseSpecifiers(CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)

Perform substitution on the base class specifiers of the given class template specialization.

void PerformDependentDiagnostics(const DeclContext *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)

ASTMutationListener * getASTMutationListener() const

ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)

TypeSourceInfo * SubstFunctionDeclType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, CXXRecordDecl *ThisContext, Qualifiers ThisTypeQuals, bool EvaluateConstraints=true)

A form of SubstType intended specifically for instantiating the type of a FunctionDecl.

Encodes a location in the source.

unsigned getExpansionLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const

StringRef getFilename(SourceLocation SpellingLoc) const

Return the filename of the file containing a SourceLocation.

SourceLocation getExpansionLoc(SourceLocation Loc) const

Given a SourceLocation object Loc, return the expansion location referenced by the ID.

A trivial tuple used to represent a source range.

void warnOnStackNearlyExhausted(SourceLocation Loc)

Check to see if we're low on stack space and produce a warning if we're low on stack space (Currently...

Represents a C++11 static_assert declaration.

Stmt - This represents one statement.

SourceLocation getEndLoc() const LLVM_READONLY

void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

SourceLocation getBeginLoc() const LLVM_READONLY

Represents a reference to a non-type template parameter that has been substituted with a template arg...

Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...

A structure for storing an already-substituted template template parameter pack.

Wrapper for substituted template type parameters.

Represents the result of substituting a set of types for a template type parameter pack.

Wrapper for substituted template type parameters.

Represents the result of substituting a type for a template type parameter.

Represents the declaration of a struct/union/class/enum.

void setTagKind(TagKind TK)

SourceRange getBraceRange() const

SourceLocation getInnerLocStart() const

Return SourceLocation representing start of source range ignoring outer template declarations.

StringRef getKindName() const

void startDefinition()

Starts the definition of this tag declaration.

TagKind getTagKind() const

void setBraceRange(SourceRange R)

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

A convenient class for passing around template argument information.

void setLAngleLoc(SourceLocation Loc)

void setRAngleLoc(SourceLocation Loc)

A template argument list.

ArrayRef< TemplateArgument > asArray() const

Produce this as an array ref.

Location wrapper for a TemplateArgument.

const TemplateArgument & getArgument() const

Represents a template argument.

ArrayRef< TemplateArgument > getPackAsArray() const

Return the array of arguments in this template argument pack.

Expr * getAsExpr() const

Retrieve the template argument as an expression.

bool isDependent() const

Whether this template argument is dependent on a template parameter such that its result can change f...

pack_iterator pack_begin() const

Iterator referencing the first argument of a template argument pack.

QualType getAsType() const

Retrieve the type for a type template argument.

TemplateName getAsTemplate() const

Retrieve the template name for a template name argument.

TemplateArgument getPackExpansionPattern() const

When the template argument is a pack expansion, returns the pattern of the pack expansion.

bool isNull() const

Determine whether this template argument has no value.

unsigned pack_size() const

The number of template arguments in the given template argument pack.

@ Declaration

The template argument is a declaration that was provided for a pointer, reference,...

@ Template

The template argument is a template name that was provided for a template template parameter.

@ Pack

The template argument is actually a parameter pack.

@ NullPtr

The template argument is a null pointer or null pointer to member that was provided for a non-type te...

@ Type

The template argument is a type.

@ Expression

The template argument is an expression, and we've not resolved it to one of the other forms yet,...

ArgKind getKind() const

Return the kind of stored template argument.

bool isPackExpansion() const

Determine whether this template argument is a pack expansion.

void enableLateAttributeInstantiation(Sema::LateInstantiatedAttrVec *LA)

void disableLateAttributeInstantiation()

delayed_var_partial_spec_iterator delayed_var_partial_spec_end()

delayed_partial_spec_iterator delayed_partial_spec_begin()

Return an iterator to the beginning of the set of "delayed" partial specializations,...

void setEvaluateConstraints(bool B)

SmallVectorImpl< std::pair< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > >::iterator delayed_var_partial_spec_iterator

LocalInstantiationScope * getStartingScope() const

VarTemplatePartialSpecializationDecl * InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec)

Instantiate the declaration of a variable template partial specialization.

SmallVectorImpl< std::pair< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > >::iterator delayed_partial_spec_iterator

void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)

delayed_partial_spec_iterator delayed_partial_spec_end()

Return an iterator to the end of the set of "delayed" partial specializations, which must be passed t...

delayed_var_partial_spec_iterator delayed_var_partial_spec_begin()

ClassTemplatePartialSpecializationDecl * InstantiateClassTemplatePartialSpecialization(ClassTemplateDecl *ClassTemplate, ClassTemplatePartialSpecializationDecl *PartialSpec)

Instantiate the declaration of a class template partial specialization.

The base class of all kinds of template declarations (e.g., class, function, etc.).

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

Represents a C++ template name within the type system.

TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) const

Retrieve the underlying template declaration that this template name refers to, if known.

bool isNull() const

Determine whether this template name is NULL.

Stores a list of template parameters for a TemplateDecl and its derived classes.

NamedDecl * getParam(unsigned Idx)

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation getTemplateLoc() const

TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...

SourceLocation getLocation() const

TemplateSpecCandidate & addCandidate()

Add a new candidate with NumConversions conversion sequence slots to the overload set.

Represents a type template specialization; the template must be a class template, a type alias templa...

TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.

unsigned getDepth() const

Get the nesting depth of the template parameter.

Declaration of a template type parameter.

bool isParameterPack() const

Returns whether this is a parameter pack.

void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint)

Wrapper for template type parameters.

bool isParameterPack() const

unsigned getIndex() const

unsigned getDepth() const

A semantic tree transformation that allows one to transform one abstract syntax tree into another.

Declaration of an alias template.

TypeAliasDecl * getTemplatedDecl() const

Get the underlying function declaration of the template.

Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...

const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const

ConceptDecl * getNamedConcept() const

Expr * getImmediatelyDeclaredConstraint() const

Get the immediately-declared constraint expression introduced by this type-constraint,...

const NestedNameSpecifierLoc & getNestedNameSpecifierLoc() const

const DeclarationNameInfo & getConceptNameInfo() const

ConceptReference * getConceptReference() const

void setLocStart(SourceLocation L)

TyLocType push(QualType T)

Pushes space for a new TypeLoc of the given type.

void pushFullCopy(TypeLoc L)

Pushes a copy of the given TypeLoc onto this builder.

void reserve(size_t Requested)

Ensures that this buffer has at least as much capacity as described.

TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)

Creates a TypeSourceInfo for the given type.

void pushTrivial(ASTContext &Context, QualType T, SourceLocation Loc)

Pushes 'T' with all locations pointing to 'Loc'.

Base wrapper for a particular "section" of type source info.

QualType getType() const

Get the type for which this source info wrapper provides information.

T getAs() const

Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...

TypeLoc IgnoreParens() const

T castAs() const

Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.

SourceRange getSourceRange() const LLVM_READONLY

Get the full source range.

unsigned getFullDataSize() const

Returns the size of the type source info data block.

SourceLocation getEndLoc() const

Get the end source location.

SourceLocation getBeginLoc() const

Get the begin source location.

A container of type source information.

TypeLoc getTypeLoc() const

Return the TypeLoc wrapper for the type source info.

QualType getType() const

Return the type wrapped by this type source info.

SourceLocation getNameLoc() const

void setNameLoc(SourceLocation Loc)

static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)

Converts an elaborated type keyword into a TagTypeKind.

The base class of the type hierarchy.

bool isReferenceType() const

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isInstantiationDependentType() const

Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...

bool isDependentType() const

Whether this type is a dependent type, meaning that its definition somehow depends on a template para...

bool containsUnexpandedParameterPack() const

Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...

bool isVariablyModifiedType() const

Whether this type is a variably-modified type (C99 6.7.5).

const T * getAs() const

Member-template getAs<specific type>'.

bool isRecordType() const

QualType getUnderlyingType() const

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

bool isParameterPack() const

Determine whether this value is actually a function parameter pack, init-capture pack,...

Represents a variable declaration or definition.

bool isStaticDataMember() const

Determines whether this is a static data member.

VarDecl * getDefinition(ASTContext &)

Get the real (not just tentative) definition for this declaration.

VarDecl * getInstantiatedFromStaticDataMember() const

If this variable is an instantiated static data member of a class template specialization,...

void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())

For a static data member that was instantiated from a static data member of a class template,...

StorageClass getStorageClass() const

Returns the storage class as written in the source.

MemberSpecializationInfo * getMemberSpecializationInfo() const

If this variable is an instantiation of a static data member of a class template specialization,...

Declaration of a variable template.

Represents a variable template specialization, which refers to a variable template with a given set o...

const TemplateArgumentList & getTemplateInstantiationArgs() const

Retrieve the set of template arguments that should be used to instantiate the initializer of the vari...

bool isClassScopeExplicitSpecialization() const

llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const

Retrieve the variable template or variable template partial specialization which was specialized by t...

TemplateSpecializationKind getSpecializationKind() const

Determine the kind of specialization that this declaration represents.

VarTemplateDecl * getSpecializedTemplate() const

Retrieve the template that this specialization specializes.

Represents a GCC generic vector type.

A requires-expression requirement which queries the validity and properties of an expression ('simple...

SubstitutionDiagnostic * getExprSubstitutionDiagnostic() const

bool isExprSubstitutionFailure() const

const ReturnTypeRequirement & getReturnTypeRequirement() const

SourceLocation getNoexceptLoc() const

A requires-expression requirement which is satisfied when a general constraint expression is satisfie...

const ASTConstraintSatisfaction & getConstraintSatisfaction() const

bool hasInvalidConstraint() const

Expr * getConstraintExpr() const

StringRef getInvalidConstraintEntity()

A static requirement that can be used in a requires-expression to check properties of types and expre...

A requires-expression requirement which queries the existence of a type name or type template special...

bool isSubstitutionFailure() const

SubstitutionDiagnostic * getSubstitutionDiagnostic() const

TypeSourceInfo * getType() const

CXXMethodDecl * CallOperator

The lambda's compiler-generated operator().

Provides information about an attempted template argument deduction, whose success or failure was des...

TemplateArgumentList * takeCanonical()

SourceLocation getLocation() const

Returns the location at which template argument is occurring.

bool hasSFINAEDiagnostic() const

Is a SFINAE diagnostic available?

bool hasMatchedPackOnParmToNonPackOnArg() const

void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)

Take ownership of the SFINAE diagnostic.

Defines the clang::TargetInfo interface.

Attr * instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)

Attr * instantiateTemplateAttributeForDecl(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)

The JSON file list parser is used to communicate input to InstallAPI.

void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)

void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)

@ Specialization

We are substituting template parameters for template arguments in order to form a template specializa...

NamedDecl * getAsNamedDecl(TemplateParameter P)

bool isGenericLambdaCallOperatorOrStaticInvokerSpecialization(const DeclContext *DC)

bool isLambdaCallOperator(const CXXMethodDecl *MD)

@ Result

The result type of a method or function.

std::pair< unsigned, unsigned > getDepthAndIndex(const NamedDecl *ND)

Retrieve the depth and index of a template parameter.

TagTypeKind

The kind of a tag type.

DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)

Convert from Sema's representation of template deduction information to the form used in overload-can...

llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter

Stores a template parameter of any kind.

@ VK_PRValue

A pr-value expression (in the C++11 taxonomy) produces a temporary value.

@ VK_LValue

An l-value expression is a reference to an object with independent storage.

const FunctionProtoType * T

void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)

Print a template argument list, including the '<' and '>' enclosing the template arguments.

std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt

A partial diagnostic along with the source location where this diagnostic occurs.

TemplateDeductionResult

Describes the result of template argument deduction.

@ Success

Template argument deduction was successful.

TemplateSpecializationKind

Describes the kind of template specialization that a particular template specialization declaration r...

@ TSK_ExplicitInstantiationDefinition

This template specialization was instantiated from a template due to an explicit instantiation defini...

@ TSK_ExplicitInstantiationDeclaration

This template specialization was instantiated from a template due to an explicit instantiation declar...

@ TSK_ExplicitSpecialization

This template specialization was declared or defined by an explicit specialization (C++ [temp....

@ TSK_ImplicitInstantiation

This template specialization was implicitly instantiated from a template.

ElaboratedTypeKeyword

The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...

@ None

No keyword precedes the qualified type name.

@ Enum

The "enum" keyword introduces the elaborated-type-specifier.

@ Typename

The "typename" keyword precedes the qualified type name, e.g., typename T::type.

@ EST_Uninstantiated

not instantiated yet

@ EST_None

no exception specification

__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)

Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".

SourceLocation RAngleLoc

The source location of the right angle bracket ('>').

SourceLocation LAngleLoc

The source location of the left angle bracket ('<').

llvm::ArrayRef< TemplateArgumentLoc > arguments() const

DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...

SourceLocation getLoc() const

getLoc - Returns the main location of the declaration name.

DeclarationName getName() const

getName - Returns the embedded declaration name.

Holds information about the various types of exception specification.

ExceptionSpecificationType Type

The kind of exception specification this is.

ExceptionSpecInfo ExceptionSpec

A context in which code is being synthesized (where a source location alone is not sufficient to iden...

SourceRange InstantiationRange

The source range that covers the construct that cause the instantiation, e.g., the template-id that c...

enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind

const TemplateArgument * TemplateArgs

The list of template arguments we are substituting, if they are not part of the entity.

sema::TemplateDeductionInfo * DeductionInfo

The template deduction info object associated with the substitution or checking of explicit or deduce...

NamedDecl * Template

The template (or partial specialization) in which we are performing the instantiation,...

SourceLocation PointOfInstantiation

The point of instantiation or synthesis within the source code.

SynthesisKind

The kind of template instantiation we are performing.

@ MarkingClassDllexported

We are marking a class as __dllexport.

@ RequirementParameterInstantiation

@ DefaultTemplateArgumentInstantiation

We are instantiating a default argument for a template parameter.

@ ExplicitTemplateArgumentSubstitution

We are substituting explicit template arguments provided for a function template.

@ DefaultTemplateArgumentChecking

We are checking the validity of a default template argument that has been used when naming a template...

@ InitializingStructuredBinding

We are initializing a structured binding.

@ ExceptionSpecInstantiation

We are instantiating the exception specification for a function template which was deferred until it ...

@ NestedRequirementConstraintsCheck

We are checking the satisfaction of a nested requirement of a requires expression.

@ BuildingBuiltinDumpStructCall

We are building an implied call from __builtin_dump_struct.

@ ParameterMappingSubstitution

@ DefiningSynthesizedFunction

We are defining a synthesized function (such as a defaulted special member).

@ Memoization

Added for Template instantiation observation.

@ ConstraintNormalization

@ LambdaExpressionSubstitution

We are substituting into a lambda expression.

@ TypeAliasTemplateInstantiation

We are instantiating a type alias template declaration.

@ BuildingDeductionGuides

We are building deduction guides for a class.

@ PartialOrderingTTP

We are performing partial ordering for template template parameters.

@ DeducedTemplateArgumentSubstitution

We are substituting template argument determined as part of template argument deduction for either a ...

@ PriorTemplateArgumentSubstitution

We are substituting prior template arguments into a new template parameter.

@ ExceptionSpecEvaluation

We are computing the exception specification for a defaulted special member function.

@ TemplateInstantiation

We are instantiating a template declaration.

@ DeclaringSpecialMember

We are declaring an implicit special member function.

@ DeclaringImplicitEqualityComparison

We are declaring an implicit 'operator==' for a defaulted 'operator<=>'.

@ DefaultFunctionArgumentInstantiation

We are instantiating a default argument for a function.

@ RewritingOperatorAsSpaceship

We are rewriting a comparison operator in terms of an operator<=>.

@ RequirementInstantiation

We are instantiating a requirement of a requires expression.

Decl * Entity

The entity that is being synthesized.

bool isInstantiationRecord() const

Determines whether this template is an actual instantiation that should be counted toward the maximum...

A stack object to be created when performing template instantiation.

bool isInvalid() const

Determines whether we have exceeded the maximum recursive template instantiations.

InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, Decl *Entity, SourceRange InstantiationRange=SourceRange())

Note that we are instantiating a class template, function template, variable template,...

void Clear()

Note that we have finished instantiating this template.

bool isAlreadyInstantiating() const

Determine whether we are already instantiating this specialization in some surrounding active instant...

void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info)

Contains all information for a given match.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4