58#include "llvm/ADT/STLForwardCompat.h"
59#include "llvm/ADT/SmallString.h"
60#include "llvm/ADT/StringExtras.h"
61#include "llvm/TargetParser/Triple.h"
66#include <unordered_map>
73 Decl *Group[2] = { OwnedType, Ptr };
84 TypeNameValidatorCCC(
bool AllowInvalid,
bool WantClass =
false,
85 bool AllowTemplates =
false,
86 bool AllowNonTemplates =
true)
87 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
88 AllowTemplates(AllowTemplates), AllowNonTemplates(AllowNonTemplates) {
89 WantExpressionKeywords =
false;
90 WantCXXNamedCasts =
false;
91 WantRemainingKeywords =
false;
96 if (!AllowInvalidDecl && ND->isInvalidDecl())
100 return AllowTemplates;
102 bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
106 if (AllowNonTemplates)
111 if (AllowTemplates) {
112 auto *RD = dyn_cast<CXXRecordDecl>(ND);
113 if (!RD || !RD->isInjectedClassName())
115 RD = cast<CXXRecordDecl>(RD->getDeclContext());
116 return RD->getDescribedClassTemplate() ||
117 isa<ClassTemplateSpecializationDecl>(RD);
123 return !WantClassName && candidate.
isKeyword();
126 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
127 return std::make_unique<TypeNameValidatorCCC>(*
this);
131 bool AllowInvalidDecl;
134 bool AllowNonTemplates;
140enum class UnqualifiedTypeNameLookupResult {
151static UnqualifiedTypeNameLookupResult
156 return UnqualifiedTypeNameLookupResult::NotFound;
158 UnqualifiedTypeNameLookupResult FoundTypeDecl =
159 UnqualifiedTypeNameLookupResult::NotFound;
162 if (
auto *BaseTT =
Base.getType()->getAs<
TagType>())
163 BaseRD = BaseTT->getAsCXXRecordDecl();
167 if (!TST || !TST->isDependentType())
169 auto *TD = TST->getTemplateName().getAsTemplateDecl();
172 if (
auto *BasePrimaryTemplate =
173 dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) {
175 BaseRD = BasePrimaryTemplate;
176 else if (
auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
178 CTD->findPartialSpecialization(
Base.getType()))
186 if (!isa<TypeDecl>(ND))
187 return UnqualifiedTypeNameLookupResult::FoundNonType;
188 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
190 if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
192 case UnqualifiedTypeNameLookupResult::FoundNonType:
193 return UnqualifiedTypeNameLookupResult::FoundNonType;
194 case UnqualifiedTypeNameLookupResult::FoundType:
195 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
197 case UnqualifiedTypeNameLookupResult::NotFound:
204 return FoundTypeDecl;
212 UnqualifiedTypeNameLookupResult FoundTypeDecl =
213 UnqualifiedTypeNameLookupResult::NotFound;
215 DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
219 RD = dyn_cast<CXXRecordDecl>(DC);
223 if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
229 S.
Diag(NameLoc, diag::ext_found_in_dependent_base) << &II;
251 bool WantNontrivialTypeSourceInfo =
true) {
253 case Type::DeducedTemplateSpecialization:
255 case Type::InjectedClassName:
258 case Type::UnresolvedUsing:
263 case Type::ObjCInterface:
264 case Type::ObjCTypeParam:
265 case Type::TemplateTypeParm:
268 llvm_unreachable(
"Unexpected Type Class");
276 if (!WantNontrivialTypeSourceInfo)
280 Builder.pushTypeSpec(
T).setNameLoc(NameLoc);
289 bool HasTrailingDot,
ParsedType ObjectTypePtr,
290 bool IsCtorOrDtorName,
291 bool WantNontrivialTypeSourceInfo,
292 bool IsClassTemplateDeductionContext,
296 bool AllowDeducedTemplate = IsClassTemplateDeductionContext &&
298 !isClassName && !HasTrailingDot;
323 !isClassName && !IsCtorOrDtorName)
325 bool IsImplicitTypename = !isClassName && !IsCtorOrDtorName;
326 if (IsImplicitTypename) {
329 Diag(QualifiedLoc, diag::warn_cxx17_compat_implicit_typename);
331 Diag(QualifiedLoc, diag::ext_implicit_typename)
338 if (WantNontrivialTypeSourceInfo)
371 if (ObjectTypePtr &&
Result.empty()) {
395 switch (
Result.getResultKind()) {
398 TypeNameValidatorCCC CCC(
true, isClassName,
399 AllowDeducedTemplate);
404 bool MemberOfUnknownSpecialization;
413 if (Correction && (NNS || NewII != &II) &&
419 Template, MemberOfUnknownSpecialization))) {
421 isClassName, HasTrailingDot, ObjectTypePtr,
423 WantNontrivialTypeSourceInfo,
424 IsClassTemplateDeductionContext);
427 PDiag(diag::err_unknown_type_or_class_name_suggest)
428 <<
Result.getLookupName() << isClassName);
431 *CorrectedII = NewII;
436 Result.suppressDiagnostics();
452 Result.suppressDiagnostics();
462 Result.suppressDiagnostics();
468 Res != ResEnd; ++Res) {
470 if (isa<TypeDecl, ObjCInterfaceDecl, UnresolvedUsingIfExistsDecl>(
477 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*Res);
489 Result.suppressDiagnostics();
500 IIDecl =
Result.getFoundDecl();
501 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*
Result.begin());
505 assert(IIDecl &&
"Didn't find decl");
508 if (
TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
512 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
513 auto *FoundRD = dyn_cast<CXXRecordDecl>(TD);
514 if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD &&
515 FoundRD->isInjectedClassName() &&
517 Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor)
528 FoundUsingShadow =
nullptr;
529 }
else if (
auto *UD = dyn_cast<UnresolvedUsingIfExistsDecl>(IIDecl)) {
533 }
else if (AllowDeducedTemplate) {
535 assert(!FoundUsingShadow || FoundUsingShadow->
getTargetDecl() == TD);
542 FoundUsingShadow =
nullptr;
548 Result.suppressDiagnostics();
552 if (FoundUsingShadow)
555 return buildNamedType(*
this, SS,
T, NameLoc, WantNontrivialTypeSourceInfo);
563 auto *ND = dyn_cast<NamespaceDecl>(DC);
564 if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
566 else if (
auto *RD = dyn_cast<CXXRecordDecl>(DC))
568 RD->getTypeForDecl());
569 else if (isa<TranslationUnitDecl>(DC))
572 llvm_unreachable(
"something isn't in TU scope?");
583 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
584 if (MD->getParent()->hasAnyDependentBases())
592 bool IsTemplateTypeArg) {
593 assert(
getLangOpts().MSVCCompat &&
"shouldn't be called in non-MSVC mode");
596 if (IsTemplateTypeArg &&
getCurScope()->isTemplateParamScope()) {
605 Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
611 RD->getTypeForDecl());
615 Diag(NameLoc, diag::ext_undeclared_unqual_id_with_dependent_base) << &II
646 switch (TD->getTagKind()) {
674 return S->isFunctionPrototypeScope();
684 bool IsTemplateName) {
689 SuggestedType =
nullptr;
693 TypeNameValidatorCCC CCC(
false,
false,
700 bool CanRecover = !IsTemplateName;
701 if (Corrected.isKeyword()) {
704 PDiag(IsTemplateName ? diag::err_no_template_suggest
705 : diag::err_unknown_typename_suggest)
707 II = Corrected.getCorrectionAsIdentifierInfo();
710 if (!SS || !SS->
isSet()) {
712 PDiag(IsTemplateName ? diag::err_no_template_suggest
713 : diag::err_unknown_typename_suggest)
716 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
717 bool DroppedSpecifier =
718 Corrected.WillReplaceSpecifier() && II->
getName() == CorrectedStr;
721 ? diag::err_no_member_template_suggest
722 : diag::err_unknown_nested_typename_suggest)
723 << II << DC << DroppedSpecifier << SS->
getRange(),
726 llvm_unreachable(
"could not have corrected a typo here");
733 if (Corrected.getCorrectionSpecifier())
738 getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), IILoc, S,
739 tmpSS.
isSet() ? &tmpSS : SS,
false,
false,
nullptr,
749 Name.setIdentifier(II, IILoc);
752 bool MemberOfUnknownSpecialization;
754 Name,
nullptr,
true, TemplateResult,
765 Diag(IILoc, IsTemplateName ? diag::err_no_template
766 : diag::err_unknown_typename)
769 Diag(IILoc, IsTemplateName ? diag::err_no_member_template
770 : diag::err_typename_nested_not_found)
776 unsigned DiagID = diag::err_typename_missing;
778 DiagID = diag::ext_typename_missing;
785 *SS, *II, IILoc).
get();
788 "Invalid scope specifier has already been diagnosed");
796 NextToken.
is(tok::less);
799 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
802 if (CheckTemplate && isa<TemplateDecl>(*I))
816 StringRef FixItTagName;
817 switch (Tag->getTagKind()) {
819 FixItTagName =
"class ";
823 FixItTagName =
"enum ";
827 FixItTagName =
"struct ";
831 FixItTagName =
"__interface ";
835 FixItTagName =
"union ";
839 StringRef TagName = FixItTagName.drop_back();
840 SemaRef.
Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
841 << Name << TagName << SemaRef.
getLangOpts().CPlusPlus
846 SemaRef.
Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
861 const Token &NextToken,
866 assert(NextToken.
isNot(tok::coloncolon) &&
867 "parse nested name specifiers before calling ClassifyName");
908 bool SecondTry =
false;
909 bool IsFilteredTemplateName =
false;
912 switch (
Result.getResultKind()) {
916 if (SS.
isEmpty() && NextToken.
is(tok::l_paren)) {
962 if (!SecondTry && CCC) {
967 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
968 unsigned QualifiedDiag = diag::err_no_member_suggest;
971 NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl();
973 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
974 UnqualifiedDiag = diag::err_no_template_suggest;
975 QualifiedDiag = diag::err_no_member_template_suggest;
976 }
else if (UnderlyingFirstDecl &&
977 (isa<TypeDecl>(UnderlyingFirstDecl) ||
978 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
979 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
980 UnqualifiedDiag = diag::err_unknown_typename_suggest;
981 QualifiedDiag = diag::err_unknown_nested_typename_suggest;
987 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
988 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
989 Name->getName() == CorrectedStr;
992 << DroppedSpecifier << SS.
getRange());
996 Name = Corrected.getCorrectionAsIdentifierInfo();
999 if (Corrected.isKeyword())
1005 Result.setLookupName(Corrected.getCorrection());
1027 Result.suppressDiagnostics();
1069 if (!
Result.isAmbiguous()) {
1070 IsFilteredTemplateName =
true;
1080 (IsFilteredTemplateName ||
1096 if (!IsFilteredTemplateName)
1099 bool IsFunctionTemplate;
1103 IsFunctionTemplate =
true;
1106 }
else if (!
Result.empty()) {
1110 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
1111 IsVarTemplate = isa<VarTemplateDecl>(TD);
1114 dyn_cast<UsingShadowDecl>(*
Result.begin());
1115 assert(!FoundUsingShadow ||
1116 TD == cast<TemplateDecl>(FoundUsingShadow->
getTargetDecl()));
1124 IsFunctionTemplate =
true;
1128 if (IsFunctionTemplate) {
1132 Result.suppressDiagnostics();
1143 if (
const auto *USD = dyn_cast<UsingShadowDecl>(
Found))
1159 dyn_cast<ObjCCompatibleAliasDecl>(
FirstDecl))
1160 Class = Alias->getClassInterface();
1166 if (NextToken.
is(tok::period)) {
1169 Result.suppressDiagnostics();
1179 if (
auto *USD = dyn_cast<UsingShadowDecl>(
Result.getRepresentativeDecl()))
1185 if (
auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(
FirstDecl)) {
1198 bool NextIsOp = NextToken.
isOneOf(tok::amp, tok::star);
1199 if ((NextToken.
is(tok::identifier) ||
1201 FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
1213 if (
Result.isSingleResult() && !ADL &&
1218 Result.suppressDiagnostics();
1238 bool IsAddressOfOperand) {
1241 NameInfo, IsAddressOfOperand,
1248 const Token &NextToken) {
1250 if (
auto *Ivar = dyn_cast<ObjCIvarDecl>(
Found->getUnderlyingDecl()))
1265 auto *ULE = cast<UnresolvedLookupExpr>(
E);
1266 if ((*ULE->decls_begin())->isCXXClassMember()) {
1268 SS.
Adopt(ULE->getQualifierLoc());
1273 Result.setNamingClass(ULE->getNamingClass());
1274 for (
auto I = ULE->decls_begin(),
E = ULE->decls_end(); I !=
E; ++I)
1275 Result.addDecl(*I, I.getAccess());
1288 auto *TD = Name.getAsTemplateDecl();
1291 if (isa<ClassTemplateDecl>(TD))
1293 if (isa<FunctionTemplateDecl>(TD))
1295 if (isa<VarTemplateDecl>(TD))
1297 if (isa<TypeAliasTemplateDecl>(TD))
1299 if (isa<TemplateTemplateParmDecl>(TD))
1301 if (isa<ConceptDecl>(TD))
1308 "The next DeclContext should be lexically contained in the current one.");
1314 assert(
CurContext &&
"DeclContext imbalance!");
1317 assert(
CurContext &&
"Popped translation unit!");
1327 assert(
CurContext &&
"skipping definition of undefined tag");
1355 assert(!S->getEntity() &&
"scope already has entity");
1358 Scope *Ancestor = S->getParent();
1366 if (S->getParent()->isTemplateParamScope()) {
1374 assert(S->getEntity() ==
CurContext &&
"Context imbalance!");
1378 Scope *Ancestor = S->getParent();
1387 assert(S->isTemplateParamScope() &&
1388 "expected to be initializing a template parameter scope");
1412 for (; S && S->isTemplateParamScope(); S = S->getParent(), --ScopeDepth) {
1416 cast<Decl>(DC)->getDescribedTemplateParams()) {
1417 unsigned DCDepth = TPL->getDepth() + 1;
1418 if (DCDepth > ScopeDepth)
1420 if (ScopeDepth == DCDepth)
1425 S->setLookupEntity(SearchDCAfterScope);
1439 "The next DeclContext should be lexically contained in the current one.");
1443 for (
unsigned P = 0, NumParams = FD->
getNumParams();
P < NumParams; ++
P) {
1456 assert(
CurContext &&
"DeclContext imbalance!");
1458 assert(
CurContext &&
"Popped translation unit!");
1487 return ND->
hasAttr<OverloadableAttr>();
1490 return Previous.getFoundDecl()->hasAttr<OverloadableAttr>();
1499 while (S->getEntity() && S->getEntity()->isTransparentContext())
1514 if (isa<FunctionDecl>(
D) &&
1515 cast<FunctionDecl>(
D)->isFunctionTemplateSpecialization())
1518 if (isa<UsingEnumDecl>(
D) &&
D->getDeclName().isEmpty()) {
1525 for (; I != IEnd; ++I) {
1526 if (S->isDeclScope(*I) &&
D->declarationReplaces(*I)) {
1537 if (isa<LabelDecl>(
D) && !cast<LabelDecl>(
D)->isGnuLocal()) {
1544 if (!S->isDeclScope(*I))
1558 bool AllowInlineNamespace)
const {
1566 if (ScopeDC->getPrimaryContext() == TargetDC)
1568 }
while ((S = S->getParent()));
1578 bool ConsiderLinkage,
1579 bool AllowInlineNamespace) {
1637 if (NewIsModuleInterface || OldIsModuleInterface) {
1643 << NewIsModuleInterface
1645 << OldIsModuleInterface
1673 if (!IsNewExported && !IsOldExported)
1688 assert(IsNewExported);
1696 Diag(New->
getLocation(), diag::err_redeclaration_non_exported) << New << S;
1714 "New and Old are not the same definition, we should diagnostic it "
1715 "immediately instead of checking it.");
1718 "We shouldn't see unreachable definitions here.");
1766 return OldM == NewM;
1773 return isa<UsingShadowDecl>(
D) ||
1774 isa<UnresolvedUsingTypenameDecl>(
D) ||
1775 isa<UnresolvedUsingValueDecl>(
D);
1799 if (
D->doesThisDeclarationHaveABody())
1803 return CD->isCopyConstructor();
1804 return D->isCopyAssignmentOperator();
1810 if (
const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1811 if (!RD->hasNameForLinkage())
1817 return !
D->isExternallyVisible();
1846 FD->getMemberSpecializationInfo() && !FD->isOutOfLine())
1849 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1854 if (FD->isInlined() && !
isMainFileLoc(*
this, FD->getLocation()))
1858 if (FD->doesThisDeclarationHaveABody() &&
1861 }
else if (
const VarDecl *VD = dyn_cast<VarDecl>(
D)) {
1871 if (VD->isStaticDataMember() &&
1874 if (VD->isStaticDataMember() &&
1876 VD->getMemberSpecializationInfo() && !VD->isOutOfLine())
1879 if (VD->isInline() && !
isMainFileLoc(*
this, VD->getLocation()))
1888 return mightHaveNonExternalLinkage(
D);
1901 if (
const VarDecl *VD = dyn_cast<VarDecl>(
D)) {
1916 if (
const auto *DD = dyn_cast<DecompositionDecl>(
D)) {
1920 bool IsAllPlaceholders =
true;
1921 for (
const auto *BD : DD->bindings()) {
1922 if (BD->isReferenced() || BD->hasAttr<UnusedAttr>())
1924 IsAllPlaceholders = IsAllPlaceholders && BD->isPlaceholderVar(LangOpts);
1926 if (IsAllPlaceholders)
1928 }
else if (!
D->getDeclName()) {
1934 if (
D->isPlaceholderVar(LangOpts))
1941 if (isa<LabelDecl>(
D))
1950 WithinFunction || (R->isLocalClass() && !R->isDependentType());
1951 if (!WithinFunction)
1954 if (isa<TypedefNameDecl>(
D))
1958 if (!isa<VarDecl>(
D) || isa<ParmVarDecl>(
D) || isa<ImplicitParamDecl>(
D))
1962 if (
const VarDecl *VD = dyn_cast<VarDecl>(
D)) {
1965 if (
const auto *Cleanups = dyn_cast_if_present<ExprWithCleanups>(
Init))
1966 Init = Cleanups->getSubExpr();
1968 const auto *Ty = VD->getType().getTypePtr();
1973 if (TT->getDecl()->hasAttr<UnusedAttr>())
1979 if (
const auto *MTE = dyn_cast_if_present<MaterializeTemporaryExpr>(
Init);
1980 MTE && MTE->getExtendingDecl()) {
1981 Ty = VD->getType().getNonReferenceType().getTypePtr();
1982 Init = MTE->getSubExpr()->IgnoreImplicitAsWritten();
1987 if (Ty->isIncompleteType() || Ty->isDependentType())
1992 Ty = Ty->getBaseElementTypeUnsafe();
1995 const TagDecl *Tag = TT->getDecl();
1996 if (Tag->hasAttr<UnusedAttr>())
1999 if (
const auto *RD = dyn_cast<CXXRecordDecl>(Tag)) {
2000 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
2004 const auto *Construct =
2005 dyn_cast<CXXConstructExpr>(
Init->IgnoreImpCasts());
2006 if (Construct && !Construct->isElidable()) {
2008 if (!CD->
isTrivial() && !RD->hasAttr<WarnUnusedAttr>() &&
2009 (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
2015 if (
Init->isTypeDependent()) {
2017 if (!Ctor->isTrivial())
2023 if (isa<CXXUnresolvedConstructExpr>(
Init))
2037 if (isa<LabelDecl>(
D)) {
2055 if (
D->getTypeForDecl()->isDependentType())
2058 for (
auto *TmpD :
D->decls()) {
2059 if (
const auto *
T = dyn_cast<TypedefNameDecl>(TmpD))
2061 else if(
const auto *R = dyn_cast<RecordDecl>(TmpD))
2075 if (
auto *TD = dyn_cast<TypedefNameDecl>(
D)) {
2086 if (isa<VarDecl>(
D) && cast<VarDecl>(
D)->isExceptionVariable())
2087 DiagID = diag::warn_unused_exception_param;
2088 else if (isa<LabelDecl>(
D))
2089 DiagID = diag::warn_unused_label;
2091 DiagID = diag::warn_unused_variable;
2110 if (Ty->isReferenceType() || Ty->isDependentType())
2114 const TagDecl *Tag = TT->getDecl();
2115 if (Tag->hasAttr<UnusedAttr>())
2119 if (
const auto *RD = dyn_cast<CXXRecordDecl>(Tag);
2120 RD && !RD->hasAttr<WarnUnusedAttr>())
2127 if (VD->
hasAttr<BlocksAttr>() && Ty->isObjCObjectPointerType())
2133 if (VD->
hasAttr<ObjCPreciseLifetimeAttr>() && Ty->isObjCObjectPointerType())
2140 assert(iter->getSecond() >= 0 &&
2141 "Found a negative number of references to a VarDecl");
2142 if (
int RefCnt = iter->getSecond(); RefCnt > 0) {
2152 bool UnusedCXXCondDecl = VD->
isCXXCondDecl() && (RefCnt == 1);
2153 if (!UnusedCXXCondDecl)
2157 unsigned DiagID = isa<ParmVarDecl>(VD) ? diag::warn_unused_but_set_parameter
2158 : diag::warn_unused_but_set_variable;
2168 bool Diagnose =
false;
2172 Diagnose = L->
getStmt() ==
nullptr;
2181 if (S->decl_empty())
return;
2183 "Scope shouldn't contain decls!");
2190 std::optional<SourceLocation> PreviousDeclLoc;
2195 DeclDiags.push_back(LocAndDiag{
Loc, std::nullopt, std::move(PD)});
2200 DeclDiags.push_back(LocAndDiag{
Loc, PreviousDeclLoc, std::move(PD)});
2203 for (
auto *TmpD : S->decls()) {
2204 assert(TmpD &&
"This decl didn't get pushed??");
2206 assert(isa<NamedDecl>(TmpD) &&
"Decl isn't NamedDecl?");
2210 if (!S->hasUnrecoverableErrorOccurred()) {
2212 if (
const auto *RD = dyn_cast<RecordDecl>(
D))
2214 if (
VarDecl *VD = dyn_cast<VarDecl>(
D)) {
2220 if (!
D->getDeclName())
continue;
2234 auto ShadowI = ShadowingDecls.find(
D);
2235 if (ShadowI != ShadowingDecls.end()) {
2236 if (
const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
2238 PDiag(diag::warn_ctor_parm_shadows_field)
2239 <<
D << FD << FD->getParent());
2241 ShadowingDecls.erase(ShadowI);
2245 llvm::sort(DeclDiags,
2246 [](
const LocAndDiag &LHS,
const LocAndDiag &RHS) ->
bool {
2251 return LHS.Loc.getRawEncoding() < RHS.Loc.getRawEncoding();
2253 for (
const LocAndDiag &
D : DeclDiags) {
2255 if (
D.PreviousDeclLoc)
2256 Diag(*
D.PreviousDeclLoc, diag::note_previous_declaration);
2262 (S->getEntity() && S->getEntity()->isTransparentContext()) ||
2280 return "ucontext.h";
2282 llvm_unreachable(
"unhandled error kind");
2293 Parent->addDecl(CLinkageDecl);
2300 "consteval builtins should only be available in C++20 mode");
2315 for (
unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2318 FT->getParamType(i),
nullptr,
SC_None,
nullptr);
2320 Params.push_back(parm);
2322 New->setParams(Params);
2330 Scope *S,
bool ForRedeclaration,
2337 if (!ForRedeclaration)
2349 Diag(
Loc, diag::warn_implicit_decl_no_jmp_buf)
2356 Diag(
Loc, diag::warn_implicit_decl_requires_sysheader)
2362 if (!ForRedeclaration &&
2366 : diag::ext_implicit_lib_function_decl)
2369 Diag(
Loc, diag::note_include_header_or_declare)
2406 while (Filter.hasNext()) {
2415 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2417 Decl->getUnderlyingType()))
2422 if (OldTD->getAnonDeclWithTypedefName(
true) &&
2423 Decl->getAnonDeclWithTypedefName())
2435 if (
const TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
2436 OldType = OldTypedef->getUnderlyingType();
2443 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2444 Diag(New->
getLocation(), diag::err_redefinition_variably_modified_typedef)
2452 if (OldType != NewType &&
2456 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2458 << Kind << NewType << OldType;
2477 switch (TypeID->getLength()) {
2481 if (!TypeID->isStr(
"id"))
2497 if (!TypeID->isStr(
"Class"))
2504 if (!TypeID->isStr(
"SEL"))
2531 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2532 auto *OldTag = OldTD->getAnonDeclWithTypedefName(
true);
2535 if (OldTag && NewTag &&
2536 OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
2541 if (OldTD->isModed())
2543 OldTD->getUnderlyingType());
2552 if (isa<EnumDecl>(NewTag)) {
2554 for (
auto *
D : NewTag->decls()) {
2555 auto *ED = cast<EnumConstantDecl>(
D);
2559 ED->getLexicalDeclContext()->removeDecl(ED);
2609 if (!isa<TypedefNameDecl>(Old))
2641 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
2642 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
2643 for (
const auto *i :
D->
attrs())
2644 if (i->getKind() == A->
getKind()) {
2646 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
2651 if (OA && isa<OwnershipAttr>(i))
2652 return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
2660 if (
VarDecl *VD = dyn_cast<VarDecl>(
D))
2661 return VD->isThisDeclarationADefinition();
2662 if (
TagDecl *TD = dyn_cast<TagDecl>(
D))
2663 return TD->isCompleteDefinition() || TD->isBeingDefined();
2674 AlignedAttr *OldAlignasAttr =
nullptr;
2675 AlignedAttr *OldStrictestAlignAttr =
nullptr;
2676 unsigned OldAlign = 0;
2684 if (I->isAlignmentDependent())
2690 unsigned Align = I->getAlignment(S.
Context);
2691 if (Align > OldAlign) {
2693 OldStrictestAlignAttr = I;
2698 AlignedAttr *NewAlignasAttr =
nullptr;
2699 unsigned NewAlign = 0;
2701 if (I->isAlignmentDependent())
2707 unsigned Align = I->getAlignment(S.
Context);
2708 if (Align > NewAlign)
2712 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2720 if (OldAlign == 0 || NewAlign == 0) {
2722 if (
ValueDecl *VD = dyn_cast<ValueDecl>(New))
2733 if (OldAlign != NewAlign) {
2734 S.
Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2737 S.
Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2752 S.
Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2756 bool AnyAdded =
false;
2759 if (OldAlign > NewAlign) {
2760 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.
Context);
2761 Clone->setInherited(
true);
2767 if (OldAlignasAttr && !NewAlignasAttr &&
2768 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2769 AlignedAttr *Clone = OldAlignasAttr->clone(S.
Context);
2770 Clone->setInherited(
true);
2778#define WANT_DECL_MERGE_LOGIC
2779#include "clang/Sema/AttrParsedAttrImpl.inc"
2780#undef WANT_DECL_MERGE_LOGIC
2787 if (!DiagnoseMutualExclusions(S,
D,
Attr))
2798 if (
const auto *AA = dyn_cast<AvailabilityAttr>(
Attr))
2800 D, *AA, AA->getPlatform(), AA->
isImplicit(), AA->getIntroduced(),
2801 AA->getDeprecated(), AA->getObsoleted(), AA->getUnavailable(),
2802 AA->getMessage(), AA->getStrict(), AA->getReplacement(), AMK,
2803 AA->getPriority(), AA->getEnvironment());
2804 else if (
const auto *VA = dyn_cast<VisibilityAttr>(
Attr))
2806 else if (
const auto *VA = dyn_cast<TypeVisibilityAttr>(
Attr))
2808 else if (
const auto *ImportA = dyn_cast<DLLImportAttr>(
Attr))
2810 else if (
const auto *ExportA = dyn_cast<DLLExportAttr>(
Attr))
2812 else if (
const auto *EA = dyn_cast<ErrorAttr>(
Attr))
2814 else if (
const auto *FA = dyn_cast<FormatAttr>(
Attr))
2817 else if (
const auto *SA = dyn_cast<SectionAttr>(
Attr))
2819 else if (
const auto *CSA = dyn_cast<CodeSegAttr>(
Attr))
2821 else if (
const auto *IA = dyn_cast<MSInheritanceAttr>(
Attr))
2823 IA->getInheritanceModel());
2824 else if (
const auto *AA = dyn_cast<AlwaysInlineAttr>(
Attr))
2827 else if (S.
getLangOpts().CUDA && isa<FunctionDecl>(
D) &&
2828 (isa<CUDAHostAttr>(
Attr) || isa<CUDADeviceAttr>(
Attr) ||
2829 isa<CUDAGlobalAttr>(
Attr))) {
2833 }
else if (
const auto *MA = dyn_cast<MinSizeAttr>(
Attr))
2835 else if (
const auto *SNA = dyn_cast<SwiftNameAttr>(
Attr))
2837 else if (
const auto *OA = dyn_cast<OptimizeNoneAttr>(
Attr))
2839 else if (
const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(
Attr))
2841 else if (isa<AlignedAttr>(
Attr))
2845 else if ((isa<DeprecatedAttr>(
Attr) || isa<UnavailableAttr>(
Attr)) &&
2850 else if (
const auto *UA = dyn_cast<UuidAttr>(
Attr))
2851 NewAttr = S.
mergeUuidAttr(
D, *UA, UA->getGuid(), UA->getGuidDecl());
2852 else if (
const auto *IMA = dyn_cast<WebAssemblyImportModuleAttr>(
Attr))
2854 else if (
const auto *INA = dyn_cast<WebAssemblyImportNameAttr>(
Attr))
2856 else if (
const auto *TCBA = dyn_cast<EnforceTCBAttr>(
Attr))
2858 else if (
const auto *TCBLA = dyn_cast<EnforceTCBLeafAttr>(
Attr))
2860 else if (
const auto *BTFA = dyn_cast<BTFDeclTagAttr>(
Attr))
2862 else if (
const auto *NT = dyn_cast<HLSLNumThreadsAttr>(
Attr))
2865 else if (
const auto *SA = dyn_cast<HLSLShaderAttr>(
Attr))
2867 else if (isa<SuppressAttr>(
Attr))
2876 if (isa<MSInheritanceAttr>(NewAttr))
2885 if (
const TagDecl *TD = dyn_cast<TagDecl>(
D))
2886 return TD->getDefinition();
2887 if (
const VarDecl *VD = dyn_cast<VarDecl>(
D)) {
2895 if (FD->isDefined(Def,
true))
2902 for (
const auto *Attribute :
D->
attrs())
2903 if (Attribute->getKind() == Kind)
2915 if (!Def || Def == New)
2919 for (
unsigned I = 0,
E = NewAttributes.size(); I !=
E;) {
2920 const Attr *NewAttribute = NewAttributes[I];
2922 if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {
2929 NewAttributes.erase(NewAttributes.begin() + I);
2934 VarDecl *VD = cast<VarDecl>(New);
2935 unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
2937 ? diag::err_alias_after_tentative
2938 : diag::err_redefinition;
2940 if (
Diag == diag::err_redefinition)
2950 if (
const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
2963 if (isa<C11NoReturnAttr>(NewAttribute)) {
2967 }
else if (isa<UuidAttr>(NewAttribute)) {
2971 }
else if (
const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
2972 if (AA->isAlignas()) {
2983 S.
Diag(NewAttribute->
getLocation(), diag::note_alignas_on_declaration)
2985 NewAttributes.erase(NewAttributes.begin() + I);
2989 }
else if (isa<LoaderUninitializedAttr>(NewAttribute)) {
2995 diag::err_loader_uninitialized_redeclaration);
2997 NewAttributes.erase(NewAttributes.begin() + I);
3001 }
else if (isa<SelectAnyAttr>(NewAttribute) &&
3002 cast<VarDecl>(New)->isInline() &&
3003 !cast<VarDecl>(New)->isInlineSpecified()) {
3010 }
else if (isa<OMPDeclareVariantAttr>(NewAttribute)) {
3018 diag::warn_attribute_precede_definition);
3020 NewAttributes.erase(NewAttributes.begin() + I);
3026 const ConstInitAttr *CIAttr,
3027 bool AttrBeforeInit) {
3034 std::string SuitableSpelling;
3036 SuitableSpelling = std::string(
3038 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3040 InsertLoc, {tok::l_square, tok::l_square,
3041 S.PP.getIdentifierInfo(
"clang"), tok::coloncolon,
3042 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3043 tok::r_square, tok::r_square}));
3044 if (SuitableSpelling.empty())
3046 InsertLoc, {tok::kw___attribute, tok::l_paren, tok::r_paren,
3047 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3048 tok::r_paren, tok::r_paren}));
3049 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus20)
3050 SuitableSpelling =
"constinit";
3051 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3052 SuitableSpelling =
"[[clang::require_constant_initialization]]";
3053 if (SuitableSpelling.empty())
3054 SuitableSpelling =
"__attribute__((require_constant_initialization))";
3055 SuitableSpelling +=
" ";
3057 if (AttrBeforeInit) {
3060 assert(CIAttr->isConstinit() &&
"should not diagnose this for attribute");
3063 S.
Diag(CIAttr->getLocation(), diag::note_constinit_specified_here);
3067 S.
Diag(CIAttr->getLocation(),
3068 CIAttr->isConstinit() ? diag::err_constinit_added_too_late
3069 : diag::warn_require_const_init_added_too_late)
3072 << CIAttr->isConstinit()
3080 UsedAttr *NewAttr = OldAttr->clone(
Context);
3081 NewAttr->setInherited(
true);
3085 RetainAttr *NewAttr = OldAttr->clone(
Context);
3086 NewAttr->setInherited(
true);
3096 const auto *OldConstInit = Old->
getAttr<ConstInitAttr>();
3097 const auto *NewConstInit = New->
getAttr<ConstInitAttr>();
3098 if (
bool(OldConstInit) !=
bool(NewConstInit)) {
3099 const auto *OldVD = cast<VarDecl>(Old);
3100 auto *NewVD = cast<VarDecl>(New);
3106 (NewVD->hasInit() || NewVD->isThisDeclarationADefinition()))
3109 if (InitDecl == NewVD) {
3113 if (OldConstInit && OldConstInit->isConstinit())
3116 }
else if (NewConstInit) {
3120 if (InitDecl && InitDecl != NewVD) {
3123 NewVD->dropAttr<ConstInitAttr>();
3131 if (AsmLabelAttr *NewA = New->
getAttr<AsmLabelAttr>()) {
3132 if (AsmLabelAttr *OldA = Old->
getAttr<AsmLabelAttr>()) {
3133 if (!OldA->isEquivalent(NewA)) {
3136 Diag(OldA->getLocation(), diag::note_previous_declaration);
3138 }
else if (Old->
isUsed()) {
3142 << isa<FunctionDecl>(Old) << New->
getAttr<AsmLabelAttr>()->
getRange();
3147 if (
const auto *NewAbiTagAttr = New->
getAttr<AbiTagAttr>()) {
3148 if (
const auto *OldAbiTagAttr = Old->
getAttr<AbiTagAttr>()) {
3149 for (
const auto &NewTag : NewAbiTagAttr->tags()) {
3150 if (!llvm::is_contained(OldAbiTagAttr->tags(), NewTag)) {
3151 Diag(NewAbiTagAttr->getLocation(),
3152 diag::err_new_abi_tag_on_redeclaration)
3154 Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
3158 Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
3164 if (New->
hasAttr<SectionAttr>() && !Old->
hasAttr<SectionAttr>()) {
3165 if (
auto *VD = dyn_cast<VarDecl>(New)) {
3167 Diag(New->
getLocation(), diag::warn_attribute_section_on_redeclaration);
3174 const auto *NewCSA = New->
getAttr<CodeSegAttr>();
3175 if (NewCSA && !Old->
hasAttr<CodeSegAttr>() &&
3176 !NewCSA->isImplicit() && isa<CXXMethodDecl>(New)) {
3194 if (isa<DeprecatedAttr>(I) ||
3195 isa<UnavailableAttr>(I) ||
3196 isa<AvailabilityAttr>(I)) {
3211 if (isa<UsedAttr>(I) || isa<RetainAttr>(I))
3233 const CarriesDependencyAttr *CDA = newDecl->
getAttr<CarriesDependencyAttr>();
3234 if (CDA && !oldDecl->
hasAttr<CarriesDependencyAttr>()) {
3235 S.
Diag(CDA->getLocation(),
3236 diag::err_carries_dependency_missing_on_first_decl) << 1;
3244 diag::note_carries_dependency_missing_first_decl) << 1;
3252 const auto *NDAttr = newDecl->
getAttr<HLSLParamModifierAttr>();
3253 const auto *ODAttr = oldDecl->
getAttr<HLSLParamModifierAttr>();
3258 if (NDAttr && ODAttr &&
3259 NDAttr->getSpellingListIndex() != ODAttr->getSpellingListIndex()) {
3260 S.
Diag(newDecl->
getLocation(), diag::err_hlsl_param_qualifier_mismatch)
3261 << NDAttr << newDecl;
3270 bool foundAny = newDecl->
hasAttrs();
3279 cast<InheritableParamAttr>(I->clone(S.
Context));
3292 auto NoSizeInfo = [&Ctx](
QualType Ty) {
3293 if (Ty->isIncompleteArrayType() || Ty->isPointerType())
3301 if (NoSizeInfo(Old) && NoSizeInfo(New))
3333 if (*Oldnullability != *Newnullability) {
3334 S.
Diag(NewParam->
getLocation(), diag::warn_mismatched_nullability_attr)
3353 const auto *OldParamDT = dyn_cast<DecayedType>(OldParam->
getType());
3354 const auto *NewParamDT = dyn_cast<DecayedType>(NewParam->
getType());
3355 if (OldParamDT && NewParamDT &&
3356 OldParamDT->getPointeeType() == NewParamDT->getPointeeType()) {
3357 QualType OldParamOT = OldParamDT->getOriginalType();
3358 QualType NewParamOT = NewParamDT->getOriginalType();
3361 << NewParam << NewParamOT;
3372struct GNUCompatibleParamWarning {
3382template <
typename T>
3383static std::pair<diag::kind, SourceLocation>
3387 if (Old->isThisDeclarationADefinition())
3388 PrevDiag = diag::note_previous_definition;
3389 else if (Old->isImplicit()) {
3390 PrevDiag = diag::note_previous_implicit_declaration;
3391 if (
const auto *FD = dyn_cast<FunctionDecl>(Old)) {
3392 if (FD->getBuiltinID())
3393 PrevDiag = diag::note_previous_builtin_declaration;
3396 OldLocation = New->getLocation();
3398 PrevDiag = diag::note_previous_declaration;
3399 return std::make_pair(PrevDiag, OldLocation);
3407 return ((FD->
hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
3408 !LangOpts.CPlusPlus &&
3420template <
typename T>
3441template<
typename ExpectedDecl>
3463 !Old->getDeclContext()->getRedeclContext()->Equals(
3464 New->getDeclContext()->getRedeclContext()) &&
3469 S.
Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
3482 const auto *AttrA = A->
getAttr<PassObjectSizeAttr>();
3483 const auto *AttrB = B->
getAttr<PassObjectSizeAttr>();
3486 return AttrA && AttrB && AttrA->getType() == AttrB->getType() &&
3487 AttrA->isDynamic() == AttrB->isDynamic();
3513 if (NamedDC->Equals(SemaDC))
3516 assert((NamedDC->InEnclosingNamespaceSetOf(SemaDC) ||
3518 "unexpected context for redeclaration");
3529 if (
auto *FD = dyn_cast<FunctionDecl>(NewD))
3530 FixSemaDC(FD->getDescribedFunctionTemplate());
3531 else if (
auto *VD = dyn_cast<VarDecl>(NewD))
3532 FixSemaDC(VD->getDescribedVarTemplate());
3536 bool MergeTypeWithOld,
bool NewDeclIsDefn) {
3543 Diag(Shadow->getTargetDecl()->getLocation(),
3544 diag::note_using_decl_target);
3545 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
3554 if (checkUsingShadowRedecl<FunctionTemplateDecl>(*
this, Shadow,
3557 OldD = Old = cast<FunctionTemplateDecl>(Shadow->getTargetDecl())
3560 if (checkUsingShadowRedecl<FunctionDecl>(*
this, Shadow, New))
3562 OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
3590 std::tie(PrevDiag, OldLocation) =
3597 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
3604 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3607 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3612 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
3613 if (!Old->
hasAttr<InternalLinkageAttr>()) {
3617 New->
dropAttr<InternalLinkageAttr>();
3620 if (
auto *EA = New->
getAttr<ErrorAttr>()) {
3621 if (!Old->
hasAttr<ErrorAttr>()) {
3622 Diag(EA->getLocation(), diag::err_attribute_missing_on_first_decl) << EA;
3632 bool OldOvl = Old->
hasAttr<OverloadableAttr>();
3643 const Decl *DiagOld = Old;
3645 auto OldIter = llvm::find_if(Old->
redecls(), [](
const Decl *
D) {
3646 const auto *A = D->getAttr<OverloadableAttr>();
3647 return A && !A->isImplicit();
3651 DiagOld = OldIter == Old->
redecls_end() ? nullptr : *OldIter;
3656 diag::note_attribute_overloadable_prev_overload)
3671 Diag(OldLocation, diag::note_previous_declaration);
3690 const FunctionType *OldType = cast<FunctionType>(OldQType);
3691 const FunctionType *NewType = cast<FunctionType>(NewQType);
3694 bool RequiresAdjustment =
false;
3696 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC()) {
3702 if (!NewCCExplicit) {
3706 RequiresAdjustment =
true;
3718 RequiresAdjustment =
true;
3725 << (!FirstCCExplicit ?
"" :
3729 Diag(
First->getLocation(), diag::note_previous_declaration);
3737 RequiresAdjustment =
true;
3747 Diag(OldLocation, diag::note_previous_declaration);
3752 RequiresAdjustment =
true;
3759 <<
"'ns_returns_retained'";
3760 Diag(OldLocation, diag::note_previous_declaration);
3765 RequiresAdjustment =
true;
3771 AnyX86NoCallerSavedRegistersAttr *
Attr =
3772 New->
getAttr<AnyX86NoCallerSavedRegistersAttr>();
3774 Diag(OldLocation, diag::note_previous_declaration);
3779 RequiresAdjustment =
true;
3782 if (RequiresAdjustment) {
3792 !New->
hasAttr<GNUInlineAttr>() &&
3801 if (New->
hasAttr<GNUInlineAttr>() &&
3812 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3816 QualType OldQTypeForComparison = OldQType;
3820 if (OldFX != NewFX) {
3822 for (
const auto &Diff : Diffs) {
3823 if (Diff.shouldDiagnoseRedeclaration(*Old, OldFX, *New, NewFX)) {
3825 diag::warn_mismatched_func_effect_redeclaration)
3826 << Diff.effectName();
3837 if (!MergeErrs.empty())
3844 NewFPT->getParamTypes(), EPI);
3852 EPI = OldFPT->getExtProtoInfo();
3855 OldFPT->getReturnType(), OldFPT->getParamTypes(), EPI);
3874 OldDeclaredReturnType)) {
3882 Diag(New->
getLocation(), diag::err_member_def_does_not_match_ret_type)
3887 Diag(OldLocation, PrevDiag) << Old << Old->
getType()
3896 QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
3897 if (OldReturnType != NewReturnType) {
3913 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
3915 if (OldMethod && NewMethod) {
3922 bool IsClassScopeExplicitSpecialization =
3928 !IsClassScopeExplicitSpecialization) {
3934 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3944 if (isa<CXXConstructorDecl>(OldMethod))
3945 NewDiag = diag::err_constructor_redeclared;
3946 else if (isa<CXXDestructorDecl>(NewMethod))
3947 NewDiag = diag::err_destructor_redeclared;
3948 else if (isa<CXXConversionDecl>(NewMethod))
3949 NewDiag = diag::err_conv_function_redeclared;
3951 NewDiag = diag::err_member_redeclared;
3955 Diag(New->
getLocation(), diag::err_member_redeclared_in_instantiation)
3958 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3971 diag::err_definition_of_implicitly_declared_member)
3977 diag::err_definition_of_explicitly_defaulted_member)
4000 if (
const auto *NRA = New->
getAttr<CXX11NoReturnAttr>())
4001 if (!Old->
hasAttr<CXX11NoReturnAttr>()) {
4002 Diag(NRA->getLocation(), diag::err_attribute_missing_on_first_decl)
4011 const CarriesDependencyAttr *CDA = New->
getAttr<CarriesDependencyAttr>();
4012 if (CDA && !Old->
hasAttr<CarriesDependencyAttr>()) {
4013 Diag(CDA->getLocation(),
4014 diag::err_carries_dependency_missing_on_first_decl) << 0;
4016 diag::note_carries_dependency_missing_first_decl) << 0;
4029 OldQTypeForComparison =
QualType(OldTypeForComparison, 0);
4044 Diag(OldLocation, PrevDiag);
4046 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4047 Diag(OldLocation, PrevDiag);
4118 bool IsWithoutProtoADef =
false, IsWithProtoADef =
false;
4119 if (WithoutProto == New)
4120 IsWithoutProtoADef = NewDeclIsDefn;
4122 IsWithProtoADef = NewDeclIsDefn;
4124 diag::warn_non_prototype_changes_behavior)
4125 << IsWithoutProtoADef << (WithoutProto->
getNumParams() ? 0 : 1)
4126 << (WithoutProto == Old) << IsWithProtoADef;
4136 !IsWithoutProtoADef)
4146 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
4147 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
4150 assert(!OldProto->hasExceptionSpec() &&
"Exception spec in C");
4152 OldProto->getParamTypes(),
4153 OldProto->getExtProtoInfo());
4159 for (
const auto &ParamType : OldProto->param_types()) {
4162 ParamType,
nullptr,
SC_None,
nullptr);
4165 Params.push_back(Param);
4168 New->setParams(Params);
4204 NewProto->getReturnType());
4205 bool LooseCompatible = !MergedReturn.
isNull();
4207 LooseCompatible && Idx != End; ++Idx) {
4211 NewProto->getParamType(Idx))) {
4212 ArgTypes.push_back(NewParm->
getType());
4216 GNUCompatibleParamWarning Warn = { OldParm, NewParm,
4217 NewProto->getParamType(Idx) };
4218 Warnings.push_back(Warn);
4219 ArgTypes.push_back(NewParm->
getType());
4221 LooseCompatible =
false;
4224 if (LooseCompatible) {
4225 for (
unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
4226 Diag(Warnings[Warn].NewParm->getLocation(),
4227 diag::ext_param_promoted_not_compatible_with_prototype)
4228 << Warnings[Warn].PromotedType
4229 << Warnings[Warn].OldParm->getType();
4230 if (Warnings[Warn].OldParm->getLocation().isValid())
4231 Diag(Warnings[Warn].OldParm->getLocation(),
4232 diag::note_previous_declaration);
4235 if (MergeTypeWithOld)
4255 Diag(OldLocation, diag::note_previous_builtin_declaration)
4260 PrevDiag = diag::note_previous_builtin_declaration;
4264 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4269 Scope *S,
bool MergeTypeWithOld) {
4284 for (
unsigned i = 0, e = New->
getNumParams(); i != e; ++i) {
4298 if (!Merged.isNull() && MergeTypeWithOld)
4321 ni != ne && oi != oe; ++ni, ++oi)
4331 ? diag::err_redefinition_different_type
4332 : diag::err_redeclaration_different_type)
4337 std::tie(PrevDiag, OldLocation)
4339 S.
Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4344 bool MergeTypeWithOld) {
4372 QualType PrevVDTy = PrevVD->getType();
4426 if (MergeTypeWithOld)
4464 if (!shouldLinkPossiblyHiddenDecl(
Previous, New))
4474 OldTemplate = dyn_cast<VarTemplateDecl>(
Previous.getFoundDecl());
4478 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4479 if (checkUsingShadowRedecl<VarTemplateDecl>(*
this, Shadow, NewTemplate))
4482 Old = dyn_cast<VarDecl>(
Previous.getFoundDecl());
4485 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4486 if (checkUsingShadowRedecl<VarDecl>(*
this, Shadow, New))
4523 if (New->
hasAttr<WeakImportAttr>())
4534 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
4535 if (!Old->
hasAttr<InternalLinkageAttr>()) {
4539 New->
dropAttr<InternalLinkageAttr>();
4544 if (MostRecent != Old) {
4557 std::tie(PrevDiag, OldLocation) =
4567 Diag(OldLocation, PrevDiag);
4571 Diag(OldLocation, PrevDiag);
4590 Diag(OldLocation, PrevDiag);
4598 Diag(OldLocation, PrevDiag);
4604 Diag(OldLocation, PrevDiag);
4620 Diag(OldLocation, PrevDiag);
4630 Diag(Def->getLocation(), diag::note_previous_definition);
4644 Diag(OldLocation, PrevDiag);
4647 Diag(OldLocation, PrevDiag);
4655 Diag(OldLocation, PrevDiag);
4665 diag::warn_deprecated_redundant_constexpr_static_def);
4674 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4675 Diag(OldLocation, PrevDiag);
4705 StringRef HdrFilename =
4708 auto noteFromModuleOrInclude = [&](
Module *Mod,
4714 if (IncLoc.isValid()) {
4716 Diag(IncLoc, diag::note_redefinition_modules_same_file)
4722 Diag(IncLoc, diag::note_redefinition_include_same_file)
4723 << HdrFilename.str();
4733 if (FNew == FOld && FNewDecLoc.second == FOldDecLoc.second) {
4741 if (FOld && !HSI.isFileMultipleIncludeGuarded(*FOld))
4756 isa<VarTemplateSpecializationDecl>(New) ||
4792 ? S->getMSCurManglingNumber()
4793 : S->getMSLastManglingNumber();
4800 if (isa<CXXRecordDecl>(Tag->getParent())) {
4803 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl())
4815 Decl *ManglingContextDecl;
4816 std::tie(MCtx, ManglingContextDecl) =
4826struct NonCLikeKind {
4846 return {NonCLikeKind::Invalid, {}};
4853 return {NonCLikeKind::BaseClass,
4865 if (
auto *FD = dyn_cast<FieldDecl>(
D)) {
4866 if (FD->hasInClassInitializer()) {
4867 auto *
Init = FD->getInClassInitializer();
4868 return {NonCLikeKind::DefaultMemberInit,
4876 if (isa<FriendDecl>(
D))
4881 if (isa<StaticAssertDecl>(
D) || isa<IndirectFieldDecl>(
D) ||
4884 auto *MemberRD = dyn_cast<CXXRecordDecl>(
D);
4892 if (MemberRD->isLambda())
4893 return {NonCLikeKind::Lambda, MemberRD->getSourceRange()};
4897 if (MemberRD->isThisDeclarationADefinition()) {
4903 return {
Invalid ? NonCLikeKind::Invalid : NonCLikeKind::None, {}};
4933 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TagFromDeclSpec);
4937 if (NonCLike || ChangesLinkage) {
4938 if (NonCLike.Kind == NonCLikeKind::Invalid)
4941 unsigned DiagID = diag::ext_non_c_like_anon_struct_in_typedef;
4942 if (ChangesLinkage) {
4944 if (NonCLike.Kind == NonCLikeKind::None)
4945 DiagID = diag::err_typedef_changes_linkage;
4947 DiagID = diag::err_non_c_like_anon_struct_in_typedef;
4953 TextToInsert +=
' ';
4956 Diag(FixitLoc, DiagID)
4957 << isa<TypeAliasDecl>(NewTD)
4959 if (NonCLike.Kind != NonCLikeKind::None) {
4960 Diag(NonCLike.Range.getBegin(), diag::note_non_c_like_anon_struct)
4961 << NonCLike.Kind - 1 << NonCLike.Range;
4964 << NewTD << isa<TypeAliasDecl>(NewTD);
4986 if (
const auto *ED = dyn_cast<EnumDecl>(DS.
getRepAsDecl())) {
4987 if (ED->isScopedUsingClassTag())
4994 llvm_unreachable(
"unexpected type specifier");
5002 bool IsExplicitInstantiation,
5004 Decl *TagD =
nullptr;
5019 if (isa<TagDecl>(TagD))
5020 Tag = cast<TagDecl>(TagD);
5022 Tag = CTD->getTemplatedDecl();
5027 Tag->setFreeStanding();
5028 if (Tag->isInvalidDecl())
5037 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
5074 bool DeclaresAnything =
true;
5078 if (!
Record->getDeclName() &&
Record->isCompleteDefinition() &&
5081 Record->getDeclContext()->isRecord()) {
5095 DeclaresAnything =
false;
5114 if ((Tag && Tag->getDeclName()) ||
5118 Record = dyn_cast<RecordDecl>(Tag);
5131 DeclaresAnything =
false;
5143 if (
Enum->enumerator_begin() ==
Enum->enumerator_end() &&
5144 !
Enum->getIdentifier() && !
Enum->isInvalidDecl())
5145 DeclaresAnything =
false;
5153 DeclaresAnything =
false;
5157 Tag && Tag->getDeclContext()->isFunctionOrMethod())
5159 << llvm::to_underlying(Tag->getTagKind())
5172 if (!DeclaresAnything) {
5175 Diag(DS.
getBeginLoc(), (IsExplicitInstantiation || !TemplateParams.empty())
5176 ? diag::err_no_declarators
5177 : diag::ext_no_declarators)
5190 unsigned DiagID = diag::warn_standalone_specifier;
5192 DiagID = diag::ext_standalone_specifier;
5233 auto EmitAttributeDiagnostic = [
this, &DS](
const ParsedAttr &AL) {
5234 unsigned DiagnosticId = diag::warn_declspec_attribute_ignored;
5236 DiagnosticId = diag::warn_attribute_ignored;
5237 else if (AL.isRegularKeywordAttribute())
5238 DiagnosticId = diag::err_declspec_keyword_has_no_effect;
5240 DiagnosticId = diag::warn_declspec_attribute_ignored;
5241 Diag(AL.getLoc(), DiagnosticId)
5245 llvm::for_each(DS.
getAttributes(), EmitAttributeDiagnostic);
5246 llvm::for_each(DeclAttrs, EmitAttributeDiagnostic);
5265 RedeclarationKind::ForVisibleRedeclaration);
5270 assert(PrevDecl &&
"Expected a non-null Decl");
5283 SemaRef.
Diag(NameLoc, diag::err_anonymous_record_member_redecl)
5285 SemaRef.
Diag(PrevDecl->
getLocation(), diag::note_previous_declaration);
5291 if (
auto *RD = dyn_cast_if_present<RecordDecl>(
D))
5301 if (
Record->isAnonymousStructOrUnion())
5306 const NamedDecl *ND = dyn_cast<NamedDecl>(
D);
5340 for (
auto *
D : AnonRecord->
decls()) {
5341 if ((isa<FieldDecl>(
D) || isa<IndirectFieldDecl>(
D)) &&
5342 cast<NamedDecl>(
D)->getDeclName()) {
5358 unsigned OldChainingSize = Chaining.size();
5360 Chaining.append(IF->chain_begin(), IF->chain_end());
5362 Chaining.push_back(VD);
5364 assert(Chaining.size() >= 2);
5367 for (
unsigned i = 0; i < Chaining.size(); i++)
5368 NamedChain[i] = Chaining[i];
5372 VD->
getType(), {NamedChain, Chaining.size()});
5384 Chaining.resize(OldChainingSize);
5399 "Parser allowed 'typedef' as storage class VarDecl.");
5400 switch (StorageClassSpec) {
5414 llvm_unreachable(
"unknown storage class specifier");
5418 assert(
Record->hasInClassInitializer());
5420 for (
const auto *I :
Record->decls()) {
5421 const auto *FD = dyn_cast<FieldDecl>(I);
5422 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
5423 FD = IFD->getAnonField();
5424 if (FD && FD->hasInClassInitializer())
5425 return FD->getLocation();
5428 llvm_unreachable(
"couldn't find in-class initializer");
5433 if (!
Parent->isUnion() || !
Parent->hasInClassInitializer())
5436 S.
Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
5442 if (!
Parent->isUnion() || !
Parent->hasInClassInitializer())
5456 Diag(
Record->getLocation(), diag::ext_anonymous_union);
5458 Diag(
Record->getLocation(), diag::ext_gnu_anonymous_struct);
5460 Diag(
Record->getLocation(), diag::ext_c11_anonymous_struct);
5466 const char *PrevSpec =
nullptr;
5477 !cast<NamespaceDecl>(OwnerScope)->isAnonymousNamespace()))) {
5478 Diag(
Record->getLocation(), diag::err_anonymous_union_not_static)
5483 PrevSpec, DiagID, Policy);
5489 isa<RecordDecl>(Owner)) {
5491 diag::err_anonymous_union_with_storage_spec)
5505 <<
Record->isUnion() <<
"const"
5509 diag::ext_anonymous_struct_union_qualified)
5510 <<
Record->isUnion() <<
"volatile"
5514 diag::ext_anonymous_struct_union_qualified)
5515 <<
Record->isUnion() <<
"restrict"
5519 diag::ext_anonymous_struct_union_qualified)
5520 <<
Record->isUnion() <<
"_Atomic"
5524 diag::ext_anonymous_struct_union_qualified)
5525 <<
Record->isUnion() <<
"__unaligned"
5535 for (
auto *Mem :
Record->decls()) {
5537 if (Mem->isInvalidDecl())
5540 if (
auto *FD = dyn_cast<FieldDecl>(Mem)) {
5544 assert(FD->getAccess() !=
AS_none);
5546 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
5558 }
else if (Mem->isImplicit()) {
5560 }
else if (isa<TagDecl>(Mem) && Mem->getDeclContext() !=
Record) {
5565 }
else if (
auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
5566 if (!MemRecord->isAnonymousStructOrUnion() &&
5567 MemRecord->getDeclName()) {
5570 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
5574 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
5582 Diag(MemRecord->getLocation(),
5583 diag::ext_anonymous_record_with_anonymous_type)
5586 }
else if (isa<AccessSpecDecl>(Mem)) {
5588 }
else if (isa<StaticAssertDecl>(Mem)) {
5593 unsigned DK = diag::err_anonymous_record_bad_member;
5594 if (isa<TypeDecl>(Mem))
5595 DK = diag::err_anonymous_record_with_type;
5596 else if (isa<FunctionDecl>(Mem))
5597 DK = diag::err_anonymous_record_with_function;
5598 else if (isa<VarDecl>(Mem))
5599 DK = diag::err_anonymous_record_with_static;
5603 DK == diag::err_anonymous_record_with_type)
5604 Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
5607 Diag(Mem->getLocation(), DK) <<
Record->isUnion();
5616 if (cast<CXXRecordDecl>(
Record)->hasInClassInitializer() &&
5619 cast<CXXRecordDecl>(
Record));
5623 Diag(
Record->getLocation(), diag::err_anonymous_struct_not_member)
5644 assert(TInfo &&
"couldn't build declarator info for anonymous struct/union");
5648 if (
RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
5664 Diag(
Record->getLocation(), diag::err_mutable_nonmember);
5670 Record->getLocation(),
nullptr,
5686 Record->setAnonymousStructOrUnion(
true);
5697 Chain.push_back(Anon);
5703 if (
VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
5706 Decl *ManglingContextDecl;
5707 std::tie(MCtx, ManglingContextDecl) =
5726 assert(
Record &&
"expected a record!");
5731 assert(TInfo &&
"couldn't build declarator info for anonymous struct");
5733 auto *ParentDecl = cast<RecordDecl>(
CurContext);
5739 nullptr, RecTy, TInfo,
5751 Chain.push_back(Anon);
5755 diag::err_field_incomplete_or_sizeless) ||
5760 ParentDecl->setInvalidDecl();
5773 NameInfo.
setLoc(Name.StartLocation);
5775 switch (Name.getKind()) {
5779 NameInfo.
setName(Name.Identifier);
5795 if (!Template || !isa<ClassTemplateDecl>(Template)) {
5796 Diag(Name.StartLocation,
5797 diag::err_deduction_guide_name_not_class_template)
5811 Name.OperatorFunctionId.Operator));
5813 Name.OperatorFunctionId.SymbolLocations[0], Name.EndLocation));
5849 if (!CurClass || CurClass->
getIdentifier() != Name.TemplateId->Name)
5885 llvm_unreachable(
"Unknown name kind");
5913 for (
unsigned Idx = 0; Idx <
Declaration->param_size(); ++Idx) {
5927 (DeclTyName && DeclTyName == DefTyName))
5928 Params.push_back(Idx);
5955#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case DeclSpec::TST_##Trait:
5956#include "clang/Basic/TransformTypeTraits.def"
5971 if (!TSI)
return true;
5984 if (
Result.isInvalid())
return true;
5995 for (
unsigned I = 0,
E =
D.getNumTypeObjects(); I !=
E; ++I) {
6029 << D << static_cast<int>(Status);
6040 if (
OpenMP().getOMPTraitInfoForSurroundingScope()->isExtensionActive(
6041 llvm::omp::TraitProperty::
6042 implementation_extension_bind_to_declaration))
6067 Diag(NameInfo.
getLoc(), diag::err_member_name_of_class) << Name;
6078 bool IsMemberSpecialization) {
6079 assert(SS.
isValid() &&
"diagnoseQualifiedDeclaration called for declaration "
6080 "without nested-name-specifier");
6082 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
6096 Diag(
Loc,
LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
6097 : diag::err_member_extra_qualification)
6101 Diag(
Loc, diag::warn_namespace_member_extra_qualification) << Name;
6109 if (!Cur->
Encloses(DC) && !(TemplateId || IsMemberSpecialization)) {
6111 Diag(
Loc, diag::err_member_qualification)
6113 else if (isa<TranslationUnitDecl>(DC))
6114 Diag(
Loc, diag::err_invalid_declarator_global_scope)
6116 else if (isa<FunctionDecl>(Cur))
6117 Diag(
Loc, diag::err_invalid_declarator_in_function)
6119 else if (isa<BlockDecl>(Cur))
6120 Diag(
Loc, diag::err_invalid_declarator_in_block)
6122 else if (isa<ExportDecl>(Cur)) {
6123 if (!isa<NamespaceDecl>(DC))
6124 Diag(
Loc, diag::err_export_non_namespace_scope_name)
6131 Diag(
Loc, diag::err_invalid_declarator_scope)
6132 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.
getRange();
6139 Diag(
Loc, diag::err_member_qualification)
6165 Diag(
Loc, diag::ext_template_after_declarative_nns)
6172 Diag(
Loc, diag::ext_template_after_declarative_nns)
6183 if (TST->isDependentType() && TST->isTypeAlias())
6184 Diag(
Loc, diag::ext_alias_template_in_declarative_nns)
6193 Diag(
Loc, diag::err_computed_type_in_declarative_nns)
6197 }
while ((SpecLoc = SpecLoc.
getPrefix()));
6210 if (
D.isDecompositionDeclarator()) {
6213 if (!
D.isInvalidType())
6221 if (
D.getCXXScopeSpec().isInvalid())
6223 else if (
D.getCXXScopeSpec().isSet()) {
6228 bool EnteringContext = !
D.getDeclSpec().isFriendSpecified();
6230 if (!DC || isa<EnumDecl>(DC)) {
6235 Diag(
D.getIdentifierLoc(),
6236 diag::err_template_qualified_declarator_no_match)
6237 <<
D.getCXXScopeSpec().getScopeRep()
6238 <<
D.getCXXScopeSpec().getRange();
6243 if (!IsDependentContext &&
6248 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->
hasDefinition()) {
6249 Diag(
D.getIdentifierLoc(),
6250 diag::err_member_def_undefined_record)
6251 << Name << DC <<
D.getCXXScopeSpec().getRange();
6254 if (!
D.getDeclSpec().isFriendSpecified()) {
6257 ?
D.getName().TemplateId
6260 D.getIdentifierLoc(), TemplateId,
6271 if (EnteringContext && IsDependentContext &&
6272 TemplateParamLists.size() != 0) {
6290 if (!
D.getCXXScopeSpec().isSet()) {
6291 bool IsLinkageLookup =
false;
6292 bool CreateBuiltins =
false;
6306 IsLinkageLookup =
true;
6311 CreateBuiltins =
true;
6313 if (IsLinkageLookup) {
6316 RedeclarationKind::ForExternalRedeclaration);
6354 if (!
D.isInvalidType()) {
6355 bool AllowForCompatibility =
false;
6356 if (
Scope *DeclParent = S->getDeclParent();
6357 Scope *TemplateParamParent = S->getTemplateParamParent()) {
6358 AllowForCompatibility = DeclParent->Contains(*TemplateParamParent) &&
6359 TemplateParamParent->isDeclScope(TPD);
6362 AllowForCompatibility);
6388 S = S->getDeclParent();
6392 bool AddToScope =
true;
6394 if (TemplateParamLists.size()) {
6395 Diag(
D.getIdentifierLoc(), diag::err_template_typedef);
6417 if (
OpenMP().isInOpenMPDeclareTargetContext())
6428 bool &SizeIsNegative,
6429 llvm::APSInt &Oversized) {
6434 SizeIsNegative =
false;
6443 if (
const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
6448 if (FixedType.
isNull())
return FixedType;
6450 return Qs.
apply(Context, FixedType);
6452 if (
const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
6453 QualType Inner = PTy->getInnerType();
6457 if (FixedType.
isNull())
return FixedType;
6459 return Qs.
apply(Context, FixedType);
6469 SizeIsNegative, Oversized);
6479 llvm::APSInt Res =
Result.Val.getInt();
6482 if (Res.isSigned() && Res.isNegative()) {
6483 SizeIsNegative =
true;
6488 unsigned ActiveSizeBits =
6492 : Res.getActiveBits();
6500 return Qs.
apply(Context, FoldedArrayType);
6525 TypeLoc DstElemTL = DstATL.getElementLoc();
6544 bool &SizeIsNegative,
6545 llvm::APSInt &Oversized) {
6548 SizeIsNegative, Oversized);
6559 unsigned FailedFoldDiagID) {
6560 bool SizeIsNegative;
6561 llvm::APSInt Oversized;
6563 TInfo,
Context, SizeIsNegative, Oversized);
6565 Diag(
Loc, diag::ext_vla_folded_to_constant);
6572 Diag(
Loc, diag::err_typecheck_negative_array_size);
6573 else if (Oversized.getBoolValue())
6575 else if (FailedFoldDiagID)
6602 diag::err_virtual_non_function);
6606 diag::err_explicit_non_function);
6610 diag::err_noreturn_non_function);
6617 if (
D.getCXXScopeSpec().isSet()) {
6618 Diag(
D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
6619 <<
D.getCXXScopeSpec().getRange();
6628 if (
D.getDeclSpec().isInlineSpecified())
6629 Diag(
D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
6631 if (
D.getDeclSpec().hasConstexprSpecifier())
6632 Diag(
D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
6633 << 1 <<
static_cast<int>(
D.getDeclSpec().getConstexprSpecifier());
6637 Diag(
D.getName().StartLocation,
6638 diag::err_deduction_guide_invalid_specifier)
6641 Diag(
D.getName().StartLocation, diag::err_typedef_not_identifier)
6647 if (!NewTD)
return nullptr;
6654 bool Redeclaration =
D.isRedeclaration();
6656 D.setRedeclaration(Redeclaration);
6671 if (S->getFnParent() ==
nullptr) {
6672 bool SizeIsNegative;
6673 llvm::APSInt Oversized;
6686 else if (Oversized.getBoolValue())
6710 Redeclaration =
true;
6716 if (ShadowedDecl && !Redeclaration)
6723 switch (II->getNotableIdentifierID()) {
6724 case tok::NotableIdentifierKind::FILE:
6727 case tok::NotableIdentifierKind::jmp_buf:
6730 case tok::NotableIdentifierKind::sigjmp_buf:
6733 case tok::NotableIdentifierKind::ucontext_t:
6736 case tok::NotableIdentifierKind::float_t:
6737 case tok::NotableIdentifierKind::double_t:
6738 NewTD->
addAttr(AvailableOnlyInDefaultEvalMethodAttr::Create(
Context));
6799 if (!OuterContext->
Equals(PrevOuterContext))
6808 if (!SS.
isSet())
return;
6813 if (
Decl->getType().hasAddressSpace())
6815 if (
Decl->getType()->isDependentType())
6827 Var->hasGlobalStorage())
6831 if (
auto DT = dyn_cast<DecayedType>(
Type)) {
6832 auto OrigTy = DT->getOriginalType();
6833 if (!OrigTy.hasAddressSpace() && OrigTy->isArrayType()) {
6865 if (WeakRefAttr *
Attr = ND.
getAttr<WeakRefAttr>()) {
6872 if (
auto *VD = dyn_cast<VarDecl>(&ND)) {
6873 if (VD->hasInit()) {
6874 if (
const auto *
Attr = VD->getAttr<AliasAttr>()) {
6875 assert(VD->isThisDeclarationADefinition() &&
6876 !VD->isExternallyVisible() &&
"Broken AliasAttr handled late!");
6878 VD->dropAttr<AliasAttr>();
6885 if (SelectAnyAttr *
Attr = ND.
getAttr<SelectAnyAttr>()) {
6888 diag::err_attribute_selectany_non_extern_data);
6894 auto *VD = dyn_cast<VarDecl>(&ND);
6895 bool IsAnonymousNS =
false;
6898 const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(VD->getDeclContext());
6899 while (NS && !IsAnonymousNS) {
6901 NS = dyn_cast<NamespaceDecl>(NS->
getParent());
6908 bool AnonNSInMicrosoftMode = IsAnonymousNS && IsMicrosoft;
6910 (!AnonNSInMicrosoftMode &&
6919 if (
const auto *FD = dyn_cast<FunctionDecl>(&ND)) {
6924 for (
TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc();
6930 if (
const auto *A = ATL.
getAttrAs<LifetimeBoundAttr>()) {
6931 const auto *MD = dyn_cast<CXXMethodDecl>(FD);
6932 if (!MD || MD->isStatic()) {
6933 S.
Diag(A->getLocation(), diag::err_lifetimebound_no_object_param)
6934 << !MD << A->getRange();
6935 }
else if (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)) {
6936 S.
Diag(A->getLocation(), diag::err_lifetimebound_ctor_dtor)
6937 << isa<CXXDestructorDecl>(MD) << A->getRange();
6946 bool IsSpecialization,
6947 bool IsDefinition) {
6951 bool IsTemplate =
false;
6952 if (
TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl)) {
6953 OldDecl = OldTD->getTemplatedDecl();
6955 if (!IsSpecialization)
6956 IsDefinition =
false;
6958 if (
TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl)) {
6959 NewDecl = NewTD->getTemplatedDecl();
6963 if (!OldDecl || !NewDecl)
6966 const DLLImportAttr *OldImportAttr = OldDecl->
getAttr<DLLImportAttr>();
6967 const DLLExportAttr *OldExportAttr = OldDecl->
getAttr<DLLExportAttr>();
6968 const DLLImportAttr *NewImportAttr = NewDecl->
getAttr<DLLImportAttr>();
6969 const DLLExportAttr *NewExportAttr = NewDecl->
getAttr<DLLExportAttr>();
6973 bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
6974 (NewExportAttr && !NewExportAttr->isInherited());
6980 bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
6982 if (AddsAttr && !IsSpecialization && !OldDecl->
isImplicit()) {
6984 bool JustWarn =
false;
6986 auto *VD = dyn_cast<VarDecl>(OldDecl);
6987 if (VD && !VD->getDescribedVarTemplate())
6989 auto *FD = dyn_cast<FunctionDecl>(OldDecl);
6998 if (!isa<FunctionDecl>(OldDecl) || !NewImportAttr)
7001 unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
7002 : diag::err_attribute_dll_redeclaration;
7005 << (NewImportAttr ? (
const Attr *)NewImportAttr : NewExportAttr);
7018 bool IsInline =
false, IsStaticDataMember =
false, IsQualifiedFriend =
false;
7020 if (
const auto *VD = dyn_cast<VarDecl>(NewDecl)) {
7023 IsStaticDataMember = VD->isStaticDataMember();
7024 IsDefinition = VD->isThisDeclarationADefinition(S.
Context) !=
7026 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
7027 IsInline = FD->isInlined();
7028 IsQualifiedFriend = FD->getQualifier() &&
7032 if (OldImportAttr && !HasNewAttr &&
7033 (!IsInline || (IsMicrosoftABI && IsTemplate)) && !IsStaticDataMember &&
7035 if (IsMicrosoftABI && IsDefinition) {
7036 if (IsSpecialization) {
7039 diag::err_attribute_dllimport_function_specialization_definition);
7040 S.
Diag(OldImportAttr->getLocation(), diag::note_attribute);
7041 NewDecl->
dropAttr<DLLImportAttr>();
7044 diag::warn_redeclaration_without_import_attribute)
7047 NewDecl->
dropAttr<DLLImportAttr>();
7048 NewDecl->
addAttr(DLLExportAttr::CreateImplicit(
7049 S.
Context, NewImportAttr->getRange()));
7051 }
else if (IsMicrosoftABI && IsSpecialization) {
7052 assert(!IsDefinition);
7056 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
7057 << NewDecl << OldImportAttr;
7059 S.
Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
7060 OldDecl->
dropAttr<DLLImportAttr>();
7061 NewDecl->
dropAttr<DLLImportAttr>();
7063 }
else if (IsInline && OldImportAttr && !IsMicrosoftABI) {
7066 OldDecl->
dropAttr<DLLImportAttr>();
7067 NewDecl->
dropAttr<DLLImportAttr>();
7069 diag::warn_dllimport_dropped_from_inline_function)
7070 << NewDecl << OldImportAttr;
7077 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDecl)) {
7079 !NewImportAttr && !NewExportAttr) {
7080 if (
const DLLExportAttr *ParentExportAttr =
7081 MD->getParent()->getAttr<DLLExportAttr>()) {
7082 DLLExportAttr *NewAttr = ParentExportAttr->clone(S.
Context);
7083 NewAttr->setInherited(
true);
7127 if (!
D->isInExternCContext() ||
D->template hasAttr<OverloadableAttr>())
7131 if (S.
getLangOpts().CUDA && (
D->template hasAttr<CUDADeviceAttr>() ||
7132 D->template hasAttr<CUDAHostAttr>()))
7135 return D->isExternC();
7141 isa<OMPDeclareMapperDecl>(DC))
7150 if (isa<RequiresExprBodyDecl>(DC))
7152 llvm_unreachable(
"Unexpected context");
7158 isa<OMPDeclareReductionDecl>(DC) || isa<OMPDeclareMapperDecl>(DC))
7162 llvm_unreachable(
"Unexpected context");
7207 if (
const auto *FD = dyn_cast<FunctionDecl>(
D))
7208 return FD->isExternC();
7209 if (
const auto *VD = dyn_cast<VarDecl>(
D))
7210 return VD->isExternC();
7212 llvm_unreachable(
"Unknown type of decl!");
7225 diag::err_opencl_type_can_only_be_used_as_function_parameter)
7239 diag::err_invalid_type_for_program_scope_var)
7268 Se.
Diag(NewVD->
getLocation(), diag::err_opencl_half_declaration) << R;
7301 Se.
Diag(NewVD->
getLocation(), diag::err_opencl_nonconst_global_sampler);
7311template <
typename AttrTy>
7314 if (
const auto *Attribute = TND->
getAttr<AttrTy>()) {
7315 AttrTy *Clone = Attribute->clone(S.
Context);
7316 Clone->setInherited(
true);
7344 if (
const auto *ConstDecl = RD->
getAttr<ReadOnlyPlacementAttr>()) {
7346 S.
Diag(ConstDecl->getLocation(), diag::note_enforce_read_only_placement);
7359 bool IsPlaceholderVariable =
false;
7361 if (
D.isDecompositionDeclarator()) {
7364 auto &Decomp =
D.getDecompositionDeclarator();
7365 if (!Decomp.bindings().empty()) {
7366 II = Decomp.bindings()[0].Name;
7370 Diag(
D.getIdentifierLoc(), diag::err_bad_variable_name) << Name;
7380 IsPlaceholderVariable =
true;
7398 bool IsLocalExternDecl = SC ==
SC_Extern &&
7404 Diag(
D.getIdentifierLoc(), diag::err_mutable_nonmember);
7411 D.getDeclSpec().getStorageClassSpecLoc())) {
7415 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
7417 : diag::warn_deprecated_register)
7423 if (!DC->
isRecord() && S->getFnParent() ==
nullptr) {
7428 Diag(
D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
7440 const AutoType *AT = TL.getTypePtr();
7444 bool IsMemberSpecialization =
false;
7445 bool IsVariableTemplateSpecialization =
false;
7447 bool IsVariableTemplate =
false;
7458 if (
D.isInvalidType())
7471 D.getCXXScopeSpec(),
7473 ?
D.getName().TemplateId
7476 false, IsMemberSpecialization,
Invalid);
7478 if (TemplateParams) {
7479 if (!TemplateParams->
size() &&
7484 diag::err_template_variable_noparams)
7488 TemplateParams =
nullptr;
7496 IsVariableTemplateSpecialization =
true;
7500 IsVariableTemplate =
true;
7503 Diag(
D.getIdentifierLoc(),
7505 ? diag::warn_cxx11_compat_variable_template
7506 : diag::ext_variable_template);
7511 if (!TemplateParamLists.empty() && IsMemberSpecialization &&
7516 "should have a 'template<>' for this decl");
7519 bool IsExplicitSpecialization =
7530 (IsExplicitSpecialization || IsMemberSpecialization)) {
7531 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
7532 diag::ext_explicit_specialization_storage_class)
7538 if (
const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
7544 if (Ctxt->isFunctionOrMethod()) {
7545 FunctionOrMethod = Ctxt;
7548 const CXXRecordDecl *ParentDecl = dyn_cast<CXXRecordDecl>(Ctxt);
7550 AnonStruct = ParentDecl;
7554 if (FunctionOrMethod) {
7557 Diag(
D.getIdentifierLoc(),
7558 diag::err_static_data_member_not_allowed_in_local_class)
7559 << Name << RD->getDeclName()
7560 << llvm::to_underlying(RD->getTagKind());
7561 }
else if (AnonStruct) {
7565 Diag(
D.getIdentifierLoc(),
7566 diag::err_static_data_member_not_allowed_in_anon_struct)
7567 << Name << llvm::to_underlying(AnonStruct->
getTagKind());
7569 }
else if (RD->isUnion()) {
7572 Diag(
D.getIdentifierLoc(),
7574 ? diag::warn_cxx98_compat_static_data_member_in_union
7575 : diag::ext_static_data_member_in_union)
7581 Diag(
D.getIdentifierLoc(), diag::err_template_member)
7592 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
7593 diag::err_static_out_of_line)
7595 D.getDeclSpec().getStorageClassSpecLoc());
7605 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
7606 diag::err_storage_class_for_static_member)
7608 D.getDeclSpec().getStorageClassSpecLoc());
7611 llvm_unreachable(
"C storage class in c++!");
7615 if (IsVariableTemplateSpecialization) {
7617 TemplateParamLists.size() > 0
7618 ? TemplateParamLists[0]->getTemplateLoc()
7621 S,
D, TInfo,
Previous, TemplateKWLoc, TemplateParams, SC,
7625 NewVD = cast<VarDecl>(Res.
get());
7627 }
else if (
D.isDecompositionDeclarator()) {
7629 D.getIdentifierLoc(), R, TInfo, SC,
7633 D.getIdentifierLoc(), II, R, TInfo, SC);
7636 if (IsVariableTemplate) {
7639 TemplateParams, NewVD);
7648 if (
D.isInvalidType() ||
Invalid) {
7660 unsigned VDTemplateParamLists =
7661 (TemplateParams && !IsExplicitSpecialization) ? 1 : 0;
7662 if (TemplateParamLists.size() > VDTemplateParamLists)
7664 Context, TemplateParamLists.drop_back(VDTemplateParamLists));
7667 if (
D.getDeclSpec().isInlineSpecified()) {
7669 Diag(
D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
7673 Diag(
D.getDeclSpec().getInlineSpecLoc(),
7674 diag::err_inline_declaration_block_scope) << Name
7677 Diag(
D.getDeclSpec().getInlineSpecLoc(),
7679 : diag::ext_inline_variable);
7690 if (IsLocalExternDecl) {
7691 if (
D.isDecompositionDeclarator())
7693 B->setLocalExternDecl();
7698 bool EmitTLSUnsupportedError =
false;
7699 if (
DeclSpec::TSCS TSCS =
D.getDeclSpec().getThreadStorageClassSpec()) {
7710 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
7711 diag::err_thread_non_global)
7719 EmitTLSUnsupportedError =
true;
7725 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
7726 diag::err_thread_unsupported);
7731 switch (
D.getDeclSpec().getConstexprSpecifier()) {
7736 Diag(
D.getDeclSpec().getConstexprSpecLoc(),
7737 diag::err_constexpr_wrong_decl_kind)
7738 <<
static_cast<int>(
D.getDeclSpec().getConstexprSpecifier());
7754 Diag(
D.getDeclSpec().getConstexprSpecLoc(),
7755 diag::err_constinit_local_variable);
7758 ConstInitAttr::Create(
Context,
D.getDeclSpec().getConstexprSpecLoc(),
7759 ConstInitAttr::Keyword_constinit));
7772 if (SC ==
SC_Static && S->getFnParent() !=
nullptr &&
7776 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
7777 diag::warn_static_local_in_extern_inline);
7782 if (
D.getDeclSpec().isModulePrivateSpecified()) {
7783 if (IsVariableTemplateSpecialization)
7787 D.getDeclSpec().getModulePrivateSpecLoc());
7788 else if (IsMemberSpecialization)
7795 <<
SourceRange(
D.getDeclSpec().getModulePrivateSpecLoc())
7797 D.getDeclSpec().getModulePrivateSpecLoc());
7803 B->setModulePrivate();
7812 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
7813 diag::err_opencl_unknown_type_specifier)
7823 if (
const auto *ATy = dyn_cast<ArrayType>(NewVD->
getType())) {
7824 if (ATy && ATy->getElementType().isWebAssemblyReferenceType() &&
7841 copyAttrFromTypedefToDecl<AllocSizeAttr>(*
this, NewVD, TT);
7845 if (EmitTLSUnsupportedError &&
7848 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(NewVD))))
7849 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
7850 diag::err_thread_unsupported);
7852 if (EmitTLSUnsupportedError &&
7855 targetDiag(
D.getIdentifierLoc(), diag::err_thread_unsupported);
7858 if (SC ==
SC_None && S->getFnParent() !=
nullptr &&
7859 (NewVD->
hasAttr<CUDASharedAttr>() ||
7860 NewVD->
hasAttr<CUDAConstantAttr>())) {
7868 assert(!NewVD->
hasAttr<DLLImportAttr>() ||
7869 NewVD->
getAttr<DLLImportAttr>()->isInherited() ||
7874 if (
getLangOpts().ObjCAutoRefCount &&
ObjC().inferObjCARCLifetime(NewVD))
7882 if (S->getFnParent() !=
nullptr) {
7903 bool HasSizeMismatch;
7905 if (!TI.isValidGCCRegisterName(
Label))
7907 else if (!TI.validateGlobalRegisterVariable(
Label,
7911 else if (HasSizeMismatch)
7925 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
7938 NamedDecl *ShadowedDecl =
D.getCXXScopeSpec().isEmpty()
7946 D.getCXXScopeSpec().isNotEmpty() ||
7947 IsMemberSpecialization ||
7948 IsVariableTemplateSpecialization);
7962 if (IsMemberSpecialization && !IsVariableTemplateSpecialization &&
7969 isa<FieldDecl>(
Previous.getFoundDecl()) &&
7970 D.getCXXScopeSpec().isSet()) {
7974 <<
D.getCXXScopeSpec().getRange();
7978 }
else if (
D.getCXXScopeSpec().isSet() &&
7979 !IsVariableTemplateSpecialization) {
7981 Diag(
D.getIdentifierLoc(), diag::err_no_member)
7983 <<
D.getCXXScopeSpec().getRange();
7987 if (!IsPlaceholderVariable)
8010 (
D.getCXXScopeSpec().isSet() && DC && DC->
isRecord() &&
8018 if (PrevVarTemplate &&
8025 if (!IsPlaceholderVariable && ShadowedDecl && !
D.isRedeclaration())
8038 Decl *ManglingContextDecl;
8039 std::tie(MCtx, ManglingContextDecl) =
8050 if (Name.getAsIdentifierInfo() && Name.getAsIdentifierInfo()->isStr(
"main") &&
8065 if (
D.isRedeclaration() && !
Previous.empty()) {
8068 D.isFunctionDefinition());
8100 if (isa<TypeAliasDecl>(ShadowedDecl))
8102 else if (isa<TypedefDecl>(ShadowedDecl))
8104 else if (isa<BindingDecl>(ShadowedDecl))
8106 else if (isa<RecordDecl>(OldDC))
8139 if (
D->hasGlobalStorage() && !
D->isStaticLocal())
8143 return isa<VarDecl, FieldDecl, BindingDecl>(ShadowedDecl) ? ShadowedDecl
8157 return isa<TypedefNameDecl>(ShadowedDecl) ? ShadowedDecl :
nullptr;
8166 return isa<VarDecl, FieldDecl, BindingDecl>(ShadowedDecl) ? ShadowedDecl
8174 if (
FieldDecl *FD = dyn_cast<FieldDecl>(ShadowedDecl)) {
8182 if (isa<CXXConstructorDecl>(NewDC))
8183 if (
const auto PVD = dyn_cast<ParmVarDecl>(
D)) {
8186 ShadowingDecls.insert({PVD->getCanonicalDecl(), FD});
8191 if (
VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
8192 if (shadowedVar->isExternC()) {
8195 for (
auto *I : shadowedVar->redecls())
8196 if (I->isFileVarDecl()) {
8204 unsigned WarningDiag = diag::warn_decl_shadow;
8206 if (isa<VarDecl>(
D) && NewDC && isa<CXXMethodDecl>(NewDC)) {
8207 if (
const auto *RD = dyn_cast<CXXRecordDecl>(NewDC->
getParent())) {
8209 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl)) {
8211 if (RD->getLambdaCaptureDefault() ==
LCD_None) {
8217 WarningDiag = diag::warn_decl_shadow_uncaptured_local;
8223 ->ShadowingDecls.push_back({
D, VD});
8227 if (isa<FieldDecl>(ShadowedDecl)) {
8234 ->ShadowingDecls.push_back({
D, ShadowedDecl});
8238 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl);
8239 VD && VD->hasLocalStorage()) {
8243 ParentDC && !ParentDC->
Equals(OldDC);
8247 if (!isa<BlockDecl>(ParentDC) && !isa<CapturedDecl>(ParentDC) &&
8281 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
8288 const NamedDecl *ShadowedDecl = Shadow.ShadowedDecl;
8291 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl)) {
8293 Diag(Shadow.VD->getLocation(),
8294 CaptureLoc.
isInvalid() ? diag::warn_decl_shadow_uncaptured_local
8295 : diag::warn_decl_shadow)
8296 << Shadow.VD->getDeclName()
8299 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
8300 << Shadow.VD->getDeclName() << 0;
8302 }
else if (isa<FieldDecl>(ShadowedDecl)) {
8303 Diag(Shadow.VD->getLocation(),
8305 : diag::warn_decl_shadow_uncaptured_local)
8306 << Shadow.VD->getDeclName()
8319 RedeclarationKind::ForVisibleRedeclaration);
8332 auto *DRE = dyn_cast<DeclRefExpr>(
E);
8335 const NamedDecl *
D = cast<NamedDecl>(DRE->getDecl()->getCanonicalDecl());
8336 auto I = ShadowingDecls.find(
D);
8337 if (I == ShadowingDecls.end())
8339 const NamedDecl *ShadowedDecl = I->second;
8341 Diag(
Loc, diag::warn_modifying_shadowing_decl) <<
D << OldDC;
8346 ShadowingDecls.erase(I);
8354 assert(S.
getLangOpts().CPlusPlus &&
"only C++ has extern \"C\"");
8375 if (!isa<VarDecl>(ND))
8385 if (isa<VarDecl>(*I)) {
8395 if (isa<VarDecl>(*I)) {
8413 assert(Prev &&
"should have found a previous declaration to diagnose");
8415 Prev = FD->getFirstDecl();
8417 Prev = cast<VarDecl>(Prev)->getFirstDecl();
8419 S.
Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
8441 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
8453 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
8473 SemaRef.
Diag(VarLoc, diag::err_c23_constexpr_invalid_type) <<
T;
8483 SemaRef.
Diag(VarLoc, diag::err_c23_constexpr_invalid_type) <<
T;
8489 if (llvm::any_of(RD->
fields(), [&SemaRef, VarLoc](
const FieldDecl *F) {
8490 return CheckC23ConstexprVarType(SemaRef, VarLoc, F->getType());
8546 if (NewVD->
hasAttr<BlocksAttr>()) {
8554 if (!
T.isConstQualified()) {
8555 Diag(NewVD->
getLocation(), diag::err_opencl_invalid_block_declaration)
8561 Diag(NewVD->
getLocation(), diag::err_opencl_extern_block_declaration);
8577 Diag(NewVD->
getLocation(), diag::err_opencl_global_invalid_addr_space)
8578 <<
Scope <<
"global or constant";
8580 Diag(NewVD->
getLocation(), diag::err_opencl_global_invalid_addr_space)
8581 <<
Scope <<
"constant";
8597 if (FD && !FD->
hasAttr<OpenCLKernelAttr>()) {
8609 if (FD && FD->
hasAttr<OpenCLKernelAttr>()) {
8634 && !NewVD->
hasAttr<BlocksAttr>()) {
8656 const auto *ATy = dyn_cast<ConstantArrayType>(
T.getTypePtr());
8657 if (!ATy || ATy->getZExtSize() != 0) {
8659 diag::err_typecheck_wasm_table_must_have_zero_length);
8666 if (isVM || NewVD->
hasAttr<CleanupAttr>() ||
8672 bool SizeIsNegative;
8673 llvm::APSInt Oversized;
8678 FixedT = FixedTInfo->
getType();
8679 else if (FixedTInfo) {
8736 !
T.isWebAssemblyReferenceType()) {
8742 if (isVM && NewVD->
hasAttr<BlocksAttr>()) {
8756 diag::err_constexpr_var_non_literal)) {
8772 llvm::StringMap<bool> CallerFeatureMap;
8783 diag::err_sve_vector_in_non_streaming_function)
8793 llvm::StringMap<bool> CallerFeatureMap;
8839 dyn_cast<CXXMethodDecl>(BaseND->getCanonicalDecl());
8846 if (Overridden.insert(BaseMD).second) {
8863 return !Overridden.empty();
8869 struct ActOnFDArgs {
8885 : Context(Context), OriginalFD(TypoFD),
8888 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
8894 CDeclEnd = candidate.
end();
8895 CDecl != CDeclEnd; ++CDecl) {
8902 if (
Parent &&
Parent->getCanonicalDecl() == ExpectedParent)
8904 }
else if (!ExpectedParent) {
8913 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
8914 return std::make_unique<DifferentNameValidatorCCC>(*
this);
8940 ActOnFDArgs &ExtraArgs,
bool IsLocalFriend,
Scope *S) {
8946 bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
8948 IsLocalFriend ? diag::err_no_matching_local_friend :
8950 diag::err_member_decl_does_not_match;
8954 RedeclarationKind::ForVisibleRedeclaration);
8962 "Cannot have an ambiguity in previous-declaration lookup");
8964 DifferentNameValidatorCCC CCC(SemaRef.
Context, NewFD,
8966 if (!Prev.
empty()) {
8975 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
8976 NearMatches.push_back(std::make_pair(FD, ParamNum));
8983 IsLocalFriend ?
nullptr : NewDC))) {
8986 ExtraArgs.D.getIdentifierLoc());
8990 CDeclEnd = Correction.
end();
8991 CDecl != CDeclEnd; ++CDecl) {
8998 bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
9011 ExtraArgs.S, ExtraArgs.D,
9014 ExtraArgs.AddToScope);
9022 Decl *Canonical =
Result->getCanonicalDecl();
9025 if ((*I)->getCanonicalDecl() == Canonical)
9032 SemaRef.
PDiag(IsLocalFriend
9033 ? diag::err_no_matching_local_friend_suggest
9034 : diag::err_member_decl_does_not_match_suggest)
9035 << Name << NewDC << IsDefinition);
9040 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
9041 ExtraArgs.D.getIdentifierLoc());
9042 ExtraArgs.D.setRedeclaration(wasRedeclaration);
9048 << Name << NewDC << IsDefinition << NewFD->
getLocation();
9050 bool NewFDisConst =
false;
9052 NewFDisConst = NewMD->isConst();
9055 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
9056 NearMatch != NearMatchEnd; ++NearMatch) {
9059 bool FDisConst = MD && MD->
isConst();
9060 bool IsMember = MD || !IsLocalFriend;
9063 if (
unsigned Idx = NearMatch->second) {
9067 SemaRef.
Diag(
Loc, IsMember ? diag::note_member_def_close_param_match
9068 : diag::note_local_decl_close_param_match)
9071 }
else if (FDisConst != NewFDisConst) {
9073 diag::note_member_def_close_const_match)
9075 if (
const auto &FTI = ExtraArgs.D.getFunctionTypeInfo(); !NewFDisConst)
9078 else if (FTI.hasMethodTypeQualifiers() &&
9079 FTI.getConstQualifierLoc().isValid())
9083 IsMember ? diag::note_member_def_close_match
9084 : diag::note_local_decl_close_match);
9091 switch (
D.getDeclSpec().getStorageClassSpec()) {
9092 default: llvm_unreachable(
"Unknown storage class!");
9096 SemaRef.
Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
9097 diag::err_typecheck_sclass_func);
9098 D.getMutableDeclSpec().ClearStorageClassSpecs();
9103 if (
D.getDeclSpec().isExternInLinkageSpec())
9113 SemaRef.
Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
9114 diag::err_static_block_func);
9130 bool &IsVirtualOkay) {
9135 bool isInline =
D.getDeclSpec().isInlineSpecified();
9143 SemaRef.
Diag(
D.getDeclSpec().getConstexprSpecLoc(),
9144 diag::err_c23_constexpr_not_variable);
9146 SemaRef.
Diag(
D.getDeclSpec().getConstexprSpecLoc(),
9147 diag::err_constexpr_wrong_decl_kind)
9148 <<
static_cast<int>(ConstexprKind);
9150 D.getMutableDeclSpec().ClearConstexprSpec();
9165 (
D.isFunctionDeclarator() &&
D.getFunctionTypeInfo().hasPrototype) ||
9166 (
D.getDeclSpec().isTypeRep() &&
9168 ->isFunctionProtoType()) ||
9172 "Strict prototypes are required");
9179 if (
D.isInvalidType())
9186 Expr *TrailingRequiresClause =
D.getTrailingRequiresClause();
9193 "Constructors can only be declared in a member context");
9199 isInline,
false, ConstexprKind,
9210 false, ConstexprKind,
9211 TrailingRequiresClause);
9214 if (
Record->isBeingDefined())
9223 IsVirtualOkay =
true;
9227 SemaRef.
Diag(
D.getIdentifierLoc(), diag::err_destructor_not_member);
9235 true, ConstexprKind, TrailingRequiresClause);
9240 SemaRef.
Diag(
D.getIdentifierLoc(),
9241 diag::err_conv_function_not_member);
9246 if (
D.isInvalidType())
9249 IsVirtualOkay =
true;
9254 TrailingRequiresClause);
9257 if (TrailingRequiresClause)
9259 diag::err_trailing_requires_clause_on_deduction_guide)
9271 if (Name.getAsIdentifierInfo() &&
9272 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
9273 SemaRef.
Diag(
D.getIdentifierLoc(), diag::err_constructor_return_type)
9284 IsVirtualOkay = !Ret->isStatic();
9288 SemaRef.
getLangOpts().CPlusPlus &&
D.getDeclSpec().isFriendSpecified();
9298 true , ConstexprKind, TrailingRequiresClause);
9315 StringRef SizeTypeNames[] = {
"size_t",
"intptr_t",
"uintptr_t",
"ptrdiff_t"};
9323 if (Names.end() != Match)
9328 }
while (DesugaredTy != Ty);
9367 "__cl_clang_non_portable_kernel_param_types", S.
getLangOpts())) {
9369 bool IsStandardLayoutType =
true;
9375 if (!CXXRec->hasDefinition())
9377 if (!CXXRec || !CXXRec->hasDefinition() || !CXXRec->isStandardLayout())
9378 IsStandardLayoutType =
false;
9381 !IsStandardLayoutType)
9429 "__cl_clang_non_portable_kernel_param_types", S.
getLangOpts()) &&
9443 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
9490 S.
Diag(
Loc, diag::note_entity_declared_at) << PT;
9513 HistoryStack.push_back(
nullptr);
9522 VisitStack.push_back(RecTy->
getDecl());
9523 assert(VisitStack.back() &&
"First decl null?");
9526 const Decl *Next = VisitStack.pop_back_val();
9528 assert(!HistoryStack.empty());
9530 if (
const FieldDecl *Hist = HistoryStack.pop_back_val())
9531 ValidTypes.insert(Hist->getType().getTypePtr());
9539 if (
const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
9540 HistoryStack.push_back(Field);
9542 QualType FieldTy = Field->getType();
9546 "Unexpected type.");
9551 RD = cast<RecordDecl>(Next);
9555 VisitStack.push_back(
nullptr);
9557 for (
const auto *FD : RD->
fields()) {
9568 VisitStack.push_back(FD);
9580 diag::err_record_with_pointers_kernel_param)
9587 S.
Diag(OrigRecDecl->getLocation(), diag::note_within_field_of_type)
9588 << OrigRecDecl->getDeclName();
9593 I = HistoryStack.begin() + 1,
9594 E = HistoryStack.end();
9607 }
while (!VisitStack.empty());
9623 while (S->isClassScope() ||
9624 (LangOpts.CPlusPlus &&
9625 S->isFunctionPrototypeScope()) ||
9627 (S->getEntity() && S->getEntity()->isTransparentContext()))
9634 unsigned BuiltinID) {
9635 switch (BuiltinID) {
9636 case Builtin::BI__GetExceptionInfo:
9640 case Builtin::BIaddressof:
9641 case Builtin::BI__addressof:
9642 case Builtin::BIforward:
9643 case Builtin::BIforward_like:
9644 case Builtin::BImove:
9645 case Builtin::BImove_if_noexcept:
9646 case Builtin::BIas_const: {
9668 Diag(
D.getIdentifierLoc(), diag::err_function_decl_cmse_ns_call);
9671 llvm::append_range(TemplateParamLists, TemplateParamListsRef);
9673 if (!TemplateParamLists.empty() && !TemplateParamLists.back()->empty() &&
9674 Invented->getDepth() == TemplateParamLists.back()->getDepth())
9675 TemplateParamLists.back() = Invented;
9677 TemplateParamLists.push_back(Invented);
9685 if (
DeclSpec::TSCS TSCS =
D.getDeclSpec().getThreadStorageClassSpec())
9686 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
9687 diag::err_invalid_thread)
9690 if (
D.isFirstDeclarationOfMember())
9692 R, !(
D.isStaticMember() ||
D.isExplicitObjectMemberFunction()),
9693 D.isCtorOrDtor(),
D.getIdentifierLoc());
9695 bool isFriend =
false;
9697 bool isMemberSpecialization =
false;
9698 bool isFunctionTemplateSpecialization =
false;
9700 bool HasExplicitTemplateArgs =
false;
9703 bool isVirtualOkay =
false;
9710 if (!NewFD)
return nullptr;
9720 if (IsLocalExternDecl)
9729 bool ImplicitInlineCXX20 = !
getLangOpts().CPlusPlusModules ||
9733 bool isInline =
D.getDeclSpec().isInlineSpecified();
9734 bool isVirtual =
D.getDeclSpec().isVirtualSpecified();
9735 bool hasExplicit =
D.getDeclSpec().hasExplicitSpecifier();
9736 isFriend =
D.getDeclSpec().isFriendSpecified();
9737 if (isFriend && !isInline &&
D.isFunctionDefinition()) {
9752 if (
Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
9757 if (isVirtual &&
Parent->isUnion()) {
9758 Diag(
D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_in_union);
9762 Parent->hasAttr<SYCLSpecialClassAttr>() &&
9764 NewFD->
getName() ==
"__init" &&
D.isFunctionDefinition()) {
9765 if (
auto *Def =
Parent->getDefinition())
9766 Def->setInitMethod(
true);
9771 isMemberSpecialization =
false;
9772 isFunctionTemplateSpecialization =
false;
9773 if (
D.isInvalidType())
9781 ?
D.getName().TemplateId
9786 D.getCXXScopeSpec(), TemplateId, TemplateParamLists, isFriend,
9787 isMemberSpecialization,
Invalid);
9788 if (TemplateParams) {
9793 if (TemplateParams->
size() > 0) {
9801 }
else if (TemplateId) {
9802 Diag(
D.getIdentifierLoc(), diag::err_function_template_partial_spec)
9818 Name, TemplateParams,
9824 if (TemplateParamLists.size() > 1) {
9831 isFunctionTemplateSpecialization =
true;
9833 if (TemplateParamLists.size() > 0)
9852 Diag(
D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
9853 << Name << RemoveRange
9859 HasExplicitTemplateArgs =
true;
9866 if (!TemplateParamLists.empty() && isMemberSpecialization &&
9872 if (TemplateParamLists.size() > 0)
9877 if (isFriend && TemplateId)
9878 isFunctionTemplateSpecialization =
true;
9884 if (isFunctionTemplateSpecialization && TemplateId) {
9885 HasExplicitTemplateArgs =
true;
9916 if (!isVirtualOkay) {
9917 Diag(
D.getDeclSpec().getVirtualSpecLoc(),
9918 diag::err_virtual_non_function);
9921 Diag(
D.getDeclSpec().getVirtualSpecLoc(),
9922 diag::err_virtual_out_of_class)
9927 Diag(
D.getDeclSpec().getVirtualSpecLoc(),
9928 diag::err_virtual_member_function_template)
9937 Diag(
D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual);
9946 Diag(
D.getDeclSpec().getInlineSpecLoc(),
9947 diag::err_inline_declaration_block_scope) << Name
9957 !isa<CXXDeductionGuideDecl>(NewFD)) {
9960 Diag(
D.getDeclSpec().getExplicitSpecLoc(),
9961 diag::err_explicit_out_of_class)
9963 }
else if (!isa<CXXConstructorDecl>(NewFD) &&
9964 !isa<CXXConversionDecl>(NewFD)) {
9967 Diag(
D.getDeclSpec().getExplicitSpecLoc(),
9968 diag::err_explicit_non_ctor_or_conv_function)
9982 if (isa<CXXDestructorDecl>(NewFD) &&
9985 Diag(
D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor)
9986 <<
static_cast<int>(ConstexprKind);
9999 Diag(
D.getDeclSpec().getConstexprSpecLoc(),
10000 diag::err_invalid_consteval_decl_kind)
10007 if (
D.getDeclSpec().isModulePrivateSpecified()) {
10008 if (isFunctionTemplateSpecialization) {
10010 =
D.getDeclSpec().getModulePrivateSpecLoc();
10011 Diag(ModulePrivateLoc, diag::err_module_private_specialization)
10032 switch (
D.getFunctionDefinitionKind()) {
10046 if (isa<CXXMethodDecl>(NewFD) && DC ==
CurContext &&
10047 D.isFunctionDefinition() && !isInline) {
10057 if (!isFriend && SC !=
SC_None) {
10065 if (isFunctionTemplateSpecialization || isMemberSpecialization) {
10066 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
10067 diag::ext_explicit_specialization_storage_class)
10069 D.getDeclSpec().getStorageClassSpecLoc());
10073 assert(isa<CXXMethodDecl>(NewFD) &&
10074 "Out-of-line member function should be a CXXMethodDecl");
10086 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
10088 cast<CXXRecordDecl>(DC)->getDescribedClassTemplate()) ||
10091 ? diag::ext_static_out_of_line
10092 : diag::err_static_out_of_line)
10094 D.getDeclSpec().getStorageClassSpecLoc());
10102 if ((Name.getCXXOverloadedOperator() == OO_Delete ||
10103 Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
10116 if (isInline && !
D.isFunctionDefinition() &&
getLangOpts().CPlusPlus20 &&
10118 PendingInlineFuncDecls.insert(NewFD);
10124 D.getCXXScopeSpec().isNotEmpty() ||
10125 isMemberSpecialization ||
10126 isFunctionTemplateSpecialization);
10136 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
10152 if (
D.isFunctionDeclarator(FTIIdx)) {
10161 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
10165 Params.push_back(Param);
10180 auto *TD = dyn_cast<TagDecl>(NonParmDecl);
10185 if (
auto *ECD = dyn_cast<EnumConstantDecl>(NonParmDecl))
10186 TD = cast<EnumDecl>(ECD->getDeclContext());
10190 DeclContext *TagDC = TD->getLexicalDeclContext();
10194 TD->setDeclContext(NewFD);
10202 if (TagDC != PrototypeTagContext)
10203 TD->setLexicalDeclContext(TagDC);
10217 for (
const auto &AI : FT->param_types()) {
10221 Params.push_back(Param);
10225 "Should not need args for typedef of non-prototype fn");
10229 NewFD->setParams(Params);
10231 if (
D.getDeclSpec().isNoreturnSpecified())
10233 C11NoReturnAttr::Create(
Context,
D.getDeclSpec().getNoreturnSpecLoc()));
10245 !NewFD->
hasAttr<SectionAttr>())
10246 NewFD->
addAttr(PragmaClangTextSectionAttr::CreateImplicit(
10251 if (
CodeSegStack.CurrentValue &&
D.isFunctionDefinition() &&
10252 !NewFD->
hasAttr<SectionAttr>()) {
10253 NewFD->
addAttr(SectionAttr::CreateImplicit(
10255 CodeSegStack.CurrentPragmaLocation, SectionAttr::Declspec_allocate));
10266 !NewFD->
hasAttr<StrictGuardStackCheckAttr>())
10267 NewFD->
addAttr(StrictGuardStackCheckAttr::CreateImplicit(
10272 if (!NewFD->
hasAttr<CodeSegAttr>()) {
10274 D.isFunctionDefinition())) {
10281 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
10282 if (NewTVA && !NewTVA->isDefaultVersion() &&
10285 AddToScope =
false;
10297 Diag(NewFD->
getLocation(), diag::err_return_value_with_address_space);
10312 isMemberSpecialization,
10313 D.isFunctionDefinition()));
10316 D.setRedeclaration(
true);
10319 "previous declaration set still overloaded");
10325 if (isa<FunctionNoProtoType>(FT) && !
D.isFunctionDefinition()) {
10331 CC ==
CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
10350 if (
D.getDeclSpec().isInlineSpecified() &&
10353 Diag(
D.getDeclSpec().getInlineSpecLoc(),
10354 diag::ext_operator_new_delete_declared_inline)
10381 if (isFunctionTemplateSpecialization || isMemberSpecialization) {
10393 Diag(TRC->getBeginLoc(), diag::err_non_temp_spec_requires_clause)
10396 !
D.isFunctionDefinition()) {
10401 diag::err_non_temp_friend_decl_with_requires_clause_must_be_def);
10404 !(isa<CXXMethodDecl>(NewFD) ||
D.isFunctionDefinition())) {
10405 Diag(TRC->getBeginLoc(),
10406 diag::err_constrained_non_templated_function);
10423 if (isFunctionTemplateSpecialization) {
10424 bool isDependentSpecialization =
false;
10429 isDependentSpecialization =
10431 (HasExplicitTemplateArgs &&
10435 assert((!isDependentSpecialization ||
10436 (HasExplicitTemplateArgs == isDependentSpecialization)) &&
10437 "dependent friend function specialization without template "
10443 isDependentSpecialization =
10448 HasExplicitTemplateArgs ? &TemplateArgs :
nullptr;
10449 if (isDependentSpecialization) {
10456 NewFD, ExplicitTemplateArgs,
Previous))
10463 }
else if (isMemberSpecialization && isa<CXXMethodDecl>(NewFD)) {
10477 isMemberSpecialization,
10478 D.isFunctionDefinition()));
10481 D.setRedeclaration(
true);
10484 !
D.isRedeclaration() ||
10486 "previous declaration set still overloaded");
10513 D.getDeclSpec().isFriendSpecified()
10514 ? (
D.isFunctionDefinition()
10517 : (
D.getCXXScopeSpec().isSet() &&
10526 }
else if (!
D.isRedeclaration()) {
10527 struct ActOnFDArgs ExtraArgs = { S,
D, TemplateParamLists,
10534 if (
D.getCXXScopeSpec().isSet()) {
10549 (
D.getCXXScopeSpec().getScopeRep()->isDependent() ||
10573 *
this,
Previous, NewFD, ExtraArgs,
false,
nullptr)) {
10574 AddToScope = ExtraArgs.AddToScope;
10581 }
else if (isFriend && cast<CXXRecordDecl>(
CurContext)->isLocalClass()) {
10583 *
this,
Previous, NewFD, ExtraArgs,
true, S)) {
10584 AddToScope = ExtraArgs.AddToScope;
10588 }
else if (!
D.isFunctionDefinition() &&
10589 isa<CXXMethodDecl>(NewFD) && NewFD->
isOutOfLine() &&
10590 !isFriend && !isFunctionTemplateSpecialization &&
10591 !isMemberSpecialization) {
10600 <<
D.getCXXScopeSpec().getRange();
10606 if (!NewFD->
isInvalidDecl() && S->getDepth() == 0 && Name.isIdentifier())
10609 if (NewFD->
hasAttr<HLSLShaderAttr>())
10615 if (!
D.isRedeclaration()) {
10617 if (
unsigned BuiltinID = II->getBuiltinID()) {
10619 if (!InStdNamespace &&
10625 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10634 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10639 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10650 if (NewFD->
hasAttr<OverloadableAttr>() &&
10653 diag::err_attribute_overloadable_no_prototype)
10655 NewFD->
dropAttr<OverloadableAttr>();
10669 if (
D.isFunctionDefinition()) {
10685 if (
D.isRedeclaration() && !
Previous.empty()) {
10688 isMemberSpecialization ||
10689 isFunctionTemplateSpecialization,
10690 D.isFunctionDefinition());
10695 if (II && II->
isStr(
CUDA().getConfigureFuncName()) &&
10708 (NewFD->
hasAttr<CUDADeviceAttr>() ||
10709 NewFD->
hasAttr<CUDAGlobalAttr>()) &&
10711 !
D.isFunctionDefinition())) {
10723 Diag(
D.getIdentifierLoc(), diag::err_static_kernel);
10724 D.setInvalidType();
10730 Diag(
D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type)
10733 D.setInvalidType();
10742 Diag(
D.getIdentifierLoc(), diag::err_method_kernel);
10743 D.setInvalidType();
10746 Diag(
D.getIdentifierLoc(), diag::err_template_kernel);
10747 D.setInvalidType();
10762 if (!
D.isFunctionDefinition()) {
10764 diag::err_friend_decl_with_enclosing_temp_constraint_must_be_def);
10784 if (
getLangOpts().getOpenCLCompatibleVersion() >= 200) {
10786 QualType ElemTy = PipeTy->getElementType();
10788 Diag(Param->getTypeSpecStartLoc(), diag::err_reference_pipe_type );
10789 D.setInvalidType();
10796 Diag(Param->getTypeSpecStartLoc(),
10797 diag::err_wasm_table_as_function_parameter);
10798 D.setInvalidType();
10805 if (
const auto *
attr = NewFD->
getAttr<AvailabilityAttr>()) {
10806 if (NewFD->
hasAttr<ConstructorAttr>()) {
10807 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
10809 NewFD->
dropAttr<AvailabilityAttr>();
10811 if (NewFD->
hasAttr<DestructorAttr>()) {
10812 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
10814 NewFD->
dropAttr<AvailabilityAttr>();
10825 if (
const auto *NBA = NewFD->
getAttr<NoBuiltinAttr>())
10826 switch (
D.getFunctionDefinitionKind()) {
10829 Diag(NBA->getLocation(),
10830 diag::err_attribute_no_builtin_on_defaulted_deleted_function)
10831 << NBA->getSpelling();
10834 Diag(NBA->getLocation(), diag::err_attribute_no_builtin_on_non_definition)
10835 << NBA->getSpelling();
10863 const auto *Method = dyn_cast<CXXMethodDecl>(FD);
10867 if (
const auto *SAttr =
Parent->getAttr<CodeSegAttr>()) {
10878 while ((
Parent = dyn_cast<CXXRecordDecl>(
Parent->getParent()))) {
10879 if (
const auto *SAttr =
Parent->getAttr<CodeSegAttr>()) {
10889 bool IsDefinition) {
10892 if (!FD->
hasAttr<SectionAttr>() && IsDefinition &&
10894 return SectionAttr::CreateImplicit(
10896 CodeSegStack.CurrentPragmaLocation, SectionAttr::Declspec_allocate);
10944 auto *VD = dyn_cast<ValueDecl>(
D);
10945 auto *PrevVD = dyn_cast<ValueDecl>(PrevDecl);
10946 return !VD || !PrevVD ||
10948 PrevVD->getType());
10956 const auto *TA = FD->
getAttr<TargetAttr>();
10957 const auto *TVA = FD->
getAttr<TargetVersionAttr>();
10960 "MultiVersion candidate requires a target or target_version attribute");
10972 for (
const auto &Feat : ParseInfo.
Features) {
10973 auto BareFeat = StringRef{Feat}.substr(1);
10974 if (Feat[0] ==
'-') {
10976 << Feature << (
"no-" + BareFeat).str();
10983 << Feature << BareFeat;
10991 TVA->getFeatures(Feats);
10992 for (
const auto &Feat : Feats) {
10995 << Feature << Feat;
11014 case attr::NonNull:
11015 case attr::NoThrow:
11024 const auto Diagnose = [FD, CausedFD, MVKind](
Sema &S,
const Attr *A) {
11025 S.
Diag(FD->
getLocation(), diag::err_multiversion_disallowed_other_attr)
11026 <<
static_cast<unsigned>(MVKind) << A;
11028 S.
Diag(CausedFD->
getLocation(), diag::note_multiversioning_caused_here);
11033 switch (A->getKind()) {
11034 case attr::CPUDispatch:
11035 case attr::CPUSpecific:
11038 return Diagnose(S, A);
11042 return Diagnose(S, A);
11044 case attr::TargetVersion:
11047 return Diagnose(S, A);
11049 case attr::TargetClones:
11052 return Diagnose(S, A);
11056 return Diagnose(S, A);
11069 bool ConstexprSupported,
bool CLinkageMayDiffer) {
11070 enum DoesntSupport {
11077 DefaultedFuncs = 6,
11078 ConstexprFuncs = 7,
11079 ConstevalFuncs = 8,
11091 if (NoProtoDiagID.
getDiagID() != 0 && OldFD &&
11094 Diag(NoteCausedDiagIDAt.first, NoteCausedDiagIDAt.second);
11102 if (!TemplatesSupported &&
11104 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11107 if (
const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) {
11108 if (NewCXXFD->isVirtual())
11109 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11112 if (isa<CXXConstructorDecl>(NewCXXFD))
11113 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11116 if (isa<CXXDestructorDecl>(NewCXXFD))
11117 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11122 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11126 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11130 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11131 << (NewFD->
isConsteval() ? ConstevalFuncs : ConstexprFuncs);
11134 const auto *NewType = cast<FunctionType>(NewQType);
11135 QualType NewReturnType = NewType->getReturnType();
11138 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11144 const auto *OldType = cast<FunctionType>(OldQType);
11148 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC())
11151 QualType OldReturnType = OldType->getReturnType();
11153 if (OldReturnType != NewReturnType)
11154 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ReturnType;
11157 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ConstexprSpec;
11160 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << InlineSpec;
11163 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) <<
Linkage;
11187 bool IsCPUSpecificCPUDispatchMVKind =
11191 if (CausesMV && OldFD &&
11199 if (OldFD && CausesMV && OldFD->
isUsed(
false))
11200 return S.
Diag(NewFD->
getLocation(), diag::err_multiversion_after_used);
11203 OldFD, NewFD, S.
PDiag(diag::err_multiversion_noproto),
11205 S.
PDiag(diag::note_multiversioning_caused_here)),
11207 S.
PDiag(diag::err_multiversion_doesnt_support)
11208 <<
static_cast<unsigned>(MVKind)),
11210 S.
PDiag(diag::err_multiversion_diff)),
11212 !IsCPUSpecificCPUDispatchMVKind,
11225 "Function lacks multiversion attribute");
11226 const auto *TA = FD->
getAttr<TargetAttr>();
11227 const auto *TVA = FD->
getAttr<TargetVersionAttr>();
11230 if (TA && !TA->isDefaultVersion())
11234 if (TVA && TVA->isDefaultVersion())
11270 To->
addAttr(TargetVersionAttr::CreateImplicit(
11276 bool &Redeclaration,
11286 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11287 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11288 const auto *OldTA = OldFD->
getAttr<TargetAttr>();
11292 if (NewTA && !NewTA->isDefaultVersion() &&
11293 (!OldTA || OldTA->getFeaturesStr() == NewTA->getFeaturesStr()))
11298 if (NewTVA && NewTVA->isDefaultVersion())
11315 if (NewTA && NewTA->isDefaultVersion() && !OldTA) {
11316 Redeclaration =
true;
11324 S.
Diag(NewFD->
getLocation(), diag::note_multiversioning_caused_here);
11332 OldTA->getFeaturesStr());
11336 NewTA->getFeaturesStr());
11339 if (OldParsed == NewParsed) {
11347 for (
const auto *FD : OldFD->
redecls()) {
11348 const auto *CurTA = FD->
getAttr<TargetAttr>();
11349 const auto *CurTVA = FD->
getAttr<TargetVersionAttr>();
11353 ((NewTA && (!CurTA || CurTA->isInherited())) ||
11354 (NewTVA && (!CurTVA || CurTVA->isInherited())))) {
11356 << (NewTA ? 0 : 2);
11357 S.
Diag(NewFD->
getLocation(), diag::note_multiversioning_caused_here);
11365 Redeclaration =
false;
11404 const CPUDispatchAttr *NewCPUDisp,
const CPUSpecificAttr *NewCPUSpec,
11405 const TargetClonesAttr *NewClones,
bool &Redeclaration,
NamedDecl *&OldDecl,
11420 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11421 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11428 NewTA->getFeaturesStr());
11433 NewTVA->getFeatures(NewFeats);
11434 llvm::sort(NewFeats);
11437 bool UseMemberUsingDeclRules =
11440 bool MayNeedOverloadableChecks =
11449 if (MayNeedOverloadableChecks &&
11450 S.
IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
11453 switch (NewMVKind) {
11456 "Only target_clones can be omitted in subsequent declarations");
11459 const auto *CurTA = CurFD->
getAttr<TargetAttr>();
11460 if (CurTA->getFeaturesStr() == NewTA->getFeaturesStr()) {
11462 Redeclaration =
true;
11469 CurTA->getFeaturesStr());
11471 if (CurParsed == NewParsed) {
11480 if (
const auto *CurTVA = CurFD->
getAttr<TargetVersionAttr>()) {
11481 if (CurTVA->getName() == NewTVA->getName()) {
11483 Redeclaration =
true;
11488 CurTVA->getFeatures(CurFeats);
11489 llvm::sort(CurFeats);
11491 if (CurFeats == NewFeats) {
11497 }
else if (
const auto *CurClones = CurFD->
getAttr<TargetClonesAttr>()) {
11499 if (NewFeats.empty())
11502 for (
unsigned I = 0; I < CurClones->featuresStrs_size(); ++I) {
11504 CurClones->getFeatures(CurFeats, I);
11505 llvm::sort(CurFeats);
11507 if (CurFeats == NewFeats) {
11518 assert(NewClones &&
"MultiVersionKind does not match attribute type");
11519 if (
const auto *CurClones = CurFD->
getAttr<TargetClonesAttr>()) {
11520 if (CurClones->featuresStrs_size() != NewClones->featuresStrs_size() ||
11521 !std::equal(CurClones->featuresStrs_begin(),
11522 CurClones->featuresStrs_end(),
11523 NewClones->featuresStrs_begin())) {
11529 }
else if (
const auto *CurTVA = CurFD->
getAttr<TargetVersionAttr>()) {
11531 CurTVA->getFeatures(CurFeats);
11532 llvm::sort(CurFeats);
11535 if (CurFeats.empty())
11538 for (
unsigned I = 0; I < NewClones->featuresStrs_size(); ++I) {
11540 NewClones->getFeatures(NewFeats, I);
11541 llvm::sort(NewFeats);
11543 if (CurFeats == NewFeats) {
11552 Redeclaration =
true;
11559 const auto *CurCPUSpec = CurFD->
getAttr<CPUSpecificAttr>();
11560 const auto *CurCPUDisp = CurFD->
getAttr<CPUDispatchAttr>();
11565 CurFD->
hasAttr<CPUDispatchAttr>()) {
11566 if (CurCPUDisp->cpus_size() == NewCPUDisp->cpus_size() &&
11568 CurCPUDisp->cpus_begin(), CurCPUDisp->cpus_end(),
11569 NewCPUDisp->cpus_begin(),
11571 return Cur->getName() == New->getName();
11574 Redeclaration =
true;
11586 if (CurCPUSpec->cpus_size() == NewCPUSpec->cpus_size() &&
11588 CurCPUSpec->cpus_begin(), CurCPUSpec->cpus_end(),
11589 NewCPUSpec->cpus_begin(),
11591 return Cur->getName() == New->getName();
11594 Redeclaration =
true;
11602 if (CurII == NewII) {
11637 Redeclaration =
true;
11643 Redeclaration =
false;
11656 bool &Redeclaration,
NamedDecl *&OldDecl,
11658 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11659 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11660 const auto *NewCPUDisp = NewFD->
getAttr<CPUDispatchAttr>();
11661 const auto *NewCPUSpec = NewFD->
getAttr<CPUSpecificAttr>();
11662 const auto *NewClones = NewFD->
getAttr<TargetClonesAttr>();
11672 NewTVA->isDefaultVersion())) {
11673 S.
Diag(NewFD->
getLocation(), diag::err_multiversion_not_allowed_on_main);
11683 if (NewTA &&
T.isAArch64())
11687 if (NewTA &&
T.isRISCV())
11710 S.
Diag(NewFD->
getLocation(), diag::err_multiversion_required_in_redecl)
11721 S, OldFD, NewFD, Redeclaration, OldDecl,
Previous);
11723 if (OldFD->
isUsed(
false)) {
11725 return S.
Diag(NewFD->
getLocation(), diag::err_multiversion_after_used);
11741 NewCPUSpec, NewClones, Redeclaration,
11746 bool IsPure = NewFD->
hasAttr<PureAttr>();
11747 bool IsConst = NewFD->
hasAttr<ConstAttr>();
11750 if (!IsPure && !IsConst)
11757 if (IsPure && IsConst) {
11767 NewFD->
dropAttrs<PureAttr, ConstAttr>();
11773 bool IsMemberSpecialization,
11776 "Variably modified return types are not handled here");
11781 bool MergeTypeWithPrevious = !
getLangOpts().CPlusPlus &&
11784 bool Redeclaration =
false;
11786 bool MayNeedOverloadableChecks =
false;
11797 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
11798 Redeclaration =
true;
11799 OldDecl = Candidate;
11802 MayNeedOverloadableChecks =
true;
11806 Redeclaration =
true;
11810 Redeclaration =
true;
11814 Redeclaration =
false;
11821 if (!Redeclaration &&
11826 Redeclaration =
true;
11827 OldDecl =
Previous.getFoundDecl();
11828 MergeTypeWithPrevious =
false;
11831 if (OldDecl->
hasAttr<OverloadableAttr>() ||
11832 NewFD->
hasAttr<OverloadableAttr>()) {
11833 if (
IsOverload(NewFD, cast<FunctionDecl>(OldDecl),
false)) {
11834 MayNeedOverloadableChecks =
true;
11835 Redeclaration =
false;
11843 return Redeclaration;
11893 !MD->
isStatic() && !isa<CXXConstructorDecl>(MD) &&
11897 OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->
getAsFunction());
11898 if (!OldMD || !OldMD->
isStatic()) {
11920 if (Redeclaration) {
11926 return Redeclaration;
11933 dyn_cast<FunctionTemplateDecl>(OldDecl)) {
11934 auto *OldFD = OldTemplateDecl->getTemplatedDecl();
11937 assert(NewTemplateDecl &&
"Template/non-template mismatch");
11946 NewFD->
setAccess(OldTemplateDecl->getAccess());
11947 NewTemplateDecl->
setAccess(OldTemplateDecl->getAccess());
11952 if (IsMemberSpecialization &&
11955 assert(OldTemplateDecl->isMemberSpecialization());
11958 if (OldFD->isDeleted()) {
11960 assert(OldFD->getCanonicalDecl() == OldFD);
11962 OldFD->setDeletedAsWritten(
false);
11968 auto *OldFD = cast<FunctionDecl>(OldDecl);
11976 !NewFD->
getAttr<OverloadableAttr>()) {
11980 return ND->hasAttr<OverloadableAttr>();
11982 "Non-redecls shouldn't happen without overloadable present");
11985 const auto *FD = dyn_cast<FunctionDecl>(ND);
11986 return FD && !FD->
hasAttr<OverloadableAttr>();
11989 if (OtherUnmarkedIter !=
Previous.end()) {
11991 diag::err_attribute_overloadable_multiple_unmarked_overloads);
11992 Diag((*OtherUnmarkedIter)->getLocation(),
11993 diag::note_attribute_overloadable_prev_overload)
12010 dyn_cast<CXXDestructorDecl>(NewFD)) {
12018 !
Destructor->getFunctionObjectParameterType()->isDependentType()) {
12027 return Redeclaration;
12030 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(NewFD)) {
12031 if (
auto *TD = Guide->getDescribedFunctionTemplate())
12037 Diag(Guide->getBeginLoc(), diag::err_deduction_guide_specialized)
12042 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
12043 if (!Method->isFunctionTemplateSpecialization() &&
12044 !Method->getDescribedFunctionTemplate() &&
12045 Method->isCanonicalDecl()) {
12052 diag::err_constrained_virtual_method);
12054 if (Method->isStatic())
12065 return Redeclaration;
12072 return Redeclaration;
12092 Diag(NewFD->
getLocation(), diag::warn_return_value_udt) << NewFD << R;
12105 auto HasNoexcept = [&](
QualType T) ->
bool {
12116 if (FPT->isNothrow())
12122 bool AnyNoexcept = HasNoexcept(FPT->getReturnType());
12124 AnyNoexcept |= HasNoexcept(
T);
12127 diag::warn_cxx17_compat_exception_spec_in_signature)
12131 if (!Redeclaration &&
LangOpts.CUDA)
12140 bool UsesSM = NewFD->
hasAttr<ArmLocallyStreamingAttr>();
12141 bool UsesZA =
Attr &&
Attr->isNewZA();
12142 bool UsesZT0 =
Attr &&
Attr->isNewZT0();
12144 if (NewFD->
hasAttr<ArmLocallyStreamingAttr>()) {
12147 diag::warn_sme_locally_streaming_has_vl_args_returns)
12150 return P->getOriginalType()->isSizelessVectorType();
12153 diag::warn_sme_locally_streaming_has_vl_args_returns)
12166 if (UsesSM || UsesZA) {
12167 llvm::StringMap<bool> FeatureMap;
12169 if (!FeatureMap.contains(
"sme")) {
12172 diag::err_sme_definition_using_sm_in_non_sme_target);
12175 diag::err_sme_definition_using_za_in_non_sme_target);
12179 llvm::StringMap<bool> FeatureMap;
12181 if (!FeatureMap.contains(
"sme2")) {
12183 diag::err_sme_definition_using_zt0_in_non_sme2_target);
12188 return Redeclaration;
12201 ? diag::err_static_main : diag::warn_static_main)
12209 Diag(NoreturnLoc, diag::ext_noreturn_main);
12210 Diag(NoreturnLoc, diag::note_main_remove_noreturn)
12222 << FD->
hasAttr<OpenCLKernelAttr>();
12233 assert(
T->
isFunctionType() &&
"function decl is not of function type");
12255 Diag(RTRange.
getBegin(), diag::note_main_change_return_type)
12277 if (isa<FunctionNoProtoType>(FT))
return;
12283 bool HasExtraParameters = (nparams > 3);
12295 HasExtraParameters =
false;
12297 if (HasExtraParameters) {
12310 for (
unsigned i = 0; i < nparams; ++i) {
12313 bool mismatch =
true;
12330 mismatch = !qs.
empty();
12359 if (
T.isWindowsGNUEnvironment())
12364 if (
T.isOSWindows() &&
T.getArch() == llvm::Triple::x86)
12372 assert(
T->
isFunctionType() &&
"function decl is not of function type");
12381 if (FD->
getName() !=
"DllMain")
12415 if (
Init->isValueDependent()) {
12416 assert(
Init->containsErrors() &&
12417 "Dependent code should only occur in error-recovery path.");
12420 const Expr *Culprit;
12421 if (
Init->isConstantInitializer(
Context,
false, &Culprit))
12430 class SelfReferenceChecker
12436 bool isReferenceType;
12444 SelfReferenceChecker(
Sema &S,
Decl *OrigDecl) : Inherited(S.Context),
12445 S(S), OrigDecl(OrigDecl) {
12448 isReferenceType =
false;
12449 isInitList =
false;
12450 if (
ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
12451 isPODType = VD->getType().isPODType(S.
Context);
12453 isReferenceType = VD->getType()->isReferenceType();
12460 void CheckExpr(
Expr *
E) {
12469 InitFieldIndex.push_back(0);
12470 for (
auto *Child : InitList->
children()) {
12471 CheckExpr(cast<Expr>(Child));
12472 ++InitFieldIndex.back();
12474 InitFieldIndex.pop_back();
12479 bool CheckInitListMemberExpr(
MemberExpr *
E,
bool CheckReference) {
12482 bool ReferenceField =
false;
12486 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
12489 Fields.push_back(FD);
12491 ReferenceField =
true;
12492 Base = ME->getBase()->IgnoreParenImpCasts();
12497 if (!DRE || DRE->
getDecl() != OrigDecl)
12501 if (CheckReference && !ReferenceField)
12506 for (
const FieldDecl *I : llvm::reverse(Fields))
12507 UsedFieldIndex.push_back(I->getFieldIndex());
12512 for (
auto UsedIter = UsedFieldIndex.begin(),
12513 UsedEnd = UsedFieldIndex.end(),
12514 OrigIter = InitFieldIndex.begin(),
12515 OrigEnd = InitFieldIndex.end();
12516 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
12517 if (*UsedIter < *OrigIter)
12519 if (*UsedIter > *OrigIter)
12524 HandleDeclRefExpr(DRE);
12531 void HandleValue(
Expr *
E) {
12534 HandleDeclRefExpr(DRE);
12539 Visit(CO->getCond());
12540 HandleValue(CO->getTrueExpr());
12541 HandleValue(CO->getFalseExpr());
12546 dyn_cast<BinaryConditionalOperator>(
E)) {
12547 Visit(BCO->getCond());
12548 HandleValue(BCO->getFalseExpr());
12553 if (
Expr *SE = OVE->getSourceExpr())
12559 if (BO->getOpcode() == BO_Comma) {
12560 Visit(BO->getLHS());
12561 HandleValue(BO->getRHS());
12566 if (isa<MemberExpr>(
E)) {
12568 if (CheckInitListMemberExpr(cast<MemberExpr>(
E),
12576 if (!isa<FieldDecl>(ME->getMemberDecl()))
12578 Base = ME->getBase()->IgnoreParenImpCasts();
12581 HandleDeclRefExpr(DRE);
12591 if (isReferenceType)
12592 HandleDeclRefExpr(
E);
12596 if (
E->getCastKind() == CK_LValueToRValue) {
12597 HandleValue(
E->getSubExpr());
12601 Inherited::VisitImplicitCastExpr(
E);
12606 if (CheckInitListMemberExpr(
E,
true ))
12615 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(
E->getMemberDecl());
12616 bool Warn = (MD && !MD->
isStatic());
12619 if (!isa<FieldDecl>(ME->getMemberDecl()))
12621 Base = ME->getBase()->IgnoreParenImpCasts();
12626 HandleDeclRefExpr(DRE);
12638 if (isa<UnresolvedLookupExpr>(Callee))
12639 return Inherited::VisitCXXOperatorCallExpr(
E);
12642 for (
auto Arg:
E->arguments())
12643 HandleValue(Arg->IgnoreParenImpCasts());
12651 HandleValue(
E->getSubExpr());
12655 if (
E->isIncrementDecrementOp()) {
12656 HandleValue(
E->getSubExpr());
12660 Inherited::VisitUnaryOperator(
E);
12666 if (
E->getConstructor()->isCopyConstructor()) {
12667 Expr *ArgExpr =
E->getArg(0);
12668 if (
InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
12669 if (ILE->getNumInits() == 1)
12670 ArgExpr = ILE->getInit(0);
12672 if (ICE->getCastKind() == CK_NoOp)
12673 ArgExpr = ICE->getSubExpr();
12674 HandleValue(ArgExpr);
12677 Inherited::VisitCXXConstructExpr(
E);
12682 if (
E->isCallToStdMove()) {
12683 HandleValue(
E->getArg(0));
12687 Inherited::VisitCallExpr(
E);
12691 if (
E->isCompoundAssignmentOp()) {
12692 HandleValue(
E->getLHS());
12693 Visit(
E->getRHS());
12697 Inherited::VisitBinaryOperator(
E);
12704 Visit(
E->getCond());
12705 Visit(
E->getFalseExpr());
12710 if (OrigDecl != ReferenceDecl)
return;
12712 if (isReferenceType) {
12713 diag = diag::warn_uninit_self_reference_in_reference_init;
12714 }
else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
12715 diag = diag::warn_static_self_reference_in_init;
12716 }
else if (isa<TranslationUnitDecl>(OrigDecl->
getDeclContext()) ||
12719 diag = diag::warn_uninit_self_reference_in_init;
12733 static void CheckSelfReference(
Sema &S,
Decl* OrigDecl,
Expr *
E,
12737 if (isa<ParmVarDecl>(OrigDecl))
12746 if (ICE->getCastKind() == CK_LValueToRValue)
12747 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
12748 if (DRE->
getDecl() == OrigDecl)
12751 SelfReferenceChecker(S, OrigDecl).CheckExpr(
E);
12758 struct VarDeclOrName {
12764 return VN.VDecl ?
Diag << VN.VDecl :
Diag << VN.Name;
12774 bool IsInitCapture = !VDecl;
12776 "init captures are expected to be deduced prior to initialization");
12778 VarDeclOrName VN{VDecl, Name};
12781 assert(Deduced &&
"deduceVarTypeFromInitializer for non-deduced type");
12785 !isa_and_present<StringLiteral, InitListExpr>(
Init)) {
12794 assert(VDecl &&
"no init for init capture deduction?");
12798 if (!isa<DeducedTemplateSpecializationType>(Deduced) ||
12809 DeduceInits =
Init;
12811 auto *PL = dyn_cast_if_present<ParenListExpr>(
Init);
12813 DeduceInits = PL->exprs();
12815 if (isa<DeducedTemplateSpecializationType>(Deduced)) {
12816 assert(VDecl &&
"non-auto type for init capture deduction?");
12827 if (
auto *IL = dyn_cast<InitListExpr>(
Init))
12828 DeduceInits = IL->inits();
12832 if (DeduceInits.empty()) {
12835 Diag(
Init->getBeginLoc(), IsInitCapture
12836 ? diag::err_init_capture_no_expression
12837 : diag::err_auto_var_init_no_expression)
12842 if (DeduceInits.size() > 1) {
12843 Diag(DeduceInits[1]->getBeginLoc(),
12844 IsInitCapture ? diag::err_init_capture_multiple_expressions
12845 : diag::err_auto_var_init_multiple_expressions)
12850 Expr *DeduceInit = DeduceInits[0];
12851 if (
DirectInit && isa<InitListExpr>(DeduceInit)) {
12852 Diag(
Init->getBeginLoc(), IsInitCapture
12853 ? diag::err_init_capture_paren_braces
12854 : diag::err_auto_var_init_paren_braces)
12860 bool DefaultedAnyToId =
false;
12864 if (
Result.isInvalid()) {
12868 DefaultedAnyToId =
true;
12874 if (VDecl && isa<DecompositionDecl>(VDecl) &&
12878 Type.getQualifiers());
12886 if (!IsInitCapture)
12888 else if (isa<InitListExpr>(
Init))
12890 diag::err_init_capture_deduction_failure_from_init_list)
12919 assert(!
Init || !
Init->containsErrors());
12932 if (
getLangOpts().ObjCAutoRefCount &&
ObjC().inferObjCARCLifetime(VDecl))
12953 if (
auto *EWC = dyn_cast<ExprWithCleanups>(
Init))
12954 Init = EWC->getSubExpr();
12956 if (
auto *CE = dyn_cast<ConstantExpr>(
Init))
12957 Init = CE->getSubExpr();
12962 "shouldn't be called if type doesn't have a non-trivial C struct");
12963 if (
auto *ILE = dyn_cast<InitListExpr>(
Init)) {
12964 for (
auto *I : ILE->inits()) {
12965 if (!I->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion() &&
12966 !I->getType().hasNonTrivialToPrimitiveCopyCUnion())
12974 if (isa<ImplicitValueInitExpr>(
Init)) {
12990bool shouldIgnoreForRecordTriviality(
const FieldDecl *FD) {
12996 return FD->
hasAttr<UnavailableAttr>();
12999struct DiagNonTrivalCUnionDefaultInitializeVisitor
13006 DiagNonTrivalCUnionDefaultInitializeVisitor(
13009 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13012 const FieldDecl *FD,
bool InNonTrivialUnion) {
13015 InNonTrivialUnion);
13016 return Super::visitWithKind(PDIK, QT, FD, InNonTrivialUnion);
13020 bool InNonTrivialUnion) {
13021 if (InNonTrivialUnion)
13023 << 1 << 0 << QT << FD->
getName();
13027 if (InNonTrivialUnion)
13029 << 1 << 0 << QT << FD->
getName();
13035 if (OrigLoc.isValid()) {
13036 bool IsUnion =
false;
13037 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13038 IsUnion = OrigRD->isUnion();
13039 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13040 << 0 << OrigTy << IsUnion << UseContext;
13044 InNonTrivialUnion =
true;
13047 if (InNonTrivialUnion)
13052 if (!shouldIgnoreForRecordTriviality(FD))
13053 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13066struct DiagNonTrivalCUnionDestructedTypeVisitor
13071 DiagNonTrivalCUnionDestructedTypeVisitor(
13074 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13077 const FieldDecl *FD,
bool InNonTrivialUnion) {
13080 InNonTrivialUnion);
13081 return Super::visitWithKind(DK, QT, FD, InNonTrivialUnion);
13085 bool InNonTrivialUnion) {
13086 if (InNonTrivialUnion)
13088 << 1 << 1 << QT << FD->
getName();
13092 if (InNonTrivialUnion)
13094 << 1 << 1 << QT << FD->
getName();
13100 if (OrigLoc.isValid()) {
13101 bool IsUnion =
false;
13102 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13103 IsUnion = OrigRD->isUnion();
13104 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13105 << 1 << OrigTy << IsUnion << UseContext;
13109 InNonTrivialUnion =
true;
13112 if (InNonTrivialUnion)
13117 if (!shouldIgnoreForRecordTriviality(FD))
13118 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13123 bool InNonTrivialUnion) {}
13133struct DiagNonTrivalCUnionCopyVisitor
13140 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13143 const FieldDecl *FD,
bool InNonTrivialUnion) {
13146 InNonTrivialUnion);
13147 return Super::visitWithKind(PCK, QT, FD, InNonTrivialUnion);
13151 bool InNonTrivialUnion) {
13152 if (InNonTrivialUnion)
13154 << 1 << 2 << QT << FD->
getName();
13158 if (InNonTrivialUnion)
13160 << 1 << 2 << QT << FD->
getName();
13166 if (OrigLoc.isValid()) {
13167 bool IsUnion =
false;
13168 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13169 IsUnion = OrigRD->isUnion();
13170 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13171 << 2 << OrigTy << IsUnion << UseContext;
13175 InNonTrivialUnion =
true;
13178 if (InNonTrivialUnion)
13183 if (!shouldIgnoreForRecordTriviality(FD))
13184 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13188 const FieldDecl *FD,
bool InNonTrivialUnion) {}
13191 bool InNonTrivialUnion) {}
13205 unsigned NonTrivialKind) {
13209 "shouldn't be called if type doesn't have a non-trivial C union");
13213 DiagNonTrivalCUnionDefaultInitializeVisitor(QT,
Loc, UseContext, *
this)
13214 .
visit(QT,
nullptr,
false);
13217 DiagNonTrivalCUnionDestructedTypeVisitor(QT,
Loc, UseContext, *
this)
13218 .visit(QT,
nullptr,
false);
13220 DiagNonTrivalCUnionCopyVisitor(QT,
Loc, UseContext, *
this)
13221 .visit(QT,
nullptr,
false);
13232 if (
auto *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
13233 if (!Method->isInvalidDecl()) {
13235 Diag(Method->getLocation(), diag::err_member_function_initialization)
13236 << Method->getDeclName() <<
Init->getSourceRange();
13237 Method->setInvalidDecl();
13242 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
13244 assert(!isa<FieldDecl>(RealDecl) &&
"field init shouldn't get here");
13254 SubExprs.push_back(Res.
get());
13263 if (
Init && !
Init->getType().isNull() &&
13264 Init->getType()->isWebAssemblyTableType()) {
13265 Diag(
Init->getExprLoc(), diag::err_wasm_table_art) << 0;
13296 Diag(VDecl->
getLocation(), diag::err_attribute_dllimport_data_definition);
13317 BaseDeclType = Array->getElementType();
13319 diag::err_typecheck_decl_incomplete_type)) {
13326 diag::err_abstract_type_in_decl,
13336 !VDecl->
isTemplated() && !isa<VarTemplateSpecializationDecl>(VDecl) &&
13346 if (Def != VDecl &&
13366 Diag(
Init->getExprLoc(), diag::err_static_data_member_reinitialization)
13369 diag::note_previous_initializer)
13392 if (VDecl->
hasAttr<LoaderUninitializedAttr>()) {
13393 Diag(VDecl->
getLocation(), diag::err_loader_uninitialized_cant_init);
13407 if (
Result.isInvalid()) {
13416 bool IsParenListInit =
false;
13428 for (
size_t Idx = 0; Idx < Args.size(); ++Idx) {
13430 Args[Idx], VDecl,
true,
13431 [
this, Entity, Kind](
Expr *
E) {
13437 }
else if (Res.
get() != Args[Idx]) {
13438 Args[Idx] = Res.
get();
13448 if (
Result.isInvalid()) {
13462 if (isa<DecompositionDecl>(VDecl))
13468 IsParenListInit = !InitSeq.
steps().empty() &&
13472 if (
Init && !
Init->getType().isNull() &&
13504 if (VDecl->
hasAttr<BlocksAttr>())
13518 Init->getBeginLoc()))
13519 FSI->markSafeWeakUse(
Init);
13536 if (
Result.isInvalid()) {
13569 isa<InitListExpr>(
Init)) {
13573 if (
auto *
E = dyn_cast<ExprWithCleanups>(
Init))
13574 if (
auto *BE = dyn_cast<BlockExpr>(
E->getSubExpr()->
IgnoreParens()))
13576 BE->getBlockDecl()->setCanAvoidCopyToHeap();
13611 <<
Init->getSourceRange();
13622 else if (
Init->isValueDependent())
13626 else if (
Init->getType()->isScopedEnumeralType() &&
13632 Diag(
Loc, diag::ext_in_class_initializer_non_constant)
13633 <<
Init->getSourceRange();
13637 Diag(
Loc, diag::err_in_class_initializer_non_constant)
13638 <<
Init->getSourceRange();
13648 diag::ext_in_class_initializer_float_type_cxx11)
13649 << DclT <<
Init->getSourceRange();
13651 diag::note_in_class_initializer_float_type_cxx11)
13654 Diag(VDecl->
getLocation(), diag::ext_in_class_initializer_float_type)
13655 << DclT <<
Init->getSourceRange();
13658 Diag(
Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
13659 <<
Init->getSourceRange();
13666 Diag(VDecl->
getLocation(), diag::err_in_class_initializer_literal_type)
13667 << DclT <<
Init->getSourceRange()
13673 << DclT <<
Init->getSourceRange();
13707 if (!InitType.
isNull() &&
13726 if (CXXDirectInit) {
13727 assert(
DirectInit &&
"Call-style initializer must be direct init.");
13738 DeclsToCheckForDeferredDiags.insert(VDecl);
13747 VarDecl *VD = dyn_cast<VarDecl>(
D);
13751 if (
auto *DD = dyn_cast<DecompositionDecl>(
D))
13752 for (
auto *BD : DD->bindings())
13753 BD->setInvalidDecl();
13767 diag::err_typecheck_decl_incomplete_type)) {
13774 diag::err_abstract_type_in_decl,
13789 if (
VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
13793 if (isa<DecompositionDecl>(RealDecl)) {
13794 Diag(Var->getLocation(), diag::err_decomp_decl_requires_init) << Var;
13795 Var->setInvalidDecl();
13809 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition() &&
13810 !Var->isThisDeclarationADemotedDefinition()) {
13811 if (Var->isStaticDataMember()) {
13816 Diag(Var->getLocation(),
13817 diag::err_constexpr_static_mem_var_requires_init)
13819 Var->setInvalidDecl();
13823 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
13824 Var->setInvalidDecl();
13831 if (!Var->isInvalidDecl() &&
13833 Var->getStorageClass() !=
SC_Extern && !Var->getInit()) {
13834 bool HasConstExprDefaultConstructor =
false;
13835 if (
CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
13836 for (
auto *Ctor : RD->ctors()) {
13837 if (Ctor->isConstexpr() && Ctor->getNumParams() == 0 &&
13838 Ctor->getMethodQualifiers().getAddressSpace() ==
13840 HasConstExprDefaultConstructor =
true;
13844 if (!HasConstExprDefaultConstructor) {
13845 Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
13846 Var->setInvalidDecl();
13851 if (!Var->isInvalidDecl() && RealDecl->
hasAttr<LoaderUninitializedAttr>()) {
13852 if (Var->getStorageClass() ==
SC_Extern) {
13853 Diag(Var->getLocation(), diag::err_loader_uninitialized_extern_decl)
13855 Var->setInvalidDecl();
13859 diag::err_typecheck_decl_incomplete_type)) {
13860 Var->setInvalidDecl();
13863 if (
CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
13864 if (!RD->hasTrivialDefaultConstructor()) {
13865 Diag(Var->getLocation(), diag::err_loader_uninitialized_trivial_ctor);
13866 Var->setInvalidDecl();
13876 Var->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion())
13883 if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
13899 !Var->hasLinkage() && !Var->isInvalidDecl() &&
13901 diag::err_typecheck_decl_incomplete_type))
13902 Var->setInvalidDecl();
13907 diag::err_abstract_type_in_decl,
13909 Var->setInvalidDecl();
13912 Diag(Var->getLocation(), diag::warn_private_extern);
13913 Diag(Var->getLocation(), diag::note_private_extern);
13917 !Var->isInvalidDecl())
13928 if (!Var->isInvalidDecl()) {
13932 Var->getLocation(), ArrayT->getElementType(),
13933 diag::err_array_incomplete_or_sizeless_type))
13934 Var->setInvalidDecl();
13935 }
else if (Var->getStorageClass() ==
SC_Static) {
13945 if (Var->isFirstDecl())
13947 diag::ext_typecheck_decl_incomplete_type);
13952 if (!Var->isInvalidDecl())
13960 if (Var->isConstexpr())
13961 Diag(Var->getLocation(), diag::err_constexpr_var_requires_const_init)
13964 Diag(Var->getLocation(),
13965 diag::err_typecheck_incomplete_array_needs_initializer);
13966 Var->setInvalidDecl();
13973 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
13974 << Var <<
SourceRange(Var->getLocation(), Var->getLocation());
13983 if (Var->isInvalidDecl())
13986 if (!Var->hasAttr<AliasAttr>()) {
13989 diag::err_typecheck_decl_incomplete_type)) {
13990 Var->setInvalidDecl();
13999 diag::err_abstract_type_in_decl,
14001 Var->setInvalidDecl();
14022 if (!CXXRecord->isPOD())
14056 }
else if (
Init.isInvalid()) {
14074 VarDecl *VD = dyn_cast<VarDecl>(
D);
14133 const char *PrevSpec;
14139 D.SetIdentifier(Ident, IdentLoc);
14140 D.takeAttributes(Attrs);
14145 cast<VarDecl>(Var)->setCXXForRangeDecl(
true);
14153 if (var->isInvalidDecl())
return;
14160 if (var->getTypeSourceInfo()->getType()->isBlockPointerType() &&
14162 Diag(var->getLocation(), diag::err_opencl_invalid_block_declaration)
14164 var->setInvalidDecl();
14172 var->hasLocalStorage()) {
14173 switch (var->getType().getObjCLifetime()) {
14186 if (var->hasLocalStorage() &&
14195 if (var->isThisDeclarationADefinition() &&
14196 var->getDeclContext()->getRedeclContext()->isFileContext() &&
14197 var->isExternallyVisible() && var->hasLinkage() &&
14198 !var->isInline() && !var->getDescribedVarTemplate() &&
14200 !isa<VarTemplatePartialSpecializationDecl>(var) &&
14202 !
getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
14203 var->getLocation())) {
14205 VarDecl *prev = var->getPreviousDecl();
14210 Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var;
14211 Diag(var->getTypeSpecStartLoc(), diag::note_static_for_internal_linkage)
14217 std::optional<bool> CacheHasConstInit;
14218 const Expr *CacheCulprit =
nullptr;
14219 auto checkConstInit = [&]()
mutable {
14220 if (!CacheHasConstInit)
14221 CacheHasConstInit = var->getInit()->isConstantInitializer(
14222 Context, var->getType()->isReferenceType(), &CacheCulprit);
14223 return *CacheHasConstInit;
14227 if (var->getType().isDestructedType()) {
14231 Diag(var->getLocation(), diag::err_thread_nontrivial_dtor);
14233 Diag(var->getLocation(), diag::note_use_thread_local);
14235 if (!checkConstInit()) {
14243 Diag(var->getLocation(), diag::note_use_thread_local);
14249 if (!var->getType()->isStructureType() && var->hasInit() &&
14250 isa<InitListExpr>(var->getInit())) {
14251 const auto *ILE = cast<InitListExpr>(var->getInit());
14252 unsigned NumInits = ILE->getNumInits();
14254 for (
unsigned I = 0; I < NumInits; ++I) {
14255 const auto *
Init = ILE->getInit(I);
14258 const auto *SL = dyn_cast<StringLiteral>(
Init->IgnoreImpCasts());
14262 unsigned NumConcat = SL->getNumConcatenated();
14266 if (NumConcat == 2 && !SL->getBeginLoc().isMacroID()) {
14267 bool OnlyOneMissingComma =
true;
14268 for (
unsigned J = I + 1; J < NumInits; ++J) {
14269 const auto *
Init = ILE->getInit(J);
14272 const auto *SLJ = dyn_cast<StringLiteral>(
Init->IgnoreImpCasts());
14273 if (!SLJ || SLJ->getNumConcatenated() > 1) {
14274 OnlyOneMissingComma =
false;
14279 if (OnlyOneMissingComma) {
14281 for (
unsigned i = 0; i < NumConcat - 1; ++i)
14285 Diag(SL->getStrTokenLoc(1),
14286 diag::warn_concatenated_literal_array_init)
14288 Diag(SL->getBeginLoc(),
14289 diag::note_concatenated_string_literal_silence);
14300 if (var->hasAttr<BlocksAttr>())
14304 bool GlobalStorage = var->hasGlobalStorage();
14305 bool IsGlobal = GlobalStorage && !var->isStaticLocal();
14307 bool HasConstInit =
true;
14310 Diag(var->getLocation(), diag::err_constexpr_var_requires_const_init)
14315 !
type->isDependentType() &&
Init && !
Init->isValueDependent() &&
14316 (GlobalStorage || var->isConstexpr() ||
14317 var->mightBeUsableInConstantExpressions(
Context))) {
14329 HasConstInit = checkConstInit();
14333 if (HasConstInit) {
14334 (void)var->checkForConstantInitialization(Notes);
14336 }
else if (CacheCulprit) {
14337 Notes.emplace_back(CacheCulprit->
getExprLoc(),
14338 PDiag(diag::note_invalid_subexpr_in_const_expr));
14343 HasConstInit = var->checkForConstantInitialization(Notes);
14346 if (HasConstInit) {
14348 }
else if (var->isConstexpr()) {
14352 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
14353 diag::note_invalid_subexpr_in_const_expr) {
14354 DiagLoc = Notes[0].first;
14357 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
14358 << var <<
Init->getSourceRange();
14359 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
14360 Diag(Notes[I].first, Notes[I].second);
14361 }
else if (GlobalStorage && var->hasAttr<ConstInitAttr>()) {
14362 auto *
Attr = var->getAttr<ConstInitAttr>();
14363 Diag(var->getLocation(), diag::err_require_constant_init_failed)
14364 <<
Init->getSourceRange();
14367 for (
auto &it : Notes)
14368 Diag(it.first, it.second);
14369 }
else if (IsGlobal &&
14371 var->getLocation())) {
14380 if (!checkConstInit())
14381 Diag(var->getLocation(), diag::warn_global_constructor)
14382 <<
Init->getSourceRange();
14388 if (GlobalStorage && var->isThisDeclarationADefinition() &&
14394 std::optional<QualType::NonConstantStorageReason> Reason;
14395 if (HasConstInit &&
14396 !(Reason = var->getType().isNonConstantStorage(
Context,
true,
false))) {
14402 if (
const SectionAttr *SA = var->getAttr<SectionAttr>()) {
14406 }
else if (Stack->CurrentValue) {
14409 var->getType().isConstQualified()) {
14411 NonConstNonReferenceType) &&
14412 "This case should've already been handled elsewhere");
14413 Diag(var->getLocation(), diag::warn_section_msvc_compat)
14419 auto SectionName = Stack->CurrentValue->getString();
14420 var->addAttr(SectionAttr::CreateImplicit(
Context, SectionName,
14421 Stack->CurrentPragmaLocation,
14422 SectionAttr::Declspec_allocate));
14424 var->dropAttr<SectionAttr>();
14445 if (!
type->isDependentType())
14455 if (
auto *DD = dyn_cast<DecompositionDecl>(var))
14466 !FD->
hasAttr<DLLExportStaticLocalAttr>() &&
14467 !FD->
hasAttr<DLLImportStaticLocalAttr>()) {
14476 auto *NewAttr = cast<InheritableAttr>(A->clone(
getASTContext()));
14477 NewAttr->setInherited(
true);
14479 }
else if (
Attr *A = FD->
getAttr<DLLExportStaticLocalAttr>()) {
14480 auto *NewAttr = DLLExportAttr::CreateImplicit(
getASTContext(), *A);
14481 NewAttr->setInherited(
true);
14486 if (!FD->
hasAttr<DLLExportAttr>())
14489 }
else if (
Attr *A = FD->
getAttr<DLLImportStaticLocalAttr>()) {
14490 auto *NewAttr = DLLImportAttr::CreateImplicit(
getASTContext(), *A);
14491 NewAttr->setInherited(
true);
14520 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
14528 VD->
addAttr(PragmaClangBSSSectionAttr::CreateImplicit(
14532 VD->
addAttr(PragmaClangDataSectionAttr::CreateImplicit(
14536 VD->
addAttr(PragmaClangRodataSectionAttr::CreateImplicit(
14540 VD->
addAttr(PragmaClangRelroSectionAttr::CreateImplicit(
14545 if (
auto *DD = dyn_cast<DecompositionDecl>(ThisDecl)) {
14546 for (
auto *BD : DD->bindings()) {
14571 if (
const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
14578 bool IsClassTemplateMember =
14579 isa<ClassTemplatePartialSpecializationDecl>(
Context) ||
14580 Context->getDescribedClassTemplate();
14583 IsClassTemplateMember
14584 ? diag::warn_attribute_dllimport_static_field_definition
14585 : diag::err_attribute_dllimport_static_field_definition);
14586 Diag(IA->getLocation(), diag::note_attribute);
14587 if (!IsClassTemplateMember)
14615 if (RetainAttr *
Attr = VD->
getAttr<RetainAttr>()) {
14630 if (VD->
isFileVarDecl() && !isa<VarTemplatePartialSpecializationDecl>(VD))
14635 if (!VD->
hasAttr<TypeTagForDatatypeAttr>() ||
14639 for (
const auto *I : ThisDecl->
specific_attrs<TypeTagForDatatypeAttr>()) {
14641 if (!MagicValueExpr) {
14644 std::optional<llvm::APSInt> MagicValueInt;
14646 Diag(I->getRange().getBegin(),
14647 diag::err_type_tag_for_datatype_not_ice)
14651 if (MagicValueInt->getActiveBits() > 64) {
14652 Diag(I->getRange().getBegin(),
14653 diag::err_type_tag_for_datatype_too_large)
14657 uint64_t MagicValue = MagicValueInt->getZExtValue();
14660 I->getMatchingCType(),
14661 I->getLayoutCompatible(),
14662 I->getMustBeNull());
14667 auto *VD = dyn_cast<VarDecl>(DD);
14668 return VD && !VD->getType()->hasAutoForTrailingReturnType();
14680 bool DiagnosedMultipleDecomps =
false;
14682 bool DiagnosedNonDeducedAuto =
false;
14684 for (
Decl *
D : Group) {
14689 if (
auto *VD = dyn_cast<VarDecl>(
D);
14690 LangOpts.OpenMP && VD && VD->hasAttr<OMPDeclareTargetDeclAttr>() &&
14691 VD->hasGlobalStorage())
14695 if (
auto *DD = dyn_cast<DeclaratorDecl>(
D)) {
14696 if (!FirstDeclaratorInGroup)
14697 FirstDeclaratorInGroup = DD;
14698 if (!FirstDecompDeclaratorInGroup)
14699 FirstDecompDeclaratorInGroup = dyn_cast<DecompositionDecl>(
D);
14702 FirstNonDeducedAutoInGroup = DD;
14704 if (FirstDeclaratorInGroup != DD) {
14707 if (FirstDecompDeclaratorInGroup && !DiagnosedMultipleDecomps) {
14709 diag::err_decomp_decl_not_alone)
14711 << DD->getSourceRange();
14712 DiagnosedMultipleDecomps =
true;
14718 if (FirstNonDeducedAutoInGroup && !DiagnosedNonDeducedAuto) {
14720 diag::err_auto_non_deduced_not_alone)
14721 << FirstNonDeducedAutoInGroup->
getType()
14724 << DD->getSourceRange();
14725 DiagnosedNonDeducedAuto =
true;
14730 Decls.push_back(
D);
14736 if (FirstDeclaratorInGroup && !Tag->hasNameForLinkage() &&
14750 if (Group.size() > 1) {
14752 VarDecl *DeducedDecl =
nullptr;
14753 for (
unsigned i = 0, e = Group.size(); i != e; ++i) {
14754 VarDecl *
D = dyn_cast<VarDecl>(Group[i]);
14757 DeducedType *DT =
D->getType()->getContainedDeducedType();
14764 auto *AT = dyn_cast<AutoType>(DT);
14766 diag::err_auto_different_deductions)
14767 << (AT ? (
unsigned)AT->getKeyword() : 3) << Deduced
14769 <<
D->getDeclName();
14792 if (Group.empty() || !Group[0])
14796 Group[0]->getLocation()) &&
14798 Group[0]->getLocation()))
14801 if (Group.size() >= 2) {
14809 Decl *MaybeTagDecl = Group[0];
14810 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
14811 Group = Group.slice(1);
14828 if (
D.getCXXScopeSpec().isSet()) {
14829 Diag(
D.getIdentifierLoc(), diag::err_qualified_param_declarator)
14830 <<
D.getCXXScopeSpec().getRange();
14846 Diag(
D.getIdentifierLoc(), diag::err_bad_parameter_name)
14853 Diag(
D.getIdentifierLoc(), diag::err_bad_parameter_name_template_id);
14860 if (!ExplicitThisLoc.
isValid())
14863 "explicit parameter in non-cplusplus mode");
14865 S.
Diag(ExplicitThisLoc, diag::err_cxx20_deducing_this)
14866 <<
P->getSourceRange();
14870 if (
P->isParameterPack()) {
14871 S.
Diag(
P->getBeginLoc(), diag::err_explicit_object_parameter_pack)
14872 <<
P->getSourceRange();
14875 P->setExplicitObjectParameterLoc(ExplicitThisLoc);
14877 LSI->ExplicitObjectParameter =
P;
14895 : diag::warn_deprecated_register)
14903 diag::err_invalid_storage_class_in_func_decl);
14904 D.getMutableDeclSpec().ClearStorageClassSpecs();
14915 << 0 <<
static_cast<int>(
D.getDeclSpec().getConstexprSpecifier());
14928 RedeclarationKind::ForVisibleRedeclaration);
14936 PrevDecl =
nullptr;
14938 if (PrevDecl && S->isDeclScope(PrevDecl)) {
14939 Diag(
D.getIdentifierLoc(), diag::err_param_redefinition) << II;
14943 D.SetIdentifier(
nullptr,
D.getIdentifierLoc());
14944 D.setInvalidType(
true);
14954 D.getIdentifierLoc(), II, parmDeclType, TInfo, SC);
14956 if (
D.isInvalidType())
14961 assert(S->isFunctionPrototypeScope());
14962 assert(S->getFunctionPrototypeDepth() >= 1);
14964 S->getNextFunctionPrototypeIndex());
14973 if (
D.getDeclSpec().isModulePrivateSpecified())
14975 << 1 << New <<
SourceRange(
D.getDeclSpec().getModulePrivateSpecLoc())
14978 if (New->
hasAttr<BlocksAttr>()) {
15010 !
Parameter->getIdentifier()->isPlaceholder()) {
15011 Diag(
Parameter->getLocation(), diag::warn_unused_parameter)
15019 if (
LangOpts.NumLargeByValueCopy == 0)
15026 if (Size >
LangOpts.NumLargeByValueCopy)
15037 if (Size >
LangOpts.NumLargeByValueCopy)
15058 if (!
T.isConstQualified()) {
15062 NameLoc, diag::err_arc_array_param_no_ownership,
T,
false));
15064 Diag(NameLoc, diag::err_arc_array_param_no_ownership)
15076 TSInfo, SC,
nullptr);
15083 LSI->LocalPacks.push_back(New);
15096 diag::err_object_cannot_be_passed_returned_by_value) << 1 <<
T
15115 Diag(NameLoc, diag::err_arg_with_address_space);
15143 for (
int i = FTI.
NumParams; i != 0; ) {
15148 llvm::raw_svector_ostream(Code)
15159 const char* PrevSpec;
15180 assert(
D.isFunctionDeclarator() &&
"Not a function declarator!");
15191 if (
LangOpts.OpenMP &&
OpenMP().isInOpenMPDeclareVariantScope())
15193 ParentScope,
D, TemplateParameterLists, Bases);
15199 if (!Bases.empty())
15216 if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
15219 PossiblePrototype = Prev;
15237 if (isa<CXXMethodDecl>(FD))
15243 if (II->isStr(
"main") || II->isStr(
"efi_main"))
15262 if (FD->
hasAttr<OpenCLKernelAttr>())
15316 Definition->getNumTemplateParameterLists())) {
15319 if (
auto *TD =
Definition->getDescribedFunctionTemplate())
15332 Diag(
Definition->getLocation(), diag::note_previous_definition);
15341 LSI->
Lambda = LambdaClass;
15365 for (
const auto &
C : LambdaClass->
captures()) {
15366 if (
C.capturesVariable()) {
15370 const bool ByRef =
C.getCaptureKind() ==
LCK_ByRef;
15372 true,
C.getLocation(),
15373 C.isPackExpansion()
15375 I->getType(),
false);
15377 }
else if (
C.capturesThis()) {
15403 FD = FunTmpl->getTemplatedDecl();
15405 FD = cast<FunctionDecl>(
D);
15430 if (
const auto *
Attr = FD->
getAttr<AliasAttr>()) {
15435 if (
const auto *
Attr = FD->
getAttr<IFuncAttr>()) {
15440 if (
const auto *
Attr = FD->
getAttr<TargetVersionAttr>()) {
15442 !
Attr->isDefaultVersion()) {
15451 if (
auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
15453 Ctor->isDefaultConstructor() &&
15496 "There should be an active template instantiation on the stack "
15497 "when instantiating a generic lambda!");
15523 diag::err_func_def_incomplete_result) ||
15525 diag::err_abstract_type_in_decl,
15541 auto *NonParmDecl = dyn_cast<NamedDecl>(NPD);
15544 assert(!isa<ParmVarDecl>(NonParmDecl) &&
15545 "parameters should not be in newly created FD yet");
15548 if (NonParmDecl->getDeclName())
15553 if (
auto *ED = dyn_cast<EnumDecl>(NonParmDecl)) {
15554 for (
auto *EI : ED->enumerators())
15562 Param->setOwningFunction(FD);
15565 if (Param->getIdentifier() && FnBodyScope) {
15594 assert(!FD->
hasAttr<DLLExportAttr>());
15595 Diag(FD->
getLocation(), diag::err_attribute_dllimport_function_definition);
15618 if (
auto *TD = dyn_cast<FunctionTemplateDecl>(FD))
15619 FD = TD->getTemplatedDecl();
15620 if (FD && FD->
hasAttr<OptimizeNoneAttr>()) {
15632 for (
unsigned I = 0,
E =
Scope->Returns.size(); I !=
E; ++I) {
15633 if (
const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
15634 if (!NRVOCandidate->isNRVOVariable())
15642 if (
D.getDeclSpec().hasConstexprSpecifier())
15647 if (
D.getDeclSpec().hasAutoTypeSpec()) {
15650 if (
D.getNumTypeObjects()) {
15651 const auto &Outer =
D.getTypeObject(
D.getNumTypeObjects() - 1);
15653 Outer.Fun.hasTrailingReturnType()) {
15671 if (FD->isConstexpr())
15676 if (FD->getReturnType()->getContainedDeducedType())
15686 FD->setHasSkippedBody();
15708 bool IsLambda =
false;
15712 llvm::DenseMap<const BlockDecl *, bool> EscapeInfo;
15714 auto IsOrNestedInEscapingBlock = [&](
const BlockDecl *BD) {
15715 if (EscapeInfo.count(BD))
15716 return EscapeInfo[BD];
15728 return EscapeInfo[BD] = R;
15733 for (
const std::pair<SourceLocation, const BlockDecl *> &
P :
15735 if (IsOrNestedInEscapingBlock(
P.second))
15736 S.
Diag(
P.first, diag::warn_implicitly_retains_self)
15741 return isa<CXXMethodDecl>(FD) && FD->
param_empty() &&
15751 methodHasName(FD,
"get_return_object_on_allocation_failure");
15761 if (!FD->
hasAttr<CoroWrapperAttr>())
15766 bool IsInstantiation) {
15816 Expr *Dummy =
nullptr;
15827 if (LSI->HasImplicitReturnType) {
15834 LSI->ReturnType.isNull() ?
Context.
VoidTy : LSI->ReturnType;
15839 Proto->getExtProtoInfo()));
15867 dyn_cast<CXXDestructorDecl>(FD))
15887 if (PossiblePrototype) {
15891 TypeLoc TL = TI->getTypeLoc();
15894 diag::note_declaration_not_a_prototype)
15897 FTL.getRParenLoc(),
"void")
15904 std::pair<FileID, unsigned> LocInfo =
SM.getDecomposedLoc(
Loc);
15905 if (LocInfo.first.isInvalid())
15909 StringRef Buffer =
SM.getBufferData(LocInfo.first, &
Invalid);
15913 if (LocInfo.second > Buffer.size())
15916 const char *LexStart = Buffer.data() + LocInfo.second;
15917 StringRef StartTok(LexStart, Buffer.size() - LocInfo.second);
15919 return StartTok.consume_front(
"const") &&
15921 StartTok.starts_with(
"/*") || StartTok.starts_with(
"//"));
15924 auto findBeginLoc = [&]() {
15940 diag::note_static_for_internal_linkage)
15951 if (!PossiblePrototype)
15997 if (PossiblePrototype)
15999 diag::warn_non_prototype_changes_behavior)
16006 if (
const auto *CmpndBody = dyn_cast<CompoundStmt>(Body))
16007 if (!CmpndBody->body_empty())
16008 Diag(CmpndBody->body_front()->getBeginLoc(),
16009 diag::warn_dispatch_body_ignored);
16011 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
16036 "Function parsing confused");
16037 }
else if (
ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
16049 << MD->getSelector().getAsString();
16054 bool isDesignated =
16055 MD->isDesignatedInitializerForTheInterface(&InitMethod);
16056 assert(isDesignated && InitMethod);
16057 (void)isDesignated;
16060 auto IFace = MD->getClassInterface();
16063 auto SuperD = IFace->getSuperClass();
16073 diag::warn_objc_designated_init_missing_super_call);
16075 diag::note_objc_designated_init_marked_here);
16083 diag::warn_objc_secondary_init_missing_init_call);
16099 "This should only be set for ObjC methods, which should have been "
16100 "handled in the block above.");
16107 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
16115 if (!
Destructor->getParent()->isDependentType())
16133 ActivePolicy = &WP;
16136 if (!IsInstantiation && FD &&
16142 if (FD && FD->
hasAttr<NakedAttr>()) {
16146 bool RegisterVariables =
false;
16147 if (
auto *DS = dyn_cast<DeclStmt>(S)) {
16148 for (
const auto *
Decl : DS->decls()) {
16149 if (
const auto *Var = dyn_cast<VarDecl>(
Decl)) {
16150 RegisterVariables =
16151 Var->hasAttr<AsmLabelAttr>() && !Var->hasInit();
16152 if (!RegisterVariables)
16157 if (RegisterVariables)
16159 if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
16160 Diag(S->getBeginLoc(), diag::err_non_asm_stmt_in_naked_function);
16161 Diag(FD->
getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
16170 "Leftover temporaries in function");
16172 "Unaccounted cleanups in function");
16174 "Leftover expressions for odr-use checking");
16180 if (!IsInstantiation)
16197 DeclsToCheckForDeferredDiags.insert(FD);
16212 D = TD->getTemplatedDecl();
16217 if (Method->isStatic())
16225 "Implicit function declarations aren't allowed in this language mode");
16232 Scope *BlockScope = S;
16240 Scope *ContextScope = BlockScope;
16244 ContextScope = ContextScope->
getParent();
16260 if (!isa<FunctionDecl>(ExternCPrev) ||
16262 cast<FunctionDecl>(ExternCPrev)->getType(),
16264 Diag(
Loc, diag::ext_use_out_of_scope_declaration)
16267 return ExternCPrev;
16273 if (II.
getName().starts_with(
"__builtin_"))
16274 diag_id = diag::warn_builtin_unknown;
16277 diag_id = diag::ext_implicit_function_decl_c99;
16279 diag_id = diag::warn_implicit_function_decl;
16287 if (S && !ExternCPrev &&
16310 return ExternCPrev;
16320 assert(!Error &&
"Error setting up implicit decl!");
16342 D.SetIdentifier(&II,
Loc);
16362 std::optional<unsigned> AlignmentParam;
16363 bool IsNothrow =
false;
16375 if (!IsNothrow && !FD->
hasAttr<ReturnsNonNullAttr>() &&
16393 if (!FD->
hasAttr<AllocSizeAttr>()) {
16394 FD->
addAttr(AllocSizeAttr::CreateImplicit(
16405 if (AlignmentParam && !FD->
hasAttr<AllocAlignAttr>()) {
16406 FD->
addAttr(AllocAlignAttr::CreateImplicit(
16430 unsigned FormatIdx;
16433 if (!FD->
hasAttr<FormatAttr>()) {
16434 const char *fmt =
"printf";
16436 if (FormatIdx < NumParams &&
16442 HasVAListArg ? 0 : FormatIdx+2,
16448 if (!FD->
hasAttr<FormatAttr>())
16452 HasVAListArg ? 0 : FormatIdx+2,
16458 if (!FD->
hasAttr<CallbackAttr>() &&
16460 FD->
addAttr(CallbackAttr::CreateImplicit(
16466 bool NoExceptions =
16468 bool ConstWithoutErrnoAndExceptions =
16470 bool ConstWithoutExceptions =
16472 if (!FD->
hasAttr<ConstAttr>() &&
16473 (ConstWithoutErrnoAndExceptions || ConstWithoutExceptions) &&
16474 (!ConstWithoutErrnoAndExceptions ||
16476 (!ConstWithoutExceptions || NoExceptions))
16483 if ((Trip.isGNUEnvironment() || Trip.isOSMSVCRT()) &&
16485 switch (BuiltinID) {
16486 case Builtin::BI__builtin_fma:
16487 case Builtin::BI__builtin_fmaf:
16488 case Builtin::BI__builtin_fmal:
16489 case Builtin::BIfma:
16490 case Builtin::BIfmaf:
16491 case Builtin::BIfmal:
16500 !FD->
hasAttr<ReturnsTwiceAttr>())
16510 !FD->
hasAttr<CUDADeviceAttr>() && !FD->
hasAttr<CUDAHostAttr>()) {
16522 switch (BuiltinID) {
16523 case Builtin::BImemalign:
16524 case Builtin::BIaligned_alloc:
16525 if (!FD->
hasAttr<AllocAlignAttr>())
16534 switch (BuiltinID) {
16535 case Builtin::BIcalloc:
16536 FD->
addAttr(AllocSizeAttr::CreateImplicit(
16539 case Builtin::BImemalign:
16540 case Builtin::BIaligned_alloc:
16541 case Builtin::BIrealloc:
16545 case Builtin::BImalloc:
16554 switch (BuiltinID) {
16555 case Builtin::BIaddressof:
16556 case Builtin::BI__addressof:
16557 case Builtin::BI__builtin_addressof:
16558 case Builtin::BIas_const:
16559 case Builtin::BIforward:
16560 case Builtin::BIforward_like:
16561 case Builtin::BImove:
16562 case Builtin::BImove_if_noexcept:
16564 !
P->hasAttr<LifetimeBoundAttr>())
16581 if (!FPT || FPT->getExceptionSpecType() ==
EST_None)
16597 if (Name->isStr(
"asprintf") || Name->isStr(
"vasprintf")) {
16600 if (!FD->
hasAttr<FormatAttr>())
16603 Name->isStr(
"vasprintf") ? 0 : 3,
16607 if (Name->isStr(
"__CFStringMakeConstantString")) {
16610 if (!FD->
hasAttr<FormatArgAttr>())
16618 assert(
D.getIdentifier() &&
"Wrong callback for declspec without declarator");
16619 assert(!
T.isNull() &&
"GetTypeForDeclarator() returned null type");
16622 assert(
D.isInvalidType() &&
"no declarator info for valid type");
16629 D.getIdentifierLoc(),
D.getIdentifier(), TInfo);
16632 if (
D.isInvalidType()) {
16637 if (
D.getDeclSpec().isModulePrivateSpecified()) {
16641 <<
SourceRange(
D.getDeclSpec().getModulePrivateSpecLoc())
16643 D.getDeclSpec().getModulePrivateSpecLoc());
16654 switch (
D.getDeclSpec().getTypeSpecType()) {
16660 TagDecl *tagFromDeclSpec = cast<TagDecl>(
D.getDeclSpec().getRepAsDecl());
16682 if (BT->isInteger())
16685 return Diag(UnderlyingLoc, diag::err_enum_invalid_underlying)
16690 QualType EnumUnderlyingTy,
bool IsFixed,
16692 if (IsScoped != Prev->
isScoped()) {
16693 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
16699 if (IsFixed && Prev->
isFixed()) {
16705 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
16711 }
else if (IsFixed != Prev->
isFixed()) {
16712 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
16734 default: llvm_unreachable(
"Invalid tag kind for redecl diagnostic!");
16750 if (isa<TypedefDecl>(PrevDecl))
16752 else if (isa<TypeAliasDecl>(PrevDecl))
16754 else if (isa<ClassTemplateDecl>(PrevDecl))
16756 else if (isa<TypeAliasTemplateDecl>(PrevDecl))
16758 else if (isa<TemplateTemplateParmDecl>(PrevDecl))
16770 llvm_unreachable(
"invalid TTK");
16791 if (OldTag != NewTag &&
16809 if (IsIgnoredLoc(NewTagLoc))
16812 auto IsIgnored = [&](
const TagDecl *Tag) {
16813 return IsIgnoredLoc(Tag->getLocation());
16827 if (OldTag != NewTag) {
16830 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
16838 if (isDefinition) {
16846 bool previousMismatch =
false;
16848 if (I->getTagKind() != NewTag) {
16853 if (!previousMismatch) {
16854 previousMismatch =
true;
16855 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
16859 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
16872 if (PrevDef && IsIgnored(PrevDef))
16876 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
16883 Diag(NewTagLoc, diag::note_struct_class_suggestion)
16913 if (!Namespace || Namespace->isAnonymousNamespace())
16916 Namespaces.push_back(II);
16919 if (Lookup == Namespace)
16926 llvm::raw_svector_ostream OS(Insertion);
16929 std::reverse(Namespaces.begin(), Namespaces.end());
16930 for (
auto *II : Namespaces)
16931 OS << II->getName() <<
"::";
16944 if (OldDC->
Equals(NewDC))
16963 bool ScopedEnumUsesClassTag,
TypeResult UnderlyingType,
16964 bool IsTypeSpecifier,
bool IsTemplateParamOrArg,
16969 "Nameless record must be a definition!");
16974 bool ScopedEnum = ScopedEnumKWLoc.
isValid();
16977 bool isMemberSpecialization =
false;
16983 if (TemplateParameterLists.size() > 0 ||
16987 KWLoc, NameLoc, SS,
nullptr, TemplateParameterLists,
17004 !isMemberSpecialization)
17005 Diag(SS.
getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
17008 if (TemplateParams) {
17010 Diag(KWLoc, diag::err_enum_template);
17014 if (TemplateParams->
size() > 0) {
17023 S, TagSpec, TUK, KWLoc, SS, Name, NameLoc, Attrs, TemplateParams,
17024 AS, ModulePrivateLoc,
17026 TemplateParameterLists.data(), SkipBody);
17032 isMemberSpecialization =
true;
17036 if (!TemplateParameterLists.empty() && isMemberSpecialization &&
17055 ScopedEnum ?
SourceRange(KWLoc, ScopedEnumKWLoc) : KWLoc);
17056 assert(ScopedEnum || !ScopedEnumUsesClassTag);
17057 Diag(KWLoc, diag::note_enum_friend)
17058 << (ScopedEnum + ScopedEnumUsesClassTag);
17064 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
17065 bool IsFixed = !UnderlyingType.
isUnset() || ScopedEnum;
17068 if (UnderlyingType.
isInvalid() || (!UnderlyingType.
get() && ScopedEnum)) {
17072 }
else if (UnderlyingType.
get()) {
17077 EnumUnderlying = TI;
17099 bool isStdBadAlloc =
false;
17100 bool isStdAlignValT =
false;
17104 Redecl = RedeclarationKind::NotForRedeclaration;
17109 auto createTagFromNewDecl = [&]() ->
TagDecl * {
17119 ScopedEnum, ScopedEnumUsesClassTag, IsFixed);
17123 if (EnumUnderlying) {
17124 EnumDecl *ED = cast<EnumDecl>(New);
17139 if (
RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
17166 goto CreateNewDecl;
17174 IsDependent =
true;
17203 if (
Previous.wasNotFoundInCurrentInstantiation() &&
17205 IsDependent =
true;
17210 Diag(NameLoc, diag::err_not_tag_in_scope)
17211 << llvm::to_underlying(Kind) << Name << DC << SS.
getRange();
17214 goto CreateNewDecl;
17262 bool FriendSawTagOutsideEnclosingNamespace =
false;
17269 FriendSawTagOutsideEnclosingNamespace =
true;
17278 if (
Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
17280 Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
17294 while (isa<RecordDecl, EnumDecl, ObjCContainerDecl>(SearchDC))
17300 while (isa<ObjCContainerDecl>(SearchDC))
17306 while (isa<ObjCContainerDecl>(SearchDC))
17311 Previous.getFoundDecl()->isTemplateParameter()) {
17320 if (Name->isStr(
"bad_alloc")) {
17322 isStdBadAlloc =
true;
17329 }
else if (Name->isStr(
"align_val_t")) {
17330 isStdAlignValT =
true;
17342 IsTemplateParamOrArg)) {
17343 if (
Invalid)
goto CreateNewDecl;
17427 TagDecl *Tag = TT->getDecl();
17428 if (Tag->getDeclName() == Name &&
17429 Tag->getDeclContext()->getRedeclContext()
17430 ->Equals(TD->getDeclContext()->getRedeclContext())) {
17443 if (
auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
17444 auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
17447 isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) &&
17449 *
this, OldTag->getDeclContext(), SearchDC))) {
17450 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
17451 Diag(Shadow->getTargetDecl()->getLocation(),
17452 diag::note_using_decl_target);
17453 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
17457 goto CreateNewDecl;
17461 if (
TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
17467 SS.
isNotEmpty() || isMemberSpecialization)) {
17473 bool SafeToContinue =
17476 if (SafeToContinue)
17477 Diag(KWLoc, diag::err_use_with_wrong_tag)
17480 PrevTagDecl->getKindName());
17482 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
17483 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
17485 if (SafeToContinue)
17486 Kind = PrevTagDecl->getTagKind();
17497 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
17499 return PrevTagDecl;
17503 EnumUnderlyingTy = TI->getType().getUnqualifiedType();
17504 else if (
const Type *
T = EnumUnderlying.dyn_cast<
const Type*>())
17511 ScopedEnum, EnumUnderlyingTy,
17512 IsFixed, PrevEnum))
17521 S->isDeclScope(PrevDecl)) {
17522 Diag(NameLoc, diag::ext_member_redeclared);
17523 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
17530 if (!Attrs.
empty()) {
17534 (PrevTagDecl->getFriendObjectKind() ==
17547 return PrevTagDecl;
17552 return PrevTagDecl;
17558 if (
NamedDecl *Def = PrevTagDecl->getDefinition()) {
17562 bool IsExplicitSpecializationAfterInstantiation =
false;
17563 if (isMemberSpecialization) {
17565 IsExplicitSpecializationAfterInstantiation =
17566 RD->getTemplateSpecializationKind() !=
17568 else if (
EnumDecl *ED = dyn_cast<EnumDecl>(Def))
17569 IsExplicitSpecializationAfterInstantiation =
17570 ED->getTemplateSpecializationKind() !=
17590 SkipBody->
New = createTagFromNewDecl();
17600 }
else if (!IsExplicitSpecializationAfterInstantiation) {
17604 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
17606 Diag(NameLoc, diag::err_redefinition) << Name;
17608 NameLoc.
isValid() ? NameLoc : KWLoc);
17620 if (TD->isBeingDefined()) {
17621 Diag(NameLoc, diag::err_nested_redefinition) << Name;
17622 Diag(PrevTagDecl->getLocation(),
17623 diag::note_previous_definition);
17638 SearchDC = PrevTagDecl->getDeclContext();
17666 Diag(NameLoc, diag::err_tag_reference_non_tag)
17667 << PrevDecl << NTK << llvm::to_underlying(Kind);
17673 SS.
isNotEmpty() || isMemberSpecialization)) {
17679 Diag(NameLoc, diag::err_tag_reference_conflict) << NTK;
17685 }
else if (
TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
17687 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
17688 Diag(NameLoc, diag::err_tag_definition_of_typedef)
17689 << Name << Kind << TND->getUnderlyingType();
17697 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
17713 PrevDecl = cast<TagDecl>(
Previous.getFoundDecl());
17729 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
17730 ScopedEnumUsesClassTag, IsFixed);
17738 if (IsFixed && cast<EnumDecl>(New)->isFixed()) {
17742 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->
getDefinition())) {
17743 Diag(
Loc, diag::ext_forward_ref_enum_def)
17747 unsigned DiagID = diag::ext_forward_ref_enum;
17749 DiagID = diag::ext_ms_forward_ref_enum;
17751 DiagID = diag::err_forward_ref_enum;
17756 if (EnumUnderlying) {
17757 EnumDecl *ED = cast<EnumDecl>(New);
17766 assert(ED->
isComplete() &&
"enum with type should be complete");
17776 cast_or_null<CXXRecordDecl>(PrevDecl));
17782 cast_or_null<RecordDecl>(PrevDecl));
17794 (IsTypeSpecifier || IsTemplateParamOrArg) &&
17816 isMemberSpecialization))
17820 if (TemplateParameterLists.size() > 0) {
17828 if (
RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
17844 if (ModulePrivateLoc.
isValid()) {
17845 if (isMemberSpecialization)
17870 Diag(
Loc, diag::err_type_defined_in_param_type)
17874 }
else if (!PrevDecl) {
17935 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(New)) {
17952 if (
auto RD = dyn_cast<RecordDecl>(New))
17955 }
else if (SkipBody && SkipBody->
ShouldSkip) {
17964 TagDecl *Tag = cast<TagDecl>(TagD);
17987 bool IsFinalSpelledSealed,
17995 if (!
Record->getIdentifier())
18003 IsFinalSpelledSealed
18004 ? FinalAttr::Keyword_sealed
18005 : FinalAttr::Keyword_final));
18024 "Broken injected-class-name");
18030 TagDecl *Tag = cast<TagDecl>(TagD);
18031 Tag->setBraceRange(BraceRange);
18034 if (Tag->isBeingDefined()) {
18035 assert(Tag->isInvalidDecl() &&
"We should already have completed it");
18036 if (
RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
18040 if (
auto *RD = dyn_cast<CXXRecordDecl>(Tag)) {
18042 if (RD->
hasAttr<SYCLSpecialClassAttr>()) {
18044 assert(Def &&
"The record is expected to have a completed definition");
18045 unsigned NumInitMethods = 0;
18046 for (
auto *Method : Def->methods()) {
18047 if (!Method->getIdentifier())
18049 if (Method->getName() ==
"__init")
18052 if (NumInitMethods > 1 || !Def->hasInitMethod())
18053 Diag(RD->
getLocation(), diag::err_sycl_special_type_num_init_method);
18061 Tag->getDeclContext()->isFileContext())
18062 Tag->setTopLevelDeclInObjCContainer();
18065 if (!Tag->isInvalidDecl())
18076 const RecordDecl *RD = dyn_cast<RecordDecl>(Tag);
18080 if (llvm::any_of(RD->
fields(),
18081 [](
const FieldDecl *FD) { return FD->isBitField(); }))
18082 Diag(BraceRange.
getBegin(), diag::warn_pragma_align_not_xl_compatible);
18088 TagDecl *Tag = cast<TagDecl>(TagD);
18089 Tag->setInvalidDecl();
18092 if (Tag->isBeingDefined()) {
18093 if (
RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
18107 QualType FieldTy,
bool IsMsStruct,
18118 diag::err_field_incomplete_or_sizeless))
18121 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
18123 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
18134 llvm::APSInt
Value;
18138 BitWidth = ICE.
get();
18141 if (
Value == 0 && FieldName)
18142 return Diag(FieldLoc, diag::err_bitfield_has_zero_width)
18145 if (
Value.isSigned() &&
Value.isNegative()) {
18147 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
18149 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
18156 return Diag(FieldLoc, diag::err_bitfield_too_wide)
18163 bool BitfieldIsOverwide =
Value.ugt(TypeWidth);
18167 bool CStdConstraintViolation =
18169 bool MSBitfieldViolation =
18170 Value.ugt(TypeStorageSize) &&
18172 if (CStdConstraintViolation || MSBitfieldViolation) {
18173 unsigned DiagWidth =
18174 CStdConstraintViolation ? TypeWidth : TypeStorageSize;
18175 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_width)
18177 << !CStdConstraintViolation << DiagWidth;
18183 if (BitfieldIsOverwide && !FieldTy->
isBooleanType() && FieldName) {
18184 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_width)
18206 if (
D.isDecompositionDeclarator()) {
18215 if (II)
Loc =
D.getIdentifierLoc();
18224 D.setInvalidType();
18232 if (
D.getDeclSpec().isInlineSpecified())
18233 Diag(
D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
18235 if (
DeclSpec::TSCS TSCS =
D.getDeclSpec().getThreadStorageClassSpec())
18236 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
18237 diag::err_invalid_thread)
18243 RedeclarationKind::ForVisibleRedeclaration);
18245 switch (
Previous.getResultKind()) {
18252 PrevDecl =
Previous.getRepresentativeDecl();
18266 PrevDecl =
nullptr;
18270 PrevDecl =
nullptr;
18277 TSSL, AS, PrevDecl, &
D);
18280 Record->setInvalidDecl();
18282 if (
D.getDeclSpec().isModulePrivateSpecified())
18299 bool Mutable,
Expr *BitWidth,
18305 bool InvalidDecl =
false;
18306 if (
D) InvalidDecl =
D->isInvalidType();
18311 InvalidDecl =
true;
18318 diag::err_field_incomplete_or_sizeless)) {
18320 Record->setInvalidDecl();
18321 InvalidDecl =
true;
18326 Record->setInvalidDecl();
18327 InvalidDecl =
true;
18335 Diag(
Loc, diag::err_field_with_address_space);
18336 Record->setInvalidDecl();
18337 InvalidDecl =
true;
18345 Diag(
Loc, diag::err_opencl_type_struct_or_union_field) <<
T;
18346 Record->setInvalidDecl();
18347 InvalidDecl =
true;
18352 "__cl_clang_bitfields",
LangOpts)) {
18353 Diag(
Loc, diag::err_opencl_bitfields);
18354 InvalidDecl =
true;
18360 T.hasQualifiers()) {
18361 InvalidDecl =
true;
18362 Diag(
Loc, diag::err_anon_bitfield_qualifiers);
18369 TInfo,
T,
Loc, diag::err_typecheck_field_variable_size))
18370 InvalidDecl =
true;
18375 diag::err_abstract_type_in_decl,
18377 InvalidDecl =
true;
18380 BitWidth =
nullptr;
18386 InvalidDecl =
true;
18387 BitWidth =
nullptr;
18392 if (!InvalidDecl && Mutable) {
18393 unsigned DiagID = 0;
18395 DiagID =
getLangOpts().MSVCCompat ? diag::ext_mutable_reference
18396 : diag::err_mutable_reference;
18397 else if (
T.isConstQualified())
18398 DiagID = diag::err_mutable_const;
18402 if (
D &&
D->getDeclSpec().getStorageClassSpecLoc().isValid())
18403 ErrLoc =
D->getDeclSpec().getStorageClassSpecLoc();
18404 Diag(ErrLoc, DiagID);
18405 if (DiagID != diag::ext_mutable_reference) {
18407 InvalidDecl =
true;
18419 BitWidth, Mutable, InitStyle);
18423 if (PrevDecl && !isa<TagDecl>(PrevDecl) &&
18425 Diag(
Loc, diag::err_duplicate_member) << II;
18431 if (
Record->isUnion()) {
18450 diag::ext_union_member_of_reference_type :
18451 diag::err_union_member_of_reference_type)
18471 if (
getLangOpts().ObjCAutoRefCount &&
ObjC().inferObjCARCLifetime(NewFD))
18474 if (
T.isObjCGCWeak())
18475 Diag(
Loc, diag::warn_attribute_weak_on_field);
18526 if (!FD->
hasAttr<UnavailableAttr>())
18528 UnavailableAttr::IR_ARCFieldWithOwnership,
Loc));
18536 ? diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member
18537 : diag::err_illegal_union_or_anon_struct_member)
18539 << llvm::to_underlying(member);
18554 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
18562 if (!CD->IsClassExtension())
18574 DeclLoc, DeclLoc,
nullptr,
18580 AllIvarDecls.push_back(Ivar);
18592 if (!
Record->hasUserDeclaredDestructor()) {
18600 if (
auto *DD = dyn_cast<CXXDestructorDecl>(
Decl)) {
18601 if (DD->isInvalidDecl())
18605 assert(DD->isIneligibleOrNotSelected() &&
"Selecting a destructor but a destructor was already selected.");
18619 Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(Best->Function));
18623 Msg = diag::err_ambiguous_destructor;
18628 Msg = diag::err_no_viable_destructor;
18639 Record->setInvalidDecl();
18646 Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(OCS.
begin()->Function));
18690 const Expr *Constraints = Method->getTrailingRequiresClause();
18692 SatisfactionStatus.push_back(
true);
18696 SatisfactionStatus.push_back(
false);
18698 SatisfactionStatus.push_back(Satisfaction.
IsSatisfied);
18702 for (
size_t i = 0; i < Methods.size(); i++) {
18703 if (!SatisfactionStatus[i])
18708 OrigMethod = cast<CXXMethodDecl>(MF);
18711 bool AnotherMethodIsMoreConstrained =
false;
18712 for (
size_t j = 0; j < Methods.size(); j++) {
18713 if (i == j || !SatisfactionStatus[j])
18717 OtherMethod = cast<CXXMethodDecl>(MF);
18724 if (!OtherConstraints)
18726 if (!Constraints) {
18727 AnotherMethodIsMoreConstrained =
true;
18732 AnotherMethodIsMoreConstrained)) {
18735 AnotherMethodIsMoreConstrained =
true;
18737 if (AnotherMethodIsMoreConstrained)
18742 if (!AnotherMethodIsMoreConstrained) {
18744 Record->addedEligibleSpecialMemberFunction(Method,
18745 1 << llvm::to_underlying(CSM));
18759 auto *MD = dyn_cast<CXXMethodDecl>(
Decl);
18761 auto *FTD = dyn_cast<FunctionTemplateDecl>(
Decl);
18763 MD = dyn_cast<CXXMethodDecl>(FTD->getTemplatedDecl());
18767 if (
auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
18768 if (CD->isInvalidDecl())
18770 if (CD->isDefaultConstructor())
18771 DefaultConstructors.push_back(MD);
18772 else if (CD->isCopyConstructor())
18773 CopyConstructors.push_back(MD);
18774 else if (CD->isMoveConstructor())
18775 MoveConstructors.push_back(MD);
18777 CopyAssignmentOperators.push_back(MD);
18779 MoveAssignmentOperators.push_back(MD);
18799 assert(EnclosingDecl &&
"missing record or interface decl");
18804 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
18808 case Decl::ObjCCategory:
18811 case Decl::ObjCImplementation:
18813 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
18819 CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(EnclosingDecl);
18823 unsigned NumNamedMembers = 0;
18825 for (
const auto *I :
Record->decls()) {
18826 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
18827 if (IFD->getDeclName())
18844 RecFields.push_back(FD);
18864 bool IsLastField = (i + 1 == Fields.end());
18873 (
Record || isa<ObjCContainerDecl>(EnclosingDecl))) {
18879 unsigned DiagID = 0;
18880 if (!
Record->isUnion() && !IsLastField) {
18883 << llvm::to_underlying(
Record->getTagKind());
18884 Diag((*(i + 1))->getLocation(), diag::note_next_field_declaration);
18888 }
else if (
Record->isUnion())
18890 ? diag::ext_flexible_array_union_ms
18891 : diag::ext_flexible_array_union_gnu;
18892 else if (NumNamedMembers < 1)
18894 ? diag::ext_flexible_array_empty_aggregate_ms
18895 : diag::ext_flexible_array_empty_aggregate_gnu;
18905 if (CXXRecord && CXXRecord->getNumVBases() != 0)
18919 Diag(FD->
getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
18926 Record->setHasFlexibleArrayMember(
true);
18935 diag::err_field_incomplete_or_sizeless)) {
18941 if (
Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
18944 Record->setHasFlexibleArrayMember(
true);
18945 if (!
Record->isUnion()) {
18960 if (isa<ObjCContainerDecl>(EnclosingDecl) &&
18962 diag::err_abstract_type_in_decl,
18967 if (
Record && FDTTy->getDecl()->hasObjectMember())
18968 Record->setHasObjectMember(
true);
18969 if (
Record && FDTTy->getDecl()->hasVolatileMember())
18970 Record->setHasVolatileMember(
true);
18989 FD->
addAttr(UnavailableAttr::CreateImplicit(
18990 Context,
"", UnavailableAttr::IR_ARCFieldWithOwnership,
18994 !
Record->hasObjectMember()) {
18997 Record->setHasObjectMember(
true);
19002 Record->setHasObjectMember(
true);
19005 Record->setHasObjectMember(
true);
19010 !shouldIgnoreForRecordTriviality(FD)) {
19013 Record->setNonTrivialToPrimitiveDefaultInitialize(
true);
19016 Record->setHasNonTrivialToPrimitiveDefaultInitializeCUnion(
true);
19020 Record->setNonTrivialToPrimitiveCopy(
true);
19022 Record->setHasNonTrivialToPrimitiveCopyCUnion(
true);
19025 Record->setNonTrivialToPrimitiveDestroy(
true);
19026 Record->setParamDestroyedInCallee(
true);
19028 Record->setHasNonTrivialToPrimitiveDestructCUnion(
true);
19032 if (RT->getDecl()->getArgPassingRestrictions() ==
19034 Record->setArgPassingRestrictions(
19037 Record->setArgPassingRestrictions(
19042 Record->setHasVolatileMember(
true);
19050 bool Completed =
false;
19054 Parent->isTemplateParamScope())
19055 Record->setInvalidDecl();
19059 if (!CXXRecord->isInvalidDecl()) {
19062 I = CXXRecord->conversion_begin(),
19063 E = CXXRecord->conversion_end(); I !=
E; ++I)
19064 I.setAccess((*I)->getAccess());
19070 if (!CXXRecord->isDependentType()) {
19071 if (!CXXRecord->isInvalidDecl()) {
19075 if (CXXRecord->getNumVBases()) {
19077 CXXRecord->getFinalOverriders(FinalOverriders);
19079 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
19080 MEnd = FinalOverriders.end();
19083 SOEnd = M->second.end();
19084 SO != SOEnd; ++SO) {
19085 assert(SO->second.size() > 0 &&
19086 "Virtual function without overriding functions?");
19087 if (SO->second.size() == 1)
19094 Diag(
Record->getLocation(), diag::err_multiple_final_overriders)
19096 Diag(M->first->getLocation(),
19097 diag::note_overridden_virtual_function);
19099 OM = SO->second.begin(),
19100 OMEnd = SO->second.end();
19102 Diag(OM->Method->getLocation(), diag::note_final_overrider)
19103 << (
const NamedDecl *)M->first << OM->Method->getParent();
19105 Record->setInvalidDecl();
19108 CXXRecord->completeDefinition(&FinalOverriders);
19118 Record->completeDefinition();
19124 auto IsFunctionPointerOrForwardDecl = [&](
const Decl *
D) {
19125 const FieldDecl *FD = dyn_cast<FieldDecl>(
D);
19138 if (
const auto *TD = dyn_cast<TagDecl>(
D))
19139 return !TD->isCompleteDefinition();
19143 if (isa<PointerType>(FieldType)) {
19153 (
Record->hasAttr<RandomizeLayoutAttr>() ||
19154 (!
Record->hasAttr<NoRandomizeLayoutAttr>() &&
19155 llvm::all_of(
Record->decls(), IsFunctionPointerOrForwardDecl))) &&
19157 !
Record->isRandomized()) {
19161 Record->reorderDecls(NewDeclOrdering);
19166 auto *Dtor = CXXRecord->getDestructor();
19167 if (Dtor && Dtor->isImplicit() &&
19169 CXXRecord->setImplicitDestructorIsDeleted();
19174 if (
Record->hasAttrs()) {
19177 if (
const MSInheritanceAttr *IA =
Record->getAttr<MSInheritanceAttr>())
19179 IA->getRange(), IA->getBestCase(),
19180 IA->getInheritanceModel());
19186 bool CheckForZeroSize;
19188 CheckForZeroSize =
true;
19193 CXXRecord->getLexicalDeclContext()->isExternCContext() &&
19195 CXXRecord->isCLike();
19197 if (CheckForZeroSize) {
19198 bool ZeroSize =
true;
19199 bool IsEmpty =
true;
19200 unsigned NonBitFields = 0;
19203 (NonBitFields == 0 || ZeroSize) && I !=
E; ++I) {
19205 if (I->isUnnamedBitField()) {
19206 if (!I->isZeroLengthBitField(
Context))
19210 QualType FieldType = I->getType();
19222 diag::warn_zero_size_struct_union_in_extern_c :
19223 diag::warn_zero_size_struct_union_compat)
19224 << IsEmpty <<
Record->isUnion() << (NonBitFields > 1);
19229 if (NonBitFields == 0 && !
getLangOpts().CPlusPlus) {
19230 Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
19231 diag::ext_no_named_members_in_struct_union)
19239 ID->setEndOfDefinitionLoc(RBrac);
19241 for (
unsigned i = 0, e = RecFields.size(); i != e; ++i) {
19243 ID->addDecl(ClsFields[i]);
19247 if (ID->getSuperClass())
19250 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
19251 assert(IMPDecl &&
"ActOnFields - missing ObjCImplementationDecl");
19252 for (
unsigned I = 0, N = RecFields.size(); I != N; ++I)
19258 IMPDecl->setIvarLBraceLoc(LBrac);
19259 IMPDecl->setIvarRBraceLoc(RBrac);
19261 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
19269 for (
unsigned i = 0, e = RecFields.size(); i != e; ++i) {
19273 Diag(ClsFields[i]->getLocation(),
19274 diag::err_duplicate_ivar_declaration);
19275 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
19281 Diag(ClsFields[i]->getLocation(),
19282 diag::err_duplicate_ivar_declaration);
19283 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
19289 CDecl->addDecl(ClsFields[i]);
19291 CDecl->setIvarLBraceLoc(LBrac);
19292 CDecl->setIvarRBraceLoc(RBrac);
19301 llvm::APSInt &
Value,
19304 "Integral type required!");
19307 if (
Value.isUnsigned() ||
Value.isNonNegative()) {
19310 return Value.getActiveBits() <= BitWidth;
19312 return Value.getSignificantBits() <= BitWidth;
19322 const unsigned NumTypes = 4;
19323 QualType SignedIntegralTypes[NumTypes] = {
19326 QualType UnsignedIntegralTypes[NumTypes] = {
19333 : UnsignedIntegralTypes;
19334 for (
unsigned I = 0; I != NumTypes; ++I)
19347 llvm::APSInt EnumVal(IntWidth);
19367 EltTy =
Enum->getIntegerType();
19374 Val = Converted.
get();
19381 if (
Enum->isComplete()) {
19382 EltTy =
Enum->getIntegerType();
19391 .isWindowsMSVCEnvironment()) {
19392 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
19394 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
19418 Diag(IdLoc, diag::ext_enum_value_not_int)
19420 << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
19432 if (
Enum->isDependentType())
19434 else if (!LastEnumConst) {
19443 if (
Enum->isFixed()) {
19444 EltTy =
Enum->getIntegerType();
19453 EltTy = LastEnumConst->
getType();
19456 if (EnumVal < LastEnumConst->getInitVal()) {
19468 if (
T.isNull() ||
Enum->isFixed()) {
19472 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
19474 if (
Enum->isFixed())
19476 Diag(IdLoc, diag::err_enumerator_wrapped)
19480 Diag(IdLoc, diag::ext_enumerator_increment_too_large)
19500 Diag(IdLoc, diag::warn_enum_value_overflow);
19505 Diag(IdLoc, diag::ext_enum_value_not_int)
19533 auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl);
19537 EnumDecl *PrevED = cast<EnumDecl>(PrevECD->getDeclContext());
19552 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
19554 cast_or_null<EnumConstantDecl>(lastEnumConst);
19563 RedeclarationKind::ForVisibleRedeclaration);
19571 PrevDecl =
nullptr;
19589 if (!TheEnumDecl->
isScoped() && isa<ValueDecl>(PrevDecl)) {
19597 "Received TagDecl when not in C++!");
19599 if (isa<EnumConstantDecl>(PrevDecl))
19600 Diag(IdLoc, diag::err_redefinition_of_enumerator) <<
Id;
19602 Diag(IdLoc, diag::err_redefinition) <<
Id;
19635 if (!BO->isAdditiveOp())
19643 InitExpr = BO->getLHS();
19647 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
19667 if (!
Enum->getIdentifier())
19671 if (
Enum->getNumPositiveBits() > 63 ||
Enum->getNumNegativeBits() > 64)
19680 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
19683 typedef std::unordered_map<int64_t, DeclOrVector> ValueToVectorMap;
19687 llvm::APSInt Val =
D->getInitVal();
19688 return Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue();
19691 DuplicatesVector DupVector;
19692 ValueToVectorMap EnumMap;
19696 for (
auto *Element : Elements) {
19710 EnumMap.insert({EnumConstantToKey(ECD), ECD});
19713 if (EnumMap.size() == 0)
19717 for (
auto *Element : Elements) {
19723 auto Iter = EnumMap.find(EnumConstantToKey(ECD));
19724 if (
Iter == EnumMap.end())
19727 DeclOrVector& Entry =
Iter->second;
19734 auto Vec = std::make_unique<ECDVector>();
19736 Vec->push_back(ECD);
19743 DupVector.emplace_back(std::move(Vec));
19747 ECDVector *Vec = Entry.get<ECDVector*>();
19749 if (*Vec->begin() == ECD)
19752 Vec->push_back(ECD);
19756 for (
const auto &Vec : DupVector) {
19757 assert(Vec->size() > 1 &&
"ECDVector should have at least 2 elements.");
19760 auto *FirstECD = Vec->front();
19761 S.
Diag(FirstECD->getLocation(), diag::warn_duplicate_enum_values)
19762 << FirstECD <<
toString(FirstECD->getInitVal(), 10)
19763 << FirstECD->getSourceRange();
19767 for (
auto *ECD : llvm::drop_begin(*Vec))
19768 S.
Diag(ECD->getLocation(), diag::note_duplicate_element)
19769 << ECD <<
toString(ECD->getInitVal(), 10)
19770 << ECD->getSourceRange();
19775 bool AllowMask)
const {
19776 assert(ED->
isClosedFlag() &&
"looking for value in non-flag or open enum");
19779 auto R =
FlagBitsCache.insert(std::make_pair(ED, llvm::APInt()));
19780 llvm::APInt &FlagBits = R.first->second;
19784 const auto &EVal =
E->getInitVal();
19786 if (EVal.isPowerOf2())
19787 FlagBits = FlagBits.zext(EVal.getBitWidth()) | EVal;
19799 llvm::APInt FlagMask = ~FlagBits.zextOrTrunc(Val.getBitWidth());
19800 return !(FlagMask & Val) || (AllowMask && !(FlagMask & ~Val));
19812 if (
Enum->isDependentType()) {
19813 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
19815 cast_or_null<EnumConstantDecl>(Elements[i]);
19816 if (!ECD)
continue;
19834 unsigned NumNegativeBits = 0;
19835 unsigned NumPositiveBits = 0;
19837 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
19839 cast_or_null<EnumConstantDecl>(Elements[i]);
19840 if (!ECD)
continue;
19842 const llvm::APSInt &InitVal = ECD->
getInitVal();
19845 if (InitVal.isUnsigned() || InitVal.isNonNegative()) {
19848 unsigned ActiveBits = InitVal.getActiveBits();
19849 NumPositiveBits = std::max({NumPositiveBits, ActiveBits, 1u});
19852 std::max(NumNegativeBits, (
unsigned)InitVal.getSignificantBits());
19860 if (!NumPositiveBits && !NumNegativeBits)
19861 NumPositiveBits = 1;
19865 unsigned BestWidth;
19878 bool Packed =
Enum->hasAttr<PackedAttr>();
19886 if (
Enum->isComplete()) {
19887 BestType =
Enum->getIntegerType();
19891 BestPromotionType = BestType;
19895 else if (NumNegativeBits) {
19899 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
19901 BestWidth = CharWidth;
19902 }
else if (Packed && NumNegativeBits <= ShortWidth &&
19903 NumPositiveBits < ShortWidth) {
19905 BestWidth = ShortWidth;
19906 }
else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
19908 BestWidth = IntWidth;
19912 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
19917 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
19918 Diag(
Enum->getLocation(), diag::ext_enum_too_large);
19922 BestPromotionType = (BestWidth <= IntWidth ?
Context.
IntTy : BestType);
19927 if (Packed && NumPositiveBits <= CharWidth) {
19930 BestWidth = CharWidth;
19931 }
else if (Packed && NumPositiveBits <= ShortWidth) {
19934 BestWidth = ShortWidth;
19935 }
else if (NumPositiveBits <= IntWidth) {
19937 BestWidth = IntWidth;
19939 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
19941 }
else if (NumPositiveBits <=
19945 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
19949 if (NumPositiveBits > BestWidth) {
19954 Diag(
Enum->getLocation(), diag::ext_enum_too_large);
19958 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
19965 for (
auto *
D : Elements) {
19966 auto *ECD = cast_or_null<EnumConstantDecl>(
D);
19967 if (!ECD)
continue;
19976 llvm::APSInt InitVal = ECD->getInitVal();
19984 !
Enum->isFixed() &&
19987 NewWidth = IntWidth;
19989 }
else if (ECD->getType() == BestType) {
19999 NewWidth = BestWidth;
20004 InitVal = InitVal.extOrTrunc(NewWidth);
20005 InitVal.setIsSigned(NewSign);
20006 ECD->setInitVal(
Context, InitVal);
20009 if (ECD->getInitExpr() &&
20012 Context, NewTy, CK_IntegralCast, ECD->getInitExpr(),
20020 ECD->setType(NewTy);
20023 Enum->completeDefinition(BestType, BestPromotionType,
20024 NumPositiveBits, NumNegativeBits);
20028 if (
Enum->isClosedFlag()) {
20029 for (
Decl *
D : Elements) {
20031 if (!ECD)
continue;
20034 if (InitVal != 0 && !InitVal.isPowerOf2() &&
20042 if (
Enum->hasAttrs())
20052 AsmString, StartLoc,
20068 D->setStmt(Statement);
20083 AsmLabelAttr *
Attr = AsmLabelAttr::CreateImplicit(
20090 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
20094 Diag(PrevDecl->
getLocation(), diag::warn_redefine_extname_not_applied)
20095 << (isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl;
20107 PrevDecl->
addAttr(WeakAttr::CreateImplicit(
Context, PragmaLoc));
20122 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
20123 if (!PrevDecl->
hasAttr<AliasAttr>())
20124 if (
NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
20133 assert(FD &&
"Expected non-null FunctionDecl");
20145 auto IsEmittedForExternalSymbol = [
this, FD]() {
20155 if (
LangOpts.OpenMPIsTargetDevice) {
20158 std::optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
20165 if (*DevTy == OMPDeclareTargetDeclAttr::DT_Host)
20169 if (
OpenMP().isInOpenMPDeclareTargetContext() || DevTy)
20170 if (IsEmittedForExternalSymbol())
20176 }
else if (
LangOpts.OpenMP > 45) {
20180 std::optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
20183 if (*DevTy == OMPDeclareTargetDeclAttr::DT_NoHost)
20202 if (IsEmittedForExternalSymbol())
20227 Diag(NewLoc, diag::warn_conflicting_func_effects)
20228 << Conflict.Kept.description() << Conflict.Rejected.description();
20229 Diag(OldLoc, diag::note_previous_declaration);
20243 Diag(NewAttrLoc, diag::err_attributes_are_not_compatible)
20245 << (
"'" + PrevEC.description() +
"'") <<
false;
20256 if (PrevEC.Cond.getCondition() !=
nullptr)
20262 if (PrevEC.Effect.oppositeKind() == NewKind)
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
static constexpr Builtin::Info BuiltinInfo[]
Defines enum values for all the target-independent builtin functions.
enum clang::sema::@1651::IndirectLocalPathEntry::EntryKind Kind
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
static bool isDeclExternC(const T &D)
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines helper utilities for supporting the HLSL runtime environment.
static const Decl * getCanonicalDecl(const Decl *D)
static const GlobalDecl isTemplate(GlobalDecl GD, const TemplateArgumentList *&TemplateArgs)
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::Architecture Architecture
llvm::MachO::Record Record
static bool isExternC(const NamedDecl *ND)
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
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 diagnoseImplicitlyRetainedSelf(Sema &S)
static void SetNestedNameSpecifier(Sema &S, DeclaratorDecl *DD, Declarator &D)
static UnqualifiedTypeNameLookupResult lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc, const CXXRecordDecl *RD)
Tries to perform unqualified lookup of the type decls in bases for dependent class.
static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, const FunctionDecl *&PossiblePrototype)
static bool PreviousDeclsHaveMultiVersionAttribute(const FunctionDecl *FD)
static ParsedType recoverFromTypeInKnownDependentBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc)
static void mergeParamDeclTypes(ParmVarDecl *NewParam, const ParmVarDecl *OldParam, Sema &S)
static void adjustDeclContextForDeclaratorDecl(DeclaratorDecl *NewD, DeclaratorDecl *OldD)
If necessary, adjust the semantic declaration context for a qualified declaration to name the correct...
static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken)
Determine whether the given result set contains either a type name or.
static void FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL)
static bool AllowOverloadingOfFunction(const LookupResult &Previous, ASTContext &Context, const FunctionDecl *New)
Determine whether overloading is allowed for a new function declaration considering prior declaration...
static TypeSourceInfo * TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized)
Helper method to turn variable array types into constant array types in certain situations which woul...
static StringRef getHeaderName(Builtin::Context &BuiltinInfo, unsigned ID, ASTContext::GetBuiltinTypeError Error)
static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D)
static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS, ExpectedDecl *New)
Check whether a redeclaration of an entity introduced by a using-declaration is valid,...
static bool mergeDeclAttribute(Sema &S, NamedDecl *D, const InheritableAttr *Attr, Sema::AvailabilityMergeKind AMK)
static ShadowedDeclKind computeShadowedDeclKind(const NamedDecl *ShadowedDecl, const DeclContext *OldDC)
Determine what kind of declaration we're shadowing.
static void checkIsValidOpenCLKernelParameter(Sema &S, Declarator &D, ParmVarDecl *Param, llvm::SmallPtrSetImpl< const Type * > &ValidTypes)
static void mergeParamDeclAttributes(ParmVarDecl *newDecl, const ParmVarDecl *oldDecl, Sema &S)
mergeParamDeclAttributes - Copy attributes from the old parameter to the new one.
void emitReadOnlyPlacementAttrWarning(Sema &S, const VarDecl *VD)
static bool CheckC23ConstexprVarType(Sema &SemaRef, SourceLocation VarLoc, QualType T)
static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous)
Check the validity of a mulitversion function declaration.
static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old)
Merge alignment attributes from Old to New, taking into account the special semantics of C11's _Align...
static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, LookupResult &Previous)
static void CheckConstPureAttributesUsage(Sema &S, FunctionDecl *NewFD)
static bool FindPossiblePrototype(const FunctionDecl *FD, const FunctionDecl *&PossiblePrototype)
static bool MultiVersionTypesCompatible(FunctionDecl *Old, FunctionDecl *New)
static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, FixItHint &Hint)
static void CheckExplicitObjectParameter(Sema &S, ParmVarDecl *P, SourceLocation ExplicitThisLoc)
static NestedNameSpecifier * synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC)
static void patchDefaultTargetVersion(FunctionDecl *From, FunctionDecl *To)
static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD)
Given that we are within the definition of the given function, will that definition behave like C99's...
static bool isRepresentableIntegerValue(ASTContext &Context, llvm::APSInt &Value, QualType T)
Determine whether the given integral value is representable within the given type T.
static void CheckForDuplicateEnumValues(Sema &S, ArrayRef< Decl * > Elements, EnumDecl *Enum, QualType EnumType)
static unsigned GetDiagnosticTypeSpecifierID(const DeclSpec &DS)
static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old)
checkNewAttributesAfterDef - If we already have a definition, check that there are no new attributes ...
static bool isClassCompatTagKind(TagTypeKind Tag)
Determine if tag kind is a class-key compatible with class for redeclaration (class,...
static bool hasIdenticalPassObjectSizeAttrs(const FunctionDecl *A, const FunctionDecl *B)
static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND)
static bool hasSimilarParameters(ASTContext &Context, FunctionDecl *Declaration, FunctionDecl *Definition, SmallVectorImpl< unsigned > &Params)
hasSimilarParameters - Determine whether the C++ functions Declaration and Definition have "nearly" m...
static NonCLikeKind getNonCLikeKindForAnonymousStruct(const CXXRecordDecl *RD)
Determine whether a class is C-like, according to the rules of C++ [dcl.typedef] for anonymous classe...
static FunctionDecl * CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, DeclContext *DC, QualType &R, TypeSourceInfo *TInfo, StorageClass SC, bool &IsVirtualOkay)
static Scope * getTagInjectionScope(Scope *S, const LangOptions &LangOpts)
Find the Scope in which a tag is implicitly declared if we see an elaborated type specifier in the sp...
static bool methodHasName(const FunctionDecl *FD, StringRef Name)
static std::pair< diag::kind, SourceLocation > getNoteDiagForInvalidRedeclaration(const T *Old, const T *New)
static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, LookupResult &Previous)
Apply special rules for handling extern "C" declarations.
static bool DeclHasAttr(const Decl *D, const Attr *A)
DeclhasAttr - returns true if decl Declaration already has the target attribute.
static bool isOpenCLSizeDependentType(ASTContext &C, QualType Ty)
static void diagnoseMissingConstinit(Sema &S, const VarDecl *InitDecl, const ConstInitAttr *CIAttr, bool AttrBeforeInit)
static bool shouldWarnIfShadowedDecl(const DiagnosticsEngine &Diags, const LookupResult &R)
static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S, SourceLocation NameLoc)
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
static bool CheckAnonMemberRedeclaration(Sema &SemaRef, Scope *S, DeclContext *Owner, DeclarationName Name, SourceLocation NameLoc, bool IsUnion, StorageClass SC)
We are trying to inject an anonymous member into the given scope; check if there's an existing declar...
static bool checkGlobalOrExternCConflict(Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous)
Check for conflict between this global or extern "C" declaration and previous global or extern "C" de...
static bool ShouldDiagnoseUnusedDecl(const LangOptions &LangOpts, const NamedDecl *D)
static bool isStdBuiltin(ASTContext &Ctx, FunctionDecl *FD, unsigned BuiltinID)
Determine whether a declaration matches a known function in namespace std.
static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, DeclContext *Owner, RecordDecl *AnonRecord, AccessSpecifier AS, StorageClass SC, SmallVectorImpl< NamedDecl * > &Chaining)
InjectAnonymousStructOrUnionMembers - Inject the members of the anonymous struct or union AnonRecord ...
@ InvalidAddrSpacePtrKernelParam
static bool isFromSystemHeader(SourceManager &SM, const Decl *D)
Returns true if the declaration is declared in a system header or from a system macro.
static bool AreSpecialMemberFunctionsSameKind(ASTContext &Context, CXXMethodDecl *M1, CXXMethodDecl *M2, CXXSpecialMemberKind CSM)
[class.mem.special]p5 Two special member functions are of the same kind if:
static const CXXRecordDecl * findRecordWithDependentBasesOfEnclosingMethod(const DeclContext *DC)
Find the parent class with dependent bases of the innermost enclosing method context.
static void ComputeSelectedDestructor(Sema &S, CXXRecordDecl *Record)
[class.dtor]p4: At the end of the definition of a class, overload resolution is performed among the p...
static bool shouldConsiderLinkage(const VarDecl *VD)
static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record)
static bool CheckMultiVersionAdditionalRules(Sema &S, const FunctionDecl *OldFD, const FunctionDecl *NewFD, bool CausesMV, MultiVersionKind MVKind)
static DeclContext * getTagInjectionContext(DeclContext *DC)
Find the DeclContext in which a tag is implicitly declared if we see an elaborated type specifier in ...
static bool EquivalentArrayTypes(QualType Old, QualType New, const ASTContext &Ctx)
static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New)
static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for redeclaration diagnostic message.
static void CheckPoppedLabel(LabelDecl *L, Sema &S, Sema::DiagReceiverTy DiagReceiver)
static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl *Old)
static NamedDecl * DiagnoseInvalidRedeclaration(Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S)
Generate diagnostics for an invalid function redeclaration.
static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, DeclarationName Name)
RebuildDeclaratorInCurrentInstantiation - Checks whether the given declarator needs to be rebuilt in ...
static void SetEligibleMethods(Sema &S, CXXRecordDecl *Record, ArrayRef< CXXMethodDecl * > Methods, CXXSpecialMemberKind CSM)
[class.mem.special]p6: An eligible special member function is a special member function for which:
static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc)
static bool hasParsedAttr(Scope *S, const Declarator &PD, ParsedAttr::Kind Kind)
ShadowedDeclKind
Enum describing the select options in diag::warn_decl_shadow.
static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S)
static bool canRedefineFunction(const FunctionDecl *FD, const LangOptions &LangOpts)
canRedefineFunction - checks if a function can be redefined.
static OpenCLParamType getOpenCLKernelParameterType(Sema &S, QualType PT)
static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, SourceLocation DefaultInitLoc)
static bool isDefaultStdCall(FunctionDecl *FD, Sema &S)
static bool diagnoseOpenCLTypes(Sema &Se, VarDecl *NewVD)
Returns true if there hasn't been any invalid type diagnosed.
static void RemoveUsingDecls(LookupResult &R)
Removes using shadow declarations not at class scope from the lookup results.
static void ComputeSpecialMemberFunctionsEligiblity(Sema &S, CXXRecordDecl *Record)
static bool AttrCompatibleWithMultiVersion(attr::Kind Kind, MultiVersionKind MVKind)
static bool isUsingDeclNotAtClassScope(NamedDecl *D)
static const NamedDecl * getDefinition(const Decl *D)
static QualType TryToFixInvalidVariablyModifiedType(QualType T, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized)
Helper method to turn variable array types into constant array types in certain situations which woul...
static bool hasDeducedAuto(DeclaratorDecl *DD)
static void copyAttrFromTypedefToDecl(Sema &S, Decl *D, const TypedefType *TT)
static QualType getCoreType(QualType Ty)
static bool isMainFileLoc(const Sema &S, SourceLocation Loc)
static bool CheckMultiVersionValue(Sema &S, const FunctionDecl *FD)
Check the target or target_version attribute of the function for MultiVersion validity.
static bool isOutOfScopePreviousDeclaration(NamedDecl *, DeclContext *, ASTContext &)
Determines whether the given declaration is an out-of-scope previous declaration.
static StorageClass StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS)
StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to a VarDecl::StorageClass.
static ParsedType buildNamedType(Sema &S, const CXXScopeSpec *SS, QualType T, SourceLocation NameLoc, bool WantNontrivialTypeSourceInfo=true)
Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
static bool CheckMultiVersionAdditionalDecl(Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, const CPUDispatchAttr *NewCPUDisp, const CPUSpecificAttr *NewCPUSpec, const TargetClonesAttr *NewClones, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous)
Check the validity of a new function declaration being added to an existing multiversioned declaratio...
static SourceLocation getCaptureLocation(const LambdaScopeInfo *LSI, const VarDecl *VD)
Return the location of the capture if the given lambda captures the given variable VD,...
static bool CheckMultiVersionFirstFunction(Sema &S, FunctionDecl *FD)
Check the validity of a multiversion function declaration that is the first of its kind.
static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, NamedDecl *NewDecl, bool IsSpecialization, bool IsDefinition)
static bool checkNonMultiVersionCompatAttributes(Sema &S, const FunctionDecl *FD, const FunctionDecl *CausedFD, MultiVersionKind MVKind)
static void filterNonConflictingPreviousTypedefDecls(Sema &S, const TypedefNameDecl *Decl, LookupResult &Previous)
Typedef declarations don't have linkage, but they still denote the same entity if their types are the...
static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum)
static QualType getNextLargerIntegralType(ASTContext &Context, QualType T)
static bool isIncompleteDeclExternC(Sema &S, const T *D)
Determine whether a variable is extern "C" prior to attaching an initializer.
static bool isAttributeTargetADefinition(Decl *D)
static Attr * getImplicitCodeSegAttrFromClass(Sema &S, const FunctionDecl *FD)
Return a CodeSegAttr from a containing class.
static bool CheckDeclarationCausesMultiVersioning(Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous)
static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D)
Check for this common pattern:
static bool isAcceptableTagRedeclContext(Sema &S, DeclContext *OldDC, DeclContext *NewDC)
Determine whether a tag originally declared in context OldDC can be redeclared with an unqualified na...
static bool isRecordType(QualType T)
This file declares semantic analysis for HLSL constructs.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
This file declares semantic analysis functions specific to PowerPC.
This file declares semantic analysis functions specific to RISC-V.
This file declares semantic analysis functions specific to Swift.
This file declares semantic analysis functions specific to Wasm.
static CharSourceRange getRange(const CharSourceRange &EditRange, const SourceManager &SM, const LangOptions &LangOpts, bool IncludeMacroExpansion)
Defines the SourceManager interface.
static QualType getPointeeType(const MemRegion *R)
C Language Family Type Representation.
const NestedNameSpecifier * Specifier
RAII object that pops an ExpressionEvaluationContext when exiting a function body.
ExitFunctionBodyRAII(Sema &S, bool IsLambda)
llvm::APInt getValue() const
virtual void HandleTagDeclDefinition(TagDecl *D)
HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.
virtual void HandleInlineFunctionDefinition(FunctionDecl *D)
This callback is invoked each time an inline (method or friend) function definition in a class is com...
virtual bool shouldSkipFunctionBody(Decl *D)
This callback is called for each function if the Parser was initialized with SkipFunctionBodies set t...
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 ...
QualType getUsingType(const UsingShadowDecl *Found, QualType Underlying) const
SourceManager & getSourceManager()
TranslationUnitDecl * getTranslationUnitDecl() const
const ConstantArrayType * getAsConstantArrayType(QualType T) const
QualType getParenType(QualType NamedType) const
unsigned getIntWidth(QualType T) const
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
ExternCContextDecl * getExternCContextDecl() const
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
DeclarationNameTable DeclarationNames
QualType getObjCClassType() const
Represents the Objective-C Class type.
QualType getRecordType(const RecordDecl *Decl) const
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
void setObjCIdRedefinitionType(QualType RedefType)
Set the user-written type that redefines id.
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.
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
void setObjCSelRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U) const
Determine whether two function types are the same, ignoring exception specifications in cases where t...
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Builtin::Context & BuiltinInfo
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
void addModuleInitializer(Module *M, Decl *Init)
Add a declaration to the list of declarations that are initialized for a module.
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.
void attachCommentsToJustParsedDecls(ArrayRef< Decl * > Decls, const Preprocessor *PP)
Searches existing comments for doc comments that should be attached to Decls.
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
void setucontext_tDecl(TypeDecl *ucontext_tDecl)
Set the type for the C ucontext_t type.
CanQualType UnsignedLongTy
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
bool hasAnyFunctionEffects() const
MangleNumberingContext & getManglingNumberContext(const DeclContext *DC)
Retrieve the context for computing mangling numbers in the given DeclContext.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
void setNonKeyFunction(const CXXMethodDecl *method)
Observe that the given method cannot be a key function.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
const clang::PrintingPolicy & getPrintingPolicy() const
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false, bool IsConditionalOperator=false)
QualType getObjCIdType() const
Represents the Objective-CC id type.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
void setManglingNumber(const NamedDecl *ND, unsigned Number)
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
CanQualType UnsignedLongLongTy
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
CanQualType UnsignedShortTy
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
void setcudaConfigureCallDecl(FunctionDecl *FD)
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
const VariableArrayType * getAsVariableArrayType(QualType T) const
void setObjCClassRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
void ResetObjCLayout(const ObjCContainerDecl *CD)
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
const TargetInfo & getTargetInfo() const
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
void setjmp_bufDecl(TypeDecl *jmp_bufDecl)
Set the type for the C jmp_buf type.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
QualType mergeObjCGCQualifiers(QualType, QualType)
mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 'RHS' attributes and ret...
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
LangAS getLangASForBuiltinAddressSpace(unsigned AS) const
bool hasSameFunctionTypeIgnoringPtrSizes(QualType T, QualType U)
Determine whether two function types are the same, ignoring pointer sizes in the return type and para...
TemplateName getAssumedTemplateName(DeclarationName Name) const
Retrieve a template name representing an unqualified-id that has been assumed to name a template for ...
@ GE_Missing_stdio
Missing a type from <stdio.h>
@ GE_Missing_type
Missing a type.
@ GE_Missing_ucontext
Missing a type from <ucontext.h>
@ GE_Missing_setjmp
Missing a type from <setjmp.h>
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
The result of parsing/analyzing an expression, statement etc.
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
Wrapper for source info for arrays.
SourceLocation getLBracketLoc() const
Expr * getSizeExpr() const
TypeLoc getElementLoc() const
SourceLocation getRBracketLoc() const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
Attr - This represents one attribute.
attr::Kind getKind() const
Attr * clone(ASTContext &C) const
SourceLocation getLocation() const
@ AS_Declspec
__declspec(...)
SourceRange getRange() const
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
AttributeFactory & getFactory() const
Type source information for an attributed type.
TypeLoc getModifiedLoc() const
The modified type, which is generally canonically different from the attribute type.
An attributed type is a type to which a type attribute has been applied.
QualType getModifiedType() const
bool isCallingConv() const
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
AutoTypeKeyword getKeyword() const
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
A builtin binary operation expression such as "x + y" or "x <= y".
A binding in a decomposition declaration.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
bool doesNotEscape() const
This class is used for builtin types like 'int'.
Holds information about both target-independent and target-specific builtins, allowing easy queries b...
bool performsCallback(unsigned ID, llvm::SmallVectorImpl< int > &Encoding) const
Determine whether this builtin has callback behavior (see llvm::AbstractCallSites for details).
bool isAuxBuiltinID(unsigned ID) const
Return true if builtin ID belongs to AuxTarget.
const char * getHeaderName(unsigned ID) const
If this is a library function that comes from a specific header, retrieve that header name.
llvm::StringRef getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
bool isReturnsTwice(unsigned ID) const
Return true if we know this builtin can return twice.
bool isImmediate(unsigned ID) const
Returns true if this is an immediate (consteval) function.
bool isConstWithoutErrnoAndExceptions(unsigned ID) const
Return true if this function has no side effects and doesn't read memory, except for possibly errno o...
bool allowTypeMismatch(unsigned ID) const
Determines whether a declaration of this builtin should be recognized even if the type doesn't match ...
bool isTSBuiltin(unsigned ID) const
Return true if this function is a target-specific builtin.
bool isHeaderDependentFunction(unsigned ID) const
Returns true if this builtin requires appropriate header in other compilers.
bool isScanfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg)
Determine whether this builtin is like scanf in its formatting rules and, if so, set the index to the...
bool isInStdNamespace(unsigned ID) const
Determines whether this builtin is a C++ standard library function that lives in (possibly-versioned)...
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc",...
bool isPrintfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg)
Determine whether this builtin is like printf in its formatting rules and, if so, set the index to th...
bool isConstWithoutExceptions(unsigned ID) const
bool isPredefinedRuntimeFunction(unsigned ID) const
Determines whether this builtin is a predefined compiler-rt/libgcc function, such as "__clear_cache",...
bool isPure(unsigned ID) const
Return true if this function has no side effects.
bool isNoThrow(unsigned ID) const
Return true if we know this builtin never throws an exception.
bool isConst(unsigned ID) const
Return true if this function has no side effects and doesn't read memory.
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
Represents a base class of a C++ class.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getEndLoc() const LLVM_READONLY
Represents a call to a C++ constructor.
Represents a C++ constructor within a class.
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor(), Expr *TrailingRequiresClause=nullptr)
Represents a C++ conversion function within a class.
static CXXConversionDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation, CXXConstructorDecl *Ctor=nullptr, DeductionCandidate Kind=DeductionCandidate::Normal)
Represents a C++ destructor within a class.
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
A mapping from each virtual member function to its set of final overriders.
Represents a static or instance method of a struct/union/class.
bool isExplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An explicit object member function is a non-static member function with an explic...
void addOverriddenMethod(const CXXMethodDecl *MD)
QualType getFunctionObjectParameterReferenceType() const
Return the type of the object pointed by this.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Qualifiers getMethodQualifiers() const
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
A call to an overloaded operator written using operator syntax.
Represents a C++ struct/union/class.
bool hasNonTrivialCopyAssignment() const
Determine whether this class has a non-trivial copy assignment operator (C++ [class....
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
base_class_iterator bases_end()
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
bool hasNonTrivialDestructor() const
Determine whether this class has a non-trivial destructor (C++ [class.dtor]p3)
CXXRecordDecl * getDefinition() const
unsigned getNumBases() const
Retrieves the number of base classes of this class.
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths, bool LookupInDependent=false) const
Look for entities within the base classes of this C++ class, transitively searching all base class su...
base_class_iterator bases_begin()
capture_const_range captures() const
bool hasDefinition() const
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
LambdaCaptureDefault getLambdaCaptureDefault() const
void setDescribedClassTemplate(ClassTemplateDecl *Template)
bool hasNonTrivialCopyConstructor() const
Determine whether this class has a non-trivial copy constructor (C++ [class.copy]p6,...
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
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).
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
static CharSourceRange getCharRange(SourceRange R)
CharUnits - This is an opaque type for sizes expressed in character units.
bool isZero() const
isZero - Test whether the quantity equals zero.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Declaration of a class template.
bool exprNeedsCleanups() const
ConditionalOperator - The ?: ternary operator.
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
llvm::APInt getSize() const
Return the constant array size as an APInt.
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...
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isFileContext() const
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
bool isObjCContainer() const
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
const BlockDecl * getInnermostBlockDecl() const
Return this DeclContext if it is a BlockDecl.
bool isTranslationUnit() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void removeDecl(Decl *D)
Removes a declaration from this context.
void addDecl(Decl *D)
Add the declaration D into this context.
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Decl::Kind getDeclKind() const
DeclContext * getNonTransparentContext()
Simple template class for restricting typo correction candidates to ones having a single Decl* of the...
static DeclGroupRef Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
A reference to a declared variable, function, enum, etc.
SourceLocation getBeginLoc() const LLVM_READONLY
Captures information about "declaration specifiers".
bool isVirtualSpecified() const
bool isModulePrivateSpecified() const
static const TST TST_typeof_unqualType
bool hasAutoTypeSpec() const
static const TST TST_typename
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec and return false if there was no error.
bool isNoreturnSpecified() const
TST getTypeSpecType() const
SourceLocation getStorageClassSpecLoc() const
SCS getStorageClassSpec() const
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
SourceLocation getBeginLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
void SetRangeEnd(SourceLocation Loc)
static const TST TST_interface
static const TST TST_typeofExpr
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
void SetRangeStart(SourceLocation Loc)
SourceLocation getNoreturnSpecLoc() const
bool isExternInLinkageSpec() const
static const TST TST_union
SCS
storage-class-specifier
SourceLocation getExplicitSpecLoc() const
SourceLocation getModulePrivateSpecLoc() const
bool isMissingDeclaratorOk()
Checks if this DeclSpec can stand alone, without a Declarator.
ParsedType getRepAsType() const
void UpdateTypeRep(ParsedType Rep)
TSCS getThreadStorageClassSpec() const
ParsedAttributes & getAttributes()
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
SourceLocation getConstSpecLoc() const
Expr * getRepAsExpr() const
static const TST TST_enum
static const TST TST_decltype
static bool isDeclRep(TST T)
bool isInlineSpecified() const
SourceLocation getRestrictSpecLoc() const
static const TST TST_typeof_unqualExpr
static const TST TST_class
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
static const TST TST_atomic
SourceLocation getThreadStorageClassSpecLoc() const
Decl * getRepAsDecl() const
static const TST TST_unspecified
SourceLocation getAtomicSpecLoc() const
SourceLocation getVirtualSpecLoc() const
SourceLocation getConstexprSpecLoc() const
SourceLocation getTypeSpecTypeLoc() const
void UpdateExprRep(Expr *Rep)
static const TSCS TSCS_thread_local
static const TST TST_error
bool isTypeSpecOwned() const
SourceLocation getInlineSpecLoc() const
SourceLocation getUnalignedSpecLoc() const
SourceLocation getVolatileSpecLoc() const
FriendSpecified isFriendSpecified() const
bool hasExplicitSpecifier() const
bool hasConstexprSpecifier() const
static const TST TST_typeofType
static const TST TST_auto
ConstexprSpecKind getConstexprSpecifier() const
static const TST TST_struct
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
const DeclContext * getParentFunctionOrMethod(bool LexicalParent=false) const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext,...
bool isInStdNamespace() const
SourceLocation getEndLoc() const LLVM_READONLY
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
void setAttrs(const AttrVec &Attrs)
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked 'unavailable'.
bool isInNamedModule() const
Whether this declaration comes from a named module.
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it's a function-local extern declaration.
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
void setTopLevelDeclInObjCContainer(bool V=true)
bool isInIdentifierNamespace(unsigned NS) const
@ FOK_Undeclared
A friend of a previously-undeclared entity.
@ FOK_None
Not a friend object.
@ FOK_Declared
A friend of a previously-declared entity.
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
bool isInExportDeclContext() const
Whether this declaration was exported in a lexical context.
bool isReferenced() const
Whether any declaration of this entity was referenced.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
bool isFromExplicitGlobalModule() const
Whether this declaration comes from explicit global module.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
@ OBJC_TQ_CSNullability
The nullability qualifier is set when the nullability of the result or parameter was expressed via a ...
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
bool isLocalExternDecl() const
Determine whether this is a block-scope declaration with linkage.
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
@ IDNS_Ordinary
Ordinary names.
void setLocalOwningModule(Module *M)
void setImplicit(bool I=true)
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
SourceLocation getBeginLoc() const LLVM_READONLY
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
Module * getOwningModuleForLinkage() const
Get the module that owns this declaration for linkage purposes.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
void setLexicalDeclContext(DeclContext *DC)
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
The name of a declaration.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
@ CXXConversionFunctionName
bool isIdentifier() const
Predicate functions for querying what type of name this is.
Represents a ValueDecl that came out of a declarator.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
SourceLocation getOuterLocStart() const
Return start of source range taking into account any outer template declarations.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getNumTemplateParameterLists() const
void setTypeSourceInfo(TypeSourceInfo *TI)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
TypeSourceInfo * getTypeSourceInfo() const
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Information about one declarator, including the parsed type information and the identifier.
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
const ParsedAttributes & getAttributes() const
void SetIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Set the name of this declarator to be the given identifier.
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
const ParsedAttributesView & getDeclarationAttributes() const
A decomposition declaration.
static DecompositionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation LSquareLoc, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< BindingDecl * > Bindings)
A parsed C++17 decomposition declarator of the form '[' identifier-list ']'.
SourceRange getSourceRange() const
SourceLocation getLSquareLoc() const
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it has not been deduced.
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Concrete class used by the front-end to report problems and issues.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
Expr * getCondition() const
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
An instance of this object exists for each enum constant that is defined.
llvm::APSInt getInitVal() const
static EnumConstantDecl * Create(ASTContext &C, EnumDecl *DC, SourceLocation L, IdentifierInfo *Id, QualType T, Expr *E, const llvm::APSInt &V)
const Expr * getInitExpr() const
enumerator_range enumerators() const
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
void setIntegerType(QualType T)
Set the underlying integer type.
void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo)
Set the underlying integer type source info.
bool isComplete() const
Returns true if this can be considered a complete type.
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
bool isClosedFlag() const
Returns true if this enum is annotated with flag_enum and isn't annotated with enum_extensibility(ope...
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
SourceRange getIntegerTypeRange() const LLVM_READONLY
Retrieve the source range that covers the underlying type if specified.
void setPromotionType(QualType T)
Set the promotion type.
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EvaluatedExprVisitor - This class visits 'Expr *'s.
Store information needed for an explicit specifier.
This represents one expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
Represents difference between two FPOptions values.
void setDisallowOptimizations()
void applyChanges(FPOptionsOverride FPO)
bool isFPConstrained() const
FPOptionsOverride getChangesFrom(const FPOptions &Base) const
Return difference with the given option set.
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
bool isZeroLengthBitField(const ASTContext &Ctx) const
Is this a zero-length bit-field? Such bit-fields aren't really bit-fields at all and instead act as a...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
static FileScopeAsmDecl * Create(ASTContext &C, DeclContext *DC, StringLiteral *Str, SourceLocation AsmLoc, SourceLocation RParenLoc)
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
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.
Represents a function declaration or definition.
bool isMultiVersion() const
True if this function is considered a multiversioned function.
const ParmVarDecl * getParamDecl(unsigned i) const
ConstexprSpecKind getConstexprKind() const
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
void setPreviousDeclaration(FunctionDecl *PrevDecl)
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
void setIsPureVirtual(bool P=true)
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
void setFriendConstraintRefersToEnclosingTemplate(bool V=true)
void setHasSkippedBody(bool Skipped=true)
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
param_iterator param_end()
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
void setIsMultiVersion(bool V=true)
Sets the multiversion state for this declaration and all of its redeclarations.
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
bool hasWrittenPrototype() const
Whether this function has a written prototype.
void setWillHaveBody(bool V=true)
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
param_iterator param_begin()
const ParmVarDecl * getNonObjectParameter(unsigned I) const
bool isVariadic() const
Whether this function is variadic.
bool isDeleted() const
Whether this function has been deleted.
FunctionEffectsRef getFunctionEffects() const
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
@ TK_MemberSpecialization
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function.
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
bool isDeletedAsWritten() const
void setHasInheritedPrototype(bool P=true)
State that this function inherited its prototype from a previous declaration.
bool isPureVirtual() const
Whether this virtual function is pure, i.e.
bool isExternC() const
Determines whether this function is a function with external, C linkage.
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
bool hasImplicitReturnZero() const
Whether falling off this function implicitly returns null/zero.
bool isImmediateEscalating() const
void setVirtualAsWritten(bool V)
State that this function is marked as virtual explicitly.
bool hasSkippedBody() const
True if the function was a definition but its body was skipped.
FunctionDecl * getDefinition()
Get the definition for this declaration.
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program.
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, Expr *TrailingRequiresClause=nullptr)
bool isThisDeclarationInstantiatedFromAFriendDefinition() const
Determine whether this specific declaration of the function is a friend declaration that was instanti...
void setRangeEnd(SourceLocation E)
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
bool isDefaulted() const
Whether this function is defaulted.
void setIneligibleOrNotSelected(bool II)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
const IdentifierInfo * getLiteralIdentifier() const
getLiteralIdentifier - The literal suffix identifier this function represents, if any.
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
void setConstexprKind(ConstexprSpecKind CSK)
void setDefaulted(bool D=true)
QualType getDeclaredReturnType() const
Get the declared return type, which may differ from the actual return type if the return type is dedu...
bool isGlobal() const
Determines whether this is a global function.
void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)
bool hasInheritedPrototype() const
Whether this function inherited its prototype from a previous declaration.
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization,...
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
DeclarationNameInfo getNameInfo() const
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
void setHasImplicitReturnZero(bool IRZ)
State that falling off this function implicitly returns null/zero.
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
MultiVersionKind getMultiVersionKind() const
Gets the kind of multiversioning attribute this declaration has.
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
A mutable set of FunctionEffects and possibly conditions attached to them.
static FunctionEffectSet getUnion(FunctionEffectsRef LHS, FunctionEffectsRef RHS, Conflicts &Errs)
Kind kind() const
The kind of the effect.
Kind
Identifies the particular effect.
An immutable set of FunctionEffects and possibly conditions attached to them.
Represents a prototype with parameter type info, e.g.
unsigned getNumParams() const
QualType getParamType(unsigned i) const
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
ArrayRef< QualType > param_types() const
Declaration of a template function.
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
void mergePrevDecl(FunctionTemplateDecl *Prev)
Merge Prev with our RedeclarableTemplateDecl::Common.
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration,...
Wrapper for source info for functions.
A class which abstracts out some details necessary for making a call.
ExtInfo withCallingConv(CallingConv cc) const
CallingConv getCC() const
ExtInfo withProducesResult(bool producesResult) const
unsigned getRegParm() const
bool getNoCallerSavedRegs() const
ExtInfo withNoReturn(bool noReturn) const
bool getHasRegParm() const
bool getProducesResult() const
ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const
ExtInfo withRegParm(unsigned RegParm) const
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
static StringRef getNameForCallConv(CallingConv CC)
static ArmStateValue getArmZT0State(unsigned AttrBits)
static ArmStateValue getArmZAState(unsigned AttrBits)
unsigned getRegParmType() const
CallingConv getCallConv() const
QualType getReturnType() const
bool getCmseNSCallAttr() const
@ SME_PStateSMEnabledMask
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.
bool isEditorPlaceholder() const
Return true if this identifier is an editor placeholder.
bool isPlaceholder() const
StringRef getName() const
Return the actual identifier string.
iterator - Iterate over the decls of a specified declaration name.
iterator begin(DeclarationName Name)
Returns an iterator over decls with the name 'Name'.
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
void InsertDeclAfter(iterator Pos, NamedDecl *D)
Insert the given declaration after the given iterator position.
iterator end()
Returns the end iterator.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
bool isDeclInScope(Decl *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',...
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Represents a C array with an unspecified size.
Represents a field injected from an anonymous union/struct into the parent scope.
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, const IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl * > CH)
void setInherited(bool I)
Description of a constructor that was inherited from a base class.
Describes an C or C++ initializer list.
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
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...
step_iterator step_begin() const
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.
@ SK_ParenthesizedListInit
Initialize an aggreagate with parenthesized list of values.
Describes an entity that is being initialized.
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Represents the declaration of a label.
bool isResolvedMSAsmLabel() const
LabelStmt * getStmt() const
bool isMSAsmLabel() const
@ FPE_Ignore
Assume that floating-point exceptions are masked.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
FPExceptionModeKind getDefaultExceptionMode() const
bool requiresStrictPrototypes() const
Returns true if functions without prototypes or functions with an identifier list (aka K&R C function...
clang::ObjCRuntime ObjCRuntime
std::string getOpenCLVersionString() const
Return the OpenCL C or C++ for OpenCL language name and version as a string.
bool IsHeaderFile
Indicates whether the front-end is explicitly told that the input is a header file (i....
bool implicitFunctionsAllowed() const
Returns true if implicit function declarations are allowed in the current language mode.
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
std::vector< llvm::Triple > OMPTargetTriples
Triples of the OpenMP targets that the host code codegen should take into account in order to generat...
void push_back(const T &LocalValue)
static SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)
Checks that the given token is the first token that occurs after the given location (this excludes co...
Represents a linkage specification.
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LinkageSpecLanguageIDs Lang, bool HasBraces)
void InstantiatedLocal(const Decl *D, Decl *Inst)
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.
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.
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Sema & getSema() const
Get the Sema object that this lookup result is searching with.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
LookupResultKind getResultKind() const
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
@ AmbiguousTagHiding
Name lookup results in an ambiguity because an entity with a tag name was hidden by an entity with an...
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
virtual unsigned getManglingNumber(const CXXMethodDecl *CallOperator)=0
Retrieve the mangling number of a new lambda expression with the given call operator within this cont...
virtual unsigned getStaticLocalNumber(const VarDecl *VD)=0
Static locals are numbered by source order.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
A pointer to member type per C++ 8.3.3 - Pointers to members.
Describes a module or submodule.
SourceLocation DefinitionLoc
The location of the module definition.
Module * Parent
The parent of this module.
bool isPrivateModule() const
bool isHeaderLikeModule() const
Is this module have similar semantics as headers.
bool isModuleImplementation() const
Is this a module implementation.
bool isModulePartition() const
Is this a module partition.
bool isImplicitGlobalModule() const
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
bool isNamedModule() const
Does this Module is a named module of a standard named module?
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
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.
bool isLinkageValid() const
True if the computed linkage is valid.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
bool isPlaceholderVar(const LangOptions &LangOpts) const
bool hasLinkageBeenComputed() const
True if something has required us to compute the linkage of this declaration.
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
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.
bool isExternallyVisible() const
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Represent a C++ namespace.
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
Class that aids in the construction of nested-name-specifiers along with source-location information ...
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
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.
SourceRange getLocalSourceRange() const
Retrieve the source range covering just the last part 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 containsErrors() const
Whether this nested name specifier contains an error.
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.
static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)
Returns the nested name specifier representing the global scope.
@ 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.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
ObjCCategoryDecl - Represents a category declaration.
ObjCCompatibleAliasDecl - Represents alias of a class.
ObjCContainerDecl - Represents a container for method declarations.
ObjCIvarDecl * getIvarDecl(IdentifierInfo *Id) const
getIvarDecl - This method looks up an ivar in this ContextDecl.
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Represents an ObjC class declaration.
known_extensions_range known_extensions() const
ObjCIvarDecl - Represents an ObjC instance variable.
static ObjCIvarDecl * Create(ASTContext &C, ObjCContainerDecl *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, AccessControl ac, Expr *BW=nullptr, bool synthesized=false)
An expression that sends a message to the given Objective-C object or class.
ObjCMethodDecl - Represents an instance or class method declaration.
param_const_iterator param_end() const
param_const_iterator param_begin() const
const ParmVarDecl *const * param_const_iterator
ParmVarDecl *const * param_iterator
bool isFragile() const
The inverse of isNonFragile(): does this runtime follow the set of implied behaviors for a "fragile" ...
Wrapper for void* pointer.
static OpaquePtr make(PtrTy P)
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
bool isAvailableOption(llvm::StringRef Ext, const LangOptions &LO) const
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
@ CSK_Normal
Normal lookup.
SmallVectorImpl< OverloadCandidate >::iterator iterator
void NoteCandidates(PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
When overload resolution fails, prints diagnostic messages containing the candidates in the candidate...
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
SmallVectorImpl< UniqueVirtualMethod >::iterator overriding_iterator
MapType::iterator iterator
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
unsigned getNumExprs() const
Return the number of expressions in this paren list.
void setRParenLoc(SourceLocation Loc)
TypeLoc getInnerLoc() const
void setLParenLoc(SourceLocation Loc)
Sugar for parentheses used when specifying types.
Represents a parameter to a function.
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
ObjCDeclQualifier getObjCDeclQualifier() const
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
QualType getOriginalType() const
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
ParsedAttr - Represents a syntactic attribute.
static const ParsedAttributesView & none()
bool hasAttribute(ParsedAttr::Kind K) const
ParsedAttributes - A collection of parsed attributes.
AttributePool & getPool() const
unsigned getDiagID() const
TypeLoc getPointeeLoc() const
Wrapper for source info for pointers.
void setStarLoc(SourceLocation Loc)
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
bool isIncrementalProcessingEnabled() const
Returns true if incremental processing is enabled.
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
HeaderSearch & getHeaderSearchInfo() const
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
StringRef getLastMacroWithSpelling(SourceLocation Loc, ArrayRef< TokenValue > Tokens) const
Return the name of the macro defined before Loc that has spelling Tokens.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
PrimitiveDefaultInitializeKind
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const
const IdentifierInfo * getBaseTypeIdentifier() const
Retrieves a pointer to the name of the base type.
QualType withoutLocalFastQualifiers() const
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
PrimitiveDefaultInitializeKind isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C struct types.
bool isObjCGCStrong() const
true when Type is objc's strong.
bool isConstQualified() const
Determine whether this type is const-qualified.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool hasNonTrivialObjCLifetime() const
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
@ PCK_Trivial
The type does not fall into any of the following categories.
@ PCK_VolatileTrivial
The type would be trivial except that it is volatile-qualified.
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
A qualifier set is used to build a set of qualifiers.
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
ObjCLifetime getObjCLifetime() const
Represents a struct/union/class.
bool hasObjectMember() const
field_range fields() const
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
virtual void completeDefinition()
Note that the definition of this type is now complete.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
void setMemberSpecialization()
Note that this member template is a specialization.
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
redecl_iterator redecls_end() const
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Base for LValueReferenceType and RValueReferenceType.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
void setNRVOCandidate(const VarDecl *Var)
Set the variable that might be used for the named return value optimization.
Scope - A scope is a transient data structure that is used while parsing the program.
bool isDeclScope(const Decl *D) const
isDeclScope - Return true if this is the scope that the specified decl is declared in.
DeclContext * getEntity() const
Get the entity corresponding to this scope.
bool isCompoundStmtScope() const
Determine whether this scope is a compound statement 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.
@ DeclScope
This is a scope that can contain a declaration.
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.
void checkAllowedInitializer(VarDecl *VD)
std::string getConfigureFuncName() const
Returns the name of the launch configuration function.
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
void maybeAddHostDeviceAttrs(FunctionDecl *FD, const LookupResult &Previous)
May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD, depending on FD and the current co...
void checkTargetOverload(FunctionDecl *NewFD, const LookupResult &Previous)
Check whether NewFD is a valid overload for CUDA.
void MaybeAddConstantAttr(VarDecl *VD)
May add implicit CUDAConstantAttr attribute to VD, depending on VD and current compilation settings.
void CheckEntryPoint(FunctionDecl *FD)
HLSLNumThreadsAttr * mergeNumThreadsAttr(Decl *D, const AttributeCommonInfo &AL, int X, int Y, int Z)
void ActOnTopLevelFunction(FunctionDecl *FD)
HLSLShaderAttr * mergeShaderAttr(Decl *D, const AttributeCommonInfo &AL, llvm::Triple::EnvironmentType ShaderType)
void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID)
DiagnoseDuplicateIvars - Check for duplicate ivars in the entire class at the start of @implementatio...
void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, const ObjCMethodDecl *Overridden)
Check whether the given new method is a valid override of the given overridden method,...
DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S, IdentifierInfo *II)
The parser has read a name in, and Sema has detected that we're currently inside an ObjC method.
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle.
ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV)
void AddCFAuditedAttribute(Decl *D)
AddCFAuditedAttribute - Check whether we're currently within '#pragma clang arc_cf_code_audited' and,...
void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, ObjCIvarDecl **Fields, unsigned nIvars, SourceLocation Loc)
CheckImplementationIvars - This routine checks if the instance variables listed in the implelementati...
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D)
Act on D, a function definition inside of an omp [begin/end] assumes.
void ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope(Decl *D, SmallVectorImpl< FunctionDecl * > &Bases)
Register D as specialization of all base functions in Bases in the current omp begin/end declare vari...
void ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, SmallVectorImpl< FunctionDecl * > &Bases)
The declarator D defines a function in the scope S which is nested in an omp begin/end declare varian...
void ActOnOpenMPDeclareTargetInitializer(Decl *D)
Adds OMPDeclareTargetDeclAttr to referenced variables in declare target directive.
void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
void checkRVVTypeSupport(QualType Ty, SourceLocation Loc, Decl *D, const llvm::StringMap< bool > &FeatureMap)
SwiftNameAttr * mergeNameAttr(Decl *D, const SwiftNameAttr &SNA, StringRef Name)
WebAssemblyImportNameAttr * mergeImportNameAttr(Decl *D, const WebAssemblyImportNameAttr &AL)
WebAssemblyImportModuleAttr * mergeImportModuleAttr(Decl *D, const WebAssemblyImportModuleAttr &AL)
Mode getAlignMode() const
A class which encapsulates the logic for delaying diagnostics during parsing and other processing.
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
static NameClassification DependentNonType()
static NameClassification VarTemplate(TemplateName Name)
static NameClassification Unknown()
static NameClassification OverloadSet(ExprResult E)
static NameClassification UndeclaredTemplate(TemplateName Name)
static NameClassification FunctionTemplate(TemplateName Name)
static NameClassification NonType(NamedDecl *D)
static NameClassification Concept(TemplateName Name)
static NameClassification UndeclaredNonType()
static NameClassification TypeTemplate(TemplateName Name)
static NameClassification Error()
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Sema - This implements semantic analysis and AST building for C.
StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, IdentifierInfo *Ident, ParsedAttributes &Attrs)
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S)
MergeCXXFunctionDecl - Merge two declarations of the same C++ function, once we already know that the...
Attr * getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD, bool IsDefinition)
Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a containing class.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
SmallVector< DeclaratorDecl *, 4 > ExternalDeclarations
All the external declarations encoutered and used in the TU.
void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D)
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Scope * getCurScope() const
Retrieve the parser's current scope.
void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New, LookupResult &OldDecls)
MergeTypedefNameDecl - We just parsed a typedef 'New' which has the same name and scope as a previous...
bool hasStructuralCompatLayout(Decl *D, Decl *Suggested)
Determine if D and Suggested have a structurally compatible layout as described in C11 6....
void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S)
Register the given locally-scoped extern "C" declaration so that it can be found later for redeclarat...
BTFDeclTagAttr * mergeBTFDeclTagAttr(Decl *D, const BTFDeclTagAttr &AL)
NamedDecl * ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope)
bool CheckExplicitObjectOverride(CXXMethodDecl *New, const CXXMethodDecl *Old)
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',...
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs=true)
void DiagnoseUnusedParameters(ArrayRef< ParmVarDecl * > Parameters)
Diagnose any unused parameters in the given sequence of ParmVarDecl pointers.
void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old)
Merge the exception specifications of two variable declarations.
bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &...Args)
CXXSpecialMemberKind getSpecialMember(const CXXMethodDecl *MD)
LookupNameKind
Describes the kind of name lookup to perform.
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupNestedNameSpecifierName
Look up of a name that precedes the '::' scope resolution operator in C++.
@ LookupLocalFriendName
Look up a friend of a local class.
@ LookupRedeclarationWithLinkage
Look up an ordinary name that is going to be redeclared as a name with linkage.
@ 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.
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function.
void ActOnPopScope(SourceLocation Loc, Scope *S)
void ActOnDefinedDeclarationSpecifier(Decl *D)
Called once it is known whether a tag declaration is an anonymous union or struct.
EnforceTCBAttr * mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL)
Decl * ActOnSkippedFunctionBody(Decl *Decl)
QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name, QualType Type, TypeSourceInfo *TSI, SourceRange Range, bool DirectInit, Expr *Init)
bool SetMemberAccessSpecifier(NamedDecl *MemberDecl, NamedDecl *PrevMemberDecl, AccessSpecifier LexicalAS)
SetMemberAccessSpecifier - Set the access specifier of a member.
@ NTCUC_DefaultInitializedObject
bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn)
MergeFunctionDecl - We just parsed a function 'New' from declarator D which has the same name and sco...
void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind, uint64_t MagicValue, QualType Type, bool LayoutCompatible, bool MustBeNull)
Register a magic integral constant to be used as a type tag.
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.
void LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID)
void ActOnTagDefinitionError(Scope *S, Decl *TagDecl)
ActOnTagDefinitionError - Invoked when there was an unrecoverable error parsing the definition of a t...
void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body)
TypeVisibilityAttr * mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, TypeVisibilityAttr::VisibilityType Vis)
void CheckExplicitObjectMemberFunction(Declarator &D, DeclarationName Name, QualType R, bool IsLambda, DeclContext *DC=nullptr)
bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info)
DiagnoseClassNameShadow - Implement C++ [class.mem]p13: If T is the name of a class,...
void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc, CXXRecordDecl *Record)
MarkBaseAndMemberDestructorsReferenced - Given a record decl, mark all the non-trivial destructors of...
const TranslationUnitKind TUKind
The kind of translation unit we are processing.
void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl, SourceRange BraceRange)
ActOnTagFinishDefinition - Invoked once we have finished parsing the definition of a tag (enumeration...
FunctionEmissionStatus
Status of the function emission on the CUDA/HIP/OpenMP host/device attrs.
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
PragmaClangSection PragmaClangRodataSection
NamedDecl * ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II, Scope *S)
ImplicitlyDefineFunction - An undeclared identifier was used in a function call, forming a call to an...
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
Decl * ActOnParamDeclarator(Scope *S, Declarator &D, SourceLocation ExplicitThisLoc={})
ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() to introduce parameters into fun...
void AddPragmaAttributes(Scope *S, Decl *D)
Adds the attributes that have been specified using the '#pragma clang attribute push' directives to t...
TemplateDecl * AdjustDeclIfTemplate(Decl *&Decl)
AdjustDeclIfTemplate - If the given decl happens to be a template, reset the parameter D to reference...
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
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.
bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, InheritedConstructorInfo *ICI=nullptr, bool Diagnose=false)
Determine if a special member function should have a deleted definition when it is defaulted.
void ActOnExitFunctionContext()
ExprResult RebuildExprInCurrentInstantiation(Expr *E)
DeclResult ActOnVarTemplateSpecialization(Scope *S, Declarator &D, TypeSourceInfo *DI, LookupResult &Previous, SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams, StorageClass SC, bool IsPartialSpecialization)
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
Preprocessor & getPreprocessor() const
void deduceOpenCLAddressSpace(ValueDecl *decl)
PragmaStack< FPOptionsOverride > FpPragmaStack
PragmaStack< StringLiteral * > CodeSegStack
void AddRangeBasedOptnone(FunctionDecl *FD)
Only called on function definitions; if there is a pragma in scope with the effect of a range-based o...
bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member function overrides a virtual...
DLLImportAttr * mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI)
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 ...
bool CheckOverridingFunctionAttributes(CXXMethodDecl *New, const CXXMethodDecl *Old)
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 handleTagNumbering(const TagDecl *Tag, Scope *TagScope)
void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl)
AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared special functions,...
void AddAlignmentAttributesForRecord(RecordDecl *RD)
AddAlignmentAttributesForRecord - Adds any needed alignment attributes to a the record decl,...
ErrorAttr * mergeErrorAttr(Decl *D, const AttributeCommonInfo &CI, StringRef NewUserDiagnostic)
Decl * ActOnConversionDeclarator(CXXConversionDecl *Conversion)
ActOnConversionDeclarator - Called by ActOnDeclarator to complete the declaration of the given C++ co...
void CheckMain(FunctionDecl *FD, const DeclSpec &D)
void AddKnownFunctionAttributes(FunctionDecl *FD)
Adds any function attributes that we know a priori based on the declaration of this function.
void DiagnoseUnusedButSetDecl(const VarDecl *VD, DiagReceiverTy DiagReceiver)
If VD is set but not otherwise used, diagnose, for a parameter or a variable.
@ Delete
deleted-function-body
ExprResult VerifyBitField(SourceLocation FieldLoc, const IdentifierInfo *FieldName, QualType FieldTy, bool IsMsStruct, Expr *BitWidth)
VerifyBitField - verifies that a bit field expression is an ICE and has the correct width,...
FieldDecl * HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS)
HandleField - Analyze a field of a C struct or a C++ data member.
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.
void CheckThreadLocalForLargeAlignment(VarDecl *VD)
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Look up a name, looking for a single declaration.
void ActOnReenterFunctionContext(Scope *S, Decl *D)
Push the parameters of D, which must be a function, into scope.
sema::LambdaScopeInfo * RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator)
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
const AttributedType * getCallingConvAttributedType(QualType T) const
Get the outermost AttributedType node that sets a calling convention.
TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S)
isTagName() - This method is called for error recovery purposes only to determine if the specified na...
bool CheckRedeclarationExported(NamedDecl *New, NamedDecl *Old)
[module.interface]p6: A redeclaration of an entity X is implicitly exported if X was introduced by an...
void CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC)
CheckConversionDeclarator - Called by ActOnDeclarator to check the well-formednes of the conversion f...
VisibilityAttr * mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, VisibilityAttr::VisibilityType Vis)
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization, bool Disambiguation=false)
Decl * ActOnFileScopeAsmDecl(Expr *expr, SourceLocation AsmLoc, SourceLocation RParenLoc)
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
DiagnosticsEngine & getDiagnostics() const
void ActOnFinishTopLevelStmtDecl(TopLevelStmtDecl *D, Stmt *Statement)
bool diagnoseConflictingFunctionEffect(const FunctionEffectsRef &FX, const FunctionEffectWithCondition &EC, SourceLocation NewAttrLoc)
Warn and return true if adding an effect to a set would create a conflict.
void * SkippedDefinitionContext
bool LookupBuiltin(LookupResult &R)
Lookup a builtin function, when name lookup would otherwise fail.
void DiagPlaceholderFieldDeclDefinitions(RecordDecl *Record)
Emit diagnostic warnings for placeholder members.
void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TypedefNameDecl *NewTD)
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
PragmaStack< bool > StrictGuardStackCheckStack
UnusedFileScopedDeclsType UnusedFileScopedDecls
The set of file scoped decls seen so far that have not been used and must warn if not used.
NamedDecl * LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, Scope *S, bool ForRedeclaration, SourceLocation Loc)
LazilyCreateBuiltin - The specified Builtin-ID was first used at file scope.
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...
void CheckCoroutineWrapper(FunctionDecl *FD)
bool isCurrentClassName(const IdentifierInfo &II, Scope *S, const CXXScopeSpec *SS=nullptr)
isCurrentClassName - Determine whether the identifier II is the name of the class type currently bein...
bool IsRedefinitionInModule(const NamedDecl *New, const NamedDecl *Old) const
Check the redefinition in C++20 Modules.
bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method)
Check whether 'this' shows up in the type of a static member function after the (naturally empty) cv-...
void DiagnoseUnguardedAvailabilityViolations(Decl *FD)
Issue any -Wunguarded-availability warnings in FD.
void PopExpressionEvaluationContext()
PragmaStack< StringLiteral * > ConstSegStack
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 isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S)
isMicrosoftMissingTypename - In Microsoft mode, within class scope, if a CXXScopeSpec's type is equal...
bool UseArgumentDependentLookup(const CXXScopeSpec &SS, const LookupResult &R, bool HasTrailingLParen)
void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord)
Add gsl::Pointer attribute to std::container::iterator.
bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn)
We've just determined that Old and New both appear to be definitions of the same variable.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
void ProcessPragmaWeak(Scope *S, Decl *D)
bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Decl * BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy)
BuildAnonymousStructOrUnion - Handle the declaration of an anonymous structure or union.
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
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...
void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
EnumDecl * getStdAlignValT() const
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend=false)
Perform semantic analysis for the given function template specialization.
bool UnifySection(StringRef SectionName, int SectionFlags, NamedDecl *TheDecl)
void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld)
MergeVarDeclTypes - We parsed a variable 'New' which has the same name and scope as a previous declar...
void PushFunctionScope()
Enter a new function scope.
ExprResult ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS, NamedDecl *Found, SourceLocation NameLoc, const Token &NextToken)
Act on the result of classifying a name as a specific non-type declaration.
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
void inferGslOwnerPointerAttribute(CXXRecordDecl *Record)
Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
llvm::function_ref< void(SourceLocation Loc, PartialDiagnostic PD)> DiagReceiverTy
bool CheckEnumUnderlyingType(TypeSourceInfo *TI)
Check that this is a valid underlying type for an enum declaration.
bool FriendConstraintsDependOnEnclosingTemplate(const FunctionDecl *FD)
FPOptions & getCurFPFeatures()
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
sema::LambdaScopeInfo * PushLambdaScope()
SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, SourceLocation IILoc)
Determine whether the body of an anonymous enumeration should be skipped.
@ UPPC_FixedUnderlyingType
The fixed underlying type of an enumeration.
@ UPPC_EnumeratorValue
The enumerator value.
@ UPPC_Initializer
An initializer.
@ UPPC_FriendDeclaration
A friend declaration.
@ UPPC_DeclarationType
The type of an arbitrary declaration.
@ UPPC_ExplicitSpecialization
Explicit specialization.
@ UPPC_DeclarationQualifier
A declaration qualifier.
@ UPPC_DataMemberType
The type of a data member.
@ UPPC_BitFieldWidth
The size of a bit-field.
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.
void DiagnoseInvalidJumps(Stmt *Body)
SourceLocation CurInitSegLoc
bool currentModuleIsHeaderUnit() const
Is the module scope we are in a C++ Header Unit?
void EnterTemplatedContext(Scope *S, DeclContext *DC)
Enter a template parameter scope, after it's been associated with a particular DeclContext.
bool tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo, QualType &T, SourceLocation Loc, unsigned FailedFoldDiagID)
Attempt to fold a variable-sized type to a constant-sized type, returning true if we were successful.
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
NamedDecl * findLocallyScopedExternCDecl(DeclarationName Name)
Look for a locally scoped extern "C" declaration by the given name.
bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old)
We've determined that New is a redeclaration of Old.
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...
bool CheckConstexprFunctionDefinition(const FunctionDecl *FD, CheckConstexprKind Kind)
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
MinSizeAttr * mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI)
NamedDecl * getShadowedDeclaration(const TypedefNameDecl *D, const LookupResult &R)
Return the declaration shadowed by the given typedef D, or null if it doesn't shadow any declaration ...
void checkTypeSupport(QualType Ty, SourceLocation Loc, ValueDecl *D=nullptr)
Check if the type is allowed to be used for the current target.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD)
const LangOptions & LangOpts
void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock)
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
bool isReachable(const NamedDecl *D)
Determine whether a declaration is reachable.
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr, FnBodyKind BodyKind=FnBodyKind::Other)
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn)
Perform semantic checking of a new function declaration.
CXXRecordDecl * getStdBadAlloc() const
AlwaysInlineAttr * mergeAlwaysInlineAttr(Decl *D, const AttributeCommonInfo &CI, const IdentifierInfo *Ident)
FieldDecl * CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitfieldWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D=nullptr)
Build a new FieldDecl and check its well-formedness.
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
PragmaClangSection PragmaClangRelroSection
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD, SourceLocation ReturnLoc, Expr *RetExpr, const AutoType *AT)
Deduce the return type for a function from a returned expression, per C++1y [dcl.spec....
void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D)
void CheckCXXDefaultArguments(FunctionDecl *FD)
Helpers for dealing with blocks and functions.
bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS)
checkUnsafeAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained type.
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.
void AddImplicitMSFunctionNoBuiltinAttr(FunctionDecl *FD)
Only called on function definitions; if there is a pragma in scope with the effect of a range-based n...
PragmaStack< AlignPackInfo > AlignPackStack
bool canDelayFunctionBody(const Declarator &D)
Determine whether we can delay parsing the body of a function or function template until it is used,...
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
PragmaStack< StringLiteral * > BSSSegStack
bool hasAnyAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true, bool AllowNonTemplateFunctions=false)
DeclContext * getCurLexicalContext() const
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...
OverloadKind CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &OldDecls, NamedDecl *&OldDecl, bool UseMemberUsingDeclRules)
Determine whether the given New declaration is an overload of the declarations in Old.
bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl)
CheckOverloadedOperatorDeclaration - Check whether the declaration of this overloaded operator is wel...
bool hasExplicitCallingConv(QualType T)
NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc, const Token &NextToken, CorrectionCandidateCallback *CCC=nullptr)
Perform name lookup on the given name, classifying it based on the results of name lookup and the fol...
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...
void ExitDeclaratorContext(Scope *S)
void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI)
Diagnose shadowing for variables shadowed in the lambda record LambdaRD when these variables are capt...
void CheckConstructor(CXXConstructorDecl *Constructor)
CheckConstructor - Checks a fully-formed constructor for well-formedness, issuing any diagnostics req...
void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMemberKind CSM)
Diagnose why the specified class does not have a trivial special member of the given kind.
void CheckMSVCRTEntryPoint(FunctionDecl *FD)
Decl * ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant, SourceLocation IdLoc, IdentifierInfo *Id, const ParsedAttributesView &Attrs, SourceLocation EqualLoc, Expr *Val)
sema::FunctionScopeInfo * getCurFunction() const
void PushCompoundScope(bool IsStmtExpr)
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
FunctionDecl * CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID, SourceLocation Loc)
Scope * getNonFieldDeclScope(Scope *S)
getNonFieldDeclScope - Retrieves the innermost scope, starting from S, where a non-field would be dec...
void ActOnPragmaWeakID(IdentifierInfo *WeakName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc)
ActOnPragmaWeakID - Called on well formed #pragma weak ident.
bool CheckNontrivialField(FieldDecl *FD)
llvm::DenseMap< const VarDecl *, int > RefsMinusAssignments
Increment when we find a reference; decrement when we find an ignored assignment.
void AddPushedVisibilityAttribute(Decl *RD)
AddPushedVisibilityAttribute - If '#pragma GCC visibility' was used, add an appropriate visibility at...
bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method)
Check whether 'this' shows up in the attributes of the given static member function.
void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl, SourceLocation FinalLoc, bool IsFinalSpelledSealed, bool IsAbstract, SourceLocation LBraceLoc)
ActOnStartCXXMemberDeclarations - Invoked when we have parsed a C++ record definition's base-specifie...
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 CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous)
Perform semantic checking on a newly-created variable declaration.
ExprResult DefaultLvalueConversion(Expr *E)
MSInheritanceAttr * mergeMSInheritanceAttr(Decl *D, const AttributeCommonInfo &CI, bool BestCase, MSInheritanceModel Model)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
StringLiteral * CurInitSeg
Last section used with #pragma init_seg.
FunctionEmissionStatus getEmissionStatus(const FunctionDecl *Decl, bool Final=false)
Module * getCurrentModule() const
Get the module unit whose scope we are currently within.
bool CheckDeductionGuideDeclarator(Declarator &D, QualType &R, StorageClass &SC)
Check the validity of a declarator that we parsed for a deduction-guide.
bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD)
AddOverriddenMethods - See if a method overrides any in the base classes, and if so,...
InternalLinkageAttr * mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL)
void DiagPlaceholderVariableDefinition(SourceLocation Loc)
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
bool ActOnDuplicateDefinition(Decl *Prev, SkipBodyInfo &SkipBody)
Perform ODR-like check for C/ObjC when merging tag types from modules.
void ActOnFinishInlineFunctionDef(FunctionDecl *D)
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)
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, const IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)
Check whether the given function decl's trailing requires clause is satisfied, if any.
bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl)
CheckLiteralOperatorDeclaration - Check whether the declaration of this literal operator function is ...
@ Incompatible
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST.
void CheckShadowingDeclModification(Expr *E, SourceLocation Loc)
Warn if 'E', which is an expression that is about to be modified, refers to a shadowing declaration.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
void notePreviousDefinition(const NamedDecl *Old, SourceLocation New)
void applyFunctionAttributesBeforeParsingBody(Decl *FD)
DLLExportAttr * mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI)
DeclContext * OriginalLexicalContext
Generally null except when we temporarily switch decl contexts, like in.
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
CodeSegAttr * mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Name)
SectionAttr * mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Name)
bool canSkipFunctionBody(Decl *D)
Determine whether we can skip parsing the body of a function definition, assuming we don't care about...
bool canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD, QualType NewT, QualType OldT)
Determines if we can perform a correct type check for D as a redeclaration of PrevDecl.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
@ NTK_TemplateTemplateArgument
SourceManager & getSourceManager() const
NamedDecl * ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists)
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams)
Handle a friend type declaration.
llvm::DenseMap< const EnumDecl *, llvm::APInt > FlagBitsCache
A cache of the flags available in enumerations with the flag_bits attribute.
bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, Scope *S, bool MergeTypeWithOld)
Completes the merge of two function declarations that are known to be compatible.
void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, Decl *EnumDecl, ArrayRef< Decl * > Elements, Scope *S, const ParsedAttributesView &Attr)
void EnterDeclaratorContext(Scope *S, DeclContext *DC)
EnterDeclaratorContext - Used when we must lookup names in the context of a declarator's nested name ...
bool areMultiversionVariantFunctionsCompatible(const FunctionDecl *OldFD, const FunctionDecl *NewFD, const PartialDiagnostic &NoProtoDiagID, const PartialDiagnosticAt &NoteCausedDiagIDAt, const PartialDiagnosticAt &NoSupportDiagIDAt, const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported, bool ConstexprSupported, bool CLinkageMayDiffer)
Checks if the variant/multiversion functions are compatible.
void ActOnTagStartDefinition(Scope *S, Decl *TagDecl)
ActOnTagStartDefinition - Invoked when we have entered the scope of a tag's definition (e....
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.
PragmaClangSection PragmaClangTextSection
PragmaClangSection PragmaClangDataSection
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=std::nullopt, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
void FilterAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true)
ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name, SourceLocation NameLoc)
Act on the result of classifying a name as an undeclared (ADL-only) non-type declaration.
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...
void ActOnPragmaRedefineExtname(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaRedefineExtname - Called on well formed #pragma redefine_extname oldname newname.
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.
MaybeODRUseExprSet MaybeODRUseExprs
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.
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
CheckParmsForFunctionDef - Check that the parameters of the given function are appropriate for the de...
TopLevelStmtDecl * ActOnStartTopLevelStmtDecl(Scope *S)
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don't have one.
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".
OptimizeNoneAttr * mergeOptimizeNoneAttr(Decl *D, const AttributeCommonInfo &CI)
bool CheckImmediateEscalatingFunctionDefinition(FunctionDecl *FD, const sema::FunctionScopeInfo *FSI)
void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor)
In the MS ABI, we need to instantiate default arguments of dllexported default constructors along wit...
void CheckCompleteVariableDeclaration(VarDecl *VD)
bool IsOverride(FunctionDecl *MD, FunctionDecl *BaseMD, bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs=true)
DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, ArrayRef< Decl * > Group)
void setFunctionHasBranchProtectedScope()
RedeclarationKind forRedeclarationInCurContext() const
void MergeVarDecl(VarDecl *New, LookupResult &Previous)
MergeVarDecl - We just parsed a variable 'New' which has the same name and scope as a previous declar...
LazyDeclPtr StdNamespace
The C++ "std" namespace, where the standard library resides.
ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II, SourceLocation NameLoc, bool IsTemplateTypeArg)
Attempt to behave like MSVC in situations where lookup of an unqualified type name has failed in a de...
EnforceTCBLeafAttr * mergeEnforceTCBLeafAttr(Decl *D, const EnforceTCBLeafAttr &AL)
@ CCEK_Enumerator
Enumerator value with fixed underlying type.
void ActOnLastBitfield(SourceLocation DeclStart, SmallVectorImpl< Decl * > &AllIvarDecls)
ActOnLastBitfield - This routine handles synthesized bitfields rules for class and class extensions.
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.
llvm::DenseMap< IdentifierInfo *, AsmLabelAttr * > ExtnameUndeclaredIdentifiers
ExtnameUndeclaredIdentifiers - Identifiers contained in #pragma redefine_extname before declared.
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type.
EnumConstantDecl * CheckEnumConstant(EnumDecl *Enum, EnumConstantDecl *LastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, Expr *val)
bool CheckForConstantInitializer(Expr *Init, unsigned DiagID=diag::err_init_element_not_constant)
type checking declaration initializers (C99 6.7.8)
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
@ Ovl_NonFunction
This is not an overload because the lookup results contain a non-function.
@ Ovl_Overload
This is a legitimate overload: the existing declarations are functions or function templates with dif...
@ Ovl_Match
This is not an overload because the signature exactly matches an existing declaration.
SmallVector< ExprWithCleanups::CleanupObject, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
void DiagnoseUnusedNestedTypedefs(const RecordDecl *D)
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
bool hasUncompilableErrorOccurred() const
Whether uncompilable error has occurred.
@ FirstDecl
Parsing the first decl in a TU.
void CheckConstrainedAuto(const AutoType *AutoT, SourceLocation Loc)
void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(FunctionDecl *FD)
If this function is a C++ replaceable global allocation function (C++2a [basic.stc....
@ ImmediateFunctionContext
In addition of being constant evaluated, the current expression occurs in an immediate function conte...
FormatAttr * mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Format, int FormatIdx, int FirstArg)
AvailabilityMergeKind
Describes the kind of merge to perform for availability attributes (including "deprecated",...
@ AMK_None
Don't merge availability attributes at all.
@ AMK_Override
Merge availability attributes for an override, which requires an exact match or a weakening of constr...
@ AMK_ProtocolImplementation
Merge availability attributes for an implementation of a protocol requirement.
@ AMK_OptionalProtocolImplementation
Merge availability attributes for an implementation of an optional protocol requirement.
@ AMK_Redeclaration
Merge availability attributes for a redeclaration, which requires an exact match.
void ActOnDocumentableDecls(ArrayRef< Decl * > Group)
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
void CheckStaticLocalForDllExport(VarDecl *VD)
Check if VD needs to be dllexport/dllimport due to being in a dllexport/import function.
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 {'.
Decl * ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, const ParsedAttributesView &DeclAttrs, RecordDecl *&AnonRecord)
ParsedFreeStandingDeclSpec - This method is invoked when a declspec with no declarator (e....
StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, SourceLocation LocAfterDecls)
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context)
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void ModifyFnAttributesMSPragmaOptimize(FunctionDecl *FD)
Only called on function definitions; if there is a MSVC #pragma optimize in scope,...
bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl)
Checks if the new declaration declared in dependent context must be put in the same redeclaration cha...
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
void DiscardCleanupsInEvaluationContext()
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
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.
UuidAttr * mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI, StringRef UuidAsWritten, MSGuidDecl *GuidDecl)
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
SourceManager & SourceMgr
bool CheckDestructor(CXXDestructorDecl *Destructor)
CheckDestructor - Checks a fully-formed destructor definition for well-formedness,...
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc, StringLiteral *Message=nullptr)
Decl * BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, RecordDecl *Record)
BuildMicrosoftCAnonymousStruct - Handle the declaration of an Microsoft C anonymous structure.
static bool CanBeGetReturnTypeOnAllocFailure(const FunctionDecl *FD)
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
static bool CanBeGetReturnObject(const FunctionDecl *FD)
NamespaceDecl * getStdNamespace() const
NamedDecl * ActOnTypedefDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous)
PragmaStack< StringLiteral * > DataSegStack
void deduceClosureReturnType(sema::CapturingScopeInfo &CSI)
Deduce a block or lambda's return type based on the return statements present in the body.
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
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 ...
@ TPC_FriendFunctionTemplate
@ TPC_ClassTemplateMember
@ TPC_FriendFunctionTemplateDefinition
NamedDecl * ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *D, LookupResult &Previous, bool &Redeclaration)
ActOnTypedefNameDecl - Perform semantic checking for a declaration which declares a typedef-name,...
void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs)
ActOnFinishDelayedAttribute - Invoked when we have finished parsing an attribute for which parsing is...
void DiagnoseUnusedDecl(const NamedDecl *ND)
void DiagnoseAutoDeductionFailure(const VarDecl *VDecl, const Expr *Init)
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
QualType CheckConstructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckConstructorDeclarator - Called by ActOnDeclarator to check the well-formedness of the constructo...
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D.
QualType SubstAutoTypeDependent(QualType TypeWithAuto)
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope.
void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, const WeakInfo &W)
DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak applied to it,...
bool IsInvalidSMECallConversion(QualType FromType, QualType ToType)
void ActOnUninitializedDecl(Decl *dcl)
void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc)
Emit diagnostics if the initializer or any of its explicit or implicitly-generated subexpressions req...
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope.
TypedefDecl * ParseTypedefDecl(Scope *S, Declarator &D, QualType T, TypeSourceInfo *TInfo)
Subroutines of ActOnDeclarator().
sema::LambdaScopeInfo * getEnclosingLambda() const
Get the innermost lambda enclosing the current location, if any.
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionExceptionSpec - Checks whether the exception spec is a subset of base spec.
Decl * ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth)
ActOnField - Each field of a C struct/union is passed into this in order to create a FieldDecl object...
AvailabilityAttr * mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI, IdentifierInfo *Platform, bool Implicit, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool IsUnavailable, StringRef Message, bool IsStrict, StringRef Replacement, AvailabilityMergeKind AMK, int Priority, IdentifierInfo *IIEnvironment)
void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old)
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...
void ActOnCXXForRangeDecl(Decl *D)
bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionReturnType - Checks whether the return types are covariant,...
std::tuple< MangleNumberingContext *, Decl * > getCurrentMangleNumberContext(const DeclContext *DC)
Compute the mangling number context for a lambda expression or block literal.
void diagnoseFunctionEffectMergeConflicts(const FunctionEffectSet::Conflicts &Errs, SourceLocation NewLoc, SourceLocation OldLoc)
llvm::MapVector< IdentifierInfo *, llvm::SetVector< WeakInfo, llvm::SmallVector< WeakInfo, 1u >, llvm::SmallDenseSet< WeakInfo, 2u, WeakInfo::DenseMapInfoByAliasOnly > > > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD=nullptr)
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
PragmaClangSection PragmaClangBSSSection
Decl * ActOnDeclarator(Scope *S, Declarator &D)
void ProcessAPINotes(Decl *D)
Map any API notes provided for this declaration to attributes on the declaration.
void CheckAlignasUnderalignment(Decl *D)
bool CheckRedeclarationInModule(NamedDecl *New, NamedDecl *Old)
A wrapper function for checking the semantic restrictions of a redeclaration within a module.
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
ExprResult ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, bool IsAddressOfOperand)
Act on the result of classifying a name as an undeclared member of a dependent base class.
void adjustMemberFunctionCC(QualType &T, bool HasThisPointer, bool IsCtorOrDtor, SourceLocation Loc)
Adjust the calling convention of a method to be the ABI default if it wasn't specified explicitly.
void ActOnPragmaWeakAlias(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
void CheckVariableDeclarationType(VarDecl *NewVD)
unsigned getTemplateDepth(Scope *S) const
Determine the number of levels of enclosing template parameters.
SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD)
Invoked when we enter a tag definition that we're skipping.
bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit, Expr *Init)
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.
bool isIncompatibleTypedef(const TypeDecl *Old, TypedefNameDecl *New)
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
llvm::SmallPtrSet< const NamedDecl *, 4 > TypoCorrectedFunctionDefinitions
The function definitions which were renamed as part of typo-correction to match their respective decl...
void AddSectionMSAllocText(FunctionDecl *FD)
Only called on function definitions; if there is a #pragma alloc_text that decides which code section...
void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope)
Given the set of return statements within a function body, compute the variables that are subject to ...
void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind)
Emit diagnostics if a non-trivial C union type or a struct that contains a non-trivial C union is use...
IdentifierResolver IdResolver
bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, bool AllowMask) const
IsValueInFlagEnum - Determine if a value is allowed as part of a flag enum.
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
void DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, CXXScopeSpec *SS, ParsedType &SuggestedType, bool IsTemplateName=false)
void DiagnoseSizeOfParametersAndReturnValue(ArrayRef< ParmVarDecl * > Parameters, QualType ReturnTy, NamedDecl *D)
Diagnose whether the size of parameters or return value of a function or obj-c method definition is p...
void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD)
llvm::SmallVector< std::pair< SourceLocation, const BlockDecl * >, 1 > ImplicitlyRetainedSelfLocs
List of SourceLocations where 'self' is implicitly retained inside a block.
bool checkMSInheritanceAttrOnDefinition(CXXRecordDecl *RD, SourceRange Range, bool BestCase, MSInheritanceModel SemanticSpelling)
TemplateNameKindForDiagnostics
Describes the detailed kind of a template name. Used in diagnostics.
void warnOnReservedIdentifier(const NamedDecl *D)
bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy, bool IsFixed, const EnumDecl *Prev)
Check whether this is a valid redeclaration of a previous enumeration.
void inferNullableClassAttribute(CXXRecordDecl *CRD)
Add _Nullable attributes for std:: types.
NamedDecl * ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef< BindingDecl * > Bindings=std::nullopt)
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
ExprResult ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *OverloadSet)
Act on the result of classifying a name as an overload set.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
OptionalFileEntryRef getFileEntryRefForID(FileID FID) const
Returns the FileEntryRef for the provided FileID.
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
SourceLocation getIncludeLoc(FileID FID) const
Returns the include location if FID is a #include'd file otherwise it returns an invalid location.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
StringRef getFilename(SourceLocation SpellingLoc) const
Return the filename of the file containing a SourceLocation.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
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
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getStrTokenLoc(unsigned TokNum) const
Get one of the string literal token.
StringRef getString() const
Represents the declaration of a struct/union/class/enum.
static TagDecl * castFromDeclContext(const DeclContext *DC)
bool isBeingDefined() const
Return true if this decl is currently being defined.
bool isThisDeclarationADefinition() const
Return true if this declaration is a completion definition of the type.
SourceLocation getInnerLocStart() const
Return SourceLocation representing start of source range ignoring outer template declarations.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
void startDefinition()
Starts the definition of this tag declaration.
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type?
TagKind getTagKind() const
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
bool canKeyFunctionBeInline() const
Can an out-of-line inline function serve as a key function?
Exposes information about the current target.
virtual bool validateCpuIs(StringRef Name) const
unsigned getShortWidth() const
Return the size of 'signed short' and 'unsigned short' for this target, in bits.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
virtual bool allowDebugInfoForExternalRef() const
Whether target allows debuginfo types for decl only variables/functions.
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...
bool isTLSSupported() const
Whether the target supports thread-local storage.
unsigned getMaxTLSAlign() const
Return the maximum alignment (in bits) of a TLS variable.
virtual bool validateCpuSupports(StringRef Name) const
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool isValidFeatureName(StringRef Feature) const
Determine whether this TargetInfo supports the given feature.
unsigned getCharWidth() const
virtual ParsedTargetAttr parseTargetAttr(StringRef Str) const
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
bool supportsMultiVersioning() const
Identify whether this target supports multiversioning of functions, which requires support for cpu_su...
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
virtual bool isValidGCCRegisterName(StringRef Name) const
Returns whether the passed in string is a valid register name according to GCC.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Location wrapper for a TemplateArgument.
The base class of all kinds of template declarations (e.g., class, function, etc.).
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
Stores a list of template parameters for a TemplateDecl and its derived classes.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation getRAngleLoc() const
SourceLocation getTemplateLoc() const
Represents a type template specialization; the template must be a class template, a type alias templa...
static bool anyInstantiationDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args)
Token - This structure provides full information about a lexed token.
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
bool isNot(tok::TokenKind K) const
A declaration that models statements at global scope.
static TopLevelStmtDecl * Create(ASTContext &C, Stmt *Statement)
Represents a declaration of a type.
void setTypeForDecl(const Type *TD)
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.
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
TypeLoc IgnoreParens() const
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
void initializeFullCopy(TypeLoc Other)
Initializes this by copying its information from another TypeLoc of the same 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 getTemplateKeywordLoc() const
Get the SourceLocation of the template keyword (if any).
SourceLocation getEndLoc() const
Get the end source location.
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
static StringRef getTagTypeKindName(TagTypeKind Kind)
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
The base class of the type hierarchy.
bool isSizelessType() const
As an extension, we classify types as one of "sized" or "sizeless"; every type is one or the other.
bool isStructureType() const
bool isDecltypeType() const
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isDependentSizedArrayType() const
bool isBlockPointerType() const
bool isBooleanType() const
bool isFunctionReferenceType() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
bool isIncompleteArrayType() const
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
bool isDependentAddressSpaceType() const
bool isConstantArrayType() const
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool isVoidPointerType() const
bool isFunctionPointerType() const
bool isPointerType() const
bool isSVESizelessBuiltinType() const
Returns true for SVE scalable vector types.
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isScalarType() const
bool isVariableArrayType() const
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
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.
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 isBitIntType() const
bool isOpenCLSpecificType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type.
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
const RecordType * getAsStructureType() const
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
bool containsErrors() const
Whether this type is an error type.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isAtomicType() const
bool isFunctionProtoType() const
bool isObjCIdType() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
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...
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
const T * getAsAdjusted() const
Member-template getAsAdjusted<specific type>.
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isMemberFunctionPointerType() const
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
bool isFloatingType() const
bool isAnyPointerType() const
TypeClass getTypeClass() const
bool hasAutoForTrailingReturnType() const
Determine whether this type was written with a leading 'auto' corresponding to a trailing return type...
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isNullPtrType() const
bool isRecordType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
bool isFunctionNoProtoType() const
bool isReserveIDT() const
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
bool isSizelessVectorType() const
Returns true for all scalable vector types.
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
Base class for declarations which introduce a typedef-name.
TypeSourceInfo * getTypeSourceInfo() const
void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy)
QualType getUnderlyingType() const
void setTypeSourceInfo(TypeSourceInfo *newType)
TagDecl * getAnonDeclWithTypedefName(bool AnyRedecl=false) const
Retrieves the tag declaration for which this is the typedef name for linkage purposes,...
TypedefNameDecl * getDecl() const
Simple class containing the result of Sema::CorrectTypo.
IdentifierInfo * getCorrectionAsIdentifierInfo() const
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
SmallVectorImpl< NamedDecl * >::const_iterator const_decl_iterator
DeclarationName getCorrection() const
Gets the DeclarationName of the typo correction.
unsigned getEditDistance(bool Normalized=true) const
Gets the "edit distance" of the typo correction from the typo.
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
SmallVectorImpl< NamedDecl * >::iterator decl_iterator
void setCorrectionDecl(NamedDecl *CDecl)
Clears the list of NamedDecls before adding the new one.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represents a C++ unqualified-id that has been parsed.
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent)
The iterator over UnresolvedSets.
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.
BaseUsingDecl * getIntroducer() const
Gets the (written or instantiated) using declaration that introduced this declaration.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Represents a variable declaration or definition.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
void setCXXForRangeDecl(bool FRD)
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
TLSKind getTLSKind() const
void setInitStyle(InitializationStyle Style)
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member.
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
bool isCXXCondDecl() const
@ ListInit
Direct list-initialization (C++11)
@ ParenListInit
Parenthesized list-initialization (C++20)
@ CallInit
Call-style initialization (C++98)
void setStorageClass(StorageClass SC)
void setPreviousDeclInSameBlockScope(bool Same)
bool isStaticDataMember() const
Determines whether this is a static data member.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
void setInlineSpecified()
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization,...
bool isFileVarDecl() const
Returns true for file scoped variable declaration.
void setTSCSpec(ThreadStorageClassSpecifier TSC)
bool isInline() const
Whether this variable is (C++1z) inline.
ThreadStorageClassSpecifier getTSCSpec() const
const Expr * getInit() const
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
VarDecl * getInitializingDeclaration()
Get the initializing declaration of this variable, if any.
void setConstexpr(bool IC)
@ TLS_Static
TLS with a known-constant initializer.
@ TLS_Dynamic
TLS with a dynamic initializer.
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
@ TentativeDefinition
This declaration is a tentative definition.
@ DeclarationOnly
This declaration is only a declaration.
@ Definition
This declaration is definitely a definition.
void setDescribedVarTemplate(VarTemplateDecl *Template)
bool isExternC() const
Determines whether this variable is a variable with external, C linkage.
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
void setImplicitlyInline()
bool isThisDeclarationADemotedDefinition() const
If this definition should pretend to be a declaration.
bool isPreviousDeclInSameBlockScope() const
Whether this local extern variable declaration's previous declaration was declared in the same block ...
bool hasDependentAlignment() const
Determines if this variable's alignment is dependent.
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
void demoteThisDefinitionToDeclaration()
This is a definition which should be demoted to a declaration.
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
Declaration of a variable template.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
VarTemplateDecl * getInstantiatedFromMemberTemplate() const
static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)
Create a variable template node.
Represents a C array with a specified size that is not an integer-constant-expression.
Expr * getSizeExpr() const
Captures information about a #pragma weak directive.
void disableCheckFallThrough()
Policy getDefaultPolicy()
ValueDecl * getVariable() const
bool isVariableCapture() const
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
void addVLATypeCapture(SourceLocation Loc, const VariableArrayType *VLAType, QualType CaptureType)
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
SmallVector< Capture, 4 > Captures
Captures - The captures.
ImplicitCaptureStyle ImpCaptureStyle
bool isCXXThisCaptured() const
Determine whether the C++ 'this' is captured.
void addThisCapture(bool isNested, SourceLocation Loc, QualType CaptureType, bool ByCopy)
void addCapture(ValueDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
Retains information about a function, method, or block that is currently being parsed.
bool UsesFPIntrin
Whether this function uses constrained floating point intrinsics.
void addByrefBlockVar(VarDecl *VD)
bool NeedsScopeChecking() const
bool ObjCShouldCallSuper
A flag that is set when parsing a method that must call super's implementation, such as -dealloc,...
bool ObjCWarnForNoInitDelegation
This starts true for a secondary initializer method and will be set to false if there is an invocatio...
bool HasPotentialAvailabilityViolations
Whether we make reference to a declaration that could be unavailable.
bool ObjCWarnForNoDesignatedInitChain
This starts true for a method marked as designated initializer and will be set to false if there is a...
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
ParmVarDecl * ExplicitObjectParameter
llvm::SmallVector< ShadowedOuterDecl, 4 > ShadowingDecls
CXXRecordDecl * Lambda
The class that describes the lambda.
bool AfterParameterList
Indicate that we parsed the parameter list at which point the mutability of the lambda is known.
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
bool Mutable
Whether this is a mutable lambda.
Provides information about an attempted template argument deduction, whose success or failure was des...
Defines the clang::TargetInfo interface.
bool evaluateRequiredTargetFeatures(llvm::StringRef RequiredFatures, const llvm::StringMap< bool > &TargetFetureMap)
Returns true if the required target features of a builtin function are enabled.
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
bool randomizeStructureLayout(const ASTContext &Context, RecordDecl *RD, llvm::SmallVectorImpl< Decl * > &FinalOrdering)
The JSON file list parser is used to communicate input to InstallAPI.
bool FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI)
TypeSpecifierType
Specifies the kind of type.
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
@ OR_Deleted
Succeeded, but refers to a deleted function.
@ OR_Success
Overload resolution succeeded.
@ OR_Ambiguous
Ambiguous candidates found.
@ OR_No_Viable_Function
No viable function found.
@ GVA_AvailableExternally
SmallVector< Attr *, 4 > AttrVec
AttrVec - A vector of Attr, which is how they are stored on the AST.
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
ConstexprSpecKind
Define the kind of constexpr specifier.
InClassInitStyle
In-class initialization styles for non-static data members.
@ ICIS_NoInit
No in-class initializer.
OverloadCandidateDisplayKind
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
@ LCK_ByRef
Capturing by reference.
@ LCK_StarThis
Capturing the *this object by copy.
@ IK_DeductionGuideName
A deduction-guide name (a template-name)
@ IK_ImplicitSelfParam
An implicit 'self' parameter.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_ConstructorTemplateId
A constructor named via a template-id.
@ IK_ConstructorName
A constructor name.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
@ IK_DestructorName
A destructor name.
@ IK_OperatorFunctionId
An overloaded operator name, e.g., operator+.
@ IK_ConversionFunctionId
A conversion function name, e.g., operator int.
bool DeclAttrsMatchCUDAMode(const LangOptions &LangOpts, Decl *D)
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have.
StorageClass
Storage classes.
ThreadStorageClassSpecifier
Thread storage-class-specifier.
@ TSCS_thread_local
C++11 thread_local.
@ TSCS__Thread_local
C11 _Thread_local.
@ TSCS___thread
GNU __thread.
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)
Insertion operator for diagnostics.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ External
External linkage, which indicates that the entity can be referred to from other translation units.
@ Module
Module linkage, which indicates that the entity can be referred to from other translation units withi...
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Parameter
The parameter type of a method or function.
@ Result
The result type of a method or function.
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
bool supportsVariadicCall(CallingConv CC)
Checks whether the given calling convention supports variadic calls.
TagTypeKind
The kind of a tag type.
@ Interface
The "__interface" keyword.
@ Struct
The "struct" keyword.
@ Class
The "class" keyword.
@ Union
The "union" keyword.
@ Enum
The "enum" keyword.
LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t',...
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
bool isDiscardableGVALinkage(GVALinkage L)
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword.
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ CanNeverPassInRegs
The argument of this type cannot be passed directly in registers.
@ TU_Complete
The translation unit is a complete translation unit.
int hasAttribute(AttributeCommonInfo::Syntax Syntax, const IdentifierInfo *Scope, const IdentifierInfo *Attr, const TargetInfo &Target, const LangOptions &LangOpts)
Return the version number associated with the attribute if we recognize and implement the attribute s...
CXXSpecialMemberKind
Kinds of C++ special members.
@ TNK_Type_template
The name refers to a template whose specialization produces a type.
LambdaCaptureDefault
The default, if any, capture method for a lambda expression.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
const FunctionProtoType * T
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.
@ Success
Template argument deduction was successful.
@ AlreadyDiagnosed
Some error which was already diagnosed.
@ 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.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ None
The alignment was not explicit in code.
@ None
No keyword precedes the qualified type name.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
bool IsArmStreamingFunction(const FunctionDecl *FD, bool IncludeLocallyStreaming)
Returns whether the given FunctionDecl has an __arm[_locally]_streaming attribute.
@ EST_None
no exception specification
@ EST_BasicNoexcept
noexcept
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
MutableArrayRef< Expr * > MultiExprArg
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.
void setLoc(SourceLocation L)
setLoc - Sets the main location of the declaration name.
void setCXXLiteralOperatorNameLoc(SourceLocation Loc)
setCXXLiteralOperatorNameLoc - Sets the location of the literal operator name (not the operator keywo...
void setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
void setCXXOperatorNameRange(SourceRange R)
setCXXOperatorNameRange - Sets the range of the operator name (without the operator keyword).
SourceRange getCXXOperatorNameRange() const
getCXXOperatorNameRange - Gets the range of the operator name (without the operator keyword).
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
ArrayRef< NamedDecl * > getDeclsInPrototype() const
Get the non-parameter decls defined within this function prototype.
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
const IdentifierInfo * Ident
One instance of this struct is used for each type in a declarator that is parsed.
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
enum clang::DeclaratorChunk::@225 Kind
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl * > DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult(), SourceLocation TrailingReturnTypeLoc=SourceLocation(), DeclSpec *MethodQualifiers=nullptr)
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
MemberPointerTypeInfo Mem
static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc, bool lvalue)
Return a DeclaratorChunk for a reference.
RetTy visit(QualType FT, Ts &&... Args)
EvalResult is a struct with detailed info about an evaluated expression.
A FunctionEffect plus a potential boolean expression determining whether the effect is declared (e....
std::string description() const
Return a textual description of the effect, and its condition, if any.
Extra information about a function prototype.
unsigned AArch64SMEAttributes
FunctionEffectsRef FunctionEffects
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI)
Contains information gathered from parsing the contents of TargetAttr.
std::vector< std::string > Features
Describes how types, statements, expressions, and declarations should be printed.
SourceLocation PragmaLocation
Information about a template-id annotation token.
unsigned NumArgs
NumArgs - The number of template arguments.
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.
SourceLocation TemplateKWLoc
TemplateKWLoc - The location of the template keyword.