36#include "llvm/Support/TimeProfiler.h"
47 return cast<CXXRecordDecl>(DC)->isLocalClass();
52template<
typename DeclT>
55 if (!OldDecl->getQualifierLoc())
58 assert((NewDecl->getFriendObjectKind() ||
59 !OldDecl->getLexicalDeclContext()->isDependentContext()) &&
60 "non-friend with qualified name defined in dependent context");
63 const_cast<DeclContext *
>(NewDecl->getFriendObjectKind()
64 ? NewDecl->getLexicalDeclContext()
65 : OldDecl->getLexicalDeclContext()));
74 NewDecl->setQualifierInfo(NewQualifierLoc);
80 return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
85 return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
89#include "clang/Sema/AttrTemplateInstantiate.inc"
93 const AlignedAttr *Aligned,
Decl *New,
bool IsPackExpansion) {
94 if (Aligned->isAlignmentExpr()) {
103 S.
SubstType(Aligned->getAlignmentType(), TemplateArgs,
106 Aligned->getLocation(),
107 Result->getTypeLoc().getSourceRange()))
115 const AlignedAttr *Aligned,
Decl *New) {
116 if (!Aligned->isPackExpansion()) {
122 if (Aligned->isAlignmentExpr())
128 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
131 bool Expand =
true, RetainExpansion =
false;
132 std::optional<unsigned> NumExpansions;
136 Unexpanded, TemplateArgs, Expand,
137 RetainExpansion, NumExpansions))
144 for (
unsigned I = 0; I != *NumExpansions; ++I) {
153 const AssumeAlignedAttr *Aligned,
Decl *New) {
158 Expr *
E, *OE =
nullptr;
164 if (Aligned->getOffset()) {
176 const AlignValueAttr *Aligned,
Decl *New) {
187 const AllocAlignAttr *Align,
Decl *New) {
190 llvm::APInt(64, Align->getParamIndex().getSourceIndex()),
197 const AnnotateAttr *
Attr,
Decl *New) {
203 bool HasDelayedArgs =
Attr->delayedArgs_size();
212 false, TemplateArgs, Args))
215 StringRef Str =
Attr->getAnnotation();
216 if (HasDelayedArgs) {
217 if (Args.size() < 1) {
227 ActualArgs.insert(ActualArgs.begin(), Args.begin() + 1, Args.end());
228 std::swap(Args, ActualArgs);
239 Expr *Cond =
nullptr;
253 Cond = Converted.
get();
259 S.
Diag(A->
getLocation(), diag::err_attr_cond_never_constant_expr) << A;
260 for (
const auto &
P : Diags)
261 S.
Diag(
P.first,
P.second);
271 S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New);
275 Cond, EIA->getMessage()));
282 S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New);
287 DIA->getDiagnosticType(), DIA->getArgDependent(), New));
294 const CUDALaunchBoundsAttr &
Attr,
Decl *New) {
304 Expr *MinBlocks =
nullptr;
305 if (
Attr.getMinBlocks()) {
312 Expr *MaxBlocks =
nullptr;
313 if (
Attr.getMaxBlocks()) {
334 const OMPDeclareSimdDeclAttr &
Attr,
Decl *New) {
336 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
337 New = FTD->getTemplatedDecl();
338 auto *FD = cast<FunctionDecl>(New);
339 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
345 if (
auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
348 if (FD->getNumParams() > PVD->getFunctionScopeIndex())
349 Local.InstantiatedLocal(
350 PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
354 FD->isCXXInstanceMember());
370 if (
auto *
E =
Attr.getSimdlen())
373 if (
Attr.uniforms_size() > 0) {
374 for(
auto *
E :
Attr.uniforms()) {
378 Uniforms.push_back(Inst.
get());
382 auto AI =
Attr.alignments_begin();
383 for (
auto *
E :
Attr.aligneds()) {
387 Aligneds.push_back(Inst.
get());
391 Alignments.push_back(Inst.
get());
395 auto SI =
Attr.steps_begin();
396 for (
auto *
E :
Attr.linears()) {
400 Linears.push_back(Inst.
get());
404 Steps.push_back(Inst.
get());
407 LinModifiers.append(
Attr.modifiers_begin(),
Attr.modifiers_end());
410 Uniforms, Aligneds, Alignments, Linears, LinModifiers, Steps,
417 const OMPDeclareVariantAttr &
Attr,
Decl *New) {
419 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
420 New = FTD->getTemplatedDecl();
421 auto *FD = cast<FunctionDecl>(New);
422 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
424 auto &&SubstExpr = [FD, ThisContext, &S, &TemplateArgs](
Expr *
E) {
426 if (
auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
429 if (FD->getNumParams() > PVD->getFunctionScopeIndex())
430 Local.InstantiatedLocal(
431 PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
435 FD->isCXXInstanceMember());
441 auto &&Subst = [&SubstExpr, &S](
Expr *
E) {
451 if (
Expr *
E =
Attr.getVariantFuncRef()) {
456 VariantFuncRef = Subst(
E);
462 TI = *
Attr.getTraitInfos();
465 auto SubstScoreOrConditionExpr = [&S, Subst](
Expr *&
E,
bool) {
484 std::optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
492 E = DeclVarData->second;
493 FD = DeclVarData->first;
496 if (
auto *VariantFD = dyn_cast<FunctionDecl>(VariantDRE->getDecl())) {
497 if (
auto *VariantFTD = VariantFD->getDescribedFunctionTemplate()) {
498 if (!VariantFTD->isThisDeclarationADefinition())
509 SubstFD->getType(), FD->getType(),
517 SubstFD->setInstantiationIsPending(!SubstFD->isDefined());
521 SubstFD->getLocation(),
531 for (
Expr *
E :
Attr.adjustArgsNothing()) {
535 NothingExprs.push_back(ER.
get());
537 for (
Expr *
E :
Attr.adjustArgsNeedDevicePtr()) {
541 NeedDevicePtrExprs.push_back(ER.
get());
545 AppendArgs.emplace_back(II.IsTarget, II.IsTargetSync);
549 FD,
E, TI, NothingExprs, NeedDevicePtrExprs, AppendArgs,
SourceLocation(),
555 const AMDGPUFlatWorkGroupSizeAttr &
Attr,
Decl *New) {
578 Expr *Cond =
nullptr;
586 Cond = SubstResult.
get();
596 const AMDGPUWavesPerEUAttr &
Attr,
Decl *New) {
606 Expr *MaxExpr =
nullptr;
607 if (
auto Max =
Attr.getMax()) {
619 const AMDGPUMaxNumWorkGroupsAttr &
Attr,
Decl *New) {
645 const SYCLKernelAttr &
Attr,
Decl *New) {
655 if (
const auto *PNA = dyn_cast<PreferredNameAttr>(A)) {
657 const auto *RD = cast<CXXRecordDecl>(
D);
663 PNA->getTypedefType()))
668 if (
const auto *BA = dyn_cast<BuiltinAttr>(A)) {
670 switch (BA->getID()) {
671 case Builtin::BIforward:
681 case Builtin::BImove:
682 case Builtin::BImove_if_noexcept:
698 const HLSLParamModifierAttr *
Attr,
Decl *New) {
708 if (
NamedDecl *ND = dyn_cast<NamedDecl>(New)) {
712 for (
const auto *TmplAttr : Tmpl->
attrs()) {
719 *
this, dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()),
723 TmplAttr,
Context, *
this, TemplateArgs);
733 case clang::attr::CFConsumed:
735 case clang::attr::OSConsumed:
737 case clang::attr::NSConsumed:
740 llvm_unreachable(
"Wrong argument supplied");
748 for (
const auto *TmplAttr : Tmpl->
attrs()) {
753 const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
754 if (Aligned && Aligned->isAlignmentDependent()) {
759 if (
const auto *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr)) {
764 if (
const auto *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr)) {
769 if (
const auto *AllocAlign = dyn_cast<AllocAlignAttr>(TmplAttr)) {
774 if (
const auto *Annotate = dyn_cast<AnnotateAttr>(TmplAttr)) {
779 if (
const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
781 cast<FunctionDecl>(New));
785 if (
const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {
787 cast<FunctionDecl>(New));
791 if (
const auto *CUDALaunchBounds =
792 dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
794 *CUDALaunchBounds, New);
798 if (
const auto *Mode = dyn_cast<ModeAttr>(TmplAttr)) {
803 if (
const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) {
808 if (
const auto *OMPAttr = dyn_cast<OMPDeclareVariantAttr>(TmplAttr)) {
813 if (
const auto *AMDGPUFlatWorkGroupSize =
814 dyn_cast<AMDGPUFlatWorkGroupSizeAttr>(TmplAttr)) {
816 *
this, TemplateArgs, *AMDGPUFlatWorkGroupSize, New);
819 if (
const auto *AMDGPUFlatWorkGroupSize =
820 dyn_cast<AMDGPUWavesPerEUAttr>(TmplAttr)) {
822 *AMDGPUFlatWorkGroupSize, New);
825 if (
const auto *AMDGPUMaxNumWorkGroups =
826 dyn_cast<AMDGPUMaxNumWorkGroupsAttr>(TmplAttr)) {
828 *
this, TemplateArgs, *AMDGPUMaxNumWorkGroups, New);
831 if (
const auto *ParamAttr = dyn_cast<HLSLParamModifierAttr>(TmplAttr)) {
838 if (TmplAttr->getKind() == attr::DLLExport ||
839 TmplAttr->getKind() == attr::DLLImport) {
840 if (New->
hasAttr<DLLExportAttr>() || New->
hasAttr<DLLImportAttr>()) {
845 if (
const auto *ABIAttr = dyn_cast<ParameterABIAttr>(TmplAttr)) {
850 if (isa<NSConsumedAttr>(TmplAttr) || isa<OSConsumedAttr>(TmplAttr) ||
851 isa<CFConsumedAttr>(TmplAttr)) {
858 if (
auto *A = dyn_cast<PointerAttr>(TmplAttr)) {
859 if (!New->
hasAttr<PointerAttr>())
864 if (
auto *A = dyn_cast<OwnerAttr>(TmplAttr)) {
865 if (!New->
hasAttr<OwnerAttr>())
870 if (
auto *A = dyn_cast<SYCLKernelAttr>(TmplAttr)) {
875 if (
auto *A = dyn_cast<CUDAGridConstantAttr>(TmplAttr)) {
876 if (!New->
hasAttr<CUDAGridConstantAttr>())
881 assert(!TmplAttr->isPackExpansion());
882 if (TmplAttr->isLateParsed() && LateAttrs) {
891 auto *ND = cast<NamedDecl>(New);
892 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
894 ND->isCXXInstanceMember());
897 *
this, TemplateArgs);
905 for (
const auto *
Attr : Pattern->
attrs()) {
906 if (
auto *A = dyn_cast<StrictFPAttr>(
Attr)) {
907 if (!Inst->
hasAttr<StrictFPAttr>())
920 DLLExportAttr *
Attr = Ctor->
getAttr<DLLExportAttr>();
923 for (
unsigned I = 0; I != NumParams; ++I) {
934template<
typename DeclT>
950 llvm_unreachable(
"Translation units cannot be instantiated");
954 llvm_unreachable(
"HLSL buffer declarations cannot be instantiated");
959 llvm_unreachable(
"pragma comment cannot be instantiated");
962Decl *TemplateDeclInstantiator::VisitPragmaDetectMismatchDecl(
964 llvm_unreachable(
"pragma comment cannot be instantiated");
969 llvm_unreachable(
"extern \"C\" context cannot be instantiated");
973 llvm_unreachable(
"GUID declaration cannot be instantiated");
976Decl *TemplateDeclInstantiator::VisitUnnamedGlobalConstantDecl(
978 llvm_unreachable(
"UnnamedGlobalConstantDecl cannot be instantiated");
981Decl *TemplateDeclInstantiator::VisitTemplateParamObjectDecl(
983 llvm_unreachable(
"template parameter objects cannot be instantiated");
987TemplateDeclInstantiator::VisitLabelDecl(
LabelDecl *
D) {
997 llvm_unreachable(
"Namespaces cannot be instantiated");
1004 D->getNamespaceLoc(),
1007 D->getQualifierLoc(),
1008 D->getTargetNameLoc(),
1020 DI = SemaRef.
SubstType(DI, TemplateArgs,
1041 D->getIdentifier() &&
D->getIdentifier()->isStr(
"type") &&
1060 if (
const TagType *oldTagType =
D->getUnderlyingType()->getAs<
TagType>()) {
1061 TagDecl *oldTag = oldTagType->getDecl();
1131 if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) {
1133 if (!
Found.empty()) {
1134 PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(
Found.front());
1145 D->getDeclName(), InstParams, AliasInst);
1147 if (PrevAliasTemplate)
1152 if (!PrevAliasTemplate)
1169 D->getIdentifier());
1178 for (
auto *OldBD :
D->bindings())
1179 NewBindings.push_back(cast<BindingDecl>(VisitBindingDecl(OldBD)));
1182 auto *NewDD = cast_or_null<DecompositionDecl>(
1185 if (!NewDD || NewDD->isInvalidDecl())
1186 for (
auto *NewBD : NewBindings)
1187 NewBD->setInvalidDecl();
1197 bool InstantiatingVarTemplate,
1202 D->getTypeSourceInfo(), TemplateArgs,
D->getTypeSpecStartLoc(),
1203 D->getDeclName(),
true);
1208 SemaRef.
Diag(
D->
getLocation(), diag::err_variable_instantiates_to_function)
1209 <<
D->isStaticDataMember() << DI->
getType();
1226 DI,
D->getStorageClass());
1241 StartingScope, InstantiatingVarTemplate);
1244 if (
auto *F = dyn_cast<FunctionDecl>(DC))
1245 RT = F->getReturnType();
1246 else if (isa<BlockDecl>(DC))
1250 llvm_unreachable(
"Unknown context type");
1282 D->getAccessSpecifierLoc(),
D->getColonLoc());
1292 DI = SemaRef.
SubstType(DI, TemplateArgs,
1295 DI =
D->getTypeSourceInfo();
1312 Expr *BitWidth =
D->getBitWidth();
1315 else if (BitWidth) {
1321 = SemaRef.
SubstExpr(BitWidth, TemplateArgs);
1326 BitWidth = InstantiatedBitWidth.
getAs<
Expr>();
1331 cast<RecordDecl>(Owner),
1335 D->getInClassInitStyle(),
1336 D->getInnerLocStart(),
1346 if (
Field->hasAttrs())
1350 Field->setInvalidDecl();
1357 if (
Parent->isAnonymousStructOrUnion() &&
1358 Parent->getRedeclContext()->isFunctionOrMethod())
1378 DI = SemaRef.
SubstType(DI, TemplateArgs,
1381 DI =
D->getTypeSourceInfo();
1419 for (
auto *PI :
D->chain()) {
1425 NamedChain[i++] = Next;
1428 QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
1431 {NamedChain, D->getChainingSize()});
1438 Owner->
addDecl(IndirectField);
1439 return IndirectField;
1451 if (
D->isUnsupportedFriend()) {
1454 if (
D->isPackExpansion()) {
1457 assert(!Unexpanded.empty() &&
"Pack expansion without packs");
1459 bool ShouldExpand =
true;
1460 bool RetainExpansion =
false;
1461 std::optional<unsigned> NumExpansions;
1464 TemplateArgs, ShouldExpand, RetainExpansion, NumExpansions))
1467 assert(!RetainExpansion &&
1468 "should never retain an expansion for a variadic friend decl");
1472 for (
unsigned I = 0; I != *NumExpansions; I++) {
1481 TSI,
D->getFriendLoc());
1485 Decls.push_back(FD);
1508 assert(ND &&
"friend decl must be a decl or a type!");
1515 if (!NewND)
return nullptr;
1519 cast<NamedDecl>(NewND),
D->getFriendLoc());
1527 Expr *AssertExpr =
D->getAssertExpr();
1534 = SemaRef.
SubstExpr(AssertExpr, TemplateArgs);
1539 SemaRef.
SubstExpr(
D->getMessage(), TemplateArgs);
1540 if (InstantiatedMessageExpr.
isInvalid())
1545 InstantiatedMessageExpr.
get(),
D->getRParenLoc(),
D->isFailed());
1554 if (!Prev)
return nullptr;
1555 PrevDecl = cast<EnumDecl>(Prev);
1561 D->isScoped(),
D->isScopedUsingClassTag(),
D->isFixed());
1573 Enum->setIntegerTypeSourceInfo(NewTI);
1583 Enum->setPromotionType(
1588 assert(!
D->getIntegerType()->isDependentType()
1589 &&
"Dependent type without type source info");
1590 Enum->setIntegerType(
D->getIntegerType());
1612 if (Def && Def !=
D) {
1619 SemaRef.
SubstType(TI->getType(), TemplateArgs,
1622 DefnUnderlying,
true,
Enum);
1637 if (PrevDecl ==
nullptr) {
1648 Enum->startDefinition();
1659 if (
Expr *UninstValue = EC->getInitExpr()) {
1669 if (
Value.isInvalid()) {
1682 Enum->setInvalidDecl();
1689 Enum->addDecl(EnumConst);
1690 Enumerators.push_back(EnumConst);
1691 LastEnumConst = EnumConst;
1694 !
Enum->isScoped()) {
1707 llvm_unreachable(
"EnumConstantDecls can only occur within EnumDecls.");
1712 llvm_unreachable(
"BuiltinTemplateDecls cannot be instantiated.");
1744 if (!
Found.empty()) {
1745 PrevClassTemplate = dyn_cast<ClassTemplateDecl>(
Found.front());
1746 if (PrevClassTemplate)
1759 SS.
Adopt(QualifierLoc);
1761 if (!DC)
return nullptr;
1775 if (R.isSingleResult()) {
1777 if (PrevClassTemplate)
1781 if (!PrevClassTemplate && QualifierLoc) {
1783 << llvm::to_underlying(
D->getTemplatedDecl()->getTagKind())
1801 D->getIdentifier(), InstParams, RecordInst);
1810 if (PrevClassTemplate) {
1841 if (!PrevClassTemplate)
1864 if (!PrevClassTemplate) {
1869 D->getPartialSpecializations(PartialSpecs);
1870 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1871 if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1872 OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
1879TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
1891 = dyn_cast<ClassTemplateDecl>(
Found.front());
1892 if (!InstClassTemplate)
1903 assert(
D->getTemplatedDecl()->isStaticDataMember() &&
1904 "Only static data member templates are allowed.");
1914 VarDecl *Pattern =
D->getTemplatedDecl();
1920 PrevVarTemplate = dyn_cast<VarTemplateDecl>(
Found.front());
1926 if (!VarInst)
return nullptr;
1937 if (!PrevVarTemplate)
1947 if (!PrevVarTemplate) {
1952 D->getPartialSpecializations(PartialSpecs);
1953 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1954 if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1955 OutOfLineVarPartialSpecs.push_back(
1956 std::make_pair(Inst, PartialSpecs[I]));
1962Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
1964 assert(
D->isStaticDataMember() &&
1965 "Only static data member templates are allowed.");
1971 assert(!
Found.empty() &&
"Instantiation found nothing?");
1974 assert(InstVarTemplate &&
"Instantiation did not find a variable template?");
1998 if (
CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(
D->getTemplatedDecl()))
2003 D->getTemplatedDecl(),
2014 assert(InstTemplate &&
2015 "VisitFunctionDecl/CXXMethodDecl didn't create a template!");
2022 !(isFriend && !
D->getTemplatedDecl()->isThisDeclarationADefinition()))
2033 return InstTemplate;
2042 if (!Prev)
return nullptr;
2043 PrevDecl = cast<CXXRecordDecl>(Prev);
2047 bool IsInjectedClassName =
D->isInjectedClassName();
2051 D->getLambdaDependencyKind(),
D->isGenericLambda(),
2052 D->getLambdaCaptureDefault());
2056 D->getIdentifier(), PrevDecl,
2057 IsInjectedClassName);
2059 if (IsInjectedClassName)
2075 if (!IsInjectedClassName)
2081 Record->setObjectOfFriendDecl();
2084 if (
D->isAnonymousStructOrUnion())
2085 Record->setAnonymousStructOrUnion(
true);
2087 if (
D->isLocalClass())
2108 if (
D->isCompleteDefinition() &&
D->isLocalClass()) {
2117 if (!
D->isCXXClassMember())
2123 LocalInstantiations.perform();
2128 if (IsInjectedClassName)
2129 assert(
Record->isInjectedClassName() &&
"Broken injected-class-name");
2147 if (OrigFunc->
getExtInfo() == NewFunc->getExtInfo())
2153 NewFunc->getParamTypes(), NewEPI);
2168 if (FunctionTemplate)
2184 if (FunctionTemplate && !TemplateParams) {
2187 void *InsertPos =
nullptr;
2196 bool MergeWithParentScope = (TemplateParams !=
nullptr) ||
2198 !(isa<Decl>(Owner) &&
2199 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
2203 if (
auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(
D)) {
2205 TemplateArgs, DGuide->getExplicitSpecifier());
2206 if (InstantiatedExplicitSpecifier.
isInvalid())
2216 if (TemplateParams && TemplateParams->
size()) {
2218 dyn_cast<TemplateTypeParmDecl>(TemplateParams->
asArray().back());
2219 if (LastParam && LastParam->isImplicit() &&
2220 LastParam->hasTypeConstraint()) {
2241 Expr *TrailingRequiresClause =
D->getTrailingRequiresClause();
2250 }
else if (isFriend && QualifierLoc) {
2252 SS.
Adopt(QualifierLoc);
2254 if (!DC)
return nullptr;
2267 if (
auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(
D)) {
2269 SemaRef.
Context, DC,
D->getInnerLocStart(),
2270 InstantiatedExplicitSpecifier, NameInfo,
T, TInfo,
2272 DGuide->getDeductionCandidateKind(), TrailingRequiresClause,
2273 DGuide->getSourceDeductionGuide(),
2274 DGuide->getSourceDeductionGuideKind());
2278 SemaRef.
Context, DC,
D->getInnerLocStart(), NameInfo,
T, TInfo,
2280 D->isInlineSpecified(),
D->hasWrittenPrototype(),
D->getConstexprKind(),
2281 TrailingRequiresClause);
2282 Function->setFriendConstraintRefersToEnclosingTemplate(
2283 D->FriendConstraintRefersToEnclosingTemplate());
2291 Function->setQualifierInfo(QualifierLoc);
2305 Function->setLexicalDeclContext(LexicalDC);
2308 for (
unsigned P = 0;
P < Params.size(); ++
P)
2313 if (TrailingRequiresClause)
2314 Function->setTrailingRequiresClause(TrailingRequiresClause);
2316 if (TemplateParams) {
2335 Function->setDescribedFunctionTemplate(FunctionTemplate);
2339 if (isFriend &&
D->isThisDeclarationADefinition()) {
2341 D->getDescribedFunctionTemplate());
2343 }
else if (FunctionTemplate &&
2348 Function->setFunctionTemplateSpecialization(FunctionTemplate,
2353 if (isFriend &&
D->isThisDeclarationADefinition()) {
2358 }
else if (!isFriend) {
2369 FT->setObjectOfFriendDecl();
2375 bool IsExplicitSpecialization =
false;
2385 D->getDependentSpecializationInfo()) {
2386 assert(isFriend &&
"dependent specialization info on "
2387 "non-member non-friend function?");
2391 if (
const auto *ArgsWritten = DFTSI->TemplateArgumentsAsWritten) {
2392 ExplicitArgs.
setLAngleLoc(ArgsWritten->getLAngleLoc());
2393 ExplicitArgs.
setRAngleLoc(ArgsWritten->getRAngleLoc());
2410 DFTSI->TemplateArgumentsAsWritten ? &ExplicitArgs :
nullptr,
2414 IsExplicitSpecialization =
true;
2416 D->getTemplateSpecializationArgsAsWritten()) {
2422 ArgsWritten->getRAngleLoc());
2432 IsExplicitSpecialization =
true;
2433 }
else if (TemplateParams || !FunctionTemplate) {
2449 if (isFriend && !QualifierLoc) {
2469 if (
Function->isLocalExternDecl()) {
2471 if (!PVD->hasDefaultArg())
2477 Expr *UninstExpr = PVD->getUninstantiatedDefaultArg();
2480 { UninstExpr }, UninstExpr->
getType());
2482 PVD->setDefaultArg(ErrorResult.
get());
2488 IsExplicitSpecialization,
2489 Function->isThisDeclarationADefinition());
2495 if (isFriend && TemplateParams && FunctionTemplate->
getPreviousDecl()) {
2499 Function->isThisDeclarationADefinition()
2508 if (isFriend &&
D->isThisDeclarationADefinition() &&
Function->isUsed(
false)) {
2510 Function->getMemberSpecializationInfo()) {
2511 if (MSInfo->getPointOfInstantiation().isInvalid()) {
2513 MSInfo->setPointOfInstantiation(
Loc);
2520 if (
D->isExplicitlyDefaulted()) {
2528 (TemplateParams ? cast<NamedDecl>(FunctionTemplate) :
Function);
2547 if (FunctionTemplate && !TemplateParams) {
2553 void *InsertPos =
nullptr;
2563 if (FunctionTemplate)
2568 bool MergeWithParentScope = (TemplateParams !=
nullptr) ||
2569 !(isa<Decl>(Owner) &&
2570 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
2578 unsigned NumTempParamLists = 0;
2579 if (isFriend && (NumTempParamLists =
D->getNumTemplateParameterLists())) {
2580 TempParamLists.resize(NumTempParamLists);
2581 for (
unsigned I = 0; I != NumTempParamLists; ++I) {
2586 TempParamLists[I] = InstParams;
2592 const bool CouldInstantiate =
2593 InstantiatedExplicitSpecifier.getExpr() ==
nullptr ||
2594 !InstantiatedExplicitSpecifier.getExpr()->isValueDependent();
2598 if (CouldInstantiate ||
2602 TemplateArgs, InstantiatedExplicitSpecifier);
2604 if (InstantiatedExplicitSpecifier.isInvalid())
2617 isa<CXXConstructorDecl, CXXDestructorDecl>(
D)) {
2620 D->setTypeSourceInfo(TSI);
2629 if (TemplateParams && TemplateParams->
size()) {
2631 dyn_cast<TemplateTypeParmDecl>(TemplateParams->
asArray().back());
2632 if (LastParam && LastParam->isImplicit() &&
2633 LastParam->hasTypeConstraint()) {
2658 SS.
Adopt(QualifierLoc);
2668 if (!DC)
return nullptr;
2672 Expr *TrailingRequiresClause =
D->getTrailingRequiresClause();
2687 InstantiatedExplicitSpecifier, Constructor->UsesFPIntrin(),
2688 Constructor->isInlineSpecified(),
false,
2690 TrailingRequiresClause);
2696 Destructor->getConstexprKind(), TrailingRequiresClause);
2705 Conversion->UsesFPIntrin(), Conversion->isInlineSpecified(),
2706 InstantiatedExplicitSpecifier, Conversion->getConstexprKind(),
2707 Conversion->getEndLoc(), TrailingRequiresClause);
2712 D->UsesFPIntrin(),
D->isInlineSpecified(),
D->getConstexprKind(),
2722 if (TemplateParams) {
2739 TemplateParams, Method);
2746 }
else if (FunctionTemplate) {
2762 if (NumTempParamLists)
2773 for (
unsigned P = 0;
P < Params.size(); ++
P)
2774 Params[
P]->setOwningFunction(Method);
2781 RedeclarationKind::ForExternalRedeclaration);
2783 bool IsExplicitSpecialization =
false;
2788 D->getDependentSpecializationInfo()) {
2791 if (
const auto *ArgsWritten = DFTSI->TemplateArgumentsAsWritten) {
2792 ExplicitArgs.
setLAngleLoc(ArgsWritten->getLAngleLoc());
2793 ExplicitArgs.
setRAngleLoc(ArgsWritten->getRAngleLoc());
2809 Method, DFTSI->TemplateArgumentsAsWritten ? &ExplicitArgs :
nullptr,
2813 IsExplicitSpecialization =
true;
2815 D->getTemplateSpecializationArgsAsWritten()) {
2819 ArgsWritten->getRAngleLoc());
2830 IsExplicitSpecialization =
true;
2831 }
else if (!FunctionTemplate || TemplateParams || isFriend) {
2858 for (
unsigned P = 0;
P < Params.size(); ++
P) {
2859 if (!Params[
P]->hasDefaultArg())
2865 Expr *UninstExpr = Params[
P]->getUninstantiatedDefaultArg();
2868 { UninstExpr }, UninstExpr->
getType());
2870 Params[
P]->setDefaultArg(ErrorResult.
get());
2876 IsExplicitSpecialization,
2879 if (
D->isPureVirtual())
2889 if (FunctionTemplate)
2895 if (
D->isExplicitlyDefaulted()) {
2899 if (
D->isDeletedAsWritten())
2901 D->getDeletedMessage());
2906 if (IsExplicitSpecialization && !isFriend)
2916 if (
auto *Constructor = dyn_cast<CXXConstructorDecl>(Method)) {
2917 if (Constructor->isDefaultConstructor() ||
2918 Constructor->isCopyOrMoveConstructor())
2926 if (FunctionTemplate) {
2934 }
else if (isFriend) {
2940 Record->makeDeclVisibleInContext(Method);
2951 if (Method->
hasAttr<UsedAttr>()) {
2952 if (
const auto *A = dyn_cast<CXXRecordDecl>(Owner)) {
2955 A->getMemberSpecializationInfo())
2956 Loc = MSInfo->getPointOfInstantiation();
2957 else if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(A))
2958 Loc = Spec->getPointOfInstantiation();
2984Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
2986 assert(
D->getTypeForDecl()->isTemplateTypeParmType());
2988 std::optional<unsigned> NumExpanded;
2991 if (
D->isPackExpansion() && !
D->isExpandedParameterPack()) {
2992 assert(TC->getTemplateArgsAsWritten() &&
2993 "type parameter can only be an expansion when explicit arguments "
2999 for (
auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
3005 bool RetainExpansion =
false;
3007 cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
3010 TC->hasExplicitTemplateArgs() ?
3011 TC->getTemplateArgsAsWritten()->getRAngleLoc() :
3012 TC->getConceptNameInfo().getEndLoc()),
3013 Unexpanded, TemplateArgs, Expand, RetainExpansion, NumExpanded))
3022 D->hasTypeConstraint(), NumExpanded);
3026 if (
auto *TC =
D->getTypeConstraint()) {
3032 EvaluateConstraints))
3036 if (
D->hasDefaultArgument() && !
D->defaultArgumentWasInherited()) {
3050Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
3053 TypeLoc TL =
D->getTypeSourceInfo()->getTypeLoc();
3056 bool IsExpandedParameterPack =
false;
3061 if (
D->isExpandedParameterPack()) {
3064 ExpandedParameterPackTypes.reserve(
D->getNumExpansionTypes());
3065 ExpandedParameterPackTypesAsWritten.reserve(
D->getNumExpansionTypes());
3066 for (
unsigned I = 0, N =
D->getNumExpansionTypes(); I != N; ++I) {
3068 SemaRef.
SubstType(
D->getExpansionTypeSourceInfo(I), TemplateArgs,
3078 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
3079 ExpandedParameterPackTypes.push_back(NewT);
3082 IsExpandedParameterPack =
true;
3083 DI =
D->getTypeSourceInfo();
3085 }
else if (
D->isPackExpansion()) {
3097 bool RetainExpansion =
false;
3098 std::optional<unsigned> OrigNumExpansions =
3100 std::optional<unsigned> NumExpansions = OrigNumExpansions;
3102 Pattern.getSourceRange(),
3105 Expand, RetainExpansion,
3110 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3123 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
3124 ExpandedParameterPackTypes.push_back(NewT);
3130 IsExpandedParameterPack =
true;
3131 DI =
D->getTypeSourceInfo();
3153 DI = SemaRef.
SubstType(
D->getTypeSourceInfo(), TemplateArgs,
3167 if (IsExpandedParameterPack)
3171 D->getPosition(),
D->getIdentifier(),
T, DI, ExpandedParameterPackTypes,
3172 ExpandedParameterPackTypesAsWritten);
3180 if (AutoLoc.isConstrained()) {
3182 if (IsExpandedParameterPack)
3185 else if (
auto *Constraint = dyn_cast_if_present<CXXFoldExpr>(
3186 D->getPlaceholderTypeConstraint()))
3187 EllipsisLoc = Constraint->getEllipsisLoc();
3201 if (
D->hasDefaultArgument() && !
D->defaultArgumentWasInherited()) {
3220 for (
const auto &
P : *Params) {
3221 if (
P->isTemplateParameterPack())
3233TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
3240 bool IsExpandedParameterPack =
false;
3242 if (
D->isExpandedParameterPack()) {
3246 ExpandedParams.reserve(
D->getNumExpansionTemplateParameters());
3247 for (
unsigned I = 0, N =
D->getNumExpansionTemplateParameters();
3254 ExpandedParams.push_back(Expansion);
3257 IsExpandedParameterPack =
true;
3258 InstParams = TempParams;
3259 }
else if (
D->isPackExpansion()) {
3270 bool RetainExpansion =
false;
3271 std::optional<unsigned> NumExpansions;
3276 Expand, RetainExpansion,
3281 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3287 ExpandedParams.push_back(Expansion);
3293 IsExpandedParameterPack =
true;
3294 InstParams = TempParams;
3316 if (IsExpandedParameterPack)
3320 D->getPosition(),
D->getIdentifier(),
D->wasDeclaredWithTypename(),
3321 InstParams, ExpandedParams);
3327 D->wasDeclaredWithTypename(), InstParams);
3328 if (
D->hasDefaultArgument() && !
D->defaultArgumentWasInherited()) {
3330 D->getDefaultArgument().getTemplateQualifierLoc();
3334 QualifierLoc,
D->getDefaultArgument().getArgument().getAsTemplate(),
3335 D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
3340 D->getDefaultArgument().getTemplateQualifierLoc(),
3341 D->getDefaultArgument().getTemplateNameLoc()));
3359 D->getNamespaceKeyLocation(),
3360 D->getQualifierLoc(),
3361 D->getIdentLocation(),
3362 D->getNominatedNamespace(),
3363 D->getCommonAncestor());
3379 for (
auto *Shadow :
D->shadows()) {
3383 NamedDecl *OldTarget = Shadow->getTargetDecl();
3384 if (
auto *CUSD = dyn_cast<ConstructorUsingShadowDecl>(Shadow))
3385 if (
auto *BaseShadow = CUSD->getNominatedBaseClassShadowDecl())
3386 OldTarget = BaseShadow;
3390 dyn_cast<UnresolvedUsingIfExistsDecl>(Shadow->getTargetDecl())) {
3392 SemaRef.
Context, Owner, EmptyD->getLocation(), EmptyD->getDeclName());
3395 Shadow->getLocation(), OldTarget, TemplateArgs));
3407 Shadow->getLocation(), OldPrev, TemplateArgs));
3410 nullptr, Inst, InstTarget, PrevDecl);
3413 if (isFunctionScope)
3441 if (
auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.
CurContext))
3447 bool CheckRedeclaration = Owner->
isRecord();
3449 RedeclarationKind::ForVisibleRedeclaration);
3458 SS.
Adopt(QualifierLoc);
3459 if (CheckRedeclaration) {
3460 Prev.setHideTags(
false);
3465 D->hasTypename(), SS,
3529Decl *TemplateDeclInstantiator::VisitConstructorUsingShadowDecl(
3535template <
typename T>
3536Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
3537 T *
D,
bool InstantiatingPackElement) {
3539 if (
D->isPackExpansion() && !InstantiatingPackElement) {
3547 bool RetainExpansion =
false;
3548 std::optional<unsigned> NumExpansions;
3551 Expand, RetainExpansion, NumExpansions))
3556 assert(!RetainExpansion &&
3557 "should never need to retain an expansion for UsingPackDecl");
3563 return instantiateUnresolvedUsingDecl(
D,
true);
3574 SemaRef.
Diag(
D->getEllipsisLoc(),
3575 diag::err_using_decl_redeclaration_expansion);
3581 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3583 Decl *Slice = instantiateUnresolvedUsingDecl(
D,
true);
3590 Expansions.push_back(cast<NamedDecl>(Slice));
3609 SS.
Adopt(QualifierLoc);
3616 bool InstantiatingSlice =
D->getEllipsisLoc().isValid() &&
3621 bool IsUsingIfExists =
D->template hasAttr<UsingIfExistsAttr>();
3624 TD, TypenameLoc, SS, NameInfo, EllipsisLoc,
3626 true, IsUsingIfExists);
3635Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
3637 return instantiateUnresolvedUsingDecl(
D);
3640Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
3642 return instantiateUnresolvedUsingDecl(
D);
3645Decl *TemplateDeclInstantiator::VisitUnresolvedUsingIfExistsDecl(
3647 llvm_unreachable(
"referring to unresolved decl out of UsingShadowDecl");
3652 for (
auto *UD :
D->expansions()) {
3655 Expansions.push_back(NewUD);
3666Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
3669 for (
auto *I :
D->varlist()) {
3671 assert(isa<DeclRefExpr>(Var) &&
"threadprivate arg is not a DeclRefExpr");
3672 Vars.push_back(Var);
3686 for (
auto *I :
D->varlist()) {
3688 assert(isa<DeclRefExpr>(Var) &&
"allocate arg is not a DeclRefExpr");
3689 Vars.push_back(Var);
3695 if (
auto *AC = dyn_cast<OMPAllocatorClause>(
C)) {
3700 NewE.
get(), AC->getBeginLoc(), AC->getLParenLoc(), AC->getEndLoc());
3701 }
else if (
auto *AC = dyn_cast<OMPAlignClause>(
C)) {
3706 NewE.
get(), AC->getBeginLoc(), AC->getLParenLoc(), AC->getEndLoc());
3711 Clauses.push_back(IC);
3716 if (Res.
get().isNull())
3718 return Res.
get().getSingleDecl();
3723 "Requires directive cannot be instantiated within a dependent context");
3726Decl *TemplateDeclInstantiator::VisitOMPDeclareReductionDecl(
3729 const bool RequiresInstantiation =
3730 D->getType()->isDependentType() ||
3731 D->getType()->isInstantiationDependentType() ||
3732 D->getType()->containsUnexpandedParameterPack();
3734 if (RequiresInstantiation) {
3740 SubstReductionType =
D->getType();
3742 if (SubstReductionType.
isNull())
3744 Expr *Combiner =
D->getCombiner();
3746 bool IsCorrect =
true;
3748 std::pair<QualType, SourceLocation> ReductionTypes[] = {
3750 auto *PrevDeclInScope =
D->getPrevDeclInScope();
3751 if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
3752 PrevDeclInScope = cast<OMPDeclareReductionDecl>(
3757 nullptr, Owner,
D->getDeclName(), ReductionTypes,
D->
getAccess(),
3759 auto *NewDRD = cast<OMPDeclareReductionDecl>(DRD.get().getSingleDecl());
3761 Expr *SubstCombiner =
nullptr;
3762 Expr *SubstInitializer =
nullptr;
3768 cast<DeclRefExpr>(
D->getCombinerIn())->getDecl(),
3769 cast<DeclRefExpr>(NewDRD->getCombinerIn())->getDecl());
3771 cast<DeclRefExpr>(
D->getCombinerOut())->getDecl(),
3772 cast<DeclRefExpr>(NewDRD->getCombinerOut())->getDecl());
3773 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
3776 SubstCombiner = SemaRef.
SubstExpr(Combiner, TemplateArgs).
get();
3786 cast<DeclRefExpr>(
D->getInitOrig())->getDecl(),
3787 cast<DeclRefExpr>(NewDRD->getInitOrig())->getDecl());
3789 cast<DeclRefExpr>(
D->getInitPriv())->getDecl(),
3790 cast<DeclRefExpr>(NewDRD->getInitPriv())->getDecl());
3795 cast<VarDecl>(cast<DeclRefExpr>(
D->getInitPriv())->getDecl());
3796 IsCorrect = IsCorrect && OldPrivParm->hasInit();
3802 NewDRD, SubstInitializer, OmpPrivParm);
3804 IsCorrect = IsCorrect && SubstCombiner &&
3807 SubstInitializer) ||
3809 !SubstInitializer));
3820 const bool RequiresInstantiation =
3821 D->getType()->isDependentType() ||
3822 D->getType()->isInstantiationDependentType() ||
3823 D->getType()->containsUnexpandedParameterPack();
3826 if (RequiresInstantiation) {
3832 SubstMapperTy =
D->getType();
3834 if (SubstMapperTy.
isNull())
3837 auto *PrevDeclInScope =
D->getPrevDeclInScope();
3838 if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
3839 PrevDeclInScope = cast<OMPDeclareMapperDecl>(
3843 bool IsCorrect =
true;
3849 (*
D->clauselist_begin())->getBeginLoc());
3854 cast<DeclRefExpr>(
D->getMapperVarRef())->getDecl(),
3855 cast<DeclRefExpr>(MapperVarRef.
get())->getDecl());
3856 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
3861 auto *OldC = cast<OMPMapClause>(
C);
3863 for (
Expr *OE : OldC->varlist()) {
3869 NewVars.push_back(NE);
3877 SS.
Adopt(NewQualifierLoc);
3883 OldC->getIteratorModifier(), OldC->getMapTypeModifiers(),
3884 OldC->getMapTypeModifiersLoc(), SS, NewNameInfo, OldC->getMapType(),
3885 OldC->isImplicitMapType(), OldC->getMapLoc(), OldC->getColonLoc(),
3887 Clauses.push_back(NewC);
3893 nullptr, Owner,
D->getDeclName(), SubstMapperTy,
D->
getLocation(),
3894 VN,
D->
getAccess(), MapperVarRef.
get(), Clauses, PrevDeclInScope);
3895 Decl *NewDMD = DG.
get().getSingleDecl();
3900Decl *TemplateDeclInstantiator::VisitOMPCapturedExprDecl(
3902 llvm_unreachable(
"Should not be met in templates");
3912 if (Inst && !
D->getDescribedFunctionTemplate())
3922 llvm_unreachable(
"There are only CXXRecordDecls in C++");
3926TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
3933 "can only instantiate an explicit specialization "
3934 "for a member class template");
3941 if (!InstClassTemplate)
3948 D->getTemplateArgsAsWritten()) {
3949 InstTemplateArgs.
setLAngleLoc(TemplateArgsInfo->getLAngleLoc());
3950 InstTemplateArgs.
setRAngleLoc(TemplateArgsInfo->getRAngleLoc());
3953 TemplateArgs, InstTemplateArgs))
3962 {},
false, SugaredConverted, CanonicalConverted,
3968 void *InsertPos =
nullptr;
3977 D->getSpecializationKind(),
3997 D->isThisDeclarationADefinition()) {
4000 diag::note_previous_definition);
4008 D->
getLocation(), InstClassTemplate, CanonicalConverted, PrevDecl);
4032 if (
D->isThisDeclarationADefinition() &&
4046 assert(VarTemplate &&
4047 "A template specialization without specialized template?");
4052 if (!InstVarTemplate)
4057 D->getTemplateArgsAsWritten()) {
4058 VarTemplateArgsInfo.
setLAngleLoc(TemplateArgsInfo->getLAngleLoc());
4059 VarTemplateArgsInfo.
setRAngleLoc(TemplateArgsInfo->getRAngleLoc());
4062 TemplateArgs, VarTemplateArgsInfo))
4069 InstVarTemplate,
D->
getLocation(), VarTemplateArgsInfo,
4070 {},
false, SugaredConverted, CanonicalConverted,
4075 void *InsertPos =
nullptr;
4089 InstVarTemplate,
D, VarTemplateArgsInfo, CanonicalConverted, PrevDecl);
4100 SemaRef.
SubstType(
D->getTypeSourceInfo(), TemplateArgs,
4101 D->getTypeSpecStartLoc(),
D->getDeclName());
4106 SemaRef.
Diag(
D->
getLocation(), diag::err_variable_instantiates_to_function)
4107 <<
D->isStaticDataMember() << DI->
getType();
4114 VarTemplate, DI->
getType(), DI,
D->getStorageClass(), Converted);
4117 void *InsertPos =
nullptr;
4130 StartingScope,
false, PrevDecl);
4136 llvm_unreachable(
"@defs is not supported in Objective-C++");
4143 "cannot instantiate %0 yet");
4151 llvm_unreachable(
"Concept definitions cannot reside inside a template");
4154Decl *TemplateDeclInstantiator::VisitImplicitConceptSpecializationDecl(
4156 llvm_unreachable(
"Concept specializations cannot reside inside a template");
4166 llvm_unreachable(
"Unexpected decl");
4177 SubstD = Instantiator.Visit(D);
4192 SemaRef.
Context.
BoolTy, FPT->getParamTypes(), FPT->getExtProtoInfo());
4203 assert(OldLoc &&
"type of function is not a function type?");
4205 for (
unsigned I = 0, N = OldLoc.getNumParams(); I != N; ++I)
4206 NewLoc.
setParam(I, OldLoc.getParam(I));
4216 if (Spaceship->isInvalidDecl())
4228 if (
auto *MD = dyn_cast<CXXMethodDecl>(Spaceship)) {
4233 assert(Spaceship->getFriendObjectKind() &&
4234 "defaulted spaceship is neither a member nor a friend");
4244 cast<NamedDecl>(R), Spaceship->getBeginLoc());
4248 return cast_or_null<FunctionDecl>(R);
4262 unsigned N = L->
size();
4266 for (
auto &
P : *L) {
4268 Params.push_back(
D);
4288 bool EvaluateConstraints) {
4335 ClassTemplate, PartialSpec->
getLocation(), InstTemplateArgs,
4337 false, SugaredConverted, CanonicalConverted))
4343 CanonicalConverted))
4348 void *InsertPos =
nullptr;
4363 ClassTemplate, CanonicalConverted, CanonType,
4391 diag::err_partial_spec_redeclared)
4393 SemaRef.
Diag(PrevDecl->
getLocation(), diag::note_prev_partial_spec_here)
4405 return InstPartialSpec;
4449 InstTemplateArgs, {},
4451 SugaredConverted, CanonicalConverted))
4457 CanonicalConverted))
4462 void *InsertPos =
nullptr;
4476 diag::err_variable_instantiates_to_function)
4513 diag::err_var_partial_spec_redeclared)
4516 diag::note_var_prev_partial_spec_here);
4527 LateAttrs, Owner, StartingScope);
4529 return InstPartialSpec;
4536 assert(OldTInfo &&
"substituting function without type source info");
4537 assert(Params.empty() &&
"parameter vector is non-empty at start");
4542 ThisContext = cast<CXXRecordDecl>(Owner);
4543 ThisTypeQuals = Method->getFunctionObjectParameterType().getQualifiers();
4547 OldTInfo, TemplateArgs,
D->getTypeSpecStartLoc(),
D->getDeclName(),
4548 ThisContext, ThisTypeQuals, EvaluateConstraints);
4554 if (NewTInfo != OldTInfo) {
4558 unsigned NewIdx = 0;
4559 for (
unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumParams();
4560 OldIdx != NumOldParams; ++OldIdx) {
4561 ParmVarDecl *OldParam = OldProtoLoc.getParam(OldIdx);
4567 std::optional<unsigned> NumArgumentsInExpansion;
4569 NumArgumentsInExpansion =
4572 if (!NumArgumentsInExpansion) {
4576 Params.push_back(NewParam);
4577 Scope->InstantiatedLocal(OldParam, NewParam);
4580 Scope->MakeInstantiatedLocalArgPack(OldParam);
4581 for (
unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
4583 Params.push_back(NewParam);
4584 Scope->InstantiatedLocalPackArg(OldParam, NewParam);
4593 cast<FunctionProtoType>(OldProtoLoc.getType());
4594 for (
unsigned i = 0, i_end = OldProtoLoc.getNumParams(); i != i_end;
4604 cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
4607 Params.push_back(Parm);
4624 TemplateArgs, ParamTypes, &Params,
4637 for (
auto *
decl : PatternDecl->
decls()) {
4638 if (!isa<VarDecl>(
decl) || isa<ParmVarDecl>(
decl))
4644 auto it = llvm::find_if(
Function->decls(), [&](
Decl *inst) {
4645 VarDecl *InstVD = dyn_cast<VarDecl>(inst);
4646 return InstVD && InstVD->isLocalVarDecl() &&
4647 InstVD->getIdentifier() == II;
4653 Scope.InstantiatedLocal(VD, *it);
4654 LSI->
addCapture(cast<VarDecl>(*it),
false,
false,
4660bool Sema::addInstantiatedParametersToScope(
4664 unsigned FParamIdx = 0;
4665 for (
unsigned I = 0, N = PatternDecl->
getNumParams(); I != N; ++I) {
4669 assert(FParamIdx < Function->getNumParams());
4687 Scope.InstantiatedLocal(PatternParam, FunctionParam);
4693 Scope.MakeInstantiatedLocalArgPack(PatternParam);
4694 std::optional<unsigned> NumArgumentsInExpansion =
4696 if (NumArgumentsInExpansion) {
4699 for (
unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
4712 Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
4755 false, std::nullopt,
4764 L->DefaultArgumentInstantiated(Param);
4786 Diag(PointOfInstantiation, diag::err_exception_spec_cycle) <<
Decl;
4798 false, std::nullopt,
4806 if (addInstantiatedParametersToScope(
Decl, Template,
Scope, TemplateArgs)) {
4846 if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
4847 ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
4848 if (isa<FunctionTemplateDecl>(ActiveInst.Entity)) {
4850 {ActiveInst.Entity->getCanonicalDecl(), ActiveInst.Kind});
4852 ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
4853 ActiveInst.Entity = New;
4859 assert(Proto &&
"Function template without prototype?");
4883 assert(NewProto &&
"Template instantiation without function prototype?");
4901 LateAttrs, StartingScope);
4917 if (isa<CXXDestructorDecl>(New) && SemaRef.
getLangOpts().CPlusPlus11)
4933 Lookups.reserve(DFI->getUnqualifiedLookups().size());
4934 bool AnyChanged =
false;
4937 DA.getDecl(), TemplateArgs);
4940 AnyChanged |= (
D != DA.getDecl());
4976 bool DefinitionRequired,
4984 Function->getTemplateSpecializationKindForInstantiation();
4991 !DefinitionRequired)
4996 if (
Function->isDefined(ExistingDefn,
5010 assert(PatternDecl &&
"instantiating a non-template");
5013 Stmt *Pattern =
nullptr;
5015 Pattern = PatternDef->
getBody(PatternDef);
5016 PatternDecl = PatternDef;
5018 PatternDef =
nullptr;
5024 Function->getInstantiatedFromMemberFunction(),
5025 PatternDecl, PatternDef, TSK,
5026 DefinitionRequired)) {
5027 if (DefinitionRequired)
5030 (
Function->isConstexpr() && !Recursive)) {
5034 Function->setInstantiationIsPending(
true);
5036 std::make_pair(
Function, PointOfInstantiation));
5038 if (llvm::isTimeTraceVerbose()) {
5039 llvm::timeTraceAddInstantEvent(
"DeferInstantiation", [&] {
5041 llvm::raw_string_ostream
OS(Name);
5050 Diag(PointOfInstantiation, diag::warn_func_template_missing)
5054 Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
5065 Function->setInstantiationIsPending(
true);
5067 std::make_pair(
Function, PointOfInstantiation));
5071 llvm::TimeTraceScope TimeScope(
"InstantiateFunction", [&]() {
5072 llvm::TimeTraceMetadata M;
5073 llvm::raw_string_ostream
OS(M.Detail);
5076 if (llvm::isTimeTraceVerbose()) {
5103 "missing LateParsedTemplate");
5105 Pattern = PatternDecl->
getBody(PatternDecl);
5112 "unexpected kind of function template definition");
5127 for (
auto *
D =
Function->getMostRecentDecl(); ;
5129 D->setImplicitlyInline();
5139 "instantiating function definition");
5143 Function->setVisibleDespiteOwningModule();
5158 ThisTypeQuals = Method->getMethodQualifiers();
5168 bool MergeWithParentScope =
false;
5170 MergeWithParentScope =
5171 Rec->isLocalClass() && !
Function->isFunctionTemplateSpecialization();
5174 auto RebuildTypeSourceInfoForDefaultSpecialMembers = [&]() {
5180 "Special member needs to be defaulted");
5188 auto *NewRec = dyn_cast<CXXRecordDecl>(
Function->getDeclContext());
5189 const auto *PatternRec =
5191 if (!NewRec || !PatternRec)
5193 if (!PatternRec->isLambda())
5196 struct SpecialMemberTypeInfoRebuilder
5216 getDerived().TransformDecl(TL.
getNameLoc(),
T->getDecl()));
5218 return Base::TransformRecordType(TLB, TL);
5220 QualType Result = getDerived().RebuildRecordType(NewDecl);
5221 if (Result.isNull())
5228 } IR{*
this, PatternRec, NewRec};
5231 assert(NewSI &&
"Type Transform failed?");
5233 Function->setTypeSourceInfo(NewSI);
5237 assert(NewParmSI &&
"Type transformation failed.");
5243 RebuildTypeSourceInfoForDefaultSpecialMembers();
5248 std::nullopt,
false, PatternDecl);
5266 if (addInstantiatedParametersToScope(
Function, PatternDecl,
Scope,
5283 Ctor->isDefaultConstructor()) {
5289 Body =
SubstStmt(Pattern, TemplateArgs);
5301 Listener->FunctionDefinitionInstantiated(
Function);
5311 LocalInstantiations.
perform();
5313 GlobalInstantiations.perform();
5339 bool IsMemberSpec =
false;
5341 if (
auto *PartialSpec =
5342 dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar)) {
5343 assert(PartialSpecArgs);
5344 IsMemberSpec = PartialSpec->isMemberSpecialization();
5346 PartialSpec, PartialSpecArgs->
asArray(),
false);
5349 IsMemberSpec =
VarTemplate->isMemberSpecialization();
5361 return cast_or_null<VarTemplateSpecializationDecl>(
5363 VarTemplate, FromVar, TemplateArgsInfo, Converted));
5370 "don't have a definition to instantiate from");
5399 bool InstantiatingVarTemplate,
5403 bool InstantiatingVarTemplatePartialSpec =
5404 isa<VarTemplatePartialSpecializationDecl>(OldVar) &&
5405 isa<VarTemplatePartialSpecializationDecl>(NewVar);
5408 bool InstantiatingSpecFromTemplate =
5409 isa<VarTemplateSpecializationDecl>(NewVar) &&
5411 isa<VarTemplatePartialSpecializationDecl>(OldVar));
5434 if (OldVar->
isUsed(
false))
5456 }
else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
5459 }
else if (PrevDeclForVarTemplateSpecialization) {
5460 Previous.addDecl(PrevDeclForVarTemplateSpecialization);
5464 if (!InstantiatingVarTemplate) {
5482 !InstantiatingSpecFromTemplate)
5489 dyn_cast<VarTemplateSpecializationDecl>(OldVar)) {
5491 !isa<VarTemplatePartialSpecializationDecl>(OldVTSD))
5492 cast<VarTemplateSpecializationDecl>(NewVar)->setSpecializationKind(
5501 if (InstantiatingVarTemplate || InstantiatingVarTemplatePartialSpec) {
5506 }
else if (InstantiatingSpecFromTemplate ||
5528 L->VariableDefinitionInstantiated(Var);
5555 if (!
Init.isInvalid()) {
5558 if (Var->
hasAttr<DLLImportAttr>() &&
5562 }
else if (InitExpr) {
5598 bool DefinitionRequired,
bool AtEndOfTU) {
5610 assert(PatternDecl &&
"no pattern for templated variable");
5615 dyn_cast<VarTemplateSpecializationDecl>(Var);
5626 (PatternDecl = PatternDecl->
getFirstDecl())->hasInit() &&
5634 "instantiating variable initializer");
5652 PreviousContext.
pop();
5656 LocalInstantiations.
perform();
5658 GlobalInstantiations.
perform();
5662 "not a static data member?");
5671 if (!Def && !DefinitionRequired) {
5674 std::make_pair(Var, PointOfInstantiation));
5679 Diag(PointOfInstantiation, diag::warn_var_template_missing)
5683 Diag(PointOfInstantiation, diag::note_inst_declaration_hint) << Var;
5694 PatternDecl, Def, TSK,
5695 DefinitionRequired))
5712 struct PassToConsumerRAII {
5717 : Consumer(Consumer), Var(Var) { }
5719 ~PassToConsumerRAII() {
5722 } PassToConsumerRAII(
Consumer, Var);
5729 PointOfInstantiation);
5737 "instantiating variable definition");
5757 }
else if (!VarSpec) {
5786 cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
5797 PreviousContext.
pop();
5800 PassToConsumerRAII.Var = Var;
5807 LocalInstantiations.
perform();
5809 GlobalInstantiations.
perform();
5821 for (
const auto *
Init : Tmpl->
inits()) {
5824 if (!
Init->isWritten())
5829 if (
Init->isPackExpansion()) {
5831 TypeLoc BaseTL =
Init->getTypeSourceInfo()->getTypeLoc();
5835 bool ShouldExpand =
false;
5836 bool RetainExpansion =
false;
5837 std::optional<unsigned> NumExpansions;
5841 TemplateArgs, ShouldExpand,
5848 assert(ShouldExpand &&
"Partial instantiation of base initializer?");
5851 for (
unsigned I = 0; I != *NumExpansions; ++I) {
5865 Init->getSourceLocation(),
5874 BaseTInfo, TempInit.
get(),
5882 NewInits.push_back(NewInit.
get());
5897 if (
Init->isDelegatingInitializer() ||
Init->isBaseInitializer()) {
5900 Init->getSourceLocation(),
5908 if (
Init->isBaseInitializer())
5914 }
else if (
Init->isMemberInitializer()) {
5916 Init->getMemberLocation(),
5926 Init->getSourceLocation());
5927 }
else if (
Init->isIndirectMemberInitializer()) {
5930 Init->getMemberLocation(),
5931 Init->getIndirectMember(), TemplateArgs));
5933 if (!IndirectMember) {
5940 Init->getSourceLocation());
5947 NewInits.push_back(NewInit.
get());
5966 Instance = Instance->getCanonicalDecl();
5967 if (Pattern == Instance)
return true;
5968 Instance = Instance->getInstantiatedFromMemberTemplate();
5979 Instance = Instance->getCanonicalDecl();
5980 if (Pattern == Instance)
return true;
5981 Instance = Instance->getInstantiatedFromMemberTemplate();
5991 = cast<ClassTemplatePartialSpecializationDecl>(Pattern->
getCanonicalDecl());
5993 Instance = cast<ClassTemplatePartialSpecializationDecl>(
5994 Instance->getCanonicalDecl());
5995 if (Pattern == Instance)
5997 Instance = Instance->getInstantiatedFromMember();
6008 Instance = Instance->getCanonicalDecl();
6009 if (Pattern == Instance)
return true;
6010 Instance = Instance->getInstantiatedFromMemberClass();
6021 Instance = Instance->getCanonicalDecl();
6022 if (Pattern == Instance)
return true;
6023 Instance = Instance->getInstantiatedFromMemberFunction();
6034 Instance = Instance->getCanonicalDecl();
6035 if (Pattern == Instance)
return true;
6036 Instance = Instance->getInstantiatedFromMemberEnum();
6063 bool OtherIsPackExpansion;
6065 if (
auto *OtherUUD = dyn_cast<T>(
Other)) {
6066 OtherIsPackExpansion = OtherUUD->isPackExpansion();
6068 }
else if (
auto *OtherUPD = dyn_cast<UsingPackDecl>(
Other)) {
6069 OtherIsPackExpansion =
true;
6070 OtherFrom = OtherUPD->getInstantiatedFromUsingDecl();
6071 }
else if (
auto *OtherUD = dyn_cast<UsingDecl>(
Other)) {
6072 OtherIsPackExpansion =
false;
6077 return Pattern->isPackExpansion() == OtherIsPackExpansion &&
6083 assert(Instance->isStaticDataMember());
6088 Instance = Instance->getCanonicalDecl();
6089 if (Pattern == Instance)
return true;
6090 Instance = Instance->getInstantiatedFromStaticDataMember();
6099 if (
auto *UUD = dyn_cast<UnresolvedUsingTypenameDecl>(
D))
6102 if (
auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(
D))
6108 if (
auto *
Record = dyn_cast<CXXRecordDecl>(
Other))
6114 if (
auto *
Enum = dyn_cast<EnumDecl>(
Other))
6117 if (
auto *Var = dyn_cast<VarDecl>(
Other))
6121 if (
auto *Temp = dyn_cast<ClassTemplateDecl>(
Other))
6124 if (
auto *Temp = dyn_cast<FunctionTemplateDecl>(
Other))
6127 if (
auto *PartialSpec =
6128 dyn_cast<ClassTemplatePartialSpecializationDecl>(
Other))
6132 if (
auto *Field = dyn_cast<FieldDecl>(
Other)) {
6133 if (!Field->getDeclName()) {
6136 cast<FieldDecl>(
D));
6140 if (
auto *Using = dyn_cast<UsingDecl>(
Other))
6143 if (
auto *Shadow = dyn_cast<UsingShadowDecl>(
Other))
6146 return D->getDeclName() &&
6147 D->getDeclName() == cast<NamedDecl>(
Other)->getDeclName();
6150template<
typename ForwardIterator>
6153 ForwardIterator first,
6154 ForwardIterator last) {
6155 for (; first != last; ++first)
6157 return cast<NamedDecl>(*first);
6164 if (
NamedDecl *
D = dyn_cast<NamedDecl>(DC)) {
6166 return cast_or_null<DeclContext>(ID);
6181 return cast<Decl>(DC)->getTemplateDepth() > Level;
6186 bool FindingInstantiatedContext) {
6208 if (isa<ParmVarDecl>(
D) && !ParentDependsOnArgs &&
6209 !cast<ParmVarDecl>(
D)->getType()->isInstantiationDependentType())
6211 if (isa<ParmVarDecl>(
D) || isa<NonTypeTemplateParmDecl>(
D) ||
6212 isa<TemplateTypeParmDecl>(
D) || isa<TemplateTemplateParmDecl>(
D) ||
6214 isa<OMPDeclareReductionDecl>(ParentDC) ||
6215 isa<OMPDeclareMapperDecl>(ParentDC))) ||
6216 (isa<CXXRecordDecl>(
D) && cast<CXXRecordDecl>(
D)->isLambda() &&
6217 cast<CXXRecordDecl>(
D)->getTemplateDepth() >
6224 return cast<NamedDecl>(FD);
6227 assert(PackIdx != -1 &&
6228 "found declaration pack but not pack expanding");
6230 return cast<NamedDecl>((*cast<DeclArgumentPack *>(*
Found))[PackIdx]);
6237 if (isa<NonTypeTemplateParmDecl>(
D) || isa<TemplateTypeParmDecl>(
D) ||
6238 isa<TemplateTemplateParmDecl>(
D))
6257 bool NeedInstantiate =
false;
6259 NeedInstantiate = RD->isLocalClass();
6260 else if (isa<TypedefNameDecl>(
D) &&
6262 NeedInstantiate =
true;
6264 NeedInstantiate = isa<EnumDecl>(
D);
6265 if (NeedInstantiate) {
6268 return cast<TypeDecl>(Inst);
6273 assert(isa<LabelDecl>(
D));
6276 assert(Inst &&
"Failed to instantiate label??");
6279 return cast<LabelDecl>(Inst);
6283 if (!
Record->isDependentContext())
6292 dyn_cast<ClassTemplateSpecializationDecl>(
Record))
6293 ClassTemplate = Spec->getSpecializedTemplate()->getCanonicalDecl();
6304 if (
CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
6308 = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
6328 auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FD);
6329 if (Guide && Guide->isImplicit()) {
6337 Unpacked = Arg.pack_elements();
6371 if (FindingInstantiatedContext &&
6373 Loc, cast<ClassTemplateSpecializationDecl>(SubstRecord))) {
6374 Diag(
Loc, diag::err_specialization_not_primary_template)
6391 if (!ParentDependsOnArgs)
6405 bool IsBeingInstantiated =
false;
6406 if (
CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
6407 if (!Spec->isDependentContext()) {
6410 assert(Tag &&
"type of non-dependent record is not a RecordType");
6411 if (Tag->isBeingDefined())
6412 IsBeingInstantiated =
true;
6413 if (!Tag->isBeingDefined() &&
6417 ParentDC = Tag->getDecl();
6424 if (
auto Name =
D->getDeclName()) {
6449 if (isa<UsingShadowDecl>(
D)) {
6456 }
else if (IsBeingInstantiated) {
6462 Diag(
Loc, diag::err_member_not_yet_instantiated)
6470 EnumDecl *
Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
6475 Diag(
Loc, diag::err_enumerator_does_not_exist)
6482 llvm_unreachable(
"Unable to find instantiation of declaration!");
6493 std::deque<PendingImplicitInstantiation> delayedPCHInstantiations;
6508 bool DefinitionRequired =
Function->getTemplateSpecializationKind() ==
6514 DefinitionRequired,
true);
6520 DefinitionRequired,
true);
6522 Function->setInstantiationIsPending(
false);
6525 if (!LocalOnly &&
LangOpts.PCHInstantiateTemplates &&
6527 delayedPCHInstantiations.push_back(Inst);
6532 VarDecl *Var = cast<VarDecl>(Inst.first);
6535 isa<VarTemplateSpecializationDecl>(Var)) &&
6536 "Not a static data member, nor a variable template"
6537 " specialization?");
6549 llvm_unreachable(
"Cannot instantitiate an undeclared specialization.");
6564 "instantiating variable definition");
6571 DefinitionRequired,
true);
6574 if (!LocalOnly &&
LangOpts.PCHInstantiateTemplates)
6580 for (
auto *DD : Pattern->
ddiags()) {
6581 switch (DD->getKind()) {
Defines the clang::ASTContext interface.
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
llvm::MachO::Record Record
This file declares semantic analysis functions specific to AMDGPU.
This file declares semantic analysis for CUDA constructs.
This file declares semantic analysis for HLSL constructs.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
This file declares semantic analysis functions specific to Swift.
static void instantiateDependentAMDGPUWavesPerEUAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AMDGPUWavesPerEUAttr &Attr, Decl *New)
static NamedDecl * findInstantiationOf(ASTContext &Ctx, NamedDecl *D, ForwardIterator first, ForwardIterator last)
static void instantiateDependentAMDGPUMaxNumWorkGroupsAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AMDGPUMaxNumWorkGroupsAttr &Attr, Decl *New)
static void instantiateDependentAMDGPUFlatWorkGroupSizeAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AMDGPUFlatWorkGroupSizeAttr &Attr, Decl *New)
static void instantiateDependentDiagnoseIfAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New)
static QualType adjustFunctionTypeForInstantiation(ASTContext &Context, FunctionDecl *D, TypeSourceInfo *TInfo)
Adjust the given function type for an instantiation of the given declaration, to cope with modificati...
static bool isRelevantAttr(Sema &S, const Decl *D, const Attr *A)
Determine whether the attribute A might be relevant to the declaration D.
static bool isDependentContextAtLevel(DeclContext *DC, unsigned Level)
Determine whether the given context is dependent on template parameters at level Level or below.
static void instantiateDependentModeAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const ModeAttr &Attr, Decl *New)
static void instantiateDependentCUDALaunchBoundsAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const CUDALaunchBoundsAttr &Attr, Decl *New)
static bool isDeclWithinFunction(const Decl *D)
static void instantiateDependentAssumeAlignedAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AssumeAlignedAttr *Aligned, Decl *New)
static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl, const MultiLevelTemplateArgumentList &TemplateArgs)
static void collectUnexpandedParameterPacks(Sema &S, TemplateParameterList *Params, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
static DeclT * getPreviousDeclForInstantiation(DeclT *D)
Get the previous declaration of a declaration for the purposes of template instantiation.
static Expr * instantiateDependentFunctionAttrCondition(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New)
static bool isInstantiationOf(ClassTemplateDecl *Pattern, ClassTemplateDecl *Instance)
static void instantiateDependentHLSLParamModifierAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const HLSLParamModifierAttr *Attr, Decl *New)
static void instantiateDependentAllocAlignAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AllocAlignAttr *Align, Decl *New)
static bool isInstantiationOfStaticDataMember(VarDecl *Pattern, VarDecl *Instance)
static void instantiateOMPDeclareSimdDeclAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const OMPDeclareSimdDeclAttr &Attr, Decl *New)
Instantiation of 'declare simd' attribute and its arguments.
static void instantiateDependentSYCLKernelAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const SYCLKernelAttr &Attr, Decl *New)
static void instantiateDependentAlignValueAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AlignValueAttr *Aligned, Decl *New)
static void instantiateDependentAlignedAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion)
static void instantiateOMPDeclareVariantAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const OMPDeclareVariantAttr &Attr, Decl *New)
Instantiation of 'declare variant' attribute and its arguments.
static void instantiateDependentEnableIfAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New)
static void instantiateDependentAnnotationAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AnnotateAttr *Attr, Decl *New)
static Sema::RetainOwnershipKind attrToRetainOwnershipKind(const Attr *A)
static bool isInstantiationOfUnresolvedUsingDecl(T *Pattern, Decl *Other, ASTContext &Ctx)
static bool isInvalid(LocType Loc, bool *Invalid)
Defines the SourceManager interface.
Defines the clang::TypeLoc interface and its subclasses.
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs.
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
virtual void HandleCXXStaticMemberVarInstantiation(VarDecl *D)
HandleCXXStaticMemberVarInstantiation - Tell the consumer that this.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
unsigned getManglingNumber(const NamedDecl *ND, bool ForAuxTarget=false) const
TypedefNameDecl * getTypedefNameForUnnamedTagDecl(const TagDecl *TD)
void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern)
Remember that the using decl Inst is an instantiation of the using decl Pattern of a class template.
QualType mergeFunctionTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool AllowCXX=false, bool IsConditionalOperator=false)
NamedDecl * getInstantiatedFromUsingDecl(NamedDecl *Inst)
If the given using decl Inst is an instantiation of another (possibly unresolved) using decl,...
DeclarationNameTable DeclarationNames
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
QualType getRecordType(const RecordDecl *Decl) const
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
unsigned getStaticLocalNumber(const VarDecl *VD) const
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
void forEachMultiversionedFunctionVersion(const FunctionDecl *FD, llvm::function_ref< void(FunctionDecl *)> Pred) const
Visits all versions of a multiversioned function with the passed predicate.
void setInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst, UsingEnumDecl *Pattern)
Remember that the using enum decl Inst is an instantiation of the using enum decl Pattern of a class ...
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
OMPTraitInfo & getNewOMPTraitInfo()
Return a new OMPTraitInfo object owned by this context.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
void setManglingNumber(const NamedDecl *ND, unsigned Number)
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
FieldDecl * getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) const
DeclaratorDecl * getDeclaratorForUnnamedTagDecl(const TagDecl *TD)
CanQualType UnsignedLongLongTy
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
const TargetInfo & getTargetInfo() const
void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl)
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
Represents an access specifier followed by colon ':'.
static AccessSpecDecl * Create(ASTContext &C, AccessSpecifier AS, DeclContext *DC, SourceLocation ASLoc, SourceLocation ColonLoc)
Attr - This represents one attribute.
attr::Kind getKind() const
Attr * clone(ASTContext &C) const
SourceLocation getLocation() const
SourceRange getRange() const
SourceLocation getLoc() const
Represents a C++ declaration that introduces decls from somewhere else.
A binding in a decomposition declaration.
static BindingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id)
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
Represents a C++ constructor within a class.
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor(), Expr *TrailingRequiresClause=nullptr)
Represents a C++ conversion function within a class.
static CXXConversionDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Represents a C++ deduction guide declaration.
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation, CXXConstructorDecl *Ctor=nullptr, DeductionCandidate Kind=DeductionCandidate::Normal, Expr *TrailingRequiresClause=nullptr, const CXXDeductionGuideDecl *SourceDG=nullptr, SourceDeductionGuideKind SK=SourceDeductionGuideKind::None)
Represents a C++ destructor within a class.
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
Represents a static or instance method of a struct/union/class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Represents a C++ struct/union/class.
CXXRecordDecl * getDefinition() const
static CXXRecordDecl * CreateLambda(const ASTContext &C, DeclContext *DC, TypeSourceInfo *Info, SourceLocation Loc, unsigned DependencyKind, bool IsGeneric, LambdaCaptureDefault CaptureDefault)
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
void setInstantiationOfMemberClass(CXXRecordDecl *RD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member class RD.
void setDescribedClassTemplate(ClassTemplateDecl *Template)
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
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.
void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D, void *InsertPos)
Insert the specified partial specialization knowing that it is not already in.
ClassTemplateDecl * getMostRecentDecl()
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
ClassTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, TemplateParameterList *TPL, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a class template node.
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
ClassTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *D)
Find a class template partial specialization which was instantiated from the given member partial spe...
void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
void setCommonPtr(Common *C)
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template.
Common * getCommonPtr() const
ClassTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
void setInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *PartialSpec)
static ClassTemplatePartialSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, QualType CanonInjectedType, ClassTemplatePartialSpecializationDecl *PrevDecl)
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
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.
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Retrieve the template argument list as written in the sources, if any.
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
void setExternKeywordLoc(SourceLocation Loc)
Sets the location of the extern keyword.
void setSpecializationKind(TemplateSpecializationKind TSK)
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)
Set the template argument list as written in the sources.
Declaration of a C++20 concept.
const TypeClass * getTypePtr() const
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
A POD class for pairing a NamedDecl* with an access specifier.
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...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isFileContext() const
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
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.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void addDecl(Decl *D)
Add the declaration D into this context.
decl_iterator decls_end() const
ddiag_range ddiags() const
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
decl_iterator decls_begin() const
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
SourceLocation getEndLoc() const LLVM_READONLY
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it's a function-local extern declaration.
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
bool isParameterPack() const
Whether this declaration is a parameter pack.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
bool isInIdentifierNamespace(unsigned NS) const
@ FOK_None
Not a friend object.
bool isReferenced() const
Whether any declaration of this entity was referenced.
unsigned getTemplateDepth() const
Determine the number of levels of template parameter surrounding this declaration.
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it's the object of a friend declaration.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
bool isInLocalScopeForInstantiation() const
Determine whether a substitution into this declaration would occur as part of a substitution into a d...
DeclContext * getNonTransparentDeclContext()
Return the non transparent context.
virtual bool hasBody() const
Returns true if this Decl represents a declaration for a body of code, such as a function or method d...
bool isInvalidDecl() const
bool isLocalExternDecl() const
Determine whether this is a block-scope declaration with linkage.
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
const char * getDeclKindName() const
@ IDNS_Ordinary
Ordinary names.
void setImplicit(bool I=true)
void setReferenced(bool R=true)
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
SourceLocation getBeginLoc() const LLVM_READONLY
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
void setLexicalDeclContext(DeclContext *DC)
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
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.
NameKind getNameKind() const
Determine what kind of name this is.
Represents a ValueDecl that came out of a declarator.
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
void setTypeSourceInfo(TypeSourceInfo *TI)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
TypeSourceInfo * getTypeSourceInfo() const
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Represents the type decltype(expr) (C++11).
Expr * getUnderlyingExpr() const
A decomposition declaration.
static DecompositionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation LSquareLoc, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< BindingDecl * > Bindings)
Provides information about a dependent function-template specialization declaration.
Represents a qualified type name for which the type name is dependent.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
bool hasErrorOccurred() const
RAII object that enters a new expression evaluation context.
An instance of this object exists for each enum constant that is defined.
enumerator_range enumerators() const
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists,...
EnumDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this enumeration is a member of a specialization of a templated class, determine what kind of temp...
Store information needed for an explicit specifier.
ExplicitSpecKind getKind() const
bool isInvalid() const
Determine if the explicit specifier is invalid.
static ExplicitSpecifier Invalid()
const Expr * getExpr() const
void setKind(ExplicitSpecKind Kind)
static ExplicitSpecifier getFromDecl(FunctionDecl *Function)
This represents one expression.
static bool isPotentialConstantExprUnevaluated(Expr *E, const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExprUnevaluated - Return true if this expression might be usable in a constant exp...
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant,...
Declaration context for names declared as extern "C" in C++.
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, SourceLocation EllipsisLoc={}, ArrayRef< TemplateParameterList * > FriendTypeTPLists={})
void setUnsupportedFriend(bool Unsupported)
Declaration of a friend template.
static DefaultedOrDeletedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups, StringLiteral *DeletedMessage=nullptr)
Represents a function declaration or definition.
void setInstantiationIsPending(bool IC)
State that the instantiation of this function is pending.
const ParmVarDecl * getParamDecl(unsigned i) const
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
void setInstantiationOfMemberFunction(FunctionDecl *FD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member function FD.
QualType getReturnType() const
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
void setVirtualAsWritten(bool V)
State that this function is marked as virtual explicitly.
bool hasSkippedBody() const
True if the function was a definition but its body was skipped.
FunctionDecl * getDefinition()
Get the definition for this declaration.
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, Expr *TrailingRequiresClause=nullptr)
bool isThisDeclarationInstantiatedFromAFriendDefinition() const
Determine whether this specific declaration of the function is a friend declaration that was instanti...
void setRangeEnd(SourceLocation E)
bool isDefaulted() const
Whether this function is defaulted.
void setIneligibleOrNotSelected(bool II)
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template, TemplateArgumentList *TemplateArgs, void *InsertPos, TemplateSpecializationKind TSK=TSK_ImplicitInstantiation, TemplateArgumentListInfo *TemplateArgsAsWritten=nullptr, SourceLocation PointOfInstantiation=SourceLocation())
Specify that this function declaration is actually a function template specialization.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
DeclarationNameInfo getNameInfo() const
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
DefaultedOrDeletedFunctionInfo * getDefalutedOrDeletedInfo() const
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
Represents a prototype with parameter type info, e.g.
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
QualType getParamType(unsigned i) const
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
ExtProtoInfo getExtProtoInfo() const
FunctionDecl * getExceptionSpecTemplate() const
If this function type has an uninstantiated exception specification, this is the function whose excep...
ArrayRef< QualType > getParamTypes() const
Declaration of a template function.
FunctionTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
FunctionTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
ParmVarDecl * getParam(unsigned i) const
void setParam(unsigned i, ParmVarDecl *VD)
ExtInfo getExtInfo() const
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute.
QualType getReturnType() const
HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
Represents a field injected from an anonymous union/struct into the parent scope.
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, const IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl * > CH)
Description of a constructor that was inherited from a base class.
const TypeClass * getTypePtr() const
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Represents the declaration of a label.
static LabelDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II)
A stack-allocated class that identifies which local variable declaration instantiations are present i...
void InstantiatedLocal(const Decl *D, Decl *Inst)
LocalInstantiationScope * cloneScopes(LocalInstantiationScope *Outermost)
Clone this scope, and all outer scopes, down to the given outermost scope.
llvm::PointerUnion< Decl *, DeclArgumentPack * > * findInstantiationOf(const Decl *D)
Find the instantiation of the declaration D within the current instantiation scope.
Represents the results of name lookup.
An instance of this class represents the declaration of a property member.
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
Provides information a specialization of a member of a class template, which may be a member function...
Data structure that captures multiple levels of template argument lists for use in template instantia...
const ArgList & getInnermost() const
Retrieve the innermost template argument list.
void addOuterTemplateArguments(Decl *AssociatedDecl, ArgList Args, bool Final)
Add a new outmost level to the multi-level template argument list.
unsigned getNumLevels() const
Determine the number of levels in this template argument list.
void setKind(TemplateSubstitutionKind K)
unsigned getNumSubstitutedLevels() const
Determine the number of substituted levels in this template argument list.
void addOuterRetainedLevels(unsigned Num)
unsigned getNumRetainedOuterLevels() const
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
bool hasLinkage() const
Determine whether this declaration has linkage.
void setDeclName(DeclarationName N)
Set the name of this declaration.
Represents a C++ namespace alias.
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
bool hasQualifier() const
Evaluates true when this nested-name-specifier location is non-empty.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
This represents '#pragma omp allocate ...' directive.
Pseudo declaration for capturing expressions.
This is a basic class for representing single OpenMP clause.
This represents '#pragma omp declare mapper ...' directive.
This represents '#pragma omp declare reduction ...' directive.
This represents '#pragma omp requires...' directive.
This represents '#pragma omp threadprivate ...' directive.
Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...
bool anyScoreOrCondition(llvm::function_ref< bool(Expr *&, bool)> Cond)
Represents a field declaration created by an @defs(...).
Wrapper for void* pointer.
static OpaquePtr make(QualType P)
SourceLocation getEllipsisLoc() const
TypeLoc getPatternLoc() const
Represents a pack expansion of types.
std::optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
Represents a parameter to a function.
bool hasUninstantiatedDefaultArg() const
Represents a #pragma detect_mismatch line.
PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...
A (possibly-)qualified type.
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.
Represents a struct/union/class.
Wrapper for source info for record types.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD)
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Represents the body of a requires-expression.
static RequiresExprBodyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc)
Scope - A scope is a transient data structure that is used while parsing the program.
void addAMDGPUFlatWorkGroupSizeAttr(Decl *D, const AttributeCommonInfo &CI, Expr *Min, Expr *Max)
addAMDGPUFlatWorkGroupSizeAttr - Adds an amdgpu_flat_work_group_size attribute to a particular declar...
void addAMDGPUWavesPerEUAttr(Decl *D, const AttributeCommonInfo &CI, Expr *Min, Expr *Max)
addAMDGPUWavePersEUAttr - Adds an amdgpu_waves_per_eu attribute to a particular declaration.
void addAMDGPUMaxNumWorkGroupsAttr(Decl *D, const AttributeCommonInfo &CI, Expr *XExpr, Expr *YExpr, Expr *ZExpr)
addAMDGPUMaxNumWorkGroupsAttr - Adds an amdgpu_max_num_work_groups attribute to a particular declarat...
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
void checkAllowedInitializer(VarDecl *VD)
QualType getInoutParameterType(QualType Ty)
bool inferObjCARCLifetime(ValueDecl *decl)
void AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI, Sema::RetainOwnershipKind K, bool IsTemplateInstantiation)
DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd(Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid)
Called at the end of '#pragma omp declare reduction'.
void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner)
Finish current declare reduction construct initializer.
ExprResult ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S, QualType MapperType, SourceLocation StartLoc, DeclarationName VN)
Build the mapper variable of '#pragma omp declare mapper'.
VarDecl * ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D)
Initialize declare reduction construct initializer.
QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc, TypeResult ParsedType)
Check if the specified type is allowed to be used in 'omp declare reduction' construct.
DeclGroupPtrTy ActOnOpenMPAllocateDirective(SourceLocation Loc, ArrayRef< Expr * > VarList, ArrayRef< OMPClause * > Clauses, DeclContext *Owner=nullptr)
Called on well-formed '#pragma omp allocate'.
DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart(Scope *S, DeclContext *DC, DeclarationName Name, ArrayRef< std::pair< QualType, SourceLocation > > ReductionTypes, AccessSpecifier AS, Decl *PrevDeclInScope=nullptr)
Called on start of '#pragma omp declare reduction'.
OMPClause * ActOnOpenMPAllocatorClause(Expr *Allocator, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'allocator' clause.
void EndOpenMPDSABlock(Stmt *CurDirective)
Called on end of data sharing attribute block.
QualType ActOnOpenMPDeclareMapperType(SourceLocation TyLoc, TypeResult ParsedType)
Check if the specified type is allowed to be used in 'omp declare mapper' construct.
std::optional< std::pair< FunctionDecl *, Expr * > > checkOpenMPDeclareVariantFunction(DeclGroupPtrTy DG, Expr *VariantRef, OMPTraitInfo &TI, unsigned NumAppendArgs, SourceRange SR)
Checks '#pragma omp declare variant' variant function and original functions after parsing of the ass...
void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D)
Initialize declare reduction construct initializer.
OMPClause * ActOnOpenMPMapClause(Expr *IteratorModifier, ArrayRef< OpenMPMapModifierKind > MapTypeModifiers, ArrayRef< SourceLocation > MapTypeModifiersLoc, CXXScopeSpec &MapperIdScopeSpec, DeclarationNameInfo &MapperId, OpenMPMapClauseKind MapType, bool IsMapTypeImplicit, SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef< Expr * > VarList, const OMPVarListLocTy &Locs, bool NoDiagnose=false, ArrayRef< Expr * > UnresolvedMappers={})
Called on well-formed 'map' clause.
void StartOpenMPDSABlock(OpenMPDirectiveKind K, const DeclarationNameInfo &DirName, Scope *CurScope, SourceLocation Loc)
Called on start of new data sharing attribute block.
OMPThreadPrivateDecl * CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef< Expr * > VarList)
Builds a new OpenMPThreadPrivateDecl and checks its correctness.
void ActOnOpenMPDeclareVariantDirective(FunctionDecl *FD, Expr *VariantRef, OMPTraitInfo &TI, ArrayRef< Expr * > AdjustArgsNothing, ArrayRef< Expr * > AdjustArgsNeedDevicePtr, ArrayRef< OMPInteropInfo > AppendArgs, SourceLocation AdjustArgsLoc, SourceLocation AppendArgsLoc, SourceRange SR)
Called on well-formed '#pragma omp declare variant' after parsing of the associated method/function.
void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer, VarDecl *OmpPrivParm)
Finish current declare reduction construct initializer.
DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen, ArrayRef< Expr * > Uniforms, ArrayRef< Expr * > Aligneds, ArrayRef< Expr * > Alignments, ArrayRef< Expr * > Linears, ArrayRef< unsigned > LinModifiers, ArrayRef< Expr * > Steps, SourceRange SR)
Called on well-formed '#pragma omp declare simd' after parsing of the associated method/function.
OMPClause * ActOnOpenMPAlignClause(Expr *Alignment, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'align' clause.
DeclGroupPtrTy ActOnOpenMPDeclareMapperDirective(Scope *S, DeclContext *DC, DeclarationName Name, QualType MapperType, SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS, Expr *MapperVarRef, ArrayRef< OMPClause * > Clauses, Decl *PrevDeclInScope=nullptr)
Called on start of '#pragma omp declare mapper'.
void AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI, ParameterABI abi)
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...
CXXSpecialMemberKind asSpecialMember() const
A helper class for building up ExtParameterInfos.
Records and restores the CurFPFeatures state on entry/exit of compound statements.
RAII class used to indicate that we are performing provisional semantic analysis to determine the val...
Sema - This implements semantic analysis and AST building for C.
MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, CXXRecordDecl *ClassDecl)
VarTemplateSpecializationDecl * BuildVarTemplateInstantiation(VarTemplateDecl *VarTemplate, VarDecl *FromVar, const TemplateArgumentList *PartialSpecArgs, const TemplateArgumentListInfo &TemplateArgsInfo, SmallVectorImpl< TemplateArgument > &Converted, SourceLocation PointOfInstantiation, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *StartingScope=nullptr)
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.
bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R=nullptr, const UsingDecl *UD=nullptr)
Checks that the given nested-name qualifier used in a using decl in the current context is appropriat...
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...
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupUsingDeclName
Look up all declarations in a scope with the given name, including resolved using declarations.
@ LookupRedeclarationWithLinkage
Look up an ordinary name that is going to be redeclared as a name with linkage.
Decl * ActOnSkippedFunctionBody(Decl *Decl)
Decl * BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *AssertMessageExpr, SourceLocation RParenLoc, bool Failed)
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)
NamedDecl * FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, bool FindingInstantiatedContext=false)
Find the instantiation of the given declaration within the current instantiation.
MemInitResult BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo, Expr *Init, CXXRecordDecl *ClassDecl, SourceLocation EllipsisLoc)
bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, bool IsPackExpansion)
AddAlignedAttr - Adds an aligned attribute to a particular declaration.
AccessResult CheckFriendAccess(NamedDecl *D)
Checks access to the target of a friend declaration.
const TranslationUnitKind TUKind
The kind of translation unit we are processing.
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 InstantiateExceptionSpec(SourceLocation PointOfInstantiation, FunctionDecl *Function)
void AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, Expr *OE)
AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular declaration.
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
bool TemplateParameterListsAreEqual(const TemplateCompareNewDeclInfo &NewInstFrom, TemplateParameterList *New, const NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
void CheckOverrideControl(NamedDecl *D)
CheckOverrideControl - Check C++11 override control semantics.
const ExpressionEvaluationContextRecord & currentEvaluationContext() const
llvm::DenseSet< std::pair< Decl *, unsigned > > InstantiatingSpecializations
Specializations whose definitions are currently being instantiated.
void deduceOpenCLAddressSpace(ValueDecl *decl)
PragmaStack< FPOptionsOverride > FpPragmaStack
FunctionDecl * InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD, const TemplateArgumentList *Args, SourceLocation Loc, CodeSynthesisContext::SynthesisKind CSC=CodeSynthesisContext::ExplicitTemplateArgumentSubstitution)
Instantiate (or find existing instantiation of) a function template with a given set of template argu...
bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec)
tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, const DefaultArguments &DefaultArgs, bool PartialTemplateArgs, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, bool UpdateArgsWithConversions=true, bool *ConstraintsNotSatisfied=nullptr, bool PartialOrderingTTP=false, bool *MatchedPackOnParmToNonPackOnArg=nullptr)
Check that the given template arguments can be provided to the given template, converting the argumen...
ExprResult SubstInitializer(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs, bool CXXDirectInit)
MemInitResult BuildMemberInitializer(ValueDecl *Member, Expr *Init, SourceLocation IdLoc)
UsingShadowDecl * BuildUsingShadowDecl(Scope *S, BaseUsingDecl *BUD, NamedDecl *Target, UsingShadowDecl *PrevDecl)
Builds a shadow declaration corresponding to a 'using' declaration.
void CheckThreadLocalForLargeAlignment(VarDecl *VD)
void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)
ExpressionEvaluationContextRecord & parentEvaluationContext()
LateParsedTemplateMapT LateParsedTemplateMap
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...
void CheckTemplatePartialSpecialization(ClassTemplatePartialSpecializationDecl *Partial)
StmtResult SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs)
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc, TemplateDecl *PrimaryTemplate, unsigned NumExplicitArgs, ArrayRef< TemplateArgument > Args)
Check the non-type template arguments of a class template partial specialization according to C++ [te...
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.
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
void InstantiateMemInitializers(CXXConstructorDecl *New, const CXXConstructorDecl *Tmpl, const MultiLevelTemplateArgumentList &TemplateArgs)
void CleanupVarDeclMarking()
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 inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord)
Add gsl::Pointer attribute to std::container::iterator.
NamedDecl * BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation, bool IsUsingIfExists)
Builds a using declaration.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
bool SubstTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentListInfo &Outputs)
void HandleDependentAccessCheck(const DependentDiagnostic &DD, const MultiLevelTemplateArgumentList &TemplateArgs)
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend=false)
Perform semantic analysis for the given function template specialization.
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
NamedReturnInfo getNamedReturnInfo(Expr *&E, SimplerImplicitMoveMode Mode=SimplerImplicitMoveMode::Normal)
Determine whether the given expression might be move-eligible or copy-elidable in either a (co_)retur...
bool CheckEnumUnderlyingType(TypeSourceInfo *TI)
Check that this is a valid underlying type for an enum declaration.
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 AddModeAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Name, bool InInstantiation=false)
AddModeAttr - Adds a mode attribute to a particular declaration.
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument.
const LangOptions & LangOpts
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 PerformPendingInstantiations(bool LocalOnly=false)
Performs template instantiation for all implicit template instantiations we have seen until this poin...
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr, FnBodyKind BodyKind=FnBodyKind::Other)
VarTemplateSpecializationDecl * CompleteVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiates a variable template specialization by completing it with appropriate type information an...
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn)
Perform semantic checking of a new function declaration.
FieldDecl * CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitfieldWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D=nullptr)
Build a new FieldDecl and check its well-formedness.
void updateAttrsForLateParsedTemplate(const Decl *Pattern, Decl *Inst)
Update instantiation attributes after template was late parsed.
bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange)
Mark the given method pure.
void InstantiateVariableInitializer(VarDecl *Var, VarDecl *OldVar, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the initializer of a variable.
SmallVector< PendingImplicitInstantiation, 1 > LateParsedInstantiations
Queue of implicit template instantiations that cannot be performed eagerly.
DeclarationNameInfo SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, const MultiLevelTemplateArgumentList &TemplateArgs)
Do template substitution on declaration name info.
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
const VarDecl * getCopyElisionCandidate(NamedReturnInfo &Info, QualType ReturnType)
Updates given NamedReturnInfo's move-eligible and copy-elidable statuses, considering the function re...
bool RequireCompleteEnumDecl(EnumDecl *D, SourceLocation L, CXXScopeSpec *SS=nullptr)
Require that the EnumDecl is completed with its enumerators defined or instantiated.
void AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI, Expr *ParamExpr)
AddAllocAlignAttr - Adds an alloc_align attribute to a particular declaration.
bool usesPartialOrExplicitSpecialization(SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec)
std::optional< unsigned > getNumArgumentsInExpansion(QualType T, const MultiLevelTemplateArgumentList &TemplateArgs)
Determine the number of arguments in the given pack expansion type.
ExplicitSpecifier instantiateExplicitSpecifier(const MultiLevelTemplateArgumentList &TemplateArgs, ExplicitSpecifier ES)
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...
bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous)
Perform semantic checking on a newly-created variable declaration.
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
bool CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Target, const LookupResult &PreviousDecls, UsingShadowDecl *&PrevShadow)
Determines whether to create a using shadow decl for a particular decl, given the set of decls existi...
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
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...
void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T)
Mark all of the declarations referenced within a particular AST node as referenced.
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...
SourceManager & getSourceManager() const
FunctionDecl * SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD, FunctionDecl *Spaceship)
Substitute the name and return type of a defaulted 'operator<=>' to form an implicit 'operator=='.
void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, Decl *EnumDecl, ArrayRef< Decl * > Elements, Scope *S, const ParsedAttributesView &Attr)
Decl * SubstDecl(Decl *D, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs)
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI, SourceLocation Loc)
Check that the type of a non-type template parameter is well-formed.
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
void ActOnMemInitializers(Decl *ConstructorDecl, SourceLocation ColonLoc, ArrayRef< CXXCtorInitializer * > MemInits, bool AnyErrors)
ActOnMemInitializers - Handle the member initializers for a constructor.
TemplateParameterList * SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs, bool EvaluateConstraints=true)
void AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI, Expr *MaxThreads, Expr *MinBlocks, Expr *MaxBlocks)
AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular declaration.
void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don't have one.
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.
void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor)
In the MS ABI, we need to instantiate default arguments of dllexported default constructors along wit...
RedeclarationKind forRedeclarationInCurContext() const
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 CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Previous)
Checks that the given using declaration is not an invalid redeclaration.
bool SubstDefaultArgument(SourceLocation Loc, ParmVarDecl *Param, const MultiLevelTemplateArgumentList &TemplateArgs, bool ForCallExpr=false)
Substitute the given template arguments into the default argument.
void InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
EnumConstantDecl * CheckEnumConstant(EnumDecl *Enum, EnumConstantDecl *LastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, Expr *val)
void DiagnoseUnusedNestedTypedefs(const RecordDecl *D)
bool hasUncompilableErrorOccurred() const
Whether uncompilable error has occurred.
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed.
bool CheckInheritingConstructorUsingDecl(UsingDecl *UD)
Additional checks for a using declaration referring to a constructor name.
@ 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...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
void CheckStaticLocalForDllExport(VarDecl *VD)
Check if VD needs to be dllexport/dllimport due to being in a dllexport/import function.
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
LateTemplateParserCB * LateTemplateParser
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
bool RebuildingImmediateInvocation
Whether the AST is currently being rebuilt to correct immediate invocations.
SourceManager & SourceMgr
bool CheckAlignasTypeArgument(StringRef KWName, TypeSourceInfo *TInfo, SourceLocation OpLoc, SourceRange R)
NamedDecl * BuildUsingPackDecl(NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl * > Expansions)
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc, StringLiteral *Message=nullptr)
NamespaceDecl * getStdNamespace() const
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
Attr * CreateAnnotationAttr(const AttributeCommonInfo &CI, StringRef Annot, MutableArrayRef< Expr * > Args)
CreateAnnotationAttr - Creates an annotation Annot with Args arguments.
@ TPC_FriendFunctionTemplate
@ TPC_FriendFunctionTemplateDefinition
void DiagnoseUnusedDecl(const NamedDecl *ND)
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope.
void ActOnUninitializedDecl(Decl *dcl)
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
void BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar, const MultiLevelTemplateArgumentList &TemplateArgs, LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner, LocalInstantiationScope *StartingScope, bool InstantiatingVarTemplate=false, VarTemplateSpecializationDecl *PrevVTSD=nullptr)
BuildVariableInstantiation - Used after a new variable has been created.
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC, SkipBodyInfo *SkipBody=nullptr)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
void CheckAlignasUnderalignment(Decl *D)
std::pair< ValueDecl *, SourceLocation > PendingImplicitInstantiation
An entity for which implicit template instantiation is required.
DeclContext * FindInstantiatedContext(SourceLocation Loc, DeclContext *DC, const MultiLevelTemplateArgumentList &TemplateArgs)
Finds the instantiation of the given declaration context within the current instantiation.
bool isIncompatibleTypedef(const TypeDecl *Old, TypedefNameDecl *New)
void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E)
AddAlignValueAttr - Adds an align_value attribute to a particular declaration.
ArrayRef< sema::FunctionScopeInfo * > getFunctionScopes() const
void PerformDependentDiagnostics(const DeclContext *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
bool checkStringLiteralArgumentAttr(const AttributeCommonInfo &CI, const Expr *E, StringRef &Str, SourceLocation *ArgLocation=nullptr)
Check if the argument E is a ASCII string literal.
bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy, bool IsFixed, const EnumDecl *Prev)
Check whether this is a valid redeclaration of a previous enumeration.
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr, bool SkipImmediateInvocations=true)
Instantiate or parse a C++ default argument expression as necessary.
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.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
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.
SourceLocation getEnd() const
Represents a C++11 static_assert declaration.
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
Represents the declaration of a struct/union/class/enum.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
TypedefNameDecl * getTypedefNameForAnonDecl() const
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type?
TagKind getTagKind() const
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void addArgument(const TemplateArgumentLoc &Loc)
A template argument list.
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Location wrapper for a TemplateArgument.
Represents a template argument.
@ Pack
The template argument is actually a parameter pack.
@ RewriteSpaceshipAsEqualEqual
void setEvaluateConstraints(bool B)
Decl * VisitDecl(Decl *D)
Decl * VisitVarDecl(VarDecl *D, bool InstantiatingVarTemplate, ArrayRef< BindingDecl * > *Bindings=nullptr)
bool InitMethodInstantiation(CXXMethodDecl *New, CXXMethodDecl *Tmpl)
Initializes common fields of an instantiated method declaration (New) from the corresponding fields o...
bool InitFunctionInstantiation(FunctionDecl *New, FunctionDecl *Tmpl)
Initializes the common fields of an instantiation function declaration (New) from the corresponding f...
VarTemplatePartialSpecializationDecl * InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a variable template partial specialization.
void adjustForRewrite(RewriteKind RK, FunctionDecl *Orig, QualType &T, TypeSourceInfo *&TInfo, DeclarationNameInfo &NameInfo)
TypeSourceInfo * SubstFunctionType(FunctionDecl *D, SmallVectorImpl< ParmVarDecl * > &Params)
Decl * VisitVarTemplateSpecializationDecl(VarTemplateDecl *VarTemplate, VarDecl *FromVar, const TemplateArgumentListInfo &TemplateArgsInfo, ArrayRef< TemplateArgument > Converted, VarTemplateSpecializationDecl *PrevDecl=nullptr)
void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)
Decl * VisitFunctionDecl(FunctionDecl *D, TemplateParameterList *TemplateParams, RewriteKind RK=RewriteKind::None)
Normal class members are of more specific types and therefore don't make it here.
Decl * VisitCXXMethodDecl(CXXMethodDecl *D, TemplateParameterList *TemplateParams, RewriteKind RK=RewriteKind::None)
Decl * InstantiateTypeAliasTemplateDecl(TypeAliasTemplateDecl *D)
Decl * VisitBaseUsingDecls(BaseUsingDecl *D, BaseUsingDecl *Inst, LookupResult *Lookup)
bool SubstQualifier(const DeclaratorDecl *OldDecl, DeclaratorDecl *NewDecl)
TemplateParameterList * SubstTemplateParams(TemplateParameterList *List)
Instantiates a nested template parameter list in the current instantiation context.
Decl * InstantiateTypedefNameDecl(TypedefNameDecl *D, bool IsTypeAlias)
ClassTemplatePartialSpecializationDecl * InstantiateClassTemplatePartialSpecialization(ClassTemplateDecl *ClassTemplate, ClassTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a class template partial specialization.
bool SubstDefaultedFunction(FunctionDecl *New, FunctionDecl *Tmpl)
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.
bool isNull() const
Determine whether this template name is NULL.
A template parameter object.
Stores a list of template parameters for a TemplateDecl and its derived classes.
SourceRange getSourceRange() const LLVM_READONLY
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
ArrayRef< NamedDecl * > asArray()
SourceLocation getTemplateLoc() const
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, bool Typename, TemplateParameterList *Params)
Declaration of a template type parameter.
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter.
The top declaration context.
Represents the declaration of a typedef-name via a C++11 alias-declaration.
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Declaration of an alias template.
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
void setTypeForDecl(const Type *TD)
const Type * getTypeForDecl() const
SourceLocation getBeginLoc() const LLVM_READONLY
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
Base wrapper for a particular "section" of type source info.
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.
AutoTypeLoc getContainedAutoTypeLoc() const
Get the typeloc of an AutoType whose type will be deduced for a variable with an initializer of this ...
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
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)
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isRValueReferenceType() const
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isLValueReferenceType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool containsErrors() const
Whether this type is an error type.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isFunctionType() const
const T * getAs() const
Member-template getAs<specific type>'.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
Base class for declarations which introduce a typedef-name.
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
This node is generated when a using-declaration that was annotated with attribute((using_if_exists)) ...
static UnresolvedUsingIfExistsDecl * Create(ASTContext &Ctx, DeclContext *DC, SourceLocation Loc, DeclarationName Name)
Represents a dependent using declaration which was marked with typename.
SourceLocation getTypenameLoc() const
Returns the source location of the 'typename' keyword.
Represents a dependent using declaration which was not marked with typename.
Represents a C++ using-declaration.
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
Represents C++ using-directive.
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Represents a C++ using-enum-declaration.
static UsingEnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, SourceLocation EnumL, SourceLocation NameL, TypeSourceInfo *EnumType)
Represents a pack of using declarations that a single using-declarator pack-expanded into.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
void setType(QualType newType)
Represents a variable declaration or definition.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
void setObjCForDecl(bool FRD)
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
void setCXXForRangeDecl(bool FRD)
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
void setInstantiationOfStaticDataMember(VarDecl *VD, TemplateSpecializationKind TSK)
Specify that this variable is an instantiation of the static data member VD.
TLSKind getTLSKind() const
void setInitStyle(InitializationStyle Style)
InitializationStyle getInitStyle() const
The style of initialization for this declaration.
void setInitCapture(bool IC)
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member.
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
@ CallInit
Call-style initialization (C++98)
bool isObjCForDecl() const
Determine whether this variable is a for-loop declaration for a for-in statement in Objective-C.
void setPreviousDeclInSameBlockScope(bool Same)
bool isInlineSpecified() const
bool isStaticDataMember() const
Determines whether this is a static data member.
VarDecl * getTemplateInstantiationPattern() const
Retrieve the variable declaration from which this variable could be instantiated, if it is an instant...
bool isCXXForRangeDecl() const
Determine whether this variable is the for-range-declaration in a C++0x for-range statement.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
bool mightBeUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value might be usable in a constant expression, according to the re...
void setInlineSpecified()
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template,...
void setTSCSpec(ThreadStorageClassSpecifier TSC)
void setNRVOVariable(bool NRVO)
bool isInline() const
Whether this variable is (C++1z) inline.
ThreadStorageClassSpecifier getTSCSpec() const
const Expr * getInit() const
void setConstexpr(bool IC)
void setDescribedVarTemplate(VarTemplateDecl *Template)
bool isDirectInit() const
Whether the initializer is a direct-initializer (list or call).
StorageClass getStorageClass() const
Returns the storage class as written in the source.
void setImplicitlyInline()
bool isPreviousDeclInSameBlockScope() const
Whether this local extern variable declaration's previous declaration was declared in the same block ...
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
TemplateSpecializationKind getTemplateSpecializationKindForInstantiation() const
Get the template specialization kind of this variable for the purposes of template instantiation.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
Declaration of a variable template.
void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D, void *InsertPos)
Insert the specified partial specialization knowing that it is not already in.
VarTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, TemplateParameterList *TPL, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)
Create a variable template node.
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
VarTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(VarTemplatePartialSpecializationDecl *D)
Find a variable template partial specialization which was instantiated from the given member partial ...
static VarTemplatePartialSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
void setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec)
Represents a variable template specialization, which refers to a variable template with a given set o...
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)
Set the template argument list as written in the sources.
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Retrieve the template argument list as written in the sources, if any.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate the initializer of the vari...
static VarTemplateSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
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.
void setCompleteDefinition()
QualType FunctionType
BlockType - The function type of the block, if one was given.
void addCapture(ValueDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
Provides information about an attempted template argument deduction, whose success or failure was des...
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
bool NE(InterpState &S, CodePtr OpPC)
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)
@ Rewrite
We are substituting template parameters for (typically) other template parameters in order to rewrite...
StorageClass
Storage classes.
@ Property
The type of a property.
@ Result
The result type of a method or function.
@ TU_Prefix
The translation unit is a prefix to a translation unit, and is not complete.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
const FunctionProtoType * T
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
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.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
bool isLambdaMethod(const DeclContext *DC)
@ Other
Other implicit parameter.
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
@ EST_Uninstantiated
not instantiated yet
@ EST_None
no exception specification
@ EST_BasicNoexcept
noexcept
@ EST_Unevaluated
not evaluated yet, for special member function
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...
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
const DeclarationNameLoc & getInfo() const
Holds information about the various types of exception specification.
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
ExceptionSpecificationType Type
The kind of exception specification this is.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
FunctionType::ExtInfo ExtInfo
This structure contains most locations needed for by an OMPVarListClause.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
SynthesisKind
The kind of template instantiation we are performing.
@ BuildingDeductionGuides
We are building deduction guides for a class.
@ DeducedTemplateArgumentSubstitution
We are substituting template argument determined as part of template argument deduction for either a ...
bool InLifetimeExtendingContext
Whether we are currently in a context in which all temporaries must be lifetime-extended,...
bool RebuildDefaultArgOrDefaultInit
Whether we should rebuild CXXDefaultArgExpr and CXXDefaultInitExpr.
A stack object to be created when performing template instantiation.
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
bool isAlreadyInstantiating() const
Determine whether we are already instantiating this specialization in some surrounding active instant...