60#include "llvm/ADT/STLForwardCompat.h"
61#include "llvm/ADT/SmallString.h"
62#include "llvm/ADT/StringExtras.h"
63#include "llvm/TargetParser/Triple.h"
67#include <unordered_map>
74 Decl *Group[2] = { OwnedType, Ptr };
85 TypeNameValidatorCCC(
bool AllowInvalid,
bool WantClass =
false,
86 bool AllowTemplates =
false,
87 bool AllowNonTemplates =
true)
88 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
89 AllowTemplates(AllowTemplates), AllowNonTemplates(AllowNonTemplates) {
90 WantExpressionKeywords =
false;
91 WantCXXNamedCasts =
false;
92 WantRemainingKeywords =
false;
97 if (!AllowInvalidDecl && ND->isInvalidDecl())
101 return AllowTemplates;
103 bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
107 if (AllowNonTemplates)
112 if (AllowTemplates) {
113 auto *RD = dyn_cast<CXXRecordDecl>(ND);
114 if (!RD || !RD->isInjectedClassName())
116 RD = cast<CXXRecordDecl>(RD->getDeclContext());
117 return RD->getDescribedClassTemplate() ||
118 isa<ClassTemplateSpecializationDecl>(RD);
124 return !WantClassName && candidate.
isKeyword();
127 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
128 return std::make_unique<TypeNameValidatorCCC>(*
this);
132 bool AllowInvalidDecl;
135 bool AllowNonTemplates;
141enum class UnqualifiedTypeNameLookupResult {
152static UnqualifiedTypeNameLookupResult
157 return UnqualifiedTypeNameLookupResult::NotFound;
159 UnqualifiedTypeNameLookupResult FoundTypeDecl =
160 UnqualifiedTypeNameLookupResult::NotFound;
163 if (
auto *BaseTT =
Base.getType()->getAs<
TagType>())
164 BaseRD = BaseTT->getAsCXXRecordDecl();
168 if (!TST || !TST->isDependentType())
170 auto *TD = TST->getTemplateName().getAsTemplateDecl();
173 if (
auto *BasePrimaryTemplate =
174 dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) {
176 BaseRD = BasePrimaryTemplate;
177 else if (
auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
179 CTD->findPartialSpecialization(
Base.getType()))
187 if (!isa<TypeDecl>(ND))
188 return UnqualifiedTypeNameLookupResult::FoundNonType;
189 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
191 if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
193 case UnqualifiedTypeNameLookupResult::FoundNonType:
194 return UnqualifiedTypeNameLookupResult::FoundNonType;
195 case UnqualifiedTypeNameLookupResult::FoundType:
196 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
198 case UnqualifiedTypeNameLookupResult::NotFound:
205 return FoundTypeDecl;
213 UnqualifiedTypeNameLookupResult FoundTypeDecl =
214 UnqualifiedTypeNameLookupResult::NotFound;
216 DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
220 RD = dyn_cast<CXXRecordDecl>(DC);
224 if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
230 S.
Diag(NameLoc, diag::ext_found_in_dependent_base) << &II;
252 bool WantNontrivialTypeSourceInfo =
true) {
254 case Type::DeducedTemplateSpecialization:
256 case Type::InjectedClassName:
259 case Type::UnresolvedUsing:
264 case Type::ObjCInterface:
265 case Type::ObjCTypeParam:
266 case Type::TemplateTypeParm:
269 llvm_unreachable(
"Unexpected Type Class");
277 if (!WantNontrivialTypeSourceInfo)
281 Builder.pushTypeSpec(
T).setNameLoc(NameLoc);
290 bool HasTrailingDot,
ParsedType ObjectTypePtr,
291 bool IsCtorOrDtorName,
292 bool WantNontrivialTypeSourceInfo,
293 bool IsClassTemplateDeductionContext,
297 bool AllowDeducedTemplate = IsClassTemplateDeductionContext &&
299 !isClassName && !HasTrailingDot;
324 !isClassName && !IsCtorOrDtorName)
326 bool IsImplicitTypename = !isClassName && !IsCtorOrDtorName;
327 if (IsImplicitTypename) {
330 Diag(QualifiedLoc, diag::warn_cxx17_compat_implicit_typename);
332 Diag(QualifiedLoc, diag::ext_implicit_typename)
339 if (WantNontrivialTypeSourceInfo)
375 if (ObjectTypePtr &&
Result.empty()) {
399 switch (
Result.getResultKind()) {
402 TypeNameValidatorCCC CCC(
true, isClassName,
403 AllowDeducedTemplate);
408 bool MemberOfUnknownSpecialization;
417 if (Correction && (NNS || NewII != &II) &&
423 Template, MemberOfUnknownSpecialization))) {
425 isClassName, HasTrailingDot, ObjectTypePtr,
427 WantNontrivialTypeSourceInfo,
428 IsClassTemplateDeductionContext);
431 PDiag(diag::err_unknown_type_or_class_name_suggest)
432 <<
Result.getLookupName() << isClassName);
435 *CorrectedII = NewII;
440 Result.suppressDiagnostics();
456 Result.suppressDiagnostics();
466 Result.suppressDiagnostics();
472 Res != ResEnd; ++Res) {
474 if (isa<TypeDecl, ObjCInterfaceDecl, UnresolvedUsingIfExistsDecl>(
481 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*Res);
493 Result.suppressDiagnostics();
504 IIDecl =
Result.getFoundDecl();
505 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*
Result.begin());
509 assert(IIDecl &&
"Didn't find decl");
512 if (
TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
516 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
517 auto *FoundRD = dyn_cast<CXXRecordDecl>(TD);
518 if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD &&
519 FoundRD->isInjectedClassName() &&
521 Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor)
532 FoundUsingShadow =
nullptr;
533 }
else if (
auto *UD = dyn_cast<UnresolvedUsingIfExistsDecl>(IIDecl)) {
537 }
else if (AllowDeducedTemplate) {
539 assert(!FoundUsingShadow || FoundUsingShadow->
getTargetDecl() == TD);
546 FoundUsingShadow =
nullptr;
552 Result.suppressDiagnostics();
556 if (FoundUsingShadow)
559 return buildNamedType(*
this, SS,
T, NameLoc, WantNontrivialTypeSourceInfo);
567 auto *ND = dyn_cast<NamespaceDecl>(DC);
568 if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
570 else if (
auto *RD = dyn_cast<CXXRecordDecl>(DC))
572 RD->getTypeForDecl());
573 else if (isa<TranslationUnitDecl>(DC))
576 llvm_unreachable(
"something isn't in TU scope?");
587 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
588 if (MD->getParent()->hasAnyDependentBases())
596 bool IsTemplateTypeArg) {
597 assert(
getLangOpts().MSVCCompat &&
"shouldn't be called in non-MSVC mode");
600 if (IsTemplateTypeArg &&
getCurScope()->isTemplateParamScope()) {
609 Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
615 RD->getTypeForDecl());
619 Diag(NameLoc, diag::ext_undeclared_unqual_id_with_dependent_base) << &II
650 switch (TD->getTagKind()) {
678 return S->isFunctionPrototypeScope();
688 bool IsTemplateName) {
693 SuggestedType =
nullptr;
697 TypeNameValidatorCCC CCC(
false,
false,
704 bool CanRecover = !IsTemplateName;
705 if (Corrected.isKeyword()) {
708 PDiag(IsTemplateName ? diag::err_no_template_suggest
709 : diag::err_unknown_typename_suggest)
711 II = Corrected.getCorrectionAsIdentifierInfo();
714 if (!SS || !SS->
isSet()) {
716 PDiag(IsTemplateName ? diag::err_no_template_suggest
717 : diag::err_unknown_typename_suggest)
720 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
721 bool DroppedSpecifier =
722 Corrected.WillReplaceSpecifier() && II->
getName() == CorrectedStr;
725 ? diag::err_no_member_template_suggest
726 : diag::err_unknown_nested_typename_suggest)
727 << II << DC << DroppedSpecifier << SS->
getRange(),
730 llvm_unreachable(
"could not have corrected a typo here");
737 if (Corrected.getCorrectionSpecifier())
742 getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), IILoc, S,
743 tmpSS.
isSet() ? &tmpSS : SS,
false,
false,
nullptr,
753 Name.setIdentifier(II, IILoc);
756 bool MemberOfUnknownSpecialization;
758 Name,
nullptr,
true, TemplateResult,
769 Diag(IILoc, IsTemplateName ? diag::err_no_template
770 : diag::err_unknown_typename)
773 Diag(IILoc, IsTemplateName ? diag::err_no_member_template
774 : diag::err_typename_nested_not_found)
780 unsigned DiagID = diag::err_typename_missing;
782 DiagID = diag::ext_typename_missing;
789 *SS, *II, IILoc).
get();
792 "Invalid scope specifier has already been diagnosed");
800 NextToken.
is(tok::less);
803 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
806 if (CheckTemplate && isa<TemplateDecl>(*I))
820 StringRef FixItTagName;
821 switch (Tag->getTagKind()) {
823 FixItTagName =
"class ";
827 FixItTagName =
"enum ";
831 FixItTagName =
"struct ";
835 FixItTagName =
"__interface ";
839 FixItTagName =
"union ";
843 StringRef TagName = FixItTagName.drop_back();
844 SemaRef.
Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
845 << Name << TagName << SemaRef.
getLangOpts().CPlusPlus
850 SemaRef.
Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
865 const Token &NextToken,
870 assert(NextToken.
isNot(tok::coloncolon) &&
871 "parse nested name specifiers before calling ClassifyName");
912 bool SecondTry =
false;
913 bool IsFilteredTemplateName =
false;
916 switch (
Result.getResultKind()) {
920 if (SS.
isEmpty() && NextToken.
is(tok::l_paren)) {
966 if (!SecondTry && CCC) {
971 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
972 unsigned QualifiedDiag = diag::err_no_member_suggest;
975 NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl();
977 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
978 UnqualifiedDiag = diag::err_no_template_suggest;
979 QualifiedDiag = diag::err_no_member_template_suggest;
980 }
else if (UnderlyingFirstDecl &&
981 (isa<TypeDecl>(UnderlyingFirstDecl) ||
982 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
983 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
984 UnqualifiedDiag = diag::err_unknown_typename_suggest;
985 QualifiedDiag = diag::err_unknown_nested_typename_suggest;
991 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
992 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
993 Name->getName() == CorrectedStr;
996 << DroppedSpecifier << SS.
getRange());
1000 Name = Corrected.getCorrectionAsIdentifierInfo();
1003 if (Corrected.isKeyword())
1009 Result.setLookupName(Corrected.getCorrection());
1031 Result.suppressDiagnostics();
1073 if (!
Result.isAmbiguous()) {
1074 IsFilteredTemplateName =
true;
1084 (IsFilteredTemplateName ||
1100 if (!IsFilteredTemplateName)
1103 bool IsFunctionTemplate;
1107 IsFunctionTemplate =
true;
1110 }
else if (!
Result.empty()) {
1114 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
1115 IsVarTemplate = isa<VarTemplateDecl>(TD);
1118 dyn_cast<UsingShadowDecl>(*
Result.begin());
1119 assert(!FoundUsingShadow ||
1120 TD == cast<TemplateDecl>(FoundUsingShadow->
getTargetDecl()));
1128 IsFunctionTemplate =
true;
1132 if (IsFunctionTemplate) {
1136 Result.suppressDiagnostics();
1147 if (
const auto *USD = dyn_cast<UsingShadowDecl>(
Found))
1163 dyn_cast<ObjCCompatibleAliasDecl>(
FirstDecl))
1164 Class = Alias->getClassInterface();
1170 if (NextToken.
is(tok::period)) {
1173 Result.suppressDiagnostics();
1183 if (
auto *USD = dyn_cast<UsingShadowDecl>(
Result.getRepresentativeDecl()))
1189 if (
auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(
FirstDecl)) {
1202 bool NextIsOp = NextToken.
isOneOf(tok::amp, tok::star);
1203 if ((NextToken.
is(tok::identifier) ||
1205 FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
1217 if (
Result.isSingleResult() && !ADL &&
1222 Result.suppressDiagnostics();
1242 bool IsAddressOfOperand) {
1245 NameInfo, IsAddressOfOperand,
1252 const Token &NextToken) {
1254 if (
auto *Ivar = dyn_cast<ObjCIvarDecl>(
Found->getUnderlyingDecl()))
1269 auto *ULE = cast<UnresolvedLookupExpr>(
E);
1270 if ((*ULE->decls_begin())->isCXXClassMember()) {
1272 SS.
Adopt(ULE->getQualifierLoc());
1277 Result.setNamingClass(ULE->getNamingClass());
1278 for (
auto I = ULE->decls_begin(),
E = ULE->decls_end(); I !=
E; ++I)
1279 Result.addDecl(*I, I.getAccess());
1292 auto *TD = Name.getAsTemplateDecl();
1295 if (isa<ClassTemplateDecl>(TD))
1297 if (isa<FunctionTemplateDecl>(TD))
1299 if (isa<VarTemplateDecl>(TD))
1301 if (isa<TypeAliasTemplateDecl>(TD))
1303 if (isa<TemplateTemplateParmDecl>(TD))
1305 if (isa<ConceptDecl>(TD))
1312 "The next DeclContext should be lexically contained in the current one.");
1318 assert(
CurContext &&
"DeclContext imbalance!");
1321 assert(
CurContext &&
"Popped translation unit!");
1331 assert(
CurContext &&
"skipping definition of undefined tag");
1359 assert(!S->getEntity() &&
"scope already has entity");
1362 Scope *Ancestor = S->getParent();
1370 if (S->getParent()->isTemplateParamScope()) {
1378 assert(S->getEntity() ==
CurContext &&
"Context imbalance!");
1382 Scope *Ancestor = S->getParent();
1391 assert(S->isTemplateParamScope() &&
1392 "expected to be initializing a template parameter scope");
1416 for (; S && S->isTemplateParamScope(); S = S->getParent(), --ScopeDepth) {
1420 cast<Decl>(DC)->getDescribedTemplateParams()) {
1421 unsigned DCDepth = TPL->getDepth() + 1;
1422 if (DCDepth > ScopeDepth)
1424 if (ScopeDepth == DCDepth)
1429 S->setLookupEntity(SearchDCAfterScope);
1443 "The next DeclContext should be lexically contained in the current one.");
1447 for (
unsigned P = 0, NumParams = FD->
getNumParams();
P < NumParams; ++
P) {
1460 assert(
CurContext &&
"DeclContext imbalance!");
1462 assert(
CurContext &&
"Popped translation unit!");
1491 return ND->
hasAttr<OverloadableAttr>();
1494 return Previous.getFoundDecl()->hasAttr<OverloadableAttr>();
1503 while (S->getEntity() && S->getEntity()->isTransparentContext())
1518 if (isa<FunctionDecl>(
D) &&
1519 cast<FunctionDecl>(
D)->isFunctionTemplateSpecialization())
1522 if (isa<UsingEnumDecl>(
D) &&
D->getDeclName().isEmpty()) {
1529 for (; I != IEnd; ++I) {
1530 if (S->isDeclScope(*I) &&
D->declarationReplaces(*I)) {
1541 if (isa<LabelDecl>(
D) && !cast<LabelDecl>(
D)->isGnuLocal()) {
1548 if (!S->isDeclScope(*I))
1562 bool AllowInlineNamespace)
const {
1570 if (ScopeDC->getPrimaryContext() == TargetDC)
1572 }
while ((S = S->getParent()));
1582 bool ConsiderLinkage,
1583 bool AllowInlineNamespace) {
1641 if (NewIsModuleInterface || OldIsModuleInterface) {
1647 << NewIsModuleInterface
1649 << OldIsModuleInterface
1677 if (!IsNewExported && !IsOldExported)
1692 assert(IsNewExported);
1700 Diag(New->
getLocation(), diag::err_redeclaration_non_exported) << New << S;
1718 "New and Old are not the same definition, we should diagnostic it "
1719 "immediately instead of checking it.");
1722 "We shouldn't see unreachable definitions here.");
1770 return OldM == NewM;
1777 return isa<UsingShadowDecl>(
D) ||
1778 isa<UnresolvedUsingTypenameDecl>(
D) ||
1779 isa<UnresolvedUsingValueDecl>(
D);
1803 if (
D->doesThisDeclarationHaveABody())
1807 return CD->isCopyConstructor();
1808 return D->isCopyAssignmentOperator();
1814 if (
const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1815 if (!RD->hasNameForLinkage())
1821 return !
D->isExternallyVisible();
1850 FD->getMemberSpecializationInfo() && !FD->isOutOfLine())
1853 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1858 if (FD->isInlined() && !
isMainFileLoc(*
this, FD->getLocation()))
1862 if (FD->doesThisDeclarationHaveABody() &&
1865 }
else if (
const VarDecl *VD = dyn_cast<VarDecl>(
D)) {
1875 if (VD->isStaticDataMember() &&
1878 if (VD->isStaticDataMember() &&
1880 VD->getMemberSpecializationInfo() && !VD->isOutOfLine())
1883 if (VD->isInline() && !
isMainFileLoc(*
this, VD->getLocation()))
1892 return mightHaveNonExternalLinkage(
D);
1905 if (
const VarDecl *VD = dyn_cast<VarDecl>(
D)) {
1920 if (
const auto *DD = dyn_cast<DecompositionDecl>(
D)) {
1924 bool IsAllPlaceholders =
true;
1925 for (
const auto *BD : DD->bindings()) {
1926 if (BD->isReferenced() || BD->hasAttr<UnusedAttr>())
1928 IsAllPlaceholders = IsAllPlaceholders && BD->isPlaceholderVar(LangOpts);
1930 if (IsAllPlaceholders)
1932 }
else if (!
D->getDeclName()) {
1938 if (
D->isPlaceholderVar(LangOpts))
1945 if (isa<LabelDecl>(
D))
1954 WithinFunction || (R->isLocalClass() && !R->isDependentType());
1955 if (!WithinFunction)
1958 if (isa<TypedefNameDecl>(
D))
1962 if (!isa<VarDecl>(
D) || isa<ParmVarDecl>(
D) || isa<ImplicitParamDecl>(
D))
1966 if (
const VarDecl *VD = dyn_cast<VarDecl>(
D)) {
1969 if (
const auto *Cleanups = dyn_cast_if_present<ExprWithCleanups>(
Init))
1970 Init = Cleanups->getSubExpr();
1972 const auto *Ty = VD->getType().getTypePtr();
1977 if (TT->getDecl()->hasAttr<UnusedAttr>())
1983 if (
const auto *MTE = dyn_cast_if_present<MaterializeTemporaryExpr>(
Init);
1984 MTE && MTE->getExtendingDecl()) {
1985 Ty = VD->getType().getNonReferenceType().getTypePtr();
1986 Init = MTE->getSubExpr()->IgnoreImplicitAsWritten();
1991 if (Ty->isIncompleteType() || Ty->isDependentType())
1996 Ty = Ty->getBaseElementTypeUnsafe();
1999 const TagDecl *Tag = TT->getDecl();
2000 if (Tag->hasAttr<UnusedAttr>())
2003 if (
const auto *RD = dyn_cast<CXXRecordDecl>(Tag)) {
2004 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
2008 const auto *Construct =
2009 dyn_cast<CXXConstructExpr>(
Init->IgnoreImpCasts());
2010 if (Construct && !Construct->isElidable()) {
2012 if (!CD->
isTrivial() && !RD->hasAttr<WarnUnusedAttr>() &&
2013 (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
2019 if (
Init->isTypeDependent()) {
2021 if (!Ctor->isTrivial())
2027 if (isa<CXXUnresolvedConstructExpr>(
Init))
2041 if (isa<LabelDecl>(
D)) {
2059 if (
D->getTypeForDecl()->isDependentType())
2062 for (
auto *TmpD :
D->decls()) {
2063 if (
const auto *
T = dyn_cast<TypedefNameDecl>(TmpD))
2065 else if(
const auto *R = dyn_cast<RecordDecl>(TmpD))
2079 if (
auto *TD = dyn_cast<TypedefNameDecl>(
D)) {
2090 if (isa<VarDecl>(
D) && cast<VarDecl>(
D)->isExceptionVariable())
2091 DiagID = diag::warn_unused_exception_param;
2092 else if (isa<LabelDecl>(
D))
2093 DiagID = diag::warn_unused_label;
2095 DiagID = diag::warn_unused_variable;
2114 if (Ty->isReferenceType() || Ty->isDependentType())
2118 const TagDecl *Tag = TT->getDecl();
2119 if (Tag->hasAttr<UnusedAttr>())
2123 if (
const auto *RD = dyn_cast<CXXRecordDecl>(Tag);
2124 RD && !RD->hasAttr<WarnUnusedAttr>())
2131 if (VD->
hasAttr<BlocksAttr>() && Ty->isObjCObjectPointerType())
2137 if (VD->
hasAttr<ObjCPreciseLifetimeAttr>() && Ty->isObjCObjectPointerType())
2144 assert(iter->getSecond() >= 0 &&
2145 "Found a negative number of references to a VarDecl");
2146 if (
int RefCnt = iter->getSecond(); RefCnt > 0) {
2156 bool UnusedCXXCondDecl = VD->
isCXXCondDecl() && (RefCnt == 1);
2157 if (!UnusedCXXCondDecl)
2161 unsigned DiagID = isa<ParmVarDecl>(VD) ? diag::warn_unused_but_set_parameter
2162 : diag::warn_unused_but_set_variable;
2172 bool Diagnose =
false;
2176 Diagnose = L->
getStmt() ==
nullptr;
2185 if (S->decl_empty())
return;
2187 "Scope shouldn't contain decls!");
2194 std::optional<SourceLocation> PreviousDeclLoc;
2199 DeclDiags.push_back(LocAndDiag{
Loc, std::nullopt, std::move(PD)});
2204 DeclDiags.push_back(LocAndDiag{
Loc, PreviousDeclLoc, std::move(PD)});
2207 for (
auto *TmpD : S->decls()) {
2208 assert(TmpD &&
"This decl didn't get pushed??");
2210 assert(isa<NamedDecl>(TmpD) &&
"Decl isn't NamedDecl?");
2214 if (!S->hasUnrecoverableErrorOccurred()) {
2216 if (
const auto *RD = dyn_cast<RecordDecl>(
D))
2218 if (
VarDecl *VD = dyn_cast<VarDecl>(
D)) {
2224 if (!
D->getDeclName())
continue;
2238 auto ShadowI = ShadowingDecls.find(
D);
2239 if (ShadowI != ShadowingDecls.end()) {
2240 if (
const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
2242 PDiag(diag::warn_ctor_parm_shadows_field)
2243 <<
D << FD << FD->getParent());
2245 ShadowingDecls.erase(ShadowI);
2249 llvm::sort(DeclDiags,
2250 [](
const LocAndDiag &LHS,
const LocAndDiag &RHS) ->
bool {
2255 return LHS.Loc.getRawEncoding() < RHS.Loc.getRawEncoding();
2257 for (
const LocAndDiag &
D : DeclDiags) {
2259 if (
D.PreviousDeclLoc)
2260 Diag(*
D.PreviousDeclLoc, diag::note_previous_declaration);
2266 (S->getEntity() && S->getEntity()->isTransparentContext()) ||
2284 return "ucontext.h";
2286 llvm_unreachable(
"unhandled error kind");
2297 Parent->addDecl(CLinkageDecl);
2304 "consteval builtins should only be available in C++20 mode");
2319 for (
unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2322 FT->getParamType(i),
nullptr,
SC_None,
nullptr);
2324 Params.push_back(parm);
2326 New->setParams(Params);
2334 Scope *S,
bool ForRedeclaration,
2341 if (!ForRedeclaration)
2353 Diag(
Loc, diag::warn_implicit_decl_no_jmp_buf)
2360 Diag(
Loc, diag::warn_implicit_decl_requires_sysheader)
2366 if (!ForRedeclaration &&
2370 : diag::ext_implicit_lib_function_decl)
2373 Diag(
Loc, diag::note_include_header_or_declare)
2410 while (Filter.hasNext()) {
2419 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2421 Decl->getUnderlyingType()))
2426 if (OldTD->getAnonDeclWithTypedefName(
true) &&
2427 Decl->getAnonDeclWithTypedefName())
2439 if (
const TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
2440 OldType = OldTypedef->getUnderlyingType();
2447 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2448 Diag(New->
getLocation(), diag::err_redefinition_variably_modified_typedef)
2456 if (OldType != NewType &&
2460 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2462 << Kind << NewType << OldType;
2481 switch (TypeID->getLength()) {
2485 if (!TypeID->isStr(
"id"))
2501 if (!TypeID->isStr(
"Class"))
2508 if (!TypeID->isStr(
"SEL"))
2535 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2536 auto *OldTag = OldTD->getAnonDeclWithTypedefName(
true);
2540 OldTag->getCanonicalDecl() !=
NewTag->getCanonicalDecl() &&
2545 if (OldTD->isModed())
2547 OldTD->getUnderlyingType());
2556 if (isa<EnumDecl>(
NewTag)) {
2558 for (
auto *
D :
NewTag->decls()) {
2559 auto *ED = cast<EnumConstantDecl>(
D);
2563 ED->getLexicalDeclContext()->removeDecl(ED);
2613 if (!isa<TypedefNameDecl>(Old))
2645 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
2646 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
2647 for (
const auto *i :
D->
attrs())
2648 if (i->getKind() == A->
getKind()) {
2650 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
2655 if (OA && isa<OwnershipAttr>(i))
2656 return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
2664 if (
VarDecl *VD = dyn_cast<VarDecl>(
D))
2665 return VD->isThisDeclarationADefinition();
2666 if (
TagDecl *TD = dyn_cast<TagDecl>(
D))
2667 return TD->isCompleteDefinition() || TD->isBeingDefined();
2678 AlignedAttr *OldAlignasAttr =
nullptr;
2679 AlignedAttr *OldStrictestAlignAttr =
nullptr;
2680 unsigned OldAlign = 0;
2688 if (I->isAlignmentDependent())
2694 unsigned Align = I->getAlignment(S.
Context);
2695 if (Align > OldAlign) {
2697 OldStrictestAlignAttr = I;
2702 AlignedAttr *NewAlignasAttr =
nullptr;
2703 unsigned NewAlign = 0;
2705 if (I->isAlignmentDependent())
2711 unsigned Align = I->getAlignment(S.
Context);
2712 if (Align > NewAlign)
2716 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2724 if (OldAlign == 0 || NewAlign == 0) {
2726 if (
ValueDecl *VD = dyn_cast<ValueDecl>(New))
2737 if (OldAlign != NewAlign) {
2738 S.
Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2741 S.
Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2756 S.
Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2760 bool AnyAdded =
false;
2763 if (OldAlign > NewAlign) {
2764 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.
Context);
2765 Clone->setInherited(
true);
2771 if (OldAlignasAttr && !NewAlignasAttr &&
2772 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2773 AlignedAttr *Clone = OldAlignasAttr->clone(S.
Context);
2774 Clone->setInherited(
true);
2782#define WANT_DECL_MERGE_LOGIC
2783#include "clang/Sema/AttrParsedAttrImpl.inc"
2784#undef WANT_DECL_MERGE_LOGIC
2791 if (!DiagnoseMutualExclusions(S,
D,
Attr))
2802 if (
const auto *AA = dyn_cast<AvailabilityAttr>(
Attr))
2804 D, *AA, AA->getPlatform(), AA->
isImplicit(), AA->getIntroduced(),
2805 AA->getDeprecated(), AA->getObsoleted(), AA->getUnavailable(),
2806 AA->getMessage(), AA->getStrict(), AA->getReplacement(), AMK,
2807 AA->getPriority(), AA->getEnvironment());
2808 else if (
const auto *VA = dyn_cast<VisibilityAttr>(
Attr))
2810 else if (
const auto *VA = dyn_cast<TypeVisibilityAttr>(
Attr))
2812 else if (
const auto *ImportA = dyn_cast<DLLImportAttr>(
Attr))
2814 else if (
const auto *ExportA = dyn_cast<DLLExportAttr>(
Attr))
2816 else if (
const auto *EA = dyn_cast<ErrorAttr>(
Attr))
2818 else if (
const auto *FA = dyn_cast<FormatAttr>(
Attr))
2821 else if (
const auto *SA = dyn_cast<SectionAttr>(
Attr))
2823 else if (
const auto *CSA = dyn_cast<CodeSegAttr>(
Attr))
2825 else if (
const auto *IA = dyn_cast<MSInheritanceAttr>(
Attr))
2827 IA->getInheritanceModel());
2828 else if (
const auto *AA = dyn_cast<AlwaysInlineAttr>(
Attr))
2831 else if (S.
getLangOpts().CUDA && isa<FunctionDecl>(
D) &&
2832 (isa<CUDAHostAttr>(
Attr) || isa<CUDADeviceAttr>(
Attr) ||
2833 isa<CUDAGlobalAttr>(
Attr))) {
2837 }
else if (
const auto *MA = dyn_cast<MinSizeAttr>(
Attr))
2839 else if (
const auto *SNA = dyn_cast<SwiftNameAttr>(
Attr))
2841 else if (
const auto *OA = dyn_cast<OptimizeNoneAttr>(
Attr))
2843 else if (
const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(
Attr))
2845 else if (isa<AlignedAttr>(
Attr))
2849 else if ((isa<DeprecatedAttr>(
Attr) || isa<UnavailableAttr>(
Attr)) &&
2854 else if (
const auto *UA = dyn_cast<UuidAttr>(
Attr))
2855 NewAttr = S.
mergeUuidAttr(
D, *UA, UA->getGuid(), UA->getGuidDecl());
2856 else if (
const auto *IMA = dyn_cast<WebAssemblyImportModuleAttr>(
Attr))
2858 else if (
const auto *INA = dyn_cast<WebAssemblyImportNameAttr>(
Attr))
2860 else if (
const auto *TCBA = dyn_cast<EnforceTCBAttr>(
Attr))
2862 else if (
const auto *TCBLA = dyn_cast<EnforceTCBLeafAttr>(
Attr))
2864 else if (
const auto *BTFA = dyn_cast<BTFDeclTagAttr>(
Attr))
2866 else if (
const auto *NT = dyn_cast<HLSLNumThreadsAttr>(
Attr))
2869 else if (
const auto *WS = dyn_cast<HLSLWaveSizeAttr>(
Attr))
2872 WS->getSpelledArgsCount());
2873 else if (
const auto *SA = dyn_cast<HLSLShaderAttr>(
Attr))
2875 else if (isa<SuppressAttr>(
Attr))
2884 if (isa<MSInheritanceAttr>(NewAttr))
2893 if (
const TagDecl *TD = dyn_cast<TagDecl>(
D))
2894 return TD->getDefinition();
2895 if (
const VarDecl *VD = dyn_cast<VarDecl>(
D)) {
2903 if (FD->isDefined(Def,
true))
2910 for (
const auto *Attribute :
D->
attrs())
2911 if (Attribute->getKind() == Kind)
2923 if (!Def || Def == New)
2927 for (
unsigned I = 0,
E = NewAttributes.size(); I !=
E;) {
2928 Attr *NewAttribute = NewAttributes[I];
2930 if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {
2937 NewAttributes.erase(NewAttributes.begin() + I);
2942 VarDecl *VD = cast<VarDecl>(New);
2943 unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
2945 ? diag::err_alias_after_tentative
2946 : diag::err_redefinition;
2948 if (
Diag == diag::err_redefinition)
2958 if (
const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
2971 if (isa<C11NoReturnAttr>(NewAttribute)) {
2975 }
else if (isa<UuidAttr>(NewAttribute)) {
2979 }
else if (
const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
2980 if (AA->isAlignas()) {
2991 S.
Diag(NewAttribute->
getLocation(), diag::note_alignas_on_declaration)
2993 NewAttributes.erase(NewAttributes.begin() + I);
2997 }
else if (isa<LoaderUninitializedAttr>(NewAttribute)) {
3003 diag::err_loader_uninitialized_redeclaration);
3005 NewAttributes.erase(NewAttributes.begin() + I);
3009 }
else if (isa<SelectAnyAttr>(NewAttribute) &&
3010 cast<VarDecl>(New)->isInline() &&
3011 !cast<VarDecl>(New)->isInlineSpecified()) {
3018 }
else if (isa<OMPDeclareVariantAttr>(NewAttribute)) {
3023 }
else if (isa<SYCLKernelEntryPointAttr>(NewAttribute)) {
3028 diag::err_sycl_entry_point_after_definition);
3030 cast<SYCLKernelEntryPointAttr>(NewAttribute)->setInvalidAttr();
3036 diag::warn_attribute_precede_definition);
3038 NewAttributes.erase(NewAttributes.begin() + I);
3044 const ConstInitAttr *CIAttr,
3045 bool AttrBeforeInit) {
3052 std::string SuitableSpelling;
3054 SuitableSpelling = std::string(
3056 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3058 InsertLoc, {tok::l_square, tok::l_square,
3059 S.PP.getIdentifierInfo(
"clang"), tok::coloncolon,
3060 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3061 tok::r_square, tok::r_square}));
3062 if (SuitableSpelling.empty())
3064 InsertLoc, {tok::kw___attribute, tok::l_paren, tok::r_paren,
3065 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3066 tok::r_paren, tok::r_paren}));
3067 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus20)
3068 SuitableSpelling =
"constinit";
3069 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3070 SuitableSpelling =
"[[clang::require_constant_initialization]]";
3071 if (SuitableSpelling.empty())
3072 SuitableSpelling =
"__attribute__((require_constant_initialization))";
3073 SuitableSpelling +=
" ";
3075 if (AttrBeforeInit) {
3078 assert(CIAttr->isConstinit() &&
"should not diagnose this for attribute");
3081 S.
Diag(CIAttr->getLocation(), diag::note_constinit_specified_here);
3085 S.
Diag(CIAttr->getLocation(),
3086 CIAttr->isConstinit() ? diag::err_constinit_added_too_late
3087 : diag::warn_require_const_init_added_too_late)
3090 << CIAttr->isConstinit()
3098 UsedAttr *NewAttr = OldAttr->clone(
Context);
3099 NewAttr->setInherited(
true);
3103 RetainAttr *NewAttr = OldAttr->clone(
Context);
3104 NewAttr->setInherited(
true);
3114 const auto *OldConstInit = Old->
getAttr<ConstInitAttr>();
3115 const auto *NewConstInit = New->
getAttr<ConstInitAttr>();
3116 if (
bool(OldConstInit) !=
bool(NewConstInit)) {
3117 const auto *OldVD = cast<VarDecl>(Old);
3118 auto *NewVD = cast<VarDecl>(New);
3124 (NewVD->hasInit() || NewVD->isThisDeclarationADefinition()))
3127 if (InitDecl == NewVD) {
3131 if (OldConstInit && OldConstInit->isConstinit())
3134 }
else if (NewConstInit) {
3138 if (InitDecl && InitDecl != NewVD) {
3141 NewVD->dropAttr<ConstInitAttr>();
3149 if (AsmLabelAttr *NewA = New->
getAttr<AsmLabelAttr>()) {
3150 if (AsmLabelAttr *OldA = Old->
getAttr<AsmLabelAttr>()) {
3151 if (!OldA->isEquivalent(NewA)) {
3154 Diag(OldA->getLocation(), diag::note_previous_declaration);
3156 }
else if (Old->
isUsed()) {
3160 << isa<FunctionDecl>(Old) << New->
getAttr<AsmLabelAttr>()->
getRange();
3165 if (
const auto *NewAbiTagAttr = New->
getAttr<AbiTagAttr>()) {
3166 if (
const auto *OldAbiTagAttr = Old->
getAttr<AbiTagAttr>()) {
3167 for (
const auto &
NewTag : NewAbiTagAttr->tags()) {
3168 if (!llvm::is_contained(OldAbiTagAttr->tags(),
NewTag)) {
3169 Diag(NewAbiTagAttr->getLocation(),
3170 diag::err_new_abi_tag_on_redeclaration)
3172 Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
3176 Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
3182 if (New->
hasAttr<SectionAttr>() && !Old->
hasAttr<SectionAttr>()) {
3183 if (
auto *VD = dyn_cast<VarDecl>(New)) {
3185 Diag(New->
getLocation(), diag::warn_attribute_section_on_redeclaration);
3192 const auto *NewCSA = New->
getAttr<CodeSegAttr>();
3193 if (NewCSA && !Old->
hasAttr<CodeSegAttr>() &&
3194 !NewCSA->isImplicit() && isa<CXXMethodDecl>(New)) {
3212 if (isa<DeprecatedAttr>(I) ||
3213 isa<UnavailableAttr>(I) ||
3214 isa<AvailabilityAttr>(I)) {
3229 if (isa<UsedAttr>(I) || isa<RetainAttr>(I))
3249 T *newAttr = cast<T>(I->clone(S.
Context));
3250 newAttr->setInherited(
true);
3272 foundAny |= std::forward<F>(propagator)(To, From) != 0;
3287 const CarriesDependencyAttr *CDA = newDecl->
getAttr<CarriesDependencyAttr>();
3288 if (CDA && !oldDecl->
hasAttr<CarriesDependencyAttr>()) {
3289 S.
Diag(CDA->getLocation(),
3290 diag::err_carries_dependency_missing_on_first_decl) << 1;
3298 diag::note_carries_dependency_missing_first_decl) << 1;
3304 found += propagateAttribute<InheritableParamAttr>(To, From, S);
3309 found += propagateAttribute<LifetimeBoundAttr>(To, From, S);
3317 auto NoSizeInfo = [&Ctx](
QualType Ty) {
3318 if (Ty->isIncompleteArrayType() || Ty->isPointerType())
3326 if (NoSizeInfo(Old) && NoSizeInfo(New))
3358 if (*Oldnullability != *Newnullability) {
3359 S.
Diag(NewParam->
getLocation(), diag::warn_mismatched_nullability_attr)
3376 const auto *OldParamDT = dyn_cast<DecayedType>(OldParam->
getType());
3377 const auto *NewParamDT = dyn_cast<DecayedType>(NewParam->
getType());
3378 if (OldParamDT && NewParamDT &&
3379 OldParamDT->getPointeeType() == NewParamDT->getPointeeType()) {
3380 QualType OldParamOT = OldParamDT->getOriginalType();
3381 QualType NewParamOT = NewParamDT->getOriginalType();
3384 << NewParam << NewParamOT;
3395struct GNUCompatibleParamWarning {
3405template <
typename T>
3406static std::pair<diag::kind, SourceLocation>
3410 if (Old->isThisDeclarationADefinition())
3411 PrevDiag = diag::note_previous_definition;
3412 else if (Old->isImplicit()) {
3413 PrevDiag = diag::note_previous_implicit_declaration;
3414 if (
const auto *FD = dyn_cast<FunctionDecl>(Old)) {
3415 if (FD->getBuiltinID())
3416 PrevDiag = diag::note_previous_builtin_declaration;
3419 OldLocation = New->getLocation();
3421 PrevDiag = diag::note_previous_declaration;
3422 return std::make_pair(PrevDiag, OldLocation);
3430 return ((FD->
hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
3431 !LangOpts.CPlusPlus &&
3443template <
typename T>
3464template<
typename ExpectedDecl>
3486 !Old->getDeclContext()->getRedeclContext()->Equals(
3487 New->getDeclContext()->getRedeclContext()) &&
3492 S.
Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
3505 const auto *AttrA = A->
getAttr<PassObjectSizeAttr>();
3506 const auto *AttrB = B->
getAttr<PassObjectSizeAttr>();
3509 return AttrA && AttrB && AttrA->getType() == AttrB->getType() &&
3510 AttrA->isDynamic() == AttrB->isDynamic();
3536 if (NamedDC->Equals(SemaDC))
3539 assert((NamedDC->InEnclosingNamespaceSetOf(SemaDC) ||
3541 "unexpected context for redeclaration");
3552 if (
auto *FD = dyn_cast<FunctionDecl>(NewD))
3553 FixSemaDC(FD->getDescribedFunctionTemplate());
3554 else if (
auto *VD = dyn_cast<VarDecl>(NewD))
3555 FixSemaDC(VD->getDescribedVarTemplate());
3559 bool MergeTypeWithOld,
bool NewDeclIsDefn) {
3566 Diag(Shadow->getTargetDecl()->getLocation(),
3567 diag::note_using_decl_target);
3568 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
3577 if (checkUsingShadowRedecl<FunctionTemplateDecl>(*
this, Shadow,
3580 OldD = Old = cast<FunctionTemplateDecl>(Shadow->getTargetDecl())
3583 if (checkUsingShadowRedecl<FunctionDecl>(*
this, Shadow, New))
3585 OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
3613 std::tie(PrevDiag, OldLocation) =
3620 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
3627 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3630 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3635 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
3636 if (!Old->
hasAttr<InternalLinkageAttr>()) {
3640 New->
dropAttr<InternalLinkageAttr>();
3643 if (
auto *EA = New->
getAttr<ErrorAttr>()) {
3644 if (!Old->
hasAttr<ErrorAttr>()) {
3645 Diag(EA->getLocation(), diag::err_attribute_missing_on_first_decl) << EA;
3655 bool OldOvl = Old->
hasAttr<OverloadableAttr>();
3666 const Decl *DiagOld = Old;
3668 auto OldIter = llvm::find_if(Old->
redecls(), [](
const Decl *
D) {
3669 const auto *A = D->getAttr<OverloadableAttr>();
3670 return A && !A->isImplicit();
3674 DiagOld = OldIter == Old->
redecls_end() ? nullptr : *OldIter;
3679 diag::note_attribute_overloadable_prev_overload)
3694 Diag(OldLocation, diag::note_previous_declaration);
3713 const FunctionType *OldType = cast<FunctionType>(OldQType);
3714 const FunctionType *NewType = cast<FunctionType>(NewQType);
3717 bool RequiresAdjustment =
false;
3719 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC()) {
3725 if (!NewCCExplicit) {
3729 RequiresAdjustment =
true;
3741 RequiresAdjustment =
true;
3748 << (!FirstCCExplicit ?
"" :
3752 Diag(
First->getLocation(), diag::note_previous_declaration);
3760 RequiresAdjustment =
true;
3770 Diag(OldLocation, diag::note_previous_declaration);
3775 RequiresAdjustment =
true;
3782 <<
"'ns_returns_retained'";
3783 Diag(OldLocation, diag::note_previous_declaration);
3788 RequiresAdjustment =
true;
3794 AnyX86NoCallerSavedRegistersAttr *
Attr =
3795 New->
getAttr<AnyX86NoCallerSavedRegistersAttr>();
3797 Diag(OldLocation, diag::note_previous_declaration);
3802 RequiresAdjustment =
true;
3805 if (RequiresAdjustment) {
3815 !New->
hasAttr<GNUInlineAttr>() &&
3824 if (New->
hasAttr<GNUInlineAttr>() &&
3835 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3839 QualType OldQTypeForComparison = OldQType;
3843 if (OldFX != NewFX) {
3845 for (
const auto &Diff : Diffs) {
3846 if (Diff.shouldDiagnoseRedeclaration(*Old, OldFX, *New, NewFX)) {
3848 diag::warn_mismatched_func_effect_redeclaration)
3849 << Diff.effectName();
3860 if (!MergeErrs.empty())
3867 NewFPT->getParamTypes(), EPI);
3875 EPI = OldFPT->getExtProtoInfo();
3878 OldFPT->getReturnType(), OldFPT->getParamTypes(), EPI);
3880 if (OldFX.empty()) {
3902 OldDeclaredReturnType)) {
3910 Diag(New->
getLocation(), diag::err_member_def_does_not_match_ret_type)
3913 !Old->
hasAttr<OverloadableAttr>() &&
3914 !New->
hasAttr<OverloadableAttr>())
3919 Diag(OldLocation, PrevDiag) << Old << Old->
getType()
3928 QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
3929 if (OldReturnType != NewReturnType) {
3945 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
3947 if (OldMethod && NewMethod) {
3954 bool IsClassScopeExplicitSpecialization =
3960 !IsClassScopeExplicitSpecialization) {
3966 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3976 if (isa<CXXConstructorDecl>(OldMethod))
3977 NewDiag = diag::err_constructor_redeclared;
3978 else if (isa<CXXDestructorDecl>(NewMethod))
3979 NewDiag = diag::err_destructor_redeclared;
3980 else if (isa<CXXConversionDecl>(NewMethod))
3981 NewDiag = diag::err_conv_function_redeclared;
3983 NewDiag = diag::err_member_redeclared;
3987 Diag(New->
getLocation(), diag::err_member_redeclared_in_instantiation)
3990 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4003 diag::err_definition_of_implicitly_declared_member)
4009 diag::err_definition_of_explicitly_defaulted_member)
4032 if (
const auto *NRA = New->
getAttr<CXX11NoReturnAttr>())
4033 if (!Old->
hasAttr<CXX11NoReturnAttr>()) {
4034 Diag(NRA->getLocation(), diag::err_attribute_missing_on_first_decl)
4043 const CarriesDependencyAttr *CDA = New->
getAttr<CarriesDependencyAttr>();
4044 if (CDA && !Old->
hasAttr<CarriesDependencyAttr>()) {
4045 Diag(CDA->getLocation(),
4046 diag::err_carries_dependency_missing_on_first_decl) << 0;
4048 diag::note_carries_dependency_missing_first_decl) << 0;
4061 OldQTypeForComparison =
QualType(OldTypeForComparison, 0);
4076 Diag(OldLocation, PrevDiag);
4078 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4079 Diag(OldLocation, PrevDiag);
4086 if (
HLSL().CheckCompatibleParameterABI(New, Old))
4166 bool IsWithoutProtoADef =
false, IsWithProtoADef =
false;
4167 if (WithoutProto == New)
4168 IsWithoutProtoADef = NewDeclIsDefn;
4170 IsWithProtoADef = NewDeclIsDefn;
4172 diag::warn_non_prototype_changes_behavior)
4173 << IsWithoutProtoADef << (WithoutProto->
getNumParams() ? 0 : 1)
4174 << (WithoutProto == Old) << IsWithProtoADef;
4184 !IsWithoutProtoADef)
4194 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
4195 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
4198 assert(!OldProto->hasExceptionSpec() &&
"Exception spec in C");
4200 OldProto->getParamTypes(),
4201 OldProto->getExtProtoInfo());
4207 for (
const auto &ParamType : OldProto->param_types()) {
4210 ParamType,
nullptr,
SC_None,
nullptr);
4213 Params.push_back(Param);
4216 New->setParams(Params);
4252 NewProto->getReturnType());
4253 bool LooseCompatible = !MergedReturn.
isNull();
4255 LooseCompatible && Idx != End; ++Idx) {
4259 NewProto->getParamType(Idx))) {
4260 ArgTypes.push_back(NewParm->
getType());
4264 GNUCompatibleParamWarning Warn = { OldParm, NewParm,
4265 NewProto->getParamType(Idx) };
4266 Warnings.push_back(Warn);
4267 ArgTypes.push_back(NewParm->
getType());
4269 LooseCompatible =
false;
4272 if (LooseCompatible) {
4273 for (
unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
4274 Diag(Warnings[Warn].NewParm->getLocation(),
4275 diag::ext_param_promoted_not_compatible_with_prototype)
4276 << Warnings[Warn].PromotedType
4277 << Warnings[Warn].OldParm->getType();
4278 if (Warnings[Warn].OldParm->getLocation().isValid())
4279 Diag(Warnings[Warn].OldParm->getLocation(),
4280 diag::note_previous_declaration);
4283 if (MergeTypeWithOld)
4303 Diag(OldLocation, diag::note_previous_builtin_declaration)
4308 PrevDiag = diag::note_previous_builtin_declaration;
4312 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4317 Scope *S,
bool MergeTypeWithOld) {
4332 for (
unsigned i = 0, e = New->
getNumParams(); i != e; ++i) {
4346 if (!Merged.isNull() && MergeTypeWithOld)
4369 ni != ne && oi != oe; ++ni, ++oi)
4379 ? diag::err_redefinition_different_type
4380 : diag::err_redeclaration_different_type)
4385 std::tie(PrevDiag, OldLocation)
4387 S.
Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4392 bool MergeTypeWithOld) {
4420 QualType PrevVDTy = PrevVD->getType();
4474 if (MergeTypeWithOld)
4512 if (!shouldLinkPossiblyHiddenDecl(
Previous, New))
4522 OldTemplate = dyn_cast<VarTemplateDecl>(
Previous.getFoundDecl());
4526 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4527 if (checkUsingShadowRedecl<VarTemplateDecl>(*
this, Shadow, NewTemplate))
4530 Old = dyn_cast<VarDecl>(
Previous.getFoundDecl());
4533 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4534 if (checkUsingShadowRedecl<VarDecl>(*
this, Shadow, New))
4571 if (New->
hasAttr<WeakImportAttr>())
4582 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
4583 if (!Old->
hasAttr<InternalLinkageAttr>()) {
4587 New->
dropAttr<InternalLinkageAttr>();
4592 if (MostRecent != Old) {
4605 std::tie(PrevDiag, OldLocation) =
4615 Diag(OldLocation, PrevDiag);
4619 Diag(OldLocation, PrevDiag);
4638 Diag(OldLocation, PrevDiag);
4646 Diag(OldLocation, PrevDiag);
4652 Diag(OldLocation, PrevDiag);
4668 Diag(OldLocation, PrevDiag);
4678 Diag(Def->getLocation(), diag::note_previous_definition);
4692 Diag(OldLocation, PrevDiag);
4695 Diag(OldLocation, PrevDiag);
4703 Diag(OldLocation, PrevDiag);
4713 diag::warn_deprecated_redundant_constexpr_static_def);
4722 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4723 Diag(OldLocation, PrevDiag);
4753 StringRef HdrFilename =
4756 auto noteFromModuleOrInclude = [&](
Module *Mod,
4762 if (IncLoc.isValid()) {
4764 Diag(IncLoc, diag::note_redefinition_modules_same_file)
4770 Diag(IncLoc, diag::note_redefinition_include_same_file)
4771 << HdrFilename.str();
4781 if (FNew == FOld && FNewDecLoc.second == FOldDecLoc.second) {
4789 if (FOld && !HSI.isFileMultipleIncludeGuarded(*FOld))
4804 isa<VarTemplateSpecializationDecl>(New) ||
4840 ? S->getMSCurManglingNumber()
4841 : S->getMSLastManglingNumber();
4848 if (isa<CXXRecordDecl>(Tag->getParent())) {
4851 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl())
4863 Decl *ManglingContextDecl;
4864 std::tie(MCtx, ManglingContextDecl) =
4874struct NonCLikeKind {
4894 return {NonCLikeKind::Invalid, {}};
4901 return {NonCLikeKind::BaseClass,
4913 if (
auto *FD = dyn_cast<FieldDecl>(
D)) {
4914 if (FD->hasInClassInitializer()) {
4915 auto *
Init = FD->getInClassInitializer();
4916 return {NonCLikeKind::DefaultMemberInit,
4924 if (isa<FriendDecl>(
D))
4929 if (isa<StaticAssertDecl>(
D) || isa<IndirectFieldDecl>(
D) ||
4932 auto *MemberRD = dyn_cast<CXXRecordDecl>(
D);
4940 if (MemberRD->isLambda())
4941 return {NonCLikeKind::Lambda, MemberRD->getSourceRange()};
4945 if (MemberRD->isThisDeclarationADefinition()) {
4951 return {
Invalid ? NonCLikeKind::Invalid : NonCLikeKind::None, {}};
4981 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TagFromDeclSpec);
4985 if (NonCLike || ChangesLinkage) {
4986 if (NonCLike.Kind == NonCLikeKind::Invalid)
4989 unsigned DiagID = diag::ext_non_c_like_anon_struct_in_typedef;
4990 if (ChangesLinkage) {
4992 if (NonCLike.Kind == NonCLikeKind::None)
4993 DiagID = diag::err_typedef_changes_linkage;
4995 DiagID = diag::err_non_c_like_anon_struct_in_typedef;
5001 TextToInsert +=
' ';
5004 Diag(FixitLoc, DiagID)
5005 << isa<TypeAliasDecl>(NewTD)
5007 if (NonCLike.Kind != NonCLikeKind::None) {
5008 Diag(NonCLike.Range.getBegin(), diag::note_non_c_like_anon_struct)
5009 << NonCLike.Kind - 1 << NonCLike.Range;
5012 << NewTD << isa<TypeAliasDecl>(NewTD);
5037 if (
const auto *ED = dyn_cast<EnumDecl>(DS.
getRepAsDecl())) {
5038 if (ED->isScopedUsingClassTag())
5045 llvm_unreachable(
"unexpected type specifier");
5053 bool IsExplicitInstantiation,
5056 Decl *TagD =
nullptr;
5071 if (isa<TagDecl>(TagD))
5072 Tag = cast<TagDecl>(TagD);
5074 Tag = CTD->getTemplatedDecl();
5079 Tag->setFreeStanding();
5080 if (Tag->isInvalidDecl())
5089 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
5126 "Friend ellipsis but not friend-specified?");
5129 bool DeclaresAnything =
true;
5133 if (!
Record->getDeclName() &&
Record->isCompleteDefinition() &&
5136 Record->getDeclContext()->isRecord()) {
5150 DeclaresAnything =
false;
5169 if ((Tag && Tag->getDeclName()) ||
5173 Record = dyn_cast<RecordDecl>(Tag);
5186 DeclaresAnything =
false;
5198 if (
Enum->enumerator_begin() ==
Enum->enumerator_end() &&
5199 !
Enum->getIdentifier() && !
Enum->isInvalidDecl())
5200 DeclaresAnything =
false;
5208 DeclaresAnything =
false;
5212 Tag && Tag->getDeclContext()->isFunctionOrMethod())
5214 << llvm::to_underlying(Tag->getTagKind())
5227 if (!DeclaresAnything) {
5230 Diag(DS.
getBeginLoc(), (IsExplicitInstantiation || !TemplateParams.empty())
5231 ? diag::err_no_declarators
5232 : diag::ext_no_declarators)
5245 unsigned DiagID = diag::warn_standalone_specifier;
5247 DiagID = diag::ext_standalone_specifier;
5288 auto EmitAttributeDiagnostic = [
this, &DS](
const ParsedAttr &AL) {
5289 unsigned DiagnosticId = diag::warn_declspec_attribute_ignored;
5291 DiagnosticId = diag::warn_attribute_ignored;
5292 else if (AL.isRegularKeywordAttribute())
5293 DiagnosticId = diag::err_declspec_keyword_has_no_effect;
5295 DiagnosticId = diag::warn_declspec_attribute_ignored;
5296 Diag(AL.getLoc(), DiagnosticId)
5300 llvm::for_each(DS.
getAttributes(), EmitAttributeDiagnostic);
5301 llvm::for_each(DeclAttrs, EmitAttributeDiagnostic);
5320 RedeclarationKind::ForVisibleRedeclaration);
5325 assert(PrevDecl &&
"Expected a non-null Decl");
5338 SemaRef.
Diag(NameLoc, diag::err_anonymous_record_member_redecl)
5340 SemaRef.
Diag(PrevDecl->
getLocation(), diag::note_previous_declaration);
5346 if (
auto *RD = dyn_cast_if_present<RecordDecl>(
D))
5356 if (
Record->isAnonymousStructOrUnion())
5361 const NamedDecl *ND = dyn_cast<NamedDecl>(
D);
5395 for (
auto *
D : AnonRecord->
decls()) {
5396 if ((isa<FieldDecl>(
D) || isa<IndirectFieldDecl>(
D)) &&
5397 cast<NamedDecl>(
D)->getDeclName()) {
5413 unsigned OldChainingSize = Chaining.size();
5415 Chaining.append(IF->chain_begin(), IF->chain_end());
5417 Chaining.push_back(VD);
5419 assert(Chaining.size() >= 2);
5422 for (
unsigned i = 0; i < Chaining.size(); i++)
5423 NamedChain[i] = Chaining[i];
5427 VD->
getType(), {NamedChain, Chaining.size()});
5439 Chaining.resize(OldChainingSize);
5454 "Parser allowed 'typedef' as storage class VarDecl.");
5455 switch (StorageClassSpec) {
5469 llvm_unreachable(
"unknown storage class specifier");
5473 assert(
Record->hasInClassInitializer());
5475 for (
const auto *I :
Record->decls()) {
5476 const auto *FD = dyn_cast<FieldDecl>(I);
5477 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
5478 FD = IFD->getAnonField();
5479 if (FD && FD->hasInClassInitializer())
5480 return FD->getLocation();
5483 llvm_unreachable(
"couldn't find in-class initializer");
5488 if (!
Parent->isUnion() || !
Parent->hasInClassInitializer())
5491 S.
Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
5497 if (!
Parent->isUnion() || !
Parent->hasInClassInitializer())
5511 Diag(
Record->getLocation(), diag::ext_anonymous_union);
5513 Diag(
Record->getLocation(), diag::ext_gnu_anonymous_struct);
5515 Diag(
Record->getLocation(), diag::ext_c11_anonymous_struct);
5521 const char *PrevSpec =
nullptr;
5532 !cast<NamespaceDecl>(OwnerScope)->isAnonymousNamespace()))) {
5533 Diag(
Record->getLocation(), diag::err_anonymous_union_not_static)
5538 PrevSpec, DiagID, Policy);
5544 isa<RecordDecl>(Owner)) {
5546 diag::err_anonymous_union_with_storage_spec)
5560 <<
Record->isUnion() <<
"const"
5564 diag::ext_anonymous_struct_union_qualified)
5565 <<
Record->isUnion() <<
"volatile"
5569 diag::ext_anonymous_struct_union_qualified)
5570 <<
Record->isUnion() <<
"restrict"
5574 diag::ext_anonymous_struct_union_qualified)
5575 <<
Record->isUnion() <<
"_Atomic"
5579 diag::ext_anonymous_struct_union_qualified)
5580 <<
Record->isUnion() <<
"__unaligned"
5590 for (
auto *Mem :
Record->decls()) {
5592 if (Mem->isInvalidDecl())
5595 if (
auto *FD = dyn_cast<FieldDecl>(Mem)) {
5599 assert(FD->getAccess() !=
AS_none);
5601 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
5613 }
else if (Mem->isImplicit()) {
5615 }
else if (isa<TagDecl>(Mem) && Mem->getDeclContext() !=
Record) {
5620 }
else if (
auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
5621 if (!MemRecord->isAnonymousStructOrUnion() &&
5622 MemRecord->getDeclName()) {
5625 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
5629 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
5637 Diag(MemRecord->getLocation(),
5638 diag::ext_anonymous_record_with_anonymous_type)
5641 }
else if (isa<AccessSpecDecl>(Mem)) {
5643 }
else if (isa<StaticAssertDecl>(Mem)) {
5648 unsigned DK = diag::err_anonymous_record_bad_member;
5649 if (isa<TypeDecl>(Mem))
5650 DK = diag::err_anonymous_record_with_type;
5651 else if (isa<FunctionDecl>(Mem))
5652 DK = diag::err_anonymous_record_with_function;
5653 else if (isa<VarDecl>(Mem))
5654 DK = diag::err_anonymous_record_with_static;
5658 DK == diag::err_anonymous_record_with_type)
5659 Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
5662 Diag(Mem->getLocation(), DK) <<
Record->isUnion();
5671 if (cast<CXXRecordDecl>(
Record)->hasInClassInitializer() &&
5674 cast<CXXRecordDecl>(
Record));
5678 Diag(
Record->getLocation(), diag::err_anonymous_struct_not_member)
5699 assert(TInfo &&
"couldn't build declarator info for anonymous struct/union");
5703 if (
RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
5719 Diag(
Record->getLocation(), diag::err_mutable_nonmember);
5725 Record->getLocation(),
nullptr,
5741 Record->setAnonymousStructOrUnion(
true);
5752 Chain.push_back(Anon);
5758 if (
VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
5761 Decl *ManglingContextDecl;
5762 std::tie(MCtx, ManglingContextDecl) =
5781 assert(
Record &&
"expected a record!");
5786 assert(TInfo &&
"couldn't build declarator info for anonymous struct");
5788 auto *ParentDecl = cast<RecordDecl>(
CurContext);
5794 nullptr, RecTy, TInfo,
5806 Chain.push_back(Anon);
5810 diag::err_field_incomplete_or_sizeless) ||
5815 ParentDecl->setInvalidDecl();
5828 NameInfo.
setLoc(Name.StartLocation);
5830 switch (Name.getKind()) {
5834 NameInfo.
setName(Name.Identifier);
5850 if (!Template || !isa<ClassTemplateDecl>(Template)) {
5851 Diag(Name.StartLocation,
5852 diag::err_deduction_guide_name_not_class_template)
5866 Name.OperatorFunctionId.Operator));
5868 Name.OperatorFunctionId.SymbolLocations[0], Name.EndLocation));
5904 if (!CurClass || CurClass->
getIdentifier() != Name.TemplateId->Name)
5940 llvm_unreachable(
"Unknown name kind");
5968 for (
unsigned Idx = 0; Idx <
Declaration->param_size(); ++Idx) {
5982 (DeclTyName && DeclTyName == DefTyName))
5983 Params.push_back(Idx);
6010#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case DeclSpec::TST_##Trait:
6011#include "clang/Basic/TransformTypeTraits.def"
6026 if (!TSI)
return true;
6039 if (
Result.isInvalid())
return true;
6050 for (
unsigned I = 0,
E =
D.getNumTypeObjects(); I !=
E; ++I) {
6084 << D << static_cast<int>(Status);
6095 if (
OpenMP().getOMPTraitInfoForSurroundingScope()->isExtensionActive(
6096 llvm::omp::TraitProperty::
6097 implementation_extension_bind_to_declaration))
6122 Diag(NameInfo.
getLoc(), diag::err_member_name_of_class) << Name;
6133 bool IsMemberSpecialization) {
6134 assert(SS.
isValid() &&
"diagnoseQualifiedDeclaration called for declaration "
6135 "without nested-name-specifier");
6137 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
6151 Diag(
Loc,
LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
6152 : diag::err_member_extra_qualification)
6156 Diag(
Loc, diag::warn_namespace_member_extra_qualification) << Name;
6164 if (!Cur->
Encloses(DC) && !(TemplateId || IsMemberSpecialization)) {
6166 Diag(
Loc, diag::err_member_qualification)
6168 else if (isa<TranslationUnitDecl>(DC))
6169 Diag(
Loc, diag::err_invalid_declarator_global_scope)
6171 else if (isa<FunctionDecl>(Cur))
6172 Diag(
Loc, diag::err_invalid_declarator_in_function)
6174 else if (isa<BlockDecl>(Cur))
6175 Diag(
Loc, diag::err_invalid_declarator_in_block)
6177 else if (isa<ExportDecl>(Cur)) {
6178 if (!isa<NamespaceDecl>(DC))
6179 Diag(
Loc, diag::err_export_non_namespace_scope_name)
6186 Diag(
Loc, diag::err_invalid_declarator_scope)
6187 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.
getRange();
6194 Diag(
Loc, diag::err_member_qualification)
6220 Diag(
Loc, diag::ext_template_after_declarative_nns)
6227 Diag(
Loc, diag::ext_template_after_declarative_nns)
6238 if (TST->isDependentType() && TST->isTypeAlias())
6239 Diag(
Loc, diag::ext_alias_template_in_declarative_nns)
6248 Diag(
Loc, diag::err_computed_type_in_declarative_nns)
6252 }
while ((SpecLoc = SpecLoc.
getPrefix()));
6265 if (
D.isDecompositionDeclarator()) {
6268 if (!
D.isInvalidType())
6276 if (
D.getCXXScopeSpec().isInvalid())
6278 else if (
D.getCXXScopeSpec().isSet()) {
6283 bool EnteringContext = !
D.getDeclSpec().isFriendSpecified();
6285 if (!DC || isa<EnumDecl>(DC)) {
6290 Diag(
D.getIdentifierLoc(),
6291 diag::err_template_qualified_declarator_no_match)
6292 <<
D.getCXXScopeSpec().getScopeRep()
6293 <<
D.getCXXScopeSpec().getRange();
6298 if (!IsDependentContext &&
6303 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->
hasDefinition()) {
6304 Diag(
D.getIdentifierLoc(),
6305 diag::err_member_def_undefined_record)
6306 << Name << DC <<
D.getCXXScopeSpec().getRange();
6309 if (!
D.getDeclSpec().isFriendSpecified()) {
6312 ?
D.getName().TemplateId
6315 D.getIdentifierLoc(), TemplateId,
6326 if (EnteringContext && IsDependentContext &&
6327 TemplateParamLists.size() != 0) {
6345 if (!
D.getCXXScopeSpec().isSet()) {
6346 bool IsLinkageLookup =
false;
6347 bool CreateBuiltins =
false;
6361 IsLinkageLookup =
true;
6366 CreateBuiltins =
true;
6368 if (IsLinkageLookup) {
6371 RedeclarationKind::ForExternalRedeclaration);
6409 if (!
D.isInvalidType()) {
6410 bool AllowForCompatibility =
false;
6411 if (
Scope *DeclParent = S->getDeclParent();
6412 Scope *TemplateParamParent = S->getTemplateParamParent()) {
6413 AllowForCompatibility = DeclParent->Contains(*TemplateParamParent) &&
6414 TemplateParamParent->isDeclScope(TPD);
6417 AllowForCompatibility);
6443 S = S->getDeclParent();
6447 bool AddToScope =
true;
6449 if (TemplateParamLists.size()) {
6450 Diag(
D.getIdentifierLoc(), diag::err_template_typedef);
6472 if (
OpenMP().isInOpenMPDeclareTargetContext())
6483 bool &SizeIsNegative,
6484 llvm::APSInt &Oversized) {
6489 SizeIsNegative =
false;
6498 if (
const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
6503 if (FixedType.
isNull())
return FixedType;
6505 return Qs.
apply(Context, FixedType);
6507 if (
const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
6508 QualType Inner = PTy->getInnerType();
6512 if (FixedType.
isNull())
return FixedType;
6514 return Qs.
apply(Context, FixedType);
6524 SizeIsNegative, Oversized);
6534 llvm::APSInt Res =
Result.Val.getInt();
6537 if (Res.isSigned() && Res.isNegative()) {
6538 SizeIsNegative =
true;
6543 unsigned ActiveSizeBits =
6547 : Res.getActiveBits();
6555 return Qs.
apply(Context, FoldedArrayType);
6580 TypeLoc DstElemTL = DstATL.getElementLoc();
6599 bool &SizeIsNegative,
6600 llvm::APSInt &Oversized) {
6603 SizeIsNegative, Oversized);
6614 unsigned FailedFoldDiagID) {
6615 bool SizeIsNegative;
6616 llvm::APSInt Oversized;
6618 TInfo,
Context, SizeIsNegative, Oversized);
6620 Diag(
Loc, diag::ext_vla_folded_to_constant);
6627 Diag(
Loc, diag::err_typecheck_negative_array_size);
6628 else if (Oversized.getBoolValue())
6630 else if (FailedFoldDiagID)
6657 diag::err_virtual_non_function);
6661 diag::err_explicit_non_function);
6665 diag::err_noreturn_non_function);
6672 if (
D.getCXXScopeSpec().isSet()) {
6673 Diag(
D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
6674 <<
D.getCXXScopeSpec().getRange();
6683 if (
D.getDeclSpec().isInlineSpecified())
6684 Diag(
D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
6686 if (
D.getDeclSpec().hasConstexprSpecifier())
6687 Diag(
D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
6688 << 1 <<
static_cast<int>(
D.getDeclSpec().getConstexprSpecifier());
6692 Diag(
D.getName().StartLocation,
6693 diag::err_deduction_guide_invalid_specifier)
6696 Diag(
D.getName().StartLocation, diag::err_typedef_not_identifier)
6702 if (!NewTD)
return nullptr;
6709 bool Redeclaration =
D.isRedeclaration();
6711 D.setRedeclaration(Redeclaration);
6726 if (S->getFnParent() ==
nullptr) {
6727 bool SizeIsNegative;
6728 llvm::APSInt Oversized;
6741 else if (Oversized.getBoolValue())
6765 Redeclaration =
true;
6771 if (ShadowedDecl && !Redeclaration)
6778 switch (II->getNotableIdentifierID()) {
6779 case tok::NotableIdentifierKind::FILE:
6782 case tok::NotableIdentifierKind::jmp_buf:
6785 case tok::NotableIdentifierKind::sigjmp_buf:
6788 case tok::NotableIdentifierKind::ucontext_t:
6791 case tok::NotableIdentifierKind::float_t:
6792 case tok::NotableIdentifierKind::double_t:
6793 NewTD->
addAttr(AvailableOnlyInDefaultEvalMethodAttr::Create(
Context));
6854 if (!OuterContext->
Equals(PrevOuterContext))
6863 if (!SS.
isSet())
return;
6868 if (
Decl->getType().hasAddressSpace())
6870 if (
Decl->getType()->isDependentType())
6882 Var->hasGlobalStorage())
6886 if (
auto DT = dyn_cast<DecayedType>(
Type)) {
6887 auto OrigTy = DT->getOriginalType();
6888 if (!OrigTy.hasAddressSpace() && OrigTy->isArrayType()) {
6919 if (WeakRefAttr *
Attr = ND.
getAttr<WeakRefAttr>()) {
6928 if (
auto *VD = dyn_cast<VarDecl>(&ND)) {
6929 if (VD->hasInit()) {
6930 if (
const auto *
Attr = VD->getAttr<AliasAttr>()) {
6931 assert(VD->isThisDeclarationADefinition() &&
6932 !VD->isExternallyVisible() &&
"Broken AliasAttr handled late!");
6934 VD->dropAttr<AliasAttr>();
6943 if (SelectAnyAttr *
Attr = ND.
getAttr<SelectAnyAttr>()) {
6946 diag::err_attribute_selectany_non_extern_data);
6953 if (HybridPatchableAttr *
Attr = ND.
getAttr<HybridPatchableAttr>()) {
6956 diag::warn_attribute_hybrid_patchable_non_extern);
6962 auto *VD = dyn_cast<VarDecl>(&ND);
6963 bool IsAnonymousNS =
false;
6966 const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(VD->getDeclContext());
6967 while (NS && !IsAnonymousNS) {
6969 NS = dyn_cast<NamespaceDecl>(NS->
getParent());
6976 bool AnonNSInMicrosoftMode = IsAnonymousNS && IsMicrosoft;
6978 (!AnonNSInMicrosoftMode &&
6989 if (
const auto *FD = dyn_cast<FunctionDecl>(&ND)) {
6990 FD = FD->getMostRecentDecl();
6995 for (
TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc();
7001 if (
const auto *A = ATL.
getAttrAs<LifetimeBoundAttr>()) {
7002 const auto *MD = dyn_cast<CXXMethodDecl>(FD);
7003 int NoImplicitObjectError = -1;
7005 NoImplicitObjectError = 0;
7006 else if (MD->isStatic())
7007 NoImplicitObjectError = 1;
7008 else if (MD->isExplicitObjectMemberFunction())
7009 NoImplicitObjectError = 2;
7010 if (NoImplicitObjectError != -1) {
7011 S.
Diag(A->getLocation(), diag::err_lifetimebound_no_object_param)
7012 << NoImplicitObjectError << A->getRange();
7013 }
else if (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)) {
7014 S.
Diag(A->getLocation(), diag::err_lifetimebound_ctor_dtor)
7015 << isa<CXXDestructorDecl>(MD) << A->getRange();
7016 }
else if (MD->getReturnType()->isVoidType()) {
7020 err_lifetimebound_implicit_object_parameter_void_return_type);
7025 for (
unsigned int I = 0; I < FD->getNumParams(); ++I) {
7030 if (
auto *A =
P->getAttr<LifetimeBoundAttr>()) {
7031 if (!isa<CXXConstructorDecl>(FD) && FD->getReturnType()->isVoidType()) {
7032 S.
Diag(A->getLocation(),
7033 diag::err_lifetimebound_parameter_void_return_type);
7056 bool IsSpecialization,
7057 bool IsDefinition) {
7061 bool IsTemplate =
false;
7062 if (
TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl)) {
7063 OldDecl = OldTD->getTemplatedDecl();
7065 if (!IsSpecialization)
7066 IsDefinition =
false;
7068 if (
TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl)) {
7069 NewDecl = NewTD->getTemplatedDecl();
7073 if (!OldDecl || !NewDecl)
7076 const DLLImportAttr *OldImportAttr = OldDecl->
getAttr<DLLImportAttr>();
7077 const DLLExportAttr *OldExportAttr = OldDecl->
getAttr<DLLExportAttr>();
7078 const DLLImportAttr *NewImportAttr = NewDecl->
getAttr<DLLImportAttr>();
7079 const DLLExportAttr *NewExportAttr = NewDecl->
getAttr<DLLExportAttr>();
7083 bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
7084 (NewExportAttr && !NewExportAttr->isInherited());
7090 bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
7092 if (AddsAttr && !IsSpecialization && !OldDecl->
isImplicit()) {
7094 bool JustWarn =
false;
7096 auto *VD = dyn_cast<VarDecl>(OldDecl);
7097 if (VD && !VD->getDescribedVarTemplate())
7099 auto *FD = dyn_cast<FunctionDecl>(OldDecl);
7108 if (!isa<FunctionDecl>(OldDecl) || !NewImportAttr)
7111 unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
7112 : diag::err_attribute_dll_redeclaration;
7115 << (NewImportAttr ? (
const Attr *)NewImportAttr : NewExportAttr);
7128 bool IsInline =
false, IsStaticDataMember =
false, IsQualifiedFriend =
false;
7130 if (
const auto *VD = dyn_cast<VarDecl>(NewDecl)) {
7133 IsStaticDataMember = VD->isStaticDataMember();
7134 IsDefinition = VD->isThisDeclarationADefinition(S.
Context) !=
7136 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
7137 IsInline = FD->isInlined();
7138 IsQualifiedFriend = FD->getQualifier() &&
7142 if (OldImportAttr && !HasNewAttr &&
7143 (!IsInline || (IsMicrosoftABI && IsTemplate)) && !IsStaticDataMember &&
7145 if (IsMicrosoftABI && IsDefinition) {
7146 if (IsSpecialization) {
7149 diag::err_attribute_dllimport_function_specialization_definition);
7150 S.
Diag(OldImportAttr->getLocation(), diag::note_attribute);
7151 NewDecl->
dropAttr<DLLImportAttr>();
7154 diag::warn_redeclaration_without_import_attribute)
7157 NewDecl->
dropAttr<DLLImportAttr>();
7158 NewDecl->
addAttr(DLLExportAttr::CreateImplicit(
7159 S.
Context, NewImportAttr->getRange()));
7161 }
else if (IsMicrosoftABI && IsSpecialization) {
7162 assert(!IsDefinition);
7166 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
7167 << NewDecl << OldImportAttr;
7169 S.
Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
7170 OldDecl->
dropAttr<DLLImportAttr>();
7171 NewDecl->
dropAttr<DLLImportAttr>();
7173 }
else if (IsInline && OldImportAttr && !IsMicrosoftABI) {
7176 OldDecl->
dropAttr<DLLImportAttr>();
7177 NewDecl->
dropAttr<DLLImportAttr>();
7179 diag::warn_dllimport_dropped_from_inline_function)
7180 << NewDecl << OldImportAttr;
7187 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDecl)) {
7189 !NewImportAttr && !NewExportAttr) {
7190 if (
const DLLExportAttr *ParentExportAttr =
7191 MD->getParent()->getAttr<DLLExportAttr>()) {
7192 DLLExportAttr *NewAttr = ParentExportAttr->clone(S.
Context);
7193 NewAttr->setInherited(
true);
7237 if (!
D->isInExternCContext() ||
D->template hasAttr<OverloadableAttr>())
7241 if (S.
getLangOpts().CUDA && (
D->template hasAttr<CUDADeviceAttr>() ||
7242 D->template hasAttr<CUDAHostAttr>()))
7245 return D->isExternC();
7251 isa<OMPDeclareMapperDecl>(DC))
7260 if (isa<RequiresExprBodyDecl>(DC))
7262 llvm_unreachable(
"Unexpected context");
7268 isa<OMPDeclareReductionDecl>(DC) || isa<OMPDeclareMapperDecl>(DC))
7272 llvm_unreachable(
"Unexpected context");
7317 if (
const auto *FD = dyn_cast<FunctionDecl>(
D))
7318 return FD->isExternC();
7319 if (
const auto *VD = dyn_cast<VarDecl>(
D))
7320 return VD->isExternC();
7322 llvm_unreachable(
"Unknown type of decl!");
7335 diag::err_opencl_type_can_only_be_used_as_function_parameter)
7349 diag::err_invalid_type_for_program_scope_var)
7378 Se.
Diag(NewVD->
getLocation(), diag::err_opencl_half_declaration) << R;
7411 Se.
Diag(NewVD->
getLocation(), diag::err_opencl_nonconst_global_sampler);
7421template <
typename AttrTy>
7424 if (
const auto *Attribute = TND->
getAttr<AttrTy>()) {
7425 AttrTy *Clone = Attribute->clone(S.
Context);
7426 Clone->setInherited(
true);
7454 if (
const auto *ConstDecl = RD->
getAttr<ReadOnlyPlacementAttr>()) {
7456 S.
Diag(ConstDecl->getLocation(), diag::note_enforce_read_only_placement);
7463 return Name.getAsIdentifierInfo() &&
7464 Name.getAsIdentifierInfo()->isStr(
"main") &&
7478 bool IsPlaceholderVariable =
false;
7480 if (
D.isDecompositionDeclarator()) {
7483 auto &Decomp =
D.getDecompositionDeclarator();
7484 if (!Decomp.bindings().empty()) {
7485 II = Decomp.bindings()[0].Name;
7489 Diag(
D.getIdentifierLoc(), diag::err_bad_variable_name) << Name;
7499 IsPlaceholderVariable =
true;
7517 bool IsLocalExternDecl = SC ==
SC_Extern &&
7523 Diag(
D.getIdentifierLoc(), diag::err_mutable_nonmember);
7530 D.getDeclSpec().getStorageClassSpecLoc())) {
7534 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
7536 : diag::warn_deprecated_register)
7542 if (!DC->
isRecord() && S->getFnParent() ==
nullptr) {
7547 Diag(
D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
7559 const AutoType *AT = TL.getTypePtr();
7563 bool IsMemberSpecialization =
false;
7564 bool IsVariableTemplateSpecialization =
false;
7566 bool IsVariableTemplate =
false;
7577 if (
D.isInvalidType())
7590 D.getCXXScopeSpec(),
7592 ?
D.getName().TemplateId
7595 false, IsMemberSpecialization,
Invalid);
7597 if (TemplateParams) {
7604 if (!TemplateParams->
size() &&
7609 diag::err_template_variable_noparams)
7613 TemplateParams =
nullptr;
7621 IsVariableTemplateSpecialization =
true;
7625 IsVariableTemplate =
true;
7628 Diag(
D.getIdentifierLoc(),
7630 ? diag::warn_cxx11_compat_variable_template
7631 : diag::ext_variable_template);
7636 if (!TemplateParamLists.empty() && IsMemberSpecialization &&
7641 "should have a 'template<>' for this decl");
7644 bool IsExplicitSpecialization =
7655 (IsExplicitSpecialization || IsMemberSpecialization)) {
7656 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
7657 diag::ext_explicit_specialization_storage_class)
7663 if (
const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
7669 if (Ctxt->isFunctionOrMethod()) {
7670 FunctionOrMethod = Ctxt;
7673 const CXXRecordDecl *ParentDecl = dyn_cast<CXXRecordDecl>(Ctxt);
7675 AnonStruct = ParentDecl;
7679 if (FunctionOrMethod) {
7682 Diag(
D.getIdentifierLoc(),
7683 diag::err_static_data_member_not_allowed_in_local_class)
7684 << Name << RD->getDeclName()
7685 << llvm::to_underlying(RD->getTagKind());
7686 }
else if (AnonStruct) {
7690 Diag(
D.getIdentifierLoc(),
7691 diag::err_static_data_member_not_allowed_in_anon_struct)
7692 << Name << llvm::to_underlying(AnonStruct->
getTagKind());
7694 }
else if (RD->isUnion()) {
7697 Diag(
D.getIdentifierLoc(),
7699 ? diag::warn_cxx98_compat_static_data_member_in_union
7700 : diag::ext_static_data_member_in_union)
7706 Diag(
D.getIdentifierLoc(), diag::err_template_member)
7717 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
7718 diag::err_static_out_of_line)
7720 D.getDeclSpec().getStorageClassSpecLoc());
7730 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
7731 diag::err_storage_class_for_static_member)
7733 D.getDeclSpec().getStorageClassSpecLoc());
7736 llvm_unreachable(
"C storage class in c++!");
7740 if (IsVariableTemplateSpecialization) {
7742 TemplateParamLists.size() > 0
7743 ? TemplateParamLists[0]->getTemplateLoc()
7746 S,
D, TInfo,
Previous, TemplateKWLoc, TemplateParams, SC,
7750 NewVD = cast<VarDecl>(Res.
get());
7752 }
else if (
D.isDecompositionDeclarator()) {
7754 D.getIdentifierLoc(), R, TInfo, SC,
7758 D.getIdentifierLoc(), II, R, TInfo, SC);
7761 if (IsVariableTemplate) {
7764 TemplateParams, NewVD);
7773 if (
D.isInvalidType() ||
Invalid) {
7785 unsigned VDTemplateParamLists =
7786 (TemplateParams && !IsExplicitSpecialization) ? 1 : 0;
7787 if (TemplateParamLists.size() > VDTemplateParamLists)
7789 Context, TemplateParamLists.drop_back(VDTemplateParamLists));
7792 if (
D.getDeclSpec().isInlineSpecified()) {
7794 Diag(
D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
7798 Diag(
D.getDeclSpec().getInlineSpecLoc(),
7799 diag::err_inline_declaration_block_scope) << Name
7802 Diag(
D.getDeclSpec().getInlineSpecLoc(),
7804 : diag::ext_inline_variable);
7815 if (IsLocalExternDecl) {
7816 if (
D.isDecompositionDeclarator())
7818 B->setLocalExternDecl();
7823 bool EmitTLSUnsupportedError =
false;
7824 if (
DeclSpec::TSCS TSCS =
D.getDeclSpec().getThreadStorageClassSpec()) {
7835 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
7836 diag::err_thread_non_global)
7844 EmitTLSUnsupportedError =
true;
7850 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
7851 diag::err_thread_unsupported);
7856 switch (
D.getDeclSpec().getConstexprSpecifier()) {
7861 Diag(
D.getDeclSpec().getConstexprSpecLoc(),
7862 diag::err_constexpr_wrong_decl_kind)
7863 <<
static_cast<int>(
D.getDeclSpec().getConstexprSpecifier());
7879 Diag(
D.getDeclSpec().getConstexprSpecLoc(),
7880 diag::err_constinit_local_variable);
7883 ConstInitAttr::Create(
Context,
D.getDeclSpec().getConstexprSpecLoc(),
7884 ConstInitAttr::Keyword_constinit));
7897 if (SC ==
SC_Static && S->getFnParent() !=
nullptr &&
7901 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
7902 diag::warn_static_local_in_extern_inline);
7907 if (
D.getDeclSpec().isModulePrivateSpecified()) {
7908 if (IsVariableTemplateSpecialization)
7912 D.getDeclSpec().getModulePrivateSpecLoc());
7913 else if (IsMemberSpecialization)
7920 <<
SourceRange(
D.getDeclSpec().getModulePrivateSpecLoc())
7922 D.getDeclSpec().getModulePrivateSpecLoc());
7928 B->setModulePrivate();
7937 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
7938 diag::err_opencl_unknown_type_specifier)
7948 if (
const auto *ATy = dyn_cast<ArrayType>(NewVD->
getType())) {
7949 if (ATy && ATy->getElementType().isWebAssemblyReferenceType() &&
7969 copyAttrFromTypedefToDecl<AllocSizeAttr>(*
this, NewVD, TT);
7973 if (EmitTLSUnsupportedError &&
7976 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(NewVD))))
7977 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
7978 diag::err_thread_unsupported);
7980 if (EmitTLSUnsupportedError &&
7983 targetDiag(
D.getIdentifierLoc(), diag::err_thread_unsupported);
7986 if (SC ==
SC_None && S->getFnParent() !=
nullptr &&
7987 (NewVD->
hasAttr<CUDASharedAttr>() ||
7988 NewVD->
hasAttr<CUDAConstantAttr>())) {
7996 assert(!NewVD->
hasAttr<DLLImportAttr>() ||
7997 NewVD->
getAttr<DLLImportAttr>()->isInherited() ||
8002 if (
getLangOpts().ObjCAutoRefCount &&
ObjC().inferObjCARCLifetime(NewVD))
8010 if (S->getFnParent() !=
nullptr) {
8031 bool HasSizeMismatch;
8033 if (!TI.isValidGCCRegisterName(
Label))
8035 else if (!TI.validateGlobalRegisterVariable(
Label,
8039 else if (HasSizeMismatch)
8045 diag::err_asm_unsupported_register_type)
8055 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
8068 NamedDecl *ShadowedDecl =
D.getCXXScopeSpec().isEmpty()
8076 D.getCXXScopeSpec().isNotEmpty() ||
8077 IsMemberSpecialization ||
8078 IsVariableTemplateSpecialization);
8092 if (IsMemberSpecialization && !IsVariableTemplate &&
8093 !IsVariableTemplateSpecialization && !NewVD->
isInvalidDecl() &&
8100 isa<FieldDecl>(
Previous.getFoundDecl()) &&
8101 D.getCXXScopeSpec().isSet()) {
8105 <<
D.getCXXScopeSpec().getRange();
8109 }
else if (
D.getCXXScopeSpec().isSet() &&
8110 !IsVariableTemplateSpecialization) {
8112 Diag(
D.getIdentifierLoc(), diag::err_no_member)
8114 <<
D.getCXXScopeSpec().getRange();
8118 if (!IsPlaceholderVariable)
8141 (
D.getCXXScopeSpec().isSet() && DC && DC->
isRecord() &&
8149 if (PrevVarTemplate &&
8156 if (!IsPlaceholderVariable && ShadowedDecl && !
D.isRedeclaration())
8169 Decl *ManglingContextDecl;
8170 std::tie(MCtx, ManglingContextDecl) =
8197 if (
D.isRedeclaration() && !
Previous.empty()) {
8200 D.isFunctionDefinition());
8232 if (isa<TypeAliasDecl>(ShadowedDecl))
8234 else if (isa<TypedefDecl>(ShadowedDecl))
8236 else if (isa<BindingDecl>(ShadowedDecl))
8238 else if (isa<RecordDecl>(OldDC))
8271 if (
D->hasGlobalStorage() && !
D->isStaticLocal())
8275 return isa<VarDecl, FieldDecl, BindingDecl>(ShadowedDecl) ? ShadowedDecl
8289 return isa<TypedefNameDecl>(ShadowedDecl) ? ShadowedDecl :
nullptr;
8298 return isa<VarDecl, FieldDecl, BindingDecl>(ShadowedDecl) ? ShadowedDecl
8306 if (
FieldDecl *FD = dyn_cast<FieldDecl>(ShadowedDecl)) {
8312 if (!MD->getParent()->isLambda() && MD->isExplicitObjectMemberFunction())
8317 if (isa<CXXConstructorDecl>(NewDC))
8318 if (
const auto PVD = dyn_cast<ParmVarDecl>(
D)) {
8321 ShadowingDecls.insert({PVD->getCanonicalDecl(), FD});
8326 if (
VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
8327 if (shadowedVar->isExternC()) {
8330 for (
auto *I : shadowedVar->redecls())
8331 if (I->isFileVarDecl()) {
8339 unsigned WarningDiag = diag::warn_decl_shadow;
8341 if (isa<VarDecl>(
D) && NewDC && isa<CXXMethodDecl>(NewDC)) {
8342 if (
const auto *RD = dyn_cast<CXXRecordDecl>(NewDC->
getParent())) {
8344 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl)) {
8346 if (RD->getLambdaCaptureDefault() ==
LCD_None) {
8352 WarningDiag = diag::warn_decl_shadow_uncaptured_local;
8358 ->ShadowingDecls.push_back({
D, VD});
8362 if (isa<FieldDecl>(ShadowedDecl)) {
8369 ->ShadowingDecls.push_back({
D, ShadowedDecl});
8373 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl);
8374 VD && VD->hasLocalStorage()) {
8378 ParentDC && !ParentDC->
Equals(OldDC);
8382 if (!isa<BlockDecl>(ParentDC) && !isa<CapturedDecl>(ParentDC) &&
8404 if (ReDC->
isRecord() && isa<EnumConstantDecl>(
D) && !OldDC->
Equals(ReDC))
8421 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
8428 const NamedDecl *ShadowedDecl = Shadow.ShadowedDecl;
8431 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl)) {
8433 Diag(Shadow.VD->getLocation(),
8434 CaptureLoc.
isInvalid() ? diag::warn_decl_shadow_uncaptured_local
8435 : diag::warn_decl_shadow)
8436 << Shadow.VD->getDeclName()
8439 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
8440 << Shadow.VD->getDeclName() << 0;
8442 }
else if (isa<FieldDecl>(ShadowedDecl)) {
8443 Diag(Shadow.VD->getLocation(),
8445 : diag::warn_decl_shadow_uncaptured_local)
8446 << Shadow.VD->getDeclName()
8459 RedeclarationKind::ForVisibleRedeclaration);
8472 auto *DRE = dyn_cast<DeclRefExpr>(
E);
8475 const NamedDecl *
D = cast<NamedDecl>(DRE->getDecl()->getCanonicalDecl());
8476 auto I = ShadowingDecls.find(
D);
8477 if (I == ShadowingDecls.end())
8479 const NamedDecl *ShadowedDecl = I->second;
8481 Diag(
Loc, diag::warn_modifying_shadowing_decl) <<
D << OldDC;
8486 ShadowingDecls.erase(I);
8494 assert(S.
getLangOpts().CPlusPlus &&
"only C++ has extern \"C\"");
8515 if (!isa<VarDecl>(ND))
8525 if (isa<VarDecl>(*I)) {
8535 if (isa<VarDecl>(*I)) {
8553 assert(Prev &&
"should have found a previous declaration to diagnose");
8555 Prev = FD->getFirstDecl();
8557 Prev = cast<VarDecl>(Prev)->getFirstDecl();
8559 S.
Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
8581 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
8593 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
8613 SemaRef.
Diag(VarLoc, diag::err_c23_constexpr_invalid_type) <<
T;
8623 SemaRef.
Diag(VarLoc, diag::err_c23_constexpr_invalid_type) <<
T;
8629 if (llvm::any_of(RD->
fields(), [&SemaRef, VarLoc](
const FieldDecl *F) {
8630 return CheckC23ConstexprVarType(SemaRef, VarLoc, F->getType());
8686 if (NewVD->
hasAttr<BlocksAttr>()) {
8694 if (!
T.isConstQualified()) {
8695 Diag(NewVD->
getLocation(), diag::err_opencl_invalid_block_declaration)
8701 Diag(NewVD->
getLocation(), diag::err_opencl_extern_block_declaration);
8717 Diag(NewVD->
getLocation(), diag::err_opencl_global_invalid_addr_space)
8718 <<
Scope <<
"global or constant";
8720 Diag(NewVD->
getLocation(), diag::err_opencl_global_invalid_addr_space)
8721 <<
Scope <<
"constant";
8737 if (FD && !FD->
hasAttr<OpenCLKernelAttr>()) {
8749 if (FD && FD->
hasAttr<OpenCLKernelAttr>()) {
8774 && !NewVD->
hasAttr<BlocksAttr>()) {
8796 const auto *ATy = dyn_cast<ConstantArrayType>(
T.getTypePtr());
8797 if (!ATy || ATy->getZExtSize() != 0) {
8799 diag::err_typecheck_wasm_table_must_have_zero_length);
8809 (FD->hasAttr<CUDADeviceAttr>() || FD->hasAttr<CUDAGlobalAttr>())) {
8819 if (isVM || NewVD->
hasAttr<CleanupAttr>() ||
8825 bool SizeIsNegative;
8826 llvm::APSInt Oversized;
8831 FixedT = FixedTInfo->
getType();
8832 else if (FixedTInfo) {
8895 if (isVM && NewVD->
hasAttr<BlocksAttr>()) {
8910 diag::err_constexpr_var_non_literal)) {
8926 llvm::StringMap<bool> CallerFeatureMap;
8937 diag::err_sve_vector_in_non_streaming_function)
8947 llvm::StringMap<bool> CallerFeatureMap;
8993 dyn_cast<CXXMethodDecl>(BaseND->getCanonicalDecl());
9000 if (Overridden.insert(BaseMD).second) {
9017 return !Overridden.empty();
9023 struct ActOnFDArgs {
9039 : Context(Context), OriginalFD(TypoFD),
9042 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
9048 CDeclEnd = candidate.
end();
9049 CDecl != CDeclEnd; ++CDecl) {
9056 if (
Parent &&
Parent->getCanonicalDecl() == ExpectedParent)
9058 }
else if (!ExpectedParent) {
9067 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
9068 return std::make_unique<DifferentNameValidatorCCC>(*
this);
9094 ActOnFDArgs &ExtraArgs,
bool IsLocalFriend,
Scope *S) {
9100 bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
9102 IsLocalFriend ? diag::err_no_matching_local_friend :
9104 diag::err_member_decl_does_not_match;
9108 RedeclarationKind::ForVisibleRedeclaration);
9116 "Cannot have an ambiguity in previous-declaration lookup");
9118 DifferentNameValidatorCCC CCC(SemaRef.
Context, NewFD,
9120 if (!Prev.
empty()) {
9129 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
9130 NearMatches.push_back(std::make_pair(FD, ParamNum));
9137 IsLocalFriend ?
nullptr : NewDC))) {
9140 ExtraArgs.D.getIdentifierLoc());
9144 CDeclEnd = Correction.
end();
9145 CDecl != CDeclEnd; ++CDecl) {
9152 bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
9165 ExtraArgs.S, ExtraArgs.D,
9168 ExtraArgs.AddToScope);
9176 Decl *Canonical =
Result->getCanonicalDecl();
9179 if ((*I)->getCanonicalDecl() == Canonical)
9186 SemaRef.
PDiag(IsLocalFriend
9187 ? diag::err_no_matching_local_friend_suggest
9188 : diag::err_member_decl_does_not_match_suggest)
9189 << Name << NewDC << IsDefinition);
9194 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
9195 ExtraArgs.D.getIdentifierLoc());
9196 ExtraArgs.D.setRedeclaration(wasRedeclaration);
9202 << Name << NewDC << IsDefinition << NewFD->
getLocation();
9205 if (NewMD && DiagMsg == diag::err_member_decl_does_not_match) {
9211 bool NewFDisConst = NewMD && NewMD->
isConst();
9214 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
9215 NearMatch != NearMatchEnd; ++NearMatch) {
9218 bool FDisConst = MD && MD->
isConst();
9219 bool IsMember = MD || !IsLocalFriend;
9222 if (
unsigned Idx = NearMatch->second) {
9226 SemaRef.
Diag(
Loc, IsMember ? diag::note_member_def_close_param_match
9227 : diag::note_local_decl_close_param_match)
9230 }
else if (FDisConst != NewFDisConst) {
9232 diag::note_member_def_close_const_match)
9234 if (
const auto &FTI = ExtraArgs.D.getFunctionTypeInfo(); !NewFDisConst)
9237 else if (FTI.hasMethodTypeQualifiers() &&
9238 FTI.getConstQualifierLoc().isValid())
9242 IsMember ? diag::note_member_def_close_match
9243 : diag::note_local_decl_close_match);
9250 switch (
D.getDeclSpec().getStorageClassSpec()) {
9251 default: llvm_unreachable(
"Unknown storage class!");
9255 SemaRef.
Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
9256 diag::err_typecheck_sclass_func);
9257 D.getMutableDeclSpec().ClearStorageClassSpecs();
9262 if (
D.getDeclSpec().isExternInLinkageSpec())
9272 SemaRef.
Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
9273 diag::err_static_block_func);
9289 bool &IsVirtualOkay) {
9294 bool isInline =
D.getDeclSpec().isInlineSpecified();
9302 SemaRef.
Diag(
D.getDeclSpec().getConstexprSpecLoc(),
9303 diag::err_c23_constexpr_not_variable);
9305 SemaRef.
Diag(
D.getDeclSpec().getConstexprSpecLoc(),
9306 diag::err_constexpr_wrong_decl_kind)
9307 <<
static_cast<int>(ConstexprKind);
9309 D.getMutableDeclSpec().ClearConstexprSpec();
9324 (
D.isFunctionDeclarator() &&
D.getFunctionTypeInfo().hasPrototype) ||
9325 (
D.getDeclSpec().isTypeRep() &&
9327 ->isFunctionProtoType()) ||
9331 "Strict prototypes are required");
9338 if (
D.isInvalidType())
9345 Expr *TrailingRequiresClause =
D.getTrailingRequiresClause();
9352 "Constructors can only be declared in a member context");
9358 isInline,
false, ConstexprKind,
9369 false, ConstexprKind,
9370 TrailingRequiresClause);
9373 if (
Record->isBeingDefined())
9382 IsVirtualOkay =
true;
9386 SemaRef.
Diag(
D.getIdentifierLoc(), diag::err_destructor_not_member);
9394 true, ConstexprKind, TrailingRequiresClause);
9399 SemaRef.
Diag(
D.getIdentifierLoc(),
9400 diag::err_conv_function_not_member);
9405 if (
D.isInvalidType())
9408 IsVirtualOkay =
true;
9413 TrailingRequiresClause);
9427 if (Name.getAsIdentifierInfo() &&
9428 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
9429 SemaRef.
Diag(
D.getIdentifierLoc(), diag::err_constructor_return_type)
9440 IsVirtualOkay = !Ret->isStatic();
9444 SemaRef.
getLangOpts().CPlusPlus &&
D.getDeclSpec().isFriendSpecified();
9454 true , ConstexprKind, TrailingRequiresClause);
9471 StringRef SizeTypeNames[] = {
"size_t",
"intptr_t",
"uintptr_t",
"ptrdiff_t"};
9479 if (Names.end() != Match)
9484 }
while (DesugaredTy != Ty);
9523 "__cl_clang_non_portable_kernel_param_types", S.
getLangOpts())) {
9525 bool IsStandardLayoutType =
true;
9531 if (!CXXRec->hasDefinition())
9533 if (!CXXRec || !CXXRec->hasDefinition() || !CXXRec->isStandardLayout())
9534 IsStandardLayoutType =
false;
9537 !IsStandardLayoutType)
9585 "__cl_clang_non_portable_kernel_param_types", S.
getLangOpts()) &&
9599 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
9646 S.
Diag(
Loc, diag::note_entity_declared_at) << PT;
9669 HistoryStack.push_back(
nullptr);
9678 VisitStack.push_back(RecTy->
getDecl());
9679 assert(VisitStack.back() &&
"First decl null?");
9682 const Decl *Next = VisitStack.pop_back_val();
9684 assert(!HistoryStack.empty());
9686 if (
const FieldDecl *Hist = HistoryStack.pop_back_val())
9687 ValidTypes.insert(Hist->getType().getTypePtr());
9695 if (
const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
9696 HistoryStack.push_back(Field);
9698 QualType FieldTy = Field->getType();
9702 "Unexpected type.");
9707 RD = cast<RecordDecl>(Next);
9711 VisitStack.push_back(
nullptr);
9713 for (
const auto *FD : RD->
fields()) {
9724 VisitStack.push_back(FD);
9736 diag::err_record_with_pointers_kernel_param)
9743 S.
Diag(OrigRecDecl->getLocation(), diag::note_within_field_of_type)
9744 << OrigRecDecl->getDeclName();
9749 I = HistoryStack.begin() + 1,
9750 E = HistoryStack.end();
9763 }
while (!VisitStack.empty());
9779 while (S->isClassScope() ||
9780 (LangOpts.CPlusPlus &&
9781 S->isFunctionPrototypeScope()) ||
9783 (S->getEntity() && S->getEntity()->isTransparentContext()))
9790 unsigned BuiltinID) {
9791 switch (BuiltinID) {
9792 case Builtin::BI__GetExceptionInfo:
9796 case Builtin::BIaddressof:
9797 case Builtin::BI__addressof:
9798 case Builtin::BIforward:
9799 case Builtin::BIforward_like:
9800 case Builtin::BImove:
9801 case Builtin::BImove_if_noexcept:
9802 case Builtin::BIas_const: {
9824 Diag(
D.getIdentifierLoc(), diag::err_function_decl_cmse_ns_call);
9827 llvm::append_range(TemplateParamLists, TemplateParamListsRef);
9829 if (!TemplateParamLists.empty() && !TemplateParamLists.back()->empty() &&
9830 Invented->getDepth() == TemplateParamLists.back()->getDepth())
9831 TemplateParamLists.back() = Invented;
9833 TemplateParamLists.push_back(Invented);
9841 if (
DeclSpec::TSCS TSCS =
D.getDeclSpec().getThreadStorageClassSpec())
9842 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
9843 diag::err_invalid_thread)
9846 if (
D.isFirstDeclarationOfMember())
9848 R, !(
D.isStaticMember() ||
D.isExplicitObjectMemberFunction()),
9849 D.isCtorOrDtor(),
D.getIdentifierLoc());
9851 bool isFriend =
false;
9853 bool isMemberSpecialization =
false;
9854 bool isFunctionTemplateSpecialization =
false;
9856 bool HasExplicitTemplateArgs =
false;
9859 bool isVirtualOkay =
false;
9866 if (!NewFD)
return nullptr;
9876 if (IsLocalExternDecl)
9886 bool ImplicitInlineCXX20 = !
getLangOpts().CPlusPlusModules ||
9890 bool isInline =
D.getDeclSpec().isInlineSpecified();
9891 bool isVirtual =
D.getDeclSpec().isVirtualSpecified();
9892 bool hasExplicit =
D.getDeclSpec().hasExplicitSpecifier();
9893 isFriend =
D.getDeclSpec().isFriendSpecified();
9894 if (ImplicitInlineCXX20 && isFriend &&
D.isFunctionDefinition()) {
9909 if (
Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
9914 if (isVirtual &&
Parent->isUnion()) {
9915 Diag(
D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_in_union);
9919 Parent->hasAttr<SYCLSpecialClassAttr>() &&
9921 NewFD->
getName() ==
"__init" &&
D.isFunctionDefinition()) {
9922 if (
auto *Def =
Parent->getDefinition())
9923 Def->setInitMethod(
true);
9928 isMemberSpecialization =
false;
9929 isFunctionTemplateSpecialization =
false;
9930 if (
D.isInvalidType())
9938 ?
D.getName().TemplateId
9943 D.getCXXScopeSpec(), TemplateId, TemplateParamLists, isFriend,
9944 isMemberSpecialization,
Invalid);
9945 if (TemplateParams) {
9950 if (TemplateParams->
size() > 0) {
9958 }
else if (TemplateId) {
9959 Diag(
D.getIdentifierLoc(), diag::err_function_template_partial_spec)
9975 Name, TemplateParams,
9981 if (TemplateParamLists.size() > 1) {
9988 isFunctionTemplateSpecialization =
true;
9990 if (TemplateParamLists.size() > 0)
10009 Diag(
D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
10010 << Name << RemoveRange
10016 HasExplicitTemplateArgs =
true;
10023 if (!TemplateParamLists.empty() && isMemberSpecialization &&
10029 if (TemplateParamLists.size() > 0)
10034 if (isFriend && TemplateId)
10035 isFunctionTemplateSpecialization =
true;
10041 if (isFunctionTemplateSpecialization && TemplateId) {
10042 HasExplicitTemplateArgs =
true;
10073 if (!isVirtualOkay) {
10074 Diag(
D.getDeclSpec().getVirtualSpecLoc(),
10075 diag::err_virtual_non_function);
10078 Diag(
D.getDeclSpec().getVirtualSpecLoc(),
10079 diag::err_virtual_out_of_class)
10084 Diag(
D.getDeclSpec().getVirtualSpecLoc(),
10085 diag::err_virtual_member_function_template)
10094 Diag(
D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual);
10103 Diag(
D.getDeclSpec().getInlineSpecLoc(),
10104 diag::err_inline_declaration_block_scope) << Name
10114 !isa<CXXDeductionGuideDecl>(NewFD)) {
10117 Diag(
D.getDeclSpec().getExplicitSpecLoc(),
10118 diag::err_explicit_out_of_class)
10120 }
else if (!isa<CXXConstructorDecl>(NewFD) &&
10121 !isa<CXXConversionDecl>(NewFD)) {
10124 Diag(
D.getDeclSpec().getExplicitSpecLoc(),
10125 diag::err_explicit_non_ctor_or_conv_function)
10139 if (isa<CXXDestructorDecl>(NewFD) &&
10142 Diag(
D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor)
10143 <<
static_cast<int>(ConstexprKind);
10156 Diag(
D.getDeclSpec().getConstexprSpecLoc(),
10157 diag::err_invalid_consteval_decl_kind)
10164 if (
D.getDeclSpec().isModulePrivateSpecified()) {
10165 if (isFunctionTemplateSpecialization) {
10167 =
D.getDeclSpec().getModulePrivateSpecLoc();
10168 Diag(ModulePrivateLoc, diag::err_module_private_specialization)
10189 switch (
D.getFunctionDefinitionKind()) {
10203 if (ImplicitInlineCXX20 && isa<CXXMethodDecl>(NewFD) && DC ==
CurContext &&
10204 D.isFunctionDefinition()) {
10214 if (!isFriend && SC !=
SC_None) {
10222 if (isFunctionTemplateSpecialization || isMemberSpecialization) {
10223 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
10224 diag::ext_explicit_specialization_storage_class)
10226 D.getDeclSpec().getStorageClassSpecLoc());
10230 assert(isa<CXXMethodDecl>(NewFD) &&
10231 "Out-of-line member function should be a CXXMethodDecl");
10243 Diag(
D.getDeclSpec().getStorageClassSpecLoc(),
10245 cast<CXXRecordDecl>(DC)->getDescribedClassTemplate()) ||
10248 ? diag::ext_static_out_of_line
10249 : diag::err_static_out_of_line)
10251 D.getDeclSpec().getStorageClassSpecLoc());
10259 if ((Name.getCXXOverloadedOperator() == OO_Delete ||
10260 Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
10273 if (isInline && !
D.isFunctionDefinition() &&
getLangOpts().CPlusPlus20 &&
10275 PendingInlineFuncDecls.insert(NewFD);
10281 D.getCXXScopeSpec().isNotEmpty() ||
10282 isMemberSpecialization ||
10283 isFunctionTemplateSpecialization);
10293 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
10309 if (
D.isFunctionDeclarator(FTIIdx)) {
10318 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
10322 Params.push_back(Param);
10337 auto *TD = dyn_cast<TagDecl>(NonParmDecl);
10342 if (
auto *ECD = dyn_cast<EnumConstantDecl>(NonParmDecl))
10343 TD = cast<EnumDecl>(ECD->getDeclContext());
10347 DeclContext *TagDC = TD->getLexicalDeclContext();
10351 TD->setDeclContext(NewFD);
10359 if (TagDC != PrototypeTagContext)
10360 TD->setLexicalDeclContext(TagDC);
10374 for (
const auto &AI : FT->param_types()) {
10378 Params.push_back(Param);
10382 "Should not need args for typedef of non-prototype fn");
10386 NewFD->setParams(Params);
10388 if (
D.getDeclSpec().isNoreturnSpecified())
10390 C11NoReturnAttr::Create(
Context,
D.getDeclSpec().getNoreturnSpecLoc()));
10402 !NewFD->
hasAttr<SectionAttr>())
10403 NewFD->
addAttr(PragmaClangTextSectionAttr::CreateImplicit(
10408 if (
CodeSegStack.CurrentValue &&
D.isFunctionDefinition() &&
10409 !NewFD->
hasAttr<SectionAttr>()) {
10410 NewFD->
addAttr(SectionAttr::CreateImplicit(
10412 CodeSegStack.CurrentPragmaLocation, SectionAttr::Declspec_allocate));
10423 !NewFD->
hasAttr<StrictGuardStackCheckAttr>())
10424 NewFD->
addAttr(StrictGuardStackCheckAttr::CreateImplicit(
10429 if (!NewFD->
hasAttr<CodeSegAttr>()) {
10431 D.isFunctionDefinition())) {
10438 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
10440 !NewTVA->isDefaultVersion() &&
10443 AddToScope =
false;
10455 Diag(NewFD->
getLocation(), diag::err_return_value_with_address_space);
10470 isMemberSpecialization,
10471 D.isFunctionDefinition()));
10474 D.setRedeclaration(
true);
10477 "previous declaration set still overloaded");
10483 if (isa<FunctionNoProtoType>(FT) && !
D.isFunctionDefinition()) {
10489 CC ==
CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
10508 if (
D.getDeclSpec().isInlineSpecified() &&
10511 Diag(
D.getDeclSpec().getInlineSpecLoc(),
10512 diag::ext_operator_new_delete_declared_inline)
10539 if (isFunctionTemplateSpecialization || isMemberSpecialization) {
10551 Diag(TRC->getBeginLoc(), diag::err_non_temp_spec_requires_clause)
10554 !
D.isFunctionDefinition()) {
10559 diag::err_non_temp_friend_decl_with_requires_clause_must_be_def);
10562 !(isa<CXXMethodDecl>(NewFD) ||
D.isFunctionDefinition())) {
10563 Diag(TRC->getBeginLoc(),
10564 diag::err_constrained_non_templated_function);
10581 if (isFunctionTemplateSpecialization) {
10582 bool isDependentSpecialization =
false;
10587 isDependentSpecialization =
10589 (HasExplicitTemplateArgs &&
10593 assert((!isDependentSpecialization ||
10594 (HasExplicitTemplateArgs == isDependentSpecialization)) &&
10595 "dependent friend function specialization without template "
10601 isDependentSpecialization =
10606 HasExplicitTemplateArgs ? &TemplateArgs :
nullptr;
10607 if (isDependentSpecialization) {
10614 NewFD, ExplicitTemplateArgs,
Previous))
10635 isMemberSpecialization,
10636 D.isFunctionDefinition()));
10639 D.setRedeclaration(
true);
10642 !
D.isRedeclaration() ||
10644 "previous declaration set still overloaded");
10671 D.getDeclSpec().isFriendSpecified()
10672 ? (
D.isFunctionDefinition()
10675 : (
D.getCXXScopeSpec().isSet() &&
10684 }
else if (!
D.isRedeclaration()) {
10685 struct ActOnFDArgs ExtraArgs = { S,
D, TemplateParamLists,
10692 if (
D.getCXXScopeSpec().isSet()) {
10707 (
D.getCXXScopeSpec().getScopeRep()->isDependent() ||
10731 *
this,
Previous, NewFD, ExtraArgs,
false,
nullptr)) {
10732 AddToScope = ExtraArgs.AddToScope;
10739 }
else if (isFriend && cast<CXXRecordDecl>(
CurContext)->isLocalClass()) {
10741 *
this,
Previous, NewFD, ExtraArgs,
true, S)) {
10742 AddToScope = ExtraArgs.AddToScope;
10746 }
else if (!
D.isFunctionDefinition() &&
10747 isa<CXXMethodDecl>(NewFD) && NewFD->
isOutOfLine() &&
10748 !isFriend && !isFunctionTemplateSpecialization &&
10749 !isMemberSpecialization) {
10758 <<
D.getCXXScopeSpec().getRange();
10764 if (!NewFD->
isInvalidDecl() && S->getDepth() == 0 && Name.isIdentifier())
10767 if (NewFD->
hasAttr<HLSLShaderAttr>())
10773 if (!
D.isRedeclaration()) {
10775 if (
unsigned BuiltinID = II->getBuiltinID()) {
10777 if (!InStdNamespace &&
10783 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10792 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10797 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10808 if (NewFD->
hasAttr<OverloadableAttr>() &&
10811 diag::err_attribute_overloadable_no_prototype)
10813 NewFD->
dropAttr<OverloadableAttr>();
10827 if (
D.isFunctionDefinition()) {
10843 if (
D.isRedeclaration() && !
Previous.empty()) {
10846 isMemberSpecialization ||
10847 isFunctionTemplateSpecialization,
10848 D.isFunctionDefinition());
10853 if (II && II->
isStr(
CUDA().getConfigureFuncName()) &&
10866 (NewFD->
hasAttr<CUDADeviceAttr>() ||
10867 NewFD->
hasAttr<CUDAGlobalAttr>()) &&
10869 !
D.isFunctionDefinition())) {
10881 Diag(
D.getIdentifierLoc(), diag::err_static_kernel);
10882 D.setInvalidType();
10888 Diag(
D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type)
10891 D.setInvalidType();
10900 Diag(
D.getIdentifierLoc(), diag::err_method_kernel);
10901 D.setInvalidType();
10904 Diag(
D.getIdentifierLoc(), diag::err_template_kernel);
10905 D.setInvalidType();
10920 if (!
D.isFunctionDefinition()) {
10922 diag::err_friend_decl_with_enclosing_temp_constraint_must_be_def);
10942 if (
getLangOpts().getOpenCLCompatibleVersion() >= 200) {
10944 QualType ElemTy = PipeTy->getElementType();
10946 Diag(Param->getTypeSpecStartLoc(), diag::err_reference_pipe_type);
10947 D.setInvalidType();
10954 Diag(Param->getTypeSpecStartLoc(),
10955 diag::err_wasm_table_as_function_parameter);
10956 D.setInvalidType();
10963 if (
const auto *
attr = NewFD->
getAttr<AvailabilityAttr>()) {
10964 if (NewFD->
hasAttr<ConstructorAttr>()) {
10965 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
10967 NewFD->
dropAttr<AvailabilityAttr>();
10969 if (NewFD->
hasAttr<DestructorAttr>()) {
10970 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
10972 NewFD->
dropAttr<AvailabilityAttr>();
10983 if (
const auto *NBA = NewFD->
getAttr<NoBuiltinAttr>())
10984 switch (
D.getFunctionDefinitionKind()) {
10987 Diag(NBA->getLocation(),
10988 diag::err_attribute_no_builtin_on_defaulted_deleted_function)
10989 << NBA->getSpelling();
10992 Diag(NBA->getLocation(), diag::err_attribute_no_builtin_on_non_definition)
10993 << NBA->getSpelling();
11021 const auto *Method = dyn_cast<CXXMethodDecl>(FD);
11025 if (
const auto *SAttr =
Parent->getAttr<CodeSegAttr>()) {
11036 while ((
Parent = dyn_cast<CXXRecordDecl>(
Parent->getParent()))) {
11037 if (
const auto *SAttr =
Parent->getAttr<CodeSegAttr>()) {
11047 bool IsDefinition) {
11050 if (!FD->
hasAttr<SectionAttr>() && IsDefinition &&
11052 return SectionAttr::CreateImplicit(
11054 CodeSegStack.CurrentPragmaLocation, SectionAttr::Declspec_allocate);
11102 auto *VD = dyn_cast<ValueDecl>(
D);
11103 auto *PrevVD = dyn_cast<ValueDecl>(PrevDecl);
11104 return !VD || !PrevVD ||
11106 PrevVD->getType());
11114 const auto *TA = FD->
getAttr<TargetAttr>();
11115 const auto *TVA = FD->
getAttr<TargetVersionAttr>();
11117 assert((TA || TVA) &&
"Expecting target or target_version attribute");
11130 for (
const auto &Feat : ParseInfo.
Features) {
11131 auto BareFeat = StringRef{Feat}.substr(1);
11132 if (Feat[0] ==
'-') {
11134 << Feature << (
"no-" + BareFeat).str();
11142 << Feature << BareFeat;
11154 for (
auto &Feat : ParseInfo.
Features)
11155 Feats.push_back(StringRef{Feat}.substr(1));
11158 TVA->getFeatures(Feats);
11160 for (
const auto &Feat : Feats) {
11163 << Feature << Feat;
11180 case attr::ArmLocallyStreaming:
11185 case attr::NonNull:
11186 case attr::NoThrow:
11195 const auto Diagnose = [FD, CausedFD, MVKind](
Sema &S,
const Attr *A) {
11196 S.
Diag(FD->
getLocation(), diag::err_multiversion_disallowed_other_attr)
11197 <<
static_cast<unsigned>(MVKind) << A;
11199 S.
Diag(CausedFD->
getLocation(), diag::note_multiversioning_caused_here);
11204 switch (A->getKind()) {
11205 case attr::CPUDispatch:
11206 case attr::CPUSpecific:
11209 return Diagnose(S, A);
11213 return Diagnose(S, A);
11215 case attr::TargetVersion:
11218 return Diagnose(S, A);
11220 case attr::TargetClones:
11223 return Diagnose(S, A);
11227 return Diagnose(S, A);
11240 bool ConstexprSupported,
bool CLinkageMayDiffer) {
11241 enum DoesntSupport {
11248 DefaultedFuncs = 6,
11249 ConstexprFuncs = 7,
11250 ConstevalFuncs = 8,
11262 if (NoProtoDiagID.
getDiagID() != 0 && OldFD &&
11265 Diag(NoteCausedDiagIDAt.first, NoteCausedDiagIDAt.second);
11273 if (!TemplatesSupported &&
11275 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11278 if (
const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) {
11279 if (NewCXXFD->isVirtual())
11280 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11283 if (isa<CXXConstructorDecl>(NewCXXFD))
11284 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11287 if (isa<CXXDestructorDecl>(NewCXXFD))
11288 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11293 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11297 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11301 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11302 << (NewFD->
isConsteval() ? ConstevalFuncs : ConstexprFuncs);
11305 const auto *NewType = cast<FunctionType>(NewQType);
11306 QualType NewReturnType = NewType->getReturnType();
11309 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11315 const auto *OldType = cast<FunctionType>(OldQType);
11322 bool ArmStreamingCCMismatched =
false;
11323 if (OldFPT && NewFPT) {
11330 ArmStreamingCCMismatched =
true;
11333 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC() || ArmStreamingCCMismatched)
11336 QualType OldReturnType = OldType->getReturnType();
11338 if (OldReturnType != NewReturnType)
11339 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ReturnType;
11342 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ConstexprSpec;
11345 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << InlineSpec;
11348 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) <<
Linkage;
11371 bool IsCPUSpecificCPUDispatchMVKind =
11375 if (CausesMV && OldFD &&
11383 if (OldFD && CausesMV && OldFD->
isUsed(
false)) {
11390 OldFD, NewFD, S.
PDiag(diag::err_multiversion_noproto),
11392 S.
PDiag(diag::note_multiversioning_caused_here)),
11394 S.
PDiag(diag::err_multiversion_doesnt_support)
11395 <<
static_cast<unsigned>(MVKind)),
11397 S.
PDiag(diag::err_multiversion_diff)),
11399 !IsCPUSpecificCPUDispatchMVKind,
11412 "Function lacks multiversion attribute");
11413 const auto *TA = FD->
getAttr<TargetAttr>();
11414 const auto *TVA = FD->
getAttr<TargetVersionAttr>();
11417 if (TA && !TA->isDefaultVersion())
11454 To->
addAttr(TargetVersionAttr::CreateImplicit(
11460 bool &Redeclaration,
11465 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11466 const auto *OldTA = OldFD->
getAttr<TargetAttr>();
11467 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11468 const auto *OldTVA = OldFD->
getAttr<TargetVersionAttr>();
11470 assert((NewTA || NewTVA) &&
"Excpecting target or target_version attribute");
11479 if (NewTA && !NewTA->isDefaultVersion() &&
11480 (!OldTA || OldTA->getFeaturesStr() == NewTA->getFeaturesStr()))
11497 if ((NewTA && NewTA->isDefaultVersion() && !OldTA) ||
11498 (NewTVA && NewTVA->isDefaultVersion() && !OldTVA)) {
11499 Redeclaration =
true;
11507 S.
Diag(NewFD->
getLocation(), diag::note_multiversioning_caused_here);
11515 OldTA->getFeaturesStr());
11519 NewTA->getFeaturesStr());
11522 if (OldParsed == NewParsed) {
11530 for (
const auto *FD : OldFD->
redecls()) {
11531 const auto *CurTA = FD->
getAttr<TargetAttr>();
11532 const auto *CurTVA = FD->
getAttr<TargetVersionAttr>();
11536 ((NewTA && (!CurTA || CurTA->isInherited())) ||
11537 (NewTVA && (!CurTVA || CurTVA->isInherited())))) {
11539 << (NewTA ? 0 : 2);
11540 S.
Diag(NewFD->
getLocation(), diag::note_multiversioning_caused_here);
11548 Redeclaration =
false;
11587 const CPUDispatchAttr *NewCPUDisp,
const CPUSpecificAttr *NewCPUSpec,
11588 const TargetClonesAttr *NewClones,
bool &Redeclaration,
NamedDecl *&OldDecl,
11603 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11604 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11611 NewTA->getFeaturesStr());
11616 NewTVA->getFeatures(NewFeats);
11617 llvm::sort(NewFeats);
11620 bool UseMemberUsingDeclRules =
11623 bool MayNeedOverloadableChecks =
11632 if (MayNeedOverloadableChecks &&
11633 S.
IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
11636 switch (NewMVKind) {
11639 "Only target_clones can be omitted in subsequent declarations");
11642 const auto *CurTA = CurFD->
getAttr<TargetAttr>();
11643 if (CurTA->getFeaturesStr() == NewTA->getFeaturesStr()) {
11645 Redeclaration =
true;
11652 CurTA->getFeaturesStr());
11654 if (CurParsed == NewParsed) {
11663 if (
const auto *CurTVA = CurFD->
getAttr<TargetVersionAttr>()) {
11664 if (CurTVA->getName() == NewTVA->getName()) {
11666 Redeclaration =
true;
11671 CurTVA->getFeatures(CurFeats);
11672 llvm::sort(CurFeats);
11674 if (CurFeats == NewFeats) {
11680 }
else if (
const auto *CurClones = CurFD->
getAttr<TargetClonesAttr>()) {
11682 if (NewFeats.empty())
11685 for (
unsigned I = 0; I < CurClones->featuresStrs_size(); ++I) {
11687 CurClones->getFeatures(CurFeats, I);
11688 llvm::sort(CurFeats);
11690 if (CurFeats == NewFeats) {
11701 assert(NewClones &&
"MultiVersionKind does not match attribute type");
11702 if (
const auto *CurClones = CurFD->
getAttr<TargetClonesAttr>()) {
11703 if (CurClones->featuresStrs_size() != NewClones->featuresStrs_size() ||
11704 !std::equal(CurClones->featuresStrs_begin(),
11705 CurClones->featuresStrs_end(),
11706 NewClones->featuresStrs_begin())) {
11712 }
else if (
const auto *CurTVA = CurFD->
getAttr<TargetVersionAttr>()) {
11714 CurTVA->getFeatures(CurFeats);
11715 llvm::sort(CurFeats);
11718 if (CurFeats.empty())
11721 for (
unsigned I = 0; I < NewClones->featuresStrs_size(); ++I) {
11723 NewClones->getFeatures(NewFeats, I);
11724 llvm::sort(NewFeats);
11726 if (CurFeats == NewFeats) {
11735 Redeclaration =
true;
11742 const auto *CurCPUSpec = CurFD->
getAttr<CPUSpecificAttr>();
11743 const auto *CurCPUDisp = CurFD->
getAttr<CPUDispatchAttr>();
11748 CurFD->
hasAttr<CPUDispatchAttr>()) {
11749 if (CurCPUDisp->cpus_size() == NewCPUDisp->cpus_size() &&
11751 CurCPUDisp->cpus_begin(), CurCPUDisp->cpus_end(),
11752 NewCPUDisp->cpus_begin(),
11754 return Cur->getName() == New->getName();
11757 Redeclaration =
true;
11769 if (CurCPUSpec->cpus_size() == NewCPUSpec->cpus_size() &&
11771 CurCPUSpec->cpus_begin(), CurCPUSpec->cpus_end(),
11772 NewCPUSpec->cpus_begin(),
11774 return Cur->getName() == New->getName();
11777 Redeclaration =
true;
11785 if (CurII == NewII) {
11818 Redeclaration =
true;
11824 Redeclaration =
false;
11837 bool &Redeclaration,
NamedDecl *&OldDecl,
11845 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11846 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11847 const auto *NewCPUDisp = NewFD->
getAttr<CPUDispatchAttr>();
11848 const auto *NewCPUSpec = NewFD->
getAttr<CPUSpecificAttr>();
11849 const auto *NewClones = NewFD->
getAttr<TargetClonesAttr>();
11859 NewTVA->isDefaultVersion())) {
11860 S.
Diag(NewFD->
getLocation(), diag::err_multiversion_not_allowed_on_main);
11868 if (NewTA && TI.
getTriple().isAArch64())
11895 S.
Diag(NewFD->
getLocation(), diag::err_multiversion_required_in_redecl)
11906 S, OldFD, NewFD, Redeclaration, OldDecl,
Previous);
11908 if (OldFD->
isUsed(
false)) {
11910 return S.
Diag(NewFD->
getLocation(), diag::err_multiversion_after_used);
11926 NewCPUSpec, NewClones, Redeclaration,
11931 bool IsPure = NewFD->
hasAttr<PureAttr>();
11932 bool IsConst = NewFD->
hasAttr<ConstAttr>();
11935 if (!IsPure && !IsConst)
11942 if (IsPure && IsConst) {
11952 NewFD->
dropAttrs<PureAttr, ConstAttr>();
11958 bool IsMemberSpecialization,
11961 "Variably modified return types are not handled here");
11966 bool MergeTypeWithPrevious = !
getLangOpts().CPlusPlus &&
11969 bool Redeclaration =
false;
11971 bool MayNeedOverloadableChecks =
false;
11983 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
11984 Redeclaration =
true;
11985 OldDecl = Candidate;
11988 MayNeedOverloadableChecks =
true;
11992 Redeclaration =
true;
11996 Redeclaration =
true;
12000 Redeclaration =
false;
12007 if (!Redeclaration &&
12012 Redeclaration =
true;
12013 OldDecl =
Previous.getFoundDecl();
12014 MergeTypeWithPrevious =
false;
12017 if (OldDecl->
hasAttr<OverloadableAttr>() ||
12018 NewFD->
hasAttr<OverloadableAttr>()) {
12019 if (
IsOverload(NewFD, cast<FunctionDecl>(OldDecl),
false)) {
12020 MayNeedOverloadableChecks =
true;
12021 Redeclaration =
false;
12029 return Redeclaration;
12079 !MD->
isStatic() && !isa<CXXConstructorDecl>(MD) &&
12083 OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->
getAsFunction());
12084 if (!OldMD || !OldMD->
isStatic()) {
12106 if (Redeclaration) {
12112 return Redeclaration;
12119 dyn_cast<FunctionTemplateDecl>(OldDecl)) {
12120 auto *OldFD = OldTemplateDecl->getTemplatedDecl();
12123 assert(NewTemplateDecl &&
"Template/non-template mismatch");
12132 NewFD->
setAccess(OldTemplateDecl->getAccess());
12133 NewTemplateDecl->
setAccess(OldTemplateDecl->getAccess());
12138 if (IsMemberSpecialization &&
12141 assert(OldTemplateDecl->isMemberSpecialization());
12144 if (OldFD->isDeleted()) {
12146 assert(OldFD->getCanonicalDecl() == OldFD);
12148 OldFD->setDeletedAsWritten(
false);
12154 auto *OldFD = cast<FunctionDecl>(OldDecl);
12162 !NewFD->
getAttr<OverloadableAttr>()) {
12166 return ND->hasAttr<OverloadableAttr>();
12168 "Non-redecls shouldn't happen without overloadable present");
12171 const auto *FD = dyn_cast<FunctionDecl>(ND);
12172 return FD && !FD->
hasAttr<OverloadableAttr>();
12175 if (OtherUnmarkedIter !=
Previous.end()) {
12177 diag::err_attribute_overloadable_multiple_unmarked_overloads);
12178 Diag((*OtherUnmarkedIter)->getLocation(),
12179 diag::note_attribute_overloadable_prev_overload)
12189 if (NewFD->
hasAttr<SYCLKernelEntryPointAttr>())
12199 dyn_cast<CXXDestructorDecl>(NewFD)) {
12207 !
Destructor->getFunctionObjectParameterType()->isDependentType()) {
12216 return Redeclaration;
12219 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(NewFD)) {
12220 if (
auto *TD = Guide->getDescribedFunctionTemplate())
12226 Diag(Guide->getBeginLoc(), diag::err_deduction_guide_specialized)
12231 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
12232 if (!Method->isFunctionTemplateSpecialization() &&
12233 !Method->getDescribedFunctionTemplate() &&
12234 Method->isCanonicalDecl()) {
12241 diag::err_constrained_virtual_method);
12243 if (Method->isStatic())
12254 return Redeclaration;
12261 return Redeclaration;
12281 Diag(NewFD->
getLocation(), diag::warn_return_value_udt) << NewFD << R;
12294 auto HasNoexcept = [&](
QualType T) ->
bool {
12305 if (FPT->isNothrow())
12311 bool AnyNoexcept = HasNoexcept(FPT->getReturnType());
12313 AnyNoexcept |= HasNoexcept(
T);
12316 diag::warn_cxx17_compat_exception_spec_in_signature)
12320 if (!Redeclaration &&
LangOpts.CUDA) {
12321 bool IsKernel = NewFD->
hasAttr<CUDAGlobalAttr>();
12323 if (!Parm->getType()->isDependentType() &&
12324 Parm->hasAttr<CUDAGridConstantAttr>() &&
12325 !(IsKernel && Parm->getType().isConstQualified()))
12326 Diag(Parm->getAttr<CUDAGridConstantAttr>()->getLocation(),
12327 diag::err_cuda_grid_constant_not_allowed);
12336 return Redeclaration;
12345 Diag(FD->
getLocation(), diag::ext_main_invalid_linkage_specification)
12357 ? diag::err_static_main : diag::warn_static_main)
12365 Diag(NoreturnLoc, diag::ext_noreturn_main);
12366 Diag(NoreturnLoc, diag::note_main_remove_noreturn)
12378 << FD->
hasAttr<OpenCLKernelAttr>();
12389 assert(
T->
isFunctionType() &&
"function decl is not of function type");
12411 Diag(RTRange.
getBegin(), diag::note_main_change_return_type)
12433 if (isa<FunctionNoProtoType>(FT))
return;
12439 bool HasExtraParameters = (nparams > 3);
12451 HasExtraParameters =
false;
12453 if (HasExtraParameters) {
12466 for (
unsigned i = 0; i < nparams; ++i) {
12469 bool mismatch =
true;
12486 mismatch = !qs.
empty();
12515 if (
T.isWindowsGNUEnvironment())
12520 if (
T.isOSWindows() &&
T.getArch() == llvm::Triple::x86)
12528 assert(
T->
isFunctionType() &&
"function decl is not of function type");
12537 if (FD->
getName() !=
"DllMain")
12571 if (
Init->isValueDependent()) {
12572 assert(
Init->containsErrors() &&
12573 "Dependent code should only occur in error-recovery path.");
12576 const Expr *Culprit;
12577 if (
Init->isConstantInitializer(
Context,
false, &Culprit))
12586 class SelfReferenceChecker
12592 bool isReferenceType;
12600 SelfReferenceChecker(
Sema &S,
Decl *OrigDecl) : Inherited(S.Context),
12601 S(S), OrigDecl(OrigDecl) {
12604 isReferenceType =
false;
12605 isInitList =
false;
12606 if (
ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
12607 isPODType = VD->getType().isPODType(S.
Context);
12609 isReferenceType = VD->getType()->isReferenceType();
12616 void CheckExpr(
Expr *
E) {
12625 InitFieldIndex.push_back(0);
12626 for (
auto *Child : InitList->
children()) {
12627 CheckExpr(cast<Expr>(Child));
12628 ++InitFieldIndex.back();
12630 InitFieldIndex.pop_back();
12635 bool CheckInitListMemberExpr(
MemberExpr *
E,
bool CheckReference) {
12638 bool ReferenceField =
false;
12642 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
12645 Fields.push_back(FD);
12647 ReferenceField =
true;
12648 Base = ME->getBase()->IgnoreParenImpCasts();
12653 if (!DRE || DRE->
getDecl() != OrigDecl)
12657 if (CheckReference && !ReferenceField)
12662 for (
const FieldDecl *I : llvm::reverse(Fields))
12663 UsedFieldIndex.push_back(I->getFieldIndex());
12668 for (
auto UsedIter = UsedFieldIndex.begin(),
12669 UsedEnd = UsedFieldIndex.end(),
12670 OrigIter = InitFieldIndex.begin(),
12671 OrigEnd = InitFieldIndex.end();
12672 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
12673 if (*UsedIter < *OrigIter)
12675 if (*UsedIter > *OrigIter)
12680 HandleDeclRefExpr(DRE);
12687 void HandleValue(
Expr *
E) {
12690 HandleDeclRefExpr(DRE);
12695 Visit(CO->getCond());
12696 HandleValue(CO->getTrueExpr());
12697 HandleValue(CO->getFalseExpr());
12702 dyn_cast<BinaryConditionalOperator>(
E)) {
12703 Visit(BCO->getCond());
12704 HandleValue(BCO->getFalseExpr());
12709 if (
Expr *SE = OVE->getSourceExpr())
12715 if (BO->getOpcode() == BO_Comma) {
12716 Visit(BO->getLHS());
12717 HandleValue(BO->getRHS());
12722 if (isa<MemberExpr>(
E)) {
12724 if (CheckInitListMemberExpr(cast<MemberExpr>(
E),
12732 if (!isa<FieldDecl>(ME->getMemberDecl()))
12734 Base = ME->getBase()->IgnoreParenImpCasts();
12737 HandleDeclRefExpr(DRE);
12747 if (isReferenceType)
12748 HandleDeclRefExpr(
E);
12752 if (
E->getCastKind() == CK_LValueToRValue) {
12753 HandleValue(
E->getSubExpr());
12757 Inherited::VisitImplicitCastExpr(
E);
12762 if (CheckInitListMemberExpr(
E,
true ))
12771 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(
E->getMemberDecl());
12772 bool Warn = (MD && !MD->
isStatic());
12775 if (!isa<FieldDecl>(ME->getMemberDecl()))
12777 Base = ME->getBase()->IgnoreParenImpCasts();
12782 HandleDeclRefExpr(DRE);
12794 if (isa<UnresolvedLookupExpr>(Callee))
12795 return Inherited::VisitCXXOperatorCallExpr(
E);
12798 for (
auto Arg:
E->arguments())
12799 HandleValue(Arg->IgnoreParenImpCasts());
12807 HandleValue(
E->getSubExpr());
12811 if (
E->isIncrementDecrementOp()) {
12812 HandleValue(
E->getSubExpr());
12816 Inherited::VisitUnaryOperator(
E);
12822 if (
E->getConstructor()->isCopyConstructor()) {
12823 Expr *ArgExpr =
E->getArg(0);
12824 if (
InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
12825 if (ILE->getNumInits() == 1)
12826 ArgExpr = ILE->getInit(0);
12828 if (ICE->getCastKind() == CK_NoOp)
12829 ArgExpr = ICE->getSubExpr();
12830 HandleValue(ArgExpr);
12833 Inherited::VisitCXXConstructExpr(
E);
12838 if (
E->isCallToStdMove()) {
12839 HandleValue(
E->getArg(0));
12843 Inherited::VisitCallExpr(
E);
12847 if (
E->isCompoundAssignmentOp()) {
12848 HandleValue(
E->getLHS());
12849 Visit(
E->getRHS());
12853 Inherited::VisitBinaryOperator(
E);
12860 Visit(
E->getCond());
12861 Visit(
E->getFalseExpr());
12866 if (OrigDecl != ReferenceDecl)
return;
12868 if (isReferenceType) {
12869 diag = diag::warn_uninit_self_reference_in_reference_init;
12870 }
else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
12871 diag = diag::warn_static_self_reference_in_init;
12872 }
else if (isa<TranslationUnitDecl>(OrigDecl->
getDeclContext()) ||
12875 diag = diag::warn_uninit_self_reference_in_init;
12889 static void CheckSelfReference(
Sema &S,
Decl* OrigDecl,
Expr *
E,
12893 if (isa<ParmVarDecl>(OrigDecl))
12902 if (ICE->getCastKind() == CK_LValueToRValue)
12903 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
12904 if (DRE->
getDecl() == OrigDecl)
12907 SelfReferenceChecker(S, OrigDecl).CheckExpr(
E);
12914 struct VarDeclOrName {
12920 return VN.VDecl ?
Diag << VN.VDecl :
Diag << VN.Name;
12930 bool IsInitCapture = !VDecl;
12932 "init captures are expected to be deduced prior to initialization");
12934 VarDeclOrName VN{VDecl, Name};
12937 assert(Deduced &&
"deduceVarTypeFromInitializer for non-deduced type");
12941 !isa_and_present<StringLiteral, InitListExpr>(
Init)) {
12950 assert(VDecl &&
"no init for init capture deduction?");
12954 if (!isa<DeducedTemplateSpecializationType>(Deduced) ||
12965 DeduceInits =
Init;
12967 auto *PL = dyn_cast_if_present<ParenListExpr>(
Init);
12969 DeduceInits = PL->exprs();
12971 if (isa<DeducedTemplateSpecializationType>(Deduced)) {
12972 assert(VDecl &&
"non-auto type for init capture deduction?");
12983 if (
auto *IL = dyn_cast<InitListExpr>(
Init))
12984 DeduceInits = IL->inits();
12988 if (DeduceInits.empty()) {
12991 Diag(
Init->getBeginLoc(), IsInitCapture
12992 ? diag::err_init_capture_no_expression
12993 : diag::err_auto_var_init_no_expression)
12998 if (DeduceInits.size() > 1) {
12999 Diag(DeduceInits[1]->getBeginLoc(),
13000 IsInitCapture ? diag::err_init_capture_multiple_expressions
13001 : diag::err_auto_var_init_multiple_expressions)
13006 Expr *DeduceInit = DeduceInits[0];
13007 if (
DirectInit && isa<InitListExpr>(DeduceInit)) {
13008 Diag(
Init->getBeginLoc(), IsInitCapture
13009 ? diag::err_init_capture_paren_braces
13010 : diag::err_auto_var_init_paren_braces)
13016 bool DefaultedAnyToId =
false;
13020 if (
Result.isInvalid()) {
13024 DefaultedAnyToId =
true;
13030 if (VDecl && isa<DecompositionDecl>(VDecl) &&
13034 Type.getQualifiers());
13042 if (!IsInitCapture)
13044 else if (isa<InitListExpr>(
Init))
13046 diag::err_init_capture_deduction_failure_from_init_list)
13075 assert(!
Init || !
Init->containsErrors());
13088 if (
getLangOpts().ObjCAutoRefCount &&
ObjC().inferObjCARCLifetime(VDecl))
13109 if (
auto *EWC = dyn_cast<ExprWithCleanups>(
Init))
13110 Init = EWC->getSubExpr();
13112 if (
auto *CE = dyn_cast<ConstantExpr>(
Init))
13113 Init = CE->getSubExpr();
13118 "shouldn't be called if type doesn't have a non-trivial C struct");
13119 if (
auto *ILE = dyn_cast<InitListExpr>(
Init)) {
13120 for (
auto *I : ILE->inits()) {
13121 if (!I->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion() &&
13122 !I->getType().hasNonTrivialToPrimitiveCopyCUnion())
13130 if (isa<ImplicitValueInitExpr>(
Init)) {
13146bool shouldIgnoreForRecordTriviality(
const FieldDecl *FD) {
13152 return FD->
hasAttr<UnavailableAttr>();
13155struct DiagNonTrivalCUnionDefaultInitializeVisitor
13162 DiagNonTrivalCUnionDefaultInitializeVisitor(
13165 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13168 const FieldDecl *FD,
bool InNonTrivialUnion) {
13171 InNonTrivialUnion);
13172 return Super::visitWithKind(PDIK, QT, FD, InNonTrivialUnion);
13176 bool InNonTrivialUnion) {
13177 if (InNonTrivialUnion)
13179 << 1 << 0 << QT << FD->
getName();
13183 if (InNonTrivialUnion)
13185 << 1 << 0 << QT << FD->
getName();
13191 if (OrigLoc.isValid()) {
13192 bool IsUnion =
false;
13193 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13194 IsUnion = OrigRD->isUnion();
13195 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13196 << 0 << OrigTy << IsUnion << UseContext;
13200 InNonTrivialUnion =
true;
13203 if (InNonTrivialUnion)
13208 if (!shouldIgnoreForRecordTriviality(FD))
13209 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13222struct DiagNonTrivalCUnionDestructedTypeVisitor
13227 DiagNonTrivalCUnionDestructedTypeVisitor(
13230 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13233 const FieldDecl *FD,
bool InNonTrivialUnion) {
13236 InNonTrivialUnion);
13237 return Super::visitWithKind(DK, QT, FD, InNonTrivialUnion);
13241 bool InNonTrivialUnion) {
13242 if (InNonTrivialUnion)
13244 << 1 << 1 << QT << FD->
getName();
13248 if (InNonTrivialUnion)
13250 << 1 << 1 << QT << FD->
getName();
13256 if (OrigLoc.isValid()) {
13257 bool IsUnion =
false;
13258 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13259 IsUnion = OrigRD->isUnion();
13260 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13261 << 1 << OrigTy << IsUnion << UseContext;
13265 InNonTrivialUnion =
true;
13268 if (InNonTrivialUnion)
13273 if (!shouldIgnoreForRecordTriviality(FD))
13274 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13279 bool InNonTrivialUnion) {}
13289struct DiagNonTrivalCUnionCopyVisitor
13296 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13299 const FieldDecl *FD,
bool InNonTrivialUnion) {
13302 InNonTrivialUnion);
13303 return Super::visitWithKind(PCK, QT, FD, InNonTrivialUnion);
13307 bool InNonTrivialUnion) {
13308 if (InNonTrivialUnion)
13310 << 1 << 2 << QT << FD->
getName();
13314 if (InNonTrivialUnion)
13316 << 1 << 2 << QT << FD->
getName();
13322 if (OrigLoc.isValid()) {
13323 bool IsUnion =
false;
13324 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13325 IsUnion = OrigRD->isUnion();
13326 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13327 << 2 << OrigTy << IsUnion << UseContext;
13331 InNonTrivialUnion =
true;
13334 if (InNonTrivialUnion)
13339 if (!shouldIgnoreForRecordTriviality(FD))
13340 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13344 const FieldDecl *FD,
bool InNonTrivialUnion) {}
13347 bool InNonTrivialUnion) {}
13361 unsigned NonTrivialKind) {
13365 "shouldn't be called if type doesn't have a non-trivial C union");
13369 DiagNonTrivalCUnionDefaultInitializeVisitor(QT,
Loc, UseContext, *
this)
13370 .
visit(QT,
nullptr,
false);
13373 DiagNonTrivalCUnionDestructedTypeVisitor(QT,
Loc, UseContext, *
this)
13374 .visit(QT,
nullptr,
false);
13376 DiagNonTrivalCUnionCopyVisitor(QT,
Loc, UseContext, *
this)
13377 .visit(QT,
nullptr,
false);
13388 if (
auto *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
13389 if (!Method->isInvalidDecl()) {
13391 Diag(Method->getLocation(), diag::err_member_function_initialization)
13392 << Method->getDeclName() <<
Init->getSourceRange();
13393 Method->setInvalidDecl();
13398 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
13400 assert(!isa<FieldDecl>(RealDecl) &&
"field init shouldn't get here");
13410 SubExprs.push_back(Res.
get());
13419 if (!
Init->getType().isNull() &&
Init->getType()->isWebAssemblyTableType()) {
13420 Diag(
Init->getExprLoc(), diag::err_wasm_table_art) << 0;
13451 Diag(VDecl->
getLocation(), diag::err_attribute_dllimport_data_definition);
13472 BaseDeclType = Array->getElementType();
13474 diag::err_typecheck_decl_incomplete_type)) {
13481 diag::err_abstract_type_in_decl,
13491 !VDecl->
isTemplated() && !isa<VarTemplateSpecializationDecl>(VDecl) &&
13501 if (Def != VDecl &&
13521 Diag(
Init->getExprLoc(), diag::err_static_data_member_reinitialization)
13524 diag::note_previous_initializer)
13547 if (VDecl->
hasAttr<LoaderUninitializedAttr>()) {
13548 Diag(VDecl->
getLocation(), diag::err_loader_uninitialized_cant_init);
13562 if (!
Result.isUsable()) {
13571 bool IsParenListInit =
false;
13583 for (
size_t Idx = 0; Idx < Args.size(); ++Idx) {
13585 Args[Idx], VDecl,
true,
13586 [
this, Entity, Kind](
Expr *
E) {
13592 }
else if (Res.
get() != Args[Idx]) {
13593 Args[Idx] = Res.
get();
13603 if (!
Result.isUsable()) {
13617 if (isa<DecompositionDecl>(VDecl))
13623 IsParenListInit = !InitSeq.
steps().empty() &&
13627 if (!
Init->getType().isNull() && !
Init->getType()->isDependentType() &&
13659 if (VDecl->
hasAttr<BlocksAttr>())
13673 Init->getBeginLoc()))
13674 FSI->markSafeWeakUse(
Init);
13691 if (!
Result.isUsable()) {
13724 isa<InitListExpr>(
Init)) {
13728 if (
auto *
E = dyn_cast<ExprWithCleanups>(
Init))
13729 if (
auto *BE = dyn_cast<BlockExpr>(
E->getSubExpr()->
IgnoreParens()))
13731 BE->getBlockDecl()->setCanAvoidCopyToHeap();
13766 <<
Init->getSourceRange();
13777 else if (
Init->isValueDependent())
13781 else if (
Init->getType()->isScopedEnumeralType() &&
13787 Diag(
Loc, diag::ext_in_class_initializer_non_constant)
13788 <<
Init->getSourceRange();
13792 Diag(
Loc, diag::err_in_class_initializer_non_constant)
13793 <<
Init->getSourceRange();
13803 diag::ext_in_class_initializer_float_type_cxx11)
13804 << DclT <<
Init->getSourceRange();
13806 diag::note_in_class_initializer_float_type_cxx11)
13809 Diag(VDecl->
getLocation(), diag::ext_in_class_initializer_float_type)
13810 << DclT <<
Init->getSourceRange();
13813 Diag(
Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
13814 <<
Init->getSourceRange();
13821 Diag(VDecl->
getLocation(), diag::err_in_class_initializer_literal_type)
13822 << DclT <<
Init->getSourceRange()
13828 << DclT <<
Init->getSourceRange();
13862 if (!InitType.
isNull() &&
13881 if (CXXDirectInit) {
13882 assert(
DirectInit &&
"Call-style initializer must be direct init.");
13893 DeclsToCheckForDeferredDiags.insert(VDecl);
13902 VarDecl *VD = dyn_cast<VarDecl>(
D);
13906 if (
auto *DD = dyn_cast<DecompositionDecl>(
D))
13907 for (
auto *BD : DD->bindings())
13908 BD->setInvalidDecl();
13922 diag::err_typecheck_decl_incomplete_type)) {
13929 diag::err_abstract_type_in_decl,
13944 if (
VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
13948 if (isa<DecompositionDecl>(RealDecl)) {
13949 Diag(Var->getLocation(), diag::err_decomp_decl_requires_init) << Var;
13950 Var->setInvalidDecl();
13964 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition() &&
13965 !Var->isThisDeclarationADemotedDefinition()) {
13966 if (Var->isStaticDataMember()) {
13971 Diag(Var->getLocation(),
13972 diag::err_constexpr_static_mem_var_requires_init)
13974 Var->setInvalidDecl();
13978 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
13979 Var->setInvalidDecl();
13986 if (!Var->isInvalidDecl() &&
13988 Var->getStorageClass() !=
SC_Extern && !Var->getInit()) {
13989 bool HasConstExprDefaultConstructor =
false;
13990 if (
CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
13991 for (
auto *Ctor : RD->ctors()) {
13992 if (Ctor->isConstexpr() && Ctor->getNumParams() == 0 &&
13993 Ctor->getMethodQualifiers().getAddressSpace() ==
13995 HasConstExprDefaultConstructor =
true;
13999 if (!HasConstExprDefaultConstructor) {
14000 Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
14001 Var->setInvalidDecl();
14006 if (!Var->isInvalidDecl() && RealDecl->
hasAttr<LoaderUninitializedAttr>()) {
14007 if (Var->getStorageClass() ==
SC_Extern) {
14008 Diag(Var->getLocation(), diag::err_loader_uninitialized_extern_decl)
14010 Var->setInvalidDecl();
14014 diag::err_typecheck_decl_incomplete_type)) {
14015 Var->setInvalidDecl();
14018 if (
CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
14019 if (!RD->hasTrivialDefaultConstructor()) {
14020 Diag(Var->getLocation(), diag::err_loader_uninitialized_trivial_ctor);
14021 Var->setInvalidDecl();
14031 Var->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion())
14038 if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
14054 !Var->hasLinkage() && !Var->isInvalidDecl() &&
14056 diag::err_typecheck_decl_incomplete_type))
14057 Var->setInvalidDecl();
14062 diag::err_abstract_type_in_decl,
14064 Var->setInvalidDecl();
14067 Diag(Var->getLocation(), diag::warn_private_extern);
14068 Diag(Var->getLocation(), diag::note_private_extern);
14072 !Var->isInvalidDecl())
14083 if (!Var->isInvalidDecl()) {
14087 Var->getLocation(), ArrayT->getElementType(),
14088 diag::err_array_incomplete_or_sizeless_type))
14089 Var->setInvalidDecl();
14090 }
else if (Var->getStorageClass() ==
SC_Static) {
14100 if (Var->isFirstDecl())
14102 diag::ext_typecheck_decl_incomplete_type);
14107 if (!Var->isInvalidDecl())
14115 if (Var->isConstexpr())
14116 Diag(Var->getLocation(), diag::err_constexpr_var_requires_const_init)
14119 Diag(Var->getLocation(),
14120 diag::err_typecheck_incomplete_array_needs_initializer);
14121 Var->setInvalidDecl();
14128 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
14129 << Var <<
SourceRange(Var->getLocation(), Var->getLocation());
14138 if (Var->isInvalidDecl())
14141 if (!Var->hasAttr<AliasAttr>()) {
14144 diag::err_typecheck_decl_incomplete_type)) {
14145 Var->setInvalidDecl();
14154 diag::err_abstract_type_in_decl,
14156 Var->setInvalidDecl();
14177 if (!CXXRecord->isPOD())
14211 }
else if (
Init.isInvalid()) {
14229 VarDecl *VD = dyn_cast<VarDecl>(
D);
14288 const char *PrevSpec;
14294 D.SetIdentifier(Ident, IdentLoc);
14295 D.takeAttributes(Attrs);
14300 cast<VarDecl>(Var)->setCXXForRangeDecl(
true);
14308 if (var->isInvalidDecl())
return;
14315 if (var->getTypeSourceInfo()->getType()->isBlockPointerType() &&
14317 Diag(var->getLocation(), diag::err_opencl_invalid_block_declaration)
14319 var->setInvalidDecl();
14327 var->hasLocalStorage()) {
14328 switch (var->getType().getObjCLifetime()) {
14341 if (var->hasLocalStorage() &&
14350 if (var->isThisDeclarationADefinition() &&
14351 var->getDeclContext()->getRedeclContext()->isFileContext() &&
14352 var->isExternallyVisible() && var->hasLinkage() &&
14353 !var->isInline() && !var->getDescribedVarTemplate() &&
14355 !isa<VarTemplatePartialSpecializationDecl>(var) &&
14357 !
getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
14358 var->getLocation())) {
14360 VarDecl *prev = var->getPreviousDecl();
14365 Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var;
14366 Diag(var->getTypeSpecStartLoc(), diag::note_static_for_internal_linkage)
14372 std::optional<bool> CacheHasConstInit;
14373 const Expr *CacheCulprit =
nullptr;
14374 auto checkConstInit = [&]()
mutable {
14375 if (!CacheHasConstInit)
14376 CacheHasConstInit = var->getInit()->isConstantInitializer(
14377 Context, var->getType()->isReferenceType(), &CacheCulprit);
14378 return *CacheHasConstInit;
14382 if (var->getType().isDestructedType()) {
14386 Diag(var->getLocation(), diag::err_thread_nontrivial_dtor);
14388 Diag(var->getLocation(), diag::note_use_thread_local);
14390 if (!checkConstInit()) {
14398 Diag(var->getLocation(), diag::note_use_thread_local);
14404 if (!var->getType()->isStructureType() && var->hasInit() &&
14405 isa<InitListExpr>(var->getInit())) {
14406 const auto *ILE = cast<InitListExpr>(var->getInit());
14407 unsigned NumInits = ILE->getNumInits();
14409 for (
unsigned I = 0; I < NumInits; ++I) {
14410 const auto *
Init = ILE->getInit(I);
14413 const auto *SL = dyn_cast<StringLiteral>(
Init->IgnoreImpCasts());
14417 unsigned NumConcat = SL->getNumConcatenated();
14421 if (NumConcat == 2 && !SL->getBeginLoc().isMacroID()) {
14422 bool OnlyOneMissingComma =
true;
14423 for (
unsigned J = I + 1; J < NumInits; ++J) {
14424 const auto *
Init = ILE->getInit(J);
14427 const auto *SLJ = dyn_cast<StringLiteral>(
Init->IgnoreImpCasts());
14428 if (!SLJ || SLJ->getNumConcatenated() > 1) {
14429 OnlyOneMissingComma =
false;
14434 if (OnlyOneMissingComma) {
14436 for (
unsigned i = 0; i < NumConcat - 1; ++i)
14440 Diag(SL->getStrTokenLoc(1),
14441 diag::warn_concatenated_literal_array_init)
14443 Diag(SL->getBeginLoc(),
14444 diag::note_concatenated_string_literal_silence);
14455 if (var->hasAttr<BlocksAttr>())
14459 bool GlobalStorage = var->hasGlobalStorage();
14460 bool IsGlobal = GlobalStorage && !var->isStaticLocal();
14462 bool HasConstInit =
true;
14465 Diag(var->getLocation(), diag::err_constexpr_var_requires_const_init)
14470 !
type->isDependentType() &&
Init && !
Init->isValueDependent() &&
14471 (GlobalStorage || var->isConstexpr() ||
14472 var->mightBeUsableInConstantExpressions(
Context))) {
14484 HasConstInit = checkConstInit();
14488 if (HasConstInit) {
14489 (void)var->checkForConstantInitialization(Notes);
14491 }
else if (CacheCulprit) {
14492 Notes.emplace_back(CacheCulprit->
getExprLoc(),
14493 PDiag(diag::note_invalid_subexpr_in_const_expr));
14498 HasConstInit = var->checkForConstantInitialization(Notes);
14501 if (HasConstInit) {
14503 }
else if (var->isConstexpr()) {
14507 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
14508 diag::note_invalid_subexpr_in_const_expr) {
14509 DiagLoc = Notes[0].first;
14512 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
14513 << var <<
Init->getSourceRange();
14514 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
14515 Diag(Notes[I].first, Notes[I].second);
14516 }
else if (GlobalStorage && var->hasAttr<ConstInitAttr>()) {
14517 auto *
Attr = var->getAttr<ConstInitAttr>();
14518 Diag(var->getLocation(), diag::err_require_constant_init_failed)
14519 <<
Init->getSourceRange();
14522 for (
auto &it : Notes)
14523 Diag(it.first, it.second);
14524 }
else if (IsGlobal &&
14526 var->getLocation())) {
14535 if (!checkConstInit())
14536 Diag(var->getLocation(), diag::warn_global_constructor)
14537 <<
Init->getSourceRange();
14543 if (GlobalStorage && var->isThisDeclarationADefinition() &&
14549 std::optional<QualType::NonConstantStorageReason> Reason;
14550 if (HasConstInit &&
14551 !(Reason = var->getType().isNonConstantStorage(
Context,
true,
false))) {
14557 if (
const SectionAttr *SA = var->getAttr<SectionAttr>()) {
14561 }
else if (Stack->CurrentValue) {
14564 var->getType().isConstQualified()) {
14566 NonConstNonReferenceType) &&
14567 "This case should've already been handled elsewhere");
14568 Diag(var->getLocation(), diag::warn_section_msvc_compat)
14574 auto SectionName = Stack->CurrentValue->getString();
14575 var->addAttr(SectionAttr::CreateImplicit(
Context, SectionName,
14576 Stack->CurrentPragmaLocation,
14577 SectionAttr::Declspec_allocate));
14579 var->dropAttr<SectionAttr>();
14600 if (!
type->isDependentType())
14610 if (
auto *DD = dyn_cast<DecompositionDecl>(var))
14621 !FD->
hasAttr<DLLExportStaticLocalAttr>() &&
14622 !FD->
hasAttr<DLLImportStaticLocalAttr>()) {
14631 auto *NewAttr = cast<InheritableAttr>(A->clone(
getASTContext()));
14632 NewAttr->setInherited(
true);
14634 }
else if (
Attr *A = FD->
getAttr<DLLExportStaticLocalAttr>()) {
14635 auto *NewAttr = DLLExportAttr::CreateImplicit(
getASTContext(), *A);
14636 NewAttr->setInherited(
true);
14641 if (!FD->
hasAttr<DLLExportAttr>())
14644 }
else if (
Attr *A = FD->
getAttr<DLLImportStaticLocalAttr>()) {
14645 auto *NewAttr = DLLImportAttr::CreateImplicit(
getASTContext(), *A);
14646 NewAttr->setInherited(
true);
14675 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
14683 VD->
addAttr(PragmaClangBSSSectionAttr::CreateImplicit(
14687 VD->
addAttr(PragmaClangDataSectionAttr::CreateImplicit(
14691 VD->
addAttr(PragmaClangRodataSectionAttr::CreateImplicit(
14695 VD->
addAttr(PragmaClangRelroSectionAttr::CreateImplicit(
14700 if (
auto *DD = dyn_cast<DecompositionDecl>(ThisDecl)) {
14701 for (
auto *BD : DD->bindings()) {
14706 CheckInvalidBuiltinCountedByRef(VD->
getInit(), InitializerKind);
14728 if (
const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
14735 bool IsClassTemplateMember =
14736 isa<ClassTemplatePartialSpecializationDecl>(
Context) ||
14737 Context->getDescribedClassTemplate();
14740 IsClassTemplateMember
14741 ? diag::warn_attribute_dllimport_static_field_definition
14742 : diag::err_attribute_dllimport_static_field_definition);
14743 Diag(IA->getLocation(), diag::note_attribute);
14744 if (!IsClassTemplateMember)
14772 if (RetainAttr *
Attr = VD->
getAttr<RetainAttr>()) {
14787 if (VD->
isFileVarDecl() && !isa<VarTemplatePartialSpecializationDecl>(VD))
14792 if (!VD->
hasAttr<TypeTagForDatatypeAttr>() ||
14796 for (
const auto *I : ThisDecl->
specific_attrs<TypeTagForDatatypeAttr>()) {
14798 if (!MagicValueExpr) {
14801 std::optional<llvm::APSInt> MagicValueInt;
14803 Diag(I->getRange().getBegin(),
14804 diag::err_type_tag_for_datatype_not_ice)
14808 if (MagicValueInt->getActiveBits() > 64) {
14809 Diag(I->getRange().getBegin(),
14810 diag::err_type_tag_for_datatype_too_large)
14814 uint64_t MagicValue = MagicValueInt->getZExtValue();
14817 I->getMatchingCType(),
14818 I->getLayoutCompatible(),
14819 I->getMustBeNull());
14824 auto *VD = dyn_cast<VarDecl>(DD);
14825 return VD && !VD->getType()->hasAutoForTrailingReturnType();
14837 bool DiagnosedMultipleDecomps =
false;
14839 bool DiagnosedNonDeducedAuto =
false;
14841 for (
Decl *
D : Group) {
14846 if (
auto *VD = dyn_cast<VarDecl>(
D);
14847 LangOpts.OpenMP && VD && VD->hasAttr<OMPDeclareTargetDeclAttr>() &&
14848 VD->hasGlobalStorage())
14852 if (
auto *DD = dyn_cast<DeclaratorDecl>(
D)) {
14853 if (!FirstDeclaratorInGroup)
14854 FirstDeclaratorInGroup = DD;
14855 if (!FirstDecompDeclaratorInGroup)
14856 FirstDecompDeclaratorInGroup = dyn_cast<DecompositionDecl>(
D);
14859 FirstNonDeducedAutoInGroup = DD;
14861 if (FirstDeclaratorInGroup != DD) {
14864 if (FirstDecompDeclaratorInGroup && !DiagnosedMultipleDecomps) {
14866 diag::err_decomp_decl_not_alone)
14868 << DD->getSourceRange();
14869 DiagnosedMultipleDecomps =
true;
14875 if (FirstNonDeducedAutoInGroup && !DiagnosedNonDeducedAuto) {
14877 diag::err_auto_non_deduced_not_alone)
14878 << FirstNonDeducedAutoInGroup->
getType()
14881 << DD->getSourceRange();
14882 DiagnosedNonDeducedAuto =
true;
14887 Decls.push_back(
D);
14893 if (FirstDeclaratorInGroup && !Tag->hasNameForLinkage() &&
14907 if (Group.size() > 1) {
14909 VarDecl *DeducedDecl =
nullptr;
14910 for (
unsigned i = 0, e = Group.size(); i != e; ++i) {
14911 VarDecl *
D = dyn_cast<VarDecl>(Group[i]);
14914 DeducedType *DT =
D->getType()->getContainedDeducedType();
14921 auto *AT = dyn_cast<AutoType>(DT);
14923 diag::err_auto_different_deductions)
14924 << (AT ? (
unsigned)AT->getKeyword() : 3) << Deduced
14926 <<
D->getDeclName();
14949 if (Group.empty() || !Group[0])
14953 Group[0]->getLocation()) &&
14955 Group[0]->getLocation()))
14958 if (Group.size() >= 2) {
14966 Decl *MaybeTagDecl = Group[0];
14967 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
14968 Group = Group.slice(1);
14985 if (
D.getCXXScopeSpec().isSet()) {
14986 Diag(
D.getIdentifierLoc(), diag::err_qualified_param_declarator)
14987 <<
D.getCXXScopeSpec().getRange();
15003 Diag(
D.getIdentifierLoc(), diag::err_bad_parameter_name)
15010 Diag(
D.getIdentifierLoc(), diag::err_bad_parameter_name_template_id);
15017 if (!ExplicitThisLoc.
isValid())
15020 "explicit parameter in non-cplusplus mode");
15022 S.
Diag(ExplicitThisLoc, diag::err_cxx20_deducing_this)
15023 <<
P->getSourceRange();
15027 if (
P->isParameterPack()) {
15028 S.
Diag(
P->getBeginLoc(), diag::err_explicit_object_parameter_pack)
15029 <<
P->getSourceRange();
15032 P->setExplicitObjectParameterLoc(ExplicitThisLoc);
15034 LSI->ExplicitObjectParameter =
P;
15057 ? diag::ext_register_storage_class
15058 : diag::warn_deprecated_register)
15062 D.getNumTypeObjects() == 0) {
15064 diag::err_invalid_storage_class_in_func_decl)
15066 D.getMutableDeclSpec().ClearStorageClassSpecs();
15073 diag::err_invalid_storage_class_in_func_decl);
15074 D.getMutableDeclSpec().ClearStorageClassSpecs();
15085 << 0 <<
static_cast<int>(
D.getDeclSpec().getConstexprSpecifier());
15098 RedeclarationKind::ForVisibleRedeclaration);
15106 PrevDecl =
nullptr;
15108 if (PrevDecl && S->isDeclScope(PrevDecl)) {
15109 Diag(
D.getIdentifierLoc(), diag::err_param_redefinition) << II;
15113 D.SetIdentifier(
nullptr,
D.getIdentifierLoc());
15114 D.setInvalidType(
true);
15124 D.getIdentifierLoc(), II, parmDeclType, TInfo, SC);
15126 if (
D.isInvalidType())
15131 assert(S->isFunctionPrototypeScope());
15132 assert(S->getFunctionPrototypeDepth() >= 1);
15134 S->getNextFunctionPrototypeIndex());
15143 if (
D.getDeclSpec().isModulePrivateSpecified())
15145 << 1 << New <<
SourceRange(
D.getDeclSpec().getModulePrivateSpecLoc())
15148 if (New->
hasAttr<BlocksAttr>()) {
15180 !
Parameter->getIdentifier()->isPlaceholder()) {
15181 Diag(
Parameter->getLocation(), diag::warn_unused_parameter)
15189 if (
LangOpts.NumLargeByValueCopy == 0)
15196 if (Size >
LangOpts.NumLargeByValueCopy)
15207 if (Size >
LangOpts.NumLargeByValueCopy)
15228 if (!
T.isConstQualified()) {
15232 NameLoc, diag::err_arc_array_param_no_ownership,
T,
false));
15234 Diag(NameLoc, diag::err_arc_array_param_no_ownership)
15246 TSInfo, SC,
nullptr);
15253 CSI->LocalPacks.push_back(New);
15266 diag::err_object_cannot_be_passed_returned_by_value) << 1 <<
T
15285 Diag(NameLoc, diag::err_arg_with_address_space);
15313 for (
int i = FTI.
NumParams; i != 0; ) {
15318 llvm::raw_svector_ostream(Code)
15329 const char* PrevSpec;
15350 assert(
D.isFunctionDeclarator() &&
"Not a function declarator!");
15361 if (
LangOpts.OpenMP &&
OpenMP().isInOpenMPDeclareVariantScope())
15363 ParentScope,
D, TemplateParameterLists, Bases);
15369 if (!Bases.empty())
15386 if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
15389 PossiblePrototype = Prev;
15407 if (isa<CXXMethodDecl>(FD))
15413 if (II->isStr(
"main") || II->isStr(
"efi_main"))
15432 if (FD->
hasAttr<OpenCLKernelAttr>())
15486 Definition->getNumTemplateParameterLists())) {
15489 if (
auto *TD =
Definition->getDescribedFunctionTemplate())
15502 Diag(
Definition->getLocation(), diag::note_previous_definition);
15511 LSI->
Lambda = LambdaClass;
15550 for (
const auto &
C : LambdaClass->
captures()) {
15551 if (
C.capturesVariable()) {
15555 const bool ByRef =
C.getCaptureKind() ==
LCK_ByRef;
15557 true,
C.getLocation(),
15558 C.isPackExpansion()
15560 I->getType(),
false);
15562 }
else if (
C.capturesThis()) {
15588 FD = FunTmpl->getTemplatedDecl();
15590 FD = cast<FunctionDecl>(
D);
15615 if (
const auto *
Attr = FD->
getAttr<AliasAttr>()) {
15620 if (
const auto *
Attr = FD->
getAttr<IFuncAttr>()) {
15625 if (
const auto *
Attr = FD->
getAttr<TargetVersionAttr>()) {
15628 !
Attr->isDefaultVersion()) {
15637 if (
auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
15639 Ctor->isDefaultConstructor() &&
15682 "There should be an active template instantiation on the stack "
15683 "when instantiating a generic lambda!");
15709 diag::err_func_def_incomplete_result) ||
15711 diag::err_abstract_type_in_decl,
15727 auto *NonParmDecl = dyn_cast<NamedDecl>(NPD);
15730 assert(!isa<ParmVarDecl>(NonParmDecl) &&
15731 "parameters should not be in newly created FD yet");
15734 if (NonParmDecl->getDeclName())
15739 if (
auto *ED = dyn_cast<EnumDecl>(NonParmDecl)) {
15740 for (
auto *EI : ED->enumerators())
15748 Param->setOwningFunction(FD);
15751 if (Param->getIdentifier() && FnBodyScope) {
15780 assert(!FD->
hasAttr<DLLExportAttr>());
15781 Diag(FD->
getLocation(), diag::err_attribute_dllimport_function_definition);
15806 if (
auto *TD = dyn_cast<FunctionTemplateDecl>(FD))
15807 FD = TD->getTemplatedDecl();
15808 if (FD && FD->
hasAttr<OptimizeNoneAttr>()) {
15820 for (
unsigned I = 0,
E =
Scope->Returns.size(); I !=
E; ++I) {
15821 if (
const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
15822 if (!NRVOCandidate->isNRVOVariable())
15830 if (
D.getDeclSpec().hasConstexprSpecifier())
15835 if (
D.getDeclSpec().hasAutoTypeSpec()) {
15838 if (
D.getNumTypeObjects()) {
15839 const auto &Outer =
D.getTypeObject(
D.getNumTypeObjects() - 1);
15841 Outer.Fun.hasTrailingReturnType()) {
15859 if (FD->isConstexpr())
15864 if (FD->getReturnType()->getContainedDeducedType())
15874 FD->setHasSkippedBody();
15896 bool IsLambda =
false;
15900 llvm::DenseMap<const BlockDecl *, bool> EscapeInfo;
15902 auto IsOrNestedInEscapingBlock = [&](
const BlockDecl *BD) {
15903 if (
auto It = EscapeInfo.find(BD); It != EscapeInfo.end())
15913 CurBD = CurBD->getParent()->getInnermostBlockDecl();
15916 return EscapeInfo[BD] = R;
15921 for (
const std::pair<SourceLocation, const BlockDecl *> &
P :
15923 if (IsOrNestedInEscapingBlock(
P.second))
15924 S.
Diag(
P.first, diag::warn_implicitly_retains_self)
15929 return isa<CXXMethodDecl>(FD) && FD->
param_empty() &&
15939 methodHasName(FD,
"get_return_object_on_allocation_failure");
15949 if (!FD->
hasAttr<CoroWrapperAttr>())
15954 bool IsInstantiation) {
15975 SYCLKernelEntryPointAttr *SKEPAttr =
15976 FD->
getAttr<SYCLKernelEntryPointAttr>();
15978 Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid)
15980 SKEPAttr->setInvalidAttr();
15982 Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid)
15984 SKEPAttr->setInvalidAttr();
15986 Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid)
15988 SKEPAttr->setInvalidAttr();
15989 }
else if (Body && isa<CXXTryStmt>(Body)) {
15990 Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid)
15992 SKEPAttr->setInvalidAttr();
15995 if (Body && !FD->
isTemplated() && !SKEPAttr->isInvalidAttr()) {
16036 Expr *Dummy =
nullptr;
16047 if (LSI->HasImplicitReturnType) {
16054 LSI->ReturnType.isNull() ?
Context.
VoidTy : LSI->ReturnType;
16059 Proto->getExtProtoInfo()));
16087 dyn_cast<CXXDestructorDecl>(FD))
16107 if (PossiblePrototype) {
16111 TypeLoc TL = TI->getTypeLoc();
16114 diag::note_declaration_not_a_prototype)
16117 FTL.getRParenLoc(),
"void")
16124 std::pair<FileID, unsigned> LocInfo =
SM.getDecomposedLoc(
Loc);
16125 if (LocInfo.first.isInvalid())
16129 StringRef Buffer =
SM.getBufferData(LocInfo.first, &
Invalid);
16133 if (LocInfo.second > Buffer.size())
16136 const char *LexStart = Buffer.data() + LocInfo.second;
16137 StringRef StartTok(LexStart, Buffer.size() - LocInfo.second);
16139 return StartTok.consume_front(
"const") &&
16141 StartTok.starts_with(
"/*") || StartTok.starts_with(
"//"));
16144 auto findBeginLoc = [&]() {
16160 diag::note_static_for_internal_linkage)
16171 if (!PossiblePrototype)
16217 if (PossiblePrototype)
16219 diag::warn_non_prototype_changes_behavior)
16226 if (
const auto *CmpndBody = dyn_cast<CompoundStmt>(Body))
16227 if (!CmpndBody->body_empty())
16228 Diag(CmpndBody->body_front()->getBeginLoc(),
16229 diag::warn_dispatch_body_ignored);
16231 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
16256 "Function parsing confused");
16257 }
else if (
ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
16269 << MD->getSelector().getAsString();
16274 bool isDesignated =
16275 MD->isDesignatedInitializerForTheInterface(&InitMethod);
16276 assert(isDesignated && InitMethod);
16277 (void)isDesignated;
16280 auto IFace = MD->getClassInterface();
16283 auto SuperD = IFace->getSuperClass();
16293 diag::warn_objc_designated_init_missing_super_call);
16295 diag::note_objc_designated_init_marked_here);
16303 diag::warn_objc_secondary_init_missing_init_call);
16319 "This should only be set for ObjC methods, which should have been "
16320 "handled in the block above.");
16327 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
16335 if (!
Destructor->getParent()->isDependentType())
16353 ActivePolicy = &WP;
16356 if (!IsInstantiation && FD &&
16362 if (FD && FD->
hasAttr<NakedAttr>()) {
16366 bool RegisterVariables =
false;
16367 if (
auto *DS = dyn_cast<DeclStmt>(S)) {
16368 for (
const auto *
Decl : DS->decls()) {
16369 if (
const auto *Var = dyn_cast<VarDecl>(
Decl)) {
16370 RegisterVariables =
16371 Var->hasAttr<AsmLabelAttr>() && !Var->hasInit();
16372 if (!RegisterVariables)
16377 if (RegisterVariables)
16379 if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
16380 Diag(S->getBeginLoc(), diag::err_non_asm_stmt_in_naked_function);
16381 Diag(FD->
getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
16390 "Leftover temporaries in function");
16392 "Unaccounted cleanups in function");
16394 "Leftover expressions for odr-use checking");
16400 if (!IsInstantiation)
16417 DeclsToCheckForDeferredDiags.insert(FD);
16432 D = TD->getTemplatedDecl();
16437 if (Method->isStatic())
16445 "Implicit function declarations aren't allowed in this language mode");
16452 Scope *BlockScope = S;
16460 Scope *ContextScope = BlockScope;
16464 ContextScope = ContextScope->
getParent();
16480 if (!isa<FunctionDecl>(ExternCPrev) ||
16482 cast<FunctionDecl>(ExternCPrev)->getType(),
16484 Diag(
Loc, diag::ext_use_out_of_scope_declaration)
16487 return ExternCPrev;
16493 if (II.
getName().starts_with(
"__builtin_"))
16494 diag_id = diag::warn_builtin_unknown;
16497 diag_id = diag::ext_implicit_function_decl_c99;
16499 diag_id = diag::warn_implicit_function_decl;
16507 if (S && !ExternCPrev &&
16530 return ExternCPrev;
16540 assert(!Error &&
"Error setting up implicit decl!");
16562 D.SetIdentifier(&II,
Loc);
16582 std::optional<unsigned> AlignmentParam;
16583 bool IsNothrow =
false;
16595 if (!IsNothrow && !FD->
hasAttr<ReturnsNonNullAttr>() &&
16613 if (!FD->
hasAttr<AllocSizeAttr>()) {
16614 FD->
addAttr(AllocSizeAttr::CreateImplicit(
16625 if (AlignmentParam && !FD->
hasAttr<AllocAlignAttr>()) {
16626 FD->
addAttr(AllocAlignAttr::CreateImplicit(
16650 unsigned FormatIdx;
16653 if (!FD->
hasAttr<FormatAttr>()) {
16654 const char *fmt =
"printf";
16656 if (FormatIdx < NumParams &&
16662 HasVAListArg ? 0 : FormatIdx+2,
16668 if (!FD->
hasAttr<FormatAttr>())
16672 HasVAListArg ? 0 : FormatIdx+2,
16678 if (!FD->
hasAttr<CallbackAttr>() &&
16680 FD->
addAttr(CallbackAttr::CreateImplicit(
16686 bool NoExceptions =
16688 bool ConstWithoutErrnoAndExceptions =
16690 bool ConstWithoutExceptions =
16692 if (!FD->
hasAttr<ConstAttr>() &&
16693 (ConstWithoutErrnoAndExceptions || ConstWithoutExceptions) &&
16694 (!ConstWithoutErrnoAndExceptions ||
16696 (!ConstWithoutExceptions || NoExceptions))
16703 if ((Trip.isGNUEnvironment() || Trip.isOSMSVCRT()) &&
16705 switch (BuiltinID) {
16706 case Builtin::BI__builtin_fma:
16707 case Builtin::BI__builtin_fmaf:
16708 case Builtin::BI__builtin_fmal:
16709 case Builtin::BIfma:
16710 case Builtin::BIfmaf:
16711 case Builtin::BIfmal:
16720 !FD->
hasAttr<ReturnsTwiceAttr>())
16730 !FD->
hasAttr<CUDADeviceAttr>() && !FD->
hasAttr<CUDAHostAttr>()) {
16742 switch (BuiltinID) {
16743 case Builtin::BImemalign:
16744 case Builtin::BIaligned_alloc:
16745 if (!FD->
hasAttr<AllocAlignAttr>())
16754 switch (BuiltinID) {
16755 case Builtin::BIcalloc:
16756 FD->
addAttr(AllocSizeAttr::CreateImplicit(
16759 case Builtin::BImemalign:
16760 case Builtin::BIaligned_alloc:
16761 case Builtin::BIrealloc:
16765 case Builtin::BImalloc:
16785 if (!FPT || FPT->getExceptionSpecType() ==
EST_None)
16801 if (Name->isStr(
"asprintf") || Name->isStr(
"vasprintf")) {
16804 if (!FD->
hasAttr<FormatAttr>())
16807 Name->isStr(
"vasprintf") ? 0 : 3,
16811 if (Name->isStr(
"__CFStringMakeConstantString")) {
16814 if (!FD->
hasAttr<FormatArgAttr>())
16822 assert(
D.getIdentifier() &&
"Wrong callback for declspec without declarator");
16823 assert(!
T.isNull() &&
"GetTypeForDeclarator() returned null type");
16826 assert(
D.isInvalidType() &&
"no declarator info for valid type");
16833 D.getIdentifierLoc(),
D.getIdentifier(), TInfo);
16836 if (
D.isInvalidType()) {
16841 if (
D.getDeclSpec().isModulePrivateSpecified()) {
16845 <<
SourceRange(
D.getDeclSpec().getModulePrivateSpecLoc())
16847 D.getDeclSpec().getModulePrivateSpecLoc());
16858 switch (
D.getDeclSpec().getTypeSpecType()) {
16864 TagDecl *tagFromDeclSpec = cast<TagDecl>(
D.getDeclSpec().getRepAsDecl());
16886 if (BT->isInteger())
16889 return Diag(UnderlyingLoc, diag::err_enum_invalid_underlying)
16894 QualType EnumUnderlyingTy,
bool IsFixed,
16896 if (IsScoped != Prev->
isScoped()) {
16897 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
16903 if (IsFixed && Prev->
isFixed()) {
16909 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
16915 }
else if (IsFixed != Prev->
isFixed()) {
16916 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
16938 default: llvm_unreachable(
"Invalid tag kind for redecl diagnostic!");
16954 if (isa<TypedefDecl>(PrevDecl))
16956 else if (isa<TypeAliasDecl>(PrevDecl))
16958 else if (isa<ClassTemplateDecl>(PrevDecl))
16960 else if (isa<TypeAliasTemplateDecl>(PrevDecl))
16962 else if (isa<TemplateTemplateParmDecl>(PrevDecl))
16974 llvm_unreachable(
"invalid TTK");
17013 if (IsIgnoredLoc(NewTagLoc))
17016 auto IsIgnored = [&](
const TagDecl *Tag) {
17017 return IsIgnoredLoc(Tag->getLocation());
17034 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
17042 if (isDefinition) {
17050 bool previousMismatch =
false;
17052 if (I->getTagKind() !=
NewTag) {
17057 if (!previousMismatch) {
17058 previousMismatch =
true;
17059 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
17063 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
17076 if (PrevDef && IsIgnored(PrevDef))
17080 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
17087 Diag(NewTagLoc, diag::note_struct_class_suggestion)
17117 if (!Namespace || Namespace->isAnonymousNamespace())
17120 Namespaces.push_back(II);
17123 if (Lookup == Namespace)
17130 llvm::raw_svector_ostream OS(Insertion);
17133 std::reverse(Namespaces.begin(), Namespaces.end());
17134 for (
auto *II : Namespaces)
17135 OS << II->getName() <<
"::";
17148 if (OldDC->
Equals(NewDC))
17167 bool ScopedEnumUsesClassTag,
TypeResult UnderlyingType,
17168 bool IsTypeSpecifier,
bool IsTemplateParamOrArg,
17173 "Nameless record must be a definition!");
17178 bool ScopedEnum = ScopedEnumKWLoc.
isValid();
17181 bool isMemberSpecialization =
false;
17187 if (TemplateParameterLists.size() > 0 ||
17191 KWLoc, NameLoc, SS,
nullptr, TemplateParameterLists,
17208 !isMemberSpecialization)
17209 Diag(SS.
getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
17212 if (TemplateParams) {
17214 Diag(KWLoc, diag::err_enum_template);
17218 if (TemplateParams->
size() > 0) {
17227 S, TagSpec, TUK, KWLoc, SS, Name, NameLoc, Attrs, TemplateParams,
17228 AS, ModulePrivateLoc,
17230 TemplateParameterLists.data(), SkipBody);
17236 isMemberSpecialization =
true;
17240 if (!TemplateParameterLists.empty() && isMemberSpecialization &&
17259 ScopedEnum ?
SourceRange(KWLoc, ScopedEnumKWLoc) : KWLoc);
17260 assert(ScopedEnum || !ScopedEnumUsesClassTag);
17261 Diag(KWLoc, diag::note_enum_friend)
17262 << (ScopedEnum + ScopedEnumUsesClassTag);
17268 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
17269 bool IsFixed = !UnderlyingType.
isUnset() || ScopedEnum;
17272 if (UnderlyingType.
isInvalid() || (!UnderlyingType.
get() && ScopedEnum)) {
17276 }
else if (UnderlyingType.
get()) {
17281 EnumUnderlying = TI;
17303 bool isStdBadAlloc =
false;
17304 bool isStdAlignValT =
false;
17308 Redecl = RedeclarationKind::NotForRedeclaration;
17313 auto createTagFromNewDecl = [&]() ->
TagDecl * {
17323 ScopedEnum, ScopedEnumUsesClassTag, IsFixed);
17327 if (EnumUnderlying) {
17328 EnumDecl *ED = cast<EnumDecl>(New);
17329 if (
TypeSourceInfo *TI = dyn_cast<TypeSourceInfo *>(EnumUnderlying))
17343 if (
RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
17370 goto CreateNewDecl;
17378 IsDependent =
true;
17407 if (
Previous.wasNotFoundInCurrentInstantiation() &&
17409 IsDependent =
true;
17414 Diag(NameLoc, diag::err_not_tag_in_scope)
17415 << llvm::to_underlying(Kind) << Name << DC << SS.
getRange();
17418 goto CreateNewDecl;
17466 bool FriendSawTagOutsideEnclosingNamespace =
false;
17473 FriendSawTagOutsideEnclosingNamespace =
true;
17482 if (
Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
17484 Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
17498 while (isa<RecordDecl, EnumDecl, ObjCContainerDecl>(SearchDC))
17504 while (isa<ObjCContainerDecl>(SearchDC))
17510 while (isa<ObjCContainerDecl>(SearchDC))
17515 Previous.getFoundDecl()->isTemplateParameter()) {
17524 if (Name->isStr(
"bad_alloc")) {
17526 isStdBadAlloc =
true;
17533 }
else if (Name->isStr(
"align_val_t")) {
17534 isStdAlignValT =
true;
17546 IsTemplateParamOrArg)) {
17547 if (
Invalid)
goto CreateNewDecl;
17631 TagDecl *Tag = TT->getDecl();
17632 if (Tag->getDeclName() == Name &&
17633 Tag->getDeclContext()->getRedeclContext()
17634 ->Equals(TD->getDeclContext()->getRedeclContext())) {
17647 if (
auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
17648 auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
17651 isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) &&
17653 *
this, OldTag->getDeclContext(), SearchDC))) {
17654 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
17655 Diag(Shadow->getTargetDecl()->getLocation(),
17656 diag::note_using_decl_target);
17657 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
17661 goto CreateNewDecl;
17665 if (
TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
17671 SS.
isNotEmpty() || isMemberSpecialization)) {
17677 bool SafeToContinue =
17680 if (SafeToContinue)
17681 Diag(KWLoc, diag::err_use_with_wrong_tag)
17684 PrevTagDecl->getKindName());
17686 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
17687 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
17689 if (SafeToContinue)
17690 Kind = PrevTagDecl->getTagKind();
17701 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
17703 return PrevTagDecl;
17707 dyn_cast_if_present<TypeSourceInfo *>(EnumUnderlying))
17708 EnumUnderlyingTy = TI->getType().getUnqualifiedType();
17709 else if (
const Type *
T =
17710 dyn_cast_if_present<const Type *>(EnumUnderlying))
17717 ScopedEnum, EnumUnderlyingTy,
17718 IsFixed, PrevEnum))
17727 S->isDeclScope(PrevDecl)) {
17728 Diag(NameLoc, diag::ext_member_redeclared);
17729 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
17736 if (!Attrs.
empty()) {
17740 (PrevTagDecl->getFriendObjectKind() ==
17753 return PrevTagDecl;
17758 return PrevTagDecl;
17764 if (
NamedDecl *Def = PrevTagDecl->getDefinition()) {
17768 bool IsExplicitSpecializationAfterInstantiation =
false;
17769 if (isMemberSpecialization) {
17771 IsExplicitSpecializationAfterInstantiation =
17772 RD->getTemplateSpecializationKind() !=
17774 else if (
EnumDecl *ED = dyn_cast<EnumDecl>(Def))
17775 IsExplicitSpecializationAfterInstantiation =
17776 ED->getTemplateSpecializationKind() !=
17796 SkipBody->
New = createTagFromNewDecl();
17806 }
else if (!IsExplicitSpecializationAfterInstantiation) {
17810 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
17812 Diag(NameLoc, diag::err_redefinition) << Name;
17814 NameLoc.
isValid() ? NameLoc : KWLoc);
17826 if (TD->isBeingDefined()) {
17827 Diag(NameLoc, diag::err_nested_redefinition) << Name;
17828 Diag(PrevTagDecl->getLocation(),
17829 diag::note_previous_definition);
17844 SearchDC = PrevTagDecl->getDeclContext();
17872 Diag(NameLoc, diag::err_tag_reference_non_tag)
17873 << PrevDecl << NTK << llvm::to_underlying(Kind);
17879 SS.
isNotEmpty() || isMemberSpecialization)) {
17885 Diag(NameLoc, diag::err_tag_reference_conflict) << NTK;
17891 }
else if (
TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
17893 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
17894 Diag(NameLoc, diag::err_tag_definition_of_typedef)
17895 << Name << Kind << TND->getUnderlyingType();
17903 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
17919 PrevDecl = cast<TagDecl>(
Previous.getFoundDecl());
17935 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
17936 ScopedEnumUsesClassTag, IsFixed);
17944 if (IsFixed && cast<EnumDecl>(New)->isFixed()) {
17948 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->
getDefinition())) {
17949 Diag(
Loc, diag::ext_forward_ref_enum_def)
17953 unsigned DiagID = diag::ext_forward_ref_enum;
17955 DiagID = diag::ext_ms_forward_ref_enum;
17957 DiagID = diag::err_forward_ref_enum;
17962 if (EnumUnderlying) {
17963 EnumDecl *ED = cast<EnumDecl>(New);
17964 if (
TypeSourceInfo *TI = dyn_cast<TypeSourceInfo *>(EnumUnderlying))
17972 assert(ED->
isComplete() &&
"enum with type should be complete");
17982 cast_or_null<CXXRecordDecl>(PrevDecl));
17988 cast_or_null<RecordDecl>(PrevDecl));
18000 (IsTypeSpecifier || IsTemplateParamOrArg) &&
18022 isMemberSpecialization))
18026 if (TemplateParameterLists.size() > 0) {
18034 if (
RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
18050 if (ModulePrivateLoc.
isValid()) {
18051 if (isMemberSpecialization)
18076 Diag(
Loc, diag::err_type_defined_in_param_type)
18082 }
else if (!PrevDecl) {
18143 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(New)) {
18160 if (
auto RD = dyn_cast<RecordDecl>(New))
18163 }
else if (SkipBody && SkipBody->
ShouldSkip) {
18172 TagDecl *Tag = cast<TagDecl>(TagD);
18195 bool IsFinalSpelledSealed,
18203 if (!
Record->getIdentifier())
18211 IsFinalSpelledSealed
18212 ? FinalAttr::Keyword_sealed
18213 : FinalAttr::Keyword_final));
18232 "Broken injected-class-name");
18238 TagDecl *Tag = cast<TagDecl>(TagD);
18239 Tag->setBraceRange(BraceRange);
18242 if (Tag->isBeingDefined()) {
18243 assert(Tag->isInvalidDecl() &&
"We should already have completed it");
18244 if (
RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
18248 if (
auto *RD = dyn_cast<CXXRecordDecl>(Tag)) {
18250 if (RD->
hasAttr<SYCLSpecialClassAttr>()) {
18252 assert(Def &&
"The record is expected to have a completed definition");
18253 unsigned NumInitMethods = 0;
18254 for (
auto *Method : Def->methods()) {
18255 if (!Method->getIdentifier())
18257 if (Method->getName() ==
"__init")
18260 if (NumInitMethods > 1 || !Def->hasInitMethod())
18261 Diag(RD->
getLocation(), diag::err_sycl_special_type_num_init_method);
18278 Tag->getDeclContext()->isFileContext())
18279 Tag->setTopLevelDeclInObjCContainer();
18282 if (!Tag->isInvalidDecl())
18293 const RecordDecl *RD = dyn_cast<RecordDecl>(Tag);
18297 if (llvm::any_of(RD->
fields(),
18298 [](
const FieldDecl *FD) { return FD->isBitField(); }))
18299 Diag(BraceRange.
getBegin(), diag::warn_pragma_align_not_xl_compatible);
18305 TagDecl *Tag = cast<TagDecl>(TagD);
18306 Tag->setInvalidDecl();
18309 if (Tag->isBeingDefined()) {
18310 if (
RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
18324 QualType FieldTy,
bool IsMsStruct,
18335 diag::err_field_incomplete_or_sizeless))
18338 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
18340 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
18351 llvm::APSInt
Value;
18355 BitWidth = ICE.
get();
18358 if (
Value == 0 && FieldName)
18359 return Diag(FieldLoc, diag::err_bitfield_has_zero_width)
18362 if (
Value.isSigned() &&
Value.isNegative()) {
18364 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
18366 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
18373 return Diag(FieldLoc, diag::err_bitfield_too_wide)
18380 bool BitfieldIsOverwide =
Value.ugt(TypeWidth);
18384 bool CStdConstraintViolation =
18386 bool MSBitfieldViolation =
18387 Value.ugt(TypeStorageSize) &&
18389 if (CStdConstraintViolation || MSBitfieldViolation) {
18390 unsigned DiagWidth =
18391 CStdConstraintViolation ? TypeWidth : TypeStorageSize;
18392 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_width)
18394 << !CStdConstraintViolation << DiagWidth;
18400 if (BitfieldIsOverwide && !FieldTy->
isBooleanType() && FieldName) {
18401 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_width)
18407 if (isa<ConstantExpr>(BitWidth))
18425 if (
D.isDecompositionDeclarator()) {
18434 if (II)
Loc =
D.getIdentifierLoc();
18443 D.setInvalidType();
18451 if (
D.getDeclSpec().isInlineSpecified())
18452 Diag(
D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
18454 if (
DeclSpec::TSCS TSCS =
D.getDeclSpec().getThreadStorageClassSpec())
18455 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
18456 diag::err_invalid_thread)
18462 RedeclarationKind::ForVisibleRedeclaration);
18464 switch (
Previous.getResultKind()) {
18471 PrevDecl =
Previous.getRepresentativeDecl();
18485 PrevDecl =
nullptr;
18489 PrevDecl =
nullptr;
18496 TSSL, AS, PrevDecl, &
D);
18499 Record->setInvalidDecl();
18501 if (
D.getDeclSpec().isModulePrivateSpecified())
18518 bool Mutable,
Expr *BitWidth,
18524 bool InvalidDecl =
false;
18525 if (
D) InvalidDecl =
D->isInvalidType();
18530 InvalidDecl =
true;
18536 bool isIncomplete =
18540 diag::err_field_incomplete_or_sizeless);
18541 if (isIncomplete) {
18543 Record->setInvalidDecl();
18544 InvalidDecl =
true;
18549 Record->setInvalidDecl();
18550 InvalidDecl =
true;
18558 Diag(
Loc, diag::err_field_with_address_space);
18559 Record->setInvalidDecl();
18560 InvalidDecl =
true;
18568 Diag(
Loc, diag::err_opencl_type_struct_or_union_field) <<
T;
18569 Record->setInvalidDecl();
18570 InvalidDecl =
true;
18575 "__cl_clang_bitfields",
LangOpts)) {
18576 Diag(
Loc, diag::err_opencl_bitfields);
18577 InvalidDecl =
true;
18583 T.hasQualifiers()) {
18584 InvalidDecl =
true;
18585 Diag(
Loc, diag::err_anon_bitfield_qualifiers);
18592 TInfo,
T,
Loc, diag::err_typecheck_field_variable_size))
18593 InvalidDecl =
true;
18598 diag::err_abstract_type_in_decl,
18600 InvalidDecl =
true;
18603 BitWidth =
nullptr;
18609 InvalidDecl =
true;
18610 BitWidth =
nullptr;
18615 if (!InvalidDecl && Mutable) {
18616 unsigned DiagID = 0;
18618 DiagID =
getLangOpts().MSVCCompat ? diag::ext_mutable_reference
18619 : diag::err_mutable_reference;
18620 else if (
T.isConstQualified())
18621 DiagID = diag::err_mutable_const;
18625 if (
D &&
D->getDeclSpec().getStorageClassSpecLoc().isValid())
18626 ErrLoc =
D->getDeclSpec().getStorageClassSpecLoc();
18627 Diag(ErrLoc, DiagID);
18628 if (DiagID != diag::ext_mutable_reference) {
18630 InvalidDecl =
true;
18642 BitWidth, Mutable, InitStyle);
18646 if (PrevDecl && !isa<TagDecl>(PrevDecl) &&
18648 Diag(
Loc, diag::err_duplicate_member) << II;
18654 if (
Record->isUnion()) {
18672 const bool HaveMSExt =
18677 HaveMSExt ? diag::ext_union_member_of_reference_type
18678 : diag::err_union_member_of_reference_type)
18698 if (
getLangOpts().ObjCAutoRefCount &&
ObjC().inferObjCARCLifetime(NewFD))
18701 if (
T.isObjCGCWeak())
18702 Diag(
Loc, diag::warn_attribute_weak_on_field);
18753 if (!FD->
hasAttr<UnavailableAttr>())
18755 UnavailableAttr::IR_ARCFieldWithOwnership,
Loc));
18763 ? diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member
18764 : diag::err_illegal_union_or_anon_struct_member)
18766 << llvm::to_underlying(member);
18781 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
18789 if (!CD->IsClassExtension())
18806 AllIvarDecls.push_back(Ivar);
18818 if (!
Record->hasUserDeclaredDestructor()) {
18826 if (
auto *DD = dyn_cast<CXXDestructorDecl>(
Decl)) {
18827 if (DD->isInvalidDecl())
18831 assert(DD->isIneligibleOrNotSelected() &&
"Selecting a destructor but a destructor was already selected.");
18845 Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(Best->Function));
18849 Msg = diag::err_ambiguous_destructor;
18854 Msg = diag::err_no_viable_destructor;
18865 Record->setInvalidDecl();
18872 Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(OCS.
begin()->Function));
18916 const Expr *Constraints = Method->getTrailingRequiresClause();
18918 SatisfactionStatus.push_back(
true);
18922 SatisfactionStatus.push_back(
false);
18924 SatisfactionStatus.push_back(Satisfaction.
IsSatisfied);
18928 for (
size_t i = 0; i < Methods.size(); i++) {
18929 if (!SatisfactionStatus[i])
18934 OrigMethod = cast<CXXMethodDecl>(MF);
18937 bool AnotherMethodIsMoreConstrained =
false;
18938 for (
size_t j = 0; j < Methods.size(); j++) {
18939 if (i == j || !SatisfactionStatus[j])
18943 OtherMethod = cast<CXXMethodDecl>(MF);
18950 if (!OtherConstraints)
18952 if (!Constraints) {
18953 AnotherMethodIsMoreConstrained =
true;
18958 AnotherMethodIsMoreConstrained)) {
18961 AnotherMethodIsMoreConstrained =
true;
18963 if (AnotherMethodIsMoreConstrained)
18968 if (!AnotherMethodIsMoreConstrained) {
18970 Record->addedEligibleSpecialMemberFunction(Method,
18971 1 << llvm::to_underlying(CSM));
18985 auto *MD = dyn_cast<CXXMethodDecl>(
Decl);
18987 auto *FTD = dyn_cast<FunctionTemplateDecl>(
Decl);
18989 MD = dyn_cast<CXXMethodDecl>(FTD->getTemplatedDecl());
18993 if (
auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
18994 if (CD->isInvalidDecl())
18996 if (CD->isDefaultConstructor())
18997 DefaultConstructors.push_back(MD);
18998 else if (CD->isCopyConstructor())
18999 CopyConstructors.push_back(MD);
19000 else if (CD->isMoveConstructor())
19001 MoveConstructors.push_back(MD);
19003 CopyAssignmentOperators.push_back(MD);
19005 MoveAssignmentOperators.push_back(MD);
19025 assert(EnclosingDecl &&
"missing record or interface decl");
19030 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
19034 case Decl::ObjCCategory:
19037 case Decl::ObjCImplementation:
19039 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
19045 CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(EnclosingDecl);
19049 unsigned NumNamedMembers = 0;
19051 for (
const auto *I :
Record->decls()) {
19052 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
19053 if (IFD->getDeclName())
19070 RecFields.push_back(FD);
19090 bool IsLastField = (i + 1 == Fields.end());
19099 (
Record || isa<ObjCContainerDecl>(EnclosingDecl))) {
19105 unsigned DiagID = 0;
19106 if (!
Record->isUnion() && !IsLastField) {
19109 << llvm::to_underlying(
Record->getTagKind());
19110 Diag((*(i + 1))->getLocation(), diag::note_next_field_declaration);
19114 }
else if (
Record->isUnion())
19116 ? diag::ext_flexible_array_union_ms
19117 : diag::ext_flexible_array_union_gnu;
19118 else if (NumNamedMembers < 1)
19120 ? diag::ext_flexible_array_empty_aggregate_ms
19121 : diag::ext_flexible_array_empty_aggregate_gnu;
19131 if (CXXRecord && CXXRecord->getNumVBases() != 0)
19145 Diag(FD->
getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
19152 Record->setHasFlexibleArrayMember(
true);
19161 diag::err_incomplete_type)
19164 diag::err_field_incomplete_or_sizeless))) {
19170 if (
Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
19173 Record->setHasFlexibleArrayMember(
true);
19174 if (!
Record->isUnion()) {
19189 if (isa<ObjCContainerDecl>(EnclosingDecl) &&
19191 diag::err_abstract_type_in_decl,
19196 if (
Record && FDTTy->getDecl()->hasObjectMember())
19197 Record->setHasObjectMember(
true);
19198 if (
Record && FDTTy->getDecl()->hasVolatileMember())
19199 Record->setHasVolatileMember(
true);
19218 FD->
addAttr(UnavailableAttr::CreateImplicit(
19219 Context,
"", UnavailableAttr::IR_ARCFieldWithOwnership,
19223 !
Record->hasObjectMember()) {
19226 Record->setHasObjectMember(
true);
19231 Record->setHasObjectMember(
true);
19234 Record->setHasObjectMember(
true);
19239 !shouldIgnoreForRecordTriviality(FD)) {
19242 Record->setNonTrivialToPrimitiveDefaultInitialize(
true);
19245 Record->setHasNonTrivialToPrimitiveDefaultInitializeCUnion(
true);
19249 Record->setNonTrivialToPrimitiveCopy(
true);
19251 Record->setHasNonTrivialToPrimitiveCopyCUnion(
true);
19253 if (FD->
hasAttr<ExplicitInitAttr>())
19254 Record->setHasUninitializedExplicitInitFields(
true);
19256 Record->setNonTrivialToPrimitiveDestroy(
true);
19257 Record->setParamDestroyedInCallee(
true);
19259 Record->setHasNonTrivialToPrimitiveDestructCUnion(
true);
19263 if (RT->getDecl()->getArgPassingRestrictions() ==
19265 Record->setArgPassingRestrictions(
19268 Record->setArgPassingRestrictions(
19273 Record->setHasVolatileMember(
true);
19281 bool Completed =
false;
19285 Parent->isTemplateParamScope())
19286 Record->setInvalidDecl();
19290 if (!CXXRecord->isInvalidDecl()) {
19293 I = CXXRecord->conversion_begin(),
19294 E = CXXRecord->conversion_end(); I !=
E; ++I)
19295 I.setAccess((*I)->getAccess());
19301 if (!CXXRecord->isDependentType()) {
19302 if (!CXXRecord->isInvalidDecl()) {
19306 if (CXXRecord->getNumVBases()) {
19308 CXXRecord->getFinalOverriders(FinalOverriders);
19310 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
19311 MEnd = FinalOverriders.end();
19314 SOEnd = M->second.end();
19315 SO != SOEnd; ++SO) {
19316 assert(SO->second.size() > 0 &&
19317 "Virtual function without overriding functions?");
19318 if (SO->second.size() == 1)
19325 Diag(
Record->getLocation(), diag::err_multiple_final_overriders)
19327 Diag(M->first->getLocation(),
19328 diag::note_overridden_virtual_function);
19330 OM = SO->second.begin(),
19331 OMEnd = SO->second.end();
19333 Diag(OM->Method->getLocation(), diag::note_final_overrider)
19334 << (
const NamedDecl *)M->first << OM->Method->getParent();
19336 Record->setInvalidDecl();
19339 CXXRecord->completeDefinition(&FinalOverriders);
19349 Record->completeDefinition();
19355 auto IsFunctionPointerOrForwardDecl = [&](
const Decl *
D) {
19356 const FieldDecl *FD = dyn_cast<FieldDecl>(
D);
19369 if (
const auto *TD = dyn_cast<TagDecl>(
D))
19370 return !TD->isCompleteDefinition();
19374 if (isa<PointerType>(FieldType)) {
19384 (
Record->hasAttr<RandomizeLayoutAttr>() ||
19385 (!
Record->hasAttr<NoRandomizeLayoutAttr>() &&
19386 llvm::all_of(
Record->decls(), IsFunctionPointerOrForwardDecl))) &&
19388 !
Record->isRandomized()) {
19392 Record->reorderDecls(NewDeclOrdering);
19397 auto *Dtor = CXXRecord->getDestructor();
19398 if (Dtor && Dtor->isImplicit() &&
19400 CXXRecord->setImplicitDestructorIsDeleted();
19405 if (
Record->hasAttrs()) {
19408 if (
const MSInheritanceAttr *IA =
Record->getAttr<MSInheritanceAttr>())
19410 IA->getRange(), IA->getBestCase(),
19411 IA->getInheritanceModel());
19417 bool CheckForZeroSize;
19419 CheckForZeroSize =
true;
19424 CXXRecord->getLexicalDeclContext()->isExternCContext() &&
19426 CXXRecord->isCLike();
19428 if (CheckForZeroSize) {
19429 bool ZeroSize =
true;
19430 bool IsEmpty =
true;
19431 unsigned NonBitFields = 0;
19434 (NonBitFields == 0 || ZeroSize) && I !=
E; ++I) {
19436 if (I->isUnnamedBitField()) {
19437 if (!I->isZeroLengthBitField())
19441 QualType FieldType = I->getType();
19453 diag::warn_zero_size_struct_union_in_extern_c :
19454 diag::warn_zero_size_struct_union_compat)
19455 << IsEmpty <<
Record->isUnion() << (NonBitFields > 1);
19462 Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union
19463 : diag::ext_no_named_members_in_struct_union)
19471 ID->setEndOfDefinitionLoc(RBrac);
19473 for (
unsigned i = 0, e = RecFields.size(); i != e; ++i) {
19475 ID->addDecl(ClsFields[i]);
19479 if (ID->getSuperClass())
19482 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
19483 assert(IMPDecl &&
"ActOnFields - missing ObjCImplementationDecl");
19484 for (
unsigned I = 0, N = RecFields.size(); I != N; ++I)
19490 IMPDecl->setIvarLBraceLoc(LBrac);
19491 IMPDecl->setIvarRBraceLoc(RBrac);
19493 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
19501 for (
unsigned i = 0, e = RecFields.size(); i != e; ++i) {
19505 Diag(ClsFields[i]->getLocation(),
19506 diag::err_duplicate_ivar_declaration);
19507 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
19513 Diag(ClsFields[i]->getLocation(),
19514 diag::err_duplicate_ivar_declaration);
19515 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
19521 CDecl->addDecl(ClsFields[i]);
19523 CDecl->setIvarLBraceLoc(LBrac);
19524 CDecl->setIvarRBraceLoc(RBrac);
19533 llvm::APSInt &
Value,
19536 "Integral type required!");
19539 if (
Value.isUnsigned() ||
Value.isNonNegative()) {
19542 return Value.getActiveBits() <= BitWidth;
19544 return Value.getSignificantBits() <= BitWidth;
19554 const unsigned NumTypes = 4;
19555 QualType SignedIntegralTypes[NumTypes] = {
19558 QualType UnsignedIntegralTypes[NumTypes] = {
19565 : UnsignedIntegralTypes;
19566 for (
unsigned I = 0; I != NumTypes; ++I)
19579 llvm::APSInt EnumVal(IntWidth);
19599 EltTy =
Enum->getIntegerType();
19606 Val = Converted.
get();
19613 if (
Enum->isComplete()) {
19614 EltTy =
Enum->getIntegerType();
19623 .isWindowsMSVCEnvironment()) {
19624 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
19626 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
19651 ? diag::warn_c17_compat_enum_value_not_int
19652 : diag::ext_c23_enum_value_not_int)
19654 << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
19666 if (
Enum->isDependentType())
19668 else if (!LastEnumConst) {
19677 if (
Enum->isFixed()) {
19678 EltTy =
Enum->getIntegerType();
19687 EltTy = LastEnumConst->
getType();
19690 if (EnumVal < LastEnumConst->getInitVal()) {
19702 if (
T.isNull() ||
Enum->isFixed()) {
19706 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
19708 if (
Enum->isFixed())
19710 Diag(IdLoc, diag::err_enumerator_wrapped)
19714 Diag(IdLoc, diag::ext_enumerator_increment_too_large)
19737 ? diag::warn_c17_compat_enum_value_not_int
19738 : diag::ext_c23_enum_value_not_int)
19739 << 1 <<
toString(EnumVal, 10) << 1;
19744 : diag::ext_c23_enum_value_not_int)
19745 << 1 <<
toString(EnumVal, 10) << 1;
19772 auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl);
19776 EnumDecl *PrevED = cast<EnumDecl>(PrevECD->getDeclContext());
19780 Skip.Previous = Hidden;
19791 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
19793 cast_or_null<EnumConstantDecl>(lastEnumConst);
19802 RedeclarationKind::ForVisibleRedeclaration);
19810 PrevDecl =
nullptr;
19828 if (!TheEnumDecl->
isScoped() && isa<ValueDecl>(PrevDecl)) {
19836 "Received TagDecl when not in C++!");
19838 if (isa<EnumConstantDecl>(PrevDecl))
19839 Diag(IdLoc, diag::err_redefinition_of_enumerator) <<
Id;
19841 Diag(IdLoc, diag::err_redefinition) <<
Id;
19874 if (!BO->isAdditiveOp())
19882 InitExpr = BO->getLHS();
19886 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
19906 if (!
Enum->getIdentifier())
19910 if (
Enum->getNumPositiveBits() > 63 ||
Enum->getNumNegativeBits() > 64)
19919 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
19922 typedef std::unordered_map<int64_t, DeclOrVector> ValueToVectorMap;
19926 llvm::APSInt Val =
D->getInitVal();
19927 return Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue();
19930 DuplicatesVector DupVector;
19931 ValueToVectorMap EnumMap;
19935 for (
auto *Element : Elements) {
19949 EnumMap.insert({EnumConstantToKey(ECD), ECD});
19952 if (EnumMap.size() == 0)
19956 for (
auto *Element : Elements) {
19962 auto Iter = EnumMap.find(EnumConstantToKey(ECD));
19963 if (
Iter == EnumMap.end())
19966 DeclOrVector& Entry =
Iter->second;
19973 auto Vec = std::make_unique<ECDVector>();
19975 Vec->push_back(ECD);
19982 DupVector.emplace_back(std::move(Vec));
19986 ECDVector *Vec = cast<ECDVector *>(Entry);
19988 if (*Vec->begin() == ECD)
19991 Vec->push_back(ECD);
19995 for (
const auto &Vec : DupVector) {
19996 assert(Vec->size() > 1 &&
"ECDVector should have at least 2 elements.");
19999 auto *FirstECD = Vec->front();
20000 S.
Diag(FirstECD->getLocation(), diag::warn_duplicate_enum_values)
20001 << FirstECD <<
toString(FirstECD->getInitVal(), 10)
20002 << FirstECD->getSourceRange();
20006 for (
auto *ECD : llvm::drop_begin(*Vec))
20007 S.
Diag(ECD->getLocation(), diag::note_duplicate_element)
20008 << ECD <<
toString(ECD->getInitVal(), 10)
20009 << ECD->getSourceRange();
20014 bool AllowMask)
const {
20015 assert(ED->
isClosedFlag() &&
"looking for value in non-flag or open enum");
20018 auto R =
FlagBitsCache.insert(std::make_pair(ED, llvm::APInt()));
20019 llvm::APInt &FlagBits = R.first->second;
20023 const auto &EVal =
E->getInitVal();
20025 if (EVal.isPowerOf2())
20026 FlagBits = FlagBits.zext(EVal.getBitWidth()) | EVal;
20038 llvm::APInt FlagMask = ~FlagBits.zextOrTrunc(Val.getBitWidth());
20039 return !(FlagMask & Val) || (AllowMask && !(FlagMask & ~Val));
20051 if (
Enum->isDependentType()) {
20052 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
20054 cast_or_null<EnumConstantDecl>(Elements[i]);
20055 if (!ECD)
continue;
20066 unsigned NumNegativeBits = 0;
20067 unsigned NumPositiveBits = 0;
20068 bool MembersRepresentableByInt =
true;
20070 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
20072 cast_or_null<EnumConstantDecl>(Elements[i]);
20073 if (!ECD)
continue;
20078 if (InitVal.isUnsigned() || InitVal.isNonNegative()) {
20081 unsigned ActiveBits = InitVal.getActiveBits();
20082 NumPositiveBits = std::max({NumPositiveBits, ActiveBits, 1u});
20085 std::max(NumNegativeBits, (
unsigned)InitVal.getSignificantBits());
20087 MembersRepresentableByInt &=
20095 if (!NumPositiveBits && !NumNegativeBits)
20096 NumPositiveBits = 1;
20100 unsigned BestWidth;
20113 bool Packed =
Enum->hasAttr<PackedAttr>();
20121 if (
Enum->isComplete()) {
20122 BestType =
Enum->getIntegerType();
20126 BestPromotionType = BestType;
20131 Packed, NumNegativeBits, NumPositiveBits, BestType, BestPromotionType);
20134 Diag(
Enum->getLocation(), diag::ext_enum_too_large);
20139 for (
auto *
D : Elements) {
20140 auto *ECD = cast_or_null<EnumConstantDecl>(
D);
20141 if (!ECD)
continue;
20150 llvm::APSInt InitVal = ECD->getInitVal();
20158 MembersRepresentableByInt) {
20168 }
else if (ECD->getType() == BestType) {
20178 NewWidth = BestWidth;
20183 InitVal = InitVal.extOrTrunc(NewWidth);
20184 InitVal.setIsSigned(NewSign);
20185 ECD->setInitVal(
Context, InitVal);
20188 if (ECD->getInitExpr() &&
20191 Context, NewTy, CK_IntegralCast, ECD->getInitExpr(),
20199 ECD->setType(NewTy);
20202 Enum->completeDefinition(BestType, BestPromotionType,
20203 NumPositiveBits, NumNegativeBits);
20207 if (
Enum->isClosedFlag()) {
20208 for (
Decl *
D : Elements) {
20210 if (!ECD)
continue;
20213 if (InitVal != 0 && !InitVal.isPowerOf2() &&
20221 if (
Enum->hasAttrs())
20231 AsmString, StartLoc,
20247 D->setStmt(Statement);
20262 AsmLabelAttr *
Attr = AsmLabelAttr::CreateImplicit(
20269 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
20273 Diag(PrevDecl->
getLocation(), diag::warn_redefine_extname_not_applied)
20274 << (isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl;
20286 PrevDecl->
addAttr(WeakAttr::CreateImplicit(
Context, PragmaLoc));
20301 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
20302 if (!PrevDecl->
hasAttr<AliasAttr>())
20303 if (
NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
20312 assert(FD &&
"Expected non-null FunctionDecl");
20324 auto IsEmittedForExternalSymbol = [
this, FD]() {
20336 if (
LangOpts.OpenMPIsTargetDevice) {
20339 std::optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
20346 if (*DevTy == OMPDeclareTargetDeclAttr::DT_Host)
20350 if (
OpenMP().isInOpenMPDeclareTargetContext() || DevTy)
20351 if (IsEmittedForExternalSymbol())
20357 }
else if (
LangOpts.OpenMP > 45) {
20361 std::optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
20364 if (*DevTy == OMPDeclareTargetDeclAttr::DT_NoHost)
20383 if (IsEmittedForExternalSymbol())
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::@1727::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.
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 functions specific to ARM.
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 isMainVar(DeclarationName Name, VarDecl *VD)
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 checkHybridPatchableAttr(Sema &S, NamedDecl &ND)
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.
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 checkLifetimeBoundAttr(Sema &S, NamedDecl &ND)
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 unsigned propagateAttribute(ParmVarDecl *To, const ParmVarDecl *From, Sema &S)
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 checkInheritableAttr(Sema &S, NamedDecl &ND)
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 void emitReadOnlyPlacementAttrWarning(Sema &S, const VarDecl *VD)
static bool canRedefineFunction(const FunctionDecl *FD, const LangOptions &LangOpts)
canRedefineFunction - checks if a function can be redefined.
static void checkWeakAttr(Sema &S, NamedDecl &ND)
static void checkSelectAnyAttr(Sema &S, NamedDecl &ND)
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 void propagateAttributes(ParmVarDecl *To, const ParmVarDecl *From, F &&propagator)
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 checkAliasAttr(Sema &S, NamedDecl &ND)
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 void checkWeakRefAttr(Sema &S, NamedDecl &ND)
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 for SYCL constructs.
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
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
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.
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 getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType, const Attr *attr=nullptr) const
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
bool computeBestEnumTypes(bool IsPacked, unsigned NumNegativeBits, unsigned NumPositiveBits, QualType &BestType, QualType &BestPromotionType)
Compute BestType and BestPromotionType for an enum based on the highest number of negative and positi...
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
bool hasAnyFunctionEffects() const
bool hasSameFunctionTypeIgnoringParamABI(QualType T, QualType U) const
Determine if two function types are the same, ignoring parameter ABI annotations.
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 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
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, Expr *TrailingRequiresClause=nullptr)
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.
Represents the canonical version of C arrays with a specified constant size.
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...
bool isZeroSize() const
Return true if the size is zero.
llvm::APInt getSize() const
Return the constant array size as an APInt.
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
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 isExternCXXContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
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.
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 isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
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 TST TST_void
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,...
bool isFromGlobalModule() const
Whether this declaration comes from global module.
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).
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...
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.
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)
bool isZeroLengthBitField() const
Is this a zero-length bit-field? Such bit-fields aren't really bit-fields at all and instead act as a...
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)
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
unsigned getAArch64SMEAttributes() const
Return a bitmask describing the SME attributes on the function type, see AArch64SMETypeAttributes for...
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)
unsigned getRegParmType() const
CallingConv getCallConv() const
QualType getReturnType() const
bool getCmseNSCallAttr() const
@ SME_PStateSMEnabledMask
@ SME_PStateSMCompatibleMask
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.
void CheckSMEFunctionDefAttributes(const FunctionDecl *FD)
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)
HLSLWaveSizeAttr * mergeWaveSizeAttr(Decl *D, const AttributeCommonInfo &AL, int Min, int Max, int Preferred, int SpelledArgsCount)
void ActOnVariableDeclarator(VarDecl *VD)
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)
StmtResult BuildSYCLKernelCallStmt(FunctionDecl *FD, CompoundStmt *Body)
void CheckSYCLEntryPointFunctionDecl(FunctionDecl *FD)
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.
sema::CapturingScopeInfo * getEnclosingLambdaOrBlock() const
Get the innermost lambda or block enclosing the current location, if any.
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)
NamedDecl * ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef< BindingDecl * > Bindings={})
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()
void inferLifetimeCaptureByAttribute(FunctionDecl *FD)
Add [[clang:::lifetime_capture_by(this)]] to STL container methods.
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...
void LazyProcessLifetimeCaptureByParams(FunctionDecl *FD)
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
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={}, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false, bool HasMatchedPackOnParmToNonPackOnArg=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
DiagnosticsEngine & getDiagnostics() const
void ActOnFinishTopLevelStmtDecl(TopLevelStmtDecl *D, Stmt *Statement)
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
void inferLifetimeBoundAttribute(FunctionDecl *FD)
Add [[clang:::lifetimebound]] attr for std:: functions and methods.
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)
void maybeAddDeclWithEffects(FuncOrBlockDecl *D)
Inline checks from the start of maybeAddDeclWithEffects, to minimize performance impact on code not u...
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.
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams, SourceLocation EllipsisLoc)
Handle a friend type declaration.
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 ...
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)
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 diagnoseFunctionEffectMergeConflicts(const FunctionEffectSet::Conflicts &Errs, SourceLocation NewLoc, SourceLocation OldLoc)
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 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().
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.
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.
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
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.
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.
virtual ParsedTargetAttr parseTargetAttr(StringRef Str) const
bool supportsMultiVersioning() const
Identify whether this target supports multiversioning of functions, which requires support for cpu_su...
virtual uint64_t getFMVPriority(ArrayRef< StringRef > Features) const
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(bool IgnoreDeduced=false) 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.
bool isHLSLSpecificType() const
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...
bool isPointerOrReferenceType() const
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...
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, bool KnownInstantiationDependent)
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 [...].
TemplateParameterList * GLTemplateParameterList
If this is a generic lambda, and the template parameter list has been created (from the TemplateParam...
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.
Extra information about a function prototype.
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.