40#include "llvm/ADT/BitVector.h"
41#include "llvm/ADT/SmallBitVector.h"
42#include "llvm/ADT/SmallString.h"
43#include "llvm/ADT/StringExtras.h"
55 return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc());
63 for (
Scope *TempParamScope = S->getTemplateParamParent(); TempParamScope;
64 TempParamScope = TempParamScope->getParent()->getTemplateParamParent()) {
69 auto ParamsAtDepth = [&](
unsigned D) { Depth = std::max(Depth,
D + 1); };
74 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(FSI)) {
75 if (!LSI->TemplateParams.empty()) {
76 ParamsAtDepth(LSI->AutoTemplateParameterDepth);
79 if (LSI->GLTemplateParameterList) {
80 ParamsAtDepth(LSI->GLTemplateParameterList->getDepth());
90 if (!Info.TemplateParams.empty()) {
91 ParamsAtDepth(Info.AutoTemplateParameterDepth);
106 bool AllowFunctionTemplates,
107 bool AllowDependent) {
108 D =
D->getUnderlyingDecl();
110 if (isa<TemplateDecl>(
D)) {
111 if (!AllowFunctionTemplates && isa<FunctionTemplateDecl>(
D))
117 if (
const auto *
Record = dyn_cast<CXXRecordDecl>(
D)) {
129 if (
Record->isInjectedClassName()) {
131 if (
Record->getDescribedClassTemplate())
132 return Record->getDescribedClassTemplate();
134 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(
Record))
135 return Spec->getSpecializedTemplate();
144 if (AllowDependent && isa<UnresolvedUsingValueDecl>(
D))
151 bool AllowFunctionTemplates,
152 bool AllowDependent) {
163 bool AllowFunctionTemplates,
165 bool AllowNonTemplateFunctions) {
169 if (AllowNonTemplateFunctions &&
170 isa<FunctionDecl>((*I)->getUnderlyingDecl()))
179 bool hasTemplateKeyword,
182 bool EnteringContext,
184 bool &MemberOfUnknownSpecialization,
185 bool Disambiguation) {
189 MemberOfUnknownSpecialization =
false;
191 switch (Name.getKind()) {
198 Name.OperatorFunctionId.Operator);
238 bool AnyFunctionTemplates =
false;
241 if (isa<FunctionTemplateDecl>(FoundTemplate))
242 AnyFunctionTemplates =
true;
245 FoundUsingShadow = dyn_cast<UsingShadowDecl>(FoundD);
253 if (!
D && !AnyFunctionTemplates) {
254 R.suppressDiagnostics();
271 unsigned ResultCount = R.
end() - R.
begin();
272 if (!
D && ResultCount > 1) {
283 assert(
D &&
"unambiguous result is not a template name");
286 if (isa<UnresolvedUsingValueDecl>(
D)) {
288 MemberOfUnknownSpecialization =
true;
295 assert(!FoundUsingShadow || FoundUsingShadow->
getTargetDecl() == TD);
302 if (isa<FunctionTemplateDecl>(TD)) {
308 assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||
309 isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||
310 isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl>(TD));
333 if (R.
empty())
return false;
370 Diag(IILoc, diag::err_template_kw_missing)
380 QualType ObjectType,
bool EnteringContext,
383 bool AllowTypoCorrection) {
390 Found.setTemplateNameLookup(
true);
394 bool IsDependent =
false;
395 if (!ObjectType.
isNull()) {
398 assert(SS.
isEmpty() &&
"ObjectType and scope specifier cannot coexist");
404 "Caller should have completed object type");
436 bool ObjectTypeSearchedInScope =
false;
437 bool AllowFunctionTemplatesInLookup =
true;
453 IsDependent |=
Found.wasNotFoundInCurrentInstantiation();
469 if (!ObjectType.
isNull()) {
473 AllowFunctionTemplatesInLookup =
false;
474 ObjectTypeSearchedInScope =
true;
477 IsDependent |=
Found.wasNotFoundInCurrentInstantiation();
480 if (
Found.isAmbiguous())
497 if (AllFunctions || (
Found.empty() && !IsDependent)) {
501 *ATK = (
Found.empty() &&
Found.getLookupName().isIdentifier())
509 if (
Found.empty() && !IsDependent && AllowTypoCorrection) {
517 FilterCCC.WantExpressionKeywords =
false;
518 FilterCCC.WantRemainingKeywords =
false;
519 FilterCCC.WantCXXNamedCasts =
true;
523 if (
auto *ND = Corrected.getFoundDecl())
526 if (
Found.isAmbiguous()) {
528 }
else if (!
Found.empty()) {
529 Found.setLookupName(Corrected.getCorrection());
531 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
532 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
533 Name.getAsString() == CorrectedStr;
535 << Name << LookupCtx << DroppedSpecifier
545 Found.empty() ? nullptr :
Found.getRepresentativeDecl();
549 Found.setNotFoundInCurrentInstantiation();
555 if (ExampleLookupResult && RequiredTemplate) {
556 Diag(
Found.getNameLoc(), diag::err_template_kw_refers_to_non_template)
561 diag::note_template_kw_refers_to_non_template)
562 <<
Found.getLookupName();
569 if (S && !ObjectType.
isNull() && !ObjectTypeSearchedInScope &&
586 if (FoundOuter.
empty()) {
596 }
else if (!
Found.isSuppressingAmbiguousDiagnostics()) {
600 if (!
Found.isSingleResult() ||
604 diag::ext_nested_name_member_ref_lookup_ambiguous)
605 <<
Found.getLookupName()
607 Diag(
Found.getRepresentativeDecl()->getLocation(),
608 diag::note_ambig_member_ref_object_type)
611 diag::note_ambig_member_ref_scope);
634 bool MissingTemplateKeyword =
false;
637 if (
auto *DRE = dyn_cast<DeclRefExpr>(
TemplateName.get())) {
638 NameInfo = DRE->getNameInfo();
639 SS.
Adopt(DRE->getQualifierLoc());
641 Found = DRE->getFoundDecl();
642 }
else if (
auto *ME = dyn_cast<MemberExpr>(
TemplateName.get())) {
643 NameInfo = ME->getMemberNameInfo();
644 SS.
Adopt(ME->getQualifierLoc());
646 LookupCtx = ME->getBase()->getType()->getAsCXXRecordDecl();
647 Found = ME->getMemberDecl();
648 }
else if (
auto *DSDRE =
649 dyn_cast<DependentScopeDeclRefExpr>(
TemplateName.get())) {
650 NameInfo = DSDRE->getNameInfo();
651 SS.
Adopt(DSDRE->getQualifierLoc());
652 MissingTemplateKeyword =
true;
653 }
else if (
auto *DSME =
654 dyn_cast<CXXDependentScopeMemberExpr>(
TemplateName.get())) {
655 NameInfo = DSME->getMemberNameInfo();
656 SS.
Adopt(DSME->getQualifierLoc());
657 MissingTemplateKeyword =
true;
659 llvm_unreachable(
"unexpected kind of potential template name");
664 if (MissingTemplateKeyword) {
673 TemplateCandidateFilter(
Sema &S) : S(S) {
674 WantTypeSpecifiers =
false;
675 WantExpressionKeywords =
false;
676 WantRemainingKeywords =
false;
677 WantCXXNamedCasts =
true;
679 bool ValidateCandidate(
const TypoCorrection &Candidate)
override {
685 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
686 return std::make_unique<TemplateCandidateFilter>(*
this);
691 TemplateCandidateFilter CCC(*
this);
694 auto *ND = Corrected.getFoundDecl();
697 if (ND || Corrected.isKeyword()) {
699 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
700 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
701 Name.getAsString() == CorrectedStr;
703 PDiag(diag::err_non_template_in_member_template_id_suggest)
704 << Name << LookupCtx << DroppedSpecifier
708 PDiag(diag::err_non_template_in_template_id_suggest)
713 diag::note_non_template_in_template_id_found);
718 Diag(NameInfo.
getLoc(), diag::err_non_template_in_template_id)
721 Diag(
Found->getLocation(), diag::note_non_template_in_template_id_found);
728 bool isAddressOfOperand,
744 nullptr, NameInfo, TemplateArgs);
767 bool InstantiatedFromMember,
772 assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||
773 isa<VarDecl>(Instantiation));
775 bool IsEntityBeingDefined =
false;
776 if (
const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
777 IsEntityBeingDefined = TD->isBeingDefined();
779 if (PatternDef && !IsEntityBeingDefined) {
794 if (!Complain || (PatternDef && PatternDef->
isInvalidDecl()))
798 if (
TagDecl *TD = dyn_cast<TagDecl>(Instantiation))
801 Diag(PointOfInstantiation,
802 diag::err_template_instantiate_within_definition)
808 }
else if (InstantiatedFromMember) {
809 if (isa<FunctionDecl>(Instantiation)) {
810 Diag(PointOfInstantiation,
811 diag::err_explicit_instantiation_undefined_member)
816 assert(isa<TagDecl>(Instantiation) &&
"Must be a TagDecl!");
817 Diag(PointOfInstantiation,
818 diag::err_implicit_instantiate_member_undefined)
823 if (isa<FunctionDecl>(Instantiation)) {
824 Diag(PointOfInstantiation,
825 diag::err_explicit_instantiation_undefined_func_template)
828 }
else if (isa<TagDecl>(Instantiation)) {
829 Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
834 assert(isa<VarDecl>(Instantiation) &&
"Must be a VarDecl!");
835 if (isa<VarTemplateSpecializationDecl>(Instantiation)) {
836 Diag(PointOfInstantiation,
837 diag::err_explicit_instantiation_undefined_var_template)
841 Diag(PointOfInstantiation,
842 diag::err_explicit_instantiation_undefined_member)
859 bool SupportedForCompatibility) {
872 ? diag::ext_template_param_shadow
873 : (SupportedForCompatibility ? diag::ext_compat_template_param_shadow
874 : diag::err_template_param_shadow);
875 const auto *ND = cast<NamedDecl>(PrevDecl);
876 Diag(
Loc, DiagId) << ND->getDeclName();
881 if (
TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(
D)) {
882 D = Temp->getTemplatedDecl();
891 "Only template template arguments can be pack expansions here");
892 assert(
getAsTemplate().get().containsUnexpandedParameterPack() &&
893 "Template template argument pack expansion without packs");
895 Result.EllipsisLoc = EllipsisLoc;
930 llvm_unreachable(
"Unhandled parsed template argument");
935 for (
unsigned I = 0,
Last = TemplateArgsIn.size(); I !=
Last; ++I)
945 RedeclarationKind::ForVisibleRedeclaration);
955 assert(TInfo &&
"template argument with no location");
963 EllipsisLoc = PET.getEllipsisLoc();
964 TL = PET.getPatternLoc();
969 SS.
Adopt(ET.getQualifierLoc());
970 TL = ET.getNamedTypeLoc();
974 TemplateName Name = DTST.getTypePtr()->getTemplateName();
976 DTST.getTemplateNameLoc());
997 unsigned Depth,
unsigned Position,
1000 bool HasTypeConstraint) {
1001 assert(S->isTemplateParamScope() &&
1002 "Template type parameter not in template parameter scope!");
1004 bool IsParameterPack = EllipsisLoc.
isValid();
1007 KeyLoc, ParamNameLoc, Depth, Position,
1008 ParamName,
Typename, IsParameterPack,
1014 LSI->LocalPacks.push_back(Param);
1027 if (DefaultArg && IsParameterPack) {
1028 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1029 DefaultArg =
nullptr;
1037 assert(DefaultTInfo &&
"expected source information for type");
1065 return TemplateArgs;
1078 diag::err_type_constraint_non_type_concept);
1084 if (!WereArgsSpecified &&
1087 diag::err_type_constraint_missing_arguments)
1106 bool AllowUnexpandedPack) {
1123 if (EllipsisLoc.
isInvalid() && !AllowUnexpandedPack) {
1132 ConceptName, CD, USD ? cast<NamedDecl>(USD) : CD,
1134 ConstrainedParameter, EllipsisLoc);
1137template <
typename ArgumentLocAppender>
1152 Appender(ConstraintArgs);
1161 FoundDecl ? FoundDecl : NamedConcept, NamedConcept,
1164 return ImmediatelyDeclaredConstraint;
1180 ImmediatelyDeclaredConstraint.
get(), BO_LAnd,
1181 EllipsisLoc,
nullptr,
1197 *TemplateArgs) :
nullptr;
1202 *
this,
NS, NameInfo, NamedConcept, FoundDecl,
1205 ParamAsArgument, ConstrainedParameter->
getLocation(),
1208 for (const auto &ArgLoc : TemplateArgs->arguments())
1209 ConstraintArgs.addArgument(ArgLoc);
1212 if (ImmediatelyDeclaredConstraint.
isInvalid())
1222 ImmediatelyDeclaredConstraint.
get());
1233 diag::err_unsupported_placeholder_constraint)
1252 for (unsigned I = 0, C = TL.getNumArgs(); I != C; ++I)
1253 ConstraintArgs.addArgument(TL.getArgLoc(I));
1256 if (ImmediatelyDeclaredConstraint.
isInvalid() ||
1257 !ImmediatelyDeclaredConstraint.
isUsable())
1261 ImmediatelyDeclaredConstraint.
get());
1291 Diag(
Loc, diag::err_template_nontype_parm_rvalue_ref) <<
T;
1301 Diag(
Loc, diag::err_template_nontype_parm_bad_type) <<
T;
1309 Diag(
Loc, diag::err_template_nontype_parm_not_structural) <<
T;
1316 for (
const FieldDecl *FD : RD->fields()) {
1318 Diag(FD->getLocation(), diag::note_not_structural_non_public) <<
T << 0;
1321 if (FD->isMutable()) {
1322 Diag(FD->getLocation(), diag::note_not_structural_mutable_field) <<
T;
1325 if (FD->getType()->isRValueReferenceType()) {
1326 Diag(FD->getLocation(), diag::note_not_structural_rvalue_ref_field)
1333 for (
const auto &BaseSpec : RD->bases()) {
1334 if (BaseSpec.getAccessSpecifier() !=
AS_public) {
1335 Diag(BaseSpec.getBaseTypeLoc(), diag::note_not_structural_non_public)
1346 for (
const FieldDecl *FD : RD->fields()) {
1349 SubLoc = FD->getLocation();
1357 for (
const auto &BaseSpec : RD->bases()) {
1360 SubLoc = BaseSpec.getBaseTypeLoc();
1368 assert(Kind != -1 &&
"couldn't find reason why type is not structural");
1369 Diag(SubLoc, diag::note_not_structural_subobject)
1370 <<
T << Kind << SubType;
1383 Diag(
Loc, diag::err_variably_modified_nontype_template_param)
1407 return T.getUnqualifiedType();
1425 return T.getUnqualifiedType();
1436 Diag(
Loc, diag::err_template_nontype_parm_bad_structural_type) <<
T;
1440 Diag(
Loc, diag::warn_cxx17_compat_template_nontype_parm_type) <<
T;
1441 return T.getUnqualifiedType();
1452 auto CheckValidDeclSpecifiers = [
this, &
D] {
1466 Diag(
Loc, diag::err_invalid_decl_specifier_in_nontype_parm)
1503 CheckValidDeclSpecifiers();
1506 if (isa<AutoType>(
T))
1507 Diag(
D.getIdentifierLoc(),
1508 diag::warn_cxx14_compat_template_nontype_parm_auto_type)
1511 assert(S->isTemplateParamScope() &&
1512 "Non-type template parameter not in template parameter scope!");
1524 bool IsParameterPack =
D.hasEllipsis();
1527 D.getIdentifierLoc(), Depth, Position, ParamName,
T, IsParameterPack,
1532 if (TL.isConstrained())
1541 LSI->LocalPacks.push_back(Param);
1555 if (
Default && IsParameterPack) {
1556 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1579 assert(S->isTemplateParamScope() &&
1580 "Template template parameter not in template parameter scope!");
1583 bool IsParameterPack = EllipsisLoc.
isValid();
1586 NameLoc.
isInvalid() ? TmpLoc : NameLoc, Depth, Position, IsParameterPack,
1592 LSI->LocalPacks.push_back(Param);
1603 if (Params->
size() == 0) {
1612 if (IsParameterPack && !
Default.isInvalid()) {
1613 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1628 Diag(DefaultArg.
getLocation(), diag::err_template_arg_not_valid_template)
1646class ConstraintRefersToContainingTemplateChecker
1647 :
public TreeTransform<ConstraintRefersToContainingTemplateChecker> {
1648 bool Result =
false;
1650 unsigned TemplateDepth = 0;
1654 void CheckIfContainingRecord(
const CXXRecordDecl *CheckingRD) {
1660 DC && !DC->isFileContext(); DC = DC->getParent())
1661 if (
const auto *RD = dyn_cast<CXXRecordDecl>(DC))
1662 if (CheckingRD == RD->getMostRecentDecl())
1667 assert(
D->getDepth() <= TemplateDepth &&
1668 "Nothing should reference a value below the actual template depth, "
1669 "depth is likely wrong");
1670 if (
D->getDepth() != TemplateDepth)
1675 TransformType(
D->getType());
1681 ConstraintRefersToContainingTemplateChecker(
Sema &SemaRef,
1683 unsigned TemplateDepth)
1684 : inherited(SemaRef),
Friend(
Friend), TemplateDepth(TemplateDepth) {}
1685 bool getResult()
const {
return Result; }
1691 using inherited::TransformTemplateTypeParmType;
1695 "Nothing should reference a value below the actual template depth, "
1696 "depth is likely wrong");
1699 return inherited::TransformTemplateTypeParmType(
1711 if (
auto *TD = dyn_cast<TypedefNameDecl>(
D))
1712 TransformType(TD->getUnderlyingType());
1713 else if (
auto *NTTPD = dyn_cast<NonTypeTemplateParmDecl>(
D))
1714 CheckNonTypeTemplateParmDecl(NTTPD);
1715 else if (
auto *VD = dyn_cast<ValueDecl>(
D))
1716 TransformType(VD->getType());
1717 else if (
auto *TD = dyn_cast<TemplateDecl>(
D))
1718 TransformTemplateParameterList(TD->getTemplateParameters());
1719 else if (
auto *RD = dyn_cast<CXXRecordDecl>(
D))
1720 CheckIfContainingRecord(RD);
1721 else if (isa<NamedDecl>(
D)) {
1724 llvm_unreachable(
"Don't know how to handle this declaration type yet");
1732 const Expr *Constraint) {
1733 assert(
Friend->getFriendObjectKind() &&
"Only works on a friend");
1734 ConstraintRefersToContainingTemplateChecker Checker(*
this,
Friend,
1736 Checker.TransformExpr(
const_cast<Expr *
>(Constraint));
1737 return Checker.getResult();
1747 Expr *RequiresClause) {
1749 Diag(ExportLoc, diag::warn_template_export_unsupported);
1755 Context, TemplateLoc, LAngleLoc,
1756 llvm::ArrayRef(Params.data(), Params.size()), RAngleLoc, RequiresClause);
1791 return cast<TemplateDecl>(
D)->getTemplateParameters();
1801 assert(TemplateParams && TemplateParams->
size() > 0 &&
1802 "No template parameters");
1804 "Can only declare or define class templates");
1813 "can't build template of enumerated type");
1817 Diag(KWLoc, diag::err_template_unnamed_class);
1832 if (!SemanticContext) {
1837 ? diag::warn_template_qualified_friend_ignored
1838 : diag::err_template_qualified_declarator_no_match)
1881 PrevDecl = (*
Previous.begin())->getUnderlyingDecl();
1893 dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
1898 if (!PrevClassTemplate && isa_and_nonnull<CXXRecordDecl>(PrevDecl) &&
1899 cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
1902 = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
1903 if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
1905 = cast<ClassTemplateSpecializationDecl>(PrevDecl)
1906 ->getSpecializedTemplate();
1929 PrevDecl = PrevClassTemplate =
nullptr;
1930 SemanticContext = OutermostContext;
1944 PrevDecl = (*
Previous.begin())->getUnderlyingDecl();
1948 SemanticContext, S, SS.
isValid()))
1949 PrevDecl = PrevClassTemplate =
nullptr;
1951 if (
auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
1952 PrevDecl ?
Previous.getRepresentativeDecl() :
nullptr)) {
1954 !(PrevClassTemplate &&
1957 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
1958 Diag(Shadow->getTargetDecl()->getLocation(),
1959 diag::note_using_decl_target);
1960 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl) << 0;
1962 PrevDecl = PrevClassTemplate =
nullptr;
1966 if (PrevClassTemplate) {
1975 TemplateParams, PrevClassTemplate,
1988 Diag(KWLoc, diag::err_use_with_wrong_tag)
2004 auto *Tmpl = cast<CXXRecordDecl>(Hidden)->getDescribedClassTemplate();
2005 assert(Tmpl &&
"original definition of a class template is not a "
2010 Diag(NameLoc, diag::err_redefinition) << Name;
2011 Diag(Def->getLocation(), diag::note_previous_definition);
2018 }
else if (PrevDecl) {
2024 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
2038 (SS.
isSet() && SemanticContext && SemanticContext->
isRecord() &&
2051 ? diag::err_friend_decl_does_not_match
2052 : diag::err_member_decl_does_not_match)
2053 << Name << SemanticContext <<
true << SS.
getRange();
2063 bool ShouldAddRedecl =
2068 PrevClassTemplate && ShouldAddRedecl ?
2072 if (NumOuterTemplateParamLists > 0)
2075 llvm::ArrayRef(OuterTemplateParamLists, NumOuterTemplateParamLists));
2089 if (ShouldAddRedecl)
2094 if (ModulePrivateLoc.
isValid())
2105 if (PrevClassTemplate &&
2124 if (PrevClassTemplate)
2160 if (PrevClassTemplate)
2201 diag::warn_cxx98_compat_template_parameter_default_in_function_template
2202 : diag::ext_template_parameter_default_in_function_template)
2211 S.
Diag(ParamLoc, diag::err_template_parameter_default_template_member)
2220 S.
Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
2229 llvm_unreachable(
"Invalid TemplateParamListContext!");
2242 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
2247 if (TC->hasExplicitTemplateArgs())
2248 for (
auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
2256 if (!NTTP->isParameterPack() &&
2258 NTTP->getTypeSourceInfo(),
2266 = dyn_cast<TemplateTemplateParmDecl>(
P))
2286 bool SawDefaultArgument =
false;
2292 OldParam = OldParams->
begin();
2294 bool RemoveDefaultArguments =
false;
2296 NewParamEnd = NewParams->
end();
2297 NewParam != NewParamEnd; ++NewParam) {
2300 bool RedundantDefaultArg =
false;
2303 bool InconsistentDefaultArg =
false;
2305 std::string PrevModuleName;
2311 bool MissingDefaultArg =
false;
2314 bool SawParameterPack =
false;
2317 = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
2319 if (NewTypeParm->hasDefaultArgument() &&
2321 *
this, TPC, NewTypeParm->getLocation(),
2322 NewTypeParm->getDefaultArgument().getSourceRange()))
2323 NewTypeParm->removeDefaultArgument();
2327 = OldParams? cast<TemplateTypeParmDecl>(*OldParam) :
nullptr;
2328 if (NewTypeParm->isParameterPack()) {
2329 assert(!NewTypeParm->hasDefaultArgument() &&
2330 "Parameter packs can't have a default argument!");
2331 SawParameterPack =
true;
2333 NewTypeParm->hasDefaultArgument() &&
2336 NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
2337 SawDefaultArgument =
true;
2340 RedundantDefaultArg =
true;
2341 else if (!
getASTContext().isSameDefaultTemplateArgument(OldTypeParm,
2343 InconsistentDefaultArg =
true;
2347 PreviousDefaultArgLoc = NewDefaultLoc;
2351 NewTypeParm->setInheritedDefaultArgument(
Context, OldTypeParm);
2353 }
else if (NewTypeParm->hasDefaultArgument()) {
2354 SawDefaultArgument =
true;
2355 PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
2356 }
else if (SawDefaultArgument)
2357 MissingDefaultArg =
true;
2359 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
2361 if (!NewNonTypeParm->isParameterPack() &&
2363 NewNonTypeParm->getTypeSourceInfo(),
2370 if (NewNonTypeParm->hasDefaultArgument() &&
2372 *
this, TPC, NewNonTypeParm->getLocation(),
2373 NewNonTypeParm->getDefaultArgument().getSourceRange())) {
2374 NewNonTypeParm->removeDefaultArgument();
2379 = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) :
nullptr;
2380 if (NewNonTypeParm->isParameterPack()) {
2381 assert(!NewNonTypeParm->hasDefaultArgument() &&
2382 "Parameter packs can't have a default argument!");
2383 if (!NewNonTypeParm->isPackExpansion())
2384 SawParameterPack =
true;
2386 NewNonTypeParm->hasDefaultArgument() &&
2389 NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
2390 SawDefaultArgument =
true;
2392 RedundantDefaultArg =
true;
2394 OldNonTypeParm, NewNonTypeParm)) {
2395 InconsistentDefaultArg =
true;
2399 PreviousDefaultArgLoc = NewDefaultLoc;
2403 NewNonTypeParm->setInheritedDefaultArgument(
Context, OldNonTypeParm);
2405 }
else if (NewNonTypeParm->hasDefaultArgument()) {
2406 SawDefaultArgument =
true;
2407 PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
2408 }
else if (SawDefaultArgument)
2409 MissingDefaultArg =
true;
2412 = cast<TemplateTemplateParmDecl>(*NewParam);
2429 = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) :
nullptr;
2432 "Parameter packs can't have a default argument!");
2434 SawParameterPack =
true;
2435 }
else if (OldTemplateParm &&
2441 SawDefaultArgument =
true;
2443 RedundantDefaultArg =
true;
2445 OldTemplateParm, NewTemplateParm)) {
2446 InconsistentDefaultArg =
true;
2450 PreviousDefaultArgLoc = NewDefaultLoc;
2455 PreviousDefaultArgLoc
2458 SawDefaultArgument =
true;
2459 PreviousDefaultArgLoc
2461 }
else if (SawDefaultArgument)
2462 MissingDefaultArg =
true;
2468 if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
2471 Diag((*NewParam)->getLocation(),
2472 diag::err_template_param_pack_must_be_last_template_parameter);
2489 if (RedundantDefaultArg) {
2490 Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
2491 Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
2493 }
else if (InconsistentDefaultArg) {
2497 diag::err_template_param_default_arg_inconsistent_redefinition);
2499 diag::note_template_param_prev_default_arg_in_other_module)
2502 }
else if (MissingDefaultArg &&
2510 Diag((*NewParam)->getLocation(),
2511 diag::err_template_param_default_arg_missing);
2512 Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
2514 RemoveDefaultArguments =
true;
2525 if (RemoveDefaultArguments) {
2527 NewParamEnd = NewParams->
end();
2528 NewParam != NewParamEnd; ++NewParam) {
2530 TTP->removeDefaultArgument();
2532 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
2533 NTTP->removeDefaultArgument();
2535 cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
2555 bool IgnoreNonTypeDependent;
2560 DependencyChecker(
unsigned Depth,
bool IgnoreNonTypeDependent)
2561 : Depth(Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),
2565 : IgnoreNonTypeDependent(IgnoreNonTypeDependent), Match(
false) {
2568 Depth = PD->getDepth();
2570 dyn_cast<NonTypeTemplateParmDecl>(ND)) {
2571 Depth = PD->getDepth();
2573 Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
2578 if (ParmDepth >= Depth) {
2586 bool TraverseStmt(
Stmt *S, DataRecursionQueue *Q =
nullptr) {
2591 if (
auto *
E = dyn_cast_or_null<Expr>(S))
2594 return super::TraverseStmt(S, Q);
2597 bool TraverseTypeLoc(
TypeLoc TL) {
2598 if (IgnoreNonTypeDependent && !TL.
isNull() &&
2601 return super::TraverseTypeLoc(TL);
2610 return IgnoreNonTypeDependent || !Matches(
T->getDepth());
2616 if (Matches(PD->getDepth()))
2618 return super::TraverseTemplateName(N);
2623 dyn_cast<NonTypeTemplateParmDecl>(
E->getDecl()))
2626 return super::VisitDeclRefExpr(
E);
2630 return TraverseType(
T->getReplacementType());
2635 return TraverseTemplateArgument(
T->getArgumentPack());
2639 return TraverseType(
T->getInjectedSpecializationType());
2648 if (!Params->
size())
2651 DependencyChecker Checker(Params,
false);
2652 Checker.TraverseType(
T);
2653 return Checker.Match;
2663 if (
const Type *CurType = NNS->getAsType()) {
2679 bool &IsMemberSpecialization,
bool &
Invalid,
bool SuppressDiagnostic) {
2680 IsMemberSpecialization =
false;
2701 while (!
T.isNull()) {
2702 NestedTypes.push_back(
T);
2708 = dyn_cast<ClassTemplateSpecializationDecl>(
Record)) {
2709 if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
2711 ExplicitSpecLoc = Spec->getLocation();
2714 }
else if (
Record->getTemplateSpecializationKind()
2716 ExplicitSpecLoc =
Record->getLocation();
2729 if (
TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
2730 if (
TypeDecl *
Parent = dyn_cast<TypeDecl>(Template->getDeclContext()))
2775 std::reverse(NestedTypes.begin(), NestedTypes.end());
2783 bool SawNonEmptyTemplateParameterList =
false;
2786 if (SawNonEmptyTemplateParameterList) {
2787 if (!SuppressDiagnostic)
2788 Diag(DeclLoc, diag::err_specialize_member_of_template)
2789 << !Recovery <<
Range;
2791 IsMemberSpecialization =
false;
2800 if (CheckExplicitSpecialization(
Range,
true))
2805 if (!ParamLists.empty())
2806 ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
2808 ExpectedTemplateLoc = DeclStartLoc;
2810 if (!SuppressDiagnostic)
2811 Diag(DeclLoc, diag::err_template_spec_needs_header)
2818 for (
unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
2820 T = NestedTypes[TypeIdx];
2823 bool NeedEmptyTemplateHeader =
false;
2826 bool NeedNonemptyTemplateHeader =
false;
2839 = dyn_cast<ClassTemplatePartialSpecializationDecl>(
Record)) {
2840 ExpectedTemplateParams = Partial->getTemplateParameters();
2841 NeedNonemptyTemplateHeader =
true;
2842 }
else if (
Record->isDependentType()) {
2843 if (
Record->getDescribedClassTemplate()) {
2844 ExpectedTemplateParams =
Record->getDescribedClassTemplate()
2845 ->getTemplateParameters();
2846 NeedNonemptyTemplateHeader =
true;
2849 = dyn_cast<ClassTemplateSpecializationDecl>(
Record)) {
2855 NeedEmptyTemplateHeader =
true;
2858 }
else if (
Record->getTemplateSpecializationKind()) {
2859 if (
Record->getTemplateSpecializationKind()
2861 TypeIdx == NumTypes - 1)
2862 IsMemberSpecialization =
true;
2868 if (
TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
2869 ExpectedTemplateParams = Template->getTemplateParameters();
2870 NeedNonemptyTemplateHeader =
true;
2875 NeedNonemptyTemplateHeader =
false;
2885 if (
ParamIdx < ParamLists.size()) {
2886 if (ParamLists[
ParamIdx]->size() == 0) {
2887 if (CheckExplicitSpecialization(ParamLists[
ParamIdx]->getSourceRange(),
2891 SawNonEmptyTemplateParameterList =
true;
2894 if (NeedEmptyTemplateHeader) {
2897 if (TypeIdx == NumTypes - 1)
2898 IsMemberSpecialization =
true;
2900 if (
ParamIdx < ParamLists.size()) {
2901 if (ParamLists[
ParamIdx]->size() > 0) {
2903 if (!SuppressDiagnostic)
2905 diag::err_template_param_list_matches_nontemplate)
2908 ParamLists[
ParamIdx]->getRAngleLoc())
2920 if (DiagnoseMissingExplicitSpecialization(
2927 if (NeedNonemptyTemplateHeader) {
2933 if (
ParamIdx < ParamLists.size() &&
2935 ExpectedTemplateParams =
nullptr;
2940 if (
ParamIdx < ParamLists.size()) {
2942 if (ExpectedTemplateParams &&
2944 ExpectedTemplateParams,
2957 if (!SuppressDiagnostic)
2958 Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
2969 if (
ParamIdx >= ParamLists.size()) {
2970 if (TemplateId && !IsFriend) {
2986 if (
ParamIdx < ParamLists.size() - 1) {
2987 bool HasAnyExplicitSpecHeader =
false;
2988 bool AllExplicitSpecHeaders =
true;
2989 for (
unsigned I =
ParamIdx,
E = ParamLists.size() - 1; I !=
E; ++I) {
2990 if (ParamLists[I]->size() == 0)
2991 HasAnyExplicitSpecHeader =
true;
2993 AllExplicitSpecHeaders =
false;
2996 if (!SuppressDiagnostic)
2998 AllExplicitSpecHeaders ? diag::ext_template_spec_extra_headers
2999 : diag::err_template_spec_extra_headers)
3001 ParamLists[ParamLists.size() - 2]->getRAngleLoc());
3006 if (ExplicitSpecLoc.
isValid() && HasAnyExplicitSpecHeader &&
3007 !SuppressDiagnostic)
3008 Diag(ExplicitSpecLoc,
3009 diag::note_explicit_template_spec_does_not_need_header)
3010 << NestedTypes.back();
3015 if (!AllExplicitSpecHeaders)
3026 if (ParamLists.back()->size() == 0 &&
3027 CheckExplicitSpecialization(ParamLists[
ParamIdx]->getSourceRange(),
3033 return ParamLists.back();
3037 if (
TemplateDecl *Template = Name.getAsTemplateDecl()) {
3038 Diag(Template->getLocation(), diag::note_template_declared_here)
3039 << (isa<FunctionTemplateDecl>(Template)
3041 : isa<ClassTemplateDecl>(Template)
3043 : isa<VarTemplateDecl>(Template)
3045 : isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)
3046 << Template->getDeclName();
3054 Diag((*I)->getLocation(), diag::note_template_declared_here)
3055 << 0 << (*I)->getDeclName();
3073 QualType OrigType = Converted[1].getAsType();
3077 SemaRef.
Diag(TemplateArgs[1].getLocation(),
3078 diag::err_integer_sequence_integral_element_type);
3093 OrigType, TemplateArgs[1].getLocation())));
3095 if (llvm::APSInt NumArgs = NumArgsArg.
getAsIntegral(); NumArgs >= 0) {
3097 for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
3101 TA, OrigType, TemplateArgs[2].getLocation()));
3106 SemaRef.
Diag(TemplateArgs[2].getLocation(),
3107 diag::err_integer_sequence_negative_length);
3114 TemplateLoc, SyntheticTemplateArgs);
3121 assert(Converted.size() == 2 &&
3122 "__type_pack_element should be given an index and a parameter pack");
3130 assert(Index >= 0 &&
"the index used with __type_pack_element should be of "
3131 "type std::size_t, and hence be non-negative");
3133 if (Index >= Ts.pack_size()) {
3134 SemaRef.
Diag(TemplateArgs[0].getLocation(),
3135 diag::err_type_pack_element_out_of_bounds);
3140 int64_t N = Index.getExtValue();
3141 return Ts.getPackAsArray()[N].getAsType();
3143 llvm_unreachable(
"unexpected BuiltinTemplateDecl!");
3162 if (BinOp->getOpcode() == BO_LAnd) {
3169 Terms.push_back(Clause);
3178 if (!BinOp)
return Cond;
3180 if (BinOp->getOpcode() != BO_LOr)
return Cond;
3183 Expr *LHS = BinOp->getLHS();
3185 if (!InnerBinOp)
return Cond;
3187 if (InnerBinOp->getOpcode() != BO_EQ ||
3188 !isa<IntegerLiteral>(InnerBinOp->getRHS()))
3198 if (MacroName ==
"CONCEPT_REQUIRES" || MacroName ==
"CONCEPT_REQUIRES_")
3199 return BinOp->getRHS();
3209class FailedBooleanConditionPrinterHelper :
public PrinterHelper {
3214 bool handledStmt(
Stmt *
E, raw_ostream &OS)
override {
3215 const auto *DR = dyn_cast<DeclRefExpr>(
E);
3216 if (DR && DR->getQualifier()) {
3219 DR->getQualifier()->print(OS, Policy,
true);
3223 if (
const auto *IV = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
3226 OS, IV->getTemplateArgs().asArray(), Policy,
3227 IV->getSpecializedTemplate()->getTemplateParameters());
3240std::pair<Expr *, std::string>
3249 Expr *FailedCond =
nullptr;
3250 for (
Expr *Term : Terms) {
3254 if (isa<CXXBoolLiteralExpr>(TermAsWritten) ||
3255 isa<IntegerLiteral>(TermAsWritten))
3264 if (Term->EvaluateAsBooleanCondition(Succeeded,
Context) &&
3266 FailedCond = TermAsWritten;
3273 std::string Description;
3275 llvm::raw_string_ostream Out(Description);
3278 FailedBooleanConditionPrinterHelper Helper(Policy);
3279 FailedCond->
printPretty(Out, &Helper, Policy, 0,
"\n",
nullptr);
3281 return { FailedCond, Description };
3288 = Name.getUnderlying().getAsDependentTemplateName();
3298 if (Name.getAsAssumedTemplateName() &&
3303 if (!Template || isa<FunctionTemplateDecl>(Template) ||
3304 isa<VarTemplateDecl>(Template) || isa<ConceptDecl>(Template)) {
3307 if (Name.getAsSubstTemplateTemplateParmPack())
3311 Diag(TemplateLoc, diag::err_template_id_not_a_type)
3321 SugaredConverted, CanonicalConverted,
3328 dyn_cast<TypeAliasTemplateDecl>(Template)) {
3354 std::optional<ContextRAII> SavedContext;
3356 SavedContext.emplace(*
this,
AliasTemplate->getDeclContext());
3361 if (CanonType.
isNull()) {
3367 if (*DeductionInfo &&
3368 (*DeductionInfo)->hasSFINAEDiagnostic() &&
3369 (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==
3370 diag::err_typename_nested_not_found_enable_if &&
3371 TemplateArgs[0].getArgument().getKind()
3374 std::string FailedDescription;
3375 std::tie(FailedCond, FailedDescription) =
3381 (*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);
3385 (*DeductionInfo)->addSFINAEDiagnostic(
3387 PDiag(diag::err_typename_nested_not_found_requirement)
3388 << FailedDescription
3396 }
else if (
auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
3398 TemplateLoc, TemplateArgs);
3399 }
else if (Name.isDependent() ||
3401 TemplateArgs, CanonicalConverted)) {
3410 Name, CanonicalConverted);
3418 if (isa<ClassTemplateDecl>(Template)) {
3421 if (Ctx->isFileContext())
break;
3429 if (!isa<ClassTemplatePartialSpecializationDecl>(
Record) &&
3430 !
Record->getDescribedClassTemplate())
3436 QualType Injected = cast<InjectedClassNameType>(ICNT)
3437 ->getInjectedSpecializationType();
3450 dyn_cast<ClassTemplateDecl>(Template)) {
3453 void *InsertPos =
nullptr;
3455 ClassTemplate->findSpecialization(CanonicalConverted, InsertPos);
3487 assert(isa<RecordType>(CanonType) &&
3488 "type of non-dependent specialization is not a RecordType");
3490 llvm_unreachable(
"Unhandled template kind");
3507 auto *ATN = Name.getAsAssumedTemplateName();
3508 assert(ATN &&
"not an assumed template name");
3509 II = ATN->getDeclName().getAsIdentifierInfo();
3525 assert(ATN &&
"not an assumed template name");
3533 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
3534 return std::make_unique<CandidateCallback>(*
this);
3558 bool IsCtorOrDtorName,
bool IsClassName,
3563 if (!IsCtorOrDtorName && !IsClassName && SS.
isSet()) {
3589 TemplateD, TemplateII, TemplateIILoc, LAngleLoc,
3590 TemplateArgsIn, RAngleLoc);
3597 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
3598 if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
3601 ? diag::err_out_of_line_qualified_id_type_names_constructor
3602 : diag::ext_out_of_line_qualified_id_type_names_constructor)
3632 for (
unsigned I = 0, N = SpecTL.
getNumArgs(); I != N; ++I)
3649 for (
unsigned i = 0, e = SpecTL.
getNumArgs(); i != e; ++i)
3690 Keyword, DTN->getQualifier(), DTN->getIdentifier(),
3703 for (
unsigned I = 0, N = SpecTL.
getNumArgs(); I != N; ++I)
3714 Diag(TemplateLoc, diag::err_tag_reference_non_tag)
3716 Diag(TAT->getLocation(), diag::note_declared_at);
3728 assert(
Id &&
"templated class must have an identifier");
3732 Diag(TagLoc, diag::err_use_with_wrong_tag)
3747 for (
unsigned i = 0, e = SpecTL.
getNumArgs(); i != e; ++i)
3782 return TPT && !
Type.hasQualifiers() &&
3791 dyn_cast<NonTypeTemplateParmDecl>(DRE->
getDecl());
3797 dyn_cast_or_null<TemplateTemplateParmDecl>(
3801 llvm_unreachable(
"unexpected kind of template argument");
3806 if (Params->
size() != Args.size())
3809 unsigned Depth = Params->
getDepth();
3811 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
3830template<
typename PartialSpecDecl>
3832 if (Partial->getDeclContext()->isDependentContext())
3841 auto *Template = Partial->getSpecializedTemplate();
3842 S.
Diag(Partial->getLocation(),
3843 diag::ext_partial_spec_not_more_specialized_than_primary)
3844 << isa<VarTemplateDecl>(Template);
3853 diag::note_partial_spec_not_more_specialized_than_primary)
3859 Template->getAssociatedConstraints(TemplateAC);
3860 Partial->getAssociatedConstraints(PartialAC);
3867 const llvm::SmallBitVector &DeducibleParams) {
3868 for (
unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
3869 if (!DeducibleParams[I]) {
3882template<
typename PartialSpecDecl>
3884 PartialSpecDecl *Partial) {
3897 auto *TemplateParams = Partial->getTemplateParameters();
3898 llvm::SmallBitVector DeducibleParams(TemplateParams->size());
3900 TemplateParams->getDepth(), DeducibleParams);
3902 if (!DeducibleParams.all()) {
3903 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
3904 S.
Diag(Partial->getLocation(), diag::ext_partial_specs_not_deducible)
3905 << isa<VarTemplatePartialSpecializationDecl>(Partial)
3906 << (NumNonDeducible > 1)
3908 Partial->getTemplateArgsAsWritten()->RAngleLoc);
3929 llvm::SmallBitVector DeducibleParams(TemplateParams->size());
3931 for (
unsigned I = 0; I != TemplateParams->size(); ++I) {
3933 auto *Param = TemplateParams->getParam(I);
3935 DeducibleParams[I] =
true;
3938 if (!DeducibleParams.all()) {
3939 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
3940 Diag(TD->
getLocation(), diag::err_deduction_guide_template_not_deducible)
3941 << (NumNonDeducible > 1);
3952 "Variable template specialization is declared with a template id.");
3965 dyn_cast_or_null<VarTemplateDecl>(Name.getAsTemplateDecl());
3968 if (
auto *OTS = Name.getAsOverloadedTemplate())
3969 FnTemplate = *OTS->begin();
3971 FnTemplate = dyn_cast_or_null<FunctionTemplateDecl>(Name.getAsTemplateDecl());
3973 return Diag(
D.getIdentifierLoc(), diag::err_var_spec_no_template_but_method)
3975 return Diag(
D.getIdentifierLoc(), diag::err_var_spec_no_template)
3980 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
3991 false, SugaredConverted, CanonicalConverted,
3999 TemplateArgs.
size(),
4000 CanonicalConverted))
4005 if (!Name.isDependent() &&
4007 TemplateArgs, CanonicalConverted)) {
4008 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
4014 CanonicalConverted) &&
4021 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
4031 void *InsertPos =
nullptr;
4035 PrevDecl =
VarTemplate->findPartialSpecialization(
4036 CanonicalConverted, TemplateParams, InsertPos);
4038 PrevDecl =
VarTemplate->findSpecialization(CanonicalConverted, InsertPos);
4060 cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
4065 CanonicalConverted);
4069 VarTemplate->AddPartialSpecialization(Partial, InsertPos);
4108 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
4112 diag::note_instantiation_required_here)
4142struct PartialSpecMatchResult {
4152 assert(Template &&
"A variable template id without template?");
4157 Template, TemplateNameLoc,
4159 SugaredConverted, CanonicalConverted,
4166 TemplateArgs, CanonicalConverted))
4171 void *InsertPos =
nullptr;
4185 bool AmbiguousPartialSpec =
false;
4200 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
4214 Matched.push_back(PartialSpecMatchResult());
4215 Matched.back().Partial = Partial;
4220 if (Matched.size() >= 1) {
4222 if (Matched.size() == 1) {
4235 PEnd = Matched.end();
4238 PointOfInstantiation) ==
4246 PEnd = Matched.end();
4249 P->Partial, Best->Partial,
4250 PointOfInstantiation) != Best->Partial) {
4251 AmbiguousPartialSpec =
true;
4258 InstantiationPattern = Best->Partial;
4259 PartialSpecArgs = Best->Args;
4271 Template, InstantiationPattern, PartialSpecArgs, TemplateArgs,
4272 CanonicalConverted, TemplateNameLoc );
4276 if (AmbiguousPartialSpec) {
4279 Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
4284 Diag(
P.Partial->getLocation(), diag::note_partial_spec_match)
4291 dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
4292 Decl->setInstantiationOf(
D, PartialSpecArgs);
4296 assert(
Decl &&
"No variable template specialization?");
4307 if (
Decl.isInvalid())
4324 Diag(
Loc, diag::err_template_missing_args)
4332 bool TemplateKeyword,
4347 assert(NamedConcept &&
"A concept template id without a template?");
4351 NamedConcept, ConceptNameInfo.
getLoc(),
4353 false, SugaredConverted, CanonicalConverted,
4361 CanonicalConverted);
4363 bool AreArgsDependent =
4365 *TemplateArgs, CanonicalConverted);
4373 if (!AreArgsDependent &&
4383 TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,
4386 Context, CL, CSD, AreArgsDependent ?
nullptr : &Satisfaction);
4405 assert(!R.
isAmbiguous() &&
"ambiguous lookup when building templateid");
4409 if (!TemplateArgs && !isa<FunctionTemplateDecl>(TD)) {
4415 bool KnownDependent =
false;
4424 KnownDependent =
true;
4439 R.
begin(), R.
end(), KnownDependent);
4455 assert(TemplateArgs || TemplateKWLoc.
isValid());
4459 false, TemplateKWLoc))
4488 bool EnteringContext,
4490 bool AllowInjectedClassName) {
4491 if (TemplateKWLoc.
isValid() && S && !S->getTemplateParamParent())
4494 diag::warn_cxx98_compat_template_outside_of_template :
4495 diag::ext_template_outside_of_template)
4505 else if (ObjectType)
4524 bool MemberOfUnknownSpecialization;
4526 ObjectType, EnteringContext,
Result,
4527 MemberOfUnknownSpecialization);
4530 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
4531 if (!AllowInjectedClassName && SS.
isNotEmpty() && LookupRD &&
4533 Name.Identifier && LookupRD->getIdentifier() == Name.Identifier) {
4543 Diag(Name.getBeginLoc(),
4544 diag::ext_out_of_line_qualified_id_type_names_constructor)
4552 if (!MemberOfUnknownSpecialization) {
4569 Diag(Name.getBeginLoc(), diag::err_no_member)
4572 Diag(Name.getBeginLoc(), diag::err_undeclared_use)
4580 switch (Name.getKind()) {
4588 Qualifier, Name.OperatorFunctionId.Operator));
4602 Diag(Name.getBeginLoc(),
4603 diag::err_template_kw_refers_to_dependent_non_template)
4605 << TemplateKWLoc.
isValid() << TemplateKWLoc;
4642 dyn_cast<DependentScopeDeclRefExpr>(Arg.
getAsExpr())) {
4643 SS.
Adopt(ArgExpr->getQualifierLoc());
4644 NameInfo = ArgExpr->getNameInfo();
4646 dyn_cast<CXXDependentScopeMemberExpr>(Arg.
getAsExpr())) {
4647 if (ArgExpr->isImplicitAccess()) {
4648 SS.
Adopt(ArgExpr->getQualifierLoc());
4649 NameInfo = ArgExpr->getMemberNameInfo();
4658 Result.wasNotFoundInCurrentInstantiation()) {
4659 assert(SS.
getScopeRep() &&
"dependent scope expr must has a scope!");
4663 ? diag::ext_ms_template_type_arg_missing_typename
4664 : diag::err_template_arg_must_be_type_suggest)
4696 SugaredConverted.push_back(Arg);
4697 CanonicalConverted.push_back(Arg);
4703 Diag(SR.
getBegin(), diag::err_template_arg_must_be_type) << SR;
4725 CanonicalConverted.push_back(
4774 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
4777 bool ForLambdaCallOperator =
false;
4778 if (
const auto *Rec = dyn_cast<CXXRecordDecl>(Template->
getDeclContext()))
4779 ForLambdaCallOperator = Rec->isLambda();
4781 !ForLambdaCallOperator);
4829 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
4836 TemplateArgLists, Output);
4872 SugaredConverted,
SourceRange(TemplateLoc, RAngleLoc));
4879 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
4904 HasDefaultArg =
false;
4910 HasDefaultArg =
true;
4913 TypeParm, SugaredConverted,
4914 CanonicalConverted, Output))
4920 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4924 HasDefaultArg =
true;
4927 NonTypeParm, SugaredConverted,
4928 CanonicalConverted, Output))
4934 = cast<TemplateTemplateParmDecl>(Param);
4938 HasDefaultArg =
true;
4941 *
this, Template, TemplateLoc, RAngleLoc, TempTempParm, SugaredConverted,
4942 CanonicalConverted, QualifierLoc);
4963 QualLoc = ETLoc.getQualifierLoc();
4964 TLoc = ETLoc.getNamedTypeLoc();
4970 QualLoc, InjLoc.getNameLoc());
4978 dyn_cast<ClassTemplateSpecializationDecl>(RecLoc.getDecl()))
4981 QualLoc, RecLoc.getNameLoc());
4989 unsigned ArgumentPackIndex,
4996 CanonicalConverted);
5003 QualType NTTPType = NTTP->getType();
5004 if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
5005 NTTPType = NTTP->getExpansionType(ArgumentPackIndex);
5008 !isa<TemplateTemplateParmDecl>(Template) &&
5023 NTTPType =
SubstType(PET->getPattern(), MLTAL, NTTP->getLocation(),
5024 NTTP->getDeclName());
5026 NTTPType =
SubstType(NTTPType, MLTAL, NTTP->getLocation(),
5027 NTTP->getDeclName());
5034 NTTP->getLocation());
5041 llvm_unreachable(
"Should never see a NULL template argument here");
5048 CanonicalResult, CTAK);
5057 if (Res.
get() !=
E) {
5062 SugaredConverted.push_back(SugaredResult);
5063 CanonicalConverted.push_back(CanonicalResult);
5074 CanonicalConverted.push_back(
5117 SugaredConverted.push_back(SugaredResult);
5118 CanonicalConverted.push_back(CanonicalResult);
5145 Diag(SR.
getBegin(), diag::err_template_arg_nontype_ambig) << SR <<
T;
5147 Diag(SR.
getBegin(), diag::err_template_arg_must_be_expr) << SR;
5153 llvm_unreachable(
"Caller must expand template argument packs");
5184 Template, SugaredConverted,
true),
5203 llvm_unreachable(
"Should never see a NULL template argument here");
5212 CanonicalConverted.push_back(
5228 llvm_unreachable(
"non-type argument with template template parameter");
5231 llvm_unreachable(
"Caller must expand template argument packs");
5238template<
typename TemplateParmDecl>
5241 const TemplateParmDecl *
D,
5246 ->getTemplateParameters()
5247 ->getParam(
D->getIndex()));
5254 D->getDefaultArgumentLoc(), Modules,
5265 S.
Diag(
Loc, diag::err_template_arg_list_different_arity)
5281 bool PartialOrderingTTP) {
5300 bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
5303 unsigned ArgIdx = 0, NumArgs = NewArgs.
size();
5306 ParamEnd = Params->
end();
5307 Param != ParamEnd; ) {
5311 if (*Expansions == SugaredArgumentPack.size()) {
5314 SugaredConverted.push_back(
5316 SugaredArgumentPack.clear();
5318 CanonicalConverted.push_back(
5320 CanonicalArgumentPack.clear();
5325 }
else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
5327 Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5336 if (ArgIdx < NumArgs) {
5339 RAngleLoc, SugaredArgumentPack.size(),
5340 SugaredConverted, CanonicalConverted,
5344 CanonicalConverted.back().setIsDefaulted(
5347 CanonicalConverted, Params->
getDepth()));
5349 bool PackExpansionIntoNonPack =
5350 NewArgs[ArgIdx].getArgument().isPackExpansion() &&
5356 if (PackExpansionIntoNonPack && !PartialOrderingTTP &&
5357 (isa<TypeAliasTemplateDecl>(Template) ||
5358 isa<ConceptDecl>(Template))) {
5364 Diag(NewArgs[ArgIdx].getLocation(),
5365 diag::err_template_expansion_into_fixed_list)
5366 << (isa<ConceptDecl>(Template) ? 1 : 0)
5367 << NewArgs[ArgIdx].getSourceRange();
5375 if ((*Param)->isTemplateParameterPack()) {
5380 SugaredArgumentPack.push_back(SugaredConverted.pop_back_val());
5381 CanonicalArgumentPack.push_back(CanonicalConverted.pop_back_val());
5390 if (PackExpansionIntoNonPack) {
5391 if (!SugaredArgumentPack.empty()) {
5394 SugaredConverted.insert(SugaredConverted.end(),
5395 SugaredArgumentPack.begin(),
5396 SugaredArgumentPack.end());
5397 SugaredArgumentPack.clear();
5399 CanonicalConverted.insert(CanonicalConverted.end(),
5400 CanonicalArgumentPack.begin(),
5401 CanonicalArgumentPack.end());
5402 CanonicalArgumentPack.clear();
5405 while (ArgIdx < NumArgs) {
5407 SugaredConverted.push_back(Arg);
5408 CanonicalConverted.push_back(
5420 if (PartialTemplateArgs) {
5421 if ((*Param)->isTemplateParameterPack() && !SugaredArgumentPack.empty()) {
5422 SugaredConverted.push_back(
5424 CanonicalConverted.push_back(
5432 if ((*Param)->isTemplateParameterPack()) {
5434 "Should have dealt with this already");
5439 if (Param + 1 != ParamEnd) {
5442 "Concept templates must have parameter packs at the end.");
5446 SugaredConverted.push_back(
5448 SugaredArgumentPack.clear();
5450 CanonicalConverted.push_back(
5452 CanonicalArgumentPack.clear();
5472 TTP, SugaredConverted,
5473 CanonicalConverted, Arg))
5476 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
5482 NTTP, SugaredConverted,
5483 CanonicalConverted, Arg))
5487 = cast<TemplateTemplateParmDecl>(*Param);
5495 *
this, Template, TemplateLoc, RAngleLoc, TempParm, SugaredConverted,
5496 CanonicalConverted, QualifierLoc);
5517 SugaredConverted, CanonicalConverted,
5521 CanonicalConverted.back().setIsDefaulted(
true);
5526 if (isTemplateTemplateParameter)
5540 while (ArgIdx < NumArgs &&
5541 NewArgs[ArgIdx].
getArgument().isPackExpansion()) {
5543 SugaredConverted.push_back(Arg);
5550 if (ArgIdx < NumArgs) {
5551 Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5562 if (UpdateArgsWithConversions)
5563 TemplateArgs = std::move(NewArgs);
5565 if (!PartialTemplateArgs) {
5572 if (
auto *TD = dyn_cast<TemplateDecl>(NewContext))
5574 auto *RD = dyn_cast<CXXRecordDecl>(NewContext);
5577 if (
const auto *Method =
5579 ThisQuals = Method->getMethodQualifiers();
5585 Template, NewContext,
false, CanonicalConverted,
5602 class UnnamedLocalNoLinkageFinder
5603 :
public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
5611 UnnamedLocalNoLinkageFinder(
Sema &S,
SourceRange SR) : S(S), SR(SR) { }
5614 return T.isNull() ?
false : inherited::Visit(
T.getTypePtr());
5617#define TYPE(Class, Parent) \
5618 bool Visit##Class##Type(const Class##Type *);
5619#define ABSTRACT_TYPE(Class, Parent) \
5620 bool Visit##Class##Type(const Class##Type *) { return false; }
5621#define NON_CANONICAL_TYPE(Class, Parent) \
5622 bool Visit##Class##Type(const Class##Type *) { return false; }
5623#include "clang/AST/TypeNodes.inc"
5625 bool VisitTagDecl(
const TagDecl *Tag);
5630bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(
const BuiltinType*) {
5634bool UnnamedLocalNoLinkageFinder::VisitComplexType(
const ComplexType*
T) {
5635 return Visit(
T->getElementType());
5638bool UnnamedLocalNoLinkageFinder::VisitPointerType(
const PointerType*
T) {
5642bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
5647bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
5652bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
5657bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
5662bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
5664 return Visit(
T->getElementType());
5667bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
5669 return Visit(
T->getElementType());
5672bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
5674 return Visit(
T->getElementType());
5677bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
5679 return Visit(
T->getElementType());
5682bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
5684 return Visit(
T->getElementType());
5687bool UnnamedLocalNoLinkageFinder::VisitDependentSizedMatrixType(
5689 return Visit(
T->getElementType());
5692bool UnnamedLocalNoLinkageFinder::VisitDependentAddressSpaceType(
5697bool UnnamedLocalNoLinkageFinder::VisitVectorType(
const VectorType*
T) {
5698 return Visit(
T->getElementType());
5701bool UnnamedLocalNoLinkageFinder::VisitDependentVectorType(
5703 return Visit(
T->getElementType());
5706bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(
const ExtVectorType*
T) {
5707 return Visit(
T->getElementType());
5710bool UnnamedLocalNoLinkageFinder::VisitConstantMatrixType(
5712 return Visit(
T->getElementType());
5715bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
5725bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
5730bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
5735bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(
const TypeOfExprType*) {
5739bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(
const TypeOfType*
T) {
5740 return Visit(
T->getUnmodifiedType());
5743bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(
const DecltypeType*) {
5747bool UnnamedLocalNoLinkageFinder::VisitPackIndexingType(
5752bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
5757bool UnnamedLocalNoLinkageFinder::VisitAutoType(
const AutoType *
T) {
5758 return Visit(
T->getDeducedType());
5761bool UnnamedLocalNoLinkageFinder::VisitDeducedTemplateSpecializationType(
5763 return Visit(
T->getDeducedType());
5766bool UnnamedLocalNoLinkageFinder::VisitRecordType(
const RecordType*
T) {
5767 return VisitTagDecl(
T->getDecl());
5770bool UnnamedLocalNoLinkageFinder::VisitEnumType(
const EnumType*
T) {
5771 return VisitTagDecl(
T->getDecl());
5774bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
5779bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
5784bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
5789bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
5791 return VisitTagDecl(
T->getDecl());
5794bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
5796 return VisitNestedNameSpecifier(
T->getQualifier());
5799bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
5801 if (
auto *Q =
T->getQualifier())
5802 return VisitNestedNameSpecifier(Q);
5806bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
5808 return Visit(
T->getPattern());
5811bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(
const ObjCObjectType *) {
5815bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
5820bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
5825bool UnnamedLocalNoLinkageFinder::VisitAtomicType(
const AtomicType*
T) {
5826 return Visit(
T->getValueType());
5829bool UnnamedLocalNoLinkageFinder::VisitPipeType(
const PipeType*
T) {
5833bool UnnamedLocalNoLinkageFinder::VisitBitIntType(
const BitIntType *
T) {
5837bool UnnamedLocalNoLinkageFinder::VisitArrayParameterType(
5839 return VisitConstantArrayType(
T);
5842bool UnnamedLocalNoLinkageFinder::VisitDependentBitIntType(
5847bool UnnamedLocalNoLinkageFinder::VisitTagDecl(
const TagDecl *Tag) {
5848 if (
Tag->getDeclContext()->isFunctionOrMethod()) {
5849 S.
Diag(SR.getBegin(),
5851 diag::warn_cxx98_compat_template_arg_local_type :
5852 diag::ext_template_arg_local_type)
5857 if (!
Tag->hasNameForLinkage()) {
5858 S.
Diag(SR.getBegin(),
5860 diag::warn_cxx98_compat_template_arg_unnamed_type :
5861 diag::ext_template_arg_unnamed_type) << SR;
5862 S.
Diag(
Tag->getLocation(), diag::note_template_unnamed_type_here);
5869bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
5887 llvm_unreachable(
"Invalid NestedNameSpecifier::Kind!");
5891 assert(ArgInfo &&
"invalid TypeSourceInfo");
5897 return Diag(SR.
getBegin(), diag::err_variably_modified_template_arg) << Arg;
5899 return Diag(SR.
getBegin(), diag::err_template_arg_overload_type) << SR;
5910 UnnamedLocalNoLinkageFinder Finder(*
this, SR);
5911 (void)Finder.Visit(CanonArg);
5928 Decl *Entity =
nullptr) {
5934 if (Entity && Entity->hasAttr<DLLImportAttr>())
5939 "Incomplete parameter type in isNullPointerValueTemplateArgument!");
5952 EvalResult.
Diag = &Notes;
5960 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
5961 diag::note_invalid_subexpr_in_const_expr) {
5962 DiagLoc = Notes[0].first;
5966 S.
Diag(DiagLoc, diag::err_template_arg_not_address_constant)
5968 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
5969 S.
Diag(Notes[I].first, Notes[I].second);
5987 bool ObjCLifetimeConversion;
5990 ObjCLifetimeConversion))
5995 S.
Diag(Arg->
getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
6014 std::string Code =
"static_cast<" + ParamType.
getAsString() +
">(";
6015 S.
Diag(Arg->
getExprLoc(), diag::err_template_arg_untyped_null_constant)
6034 bool ObjCLifetimeConversion;
6038 ObjCLifetimeConversion)) {
6043 if (!ParamRef->getPointeeType()->isFunctionType()) {
6053 unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
6056 if ((ParamQuals | ArgQuals) != ParamQuals) {
6058 diag::err_template_arg_ref_bind_ignores_quals)
6095 bool AddressTaken =
false;
6102 bool ExtWarnMSTemplateArg =
false;
6105 while (
UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
6107 if (UnOpKind == UO_Deref)
6108 ExtWarnMSTemplateArg =
true;
6109 if (UnOpKind == UO_AddrOf || UnOpKind == UO_Deref) {
6112 FirstOpKind = UnOpKind;
6113 FirstOpLoc = UnOp->getOperatorLoc();
6119 if (ExtWarnMSTemplateArg)
6123 if (FirstOpKind == UO_AddrOf)
6124 AddressTaken =
true;
6128 assert(FirstOpKind == UO_Deref);
6151 bool ExtraParens =
false;
6153 if (!
Invalid && !ExtraParens) {
6156 ? diag::warn_cxx98_compat_template_arg_extra_parens
6157 : diag::ext_template_arg_extra_parens)
6162 Arg =
Parens->getSubExpr();
6166 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
6170 if (UnOp->getOpcode() == UO_AddrOf) {
6171 Arg = UnOp->getSubExpr();
6172 AddressTaken =
true;
6173 AddrOpLoc = UnOp->getOperatorLoc();
6178 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
6183 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg))
6184 Entity = DRE->getDecl();
6186 Entity = CUE->getGuidDecl();
6193 S.
Diag(Arg->
getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
6196 CanonicalConverted =
6213 CanonicalConverted =
6226 if (isa<FieldDecl>(Entity) || isa<IndirectFieldDecl>(Entity)) {
6234 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Entity)) {
6235 if (!Method->isStatic()) {
6244 VarDecl *Var = dyn_cast<VarDecl>(Entity);
6245 MSGuidDecl *Guid = dyn_cast<MSGuidDecl>(Entity);
6248 if (!
Func && !Var && !Guid) {
6260 ? diag::warn_cxx98_compat_template_arg_object_internal
6261 : diag::ext_template_arg_object_internal)
6263 S.
Diag(Entity->
getLocation(), diag::note_template_arg_internal_object)
6268 S.
Diag(Entity->
getLocation(), diag::note_template_arg_internal_object)
6297 S.
Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
6303 S.
Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
6345 CanonicalConverted =
6361 Expr *Arg = ResultArg;
6362 bool ObjCLifetimeConversion;
6374 bool ExtraParens =
false;
6376 if (!
Invalid && !ExtraParens) {
6379 ? diag::warn_cxx98_compat_template_arg_extra_parens
6380 : diag::ext_template_arg_extra_parens)
6385 Arg =
Parens->getSubExpr();
6389 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
6394 if (UnOp->getOpcode() == UO_AddrOf) {
6395 DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());
6401 else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
6404 if (isa<NonTypeTemplateParmDecl>(VD)) {
6407 CanonicalConverted =
6411 CanonicalConverted =
6430 S.
Diag(ResultArg->
getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
6442 ObjCLifetimeConversion)) {
6449 S.
Diag(ResultArg->
getBeginLoc(), diag::err_template_arg_not_convertible)
6457 diag::err_template_arg_not_pointer_to_member_form)
6460 if (isa<FieldDecl>(DRE->
getDecl()) ||
6461 isa<IndirectFieldDecl>(DRE->
getDecl()) ||
6462 isa<CXXMethodDecl>(DRE->
getDecl())) {
6463 assert((isa<FieldDecl>(DRE->
getDecl()) ||
6464 isa<IndirectFieldDecl>(DRE->
getDecl()) ||
6465 cast<CXXMethodDecl>(DRE->
getDecl())
6466 ->isImplicitObjectMemberFunction()) &&
6467 "Only non-static member pointers can make it here");
6473 CanonicalConverted =
6478 CanonicalConverted =
6486 S.
Diag(Arg->
getBeginLoc(), diag::err_template_arg_not_pointer_to_member_form)
6508 auto *AT = dyn_cast<AutoType>(DeducedT);
6509 if (AT && AT->isDecltypeAuto()) {
6520 Expr *DeductionArg = Arg;
6521 if (
auto *PE = dyn_cast<PackExpansionExpr>(DeductionArg))
6522 DeductionArg = PE->getPattern();
6525 if (isa<DeducedTemplateSpecializationType>(DeducedT)) {
6529 DeductionArg->
getBeginLoc(),
false, DeductionArg);
6530 Expr *Inits[1] = {DeductionArg};
6553 diag::err_non_type_template_parm_type_deduction_failure)
6565 if (ParamType.
isNull()) {
6573 "non-type template parameter type cannot be qualified");
6599 Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
6610 auto *PE = dyn_cast<PackExpansionExpr>(Arg);
6612 Arg = PE->getPattern();
6624 PE->getNumExpansions());
6642 if (ParamType->
isRecordType() && isa<DeclRefExpr>(InnerArg) &&
6644 NamedDecl *ND = cast<DeclRefExpr>(InnerArg)->getDecl();
6645 if (
auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
6648 CanonicalConverted =
6652 if (isa<NonTypeTemplateParmDecl>(ND)) {
6654 CanonicalConverted =
6665 bool IsConvertedConstantExpression =
true;
6666 if (isa<InitListExpr>(Arg) || ParamType->
isRecordType()) {
6669 Expr *Inits[1] = {Arg};
6683 IsConvertedConstantExpression =
false;
6692 if (IsConvertedConstantExpression) {
6705 CanonicalConverted =
6713 false, PreNarrowingValue);
6717 if (
Value.isLValue()) {
6730 isa<LifetimeExtendedTemporaryDecl, UnnamedGlobalConstantDecl>(VD))) {
6736 if (
Value.hasLValuePath() &&
Value.getLValuePath().size() == 1 && VD &&
6738 Value.getLValuePath()[0].getAsArrayIndex() == 0 &&
6743 return ArgResult.
get();
6748 if (!
Value.hasLValuePath() ||
Value.getLValuePath().size() ||
6749 Value.isLValueOnePastTheEnd()) {
6750 Diag(StartLoc, diag::err_non_type_template_arg_subobject)
6755 "null reference should not be a constant expression");
6757 "non-null value of type nullptr_t?");
6761 if (
Value.isAddrLabelDiff())
6762 return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
6766 return ArgResult.
get();
6804 CanonicalConverted =
6814 IntegerType =
Enum->getDecl()->getIntegerType();
6820 CanonicalConverted =
6828 Arg = ArgResult.
get();
6841 Diag(Arg->
getBeginLoc(), diag::err_template_arg_not_integral_or_enumeral)
6854 return S.
Diag(
Loc, diag::err_template_arg_not_ice) <<
T;
6856 } Diagnoser(ArgType);
6892 CanonicalConverted =
6899 IntegerType =
Enum->getDecl()->getIntegerType();
6906 if (
Value.getBitWidth() != AllowedBits)
6910 llvm::APSInt OldValue =
Value;
6917 if (
Value.getBitWidth() != AllowedBits)
6923 (OldValue.isSigned() && OldValue.isNegative())) {
6931 unsigned RequiredBits;
6933 RequiredBits = OldValue.getActiveBits();
6934 else if (OldValue.isUnsigned())
6935 RequiredBits = OldValue.getActiveBits() + 1;
6937 RequiredBits = OldValue.getSignificantBits();
6938 if (RequiredBits > AllowedBits) {
6948 CanonicalConverted =
6998 *
this, Param, ParamType, Arg, SugaredConverted,
6999 CanonicalConverted))
7005 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
7016 "Only object pointers allowed here");
7019 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
7031 assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&
7032 "Only object references allowed here");
7036 ParamRefType->getPointeeType(),
7051 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
7060 CanonicalConverted =
7068 << Arg->
getType() << ParamType;
7076 Diag(Arg->
getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
7090 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
7107 assert(Name.isDependent() &&
"Non-dependent template isn't a declaration?");
7126 if (!isa<ClassTemplateDecl>(Template) &&
7127 !isa<TemplateTemplateParmDecl>(Template) &&
7128 !isa<TypeAliasTemplateDecl>(Template) &&
7129 !isa<BuiltinTemplateDecl>(Template)) {
7130 assert(isa<FunctionTemplateDecl>(Template) &&
7131 "Only function templates are possible here");
7133 Diag(Template->
getLocation(), diag::note_template_arg_refers_here_func)
7155 Params, Template, Arg.
getLocation(), IsDeduced)) {
7165 if (ParamsAC.empty())
7170 bool IsParamAtLeastAsConstrained;
7172 IsParamAtLeastAsConstrained))
7174 if (!IsParamAtLeastAsConstrained) {
7176 diag::err_template_template_parameter_not_at_least_as_constrained)
7198 unsigned HereDiagID,
7199 unsigned ExternalDiagID) {
7204 llvm::raw_svector_ostream Out(Str);
7212 std::optional<SourceRange> ParamRange) {
7215 diag::note_template_decl_external);
7216 if (ParamRange && ParamRange->isValid()) {
7218 "Parameter range has location when Decl does not");
7225 diag::note_template_param_external);
7248 ? CK_NullToMemberPointer
7249 : CK_NullToPointer);
7252 "Only declaration template arguments permitted here");
7261 (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD) ||
7262 isa<IndirectFieldDecl>(VD)));
7290 assert(isa<TemplateParamObjectDecl>(VD) &&
7291 "arg for class template param not a template parameter object");
7296 "unexpected type for decl template argument");
7298 dyn_cast_if_present<NonTypeTemplateParmDecl>(
TemplateParam)) {
7299 QualType TemplateParamType = NTTP->getType();
7313 "value kind mismatch for non-type template argument");
7333 "unexpected conversion required for non-type template argument");
7360 T = ET->getDecl()->getIntegerType();
7411 llvm_unreachable(
"unexpected template argument value");
7436 return MakeInitList(
7449 return MakeInitList(Elts);
7454 llvm_unreachable(
"Unexpected APValue kind.");
7470 llvm_unreachable(
"Unhandled APValue::ValueKind enum");
7482 llvm_unreachable(
"not a non-type template argument");
7500 llvm_unreachable(
"Unhandled TemplateArgument::ArgKind enum");
7507 const NamedDecl *OldInstFrom,
bool Complain,
7512 unsigned NextDiag = diag::err_template_param_different_kind;
7513 if (TemplateArgLoc.
isValid()) {
7514 S.
Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
7515 NextDiag = diag::note_template_param_different_kind;
7534 unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
7535 if (TemplateArgLoc.
isValid()) {
7536 S.
Diag(TemplateArgLoc,
7537 diag::err_template_arg_template_params_mismatch);
7538 NextDiag = diag::note_template_parameter_pack_non_pack;
7541 unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0
7542 : isa<NonTypeTemplateParmDecl>(New)? 1
7555 = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
7563 (!OldNTTP->getType()->isDependentType() &&
7573 unsigned NextDiag = diag::err_template_nontype_parm_different_type;
7574 if (TemplateArgLoc.
isValid()) {
7575 S.
Diag(TemplateArgLoc,
7576 diag::err_template_arg_template_params_mismatch);
7577 NextDiag = diag::note_template_nontype_parm_different_type;
7582 S.
Diag(OldNTTP->getLocation(),
7583 diag::note_template_nontype_parm_prev_declaration)
7584 << OldNTTP->getType();
7595 dyn_cast<TemplateTemplateParmDecl>(Old)) {
7599 OldTTP->getTemplateParameters(), Complain,
7609 !isa<TemplateTemplateParmDecl>(Old)) {
7610 const Expr *NewC =
nullptr, *OldC =
nullptr;
7612 if (isa<TemplateTypeParmDecl>(New)) {
7613 if (
const auto *TC = cast<TemplateTypeParmDecl>(New)->getTypeConstraint())
7614 NewC = TC->getImmediatelyDeclaredConstraint();
7615 if (
const auto *TC = cast<TemplateTypeParmDecl>(Old)->getTypeConstraint())
7616 OldC = TC->getImmediatelyDeclaredConstraint();
7617 }
else if (isa<NonTypeTemplateParmDecl>(New)) {
7618 if (
const Expr *
E = cast<NonTypeTemplateParmDecl>(New)
7619 ->getPlaceholderTypeConstraint())
7621 if (
const Expr *
E = cast<NonTypeTemplateParmDecl>(Old)
7622 ->getPlaceholderTypeConstraint())
7625 llvm_unreachable(
"unexpected template parameter type");
7627 auto Diagnose = [&] {
7629 diag::err_template_different_type_constraint);
7631 diag::note_template_prev_declaration) << 0;
7634 if (!NewC != !OldC) {
7661 unsigned NextDiag = diag::err_template_param_list_different_arity;
7662 if (TemplateArgLoc.
isValid()) {
7663 S.
Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
7664 NextDiag = diag::note_template_param_list_different_arity;
7696 OldParmEnd = Old->
end();
7697 OldParm != OldParmEnd; ++OldParm) {
7699 !(*OldParm)->isTemplateParameterPack()) {
7700 if (NewParm == NewParmEnd) {
7709 OldInstFrom, Complain, Kind,
7724 for (; NewParm != NewParmEnd; ++NewParm) {
7726 OldInstFrom, Complain, Kind,
7733 if (NewParm != NewParmEnd) {
7748 diag::err_template_different_requires_clause);
7750 diag::note_template_prev_declaration) << 0;
7753 if (!NewRC != !OldRC) {
7778 S = S->getDeclParent();
7788 Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
7808 if (RD->isLocalClass())
7810 diag::err_template_inside_local_class)
7818 diag::err_template_outside_namespace_or_class_scope)
7829 return Record->getTemplateSpecializationKind();
7831 return Function->getTemplateSpecializationKind();
7832 if (
VarDecl *Var = dyn_cast<VarDecl>(
D))
7833 return Var->getTemplateSpecializationKind();
7870 if (isa<ClassTemplateDecl>(Specialized))
7872 else if (isa<VarTemplateDecl>(Specialized))
7874 else if (isa<FunctionTemplateDecl>(Specialized))
7876 else if (isa<CXXMethodDecl>(Specialized))
7878 else if (isa<VarDecl>(Specialized))
7880 else if (isa<RecordDecl>(Specialized))
7882 else if (isa<EnumDecl>(Specialized) && S.
getLangOpts().CPlusPlus11)
7885 S.
Diag(
Loc, diag::err_template_spec_unknown_kind)
7895 S.
Diag(
Loc, diag::err_template_spec_decl_function_scope)
7910 : DC->
Equals(SpecializedContext))) {
7911 if (isa<TranslationUnitDecl>(SpecializedContext))
7912 S.
Diag(
Loc, diag::err_template_spec_redecl_global_scope)
7913 << EntityKind << Specialized;
7915 auto *ND = cast<NamedDecl>(SpecializedContext);
7916 int Diag = diag::err_template_spec_redecl_out_of_scope;
7918 Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
7920 << ND << isa<CXXRecordDecl>(ND);
7923 S.
Diag(Specialized->getLocation(), diag::note_specialized_entity);
7937 DependencyChecker Checker(Depth,
true);
7938 Checker.TraverseStmt(
E);
7939 if (Checker.MatchLoc.isInvalid())
7941 return Checker.MatchLoc;
7947 DependencyChecker Checker(Depth,
true);
7948 Checker.TraverseTypeLoc(TL);
7949 if (Checker.MatchLoc.isInvalid())
7951 return Checker.MatchLoc;
7959 for (
unsigned I = 0; I != NumArgs; ++I) {
7962 S, TemplateNameLoc, Param, Args[I].pack_begin(),
7963 Args[I].pack_size(), IsDefaultArgument))
7976 ArgExpr = Expansion->getPattern();
7980 ArgExpr = ICE->getSubExpr();
7990 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
7991 if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
8011 if (ParamUseRange.
isValid()) {
8012 if (IsDefaultArgument) {
8013 S.
Diag(TemplateNameLoc,
8014 diag::err_dependent_non_type_arg_in_partial_spec);
8016 diag::note_dependent_non_type_default_arg_in_partial_spec)
8020 diag::err_dependent_non_type_arg_in_partial_spec)
8028 if (ParamUseRange.
isValid()) {
8030 diag::err_dependent_typed_non_type_arg_in_partial_spec)
8050 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
8052 = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->
getParam(I));
8057 Param, &TemplateArgs[I],
8058 1, I >= NumExplicit))
8079 = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());
8082 Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
8083 << (Name.getAsTemplateDecl() &&
8084 isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));
8088 bool isMemberSpecialization =
false;
8089 bool isPartialSpecialization =
false;
8095 TemplateNameLoc, &TemplateId,
8107 KWLoc, TemplateNameLoc, SS, &TemplateId, TemplateParameterLists,
8116 if (TemplateParams && TemplateParams->
size() > 0) {
8117 isPartialSpecialization =
true;
8120 Diag(KWLoc, diag::err_partial_specialization_friend)
8128 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
8131 if (TTP->hasDefaultArgument()) {
8132 Diag(TTP->getDefaultArgumentLoc(),
8133 diag::err_default_arg_in_partial_spec);
8134 TTP->removeDefaultArgument();
8137 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
8138 if (NTTP->hasDefaultArgument()) {
8139 Diag(NTTP->getDefaultArgumentLoc(),
8140 diag::err_default_arg_in_partial_spec)
8141 << NTTP->getDefaultArgument().getSourceRange();
8142 NTTP->removeDefaultArgument();
8148 diag::err_default_arg_in_partial_spec)
8154 }
else if (TemplateParams) {
8156 Diag(KWLoc, diag::err_template_spec_friend)
8163 "should have a 'template<>' for this decl");
8170 "Invalid enum tag in class template spec!");
8174 Diag(KWLoc, diag::err_use_with_wrong_tag)
8179 diag::note_previous_use);
8188 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
8190 isPartialSpecialization
8199 false, SugaredConverted, CanonicalConverted,
8205 if (isPartialSpecialization) {
8207 TemplateArgs.
size(),
8208 CanonicalConverted))
8213 if (!Name.isDependent() &&
8215 TemplateArgs, CanonicalConverted)) {
8216 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
8218 isPartialSpecialization =
false;
8223 void *InsertPos =
nullptr;
8226 if (isPartialSpecialization)
8228 CanonicalConverted, TemplateParams, InsertPos);
8230 PrevDecl =
ClassTemplate->findSpecialization(CanonicalConverted, InsertPos);
8239 isPartialSpecialization))
8244 if (isPartialSpecialization) {
8249 CanonicalConverted);
8262 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
8272 TemplateParameterLists.size() - 1,
8273 TemplateParameterLists.data());
8278 = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
8282 TemplateNameLoc, TemplateParams,
ClassTemplate, CanonicalConverted,
8283 CanonType, PrevPartial);
8286 if (TemplateParameterLists.size() > 1 && SS.
isSet()) {
8288 Context, TemplateParameterLists.drop_back(1));
8292 ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
8309 if (TemplateParameterLists.size() > 0) {
8311 TemplateParameterLists);
8320 CanonicalConverted);
8344 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
8348 diag::note_instantiation_required_here)
8386 if (ModulePrivateLoc.
isValid())
8388 << (isPartialSpecialization? 1 : 0)
8414 Name, TemplateNameLoc, TemplateArgs, CanonType);
8451 diag::err_concept_decls_may_only_appear_in_global_namespace_scope);
8455 if (TemplateParameterLists.size() > 1) {
8456 Diag(NameLoc, diag::err_concept_extra_headers);
8462 if (Params->
size() == 0) {
8463 Diag(NameLoc, diag::err_concept_no_parameters);
8470 ParamEnd = Params->
end();
8471 ParamIt != ParamEnd; ++ParamIt) {
8472 Decl const *Param = *ParamIt;
8474 if (++ParamIt == ParamEnd)
8477 diag::err_template_param_pack_must_be_last_template_parameter);
8491 Diag(NameLoc, diag::err_concept_no_associated_constraints);
8502 bool AddToScope =
true;
8521 auto *OldConcept = dyn_cast<ConceptDecl>(
Previous.getRepresentativeDecl()->getUnderlyingDecl());
8523 auto *Old =
Previous.getRepresentativeDecl();
8533 Diag(NewDecl->
getLocation(), diag::err_redefinition_different_concept)
8559 if (MinGW || (isa<FunctionDecl>(
D) &&
8560 cast<FunctionDecl>(
D)->isFunctionTemplateSpecialization()))
8561 D->
dropAttrs<DLLImportAttr, DLLExportAttr>();
8564 FD->setInlineSpecified(
false);
8576 Prev = Prev->getPreviousDecl()) {
8577 PrevDiagLoc = Prev->getLocation();
8579 assert(PrevDiagLoc.
isValid() &&
8580 "Explicit instantiation without point of instantiation?");
8590 bool &HasNoEffect) {
8591 HasNoEffect =
false;
8598 "previous declaration must be implicit!");
8611 if (PrevPointOfInstantiation.
isInvalid()) {
8625 PrevPointOfInstantiation.
isValid()) &&
8626 "Explicit instantiation without point of instantiation?");
8640 Diag(NewLoc, diag::err_specialization_after_instantiation)
8642 Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
8647 llvm_unreachable(
"The switch over PrevTSK must be exhaustive.");
8677 diag::err_explicit_instantiation_declaration_after_definition);
8683 diag::note_explicit_instantiation_definition_here);
8687 llvm_unreachable(
"Unexpected TemplateSpecializationKind!");
8703 Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
8706 diag::note_previous_template_specialization);
8737 ? diag::ext_explicit_instantiation_duplicate
8738 : diag::err_explicit_instantiation_duplicate)
8741 diag::note_previous_explicit_instantiation);
8747 llvm_unreachable(
"Missing specialization/instantiation case?");
8757 enum DiscardReason { NotAFunctionTemplate, NotAMemberOfEnclosing };
8761 if (!isa<FunctionTemplateDecl>(
D)) {
8763 DiscardedCandidates.push_back(std::make_pair(NotAFunctionTemplate,
D));
8770 DiscardedCandidates.push_back(std::make_pair(NotAMemberOfEnclosing,
D));
8778 Diag(FD->
getLocation(), diag::err_dependent_function_template_spec_no_match)
8780 for (
auto &
P : DiscardedCandidates)
8781 Diag(
P.second->getLocation(),
8782 diag::note_dependent_function_template_spec_discard_reason)
8783 <<
P.first << IsFriend;
8788 ExplicitTemplateArgs);
8801 llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>
8802 ConvertedTemplateArgs;
8825 if (
auto *NewMD = dyn_cast<CXXMethodDecl>(FD);
8826 !
getLangOpts().CPlusPlus14 && NewMD && NewMD->isConstexpr() &&
8827 !isa<CXXConstructorDecl, CXXDestructorDecl>(NewMD)) {
8828 auto *OldMD = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
8829 if (OldMD && OldMD->isConst()) {
8839 if (ExplicitTemplateArgs)
8840 Args = *ExplicitTemplateArgs;
8852 cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
8853 ExplicitTemplateArgs ? &Args :
nullptr, FT,
Specialization, Info);
8858 I.getPair(), FunTmpl->getTemplatedDecl(),
8874 I.getPair(), FunTmpl->getTemplatedDecl(),
8881 if (ExplicitTemplateArgs)
8890 if (QualifiedFriend && Candidates.
empty()) {
8896 if (
auto *OldFD = dyn_cast<FunctionDecl>(OldND->getUnderlyingDecl()))
8907 PDiag(diag::err_function_template_spec_ambiguous)
8908 << FD->
getDeclName() << (ExplicitTemplateArgs !=
nullptr),
8909 PDiag(diag::note_function_template_spec_matched));
8942 auto *SpecializationFPT =
8953 assert(SpecInfo &&
"Function template specialization info missing?");
8991 bool HasNoEffect =
false;
9017 "This must be the only existing declaration of this specialization");
9032 FD->setFunctionTemplateSpecialization(
9035 ExplicitTemplateArgs ? &ConvertedTemplateArgs[
Specialization] :
nullptr);
9054 assert(!isa<TemplateDecl>(
Member) &&
"Only for non-template members");
9057 NamedDecl *FoundInstantiation =
nullptr;
9066 bool Ambiguous =
false;
9070 dyn_cast<CXXMethodDecl>((*I)->getUnderlyingDecl());
9085 !Satisfaction.IsSatisfied))
9087 Candidates.push_back(Method);
9090 Method, cast<FunctionDecl>(Instantiation))
9092 if (!MoreConstrained) {
9096 if (MoreConstrained == Method) {
9098 FoundInstantiation = *I;
9099 Instantiation = Method;
9105 Diag(
Member->getLocation(), diag::err_function_member_spec_ambiguous)
9106 <<
Member << (InstantiatedFrom ? InstantiatedFrom : Instantiation);
9108 Diag(Candidate->getLocation(), diag::note_function_member_spec_matched)
9112 }
else if (isa<VarDecl>(
Member)) {
9115 (PrevVar = dyn_cast<VarDecl>(
Previous.getFoundDecl())))
9117 FoundInstantiation =
Previous.getRepresentativeDecl();
9118 Instantiation = PrevVar;
9122 }
else if (isa<RecordDecl>(
Member)) {
9125 (PrevRecord = dyn_cast<CXXRecordDecl>(
Previous.getFoundDecl()))) {
9126 FoundInstantiation =
Previous.getRepresentativeDecl();
9127 Instantiation = PrevRecord;
9131 }
else if (isa<EnumDecl>(
Member)) {
9134 (PrevEnum = dyn_cast<EnumDecl>(
Previous.getFoundDecl()))) {
9135 FoundInstantiation =
Previous.getRepresentativeDecl();
9136 Instantiation = PrevEnum;
9142 if (!Instantiation) {
9156 if (InstantiatedFrom && isa<CXXMethodDecl>(
Member)) {
9157 cast<CXXMethodDecl>(
Member)->setInstantiationOfMemberFunction(
9158 cast<CXXMethodDecl>(InstantiatedFrom),
9160 }
else if (InstantiatedFrom && isa<CXXRecordDecl>(
Member)) {
9161 cast<CXXRecordDecl>(
Member)->setInstantiationOfMemberClass(
9162 cast<CXXRecordDecl>(InstantiatedFrom),
9167 Previous.addDecl(FoundInstantiation);
9172 if (!InstantiatedFrom) {
9173 Diag(
Member->getLocation(), diag::err_spec_member_not_instantiated)
9185 assert(MSInfo &&
"Member specialization info missing?");
9187 bool HasNoEffect =
false;
9199 Instantiation,
Member->getLocation(),
9205 if (
auto *MemberFunction = dyn_cast<FunctionDecl>(
Member)) {
9206 FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation);
9211 if (InstantiationFunction->
isDeleted()) {
9214 InstantiationFunction);
9220 MemberFunction->setInstantiationOfMemberFunction(
9222 }
else if (
auto *MemberVar = dyn_cast<VarDecl>(
Member)) {
9223 MemberVar->setInstantiationOfStaticDataMember(
9225 }
else if (
auto *MemberClass = dyn_cast<CXXRecordDecl>(
Member)) {
9226 MemberClass->setInstantiationOfMemberClass(
9228 }
else if (
auto *MemberEnum = dyn_cast<EnumDecl>(
Member)) {
9229 MemberEnum->setInstantiationOfMemberEnum(
9232 llvm_unreachable(
"unknown member specialization kind");
9238 Previous.addDecl(FoundInstantiation);
9247template<
typename DeclT>
9258 OrigD->setLocation(
Loc);
9263 NamedDecl *Instantiation = cast<NamedDecl>(
Member->getCanonicalDecl());
9264 if (Instantiation ==
Member)
9267 if (
auto *
Function = dyn_cast<CXXMethodDecl>(Instantiation))
9269 else if (
auto *Var = dyn_cast<VarDecl>(Instantiation))
9271 else if (
auto *
Record = dyn_cast<CXXRecordDecl>(Instantiation))
9273 else if (
auto *
Enum = dyn_cast<EnumDecl>(Instantiation))
9276 llvm_unreachable(
"unknown member specialization kind");
9284 bool WasQualifiedName) {
9289 S.
Diag(InstLoc, diag::err_explicit_instantiation_in_class)
9302 if (WasQualifiedName) {
9303 if (CurContext->
Encloses(OrigContext))
9310 if (
NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) {
9311 if (WasQualifiedName)
9314 diag::err_explicit_instantiation_out_of_scope :
9315 diag::warn_explicit_instantiation_out_of_scope_0x)
9320 diag::err_explicit_instantiation_unqualified_wrong_namespace :
9321 diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
9326 diag::err_explicit_instantiation_must_be_global :
9327 diag::warn_explicit_instantiation_must_be_global_0x)
9336 bool WasQualifiedName,
9343 S.
Diag(InstLoc, diag::err_explicit_instantiation_internal_linkage) <<
D;
9371 if (isa<TemplateSpecializationType>(
T))
9381 auto *A = cast_or_null<InheritableAttr>(
getDLLAttr(Def));
9382 assert(A &&
"dllExportImportClassTemplateSpecialization called "
9383 "on Def without dllexport or dllimport");
9388 "delayed exports present at explicit instantiation");
9392 for (
auto &B : Def->
bases()) {
9393 if (
auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
9394 B.getType()->getAsCXXRecordDecl()))
9414 "Invalid enum tag in class template explicit instantiation!");
9420 Diag(TemplateNameLoc, diag::err_tag_reference_non_tag)
9421 << TD << NTK << llvm::to_underlying(Kind);
9429 Diag(KWLoc, diag::err_use_with_wrong_tag)
9434 diag::note_previous_use);
9451 if (AL.getKind() == ParsedAttr::AT_DLLExport) {
9453 diag::warn_attribute_dllexport_explicit_instantiation_decl);
9454 Diag(AL.getLoc(), diag::note_attribute);
9459 if (
auto *A =
ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {
9461 diag::warn_attribute_dllexport_explicit_instantiation_decl);
9462 Diag(A->getLocation(), diag::note_attribute);
9468 bool DLLImportExplicitInstantiationDef =
false;
9473 ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
9475 if (AL.getKind() == ParsedAttr::AT_DLLImport)
9477 if (AL.getKind() == ParsedAttr::AT_DLLExport) {
9485 DLLImportExplicitInstantiationDef =
true;
9497 false, SugaredConverted, CanonicalConverted,
9503 void *InsertPos =
nullptr;
9505 ClassTemplate->findSpecialization(CanonicalConverted, InsertPos);
9515 if (AL.getKind() == ParsedAttr::AT_DLLExport) {
9517 diag::warn_attribute_dllexport_explicit_instantiation_def);
9529 bool HasNoEffect =
false;
9532 PrevDecl, PrevDecl_TSK,
9553 DLLImportExplicitInstantiationDef) {
9555 HasNoEffect =
false;
9570 if (
const auto *A = PrevDecl->
getAttr<MSInheritanceAttr>()) {
9572 Clone->setInherited(
true);
9578 if (!HasNoEffect && !PrevDecl) {
9591 bool PreviouslyDLLExported =
Specialization->hasAttr<DLLExportAttr>();
9616 = cast_or_null<ClassTemplateSpecializationDecl>(
9626 Def = cast_or_null<ClassTemplateSpecializationDecl>(
9634 DLLImportExplicitInstantiationDef)) {
9643 auto *A = cast<InheritableAttr>(
9645 A->setInherited(
true);
9653 bool NewlyDLLExported =
9654 !PreviouslyDLLExported &&
Specialization->hasAttr<DLLExportAttr>();
9670 "Def and Specialization should match for implicit instantiation");
9678 PrevDecl->
hasAttr<DLLExportAttr>()) {
9703 bool IsDependent =
false;
9711 assert(!IsDependent &&
"explicit instantiation of dependent name not yet handled");
9716 TagDecl *Tag = cast<TagDecl>(TagD);
9717 assert(!Tag->isEnum() &&
"shouldn't see enumerations here");
9719 if (Tag->isInvalidDecl())
9725 Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
9727 Diag(
Record->getLocation(), diag::note_nontemplate_decl_here);
9738 Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
9753 = cast_or_null<CXXRecordDecl>(
Record->getPreviousDecl());
9758 bool HasNoEffect =
false;
9759 assert(MSInfo &&
"No member specialization information?");
9771 = cast_or_null<CXXRecordDecl>(
Record->getDefinition());
9779 Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
9780 << 0 <<
Record->getDeclName() <<
Record->getDeclContext();
9790 RecordDef = cast_or_null<CXXRecordDecl>(
Record->getDefinition());
9819 if (!
D.isInvalidType())
9821 diag::err_explicit_instantiation_requires_name)
9828 S = S->getDeclParent();
9840 Diag(
D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef)
9843 }
else if (
D.getDeclSpec().getStorageClassSpec()
9846 Diag(
D.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class)
9849 D.getMutableDeclSpec().ClearStorageClassSpecs();
9857 if (
D.getDeclSpec().isInlineSpecified())
9858 Diag(
D.getDeclSpec().getInlineSpecLoc(),
9860 diag::err_explicit_instantiation_inline :
9861 diag::warn_explicit_instantiation_inline_0x)
9866 Diag(
D.getDeclSpec().getConstexprSpecLoc(),
9867 diag::err_explicit_instantiation_constexpr);
9903 if (!PrevTemplate) {
9906 Diag(
D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
9910 Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
9916 Diag(
D.getIdentifierLoc(),
9917 diag::err_explicit_instantiation_data_member_not_instantiated)
9932 Diag(
T->getTypeLoc().getBeginLoc(),
9933 diag::err_auto_not_allowed_var_inst);
9941 Diag(
D.getIdentifierLoc(),
9942 diag::err_explicit_instantiation_without_template_id)
9944 Diag(PrevTemplate->getLocation(),
9945 diag::note_explicit_instantiation_here);
9954 D.getIdentifierLoc(), TemplateArgs);
9962 Diag(
D.getIdentifierLoc(), diag::err_explicit_instantiation_dependent);
9968 Prev = cast<VarDecl>(Res.
get());
9982 Diag(
D.getIdentifierLoc(),
9983 diag::ext_explicit_instantiation_without_qualified_id)
9984 << Prev <<
D.getCXXScopeSpec().getRange();
9991 bool HasNoEffect =
false;
9993 PrevTSK, POI, HasNoEffect))
9999 if (
auto *VTSD = dyn_cast<VarTemplatePartialSpecializationDecl>(Prev)) {
10000 VTSD->setExternKeywordLoc(ExternLoc);
10001 VTSD->setTemplateKeywordLoc(TemplateLoc);
10015 Diag(
T->getTypeLoc().getBeginLoc(),
10016 diag::err_invalid_var_template_spec_type)
10017 << 0 << PrevTemplate << R << Prev->
getType();
10018 Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
10019 << 2 << PrevTemplate->getDeclName();
10024 return (
Decl*)
nullptr;
10029 bool HasExplicitTemplateArgs =
false;
10033 HasExplicitTemplateArgs =
true;
10047 if (!HasExplicitTemplateArgs) {
10048 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) {
10052 if (Method->getPrimaryTemplate()) {
10053 TemplateMatches.
addDecl(Method,
P.getAccess());
10056 assert(!NonTemplateMatch &&
"Multiple NonTemplateMatches");
10057 NonTemplateMatch = Method;
10070 FunTmpl, (HasExplicitTemplateArgs ? &TemplateArgs :
nullptr), R,
10104 TemplateMatches.
begin(), TemplateMatches.
end(), FailedCandidates,
10105 D.getIdentifierLoc(),
10106 PDiag(diag::err_explicit_instantiation_not_known) << Name,
10107 PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
10108 PDiag(diag::note_explicit_instantiation_candidate));
10124 if (FPT->hasExceptionSpec()) {
10126 diag::err_mismatched_exception_spec_explicit_instantiation;
10128 DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;
10131 PDiag(diag::note_explicit_instantiation_here),
10141 Diag(
D.getIdentifierLoc(),
10142 diag::err_explicit_instantiation_member_function_not_instantiated)
10151 if (!PrevDecl &&
Specialization->isThisDeclarationADefinition())
10155 bool HasNoEffect =
false;
10166 return (
Decl*)
nullptr;
10177 if (
auto *RD = dyn_cast<CXXRecordDecl>(
Specialization->getDeclContext()))
10178 if (RD->getIdentifier() && RD->getIdentifier()->isStr(
"valarray") &&
10179 RD->isInStdNamespace())
10180 return (
Decl*)
nullptr;
10193 Specialization->setTemplateSpecializationKind(TSK,
D.getIdentifierLoc());
10211 D.getCXXScopeSpec().isSet() &&
10213 Diag(
D.getIdentifierLoc(),
10214 diag::ext_explicit_instantiation_without_qualified_id)
10221 D.getIdentifierLoc(),
D.getCXXScopeSpec().isSet(), TSK);
10224 return (
Decl*)
nullptr;
10233 assert(Name &&
"Expected a name in a dependent tag");
10242 Diag(NameLoc, diag::err_dependent_tag_decl)
10269 if (TypenameLoc.
isValid() && S && !S->getTemplateParamParent())
10272 diag::warn_cxx98_compat_typename_outside_of_template :
10273 diag::ext_typename_outside_of_template)
10283 TypenameLoc, QualifierLoc, II, IdLoc, &TSI,
10297 if (TypenameLoc.
isValid() && S && !S->getTemplateParamParent())
10300 diag::warn_cxx98_compat_typename_outside_of_template :
10301 diag::ext_typename_outside_of_template)
10309 if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
10310 Diag(TemplateIILoc,
10311 diag::ext_out_of_line_qualified_id_type_names_constructor)
10313 << (TemplateKWLoc.
isValid() ? 1 : 0 );
10324 assert(DTN &&
"dependent template has non-dependent name?");
10327 if (!DTN->isIdentifier()) {
10328 Diag(TemplateIILoc, diag::err_template_id_not_a_type) << Template;
10335 DTN->getIdentifier(), TemplateArgs.
arguments());
10347 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
10364 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
10382 if (!II.
isStr(
"type"))
10391 if (!EnableIfTSTLoc || EnableIfTSTLoc.
getNumArgs() == 0)
10404 if (!EnableIfII || !EnableIfII->
isStr(
"enable_if"))
10432 bool DeducedTSTContext) {
10434 DeducedTSTContext);
10439 if (isa<DependentNameType>(
T)) {
10463 SS.
Adopt(QualifierLoc);
10466 if (QualifierLoc) {
10493 unsigned DiagID = 0;
10494 Decl *Referenced =
nullptr;
10495 switch (
Result.getResultKind()) {
10500 Expr *Cond =
nullptr;
10501 if (Ctx &&
isEnableIf(QualifierLoc, II, CondRange, Cond)) {
10506 std::string FailedDescription;
10507 std::tie(FailedCond, FailedDescription) =
10511 diag::err_typename_nested_not_found_requirement)
10512 << FailedDescription
10518 diag::err_typename_nested_not_found_enable_if)
10519 << Ctx << CondRange;
10523 DiagID = Ctx ? diag::err_typename_nested_not_found
10524 : diag::err_unknown_typename;
10533 Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
10534 << Name << Ctx << FullRange;
10536 = dyn_cast<UnresolvedUsingValueDecl>(
Result.getRepresentativeDecl())){
10538 Diag(
Loc, diag::note_using_value_decl_missing_typename)
10568 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(Ctx);
10569 auto *FoundRD = dyn_cast<CXXRecordDecl>(
Type);
10571 FoundRD->isInjectedClassName() &&
10573 Diag(IILoc, diag::ext_out_of_line_qualified_id_type_names_constructor)
10590 if (!DeducedTSTContext) {
10595 Diag(IILoc, diag::err_dependent_deduced_tst)
10598 Diag(IILoc, diag::err_deduced_tst)
10610 DiagID = Ctx ? diag::err_typename_nested_not_type
10611 : diag::err_typename_not_type;
10612 Referenced =
Result.getFoundDecl();
10616 DiagID = Ctx ? diag::err_typename_nested_not_type
10617 : diag::err_typename_not_type;
10618 Referenced = *
Result.begin();
10630 Diag(IILoc, DiagID) << FullRange << Name << Ctx;
10632 Diag(IILoc, DiagID) << FullRange << Name;
10635 Ctx ? diag::note_typename_member_refers_here
10636 : diag::note_typename_refers_here)
10643 class CurrentInstantiationRebuilder
10651 CurrentInstantiationRebuilder(
Sema &SemaRef,
10655 Loc(
Loc), Entity(Entity) { }
10677 this->Entity = Entity;
10693 CurrentInstantiationRebuilder Rebuilder(*
this,
Loc, Name);
10694 return Rebuilder.TransformType(
T);
10698 CurrentInstantiationRebuilder Rebuilder(*
this,
E->
getExprLoc(),
10700 return Rebuilder.TransformExpr(
E);
10711 = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
10721 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
10725 if (isa<TemplateTypeParmDecl>(Param))
10730 = dyn_cast<TemplateTemplateParmDecl>(Param)) {
10732 TTP->getTemplateParameters()))
10774 unsigned NumArgs) {
10776 llvm::raw_svector_ostream Out(Str);
10778 if (!Params || Params->
size() == 0 || NumArgs == 0)
10779 return std::string();
10781 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
10791 Out <<
Id->getName();
10803 return std::string(Out.str());
10811 auto LPT = std::make_unique<LateParsedTemplate>();
10814 LPT->Toks.swap(Toks);
10861class ExplicitSpecializationVisibilityChecker {
10873 if (
auto *FD = dyn_cast<FunctionDecl>(ND))
10874 return checkImpl(FD);
10875 if (
auto *RD = dyn_cast<CXXRecordDecl>(ND))
10876 return checkImpl(RD);
10877 if (
auto *VD = dyn_cast<VarDecl>(ND))
10878 return checkImpl(VD);
10879 if (
auto *ED = dyn_cast<EnumDecl>(ND))
10880 return checkImpl(ED);
10884 void diagnose(
NamedDecl *
D,
bool IsPartialSpec) {
10885 auto Kind = IsPartialSpec ? Sema::MissingImportKind::PartialSpecialization
10886 : Sema::MissingImportKind::ExplicitSpecialization;
10887 const bool Recover =
true;
10892 if (Modules.empty())
10898 bool CheckMemberSpecialization(
const NamedDecl *
D) {
10899 return Kind == Sema::AcceptableKind::Visible
10904 bool CheckExplicitSpecialization(
const NamedDecl *
D) {
10905 return Kind == Sema::AcceptableKind::Visible
10927 template<
typename SpecDecl>
10928 void checkImpl(SpecDecl *Spec) {
10929 bool IsHiddenExplicitSpecialization =
false;
10931 IsHiddenExplicitSpecialization = Spec->getMemberSpecializationInfo()
10932 ? !CheckMemberSpecialization(Spec)
10933 : !CheckExplicitSpecialization(Spec);
10935 checkInstantiated(Spec);
10938 if (IsHiddenExplicitSpecialization)
10939 diagnose(Spec->getMostRecentDecl(),
false);
10948 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
10952 auto From = SD->getSpecializedTemplateOrPartial();
10955 else if (
auto *TD =
10957 if (!CheckDeclaration(TD))
10958 diagnose(TD,
true);
10963 void checkInstantiated(
VarDecl *RD) {
10964 auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
10968 auto From = SD->getSpecializedTemplateOrPartial();
10971 else if (
auto *TD =
10973 if (!CheckDeclaration(TD))
10974 diagnose(TD,
true);
10979 void checkInstantiated(
EnumDecl *FD) {}
10981 template<
typename TemplDecl>
10982 void checkTemplate(TemplDecl *TD) {
10983 if (TD->isMemberSpecialization()) {
10984 if (!CheckMemberSpecialization(TD))
10985 diagnose(TD->getMostRecentDecl(),
false);
10995 ExplicitSpecializationVisibilityChecker(*
this,
Loc,
11005 ExplicitSpecializationVisibilityChecker(*
this,
Loc,
11013 if (
const auto *FD = dyn_cast<FunctionDecl>(N)) {
11021 if (!CSC.isInstantiationRecord() || CSC.PointOfInstantiation.isInvalid())
11023 return CSC.PointOfInstantiation;
Defines the clang::ASTContext interface.
Defines enum values for all the target-independent builtin functions.
enum clang::sema::@1651::IndirectLocalPathEntry::EntryKind Kind
static Decl::Kind getKind(const Decl *D)
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Record Record
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
MatchFinder::MatchResult MatchResult
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis for CUDA constructs.
static void SetNestedNameSpecifier(Sema &S, DeclaratorDecl *DD, Declarator &D)
static bool DependsOnTemplateParameters(QualType T, TemplateParameterList *Params)
Determines whether a given type depends on the given parameter list.
static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D)
Determine what kind of template specialization the given declaration is.
static Expr * BuildExpressionFromNonTypeTemplateArgumentValue(Sema &S, QualType T, const APValue &Val, SourceLocation Loc)
static void maybeDiagnoseTemplateParameterShadow(Sema &SemaRef, Scope *S, SourceLocation Loc, const IdentifierInfo *Name)
static TemplateArgumentLoc convertTypeTemplateArgumentToTemplate(ASTContext &Context, TypeLoc TLoc)
Convert a template-argument that we parsed as a type into a template, if possible.
static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized, NamedDecl *PrevDecl, SourceLocation Loc, bool IsPartialSpecialization)
Check whether a specialization is well-formed in the current context.
static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS)
Determine whether the given scope specifier has a template-id in it.
static SourceRange findTemplateParameterInType(unsigned Depth, Expr *E)
static Sema::SemaDiagnosticBuilder noteLocation(Sema &S, const NamedDecl &Decl, unsigned HereDiagID, unsigned ExternalDiagID)
static SourceRange getRangeOfTypeInNestedNameSpecifier(ASTContext &Context, QualType T, const CXXScopeSpec &SS)
static Expr * BuildExpressionFromIntegralTemplateArgumentValue(Sema &S, QualType OrigT, const llvm::APSInt &Int, SourceLocation Loc)
Construct a new expression that refers to the given integral template argument with the given source-...
static SourceRange findTemplateParameter(unsigned Depth, TypeLoc TL)
static NullPointerValueKind isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *Arg, Decl *Entity=nullptr)
Determine whether the given template argument is a null pointer value of the appropriate type.
static ExprResult formImmediatelyDeclaredConstraint(Sema &S, NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, SourceLocation LAngleLoc, SourceLocation RAngleLoc, QualType ConstrainedType, SourceLocation ParamNameLoc, ArgumentLocAppender Appender, SourceLocation EllipsisLoc)
static bool SubstDefaultTemplateArgument(Sema &SemaRef, TemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, TemplateTypeParmDecl *Param, ArrayRef< TemplateArgument > SugaredConverted, ArrayRef< TemplateArgument > CanonicalConverted, TemplateArgumentLoc &Output)
Substitute template arguments into the default template argument for the given template type paramete...
static bool CheckNonTypeTemplatePartialSpecializationArgs(Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param, const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument)
Subroutine of Sema::CheckTemplatePartialSpecializationArgs that checks non-type template partial spec...
static void StripImplicitInstantiation(NamedDecl *D, bool MinGW)
Strips various properties off an implicit instantiation that has just been explicitly specialized.
static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II, SourceRange &CondRange, Expr *&Cond)
Determine whether this failed name lookup should be treated as being disabled by a usage of std::enab...
static void DiagnoseTemplateParameterListArityMismatch(Sema &S, TemplateParameterList *New, TemplateParameterList *Old, Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc)
Diagnose a known arity mismatch when comparing template argument lists.
static bool isTemplateArgumentTemplateParameter(const TemplateArgument &Arg, unsigned Depth, unsigned Index)
static TemplateArgumentListInfo makeTemplateArgumentListInfo(Sema &S, TemplateIdAnnotation &TemplateId)
Convert the parser's template argument list representation into our form.
static bool CheckTemplateArgumentIsCompatibleWithParameter(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn, Expr *Arg, QualType ArgType)
Checks whether the given template argument is compatible with its template parameter.
static bool CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn, TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted)
Checks whether the given template argument is the address of an object or function according to C++ [...
static void collectConjunctionTerms(Expr *Clause, SmallVectorImpl< Expr * > &Terms)
Collect all of the separable terms in the given condition, which might be a conjunction.
static void checkMoreSpecializedThanPrimary(Sema &S, PartialSpecDecl *Partial)
static bool CheckTemplateArgumentPointerToMember(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *&ResultArg, TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted)
Checks whether the given template argument is a pointer to member constant according to C++ [temp....
static SourceLocation DiagLocForExplicitInstantiation(NamedDecl *D, SourceLocation PointOfInstantiation)
Compute the diagnostic location for an explicit instantiation.
static bool isEnableIfAliasTemplate(TypeAliasTemplateDecl *AliasTemplate)
Determine whether this alias template is "enable_if_t".
static bool DiagnoseUnexpandedParameterPacks(Sema &S, TemplateTemplateParmDecl *TTP)
Check for unexpanded parameter packs within the template parameters of a template template parameter,...
static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D, SourceLocation InstLoc, bool WasQualifiedName)
Check the scope of an explicit instantiation.
static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef, const ParsedTemplateArgument &Arg)
static bool isSameAsPrimaryTemplate(TemplateParameterList *Params, ArrayRef< TemplateArgument > Args)
static void checkTemplatePartialSpecialization(Sema &S, PartialSpecDecl *Partial)
static bool CheckExplicitInstantiation(Sema &S, NamedDecl *D, SourceLocation InstLoc, bool WasQualifiedName, TemplateSpecializationKind TSK)
Common checks for whether an explicit instantiation of D is valid.
static Expr * lookThroughRangesV3Condition(Preprocessor &PP, Expr *Cond)
static bool DiagnoseDefaultTemplateArgument(Sema &S, Sema::TemplateParamListContext TPC, SourceLocation ParamLoc, SourceRange DefArgRange)
Diagnose the presence of a default template argument on a template parameter, which is ill-formed in ...
static QualType checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD, ArrayRef< TemplateArgument > Converted, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
static void noteNonDeducibleParameters(Sema &S, TemplateParameterList *TemplateParams, const llvm::SmallBitVector &DeducibleParams)
static void completeMemberSpecializationImpl(Sema &S, DeclT *OrigD, SourceLocation Loc)
Complete the explicit specialization of a member of a class template by updating the instantiated mem...
static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc, TemplateDecl *TD, const TemplateParmDecl *D, TemplateArgumentListInfo &Args)
Diagnose a missing template argument.
static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, const Sema::TemplateCompareNewDeclInfo &NewInstFrom, NamedDecl *Old, const NamedDecl *OldInstFrom, bool Complain, Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc)
Match two template parameters within template parameter lists.
static void dllExportImportClassTemplateSpecialization(Sema &S, ClassTemplateSpecializationDecl *Def)
Make a dllexport or dllimport attr on a class template specialization take effect.
Defines the clang::SourceLocation class and associated facilities.
Defines utilities for dealing with stack allocation and stack space.
static const TemplateArgument & getArgument(const TemplateArgument &A)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
const LValueBase getLValueBase() const
APSInt & getComplexIntImag()
ValueKind getKind() const
APFixedPoint & getFixedPoint()
const ValueDecl * getMemberPointerDecl() const
APValue & getVectorElt(unsigned I)
unsigned getVectorLength() const
bool isMemberPointer() const
std::string getAsString(const ASTContext &Ctx, QualType Ty) const
@ Indeterminate
This object has an indeterminate value (C++ [basic.indet]).
@ None
There is no such object (it's outside its lifetime).
bool isNullPointer() const
APSInt & getComplexIntReal()
APFloat & getComplexFloatImag()
APFloat & getComplexFloatReal()
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
unsigned getIntWidth(QualType T) const
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, ArrayRef< TemplateArgumentLoc > Args) const
bool hasSimilarType(QualType T1, QualType T2)
Determine if two types are similar, according to the C++ rules.
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
DeclarationNameTable DeclarationNames
TemplateName getCanonicalTemplateName(const TemplateName &Name) const
Retrieves the "canonical" template name that refers to a given template.
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) 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.
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
const LangOptions & getLangOpts() const
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
QualType getCanonicalTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args) const
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
CanQualType UnresolvedTemplateTy
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
bool isSameEntity(const NamedDecl *X, const NamedDecl *Y) const
Determine whether the two declarations refer to the same entity.
TypeSourceInfo * getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc, const TemplateArgumentListInfo &Args, QualType Canon=QualType()) const
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS, const IdentifierInfo *Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template apply.
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
const TargetInfo & getTargetInfo() const
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
QualType getUnconstrainedType(QualType T) const
Remove any type constraints from a template parameter type, for equivalence comparison of template pa...
void setPrimaryMergedDecl(Decl *D, Decl *Primary)
TemplateName getAssumedTemplateName(DeclarationName Name) const
Retrieve a template name representing an unqualified-id that has been assumed to name a template for ...
Represents a constant array type that does not decay to a pointer when used as a function parameter.
A structure for storing the information associated with a name that has been assumed to be a template...
DeclarationName getDeclName() const
Get the name of the template.
Attr - This represents one attribute.
AutoTypeKeyword getAutoKeyword() const
const NestedNameSpecifierLoc getNestedNameSpecifierLoc() const
SourceLocation getRAngleLoc() const
ConceptDecl * getNamedConcept() const
SourceLocation getLAngleLoc() const
NamedDecl * getFoundDecl() const
DeclarationNameInfo getConceptNameInfo() const
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
bool isDecltypeAuto() const
A fixed int type of a specified bitwidth.
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
BuiltinTemplateKind getBuiltinTemplateKind() const
This class is used for builtin types like 'int'.
static CStyleCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *BasePath, FPOptionsOverride FPO, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R)
static CXXBoolLiteralExpr * Create(const ASTContext &C, bool Val, QualType Ty, SourceLocation Loc)
Represents a C++ member access expression where the actual member referenced could not be resolved be...
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents a static or instance method of a struct/union/class.
The null pointer literal (C++11 [lex.nullptr])
Represents a C++ struct/union/class.
CXXRecordDecl * getMostRecentDecl()
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
CXXRecordDecl * getDefinition() const
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 setDescribedClassTemplate(ClassTemplateDecl *Template)
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization,...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
CXXRecordDecl * getPreviousDecl()
Represents a C++ nested-name-specifier or a global scope specifier.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
char * location_data() const
Retrieve the data associated with the source-location information.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
SourceRange getRange() const
SourceLocation getBeginLoc() const
bool isSet() const
Deprecated.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
bool isEmpty() const
No scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Declaration of a class template.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a class template node.
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template.
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
static ClassTemplatePartialSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, QualType CanonInjectedType, ClassTemplatePartialSpecializationDecl *PrevDecl)
void setMemberSpecialization()
Note that this member template is a specialization.
Represents a class template specialization, which refers to a class template with a given set of temp...
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
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.
Complex values, per C99 6.2.5p11.
Declaration of a C++20 concept.
Expr * getConstraintExpr() const
bool isTypeConcept() const
static ConceptDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, Expr *ConstraintExpr)
ConceptDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
static ConceptReference * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten)
static ConceptSpecializationExpr * Create(const ASTContext &C, ConceptReference *ConceptRef, ImplicitConceptSpecializationDecl *SpecDecl, const ConstraintSatisfaction *Satisfaction)
const TypeClass * getTypePtr() const
Represents the canonical version of C arrays with a specified constant size.
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
Represents a concrete matrix type with constant number of rows and columns.
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
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 isTransparentContext() const
isTransparentContext - Determines whether this context is a "transparent" context,...
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const
Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...
bool isTranslationUnit() const
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.
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
bool isFunctionOrMethod() const
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
A reference to a declared variable, function, enum, etc.
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
Captures information about "declaration specifiers".
bool isVirtualSpecified() const
bool isNoreturnSpecified() const
SourceLocation getStorageClassSpecLoc() const
SCS getStorageClassSpec() const
SourceLocation getNoreturnSpecLoc() const
SourceLocation getExplicitSpecLoc() const
TSCS getThreadStorageClassSpec() const
bool isInlineSpecified() const
SourceLocation getThreadStorageClassSpecLoc() const
SourceLocation getVirtualSpecLoc() const
SourceLocation getConstexprSpecLoc() const
SourceLocation getInlineSpecLoc() const
bool hasExplicitSpecifier() const
bool hasConstexprSpecifier() const
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
bool isParameterPack() const
Whether this declaration is a parameter pack.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
@ FOK_None
Not a friend object.
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Module * getImportedOwningModule() const
Get the imported owning module, if this decl is from an imported (non-local) module.
static DeclContext * castToDeclContext(const Decl *)
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it's the object of a friend declaration.
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
bool isInvalidDecl() const
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack.
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
SourceLocation getBeginLoc() const LLVM_READONLY
void print(raw_ostream &Out, unsigned Indentation=0, bool PrintInstantiation=false) const
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
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.
The name of a declaration.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
std::string getAsString() const
Retrieve the human-readable string for this name.
void setTypeSourceInfo(TypeSourceInfo *TI)
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
Represents the type decltype(expr) (C++11).
Represents a C++17 deduced template specialization type.
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Represents an extended address space qualifier where the input address space value is dependent.
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Represents a qualified type name for which the type name is dependent.
A qualified reference to a name whose declaration cannot yet be resolved.
static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents an array type in C++ whose size is a value-dependent expression.
Represents an extended vector type where either the type or size is dependent.
Represents a matrix type where the type and the number of rows and columns is dependent on a template...
Represents a dependent template name that cannot be resolved prior to template instantiation.
bool isIdentifier() const
Determine whether this template name refers to an identifier.
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
unsigned getNumArgs() const
void setTemplateKeywordLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void setLAngleLoc(SourceLocation Loc)
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateNameLoc(SourceLocation Loc)
Represents a template specialization type whose template cannot be resolved, e.g.
Represents a vector type where either the type or size is dependent.
void setElaboratedKeywordLoc(SourceLocation Loc)
TypeLoc getNamedTypeLoc() const
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
RAII object that enters a new expression evaluation context.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
This represents one expression.
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
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 isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
@ NPC_NeverValueDependent
Specifies that the expression should never be value-dependent.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
ExtVectorType - Extended vector type.
Represents a member of a struct/union/class.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
static FixedPointLiteral * CreateFromRawInt(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l, unsigned Scale)
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
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, ArrayRef< TemplateParameterList * > FriendTypeTPLists=std::nullopt)
Represents a function declaration or definition.
ConstexprSpecKind getConstexprKind() const
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
SourceLocation getPointOfInstantiation() const
Retrieve the (first) point of instantiation of a function template specialization or a member of a cl...
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization,...
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isDeleted() const
Whether this function has been deleted.
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
void setDependentTemplateSpecialization(ASTContext &Context, const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo *TemplateArgs)
Specifies that this function declaration is actually a dependent function template specialization.
void setLateTemplateParsed(bool ILT=true)
State that this templated function will be late parsed.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization,...
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
Represents a prototype with parameter type info, e.g.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
ArrayRef< QualType > param_types() const
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Provides information about a function template specialization, which is a FunctionDecl that has been ...
bool isExplicitSpecialization() const
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this function template specialization.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
QualType getReturnType() const
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.
StringRef getName() const
Return the actual identifier string.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitConceptSpecializationDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation SL, ArrayRef< TemplateArgument > ConvertedArgs)
Represents a C array with an unspecified size.
const TypeClass * getTypePtr() const
Describes an C or C++ initializer list.
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init)
Create an initialization from an initializer (which, for direct initialization from a parenthesized l...
Describes the sequence of initializations required to initialize a given object or reference with a s...
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
Describes an entity that is being initialized.
static InitializedEntity InitializeTemplateParameter(QualType T, NonTypeTemplateParmDecl *Param)
Create the initialization entity for a template parameter.
Wrapper for source info for injected class names of class templates.
The injected class name of a C++ class template or class template partial specialization.
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'.
An lvalue reference type, per C++11 [dcl.ref].
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Represents a linkage specification.
A stack-allocated class that identifies which local variable declaration instantiations are present i...
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
A class for iterating through a result set and possibly filtering out results.
void erase()
Erase the last element returned from this iterator.
Represents the results of name lookup.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
@ NotFound
No entity found met the criteria.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
@ Found
Name lookup found a single declaration that met the criteria.
bool wasNotFoundInCurrentInstantiation() const
Determine whether no result was found because we could not search into dependent base classes of the ...
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
void setTemplateNameLookup(bool TemplateName)
Sets whether this is a template-name lookup.
DeclClass * getAsSingle() const
bool empty() const
Return true if no decls were found.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Filter makeFilter()
Create a filter for this result set.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
CXXRecordDecl * getNamingClass() const
Returns the 'naming class' for this lookup, i.e.
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
A pointer to member type per C++ 8.3.3 - Pointers to members.
QualType getPointeeType() const
Provides information a specialization of a member of a class template, which may be a member function...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
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.
void addOuterRetainedLevels(unsigned Num)
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
NamedDecl * getMostRecentDecl()
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined.
bool hasLinkage() const
Determine whether this declaration has linkage.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
SourceLocation getDefaultArgumentLoc() const
Retrieve the location of the default argument, if any.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
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)
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
unsigned getDepth() const
Get the nesting depth of the template parameter.
void setPlaceholderTypeConstraint(Expr *E)
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
Interfaces are the core concept in Objective-C for object oriented design.
Represents a pointer to an Objective C object.
Represents a class type in Objective C.
static OpaquePtr make(TemplateName P)
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
A structure for storing the information associated with an overloaded template name.
NamedDecl *const * iterator
Represents a C++11 pack expansion that produces a sequence of expressions.
Represents a pack expansion of types.
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
ParenExpr - This represents a parenthesized expression, e.g.
ParsedAttr - Represents a syntactic attribute.
Represents the parsed form of a C++ template argument.
KindType getKind() const
Determine what kind of template argument we have.
SourceLocation getLocation() const
Retrieve the location of the template argument.
ParsedTemplateTy getAsTemplate() const
Retrieve the template template argument's template name.
ParsedTemplateArgument getTemplatePackExpansion(SourceLocation EllipsisLoc) const
Retrieve a pack expansion of the given template template argument.
ParsedType getAsType() const
Retrieve the template type argument's type.
@ Type
A template type parameter, stored as a type.
@ Template
A template template argument, stored as a template name.
@ NonType
A non-type template parameter, stored as an expression.
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis that makes a template template argument into a pack expansion.
Expr * getAsExpr() const
Retrieve the non-type template argument's expression.
const CXXScopeSpec & getScopeSpec() const
Retrieve the nested-name-specifier that precedes the template name in a template template argument.
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
StringRef getImmediateMacroName(SourceLocation Loc)
Retrieve the name of the immediate macro expansion.
A (possibly-)qualified type.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
void * getAsOpaquePtr() const
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
The collection of all-type qualifiers we support.
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
void setObjCLifetime(ObjCLifetime type)
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this 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...
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
void setMemberSpecialization()
Note that this member template is a specialization.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
Scope - A scope is a transient data structure that is used while parsing the program.
unsigned getFlags() const
getFlags - Return the flags for this scope.
const Scope * getParent() const
getParent - Return the scope that this is nested in.
@ TemplateParamScope
This is a scope that corresponds to the template parameters of a C++ template.
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
void inheritTargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD)
Copies target attributes from the template TD to the function FD.
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...
Whether and why a template name is required in this lookup.
SourceLocation getTemplateKeywordLoc() const
bool hasTemplateKeyword() const
Abstract base class used for diagnosing integer constant expression violations.
Sema - This implements semantic analysis and AST building for C.
bool hasReachableDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a reachable definition.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
VarTemplateSpecializationDecl * BuildVarTemplateInstantiation(VarTemplateDecl *VarTemplate, VarDecl *FromVar, const TemplateArgumentList *PartialSpecArgs, const TemplateArgumentListInfo &TemplateArgsInfo, SmallVectorImpl< TemplateArgument > &Converted, SourceLocation PointOfInstantiation, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *StartingScope=nullptr)
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
DeclResult ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, SourceLocation ModulePrivateLoc, CXXScopeSpec &SS, TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr, MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody=nullptr)
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 isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false) const
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
LookupNameKind
Describes the kind of name lookup to perform.
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
ExprResult ActOnConstantExpression(ExprResult Res)
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
bool LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, RequiredTemplateKind RequiredTemplate=SourceLocation(), AssumedTemplateKind *ATK=nullptr, bool AllowTypoCorrection=true)
bool SetMemberAccessSpecifier(NamedDecl *MemberDecl, NamedDecl *PrevMemberDecl, AccessSpecifier LexicalAS)
SetMemberAccessSpecifier - Set the access specifier of a member.
bool BuildTypeConstraint(const CXXScopeSpec &SS, TemplateIdAnnotation *TypeConstraint, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc, bool AllowUnexpandedPack)
bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc, TemplateIdAnnotation *TemplateId, bool IsMemberSpecialization)
Diagnose a declaration whose declarator-id has the given nested-name-specifier.
TemplateParameterList * ActOnTemplateParameterList(unsigned Depth, SourceLocation ExportLoc, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
ActOnTemplateParameterList - Builds a TemplateParameterList, optionally constrained by RequiresClause...
TypeResult ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, const IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false, bool IsClassName=false, ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No)
NamedDecl * ActOnTemplateTemplateParameter(Scope *S, SourceLocation TmpLoc, TemplateParameterList *Params, bool Typename, SourceLocation EllipsisLoc, IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth, unsigned Position, SourceLocation EqualLoc, ParsedTemplateArgument DefaultArg)
ActOnTemplateTemplateParameter - Called when a C++ template template parameter (e....
bool ActOnTypeConstraint(const CXXScopeSpec &SS, TemplateIdAnnotation *TypeConstraint, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
bool hasVisibleDeclaration(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine whether any declaration of an entity is visible.
bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info)
DiagnoseClassNameShadow - Implement C++ [class.mem]p13: If T is the name of a class,...
void NoteAllFoundTemplates(TemplateName Name)
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...
TypeResult ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK, const CXXScopeSpec &SS, const IdentifierInfo *Name, SourceLocation TagLoc, SourceLocation NameLoc)
TemplateDecl * AdjustDeclIfTemplate(Decl *&Decl)
AdjustDeclIfTemplate - If the given decl happens to be a template, reset the parameter D to reference...
void InstantiateClassTemplateSpecializationMembers(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK)
Instantiate the definitions of all of the members of the given class template specialization,...
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.
TemplateArgumentLoc SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, Decl *Param, ArrayRef< TemplateArgument > SugaredConverted, ArrayRef< TemplateArgument > CanonicalConverted, bool &HasDefaultArg)
If the given template parameter has a default template argument, substitute into that default templat...
Decl * ActOnConceptDefinition(Scope *S, MultiTemplateParamsArg TemplateParameterLists, const IdentifierInfo *Name, SourceLocation NameLoc, Expr *ConstraintExpr, const ParsedAttributesView &Attrs)
ExprResult RebuildExprInCurrentInstantiation(Expr *E)
DeclResult ActOnVarTemplateSpecialization(Scope *S, Declarator &D, TypeSourceInfo *DI, LookupResult &Previous, SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams, StorageClass SC, bool IsPartialSpecialization)
ClassTemplatePartialSpecializationDecl * getMoreSpecializedPartialSpecialization(ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc)
Returns the more specialized class template partial specialization according to the rules of partial ...
FunctionDecl * getMoreConstrainedFunction(FunctionDecl *FD1, FunctionDecl *FD2)
Returns the more constrained function according to the rules of partial ordering by constraints (C++ ...
void referenceDLLExportedClassMethods()
static NamedDecl * getAsTemplateNameDecl(NamedDecl *D, bool AllowFunctionTemplates=true, bool AllowDependent=true)
Try to interpret the lookup result D as a template-name.
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
TemplateParameterList * MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, ArrayRef< TemplateParameterList * > ParamLists, bool IsFriend, bool &IsMemberSpecialization, bool &Invalid, bool SuppressDiagnostic=false)
Match the given template parameter lists to the given scope specifier, returning the template paramet...
void AddAlignmentAttributesForRecord(RecordDecl *RD)
AddAlignmentAttributesForRecord - Adds any needed alignment attributes to a the record decl,...
bool RequireStructuralType(QualType T, SourceLocation Loc)
Require the given type to be a structural type, and diagnose if it is not.
ExprResult EvaluateConvertedConstantExpression(Expr *E, QualType T, APValue &Value, CCEKind CCE, bool RequireInt, const APValue &PreNarrowingValue)
EvaluateConvertedConstantExpression - Evaluate an Expression That is a converted constant expression ...
FPOptionsOverride CurFPFeatureOverrides()
ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, bool isAddressOfOperand, const TemplateArgumentListInfo *TemplateArgs)
ActOnDependentIdExpression - Handle a dependent id-expression that was just parsed.
bool hasVisibleExplicitSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a visible declaration of D that is an explicit specialization declaration for a...
bool IsInsideALocalClassWithinATemplateFunction()
Decl * ActOnTemplateDeclarator(Scope *S, MultiTemplateParamsArg TemplateParameterLists, Declarator &D)
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Look up a name, looking for a single declaration.
LateParsedTemplateMapT LateParsedTemplateMap
void UnmarkAsLateParsedTemplate(FunctionDecl *FD)
CheckTemplateArgumentKind
Specifies the context in which a particular template argument is being checked.
@ CTAK_Specified
The template argument was specified in the code or was instantiated with some deduced template argume...
@ CTAK_Deduced
The template argument was deduced via template argument deduction.
void CheckTemplatePartialSpecialization(ClassTemplatePartialSpecializationDecl *Partial)
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization, bool Disambiguation=false)
ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType)
Convert a parsed type into a parsed template argument.
bool DiagnoseUnknownTemplateName(const IdentifierInfo &II, SourceLocation IILoc, Scope *S, const CXXScopeSpec *SS, TemplateTy &SuggestedTemplate, TemplateNameKind &SuggestedKind)
bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)
IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...
bool ConstraintExpressionDependsOnEnclosingTemplate(const FunctionDecl *Friend, unsigned TemplateDepth, const Expr *Constraint)
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...
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
DiagnosticsEngine & getDiagnostics() const
ExprResult BuildExpressionFromNonTypeTemplateArgument(const TemplateArgument &Arg, SourceLocation Loc)
void propagateDLLAttrToBaseClassTemplate(CXXRecordDecl *Class, Attr *ClassAttr, ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc)
Perform propagation of DLL attributes from a derived class to a templated base class for MS compatibi...
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over....
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
void checkSpecializationReachability(SourceLocation Loc, NamedDecl *Spec)
bool hasVisibleDefaultArgument(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if the template parameter D has a visible default argument.
ASTContext & getASTContext() const
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
UnresolvedSetIterator getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd, TemplateSpecCandidateSet &FailedCandidates, SourceLocation Loc, const PartialDiagnostic &NoneDiag, const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag, bool Complain=true, QualType TargetType=QualType())
Retrieve the most specialized of the given function template specializations.
bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
IsIntegralPromotion - Determines whether the conversion from the expression From (whose potentially-a...
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.
bool IsRedefinitionInModule(const NamedDecl *New, const NamedDecl *Old) const
Check the redefinition in C++20 Modules.
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param, TemplateParameterList *Params, TemplateArgumentLoc &Arg, bool IsDeduced)
Check a template argument against its corresponding template template parameter.
TemplateParameterList * GetTemplateParameterList(TemplateDecl *TD)
Returns the template parameter list with all default template argument information.
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 MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD, CachedTokens &Toks)
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)
Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
bool isTemplateTemplateParameterAtLeastAsSpecializedAs(TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc, bool IsDeduced)
TemplateParameterListEqualKind
Enumeration describing how template parameter lists are compared for equality.
@ TPL_TemplateTemplateParmMatch
We are matching the template parameter lists of two template template parameters as part of matching ...
@ TPL_TemplateTemplateArgumentMatch
We are matching the template parameter lists of a template template argument against the template par...
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
@ TPL_TemplateParamsEquivalent
We are determining whether the template-parameters are equivalent according to C++ [temp....
NamedDecl * ActOnTypeParameter(Scope *S, bool Typename, SourceLocation EllipsisLoc, SourceLocation KeyLoc, IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth, unsigned Position, SourceLocation EqualLoc, ParsedType DefaultArg, bool HasTypeConstraint)
ActOnTypeParameter - Called when a C++ template type parameter (e.g., "typename T") has been parsed.
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend=false)
Perform semantic analysis for the given function template specialization.
@ FoundFunctions
This is assumed to be a template name because lookup found one or more functions (but no function tem...
@ None
This is not assumed to be a template name.
@ FoundNothing
This is assumed to be a template name because lookup found nothing.
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true)
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
ArrayRef< InventedTemplateParameterInfo > getInventedParameterInfos() const
void inferGslOwnerPointerAttribute(CXXRecordDecl *Record)
Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
FPOptions & getCurFPFeatures()
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template, const MultiLevelTemplateArgumentList &TemplateArgs, SourceRange TemplateIDRange)
Ensure that the given template arguments satisfy the constraints associated with the given template,...
@ UPPC_PartialSpecialization
Partial specialization.
@ UPPC_DefaultArgument
A default argument.
@ UPPC_ExplicitSpecialization
Explicit specialization.
@ UPPC_NonTypeTemplateParameterType
The type of a non-type template parameter.
@ UPPC_TypeConstraint
A type constraint.
const LangOptions & getLangOpts() const
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl, bool SupportedForCompatibility=false)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter 'PrevD...
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
bool RebuildTemplateParamsInCurrentInstantiation(TemplateParameterList *Params)
Rebuild the template parameters now that we know we're in a current instantiation.
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, QualType ObjectType, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee, SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, std::optional< unsigned > NumExpansions)
bool isPotentialImplicitMemberAccess(const CXXScopeSpec &SS, LookupResult &R, bool IsAddressOfOperand)
Check whether an expression might be an implicit class member access.
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool hasVisibleMemberSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a visible declaration of D that is a member specialization declaration (as oppo...
void checkClassLevelDLLAttribute(CXXRecordDecl *Class)
Check class-level dllimport/dllexport attribute.
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
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 ...
std::pair< Expr *, std::string > findFailedBooleanCondition(Expr *Cond)
Find the failed Boolean condition within a given Boolean constant expression, and describe it with a ...
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, bool UpdateArgsWithConversions=true, bool *ConstraintsNotSatisfied=nullptr, bool PartialOrderingTTP=false)
Check that the given template arguments can be provided to the given template, converting the argumen...
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
bool hasAnyAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true, bool AllowNonTemplateFunctions=false)
ExprResult BuildConvertedConstantExpression(Expr *From, QualType T, CCEKind CCE, NamedDecl *Dest=nullptr)
bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD, const TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous)
Perform semantic analysis for the given dependent function template specialization.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
bool hasExplicitCallingConv(QualType T)
NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK)
Given a non-tag type declaration, returns an enum useful for indicating what kind of non-tag type thi...
bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, TemplateArgumentLoc &Arg, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted)
bool AreConstraintExpressionsEqual(const NamedDecl *Old, const Expr *OldConstr, const TemplateCompareNewDeclInfo &New, const Expr *NewConstr)
void AddPushedVisibilityAttribute(Decl *RD)
AddPushedVisibilityAttribute - If '#pragma GCC visibility' was used, add an appropriate visibility at...
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1, ArrayRef< const Expr * > AC1, NamedDecl *D2, ArrayRef< const Expr * > AC2)
If D1 was not at least as constrained as D2, but would've been if a pair of atomic constraints involv...
ExprResult DefaultLvalueConversion(Expr *E)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
void NoteOverloadCandidate(const NamedDecl *Found, const FunctionDecl *Fn, OverloadCandidateRewriteKind RewriteKind=OverloadCandidateRewriteKind(), QualType DestType=QualType(), bool TakingAddress=false)
bool hasReachableDefaultArgument(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if the template parameter D has a reachable default argument.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
TypeSourceInfo * RebuildTypeInCurrentInstantiation(TypeSourceInfo *T, SourceLocation Loc, DeclarationName Name)
Rebuilds a type within the context of the current instantiation.
void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)
Check whether the given function decl's trailing requires clause is satisfied, if any.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
void notePreviousDefinition(const NamedDecl *Old, SourceLocation New)
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...
bool CheckTypeConstraint(TemplateIdAnnotation *TypeConstraint)
TemplateNameKind ActOnTemplateName(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool AllowInjectedClassName=false)
Form a template name from a name that is syntactically required to name a template,...
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName, SourceLocation Less, SourceLocation Greater)
ExprResult FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
DeclResult CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation TemplateNameLoc, const TemplateArgumentListInfo &TemplateArgs)
Get the specialization of the given variable template corresponding to the specified argument list,...
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
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)
void diagnoseMissingImport(SourceLocation Loc, const NamedDecl *Decl, MissingImportKind MIK, bool Recover=true)
Diagnose that the specified declaration needs to be visible but isn't, and suggest a module import th...
void FilterAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true)
TypeSourceInfo * SubstAutoTypeSourceInfoDependent(TypeSourceInfo *TypeWithAuto)
bool IsAtLeastAsConstrained(NamedDecl *D1, MutableArrayRef< const Expr * > AC1, NamedDecl *D2, MutableArrayRef< const Expr * > AC2, bool &Result)
Check whether the given declaration's associated constraints are at least as constrained than another...
bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams)
Check whether a template can be declared within this scope.
void AddMsStructLayoutForRecord(RecordDecl *RD)
AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
TemplateParameterList * SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs, bool EvaluateConstraints=true)
SourceLocation getTopMostPointOfInstantiation(const NamedDecl *) const
Returns the top most location responsible for the definition of N.
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg, SourceLocation EllipsisLoc)
Invoked when parsing a template argument followed by an ellipsis, which creates a pack expansion.
void ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &Name, TemplateNameKind &TNK, SourceLocation NameLoc, IdentifierInfo *&II)
Try to resolve an undeclared template name as a type template.
bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
Perform semantic analysis for the given non-template member specialization.
TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc, ImplicitTypenameContext IsImplicitTypename=ImplicitTypenameContext::No)
Called when the parser has parsed a C++ typename specifier, e.g., "typename T::type".
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)
Instantiate the definition of a class from a given pattern.
bool hasReachableMemberSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a reachable declaration of D that is a member specialization declaration (as op...
RedeclarationKind forRedeclarationInCurContext() const
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
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.
@ CCEK_TemplateArg
Value of a non-type template parameter.
void InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
void MarkUnusedFileScopedDecl(const DeclaratorDecl *D)
If it's a file scoped decl that must warn if not used, keep track of it.
ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, bool IsAddressOfOperand)
void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used)
Mark which template parameters are used in a given expression.
DeclResult ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy Template, SourceLocation TemplateNameLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, const ParsedAttributesView &Attr)
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
QualType BuildDecltypeType(Expr *E, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
DeclResult ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, OffsetOfKind OOK, SkipBodyInfo *SkipBody=nullptr)
This is invoked when we see 'struct foo' or 'struct {'.
bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, CheckTemplateArgumentKind CTAK)
Check that the given template argument corresponds to the given template parameter.
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.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
void makeMergedDefinitionVisible(NamedDecl *ND)
Make a merged definition of an existing hidden definition ND visible at the specified location.
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
bool hasReachableExplicitSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a reachable declaration of D that is an explicit specialization declaration for...
bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name, SourceLocation NameLoc, CXXScopeSpec &SS, ParsedTemplateTy *Template=nullptr)
Determine whether a particular identifier might be the name in a C++1z deduction-guide declaration.
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
NamedDecl * ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, unsigned Depth, unsigned Position, SourceLocation EqualLoc, Expr *DefaultArg)
void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc)
void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D)
Common checks for a parameter-declaration that should apply to both function parameters and non-type ...
TemplateParamListContext
The context in which we are checking a template parameter list.
@ TPC_FriendFunctionTemplate
@ TPC_ClassTemplateMember
@ TPC_FriendClassTemplate
@ TPC_FriendFunctionTemplateDefinition
void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We've found a use of a templated declaration that would trigger an implicit instantiation.
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.
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, ArrayRef< TemplateArgument > TemplateArgs, sema::TemplateDeductionInfo &Info)
bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name, SourceLocation NameLoc, bool Diagnose=true)
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope.
ExprResult CheckConceptTemplateId(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const TemplateArgumentListInfo *TemplateArgs)
sema::LambdaScopeInfo * getEnclosingLambda() const
Get the innermost lambda enclosing the current location, if any.
void CheckConceptRedefinition(ConceptDecl *NewDecl, LookupResult &Previous, bool &AddToScope)
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
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...
bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T, sema::TemplateDeductionInfo &Info)
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 ProcessAPINotes(Decl *D)
Map any API notes provided for this declaration to attributes on the declaration.
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments.
bool CheckRedeclarationInModule(NamedDecl *New, NamedDecl *Old)
A wrapper function for checking the semantic restrictions of a redeclaration within a module.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
unsigned getTemplateDepth(Scope *S) const
Determine the number of levels of enclosing template parameters.
ExprResult BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, QualType ParamType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Given a non-type template argument that refers to a declaration and the type of its corresponding non...
TemplateDeductionResult DeduceAutoType(TypeLoc AutoTypeLoc, Expr *Initializer, QualType &Result, sema::TemplateDeductionInfo &Info, bool DependentDeduction=false, bool IgnoreConstraints=false, TemplateSpecCandidateSet *FailedTSC=nullptr)
Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, bool AdjustExceptionSpec=false)
Adjust the type ArgFunctionType to match the calling convention, noreturn, and optionally the excepti...
void NoteTemplateParameterLocation(const NamedDecl &Decl)
IdentifierResolver IdResolver
ArrayRef< sema::FunctionScopeInfo * > getFunctionScopes() const
void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD)
bool IsFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy)
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
TypeResult ActOnTagTemplateIdType(TagUseKind TUK, TypeSpecifierType TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy TemplateD, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc)
Parsed an elaborated-type-specifier that refers to a template-id, such as class T::template apply.
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)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
bool hasReachableDeclaration(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine whether any declaration of an entity is reachable.
void MarkDeducedTemplateParameters(const FunctionTemplateDecl *FunctionTemplate, llvm::SmallBitVector &Deduced)
bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc, UnexpandedParameterPackContext UPPC, ArrayRef< UnexpandedParameterPack > Unexpanded)
Diagnose unexpanded parameter packs.
void warnOnReservedIdentifier(const NamedDecl *D)
void inferNullableClassAttribute(CXXRecordDecl *CRD)
Add _Nullable attributes for std:: types.
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Represents the result of substituting a set of types for a template type parameter pack.
Represents the result of substituting a type for a template type parameter.
Represents the declaration of a struct/union/class/enum.
StringRef getKindName() const
void startDefinition()
Starts the definition of this tag declaration.
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
TagKind getTagKind() const
bool isBeingDefined() const
Determines whether this type is in the process of being defined.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
A convenient class for passing around template argument information.
SourceLocation getRAngleLoc() const
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void addArgument(const TemplateArgumentLoc &Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
SourceLocation getLAngleLoc() const
A template argument list.
const TemplateArgument * data() const
Retrieve a pointer to the 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.
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Location wrapper for a TemplateArgument.
SourceLocation getLocation() const
SourceLocation getTemplateEllipsisLoc() const
const TemplateArgument & getArgument() const
SourceLocation getTemplateNameLoc() const
TypeSourceInfo * getTypeSourceInfo() const
SourceRange getSourceRange() const LLVM_READONLY
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Expr * getSourceExpression() const
Represents a template argument.
QualType getStructuralValueType() const
Get the type of a StructuralValue.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
bool isDependent() const
Whether this template argument is dependent on a template parameter such that its result can change f...
bool isInstantiationDependent() const
Whether this template argument is dependent on a template parameter.
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
QualType getNonTypeTemplateArgumentType() const
If this is a non-type template argument, get its type.
QualType getAsType() const
Retrieve the type for a type template argument.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
static TemplateArgument CreatePackCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument pack by copying the given set of template arguments.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
bool isNull() const
Determine whether this template argument has no value.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
void print(const PrintingPolicy &Policy, raw_ostream &Out, bool IncludeType) const
Print this template argument to the given output stream.
QualType getIntegralType() const
Retrieve the type of the integral value.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion,...
const APValue & getAsStructuralValue() const
Get the value of a StructuralValue.
The base class of all kinds of template declarations (e.g., class, function, etc.).
bool hasAssociatedConstraints() const
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr * > &AC) const
Get the total constraint-expression associated with this template, including constraint-expressions d...
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.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
AssumedTemplateStorage * getAsAssumedTemplateName() const
Retrieve information on a name that has been assumed to be a template-name in order to permit a call ...
UsingShadowDecl * getAsUsingShadowDecl() const
Retrieve the using shadow declaration through which the underlying template declaration is introduced...
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
SourceRange getSourceRange() const LLVM_READONLY
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
bool hasAssociatedConstraints() const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
NamedDecl *const * const_iterator
Iterates through the template parameters in this list.
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr * > &AC) const
All associated constraints derived from this template parameter list, including the requires clause a...
static bool shouldIncludeTypeForArgument(const PrintingPolicy &Policy, const TemplateParameterList *TPL, unsigned Idx)
SourceLocation getTemplateLoc() const
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
void NoteCandidates(Sema &S, SourceLocation Loc)
NoteCandidates - When no template specialization match is found, prints diagnostic messages containin...
SourceLocation getLocation() const
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set.
unsigned getNumArgs() const
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateKeywordLoc(SourceLocation Loc)
TemplateArgumentLoc getArgLoc(unsigned i) const
void setTemplateNameLoc(SourceLocation Loc)
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
Represents a type template specialization; the template must be a class template, a type alias templa...
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
static bool anyDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, ArrayRef< TemplateArgument > Converted)
Determine whether any of the given template arguments are dependent.
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
TemplateParameterList * getExpansionTemplateParameters(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
void setInheritedDefaultArgument(const ASTContext &C, TemplateTemplateParmDecl *Prev)
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
unsigned getDepth() const
Get the nesting depth of the template parameter.
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, bool Typename, TemplateParameterList *Params)
void removeDefaultArgument()
Removes the default argument of this template parameter.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Declaration of a template type parameter.
SourceLocation getDefaultArgumentLoc() const
Retrieves the location of the default argument declaration.
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
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)
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool isParameterPack() const
Returns whether this is a parameter pack.
unsigned getDepth() const
Retrieve the depth of the template parameter.
void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint)
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter.
Wrapper for template type parameters.
TemplateTypeParmDecl * getDecl() const
unsigned getIndex() const
unsigned getDepth() const
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Declaration of an alias template.
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
Represents a declaration of a type.
const Type * getTypeForDecl() const
SourceLocation getBeginLoc() const LLVM_READONLY
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
Base wrapper for a particular "section" of type source info.
QualType getType() const
Get the type for which this source info wrapper provides information.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
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 ...
SourceLocation getBeginLoc() const
Get the begin source location.
Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expre...
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
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.
A reasonable base class for TypeLocs that correspond to types that are written as a type-specifier.
SourceLocation getNameLoc() const
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
The base class of the type hierarchy.
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBooleanType() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
bool isRValueReferenceType() const
bool isVoidPointerType() const
bool isPointerType() const
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isScalarType() const
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
const Type * getArrayElementTypeNoTypeQual() const
If this is an array type, return the element type of the array, potentially with type qualifiers miss...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
bool isObjCObjectOrInterfaceType() 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 isBitIntType() const
bool isStructuralType() const
Determine if this type is a structural type, per C++20 [temp.param]p7.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isChar16Type() const
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
QualType getCanonicalTypeInternal() const
bool isMemberPointerType() const
bool isChar32Type() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool hasUnnamedOrLocalType() const
Whether this type is or contains a local or unnamed type.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isVectorType() const
bool isWideCharType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isNullPtrType() const
bool isRecordType() const
QualType getUnderlyingType() const
Simple class containing the result of Sema::CorrectTypo.
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
DeclClass * getCorrectionDeclAs() const
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represents a C++ unqualified-id that has been parsed.
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent)
void addDecl(NamedDecl *D)
The iterator over UnresolvedSets.
A set of unresolved declarations.
Represents the dependent type named by a dependently-scoped typename using declaration,...
Represents a dependent using declaration which was not marked with typename.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
Represents a variable declaration or definition.
TLSKind getTLSKind() const
bool isStaticDataMember() const
Determines whether this is a static data member.
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization,...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template,...
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
Declaration of a variable template.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > & getPartialSpecializations() const
Retrieve the set of partial specializations of this class template.
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
static VarTemplatePartialSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
void setMemberSpecialization()
Note that this member template is a specialization.
VarTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member variable template partial specialization from which this particular variable temp...
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.
static VarTemplateSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
Represents a C array with a specified size that is not an integer-constant-expression.
Represents a GCC generic vector type.
Retains information about a function, method, or block that is currently being parsed.
Provides information about an attempted template argument deduction, whose success or failure was des...
TemplateArgumentList * takeCanonical()
bool hasSFINAEDiagnostic() const
Is a SFINAE diagnostic available?
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
Defines the clang::TargetInfo interface.
The JSON file list parser is used to communicate input to InstallAPI.
TypeSpecifierType
Specifies the kind of type.
bool isa(CodeGen::Address addr)
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
@ IK_OperatorFunctionId
An overloaded operator name, e.g., operator+.
StorageClass
Storage classes.
@ CRK_None
Candidate is not a rewritten candidate.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
@ Result
The result type of a method or function.
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
ActionResult< Expr * > ExprResult
TagTypeKind
The kind of a tag type.
@ Enum
The "enum" keyword.
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema's representation of template deduction information to the form used in overload-can...
@ BTK__type_pack_element
This names the __type_pack_element BuiltinTemplateDecl.
@ BTK__make_integer_seq
This names the __make_integer_seq BuiltinTemplateDecl.
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
CastKind
CastKind - The kind of operation required for a conversion.
std::optional< unsigned > getExpandedPackSize(const NamedDecl *Param)
Check whether the template parameter is a pack expansion, and if so, determine the number of paramete...
SourceRange getTemplateParamsRange(TemplateParameterList const *const *Params, unsigned NumParams)
Retrieves the range of the given template parameter lists.
bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg, const NamedDecl *Param, ArrayRef< TemplateArgument > Args, unsigned Depth)
Make a best-effort determination of whether the type T can be produced by substituting Args into the ...
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
@ TNK_Var_template
The name refers to a variable template whose specialization produces a variable.
@ TNK_Type_template
The name refers to a template whose specialization produces a type.
@ TNK_Dependent_template_name
The name refers to a dependent template name:
@ TNK_Function_template
The name refers to a function template or a set of overloaded functions that includes at least one fu...
@ TNK_Concept_template
The name refers to a concept.
@ TNK_Non_template
The name does not refer to a template.
@ TNK_Undeclared_template
Lookup for the name failed, but we're assuming it was a template name anyway.
ActionResult< ParsedType > TypeResult
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
const FunctionProtoType * T
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
TemplateDeductionResult
Describes the result of template argument deduction.
@ ConstraintsNotSatisfied
The deduced arguments did not satisfy the constraints associated with the template.
@ CUDATargetMismatch
CUDA Target attributes do not match.
@ Success
Template argument deduction was successful.
@ AlreadyDiagnosed
Some error which was already diagnosed.
ActionResult< Decl * > DeclResult
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,...
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ None
No keyword precedes the qualified type name.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
@ Parens
New-expression has a C++98 paren-delimited initializer.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
SourceLocation getEndLoc() const LLVM_READONLY
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
bool HasSideEffects
Whether the evaluated expression has side effects.
Extra information about a function prototype.
Describes how types, statements, expressions, and declarations should be printed.
unsigned PrintCanonicalTypes
Whether to print types as written or canonically.
unsigned TerseOutput
Provide a 'terse' output.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
@ BuildingDeductionGuides
We are building deduction guides for a class.
A stack object to be created when performing template instantiation.
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
Location information for a TemplateArgument.
Information about a template-id annotation token.
const IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
unsigned NumArgs
NumArgs - The number of template arguments.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info)
Contains all information for a given match.