53#include "llvm/ADT/STLForwardCompat.h"
54#include "llvm/ADT/SmallString.h"
55#include "llvm/ADT/StringExtras.h"
56#include "llvm/TargetParser/Triple.h"
61#include <unordered_map>
68 Decl *Group[2] = { OwnedType, Ptr };
79 TypeNameValidatorCCC(
bool AllowInvalid,
bool WantClass =
false,
80 bool AllowTemplates =
false,
81 bool AllowNonTemplates =
true)
82 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
83 AllowTemplates(AllowTemplates), AllowNonTemplates(AllowNonTemplates) {
84 WantExpressionKeywords =
false;
85 WantCXXNamedCasts =
false;
86 WantRemainingKeywords =
false;
91 if (!AllowInvalidDecl && ND->isInvalidDecl())
95 return AllowTemplates;
97 bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
101 if (AllowNonTemplates)
106 if (AllowTemplates) {
107 auto *RD = dyn_cast<CXXRecordDecl>(ND);
108 if (!RD || !RD->isInjectedClassName())
110 RD = cast<CXXRecordDecl>(RD->getDeclContext());
111 return RD->getDescribedClassTemplate() ||
112 isa<ClassTemplateSpecializationDecl>(RD);
118 return !WantClassName && candidate.
isKeyword();
121 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
122 return std::make_unique<TypeNameValidatorCCC>(*
this);
126 bool AllowInvalidDecl;
129 bool AllowNonTemplates;
135enum class UnqualifiedTypeNameLookupResult {
146static UnqualifiedTypeNameLookupResult
151 return UnqualifiedTypeNameLookupResult::NotFound;
153 UnqualifiedTypeNameLookupResult FoundTypeDecl =
154 UnqualifiedTypeNameLookupResult::NotFound;
157 if (
auto *BaseTT =
Base.getType()->getAs<
TagType>())
158 BaseRD = BaseTT->getAsCXXRecordDecl();
162 if (!TST || !TST->isDependentType())
164 auto *TD = TST->getTemplateName().getAsTemplateDecl();
167 if (
auto *BasePrimaryTemplate =
168 dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) {
170 BaseRD = BasePrimaryTemplate;
171 else if (
auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
173 CTD->findPartialSpecialization(
Base.getType()))
181 if (!isa<TypeDecl>(ND))
182 return UnqualifiedTypeNameLookupResult::FoundNonType;
183 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
185 if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
187 case UnqualifiedTypeNameLookupResult::FoundNonType:
188 return UnqualifiedTypeNameLookupResult::FoundNonType;
189 case UnqualifiedTypeNameLookupResult::FoundType:
190 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
192 case UnqualifiedTypeNameLookupResult::NotFound:
199 return FoundTypeDecl;
207 UnqualifiedTypeNameLookupResult FoundTypeDecl =
208 UnqualifiedTypeNameLookupResult::NotFound;
210 DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
214 RD = dyn_cast<CXXRecordDecl>(DC);
218 if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
224 S.
Diag(NameLoc, diag::ext_found_in_dependent_base) << &II;
246 bool WantNontrivialTypeSourceInfo =
true) {
248 case Type::DeducedTemplateSpecialization:
250 case Type::InjectedClassName:
253 case Type::UnresolvedUsing:
258 case Type::ObjCInterface:
259 case Type::ObjCTypeParam:
260 case Type::TemplateTypeParm:
263 llvm_unreachable(
"Unexpected Type Class");
271 if (!WantNontrivialTypeSourceInfo)
275 Builder.pushTypeSpec(
T).setNameLoc(NameLoc);
292 bool HasTrailingDot,
ParsedType ObjectTypePtr,
293 bool IsCtorOrDtorName,
294 bool WantNontrivialTypeSourceInfo,
295 bool IsClassTemplateDeductionContext,
299 bool AllowDeducedTemplate = IsClassTemplateDeductionContext &&
301 !isClassName && !HasTrailingDot;
326 !isClassName && !IsCtorOrDtorName)
328 bool IsImplicitTypename = !isClassName && !IsCtorOrDtorName;
329 if (IsImplicitTypename) {
332 Diag(QualifiedLoc, diag::warn_cxx17_compat_implicit_typename);
334 Diag(QualifiedLoc, diag::ext_implicit_typename)
341 if (WantNontrivialTypeSourceInfo)
374 if (ObjectTypePtr &&
Result.empty()) {
398 switch (
Result.getResultKind()) {
401 TypeNameValidatorCCC CCC(
true, isClassName,
402 AllowDeducedTemplate);
407 bool MemberOfUnknownSpecialization;
416 if (Correction && (NNS || NewII != &II) &&
422 Template, MemberOfUnknownSpecialization))) {
424 isClassName, HasTrailingDot, ObjectTypePtr,
426 WantNontrivialTypeSourceInfo,
427 IsClassTemplateDeductionContext);
430 PDiag(diag::err_unknown_type_or_class_name_suggest)
431 <<
Result.getLookupName() << isClassName);
434 *CorrectedII = NewII;
439 Result.suppressDiagnostics();
455 Result.suppressDiagnostics();
465 Result.suppressDiagnostics();
471 Res != ResEnd; ++Res) {
473 if (isa<TypeDecl, ObjCInterfaceDecl, UnresolvedUsingIfExistsDecl>(
480 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*Res);
492 Result.suppressDiagnostics();
503 IIDecl =
Result.getFoundDecl();
504 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*
Result.begin());
508 assert(IIDecl &&
"Didn't find decl");
511 if (
TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
515 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
516 auto *FoundRD = dyn_cast<CXXRecordDecl>(TD);
517 if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD &&
518 FoundRD->isInjectedClassName() &&
520 Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor)
531 FoundUsingShadow =
nullptr;
532 }
else if (
auto *UD = dyn_cast<UnresolvedUsingIfExistsDecl>(IIDecl)) {
536 }
else if (AllowDeducedTemplate) {
538 assert(!FoundUsingShadow || FoundUsingShadow->
getTargetDecl() == TD);
544 FoundUsingShadow =
nullptr;
550 Result.suppressDiagnostics();
554 if (FoundUsingShadow)
557 return buildNamedType(*
this, SS,
T, NameLoc, WantNontrivialTypeSourceInfo);
565 auto *ND = dyn_cast<NamespaceDecl>(DC);
566 if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
568 else if (
auto *RD = dyn_cast<CXXRecordDecl>(DC))
570 RD->getTypeForDecl());
571 else if (isa<TranslationUnitDecl>(DC))
574 llvm_unreachable(
"something isn't in TU scope?");
585 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
586 if (MD->getParent()->hasAnyDependentBases())
594 bool IsTemplateTypeArg) {
595 assert(
getLangOpts().MSVCCompat &&
"shouldn't be called in non-MSVC mode");
598 if (IsTemplateTypeArg &&
getCurScope()->isTemplateParamScope()) {
607 Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
613 RD->getTypeForDecl());
617 Diag(NameLoc, diag::ext_undeclared_unqual_id_with_dependent_base) << &II
653 switch (TD->getTagKind()) {
695 return S->isFunctionPrototypeScope();
705 bool IsTemplateName) {
710 SuggestedType =
nullptr;
714 TypeNameValidatorCCC CCC(
false,
false,
721 bool CanRecover = !IsTemplateName;
722 if (Corrected.isKeyword()) {
725 PDiag(IsTemplateName ? diag::err_no_template_suggest
726 : diag::err_unknown_typename_suggest)
728 II = Corrected.getCorrectionAsIdentifierInfo();
731 if (!SS || !SS->
isSet()) {
733 PDiag(IsTemplateName ? diag::err_no_template_suggest
734 : diag::err_unknown_typename_suggest)
737 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
738 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
739 II->
getName().equals(CorrectedStr);
742 ? diag::err_no_member_template_suggest
743 : diag::err_unknown_nested_typename_suggest)
744 << II << DC << DroppedSpecifier << SS->
getRange(),
747 llvm_unreachable(
"could not have corrected a typo here");
754 if (Corrected.getCorrectionSpecifier())
759 getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), IILoc, S,
760 tmpSS.
isSet() ? &tmpSS : SS,
false,
false,
nullptr,
770 Name.setIdentifier(II, IILoc);
773 bool MemberOfUnknownSpecialization;
775 Name,
nullptr,
true, TemplateResult,
786 Diag(IILoc, IsTemplateName ? diag::err_no_template
787 : diag::err_unknown_typename)
790 Diag(IILoc, IsTemplateName ? diag::err_no_member_template
791 : diag::err_typename_nested_not_found)
797 unsigned DiagID = diag::err_typename_missing;
799 DiagID = diag::ext_typename_missing;
806 *SS, *II, IILoc).
get();
809 "Invalid scope specifier has already been diagnosed");
817 NextToken.
is(tok::less);
820 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
823 if (CheckTemplate && isa<TemplateDecl>(*I))
837 StringRef FixItTagName;
838 switch (Tag->getTagKind()) {
840 FixItTagName =
"class ";
844 FixItTagName =
"enum ";
848 FixItTagName =
"struct ";
852 FixItTagName =
"__interface ";
856 FixItTagName =
"union ";
860 StringRef TagName = FixItTagName.drop_back();
861 SemaRef.
Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
862 << Name << TagName << SemaRef.
getLangOpts().CPlusPlus
867 SemaRef.
Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
882 const Token &NextToken,
887 assert(NextToken.
isNot(tok::coloncolon) &&
888 "parse nested name specifiers before calling ClassifyName");
928 bool SecondTry =
false;
929 bool IsFilteredTemplateName =
false;
932 switch (
Result.getResultKind()) {
936 if (SS.
isEmpty() && NextToken.
is(tok::l_paren)) {
982 if (!SecondTry && CCC) {
987 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
988 unsigned QualifiedDiag = diag::err_no_member_suggest;
991 NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl();
993 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
994 UnqualifiedDiag = diag::err_no_template_suggest;
995 QualifiedDiag = diag::err_no_member_template_suggest;
996 }
else if (UnderlyingFirstDecl &&
997 (isa<TypeDecl>(UnderlyingFirstDecl) ||
998 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
999 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
1000 UnqualifiedDiag = diag::err_unknown_typename_suggest;
1001 QualifiedDiag = diag::err_unknown_nested_typename_suggest;
1007 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
1008 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
1009 Name->getName().equals(CorrectedStr);
1012 << DroppedSpecifier << SS.
getRange());
1016 Name = Corrected.getCorrectionAsIdentifierInfo();
1019 if (Corrected.isKeyword())
1025 Result.setLookupName(Corrected.getCorrection());
1047 Result.suppressDiagnostics();
1089 if (!
Result.isAmbiguous()) {
1090 IsFilteredTemplateName =
true;
1100 (IsFilteredTemplateName ||
1116 if (!IsFilteredTemplateName)
1119 bool IsFunctionTemplate;
1123 IsFunctionTemplate =
true;
1126 }
else if (!
Result.empty()) {
1130 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
1131 IsVarTemplate = isa<VarTemplateDecl>(TD);
1134 dyn_cast<UsingShadowDecl>(*
Result.begin());
1135 assert(!FoundUsingShadow ||
1136 TD == cast<TemplateDecl>(FoundUsingShadow->
getTargetDecl()));
1146 IsFunctionTemplate =
true;
1150 if (IsFunctionTemplate) {
1154 Result.suppressDiagnostics();
1165 if (
const auto *USD = dyn_cast<UsingShadowDecl>(Found))
1181 dyn_cast<ObjCCompatibleAliasDecl>(
FirstDecl))
1182 Class = Alias->getClassInterface();
1188 if (NextToken.
is(tok::period)) {
1191 Result.suppressDiagnostics();
1201 if (
auto *USD = dyn_cast<UsingShadowDecl>(
Result.getRepresentativeDecl()))
1207 if (
auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(
FirstDecl)) {
1220 bool NextIsOp = NextToken.
isOneOf(tok::amp, tok::star);
1221 if ((NextToken.
is(tok::identifier) ||
1223 FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
1235 if (
Result.isSingleResult() && !ADL &&
1240 Result.suppressDiagnostics();
1260 bool IsAddressOfOperand) {
1263 NameInfo, IsAddressOfOperand,
1270 const Token &NextToken) {
1287 auto *ULE = cast<UnresolvedLookupExpr>(E);
1288 if ((*ULE->decls_begin())->isCXXClassMember()) {
1290 SS.
Adopt(ULE->getQualifierLoc());
1295 Result.setNamingClass(ULE->getNamingClass());
1296 for (
auto I = ULE->decls_begin(), E = ULE->decls_end(); I != E; ++I)
1297 Result.addDecl(*I, I.getAccess());
1310 auto *TD = Name.getAsTemplateDecl();
1313 if (isa<ClassTemplateDecl>(TD))
1315 if (isa<FunctionTemplateDecl>(TD))
1317 if (isa<VarTemplateDecl>(TD))
1319 if (isa<TypeAliasTemplateDecl>(TD))
1321 if (isa<TemplateTemplateParmDecl>(TD))
1323 if (isa<ConceptDecl>(TD))
1330 "The next DeclContext should be lexically contained in the current one.");
1336 assert(
CurContext &&
"DeclContext imbalance!");
1339 assert(
CurContext &&
"Popped translation unit!");
1348 CurContext = cast<TagDecl>(D)->getDefinition();
1349 assert(
CurContext &&
"skipping definition of undefined tag");
1380 assert(!S->getEntity() &&
"scope already has entity");
1383 Scope *Ancestor = S->getParent();
1391 if (S->getParent()->isTemplateParamScope()) {
1399 assert(S->getEntity() ==
CurContext &&
"Context imbalance!");
1403 Scope *Ancestor = S->getParent();
1412 assert(S->isTemplateParamScope() &&
1413 "expected to be initializing a template parameter scope");
1437 for (; S && S->isTemplateParamScope(); S = S->getParent(), --ScopeDepth) {
1441 cast<Decl>(DC)->getDescribedTemplateParams()) {
1442 unsigned DCDepth = TPL->getDepth() + 1;
1443 if (DCDepth > ScopeDepth)
1445 if (ScopeDepth == DCDepth)
1450 S->setLookupEntity(SearchDCAfterScope);
1464 "The next DeclContext should be lexically contained in the current one.");
1468 for (
unsigned P = 0, NumParams = FD->
getNumParams();
P < NumParams; ++
P) {
1481 assert(
CurContext &&
"DeclContext imbalance!");
1483 assert(
CurContext &&
"Popped translation unit!");
1512 return ND->
hasAttr<OverloadableAttr>();
1515 return Previous.getFoundDecl()->hasAttr<OverloadableAttr>();
1525 while (S->getEntity() && S->getEntity()->isTransparentContext())
1540 if (isa<FunctionDecl>(D) &&
1541 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
1551 for (; I != IEnd; ++I) {
1563 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1570 if (!S->isDeclScope(*I))
1584 bool AllowInlineNamespace)
const {
1592 if (ScopeDC->getPrimaryContext() == TargetDC)
1594 }
while ((S = S->getParent()));
1606 bool ConsiderLinkage,
1607 bool AllowInlineNamespace) {
1668 if (NewIsModuleInterface || OldIsModuleInterface) {
1674 << NewIsModuleInterface
1676 << OldIsModuleInterface
1707 if (!IsNewExported && !IsOldExported)
1713 assert(IsNewExported);
1721 Diag(New->
getLocation(), diag::err_redeclaration_non_exported) << New << S;
1757 "New and Old are not the same definition, we should diagnostic it "
1758 "immediately instead of checking it.");
1761 "We shouldn't see unreachable definitions here.");
1809 return OldM == NewM;
1816 return isa<UsingShadowDecl>(D) ||
1817 isa<UnresolvedUsingTypenameDecl>(D) ||
1818 isa<UnresolvedUsingValueDecl>(D);
1846 return CD->isCopyConstructor();
1865 if (
const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1866 if (!RD->hasNameForLinkage())
1895 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1901 FD->getMemberSpecializationInfo() && !FD->isOutOfLine())
1904 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1909 if (FD->isInlined() && !
isMainFileLoc(*
this, FD->getLocation()))
1913 if (FD->doesThisDeclarationHaveABody() &&
1916 }
else if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1926 if (VD->isStaticDataMember() &&
1929 if (VD->isStaticDataMember() &&
1931 VD->getMemberSpecializationInfo() && !VD->isOutOfLine())
1934 if (VD->isInline() && !
isMainFileLoc(*
this, VD->getLocation()))
1943 return mightHaveNonExternalLinkage(D);
1950 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1956 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1971 if (
const auto *DD = dyn_cast<DecompositionDecl>(D)) {
1975 bool IsAllPlaceholders =
true;
1976 for (
const auto *BD : DD->bindings()) {
1977 if (BD->isReferenced())
1979 IsAllPlaceholders = IsAllPlaceholders && BD->isPlaceholderVar(LangOpts);
1981 if (IsAllPlaceholders)
1992 if (D->
hasAttr<UnusedAttr>() || D->
hasAttr<ObjCPreciseLifetimeAttr>() ||
1996 if (isa<LabelDecl>(D))
2002 if (
const auto *R = dyn_cast<CXXRecordDecl>(D->
getDeclContext()))
2005 WithinFunction || (R->isLocalClass() && !R->isDependentType());
2006 if (!WithinFunction)
2009 if (isa<TypedefNameDecl>(D))
2013 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
2017 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2020 if (
const auto *Cleanups = dyn_cast_if_present<ExprWithCleanups>(
Init))
2021 Init = Cleanups->getSubExpr();
2023 const auto *Ty = VD->getType().getTypePtr();
2028 if (TT->getDecl()->hasAttr<UnusedAttr>())
2034 if (
const auto *MTE = dyn_cast_if_present<MaterializeTemporaryExpr>(
Init);
2035 MTE && MTE->getExtendingDecl()) {
2036 Ty = VD->getType().getNonReferenceType().getTypePtr();
2037 Init = MTE->getSubExpr()->IgnoreImplicitAsWritten();
2042 if (Ty->isIncompleteType() || Ty->isDependentType())
2047 Ty = Ty->getBaseElementTypeUnsafe();
2050 const TagDecl *Tag = TT->getDecl();
2051 if (Tag->
hasAttr<UnusedAttr>())
2054 if (
const auto *RD = dyn_cast<CXXRecordDecl>(Tag)) {
2055 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
2059 const auto *Construct =
2060 dyn_cast<CXXConstructExpr>(
Init->IgnoreImpCasts());
2061 if (Construct && !Construct->isElidable()) {
2063 if (!CD->
isTrivial() && !RD->hasAttr<WarnUnusedAttr>() &&
2064 (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
2070 if (
Init->isTypeDependent()) {
2072 if (!Ctor->isTrivial())
2078 if (isa<CXXUnresolvedConstructExpr>(
Init))
2092 if (isa<LabelDecl>(D)) {
2113 for (
auto *TmpD : D->
decls()) {
2114 if (
const auto *
T = dyn_cast<TypedefNameDecl>(TmpD))
2116 else if(
const auto *R = dyn_cast<RecordDecl>(TmpD))
2132 if (
auto *TD = dyn_cast<TypedefNameDecl>(D)) {
2143 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
2144 DiagID = diag::warn_unused_exception_param;
2145 else if (isa<LabelDecl>(D))
2146 DiagID = diag::warn_unused_label;
2148 DiagID = diag::warn_unused_variable;
2167 if (Ty->isReferenceType() || Ty->isDependentType())
2171 const TagDecl *Tag = TT->getDecl();
2172 if (Tag->
hasAttr<UnusedAttr>())
2176 if (
const auto *RD = dyn_cast<CXXRecordDecl>(Tag);
2177 RD && !RD->hasAttr<WarnUnusedAttr>())
2184 if (VD->
hasAttr<BlocksAttr>() && Ty->isObjCObjectPointerType())
2190 if (VD->
hasAttr<ObjCPreciseLifetimeAttr>() && Ty->isObjCObjectPointerType())
2197 assert(iter->getSecond() >= 0 &&
2198 "Found a negative number of references to a VarDecl");
2199 if (
int RefCnt = iter->getSecond(); RefCnt > 0) {
2209 bool UnusedCXXCondDecl = VD->
isCXXCondDecl() && (RefCnt == 1);
2210 if (!UnusedCXXCondDecl)
2214 unsigned DiagID = isa<ParmVarDecl>(VD) ? diag::warn_unused_but_set_parameter
2215 : diag::warn_unused_but_set_variable;
2225 bool Diagnose =
false;
2229 Diagnose = L->
getStmt() ==
nullptr;
2238 if (S->decl_empty())
return;
2240 "Scope shouldn't contain decls!");
2247 std::optional<SourceLocation> PreviousDeclLoc;
2252 DeclDiags.push_back(LocAndDiag{Loc, std::nullopt, std::move(PD)});
2257 DeclDiags.push_back(LocAndDiag{Loc, PreviousDeclLoc, std::move(PD)});
2260 for (
auto *TmpD : S->decls()) {
2261 assert(TmpD &&
"This decl didn't get pushed??");
2263 assert(isa<NamedDecl>(TmpD) &&
"Decl isn't NamedDecl?");
2267 if (!S->hasUnrecoverableErrorOccurred()) {
2269 if (
const auto *RD = dyn_cast<RecordDecl>(D))
2271 if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
2280 if (
LabelDecl *LD = dyn_cast<LabelDecl>(D))
2286 auto ShadowI = ShadowingDecls.find(D);
2287 if (ShadowI != ShadowingDecls.end()) {
2288 if (
const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
2289 addDiagWithPrev(D->
getLocation(), FD->getLocation(),
2290 PDiag(diag::warn_ctor_parm_shadows_field)
2291 << D << FD << FD->getParent());
2293 ShadowingDecls.erase(ShadowI);
2297 llvm::sort(DeclDiags,
2298 [](
const LocAndDiag &LHS,
const LocAndDiag &RHS) ->
bool {
2303 return LHS.Loc.getRawEncoding() < RHS.Loc.getRawEncoding();
2305 for (
const LocAndDiag &D : DeclDiags) {
2307 if (D.PreviousDeclLoc)
2308 Diag(*D.PreviousDeclLoc, diag::note_previous_declaration);
2327 bool DoTypoCorrection) {
2332 if (!IDecl && DoTypoCorrection) {
2376 (S->getEntity() && S->getEntity()->isTransparentContext()) ||
2394 return "ucontext.h";
2396 llvm_unreachable(
"unhandled error kind");
2407 Parent->addDecl(CLinkageDecl);
2422 for (
unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2425 FT->getParamType(i),
nullptr,
SC_None,
nullptr);
2427 Params.push_back(parm);
2429 New->setParams(Params);
2441 Scope *S,
bool ForRedeclaration,
2448 if (!ForRedeclaration)
2460 Diag(Loc, diag::warn_implicit_decl_no_jmp_buf)
2467 Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
2473 if (!ForRedeclaration &&
2476 Diag(Loc,
LangOpts.C99 ? diag::ext_implicit_lib_function_decl_c99
2477 : diag::ext_implicit_lib_function_decl)
2480 Diag(Loc, diag::note_include_header_or_declare)
2517 while (Filter.hasNext()) {
2526 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2528 Decl->getUnderlyingType()))
2533 if (OldTD->getAnonDeclWithTypedefName(
true) &&
2534 Decl->getAnonDeclWithTypedefName())
2547 OldType = OldTypedef->getUnderlyingType();
2554 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2555 Diag(New->
getLocation(), diag::err_redefinition_variably_modified_typedef)
2563 if (OldType != NewType &&
2567 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2569 << Kind << NewType << OldType;
2593 switch (TypeID->getLength()) {
2597 if (!TypeID->isStr(
"id"))
2613 if (!TypeID->isStr(
"Class"))
2620 if (!TypeID->isStr(
"SEL"))
2647 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2648 auto *OldTag = OldTD->getAnonDeclWithTypedefName(
true);
2651 if (OldTag && NewTag &&
2652 OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
2657 if (OldTD->isModed())
2659 OldTD->getUnderlyingType());
2668 if (isa<EnumDecl>(NewTag)) {
2670 for (
auto *D : NewTag->decls()) {
2671 auto *ED = cast<EnumConstantDecl>(D);
2675 ED->getLexicalDeclContext()->removeDecl(ED);
2725 if (!isa<TypedefNameDecl>(Old))
2757 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
2758 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
2759 for (
const auto *i : D->
attrs())
2760 if (i->getKind() == A->
getKind()) {
2762 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
2767 if (OA && isa<OwnershipAttr>(i))
2768 return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
2776 if (
VarDecl *VD = dyn_cast<VarDecl>(D))
2777 return VD->isThisDeclarationADefinition();
2778 if (
TagDecl *TD = dyn_cast<TagDecl>(D))
2779 return TD->isCompleteDefinition() || TD->isBeingDefined();
2790 AlignedAttr *OldAlignasAttr =
nullptr;
2791 AlignedAttr *OldStrictestAlignAttr =
nullptr;
2792 unsigned OldAlign = 0;
2800 if (I->isAlignmentDependent())
2806 unsigned Align = I->getAlignment(S.
Context);
2807 if (Align > OldAlign) {
2809 OldStrictestAlignAttr = I;
2814 AlignedAttr *NewAlignasAttr =
nullptr;
2815 unsigned NewAlign = 0;
2817 if (I->isAlignmentDependent())
2823 unsigned Align = I->getAlignment(S.
Context);
2824 if (Align > NewAlign)
2828 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2836 if (OldAlign == 0 || NewAlign == 0) {
2838 if (
ValueDecl *VD = dyn_cast<ValueDecl>(New))
2849 if (OldAlign != NewAlign) {
2850 S.
Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2853 S.
Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2868 S.
Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2872 bool AnyAdded =
false;
2875 if (OldAlign > NewAlign) {
2876 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.
Context);
2877 Clone->setInherited(
true);
2883 if (OldAlignasAttr && !NewAlignasAttr &&
2884 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2885 AlignedAttr *Clone = OldAlignasAttr->clone(S.
Context);
2886 Clone->setInherited(
true);
2894#define WANT_DECL_MERGE_LOGIC
2895#include "clang/Sema/AttrParsedAttrImpl.inc"
2896#undef WANT_DECL_MERGE_LOGIC
2903 if (!DiagnoseMutualExclusions(S, D,
Attr))
2914 if (
const auto *AA = dyn_cast<AvailabilityAttr>(
Attr))
2916 D, *AA, AA->getPlatform(), AA->
isImplicit(), AA->getIntroduced(),
2917 AA->getDeprecated(), AA->getObsoleted(), AA->getUnavailable(),
2918 AA->getMessage(), AA->getStrict(), AA->getReplacement(), AMK,
2920 else if (
const auto *VA = dyn_cast<VisibilityAttr>(
Attr))
2922 else if (
const auto *VA = dyn_cast<TypeVisibilityAttr>(
Attr))
2924 else if (
const auto *ImportA = dyn_cast<DLLImportAttr>(
Attr))
2926 else if (
const auto *ExportA = dyn_cast<DLLExportAttr>(
Attr))
2928 else if (
const auto *EA = dyn_cast<ErrorAttr>(
Attr))
2930 else if (
const auto *FA = dyn_cast<FormatAttr>(
Attr))
2931 NewAttr = S.
mergeFormatAttr(D, *FA, FA->getType(), FA->getFormatIdx(),
2933 else if (
const auto *SA = dyn_cast<SectionAttr>(
Attr))
2935 else if (
const auto *CSA = dyn_cast<CodeSegAttr>(
Attr))
2937 else if (
const auto *IA = dyn_cast<MSInheritanceAttr>(
Attr))
2939 IA->getInheritanceModel());
2940 else if (
const auto *AA = dyn_cast<AlwaysInlineAttr>(
Attr))
2943 else if (S.
getLangOpts().CUDA && isa<FunctionDecl>(D) &&
2944 (isa<CUDAHostAttr>(
Attr) || isa<CUDADeviceAttr>(
Attr) ||
2945 isa<CUDAGlobalAttr>(
Attr))) {
2949 }
else if (
const auto *MA = dyn_cast<MinSizeAttr>(
Attr))
2951 else if (
const auto *SNA = dyn_cast<SwiftNameAttr>(
Attr))
2953 else if (
const auto *OA = dyn_cast<OptimizeNoneAttr>(
Attr))
2955 else if (
const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(
Attr))
2957 else if (isa<AlignedAttr>(
Attr))
2961 else if ((isa<DeprecatedAttr>(
Attr) || isa<UnavailableAttr>(
Attr)) &&
2966 else if (
const auto *UA = dyn_cast<UuidAttr>(
Attr))
2967 NewAttr = S.
mergeUuidAttr(D, *UA, UA->getGuid(), UA->getGuidDecl());
2968 else if (
const auto *IMA = dyn_cast<WebAssemblyImportModuleAttr>(
Attr))
2970 else if (
const auto *INA = dyn_cast<WebAssemblyImportNameAttr>(
Attr))
2972 else if (
const auto *TCBA = dyn_cast<EnforceTCBAttr>(
Attr))
2974 else if (
const auto *TCBLA = dyn_cast<EnforceTCBLeafAttr>(
Attr))
2976 else if (
const auto *BTFA = dyn_cast<BTFDeclTagAttr>(
Attr))
2978 else if (
const auto *NT = dyn_cast<HLSLNumThreadsAttr>(
Attr))
2981 else if (
const auto *SA = dyn_cast<HLSLShaderAttr>(
Attr))
2983 else if (isa<SuppressAttr>(
Attr))
2992 if (isa<MSInheritanceAttr>(NewAttr))
3001 if (
const TagDecl *TD = dyn_cast<TagDecl>(D))
3002 return TD->getDefinition();
3003 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
3009 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
3011 if (FD->isDefined(Def,
true))
3018 for (
const auto *Attribute : D->
attrs())
3019 if (Attribute->getKind() == Kind)
3031 if (!Def || Def == New)
3035 for (
unsigned I = 0, E = NewAttributes.size(); I != E;) {
3036 const Attr *NewAttribute = NewAttributes[I];
3038 if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {
3045 NewAttributes.erase(NewAttributes.begin() + I);
3050 VarDecl *VD = cast<VarDecl>(New);
3051 unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
3053 ? diag::err_alias_after_tentative
3054 : diag::err_redefinition;
3056 if (
Diag == diag::err_redefinition)
3066 if (
const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
3079 if (isa<C11NoReturnAttr>(NewAttribute)) {
3083 }
else if (isa<UuidAttr>(NewAttribute)) {
3087 }
else if (
const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
3088 if (AA->isAlignas()) {
3099 S.
Diag(NewAttribute->
getLocation(), diag::note_alignas_on_declaration)
3101 NewAttributes.erase(NewAttributes.begin() + I);
3105 }
else if (isa<LoaderUninitializedAttr>(NewAttribute)) {
3111 diag::err_loader_uninitialized_redeclaration);
3113 NewAttributes.erase(NewAttributes.begin() + I);
3117 }
else if (isa<SelectAnyAttr>(NewAttribute) &&
3118 cast<VarDecl>(New)->isInline() &&
3119 !cast<VarDecl>(New)->isInlineSpecified()) {
3126 }
else if (isa<OMPDeclareVariantAttr>(NewAttribute)) {
3134 diag::warn_attribute_precede_definition);
3136 NewAttributes.erase(NewAttributes.begin() + I);
3142 const ConstInitAttr *CIAttr,
3143 bool AttrBeforeInit) {
3150 std::string SuitableSpelling;
3152 SuitableSpelling = std::string(
3154 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3156 InsertLoc, {tok::l_square, tok::l_square,
3157 S.PP.getIdentifierInfo(
"clang"), tok::coloncolon,
3158 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3159 tok::r_square, tok::r_square}));
3160 if (SuitableSpelling.empty())
3162 InsertLoc, {tok::kw___attribute, tok::l_paren, tok::r_paren,
3163 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3164 tok::r_paren, tok::r_paren}));
3165 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus20)
3166 SuitableSpelling =
"constinit";
3167 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3168 SuitableSpelling =
"[[clang::require_constant_initialization]]";
3169 if (SuitableSpelling.empty())
3170 SuitableSpelling =
"__attribute__((require_constant_initialization))";
3171 SuitableSpelling +=
" ";
3173 if (AttrBeforeInit) {
3176 assert(CIAttr->isConstinit() &&
"should not diagnose this for attribute");
3179 S.
Diag(CIAttr->getLocation(), diag::note_constinit_specified_here);
3183 S.
Diag(CIAttr->getLocation(),
3184 CIAttr->isConstinit() ? diag::err_constinit_added_too_late
3185 : diag::warn_require_const_init_added_too_late)
3188 << CIAttr->isConstinit()
3197 UsedAttr *NewAttr = OldAttr->clone(
Context);
3198 NewAttr->setInherited(
true);
3202 RetainAttr *NewAttr = OldAttr->clone(
Context);
3203 NewAttr->setInherited(
true);
3213 const auto *OldConstInit = Old->
getAttr<ConstInitAttr>();
3214 const auto *NewConstInit = New->
getAttr<ConstInitAttr>();
3215 if (
bool(OldConstInit) !=
bool(NewConstInit)) {
3216 const auto *OldVD = cast<VarDecl>(Old);
3217 auto *NewVD = cast<VarDecl>(New);
3223 (NewVD->hasInit() || NewVD->isThisDeclarationADefinition()))
3226 if (InitDecl == NewVD) {
3230 if (OldConstInit && OldConstInit->isConstinit())
3233 }
else if (NewConstInit) {
3237 if (InitDecl && InitDecl != NewVD) {
3240 NewVD->dropAttr<ConstInitAttr>();
3248 if (AsmLabelAttr *NewA = New->
getAttr<AsmLabelAttr>()) {
3249 if (AsmLabelAttr *OldA = Old->
getAttr<AsmLabelAttr>()) {
3250 if (!OldA->isEquivalent(NewA)) {
3253 Diag(OldA->getLocation(), diag::note_previous_declaration);
3255 }
else if (Old->
isUsed()) {
3259 << isa<FunctionDecl>(Old) << New->
getAttr<AsmLabelAttr>()->
getRange();
3264 if (
const auto *NewAbiTagAttr = New->
getAttr<AbiTagAttr>()) {
3265 if (
const auto *OldAbiTagAttr = Old->
getAttr<AbiTagAttr>()) {
3266 for (
const auto &NewTag : NewAbiTagAttr->tags()) {
3267 if (!llvm::is_contained(OldAbiTagAttr->tags(), NewTag)) {
3268 Diag(NewAbiTagAttr->getLocation(),
3269 diag::err_new_abi_tag_on_redeclaration)
3271 Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
3275 Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
3281 if (New->
hasAttr<SectionAttr>() && !Old->
hasAttr<SectionAttr>()) {
3282 if (
auto *VD = dyn_cast<VarDecl>(New)) {
3284 Diag(New->
getLocation(), diag::warn_attribute_section_on_redeclaration);
3291 const auto *NewCSA = New->
getAttr<CodeSegAttr>();
3292 if (NewCSA && !Old->
hasAttr<CodeSegAttr>() &&
3293 !NewCSA->isImplicit() && isa<CXXMethodDecl>(New)) {
3311 if (isa<DeprecatedAttr>(I) ||
3312 isa<UnavailableAttr>(I) ||
3313 isa<AvailabilityAttr>(I)) {
3328 if (isa<UsedAttr>(I) || isa<RetainAttr>(I))
3350 const CarriesDependencyAttr *CDA = newDecl->
getAttr<CarriesDependencyAttr>();
3351 if (CDA && !oldDecl->
hasAttr<CarriesDependencyAttr>()) {
3352 S.
Diag(CDA->getLocation(),
3353 diag::err_carries_dependency_missing_on_first_decl) << 1;
3361 diag::note_carries_dependency_missing_first_decl) << 1;
3369 const auto *NDAttr = newDecl->
getAttr<HLSLParamModifierAttr>();
3370 const auto *ODAttr = oldDecl->
getAttr<HLSLParamModifierAttr>();
3375 if (NDAttr && ODAttr &&
3376 NDAttr->getSpellingListIndex() != ODAttr->getSpellingListIndex()) {
3377 S.
Diag(newDecl->
getLocation(), diag::err_hlsl_param_qualifier_mismatch)
3378 << NDAttr << newDecl;
3387 bool foundAny = newDecl->
hasAttrs();
3396 cast<InheritableParamAttr>(I->clone(S.
Context));
3409 auto NoSizeInfo = [&Ctx](
QualType Ty) {
3410 if (Ty->isIncompleteArrayType() || Ty->isPointerType())
3418 if (NoSizeInfo(Old) && NoSizeInfo(New))
3450 if (*Oldnullability != *Newnullability) {
3451 S.
Diag(NewParam->
getLocation(), diag::warn_mismatched_nullability_attr)
3470 const auto *OldParamDT = dyn_cast<DecayedType>(OldParam->
getType());
3471 const auto *NewParamDT = dyn_cast<DecayedType>(NewParam->
getType());
3472 if (OldParamDT && NewParamDT &&
3473 OldParamDT->getPointeeType() == NewParamDT->getPointeeType()) {
3474 QualType OldParamOT = OldParamDT->getOriginalType();
3475 QualType NewParamOT = NewParamDT->getOriginalType();
3478 << NewParam << NewParamOT;
3489struct GNUCompatibleParamWarning {
3499template <
typename T>
3500static std::pair<diag::kind, SourceLocation>
3504 if (Old->isThisDeclarationADefinition())
3505 PrevDiag = diag::note_previous_definition;
3506 else if (Old->isImplicit()) {
3507 PrevDiag = diag::note_previous_implicit_declaration;
3508 if (
const auto *FD = dyn_cast<FunctionDecl>(Old)) {
3509 if (FD->getBuiltinID())
3510 PrevDiag = diag::note_previous_builtin_declaration;
3513 OldLocation = New->getLocation();
3515 PrevDiag = diag::note_previous_declaration;
3516 return std::make_pair(PrevDiag, OldLocation);
3524 return ((FD->
hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
3525 !LangOpts.CPlusPlus &&
3537template <
typename T>
3551template<
typename T>
static bool isExternC(
T *D) {
return D->isExternC(); }
3558template<
typename ExpectedDecl>
3580 !Old->getDeclContext()->getRedeclContext()->Equals(
3581 New->getDeclContext()->getRedeclContext()) &&
3586 S.
Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
3599 const auto *AttrA = A->
getAttr<PassObjectSizeAttr>();
3600 const auto *AttrB = B->
getAttr<PassObjectSizeAttr>();
3603 return AttrA && AttrB && AttrA->getType() == AttrB->getType() &&
3604 AttrA->isDynamic() == AttrB->isDynamic();
3630 if (NamedDC->Equals(SemaDC))
3633 assert((NamedDC->InEnclosingNamespaceSetOf(SemaDC) ||
3635 "unexpected context for redeclaration");
3646 if (
auto *FD = dyn_cast<FunctionDecl>(NewD))
3647 FixSemaDC(FD->getDescribedFunctionTemplate());
3648 else if (
auto *VD = dyn_cast<VarDecl>(NewD))
3649 FixSemaDC(VD->getDescribedVarTemplate());
3664 bool MergeTypeWithOld,
bool NewDeclIsDefn) {
3671 Diag(Shadow->getTargetDecl()->getLocation(),
3672 diag::note_using_decl_target);
3673 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
3682 if (checkUsingShadowRedecl<FunctionTemplateDecl>(*
this, Shadow,
3685 OldD = Old = cast<FunctionTemplateDecl>(Shadow->getTargetDecl())
3688 if (checkUsingShadowRedecl<FunctionDecl>(*
this, Shadow, New))
3690 OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
3718 std::tie(PrevDiag, OldLocation) =
3725 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
3732 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3735 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3740 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
3741 if (!Old->
hasAttr<InternalLinkageAttr>()) {
3745 New->
dropAttr<InternalLinkageAttr>();
3748 if (
auto *EA = New->
getAttr<ErrorAttr>()) {
3749 if (!Old->
hasAttr<ErrorAttr>()) {
3750 Diag(EA->getLocation(), diag::err_attribute_missing_on_first_decl) << EA;
3760 bool OldOvl = Old->
hasAttr<OverloadableAttr>();
3771 const Decl *DiagOld = Old;
3773 auto OldIter = llvm::find_if(Old->
redecls(), [](
const Decl *D) {
3774 const auto *A = D->getAttr<OverloadableAttr>();
3775 return A && !A->isImplicit();
3779 DiagOld = OldIter == Old->
redecls_end() ? nullptr : *OldIter;
3784 diag::note_attribute_overloadable_prev_overload)
3799 Diag(OldLocation, diag::note_previous_declaration);
3818 const FunctionType *OldType = cast<FunctionType>(OldQType);
3819 const FunctionType *NewType = cast<FunctionType>(NewQType);
3822 bool RequiresAdjustment =
false;
3824 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC()) {
3830 if (!NewCCExplicit) {
3834 RequiresAdjustment =
true;
3846 RequiresAdjustment =
true;
3853 << (!FirstCCExplicit ?
"" :
3857 Diag(
First->getLocation(), diag::note_previous_declaration);
3865 RequiresAdjustment =
true;
3875 Diag(OldLocation, diag::note_previous_declaration);
3880 RequiresAdjustment =
true;
3887 <<
"'ns_returns_retained'";
3888 Diag(OldLocation, diag::note_previous_declaration);
3893 RequiresAdjustment =
true;
3899 AnyX86NoCallerSavedRegistersAttr *
Attr =
3900 New->
getAttr<AnyX86NoCallerSavedRegistersAttr>();
3902 Diag(OldLocation, diag::note_previous_declaration);
3907 RequiresAdjustment =
true;
3910 if (RequiresAdjustment) {
3920 !New->
hasAttr<GNUInlineAttr>() &&
3929 if (New->
hasAttr<GNUInlineAttr>() &&
3940 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3957 OldDeclaredReturnType)) {
3965 Diag(New->
getLocation(), diag::err_member_def_does_not_match_ret_type)
3970 Diag(OldLocation, PrevDiag) << Old << Old->
getType()
3979 QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
3980 if (OldReturnType != NewReturnType) {
3996 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
3998 if (OldMethod && NewMethod) {
4005 bool IsClassScopeExplicitSpecialization =
4011 !IsClassScopeExplicitSpecialization) {
4017 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4027 if (isa<CXXConstructorDecl>(OldMethod))
4028 NewDiag = diag::err_constructor_redeclared;
4029 else if (isa<CXXDestructorDecl>(NewMethod))
4030 NewDiag = diag::err_destructor_redeclared;
4031 else if (isa<CXXConversionDecl>(NewMethod))
4032 NewDiag = diag::err_conv_function_redeclared;
4034 NewDiag = diag::err_member_redeclared;
4038 Diag(New->
getLocation(), diag::err_member_redeclared_in_instantiation)
4041 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4054 diag::err_definition_of_implicitly_declared_member)
4060 diag::err_definition_of_explicitly_defaulted_member)
4083 if (
const auto *NRA = New->
getAttr<CXX11NoReturnAttr>())
4084 if (!Old->
hasAttr<CXX11NoReturnAttr>()) {
4085 Diag(NRA->getLocation(), diag::err_attribute_missing_on_first_decl)
4094 const CarriesDependencyAttr *CDA = New->
getAttr<CarriesDependencyAttr>();
4095 if (CDA && !Old->
hasAttr<CarriesDependencyAttr>()) {
4096 Diag(CDA->getLocation(),
4097 diag::err_carries_dependency_missing_on_first_decl) << 0;
4099 diag::note_carries_dependency_missing_first_decl) << 0;
4108 QualType OldQTypeForComparison = OldQType;
4113 OldQTypeForComparison =
QualType(OldTypeForComparison, 0);
4128 Diag(OldLocation, PrevDiag);
4130 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4131 Diag(OldLocation, PrevDiag);
4202 bool IsWithoutProtoADef =
false, IsWithProtoADef =
false;
4203 if (WithoutProto == New)
4204 IsWithoutProtoADef = NewDeclIsDefn;
4206 IsWithProtoADef = NewDeclIsDefn;
4208 diag::warn_non_prototype_changes_behavior)
4209 << IsWithoutProtoADef << (WithoutProto->
getNumParams() ? 0 : 1)
4210 << (WithoutProto == Old) << IsWithProtoADef;
4220 !IsWithoutProtoADef)
4230 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
4231 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
4234 assert(!OldProto->hasExceptionSpec() &&
"Exception spec in C");
4236 OldProto->getParamTypes(),
4237 OldProto->getExtProtoInfo());
4243 for (
const auto &ParamType : OldProto->param_types()) {
4246 ParamType,
nullptr,
SC_None,
nullptr);
4249 Params.push_back(Param);
4252 New->setParams(Params);
4288 NewProto->getReturnType());
4289 bool LooseCompatible = !MergedReturn.
isNull();
4291 LooseCompatible && Idx != End; ++Idx) {
4295 NewProto->getParamType(Idx))) {
4296 ArgTypes.push_back(NewParm->
getType());
4300 GNUCompatibleParamWarning Warn = { OldParm, NewParm,
4301 NewProto->getParamType(Idx) };
4302 Warnings.push_back(Warn);
4303 ArgTypes.push_back(NewParm->
getType());
4305 LooseCompatible =
false;
4308 if (LooseCompatible) {
4309 for (
unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
4310 Diag(Warnings[Warn].NewParm->getLocation(),
4311 diag::ext_param_promoted_not_compatible_with_prototype)
4312 << Warnings[Warn].PromotedType
4313 << Warnings[Warn].OldParm->getType();
4314 if (Warnings[Warn].OldParm->getLocation().isValid())
4315 Diag(Warnings[Warn].OldParm->getLocation(),
4316 diag::note_previous_declaration);
4319 if (MergeTypeWithOld)
4339 Diag(OldLocation, diag::note_previous_builtin_declaration)
4344 PrevDiag = diag::note_previous_builtin_declaration;
4348 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4362 Scope *S,
bool MergeTypeWithOld) {
4377 for (
unsigned i = 0, e = New->
getNumParams(); i != e; ++i) {
4391 if (!Merged.isNull() && MergeTypeWithOld)
4414 ni != ne && oi != oe; ++ni, ++oi)
4424 ? diag::err_redefinition_different_type
4425 : diag::err_redeclaration_different_type)
4430 std::tie(PrevDiag, OldLocation)
4432 S.
Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4444 bool MergeTypeWithOld) {
4472 QualType PrevVDTy = PrevVD->getType();
4526 if (MergeTypeWithOld)
4572 if (!shouldLinkPossiblyHiddenDecl(
Previous, New))
4582 OldTemplate = dyn_cast<VarTemplateDecl>(
Previous.getFoundDecl());
4586 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4587 if (checkUsingShadowRedecl<VarTemplateDecl>(*
this, Shadow, NewTemplate))
4590 Old = dyn_cast<VarDecl>(
Previous.getFoundDecl());
4593 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4594 if (checkUsingShadowRedecl<VarDecl>(*
this, Shadow, New))
4631 if (New->
hasAttr<WeakImportAttr>() &&
4633 !Old->
hasAttr<WeakImportAttr>()) {
4640 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
4641 if (!Old->
hasAttr<InternalLinkageAttr>()) {
4645 New->
dropAttr<InternalLinkageAttr>();
4650 if (MostRecent != Old) {
4663 std::tie(PrevDiag, OldLocation) =
4673 Diag(OldLocation, PrevDiag);
4677 Diag(OldLocation, PrevDiag);
4696 Diag(OldLocation, PrevDiag);
4704 Diag(OldLocation, PrevDiag);
4710 Diag(OldLocation, PrevDiag);
4726 Diag(OldLocation, PrevDiag);
4736 Diag(Def->getLocation(), diag::note_previous_definition);
4750 Diag(OldLocation, PrevDiag);
4753 Diag(OldLocation, PrevDiag);
4761 Diag(OldLocation, PrevDiag);
4771 diag::warn_deprecated_redundant_constexpr_static_def);
4780 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4781 Diag(OldLocation, PrevDiag);
4811 StringRef HdrFilename =
4814 auto noteFromModuleOrInclude = [&](
Module *Mod,
4820 if (IncLoc.isValid()) {
4822 Diag(IncLoc, diag::note_redefinition_modules_same_file)
4828 Diag(IncLoc, diag::note_redefinition_include_same_file)
4829 << HdrFilename.str();
4839 if (FNew == FOld && FNewDecLoc.second == FOldDecLoc.second) {
4847 if (FOld && !HSI.isFileMultipleIncludeGuarded(*FOld))
4864 isa<VarTemplateSpecializationDecl>(New) ||
4902 ? S->getMSCurManglingNumber()
4903 : S->getMSLastManglingNumber();
4910 if (isa<CXXRecordDecl>(Tag->
getParent())) {
4925 Decl *ManglingContextDecl;
4926 std::tie(MCtx, ManglingContextDecl) =
4936struct NonCLikeKind {
4948 explicit operator bool() {
return Kind !=
None; }
4956 return {NonCLikeKind::Invalid, {}};
4963 return {NonCLikeKind::BaseClass,
4975 if (
auto *FD = dyn_cast<FieldDecl>(D)) {
4976 if (FD->hasInClassInitializer()) {
4977 auto *
Init = FD->getInClassInitializer();
4978 return {NonCLikeKind::DefaultMemberInit,
4986 if (isa<FriendDecl>(D))
4991 if (isa<StaticAssertDecl>(D) || isa<IndirectFieldDecl>(D) ||
4994 auto *MemberRD = dyn_cast<CXXRecordDecl>(D);
5002 if (MemberRD->isLambda())
5003 return {NonCLikeKind::Lambda, MemberRD->getSourceRange()};
5007 if (MemberRD->isThisDeclarationADefinition()) {
5013 return {
Invalid ? NonCLikeKind::Invalid : NonCLikeKind::None, {}};
5043 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TagFromDeclSpec);
5047 if (NonCLike || ChangesLinkage) {
5048 if (NonCLike.Kind == NonCLikeKind::Invalid)
5051 unsigned DiagID = diag::ext_non_c_like_anon_struct_in_typedef;
5052 if (ChangesLinkage) {
5054 if (NonCLike.Kind == NonCLikeKind::None)
5055 DiagID = diag::err_typedef_changes_linkage;
5057 DiagID = diag::err_non_c_like_anon_struct_in_typedef;
5063 TextToInsert +=
' ';
5066 Diag(FixitLoc, DiagID)
5067 << isa<TypeAliasDecl>(NewTD)
5069 if (NonCLike.Kind != NonCLikeKind::None) {
5070 Diag(NonCLike.Range.getBegin(), diag::note_non_c_like_anon_struct)
5071 << NonCLike.Kind - 1 << NonCLike.Range;
5074 << NewTD << isa<TypeAliasDecl>(NewTD);
5096 if (
const auto *ED = dyn_cast<EnumDecl>(DS.
getRepAsDecl())) {
5097 if (ED->isScopedUsingClassTag())
5104 llvm_unreachable(
"unexpected type specifier");
5114 bool IsExplicitInstantiation,
5116 Decl *TagD =
nullptr;
5131 if (isa<TagDecl>(TagD))
5132 Tag = cast<TagDecl>(TagD);
5134 Tag = CTD->getTemplatedDecl();
5149 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
5186 bool DeclaresAnything =
true;
5190 if (!
Record->getDeclName() &&
Record->isCompleteDefinition() &&
5193 Record->getDeclContext()->isRecord()) {
5207 DeclaresAnything =
false;
5230 Record = dyn_cast<RecordDecl>(Tag);
5243 DeclaresAnything =
false;
5255 if (
Enum->enumerator_begin() ==
Enum->enumerator_end() &&
5256 !
Enum->getIdentifier() && !
Enum->isInvalidDecl())
5257 DeclaresAnything =
false;
5265 DeclaresAnything =
false;
5284 if (!DeclaresAnything) {
5287 Diag(DS.
getBeginLoc(), (IsExplicitInstantiation || !TemplateParams.empty())
5288 ? diag::err_no_declarators
5289 : diag::ext_no_declarators)
5302 unsigned DiagID = diag::warn_standalone_specifier;
5304 DiagID = diag::ext_standalone_specifier;
5345 auto EmitAttributeDiagnostic = [
this, &DS](
const ParsedAttr &AL) {
5346 unsigned DiagnosticId = diag::warn_declspec_attribute_ignored;
5348 DiagnosticId = diag::warn_attribute_ignored;
5349 else if (AL.isRegularKeywordAttribute())
5350 DiagnosticId = diag::err_declspec_keyword_has_no_effect;
5352 DiagnosticId = diag::warn_declspec_attribute_ignored;
5353 Diag(AL.getLoc(), DiagnosticId)
5357 llvm::for_each(DS.
getAttributes(), EmitAttributeDiagnostic);
5358 llvm::for_each(DeclAttrs, EmitAttributeDiagnostic);
5377 RedeclarationKind::ForVisibleRedeclaration);
5382 assert(PrevDecl &&
"Expected a non-null Decl");
5395 SemaRef.
Diag(NameLoc, diag::err_anonymous_record_member_redecl)
5397 SemaRef.
Diag(PrevDecl->
getLocation(), diag::note_previous_declaration);
5403 if (
auto *RD = dyn_cast_if_present<RecordDecl>(D))
5417 if (
Record->isAnonymousStructOrUnion())
5422 const NamedDecl *ND = dyn_cast<NamedDecl>(D);
5456 for (
auto *D : AnonRecord->
decls()) {
5457 if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) &&
5458 cast<NamedDecl>(D)->getDeclName()) {
5474 unsigned OldChainingSize = Chaining.size();
5476 Chaining.append(IF->chain_begin(), IF->chain_end());
5478 Chaining.push_back(VD);
5480 assert(Chaining.size() >= 2);
5483 for (
unsigned i = 0; i < Chaining.size(); i++)
5484 NamedChain[i] = Chaining[i];
5488 VD->
getType(), {NamedChain, Chaining.size()});
5500 Chaining.resize(OldChainingSize);
5515 "Parser allowed 'typedef' as storage class VarDecl.");
5516 switch (StorageClassSpec) {
5530 llvm_unreachable(
"unknown storage class specifier");
5534 assert(
Record->hasInClassInitializer());
5536 for (
const auto *I :
Record->decls()) {
5537 const auto *FD = dyn_cast<FieldDecl>(I);
5538 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
5539 FD = IFD->getAnonField();
5540 if (FD && FD->hasInClassInitializer())
5541 return FD->getLocation();
5544 llvm_unreachable(
"couldn't find in-class initializer");
5549 if (!
Parent->isUnion() || !
Parent->hasInClassInitializer())
5552 S.
Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
5558 if (!
Parent->isUnion() || !
Parent->hasInClassInitializer())
5576 Diag(
Record->getLocation(), diag::ext_anonymous_union);
5578 Diag(
Record->getLocation(), diag::ext_gnu_anonymous_struct);
5580 Diag(
Record->getLocation(), diag::ext_c11_anonymous_struct);
5586 const char *PrevSpec =
nullptr;
5597 !cast<NamespaceDecl>(OwnerScope)->isAnonymousNamespace()))) {
5598 Diag(
Record->getLocation(), diag::err_anonymous_union_not_static)
5603 PrevSpec, DiagID, Policy);
5609 isa<RecordDecl>(Owner)) {
5611 diag::err_anonymous_union_with_storage_spec)
5625 <<
Record->isUnion() <<
"const"
5629 diag::ext_anonymous_struct_union_qualified)
5630 <<
Record->isUnion() <<
"volatile"
5634 diag::ext_anonymous_struct_union_qualified)
5635 <<
Record->isUnion() <<
"restrict"
5639 diag::ext_anonymous_struct_union_qualified)
5640 <<
Record->isUnion() <<
"_Atomic"
5644 diag::ext_anonymous_struct_union_qualified)
5645 <<
Record->isUnion() <<
"__unaligned"
5655 for (
auto *Mem :
Record->decls()) {
5657 if (Mem->isInvalidDecl())
5660 if (
auto *FD = dyn_cast<FieldDecl>(Mem)) {
5664 assert(FD->getAccess() !=
AS_none);
5666 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
5678 }
else if (Mem->isImplicit()) {
5680 }
else if (isa<TagDecl>(Mem) && Mem->getDeclContext() !=
Record) {
5685 }
else if (
auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
5686 if (!MemRecord->isAnonymousStructOrUnion() &&
5687 MemRecord->getDeclName()) {
5690 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
5694 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
5702 Diag(MemRecord->getLocation(),
5703 diag::ext_anonymous_record_with_anonymous_type)
5706 }
else if (isa<AccessSpecDecl>(Mem)) {
5708 }
else if (isa<StaticAssertDecl>(Mem)) {
5713 unsigned DK = diag::err_anonymous_record_bad_member;
5714 if (isa<TypeDecl>(Mem))
5715 DK = diag::err_anonymous_record_with_type;
5716 else if (isa<FunctionDecl>(Mem))
5717 DK = diag::err_anonymous_record_with_function;
5718 else if (isa<VarDecl>(Mem))
5719 DK = diag::err_anonymous_record_with_static;
5723 DK == diag::err_anonymous_record_with_type)
5724 Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
5727 Diag(Mem->getLocation(), DK) <<
Record->isUnion();
5736 if (cast<CXXRecordDecl>(
Record)->hasInClassInitializer() &&
5739 cast<CXXRecordDecl>(
Record));
5743 Diag(
Record->getLocation(), diag::err_anonymous_struct_not_member)
5764 assert(TInfo &&
"couldn't build declarator info for anonymous struct/union");
5768 if (
RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
5784 Diag(
Record->getLocation(), diag::err_mutable_nonmember);
5790 Record->getLocation(),
nullptr,
5803 Record->setAnonymousStructOrUnion(
true);
5814 Chain.push_back(Anon);
5820 if (
VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
5823 Decl *ManglingContextDecl;
5824 std::tie(MCtx, ManglingContextDecl) =
5856 assert(
Record &&
"expected a record!");
5861 assert(TInfo &&
"couldn't build declarator info for anonymous struct");
5863 auto *ParentDecl = cast<RecordDecl>(
CurContext);
5869 nullptr, RecTy, TInfo,
5881 Chain.push_back(Anon);
5885 diag::err_field_incomplete_or_sizeless) ||
5890 ParentDecl->setInvalidDecl();
5906 NameInfo.
setLoc(Name.StartLocation);
5908 switch (Name.getKind()) {
5912 NameInfo.
setName(Name.Identifier);
5928 if (!Template || !isa<ClassTemplateDecl>(Template)) {
5929 Diag(Name.StartLocation,
5930 diag::err_deduction_guide_name_not_class_template)
5944 Name.OperatorFunctionId.Operator));
5946 Name.OperatorFunctionId.SymbolLocations[0], Name.EndLocation));
5982 if (!CurClass || CurClass->
getIdentifier() != Name.TemplateId->Name)
6018 llvm_unreachable(
"Unknown name kind");
6046 for (
unsigned Idx = 0; Idx <
Declaration->param_size(); ++Idx) {
6060 (DeclTyName && DeclTyName == DefTyName))
6061 Params.push_back(Idx);
6088#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case DeclSpec::TST_##Trait:
6089#include "clang/Basic/TransformTypeTraits.def"
6104 if (!TSI)
return true;
6117 if (
Result.isInvalid())
return true;
6162 << D << static_cast<int>(Status);
6173 if (
OpenMP().getOMPTraitInfoForSurroundingScope()->isExtensionActive(
6174 llvm::omp::TraitProperty::
6175 implementation_extension_bind_to_declaration))
6207 Diag(NameInfo.
getLoc(), diag::err_member_name_of_class) << Name;
6236 bool IsMemberSpecialization) {
6237 assert(SS.
isValid() &&
"diagnoseQualifiedDeclaration called for declaration "
6238 "without nested-name-specifier");
6240 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
6254 Diag(Loc,
LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
6255 : diag::err_member_extra_qualification)
6259 Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name;
6267 if (!Cur->
Encloses(DC) && !(TemplateId || IsMemberSpecialization)) {
6269 Diag(Loc, diag::err_member_qualification)
6271 else if (isa<TranslationUnitDecl>(DC))
6272 Diag(Loc, diag::err_invalid_declarator_global_scope)
6274 else if (isa<FunctionDecl>(Cur))
6275 Diag(Loc, diag::err_invalid_declarator_in_function)
6277 else if (isa<BlockDecl>(Cur))
6278 Diag(Loc, diag::err_invalid_declarator_in_block)
6280 else if (isa<ExportDecl>(Cur)) {
6281 if (!isa<NamespaceDecl>(DC))
6282 Diag(Loc, diag::err_export_non_namespace_scope_name)
6289 Diag(Loc, diag::err_invalid_declarator_scope)
6290 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.
getRange();
6297 Diag(Loc, diag::err_member_qualification)
6323 Diag(Loc, diag::ext_template_after_declarative_nns)
6330 Diag(Loc, diag::ext_template_after_declarative_nns)
6341 if (TST->isDependentType() && TST->isTypeAlias())
6342 Diag(Loc, diag::ext_alias_template_in_declarative_nns)
6351 Diag(Loc, diag::err_computed_type_in_declarative_nns)
6355 }
while ((SpecLoc = SpecLoc.
getPrefix()));
6388 if (!DC || isa<EnumDecl>(DC)) {
6394 diag::err_template_qualified_declarator_no_match)
6401 if (!IsDependentContext &&
6406 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->
hasDefinition()) {
6408 diag::err_member_def_undefined_record)
6429 if (EnteringContext && IsDependentContext &&
6430 TemplateParamLists.size() != 0) {
6449 bool IsLinkageLookup =
false;
6450 bool CreateBuiltins =
false;
6464 IsLinkageLookup =
true;
6469 CreateBuiltins =
true;
6471 if (IsLinkageLookup) {
6474 RedeclarationKind::ForExternalRedeclaration);
6513 bool AllowForCompatibility =
false;
6514 if (
Scope *DeclParent = S->getDeclParent();
6515 Scope *TemplateParamParent = S->getTemplateParamParent()) {
6516 AllowForCompatibility = DeclParent->Contains(*TemplateParamParent) &&
6517 TemplateParamParent->isDeclScope(TPD);
6520 AllowForCompatibility);
6546 S = S->getDeclParent();
6550 bool AddToScope =
true;
6552 if (TemplateParamLists.size()) {
6575 if (
OpenMP().isInOpenMPDeclareTargetContext())
6586 bool &SizeIsNegative,
6587 llvm::APSInt &Oversized) {
6592 SizeIsNegative =
false;
6601 if (
const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
6606 if (FixedType.
isNull())
return FixedType;
6608 return Qs.
apply(Context, FixedType);
6610 if (
const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
6611 QualType Inner = PTy->getInnerType();
6615 if (FixedType.
isNull())
return FixedType;
6617 return Qs.
apply(Context, FixedType);
6627 SizeIsNegative, Oversized);
6637 llvm::APSInt Res =
Result.Val.getInt();
6640 if (Res.isSigned() && Res.isNegative()) {
6641 SizeIsNegative =
true;
6646 unsigned ActiveSizeBits =
6650 : Res.getActiveBits();
6658 return Qs.
apply(Context, FoldedArrayType);
6683 TypeLoc DstElemTL = DstATL.getElementLoc();
6702 bool &SizeIsNegative,
6703 llvm::APSInt &Oversized) {
6706 SizeIsNegative, Oversized);
6719 unsigned FailedFoldDiagID) {
6720 bool SizeIsNegative;
6721 llvm::APSInt Oversized;
6723 TInfo,
Context, SizeIsNegative, Oversized);
6725 Diag(Loc, diag::ext_vla_folded_to_constant);
6732 Diag(Loc, diag::err_typecheck_negative_array_size);
6733 else if (Oversized.getBoolValue())
6734 Diag(Loc, diag::err_array_too_large) <<
toString(Oversized, 10);
6735 else if (FailedFoldDiagID)
6736 Diag(Loc, FailedFoldDiagID);
6768 diag::err_virtual_non_function);
6772 diag::err_explicit_non_function);
6776 diag::err_noreturn_non_function);
6804 diag::err_deduction_guide_invalid_specifier)
6813 if (!NewTD)
return nullptr;
6837 if (S->getFnParent() ==
nullptr) {
6838 bool SizeIsNegative;
6839 llvm::APSInt Oversized;
6852 else if (Oversized.getBoolValue())
6879 Redeclaration =
true;
6885 if (ShadowedDecl && !Redeclaration)
6892 switch (II->getNotableIdentifierID()) {
6893 case tok::NotableIdentifierKind::FILE:
6896 case tok::NotableIdentifierKind::jmp_buf:
6899 case tok::NotableIdentifierKind::sigjmp_buf:
6902 case tok::NotableIdentifierKind::ucontext_t:
6905 case tok::NotableIdentifierKind::float_t:
6906 case tok::NotableIdentifierKind::double_t:
6907 NewTD->
addAttr(AvailableOnlyInDefaultEvalMethodAttr::Create(
Context));
6968 if (!OuterContext->
Equals(PrevOuterContext))
6977 if (!SS.
isSet())
return;
6986 unsigned kind = -1U;
6988 if (var->hasAttr<BlocksAttr>())
6990 else if (!var->hasLocalStorage())
6992 }
else if (isa<ObjCIvarDecl>(
decl)) {
6994 }
else if (isa<FieldDecl>(
decl)) {
6999 Diag(
decl->getLocation(), diag::err_arc_autoreleasing_var)
7004 if (!
type->isObjCLifetimeType())
7007 lifetime =
type->getObjCARCImplicitLifetime();
7015 var->getTLSKind()) {
7016 Diag(var->getLocation(), diag::err_arc_thread_ownership)
7026 if (
Decl->getType().hasAddressSpace())
7028 if (
Decl->getType()->isDependentType())
7040 Var->hasGlobalStorage())
7044 if (
auto DT = dyn_cast<DecayedType>(
Type)) {
7045 auto OrigTy = DT->getOriginalType();
7046 if (!OrigTy.hasAddressSpace() && OrigTy->isArrayType()) {
7078 if (WeakRefAttr *
Attr = ND.
getAttr<WeakRefAttr>()) {
7085 if (
auto *VD = dyn_cast<VarDecl>(&ND)) {
7086 if (VD->hasInit()) {
7087 if (
const auto *
Attr = VD->getAttr<AliasAttr>()) {
7088 assert(VD->isThisDeclarationADefinition() &&
7089 !VD->isExternallyVisible() &&
"Broken AliasAttr handled late!");
7091 VD->dropAttr<AliasAttr>();
7098 if (SelectAnyAttr *
Attr = ND.
getAttr<SelectAnyAttr>()) {
7101 diag::err_attribute_selectany_non_extern_data);
7107 auto *VD = dyn_cast<VarDecl>(&ND);
7108 bool IsAnonymousNS =
false;
7111 const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(VD->getDeclContext());
7112 while (NS && !IsAnonymousNS) {
7114 NS = dyn_cast<NamespaceDecl>(NS->
getParent());
7121 bool AnonNSInMicrosoftMode = IsAnonymousNS && IsMicrosoft;
7123 (!AnonNSInMicrosoftMode &&
7132 if (
const auto *FD = dyn_cast<FunctionDecl>(&ND)) {
7137 for (
TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc();
7143 if (
const auto *A = ATL.
getAttrAs<LifetimeBoundAttr>()) {
7144 const auto *MD = dyn_cast<CXXMethodDecl>(FD);
7145 if (!MD || MD->isStatic()) {
7146 S.
Diag(A->getLocation(), diag::err_lifetimebound_no_object_param)
7147 << !MD << A->getRange();
7148 }
else if (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)) {
7149 S.
Diag(A->getLocation(), diag::err_lifetimebound_ctor_dtor)
7150 << isa<CXXDestructorDecl>(MD) << A->getRange();
7159 bool IsSpecialization,
7160 bool IsDefinition) {
7164 bool IsTemplate =
false;
7165 if (
TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl)) {
7166 OldDecl = OldTD->getTemplatedDecl();
7168 if (!IsSpecialization)
7169 IsDefinition =
false;
7171 if (
TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl)) {
7172 NewDecl = NewTD->getTemplatedDecl();
7176 if (!OldDecl || !NewDecl)
7179 const DLLImportAttr *OldImportAttr = OldDecl->
getAttr<DLLImportAttr>();
7180 const DLLExportAttr *OldExportAttr = OldDecl->
getAttr<DLLExportAttr>();
7181 const DLLImportAttr *NewImportAttr = NewDecl->
getAttr<DLLImportAttr>();
7182 const DLLExportAttr *NewExportAttr = NewDecl->
getAttr<DLLExportAttr>();
7186 bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
7187 (NewExportAttr && !NewExportAttr->isInherited());
7193 bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
7195 if (AddsAttr && !IsSpecialization && !OldDecl->
isImplicit()) {
7197 bool JustWarn =
false;
7199 auto *VD = dyn_cast<VarDecl>(OldDecl);
7200 if (VD && !VD->getDescribedVarTemplate())
7202 auto *FD = dyn_cast<FunctionDecl>(OldDecl);
7211 if (!isa<FunctionDecl>(OldDecl) || !NewImportAttr)
7214 unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
7215 : diag::err_attribute_dll_redeclaration;
7218 << (NewImportAttr ? (
const Attr *)NewImportAttr : NewExportAttr);
7231 bool IsInline =
false, IsStaticDataMember =
false, IsQualifiedFriend =
false;
7233 if (
const auto *VD = dyn_cast<VarDecl>(NewDecl)) {
7236 IsStaticDataMember = VD->isStaticDataMember();
7237 IsDefinition = VD->isThisDeclarationADefinition(S.
Context) !=
7239 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
7240 IsInline = FD->isInlined();
7241 IsQualifiedFriend = FD->getQualifier() &&
7245 if (OldImportAttr && !HasNewAttr &&
7246 (!IsInline || (IsMicrosoftABI && IsTemplate)) && !IsStaticDataMember &&
7248 if (IsMicrosoftABI && IsDefinition) {
7249 if (IsSpecialization) {
7252 diag::err_attribute_dllimport_function_specialization_definition);
7253 S.
Diag(OldImportAttr->getLocation(), diag::note_attribute);
7254 NewDecl->
dropAttr<DLLImportAttr>();
7257 diag::warn_redeclaration_without_import_attribute)
7260 NewDecl->
dropAttr<DLLImportAttr>();
7261 NewDecl->
addAttr(DLLExportAttr::CreateImplicit(
7262 S.
Context, NewImportAttr->getRange()));
7264 }
else if (IsMicrosoftABI && IsSpecialization) {
7265 assert(!IsDefinition);
7269 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
7270 << NewDecl << OldImportAttr;
7272 S.
Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
7273 OldDecl->
dropAttr<DLLImportAttr>();
7274 NewDecl->
dropAttr<DLLImportAttr>();
7276 }
else if (IsInline && OldImportAttr && !IsMicrosoftABI) {
7279 OldDecl->
dropAttr<DLLImportAttr>();
7280 NewDecl->
dropAttr<DLLImportAttr>();
7282 diag::warn_dllimport_dropped_from_inline_function)
7283 << NewDecl << OldImportAttr;
7290 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDecl)) {
7292 !NewImportAttr && !NewExportAttr) {
7293 if (
const DLLExportAttr *ParentExportAttr =
7294 MD->getParent()->getAttr<DLLExportAttr>()) {
7295 DLLExportAttr *NewAttr = ParentExportAttr->clone(S.
Context);
7296 NewAttr->setInherited(
true);
7340 if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>())
7344 if (S.
getLangOpts().CUDA && (D->template hasAttr<CUDADeviceAttr>() ||
7345 D->template hasAttr<CUDAHostAttr>()))
7348 return D->isExternC();
7354 isa<OMPDeclareMapperDecl>(DC))
7363 if (isa<RequiresExprBodyDecl>(DC))
7365 llvm_unreachable(
"Unexpected context");
7371 isa<OMPDeclareReductionDecl>(DC) || isa<OMPDeclareMapperDecl>(DC))
7375 llvm_unreachable(
"Unexpected context");
7422 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
7423 return FD->isExternC();
7424 if (
const auto *VD = dyn_cast<VarDecl>(D))
7425 return VD->isExternC();
7427 llvm_unreachable(
"Unknown type of decl!");
7440 diag::err_opencl_type_can_only_be_used_as_function_parameter)
7454 diag::err_invalid_type_for_program_scope_var)
7483 Se.
Diag(NewVD->
getLocation(), diag::err_opencl_half_declaration) << R;
7516 Se.
Diag(NewVD->
getLocation(), diag::err_opencl_nonconst_global_sampler);
7526template <
typename AttrTy>
7529 if (
const auto *Attribute = TND->
getAttr<AttrTy>()) {
7530 AttrTy *Clone = Attribute->clone(S.
Context);
7531 Clone->setInherited(
true);
7559 if (
const auto *ConstDecl = RD->
getAttr<ReadOnlyPlacementAttr>()) {
7561 S.
Diag(ConstDecl->getLocation(), diag::note_enforce_read_only_placement);
7574 bool IsPlaceholderVariable =
false;
7580 if (!Decomp.bindings().empty()) {
7581 II = Decomp.bindings()[0].Name;
7595 IsPlaceholderVariable =
true;
7613 bool IsLocalExternDecl = SC ==
SC_Extern &&
7632 : diag::warn_deprecated_register)
7638 if (!DC->
isRecord() && S->getFnParent() ==
nullptr) {
7654 bool IsMemberSpecialization =
false;
7655 bool IsVariableTemplateSpecialization =
false;
7657 bool IsVariableTemplate =
false;
7685 diag::err_static_out_of_line)
7697 diag::err_storage_class_for_static_member)
7701 llvm_unreachable(
"C storage class in c++!");
7706 if (
const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
7712 if (Ctxt->isFunctionOrMethod()) {
7713 FunctionOrMethod = Ctxt;
7716 const CXXRecordDecl *ParentDecl = dyn_cast<CXXRecordDecl>(Ctxt);
7718 AnonStruct = ParentDecl;
7722 if (FunctionOrMethod) {
7726 diag::err_static_data_member_not_allowed_in_local_class)
7727 << Name << RD->getDeclName()
7728 << llvm::to_underlying(RD->getTagKind());
7729 }
else if (AnonStruct) {
7734 diag::err_static_data_member_not_allowed_in_anon_struct)
7735 << Name << llvm::to_underlying(AnonStruct->
getTagKind());
7737 }
else if (RD->isUnion()) {
7742 ? diag::warn_cxx98_compat_static_data_member_in_union
7743 : diag::ext_static_data_member_in_union) << Name;
7750 bool InvalidScope =
false;
7758 false, IsMemberSpecialization, InvalidScope);
7761 if (TemplateParams) {
7762 if (!TemplateParams->
size() &&
7767 diag::err_template_variable_noparams)
7771 TemplateParams =
nullptr;
7779 IsVariableTemplateSpecialization =
true;
7783 IsVariableTemplate =
true;
7788 ? diag::warn_cxx11_compat_variable_template
7789 : diag::ext_variable_template);
7794 if (!TemplateParamLists.empty() && IsMemberSpecialization &&
7799 "should have a 'template<>' for this decl");
7802 if (IsVariableTemplateSpecialization) {
7804 TemplateParamLists.size() > 0
7805 ? TemplateParamLists[0]->getTemplateLoc()
7808 S, D, TInfo,
Previous, TemplateKWLoc, TemplateParams, SC,
7812 NewVD = cast<VarDecl>(Res.
get());
7823 if (IsVariableTemplate) {
7826 TemplateParams, NewVD);
7847 bool IsExplicitSpecialization =
7849 unsigned VDTemplateParamLists =
7850 (TemplateParams && !IsExplicitSpecialization) ? 1 : 0;
7851 if (TemplateParamLists.size() > VDTemplateParamLists)
7853 Context, TemplateParamLists.drop_back(VDTemplateParamLists));
7863 diag::err_inline_declaration_block_scope) << Name
7868 : diag::ext_inline_variable);
7879 if (IsLocalExternDecl) {
7882 B->setLocalExternDecl();
7887 bool EmitTLSUnsupportedError =
false;
7900 diag::err_thread_non_global)
7908 EmitTLSUnsupportedError =
true;
7915 diag::err_thread_unsupported);
7926 diag::err_constexpr_wrong_decl_kind)
7944 diag::err_constinit_local_variable);
7948 ConstInitAttr::Keyword_constinit));
7961 if (SC ==
SC_Static && S->getFnParent() !=
nullptr &&
7966 diag::warn_static_local_in_extern_inline);
7972 if (IsVariableTemplateSpecialization)
7977 else if (IsMemberSpecialization)
7992 B->setModulePrivate();
8002 diag::err_opencl_unknown_type_specifier)
8012 if (
const auto *ATy = dyn_cast<ArrayType>(NewVD->
getType())) {
8013 if (ATy && ATy->getElementType().isWebAssemblyReferenceType() &&
8030 copyAttrFromTypedefToDecl<AllocSizeAttr>(*
this, NewVD, TT);
8034 if (EmitTLSUnsupportedError &&
8037 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(NewVD))))
8039 diag::err_thread_unsupported);
8041 if (EmitTLSUnsupportedError &&
8047 if (SC ==
SC_None && S->getFnParent() !=
nullptr &&
8048 (NewVD->
hasAttr<CUDASharedAttr>() ||
8049 NewVD->
hasAttr<CUDAConstantAttr>())) {
8057 assert(!NewVD->
hasAttr<DLLImportAttr>() ||
8058 NewVD->
getAttr<DLLImportAttr>()->isInherited() ||
8071 if (S->getFnParent() !=
nullptr) {
8075 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) <<
Label;
8081 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) <<
Label;
8092 bool HasSizeMismatch;
8094 if (!TI.isValidGCCRegisterName(
Label))
8095 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) <<
Label;
8096 else if (!TI.validateGlobalRegisterVariable(
Label,
8099 Diag(E->getExprLoc(), diag::err_asm_invalid_global_var_reg) <<
Label;
8100 else if (HasSizeMismatch)
8101 Diag(E->getExprLoc(), diag::err_asm_register_size_mismatch) <<
Label;
8114 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
8136 IsMemberSpecialization ||
8137 IsVariableTemplateSpecialization);
8151 if (IsMemberSpecialization && !IsVariableTemplateSpecialization &&
8158 isa<FieldDecl>(
Previous.getFoundDecl()) &&
8168 !IsVariableTemplateSpecialization) {
8176 if (!IsPlaceholderVariable)
8207 if (PrevVarTemplate &&
8227 Decl *ManglingContextDecl;
8228 std::tie(MCtx, ManglingContextDecl) =
8239 if (Name.getAsIdentifierInfo() && Name.getAsIdentifierInfo()->isStr(
"main") &&
8289 if (isa<TypeAliasDecl>(ShadowedDecl))
8291 else if (isa<TypedefDecl>(ShadowedDecl))
8293 else if (isa<BindingDecl>(ShadowedDecl))
8295 else if (isa<RecordDecl>(OldDC))
8334 return isa<VarDecl, FieldDecl, BindingDecl>(ShadowedDecl) ? ShadowedDecl
8350 return isa<TypedefNameDecl>(ShadowedDecl) ? ShadowedDecl :
nullptr;
8361 return isa<VarDecl, FieldDecl, BindingDecl>(ShadowedDecl) ? ShadowedDecl
8378 if (
FieldDecl *FD = dyn_cast<FieldDecl>(ShadowedDecl)) {
8386 if (isa<CXXConstructorDecl>(NewDC))
8387 if (
const auto PVD = dyn_cast<ParmVarDecl>(D)) {
8390 ShadowingDecls.insert({PVD->getCanonicalDecl(), FD});
8395 if (
VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
8396 if (shadowedVar->isExternC()) {
8399 for (
auto *I : shadowedVar->redecls())
8400 if (I->isFileVarDecl()) {
8408 unsigned WarningDiag = diag::warn_decl_shadow;
8410 if (isa<VarDecl>(D) && NewDC && isa<CXXMethodDecl>(NewDC)) {
8411 if (
const auto *RD = dyn_cast<CXXRecordDecl>(NewDC->
getParent())) {
8413 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl)) {
8415 if (RD->getLambdaCaptureDefault() ==
LCD_None) {
8421 WarningDiag = diag::warn_decl_shadow_uncaptured_local;
8427 ->ShadowingDecls.push_back({D, VD});
8431 if (isa<FieldDecl>(ShadowedDecl)) {
8438 ->ShadowingDecls.push_back({D, ShadowedDecl});
8442 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl);
8443 VD && VD->hasLocalStorage()) {
8447 ParentDC && !ParentDC->
Equals(OldDC);
8451 if (!isa<BlockDecl>(ParentDC) && !isa<CapturedDecl>(ParentDC) &&
8485 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
8494 const NamedDecl *ShadowedDecl = Shadow.ShadowedDecl;
8497 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl)) {
8499 Diag(Shadow.VD->getLocation(),
8500 CaptureLoc.
isInvalid() ? diag::warn_decl_shadow_uncaptured_local
8501 : diag::warn_decl_shadow)
8502 << Shadow.VD->getDeclName()
8505 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
8506 << Shadow.VD->getDeclName() << 0;
8508 }
else if (isa<FieldDecl>(ShadowedDecl)) {
8509 Diag(Shadow.VD->getLocation(),
8511 : diag::warn_decl_shadow_uncaptured_local)
8512 << Shadow.VD->getDeclName()
8526 RedeclarationKind::ForVisibleRedeclaration);
8539 auto *DRE = dyn_cast<DeclRefExpr>(E);
8542 const NamedDecl *D = cast<NamedDecl>(DRE->getDecl()->getCanonicalDecl());
8543 auto I = ShadowingDecls.find(D);
8544 if (I == ShadowingDecls.end())
8546 const NamedDecl *ShadowedDecl = I->second;
8548 Diag(Loc, diag::warn_modifying_shadowing_decl) << D << OldDC;
8553 ShadowingDecls.erase(I);
8561 assert(S.
getLangOpts().CPlusPlus &&
"only C++ has extern \"C\"");
8582 if (!isa<VarDecl>(ND))
8592 if (isa<VarDecl>(*I)) {
8602 if (isa<VarDecl>(*I)) {
8620 assert(Prev &&
"should have found a previous declaration to diagnose");
8622 Prev = FD->getFirstDecl();
8624 Prev = cast<VarDecl>(Prev)->getFirstDecl();
8626 S.
Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
8648 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
8660 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
8680 SemaRef.
Diag(VarLoc, diag::err_c23_constexpr_invalid_type) <<
T;
8690 SemaRef.
Diag(VarLoc, diag::err_c23_constexpr_invalid_type) <<
T;
8696 if (llvm::any_of(RD->
fields(), [&SemaRef, VarLoc](
const FieldDecl *F) {
8697 return CheckC23ConstexprVarType(SemaRef, VarLoc, F->getType());
8753 if (NewVD->
hasAttr<BlocksAttr>()) {
8761 if (!
T.isConstQualified()) {
8762 Diag(NewVD->
getLocation(), diag::err_opencl_invalid_block_declaration)
8768 Diag(NewVD->
getLocation(), diag::err_opencl_extern_block_declaration);
8784 Diag(NewVD->
getLocation(), diag::err_opencl_global_invalid_addr_space)
8785 <<
Scope <<
"global or constant";
8787 Diag(NewVD->
getLocation(), diag::err_opencl_global_invalid_addr_space)
8788 <<
Scope <<
"constant";
8804 if (FD && !FD->
hasAttr<OpenCLKernelAttr>()) {
8816 if (FD && FD->
hasAttr<OpenCLKernelAttr>()) {
8841 && !NewVD->
hasAttr<BlocksAttr>()) {
8863 const auto *ATy = dyn_cast<ConstantArrayType>(
T.getTypePtr());
8864 if (!ATy || ATy->getZExtSize() != 0) {
8866 diag::err_typecheck_wasm_table_must_have_zero_length);
8873 if (isVM || NewVD->
hasAttr<CleanupAttr>() ||
8879 bool SizeIsNegative;
8880 llvm::APSInt Oversized;
8885 FixedT = FixedTInfo->
getType();
8886 else if (FixedTInfo) {
8943 !
T.isWebAssemblyReferenceType()) {
8949 if (isVM && NewVD->
hasAttr<BlocksAttr>()) {
8963 diag::err_constexpr_var_non_literal)) {
8979 llvm::StringMap<bool> CallerFeatureMap;
8982 "sve", CallerFeatureMap)) {
8991 llvm::StringMap<bool> CallerFeatureMap;
9051 dyn_cast<CXXMethodDecl>(BaseND->getCanonicalDecl());
9058 if (Overridden.insert(BaseMD).second) {
9075 return !Overridden.empty();
9081 struct ActOnFDArgs {
9097 : Context(Context), OriginalFD(TypoFD),
9100 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
9106 CDeclEnd = candidate.
end();
9107 CDecl != CDeclEnd; ++CDecl) {
9114 if (
Parent &&
Parent->getCanonicalDecl() == ExpectedParent)
9116 }
else if (!ExpectedParent) {
9125 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
9126 return std::make_unique<DifferentNameValidatorCCC>(*
this);
9152 ActOnFDArgs &ExtraArgs,
bool IsLocalFriend,
Scope *S) {
9158 bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
9160 IsLocalFriend ? diag::err_no_matching_local_friend :
9162 diag::err_member_decl_does_not_match;
9166 RedeclarationKind::ForVisibleRedeclaration);
9174 "Cannot have an ambiguity in previous-declaration lookup");
9176 DifferentNameValidatorCCC CCC(SemaRef.
Context, NewFD,
9178 if (!Prev.
empty()) {
9187 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
9188 NearMatches.push_back(std::make_pair(FD, ParamNum));
9195 IsLocalFriend ?
nullptr : NewDC))) {
9198 ExtraArgs.D.getIdentifierLoc());
9202 CDeclEnd = Correction.
end();
9203 CDecl != CDeclEnd; ++CDecl) {
9210 bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
9223 ExtraArgs.S, ExtraArgs.D,
9226 ExtraArgs.AddToScope);
9234 Decl *Canonical =
Result->getCanonicalDecl();
9237 if ((*I)->getCanonicalDecl() == Canonical)
9244 SemaRef.
PDiag(IsLocalFriend
9245 ? diag::err_no_matching_local_friend_suggest
9246 : diag::err_member_decl_does_not_match_suggest)
9247 << Name << NewDC << IsDefinition);
9252 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
9253 ExtraArgs.D.getIdentifierLoc());
9254 ExtraArgs.D.setRedeclaration(wasRedeclaration);
9260 << Name << NewDC << IsDefinition << NewFD->
getLocation();
9262 bool NewFDisConst =
false;
9264 NewFDisConst = NewMD->isConst();
9267 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
9268 NearMatch != NearMatchEnd; ++NearMatch) {
9271 bool FDisConst = MD && MD->
isConst();
9272 bool IsMember = MD || !IsLocalFriend;
9275 if (
unsigned Idx = NearMatch->second) {
9279 SemaRef.
Diag(Loc, IsMember ? diag::note_member_def_close_param_match
9280 : diag::note_local_decl_close_param_match)
9283 }
else if (FDisConst != NewFDisConst) {
9284 SemaRef.
Diag(FD->
getLocation(), diag::note_member_def_close_const_match)
9288 .getConstQualifierLoc())
9291 .getLocWithOffset(1),
9295 IsMember ? diag::note_member_def_close_match
9296 : diag::note_local_decl_close_match);
9303 default: llvm_unreachable(
"Unknown storage class!");
9308 diag::err_typecheck_sclass_func);
9325 diag::err_static_block_func);
9341 bool &IsVirtualOkay) {
9355 diag::err_c23_constexpr_not_variable);
9358 diag::err_constexpr_wrong_decl_kind)
9359 <<
static_cast<int>(ConstexprKind);
9379 ->isFunctionProtoType()) ||
9383 "Strict prototypes are required");
9404 "Constructors can only be declared in a member context");
9410 isInline,
false, ConstexprKind,
9421 false, ConstexprKind,
9422 TrailingRequiresClause);
9425 if (
Record->isBeingDefined())
9434 IsVirtualOkay =
true;
9446 true, ConstexprKind, TrailingRequiresClause);
9452 diag::err_conv_function_not_member);
9460 IsVirtualOkay =
true;
9465 TrailingRequiresClause);
9468 if (TrailingRequiresClause)
9470 diag::err_trailing_requires_clause_on_deduction_guide)
9482 if (Name.getAsIdentifierInfo() &&
9483 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
9495 IsVirtualOkay = !Ret->isStatic();
9509 true , ConstexprKind, TrailingRequiresClause);
9526 StringRef SizeTypeNames[] = {
"size_t",
"intptr_t",
"uintptr_t",
"ptrdiff_t"};
9534 if (Names.end() != Match)
9539 }
while (DesugaredTy != Ty);
9578 "__cl_clang_non_portable_kernel_param_types", S.
getLangOpts())) {
9580 bool IsStandardLayoutType =
true;
9586 if (!CXXRec->hasDefinition())
9588 if (!CXXRec || !CXXRec->hasDefinition() || !CXXRec->isStandardLayout())
9589 IsStandardLayoutType =
false;
9592 !IsStandardLayoutType)
9640 "__cl_clang_non_portable_kernel_param_types", S.
getLangOpts()) &&
9654 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
9701 S.
Diag(Loc, diag::note_entity_declared_at) << PT;
9724 HistoryStack.push_back(
nullptr);
9733 VisitStack.push_back(RecTy->
getDecl());
9734 assert(VisitStack.back() &&
"First decl null?");
9737 const Decl *Next = VisitStack.pop_back_val();
9739 assert(!HistoryStack.empty());
9741 if (
const FieldDecl *Hist = HistoryStack.pop_back_val())
9742 ValidTypes.insert(Hist->getType().getTypePtr());
9750 if (
const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
9751 HistoryStack.push_back(Field);
9753 QualType FieldTy = Field->getType();
9757 "Unexpected type.");
9762 RD = cast<RecordDecl>(Next);
9766 VisitStack.push_back(
nullptr);
9768 for (
const auto *FD : RD->
fields()) {
9779 VisitStack.push_back(FD);
9791 diag::err_record_with_pointers_kernel_param)
9798 S.
Diag(OrigRecDecl->getLocation(), diag::note_within_field_of_type)
9799 << OrigRecDecl->getDeclName();
9804 I = HistoryStack.begin() + 1,
9805 E = HistoryStack.end();
9818 }
while (!VisitStack.empty());
9834 while (S->isClassScope() ||
9835 (LangOpts.CPlusPlus &&
9836 S->isFunctionPrototypeScope()) ||
9838 (S->getEntity() && S->getEntity()->isTransparentContext()))
9845 unsigned BuiltinID) {
9846 switch (BuiltinID) {
9847 case Builtin::BI__GetExceptionInfo:
9851 case Builtin::BIaddressof:
9852 case Builtin::BI__addressof:
9853 case Builtin::BIforward:
9854 case Builtin::BIforward_like:
9855 case Builtin::BImove:
9856 case Builtin::BImove_if_noexcept:
9857 case Builtin::BIas_const: {
9882 llvm::append_range(TemplateParamLists, TemplateParamListsRef);
9884 if (!TemplateParamLists.empty() && !TemplateParamLists.back()->empty() &&
9885 Invented->getDepth() == TemplateParamLists.back()->getDepth())
9886 TemplateParamLists.back() = Invented;
9888 TemplateParamLists.push_back(Invented);
9898 diag::err_invalid_thread)
9906 bool isFriend =
false;
9908 bool isMemberSpecialization =
false;
9909 bool isFunctionTemplateSpecialization =
false;
9911 bool HasExplicitTemplateArgs =
false;
9914 bool isVirtualOkay =
false;
9921 if (!NewFD)
return nullptr;
9931 if (IsLocalExternDecl)
9940 bool ImplicitInlineCXX20 = !
getLangOpts().CPlusPlusModules ||
9963 if (
Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
9968 if (isVirtual &&
Parent->isUnion()) {
9973 Parent->hasAttr<SYCLSpecialClassAttr>() &&
9976 if (
auto *Def =
Parent->getDefinition())
9977 Def->setInitMethod(
true);
9982 isMemberSpecialization =
false;
9983 isFunctionTemplateSpecialization =
false;
9998 isMemberSpecialization,
Invalid);
9999 if (TemplateParams) {
10004 if (TemplateParams->
size() > 0) {
10012 }
else if (TemplateId) {
10029 Name, TemplateParams,
10035 if (TemplateParamLists.size() > 1) {
10042 isFunctionTemplateSpecialization =
true;
10044 if (TemplateParamLists.size() > 0)
10064 << Name << RemoveRange
10070 HasExplicitTemplateArgs =
true;
10077 if (!TemplateParamLists.empty() && isMemberSpecialization &&
10083 if (TemplateParamLists.size() > 0)
10088 if (isFriend && TemplateId)
10089 isFunctionTemplateSpecialization =
true;
10095 if (isFunctionTemplateSpecialization && TemplateId) {
10096 HasExplicitTemplateArgs =
true;
10127 if (!isVirtualOkay) {
10129 diag::err_virtual_non_function);
10133 diag::err_virtual_out_of_class)
10139 diag::err_virtual_member_function_template)
10158 diag::err_inline_declaration_block_scope) << Name
10168 !isa<CXXDeductionGuideDecl>(NewFD)) {
10172 diag::err_explicit_out_of_class)
10174 }
else if (!isa<CXXConstructorDecl>(NewFD) &&
10175 !isa<CXXConversionDecl>(NewFD)) {
10179 diag::err_explicit_non_ctor_or_conv_function)
10193 if (isa<CXXDestructorDecl>(NewFD) &&
10197 <<
static_cast<int>(ConstexprKind);
10211 diag::err_invalid_consteval_decl_kind)
10219 if (isFunctionTemplateSpecialization) {
10222 Diag(ModulePrivateLoc, diag::err_module_private_specialization)
10257 if (isa<CXXMethodDecl>(NewFD) && DC ==
CurContext &&
10268 if (SC ==
SC_Static && isa<CXXMethodDecl>(NewFD) &&
10283 cast<CXXRecordDecl>(DC)->getDescribedClassTemplate()) ||
10285 ? diag::ext_static_out_of_line : diag::err_static_out_of_line)
10293 if ((Name.getCXXOverloadedOperator() == OO_Delete ||
10294 Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
10309 PendingInlineFuncDecls.insert(NewFD);
10316 isMemberSpecialization ||
10317 isFunctionTemplateSpecialization);
10327 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
10352 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
10356 Params.push_back(Param);
10371 auto *TD = dyn_cast<TagDecl>(NonParmDecl);
10376 if (
auto *ECD = dyn_cast<EnumConstantDecl>(NonParmDecl))
10377 TD = cast<EnumDecl>(ECD->getDeclContext());
10381 DeclContext *TagDC = TD->getLexicalDeclContext();
10385 TD->setDeclContext(NewFD);
10393 if (TagDC != PrototypeTagContext)
10394 TD->setLexicalDeclContext(TagDC);
10408 for (
const auto &AI : FT->param_types()) {
10412 Params.push_back(Param);
10416 "Should not need args for typedef of non-prototype fn");
10420 NewFD->setParams(Params);
10436 !NewFD->
hasAttr<SectionAttr>())
10437 NewFD->
addAttr(PragmaClangTextSectionAttr::CreateImplicit(
10443 !NewFD->
hasAttr<SectionAttr>()) {
10444 NewFD->
addAttr(SectionAttr::CreateImplicit(
10446 CodeSegStack.CurrentPragmaLocation, SectionAttr::Declspec_allocate));
10457 !NewFD->
hasAttr<StrictGuardStackCheckAttr>())
10458 NewFD->
addAttr(StrictGuardStackCheckAttr::CreateImplicit(
10463 if (!NewFD->
hasAttr<CodeSegAttr>()) {
10472 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
10473 if (NewTVA && !NewTVA->isDefaultVersion() &&
10476 AddToScope =
false;
10488 Diag(NewFD->
getLocation(), diag::err_return_value_with_address_space);
10503 isMemberSpecialization,
10510 "previous declaration set still overloaded");
10522 CC ==
CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
10545 diag::ext_operator_new_delete_declared_inline)
10572 if (isFunctionTemplateSpecialization || isMemberSpecialization) {
10584 Diag(TRC->getBeginLoc(), diag::err_non_temp_spec_requires_clause)
10592 diag::err_non_temp_friend_decl_with_requires_clause_must_be_def);
10596 Diag(TRC->getBeginLoc(),
10597 diag::err_constrained_non_templated_function);
10614 if (isFunctionTemplateSpecialization) {
10615 bool isDependentSpecialization =
false;
10620 isDependentSpecialization =
10622 (HasExplicitTemplateArgs &&
10626 assert((!isDependentSpecialization ||
10627 (HasExplicitTemplateArgs == isDependentSpecialization)) &&
10628 "dependent friend function specialization without template "
10634 isDependentSpecialization =
10639 HasExplicitTemplateArgs ? &TemplateArgs :
nullptr;
10640 if (isDependentSpecialization) {
10647 NewFD, ExplicitTemplateArgs,
Previous))
10664 diag::err_explicit_specialization_inconsistent_storage_class)
10671 diag::ext_explicit_specialization_storage_class)
10675 }
else if (isMemberSpecialization && isa<CXXMethodDecl>(NewFD)) {
10689 isMemberSpecialization,
10698 "previous declaration set still overloaded");
10739 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
10785 *
this,
Previous, NewFD, ExtraArgs,
false,
nullptr)) {
10786 AddToScope = ExtraArgs.AddToScope;
10793 }
else if (isFriend && cast<CXXRecordDecl>(
CurContext)->isLocalClass()) {
10795 *
this,
Previous, NewFD, ExtraArgs,
true, S)) {
10796 AddToScope = ExtraArgs.AddToScope;
10801 isa<CXXMethodDecl>(NewFD) && NewFD->
isOutOfLine() &&
10802 !isFriend && !isFunctionTemplateSpecialization &&
10803 !isMemberSpecialization) {
10818 if (!NewFD->
isInvalidDecl() && S->getDepth() == 0 && Name.isIdentifier())
10821 if (NewFD->
hasAttr<HLSLShaderAttr>())
10829 if (
unsigned BuiltinID = II->getBuiltinID()) {
10831 if (!InStdNamespace &&
10837 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10846 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10851 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10862 if (NewFD->
hasAttr<OverloadableAttr>() &&
10865 diag::err_attribute_overloadable_no_prototype)
10867 NewFD->
dropAttr<OverloadableAttr>();
10900 isMemberSpecialization ||
10901 isFunctionTemplateSpecialization,
10907 if (II && II->
isStr(
CUDA().getConfigureFuncName()) &&
10920 (NewFD->
hasAttr<CUDADeviceAttr>() ||
10921 NewFD->
hasAttr<CUDAGlobalAttr>()) &&
10976 diag::err_friend_decl_with_enclosing_temp_constraint_must_be_def);
10996 if (
getLangOpts().getOpenCLCompatibleVersion() >= 200) {
10998 QualType ElemTy = PipeTy->getElementType();
11000 Diag(Param->getTypeSpecStartLoc(), diag::err_reference_pipe_type );
11008 Diag(Param->getTypeSpecStartLoc(),
11009 diag::err_wasm_table_as_function_parameter);
11017 if (
const auto *
attr = NewFD->
getAttr<AvailabilityAttr>()) {
11018 if (NewFD->
hasAttr<ConstructorAttr>()) {
11019 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
11021 NewFD->
dropAttr<AvailabilityAttr>();
11023 if (NewFD->
hasAttr<DestructorAttr>()) {
11024 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
11026 NewFD->
dropAttr<AvailabilityAttr>();
11037 if (
const auto *NBA = NewFD->
getAttr<NoBuiltinAttr>())
11041 Diag(NBA->getLocation(),
11042 diag::err_attribute_no_builtin_on_defaulted_deleted_function)
11043 << NBA->getSpelling();
11046 Diag(NBA->getLocation(), diag::err_attribute_no_builtin_on_non_definition)
11047 << NBA->getSpelling();
11067 const auto *Method = dyn_cast<CXXMethodDecl>(FD);
11071 if (
const auto *SAttr =
Parent->getAttr<CodeSegAttr>()) {
11082 while ((
Parent = dyn_cast<CXXRecordDecl>(
Parent->getParent()))) {
11083 if (
const auto *SAttr =
Parent->getAttr<CodeSegAttr>()) {
11102 bool IsDefinition) {
11105 if (!FD->
hasAttr<SectionAttr>() && IsDefinition &&
11107 return SectionAttr::CreateImplicit(
11109 CodeSegStack.CurrentPragmaLocation, SectionAttr::Declspec_allocate);
11174 auto *VD = dyn_cast<ValueDecl>(D);
11175 auto *PrevVD = dyn_cast<ValueDecl>(PrevDecl);
11176 return !VD || !PrevVD ||
11178 PrevVD->getType());
11186 const auto *TA = FD->
getAttr<TargetAttr>();
11187 const auto *TVA = FD->
getAttr<TargetVersionAttr>();
11190 "MultiVersion candidate requires a target or target_version attribute");
11202 for (
const auto &Feat : ParseInfo.
Features) {
11203 auto BareFeat = StringRef{Feat}.substr(1);
11204 if (Feat[0] ==
'-') {
11206 << Feature << (
"no-" + BareFeat).str();
11213 << Feature << BareFeat;
11221 TVA->getFeatures(Feats);
11222 for (
const auto &Feat : Feats) {
11225 << Feature << Feat;
11244 case attr::NonNull:
11245 case attr::NoThrow:
11254 const auto Diagnose = [FD, CausedFD, MVKind](
Sema &S,
const Attr *A) {
11255 S.
Diag(FD->
getLocation(), diag::err_multiversion_disallowed_other_attr)
11256 <<
static_cast<unsigned>(MVKind) << A;
11258 S.
Diag(CausedFD->
getLocation(), diag::note_multiversioning_caused_here);
11263 switch (A->getKind()) {
11264 case attr::CPUDispatch:
11265 case attr::CPUSpecific:
11268 return Diagnose(S, A);
11272 return Diagnose(S, A);
11274 case attr::TargetVersion:
11277 return Diagnose(S, A);
11279 case attr::TargetClones:
11282 return Diagnose(S, A);
11286 return Diagnose(S, A);
11299 bool ConstexprSupported,
bool CLinkageMayDiffer) {
11300 enum DoesntSupport {
11307 DefaultedFuncs = 6,
11308 ConstexprFuncs = 7,
11309 ConstevalFuncs = 8,
11321 if (NoProtoDiagID.
getDiagID() != 0 && OldFD &&
11324 Diag(NoteCausedDiagIDAt.first, NoteCausedDiagIDAt.second);
11332 if (!TemplatesSupported &&
11334 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11337 if (
const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) {
11338 if (NewCXXFD->isVirtual())
11339 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11342 if (isa<CXXConstructorDecl>(NewCXXFD))
11343 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11346 if (isa<CXXDestructorDecl>(NewCXXFD))
11347 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11352 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11356 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11360 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11361 << (NewFD->
isConsteval() ? ConstevalFuncs : ConstexprFuncs);
11364 const auto *NewType = cast<FunctionType>(NewQType);
11365 QualType NewReturnType = NewType->getReturnType();
11368 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11374 const auto *OldType = cast<FunctionType>(OldQType);
11378 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC())
11381 QualType OldReturnType = OldType->getReturnType();
11383 if (OldReturnType != NewReturnType)
11384 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ReturnType;
11387 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ConstexprSpec;
11390 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << InlineSpec;
11393 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) <<
Linkage;
11417 bool IsCPUSpecificCPUDispatchMVKind =
11421 if (CausesMV && OldFD &&
11429 if (OldFD && CausesMV && OldFD->
isUsed(
false))
11430 return S.
Diag(NewFD->
getLocation(), diag::err_multiversion_after_used);
11433 OldFD, NewFD, S.
PDiag(diag::err_multiversion_noproto),
11435 S.
PDiag(diag::note_multiversioning_caused_here)),
11437 S.
PDiag(diag::err_multiversion_doesnt_support)
11438 <<
static_cast<unsigned>(MVKind)),
11440 S.
PDiag(diag::err_multiversion_diff)),
11442 !IsCPUSpecificCPUDispatchMVKind,
11455 "Function lacks multiversion attribute");
11456 const auto *TA = FD->
getAttr<TargetAttr>();
11457 const auto *TVA = FD->
getAttr<TargetVersionAttr>();
11460 if (TA && !TA->isDefaultVersion())
11497 To->
addAttr(TargetVersionAttr::CreateImplicit(
11504 bool &Redeclaration,
11514 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11515 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11516 const auto *OldTA = OldFD->
getAttr<TargetAttr>();
11517 const auto *OldTVA = OldFD->
getAttr<TargetVersionAttr>();
11520 if ((NewTA && !NewTA->isDefaultVersion() &&
11521 (!OldTA || OldTA->getFeaturesStr() == NewTA->getFeaturesStr())) ||
11522 (NewTVA && !NewTVA->isDefaultVersion() &&
11523 (!OldTVA || OldTVA->getName() == NewTVA->getName())))
11540 if ((NewTA && NewTA->isDefaultVersion() && !OldTA) ||
11541 (NewTVA && NewTVA->isDefaultVersion() && !OldTVA)) {
11542 Redeclaration =
true;
11550 S.
Diag(NewFD->
getLocation(), diag::note_multiversioning_caused_here);
11558 OldTA->getFeaturesStr());
11562 NewTA->getFeaturesStr());
11565 if (OldParsed == NewParsed) {
11575 OldTVA->getFeatures(Feats);
11578 NewTVA->getFeatures(NewFeats);
11579 llvm::sort(NewFeats);
11581 if (Feats == NewFeats) {
11589 for (
const auto *FD : OldFD->
redecls()) {
11590 const auto *CurTA = FD->
getAttr<TargetAttr>();
11591 const auto *CurTVA = FD->
getAttr<TargetVersionAttr>();
11595 ((NewTA && (!CurTA || CurTA->isInherited())) ||
11596 (NewTVA && (!CurTVA || CurTVA->isInherited())))) {
11598 << (NewTA ? 0 : 2);
11599 S.
Diag(NewFD->
getLocation(), diag::note_multiversioning_caused_here);
11607 Redeclaration =
false;
11646 const CPUDispatchAttr *NewCPUDisp,
const CPUSpecificAttr *NewCPUSpec,
11647 const TargetClonesAttr *NewClones,
bool &Redeclaration,
NamedDecl *&OldDecl,
11662 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11663 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11670 NewTA->getFeaturesStr());
11675 NewTVA->getFeatures(NewFeats);
11676 llvm::sort(NewFeats);
11679 bool UseMemberUsingDeclRules =
11682 bool MayNeedOverloadableChecks =
11691 if (MayNeedOverloadableChecks &&
11692 S.
IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
11695 switch (NewMVKind) {
11698 "Only target_clones can be omitted in subsequent declarations");
11701 const auto *CurTA = CurFD->
getAttr<TargetAttr>();
11702 if (CurTA->getFeaturesStr() == NewTA->getFeaturesStr()) {
11704 Redeclaration =
true;
11711 CurTA->getFeaturesStr());
11713 if (CurParsed == NewParsed) {
11722 if (
const auto *CurTVA = CurFD->
getAttr<TargetVersionAttr>()) {
11723 if (CurTVA->getName() == NewTVA->getName()) {
11725 Redeclaration =
true;
11730 CurTVA->getFeatures(CurFeats);
11731 llvm::sort(CurFeats);
11733 if (CurFeats == NewFeats) {
11739 }
else if (
const auto *CurClones = CurFD->
getAttr<TargetClonesAttr>()) {
11741 if (NewFeats.empty())
11744 for (
unsigned I = 0; I < CurClones->featuresStrs_size(); ++I) {
11746 CurClones->getFeatures(CurFeats, I);
11747 llvm::sort(CurFeats);
11749 if (CurFeats == NewFeats) {
11760 assert(NewClones &&
"MultiVersionKind does not match attribute type");
11761 if (
const auto *CurClones = CurFD->
getAttr<TargetClonesAttr>()) {
11762 if (CurClones->featuresStrs_size() != NewClones->featuresStrs_size() ||
11763 !std::equal(CurClones->featuresStrs_begin(),
11764 CurClones->featuresStrs_end(),
11765 NewClones->featuresStrs_begin())) {
11771 }
else if (
const auto *CurTVA = CurFD->
getAttr<TargetVersionAttr>()) {
11773 CurTVA->getFeatures(CurFeats);
11774 llvm::sort(CurFeats);
11777 if (CurFeats.empty())
11780 for (
unsigned I = 0; I < NewClones->featuresStrs_size(); ++I) {
11782 NewClones->getFeatures(NewFeats, I);
11783 llvm::sort(NewFeats);
11785 if (CurFeats == NewFeats) {
11794 Redeclaration =
true;
11801 const auto *CurCPUSpec = CurFD->
getAttr<CPUSpecificAttr>();
11802 const auto *CurCPUDisp = CurFD->
getAttr<CPUDispatchAttr>();
11807 CurFD->
hasAttr<CPUDispatchAttr>()) {
11808 if (CurCPUDisp->cpus_size() == NewCPUDisp->cpus_size() &&
11810 CurCPUDisp->cpus_begin(), CurCPUDisp->cpus_end(),
11811 NewCPUDisp->cpus_begin(),
11813 return Cur->getName() == New->getName();
11816 Redeclaration =
true;
11828 if (CurCPUSpec->cpus_size() == NewCPUSpec->cpus_size() &&
11830 CurCPUSpec->cpus_begin(), CurCPUSpec->cpus_end(),
11831 NewCPUSpec->cpus_begin(),
11833 return Cur->getName() == New->getName();
11836 Redeclaration =
true;
11844 if (CurII == NewII) {
11879 Redeclaration =
true;
11885 Redeclaration =
false;
11898 bool &Redeclaration,
NamedDecl *&OldDecl,
11900 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11901 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11902 const auto *NewCPUDisp = NewFD->
getAttr<CPUDispatchAttr>();
11903 const auto *NewCPUSpec = NewFD->
getAttr<CPUSpecificAttr>();
11904 const auto *NewClones = NewFD->
getAttr<TargetClonesAttr>();
11914 NewTVA->isDefaultVersion())) {
11915 S.
Diag(NewFD->
getLocation(), diag::err_multiversion_not_allowed_on_main);
11925 if (NewTA &&
T.isAArch64())
11929 if (NewTA &&
T.isRISCV())
11945 if (NewTVA || !OldFD->
getAttr<TargetVersionAttr>())
11953 NewFD->
addAttr(TargetVersionAttr::CreateImplicit(
11958 Redeclaration =
true;
11968 S.
Diag(NewFD->
getLocation(), diag::err_multiversion_required_in_redecl)
11981 if (OldFD->
isUsed(
false)) {
11983 return S.
Diag(NewFD->
getLocation(), diag::err_multiversion_after_used);
11999 NewCPUSpec, NewClones, Redeclaration,
12004 bool IsPure = NewFD->
hasAttr<PureAttr>();
12005 bool IsConst = NewFD->
hasAttr<ConstAttr>();
12008 if (!IsPure && !IsConst)
12015 if (IsPure && IsConst) {
12025 NewFD->
dropAttrs<PureAttr, ConstAttr>();
12048 bool IsMemberSpecialization,
12051 "Variably modified return types are not handled here");
12056 bool MergeTypeWithPrevious = !
getLangOpts().CPlusPlus &&
12059 bool Redeclaration =
false;
12061 bool MayNeedOverloadableChecks =
false;
12072 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
12073 Redeclaration =
true;
12074 OldDecl = Candidate;
12077 MayNeedOverloadableChecks =
true;
12081 Redeclaration =
true;
12085 Redeclaration =
true;
12089 Redeclaration =
false;
12096 if (!Redeclaration &&
12101 Redeclaration =
true;
12102 OldDecl =
Previous.getFoundDecl();
12103 MergeTypeWithPrevious =
false;
12106 if (OldDecl->
hasAttr<OverloadableAttr>() ||
12107 NewFD->
hasAttr<OverloadableAttr>()) {
12108 if (
IsOverload(NewFD, cast<FunctionDecl>(OldDecl),
false)) {
12109 MayNeedOverloadableChecks =
true;
12110 Redeclaration =
false;
12118 return Redeclaration;
12168 !MD->
isStatic() && !isa<CXXConstructorDecl>(MD) &&
12172 OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->
getAsFunction());
12173 if (!OldMD || !OldMD->
isStatic()) {
12195 if (Redeclaration) {
12201 return Redeclaration;
12208 dyn_cast<FunctionTemplateDecl>(OldDecl)) {
12209 auto *OldFD = OldTemplateDecl->getTemplatedDecl();
12212 assert(NewTemplateDecl &&
"Template/non-template mismatch");
12221 NewFD->
setAccess(OldTemplateDecl->getAccess());
12222 NewTemplateDecl->
setAccess(OldTemplateDecl->getAccess());
12227 if (IsMemberSpecialization &&
12230 assert(OldTemplateDecl->isMemberSpecialization());
12233 if (OldFD->isDeleted()) {
12235 assert(OldFD->getCanonicalDecl() == OldFD);
12237 OldFD->setDeletedAsWritten(
false);
12243 auto *OldFD = cast<FunctionDecl>(OldDecl);
12251 !NewFD->
getAttr<OverloadableAttr>()) {
12255 return ND->hasAttr<OverloadableAttr>();
12257 "Non-redecls shouldn't happen without overloadable present");
12260 const auto *FD = dyn_cast<FunctionDecl>(ND);
12261 return FD && !FD->
hasAttr<OverloadableAttr>();
12264 if (OtherUnmarkedIter !=
Previous.end()) {
12266 diag::err_attribute_overloadable_multiple_unmarked_overloads);
12267 Diag((*OtherUnmarkedIter)->getLocation(),
12268 diag::note_attribute_overloadable_prev_overload)
12285 dyn_cast<CXXDestructorDecl>(NewFD)) {
12293 !
Destructor->getFunctionObjectParameterType()->isDependentType()) {
12302 return Redeclaration;
12305 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(NewFD)) {
12306 if (
auto *TD = Guide->getDescribedFunctionTemplate())
12312 Diag(Guide->getBeginLoc(), diag::err_deduction_guide_specialized)
12317 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
12318 if (!Method->isFunctionTemplateSpecialization() &&
12319 !Method->getDescribedFunctionTemplate() &&
12320 Method->isCanonicalDecl()) {
12327 diag::err_constrained_virtual_method);
12329 if (Method->isStatic())
12340 return Redeclaration;
12347 return Redeclaration;
12367 Diag(NewFD->
getLocation(), diag::warn_return_value_udt) << NewFD << R;
12380 auto HasNoexcept = [&](
QualType T) ->
bool {
12391 if (FPT->isNothrow())
12397 bool AnyNoexcept = HasNoexcept(FPT->getReturnType());
12399 AnyNoexcept |= HasNoexcept(
T);
12402 diag::warn_cxx17_compat_exception_spec_in_signature)
12406 if (!Redeclaration &&
LangOpts.CUDA)
12415 bool UsesSM = NewFD->
hasAttr<ArmLocallyStreamingAttr>();
12416 bool UsesZA =
Attr &&
Attr->isNewZA();
12417 bool UsesZT0 =
Attr &&
Attr->isNewZT0();
12419 if (NewFD->
hasAttr<ArmLocallyStreamingAttr>()) {
12422 diag::warn_sme_locally_streaming_has_vl_args_returns)
12425 return P->getOriginalType()->isSizelessVectorType();
12428 diag::warn_sme_locally_streaming_has_vl_args_returns)
12441 if (UsesSM || UsesZA) {
12442 llvm::StringMap<bool> FeatureMap;
12444 if (!FeatureMap.contains(
"sme")) {
12447 diag::err_sme_definition_using_sm_in_non_sme_target);
12450 diag::err_sme_definition_using_za_in_non_sme_target);
12454 llvm::StringMap<bool> FeatureMap;
12456 if (!FeatureMap.contains(
"sme2")) {
12458 diag::err_sme_definition_using_zt0_in_non_sme2_target);
12463 return Redeclaration;
12476 ? diag::err_static_main : diag::warn_static_main)
12484 Diag(NoreturnLoc, diag::ext_noreturn_main);
12485 Diag(NoreturnLoc, diag::note_main_remove_noreturn)
12497 << FD->
hasAttr<OpenCLKernelAttr>();
12508 assert(
T->
isFunctionType() &&
"function decl is not of function type");
12530 Diag(RTRange.
getBegin(), diag::note_main_change_return_type)
12552 if (isa<FunctionNoProtoType>(FT))
return;
12558 bool HasExtraParameters = (nparams > 3);
12570 HasExtraParameters =
false;
12572 if (HasExtraParameters) {
12585 for (
unsigned i = 0; i < nparams; ++i) {
12588 bool mismatch =
true;
12605 mismatch = !qs.
empty();
12634 if (
T.isWindowsGNUEnvironment())
12639 if (
T.isOSWindows() &&
T.getArch() == llvm::Triple::x86)
12647 assert(
T->
isFunctionType() &&
"function decl is not of function type");
12656 if (FD->
getName() !=
"DllMain")
12690 if (
Init->isValueDependent()) {
12691 assert(
Init->containsErrors() &&
12692 "Dependent code should only occur in error-recovery path.");
12695 const Expr *Culprit;
12696 if (
Init->isConstantInitializer(
Context,
false, &Culprit))
12705 class SelfReferenceChecker
12711 bool isReferenceType;
12719 SelfReferenceChecker(
Sema &S,
Decl *OrigDecl) : Inherited(S.Context),
12720 S(S), OrigDecl(OrigDecl) {
12723 isReferenceType =
false;
12724 isInitList =
false;
12725 if (
ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
12726 isPODType = VD->getType().isPODType(S.
Context);
12728 isReferenceType = VD->getType()->isReferenceType();
12735 void CheckExpr(
Expr *E) {
12744 InitFieldIndex.push_back(0);
12745 for (
auto *Child : InitList->
children()) {
12746 CheckExpr(cast<Expr>(Child));
12747 ++InitFieldIndex.back();
12749 InitFieldIndex.pop_back();
12754 bool CheckInitListMemberExpr(
MemberExpr *E,
bool CheckReference) {
12757 bool ReferenceField =
false;
12761 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
12764 Fields.push_back(FD);
12766 ReferenceField =
true;
12767 Base = ME->getBase()->IgnoreParenImpCasts();
12772 if (!DRE || DRE->
getDecl() != OrigDecl)
12776 if (CheckReference && !ReferenceField)
12781 for (
const FieldDecl *I : llvm::reverse(Fields))
12782 UsedFieldIndex.push_back(I->getFieldIndex());
12787 for (
auto UsedIter = UsedFieldIndex.begin(),
12788 UsedEnd = UsedFieldIndex.end(),
12789 OrigIter = InitFieldIndex.begin(),
12790 OrigEnd = InitFieldIndex.end();
12791 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
12792 if (*UsedIter < *OrigIter)
12794 if (*UsedIter > *OrigIter)
12799 HandleDeclRefExpr(DRE);
12806 void HandleValue(
Expr *E) {
12808 if (
DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
12809 HandleDeclRefExpr(DRE);
12814 Visit(CO->getCond());
12815 HandleValue(CO->getTrueExpr());
12816 HandleValue(CO->getFalseExpr());
12821 dyn_cast<BinaryConditionalOperator>(E)) {
12822 Visit(BCO->getCond());
12823 HandleValue(BCO->getFalseExpr());
12828 if (
Expr *SE = OVE->getSourceExpr())
12834 if (BO->getOpcode() == BO_Comma) {
12835 Visit(BO->getLHS());
12836 HandleValue(BO->getRHS());
12841 if (isa<MemberExpr>(E)) {
12843 if (CheckInitListMemberExpr(cast<MemberExpr>(E),
12851 if (!isa<FieldDecl>(ME->getMemberDecl()))
12853 Base = ME->getBase()->IgnoreParenImpCasts();
12856 HandleDeclRefExpr(DRE);
12866 if (isReferenceType)
12867 HandleDeclRefExpr(E);
12876 Inherited::VisitImplicitCastExpr(E);
12881 if (CheckInitListMemberExpr(E,
true ))
12891 bool Warn = (MD && !MD->
isStatic());
12894 if (!isa<FieldDecl>(ME->getMemberDecl()))
12896 Base = ME->getBase()->IgnoreParenImpCasts();
12901 HandleDeclRefExpr(DRE);
12913 if (isa<UnresolvedLookupExpr>(Callee))
12914 return Inherited::VisitCXXOperatorCallExpr(E);
12918 HandleValue(Arg->IgnoreParenImpCasts());
12935 Inherited::VisitUnaryOperator(E);
12943 if (
InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
12944 if (ILE->getNumInits() == 1)
12945 ArgExpr = ILE->getInit(0);
12947 if (ICE->getCastKind() == CK_NoOp)
12948 ArgExpr = ICE->getSubExpr();
12949 HandleValue(ArgExpr);
12952 Inherited::VisitCXXConstructExpr(E);
12958 HandleValue(E->
getArg(0));
12962 Inherited::VisitCallExpr(E);
12967 HandleValue(E->
getLHS());
12972 Inherited::VisitBinaryOperator(E);
12985 if (OrigDecl != ReferenceDecl)
return;
12987 if (isReferenceType) {
12988 diag = diag::warn_uninit_self_reference_in_reference_init;
12989 }
else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
12990 diag = diag::warn_static_self_reference_in_init;
12991 }
else if (isa<TranslationUnitDecl>(OrigDecl->
getDeclContext()) ||
12994 diag = diag::warn_uninit_self_reference_in_init;
13008 static void CheckSelfReference(
Sema &S,
Decl* OrigDecl,
Expr *E,
13012 if (isa<ParmVarDecl>(OrigDecl))
13021 if (ICE->getCastKind() == CK_LValueToRValue)
13022 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
13023 if (DRE->
getDecl() == OrigDecl)
13026 SelfReferenceChecker(S, OrigDecl).CheckExpr(E);
13033 struct VarDeclOrName {
13039 return VN.VDecl ?
Diag << VN.VDecl :
Diag << VN.Name;
13049 bool IsInitCapture = !VDecl;
13051 "init captures are expected to be deduced prior to initialization");
13053 VarDeclOrName VN{VDecl, Name};
13056 assert(Deduced &&
"deduceVarTypeFromInitializer for non-deduced type");
13060 !isa_and_present<StringLiteral, InitListExpr>(
Init)) {
13061 Diag(Range.getBegin(), diag::err_auto_not_allowed)
13069 assert(VDecl &&
"no init for init capture deduction?");
13073 if (!isa<DeducedTemplateSpecializationType>(Deduced) ||
13084 DeduceInits =
Init;
13086 auto *PL = dyn_cast_if_present<ParenListExpr>(
Init);
13088 DeduceInits = PL->exprs();
13090 if (isa<DeducedTemplateSpecializationType>(Deduced)) {
13091 assert(VDecl &&
"non-auto type for init capture deduction?");
13102 if (
auto *IL = dyn_cast<InitListExpr>(
Init))
13103 DeduceInits = IL->inits();
13107 if (DeduceInits.empty()) {
13110 Diag(
Init->getBeginLoc(), IsInitCapture
13111 ? diag::err_init_capture_no_expression
13112 : diag::err_auto_var_init_no_expression)
13113 << VN <<
Type << Range;
13117 if (DeduceInits.size() > 1) {
13118 Diag(DeduceInits[1]->getBeginLoc(),
13119 IsInitCapture ? diag::err_init_capture_multiple_expressions
13120 : diag::err_auto_var_init_multiple_expressions)
13121 << VN <<
Type << Range;
13125 Expr *DeduceInit = DeduceInits[0];
13126 if (
DirectInit && isa<InitListExpr>(DeduceInit)) {
13127 Diag(
Init->getBeginLoc(), IsInitCapture
13128 ? diag::err_init_capture_paren_braces
13129 : diag::err_auto_var_init_paren_braces)
13130 << isa<InitListExpr>(
Init) << VN <<
Type << Range;
13135 bool DefaultedAnyToId =
false;
13139 if (
Result.isInvalid()) {
13143 DefaultedAnyToId =
true;
13149 if (VDecl && isa<DecompositionDecl>(VDecl) &&
13153 Type.getQualifiers());
13161 if (!IsInitCapture)
13163 else if (isa<InitListExpr>(
Init))
13164 Diag(Range.getBegin(),
13165 diag::err_init_capture_deduction_failure_from_init_list)
13171 Diag(Range.getBegin(), diag::err_init_capture_deduction_failure)
13186 Diag(Loc, diag::warn_auto_var_is_id) << VN << Range;
13194 assert(!
Init || !
Init->containsErrors());
13228 if (
auto *EWC = dyn_cast<ExprWithCleanups>(
Init))
13229 Init = EWC->getSubExpr();
13231 if (
auto *CE = dyn_cast<ConstantExpr>(
Init))
13232 Init = CE->getSubExpr();
13237 "shouldn't be called if type doesn't have a non-trivial C struct");
13238 if (
auto *ILE = dyn_cast<InitListExpr>(
Init)) {
13239 for (
auto *I : ILE->inits()) {
13240 if (!I->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion() &&
13241 !I->getType().hasNonTrivialToPrimitiveCopyCUnion())
13249 if (isa<ImplicitValueInitExpr>(
Init)) {
13265bool shouldIgnoreForRecordTriviality(
const FieldDecl *FD) {
13271 return FD->
hasAttr<UnavailableAttr>();
13274struct DiagNonTrivalCUnionDefaultInitializeVisitor
13281 DiagNonTrivalCUnionDefaultInitializeVisitor(
13284 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13287 const FieldDecl *FD,
bool InNonTrivialUnion) {
13290 InNonTrivialUnion);
13291 return Super::visitWithKind(PDIK, QT, FD, InNonTrivialUnion);
13295 bool InNonTrivialUnion) {
13296 if (InNonTrivialUnion)
13298 << 1 << 0 << QT << FD->
getName();
13302 if (InNonTrivialUnion)
13304 << 1 << 0 << QT << FD->
getName();
13310 if (OrigLoc.isValid()) {
13311 bool IsUnion =
false;
13312 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13313 IsUnion = OrigRD->isUnion();
13314 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13315 << 0 << OrigTy << IsUnion << UseContext;
13319 InNonTrivialUnion =
true;
13322 if (InNonTrivialUnion)
13327 if (!shouldIgnoreForRecordTriviality(FD))
13328 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13341struct DiagNonTrivalCUnionDestructedTypeVisitor
13346 DiagNonTrivalCUnionDestructedTypeVisitor(
13349 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13352 const FieldDecl *FD,
bool InNonTrivialUnion) {
13355 InNonTrivialUnion);
13356 return Super::visitWithKind(DK, QT, FD, InNonTrivialUnion);
13360 bool InNonTrivialUnion) {
13361 if (InNonTrivialUnion)
13363 << 1 << 1 << QT << FD->
getName();
13367 if (InNonTrivialUnion)
13369 << 1 << 1 << QT << FD->
getName();
13375 if (OrigLoc.isValid()) {
13376 bool IsUnion =
false;
13377 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13378 IsUnion = OrigRD->isUnion();
13379 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13380 << 1 << OrigTy << IsUnion << UseContext;
13384 InNonTrivialUnion =
true;
13387 if (InNonTrivialUnion)
13392 if (!shouldIgnoreForRecordTriviality(FD))
13393 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13398 bool InNonTrivialUnion) {}
13408struct DiagNonTrivalCUnionCopyVisitor
13415 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13418 const FieldDecl *FD,
bool InNonTrivialUnion) {
13421 InNonTrivialUnion);
13422 return Super::visitWithKind(PCK, QT, FD, InNonTrivialUnion);
13426 bool InNonTrivialUnion) {
13427 if (InNonTrivialUnion)
13429 << 1 << 2 << QT << FD->
getName();
13433 if (InNonTrivialUnion)
13435 << 1 << 2 << QT << FD->
getName();
13441 if (OrigLoc.isValid()) {
13442 bool IsUnion =
false;
13443 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13444 IsUnion = OrigRD->isUnion();
13445 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13446 << 2 << OrigTy << IsUnion << UseContext;
13450 InNonTrivialUnion =
true;
13453 if (InNonTrivialUnion)
13458 if (!shouldIgnoreForRecordTriviality(FD))
13459 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13463 const FieldDecl *FD,
bool InNonTrivialUnion) {}
13466 bool InNonTrivialUnion) {}
13480 unsigned NonTrivialKind) {
13484 "shouldn't be called if type doesn't have a non-trivial C union");
13488 DiagNonTrivalCUnionDefaultInitializeVisitor(QT, Loc, UseContext, *
this)
13489 .
visit(QT,
nullptr,
false);
13492 DiagNonTrivalCUnionDestructedTypeVisitor(QT, Loc, UseContext, *
this)
13493 .visit(QT,
nullptr,
false);
13495 DiagNonTrivalCUnionCopyVisitor(QT, Loc, UseContext, *
this)
13496 .visit(QT,
nullptr,
false);
13510 if (
auto *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
13511 if (!Method->isInvalidDecl()) {
13513 Diag(Method->getLocation(), diag::err_member_function_initialization)
13514 << Method->getDeclName() <<
Init->getSourceRange();
13515 Method->setInvalidDecl();
13520 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
13522 assert(!isa<FieldDecl>(RealDecl) &&
"field init shouldn't get here");
13532 if (
Expr *E = Recovery.
get())
13538 if (
Init && !
Init->getType().isNull() &&
13539 Init->getType()->isWebAssemblyTableType()) {
13540 Diag(
Init->getExprLoc(), diag::err_wasm_table_art) << 0;
13571 Diag(VDecl->
getLocation(), diag::err_attribute_dllimport_data_definition);
13592 BaseDeclType = Array->getElementType();
13594 diag::err_typecheck_decl_incomplete_type)) {
13601 diag::err_abstract_type_in_decl,
13611 !VDecl->
isTemplated() && !isa<VarTemplateSpecializationDecl>(VDecl)) {
13620 if (Def != VDecl &&
13640 Diag(
Init->getExprLoc(), diag::err_static_data_member_reinitialization)
13643 diag::note_previous_initializer)
13666 if (VDecl->
hasAttr<LoaderUninitializedAttr>()) {
13667 Diag(VDecl->
getLocation(), diag::err_loader_uninitialized_cant_init);
13681 if (
Result.isInvalid()) {
13690 bool IsParenListInit =
false;
13702 for (
size_t Idx = 0; Idx < Args.size(); ++Idx) {
13704 Args[Idx], VDecl,
true,
13705 [
this, Entity, Kind](
Expr *E) {
13711 }
else if (Res.
get() != Args[Idx]) {
13712 Args[Idx] = Res.
get();
13722 if (
Result.isInvalid()) {
13736 if (isa<DecompositionDecl>(VDecl))
13742 IsParenListInit = !InitSeq.
steps().empty() &&
13746 if (
Init && !
Init->getType().isNull() &&
13778 if (VDecl->
hasAttr<BlocksAttr>())
13792 Init->getBeginLoc()))
13793 FSI->markSafeWeakUse(
Init);
13810 if (
Result.isInvalid()) {
13843 isa<InitListExpr>(
Init)) {
13847 if (
auto *E = dyn_cast<ExprWithCleanups>(
Init))
13848 if (
auto *BE = dyn_cast<BlockExpr>(E->getSubExpr()->
IgnoreParens()))
13850 BE->getBlockDecl()->setCanAvoidCopyToHeap();
13885 <<
Init->getSourceRange();
13896 else if (
Init->isValueDependent())
13898 else if (
Init->isIntegerConstantExpr(
Context, &Loc))
13900 else if (
Init->getType()->isScopedEnumeralType() &&
13906 Diag(Loc, diag::ext_in_class_initializer_non_constant)
13907 <<
Init->getSourceRange();
13911 Diag(Loc, diag::err_in_class_initializer_non_constant)
13912 <<
Init->getSourceRange();
13922 diag::ext_in_class_initializer_float_type_cxx11)
13923 << DclT <<
Init->getSourceRange();
13925 diag::note_in_class_initializer_float_type_cxx11)
13928 Diag(VDecl->
getLocation(), diag::ext_in_class_initializer_float_type)
13929 << DclT <<
Init->getSourceRange();
13932 Diag(
Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
13933 <<
Init->getSourceRange();
13940 Diag(VDecl->
getLocation(), diag::err_in_class_initializer_literal_type)
13941 << DclT <<
Init->getSourceRange()
13947 << DclT <<
Init->getSourceRange();
13981 if (!InitType.
isNull() &&
14000 if (CXXDirectInit) {
14001 assert(
DirectInit &&
"Call-style initializer must be direct init.");
14012 DeclsToCheckForDeferredDiags.insert(VDecl);
14025 VarDecl *VD = dyn_cast<VarDecl>(D);
14029 if (
auto *DD = dyn_cast<DecompositionDecl>(D))
14030 for (
auto *BD : DD->bindings())
14031 BD->setInvalidDecl();
14045 diag::err_typecheck_decl_incomplete_type)) {
14052 diag::err_abstract_type_in_decl,
14067 if (
VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
14071 if (isa<DecompositionDecl>(RealDecl)) {
14072 Diag(Var->getLocation(), diag::err_decomp_decl_requires_init) << Var;
14073 Var->setInvalidDecl();
14087 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition() &&
14088 !Var->isThisDeclarationADemotedDefinition()) {
14089 if (Var->isStaticDataMember()) {
14094 Diag(Var->getLocation(),
14095 diag::err_constexpr_static_mem_var_requires_init)
14097 Var->setInvalidDecl();
14101 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
14102 Var->setInvalidDecl();
14109 if (!Var->isInvalidDecl() &&
14111 Var->getStorageClass() !=
SC_Extern && !Var->getInit()) {
14112 bool HasConstExprDefaultConstructor =
false;
14113 if (
CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
14114 for (
auto *Ctor : RD->ctors()) {
14115 if (Ctor->isConstexpr() && Ctor->getNumParams() == 0 &&
14116 Ctor->getMethodQualifiers().getAddressSpace() ==
14118 HasConstExprDefaultConstructor =
true;
14122 if (!HasConstExprDefaultConstructor) {
14123 Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
14124 Var->setInvalidDecl();
14129 if (!Var->isInvalidDecl() && RealDecl->
hasAttr<LoaderUninitializedAttr>()) {
14130 if (Var->getStorageClass() ==
SC_Extern) {
14131 Diag(Var->getLocation(), diag::err_loader_uninitialized_extern_decl)
14133 Var->setInvalidDecl();
14137 diag::err_typecheck_decl_incomplete_type)) {
14138 Var->setInvalidDecl();
14141 if (
CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
14142 if (!RD->hasTrivialDefaultConstructor()) {
14143 Diag(Var->getLocation(), diag::err_loader_uninitialized_trivial_ctor);
14144 Var->setInvalidDecl();
14154 Var->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion())
14161 if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
14177 !Var->hasLinkage() && !Var->isInvalidDecl() &&
14179 diag::err_typecheck_decl_incomplete_type))
14180 Var->setInvalidDecl();
14185 diag::err_abstract_type_in_decl,
14187 Var->setInvalidDecl();
14190 Diag(Var->getLocation(), diag::warn_private_extern);
14191 Diag(Var->getLocation(), diag::note_private_extern);
14195 !Var->isInvalidDecl())
14206 if (!Var->isInvalidDecl()) {
14210 Var->getLocation(), ArrayT->getElementType(),
14211 diag::err_array_incomplete_or_sizeless_type))
14212 Var->setInvalidDecl();
14213 }
else if (Var->getStorageClass() ==
SC_Static) {
14223 if (Var->isFirstDecl())
14225 diag::ext_typecheck_decl_incomplete_type);
14230 if (!Var->isInvalidDecl())
14238 if (Var->isConstexpr())
14239 Diag(Var->getLocation(), diag::err_constexpr_var_requires_const_init)
14242 Diag(Var->getLocation(),
14243 diag::err_typecheck_incomplete_array_needs_initializer);
14244 Var->setInvalidDecl();
14251 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
14252 << Var <<
SourceRange(Var->getLocation(), Var->getLocation());
14261 if (Var->isInvalidDecl())
14264 if (!Var->hasAttr<AliasAttr>()) {
14267 diag::err_typecheck_decl_incomplete_type)) {
14268 Var->setInvalidDecl();
14277 diag::err_abstract_type_in_decl,
14279 Var->setInvalidDecl();
14300 if (!CXXRecord->isPOD())
14334 }
else if (
Init.isInvalid()) {
14352 VarDecl *VD = dyn_cast<VarDecl>(D);
14411 const char *PrevSpec;
14423 cast<VarDecl>(Var)->setCXXForRangeDecl(
true);
14478 !isa<VarTemplatePartialSpecializationDecl>(var) &&
14480 !
getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
14488 Diag(var->
getLocation(), diag::warn_missing_variable_declarations) << var;
14495 std::optional<bool> CacheHasConstInit;
14496 const Expr *CacheCulprit =
nullptr;
14497 auto checkConstInit = [&]()
mutable {
14498 if (!CacheHasConstInit)
14501 return *CacheHasConstInit;
14513 if (!checkConstInit()) {
14528 isa<InitListExpr>(var->
getInit())) {
14529 const auto *ILE = cast<InitListExpr>(var->
getInit());
14530 unsigned NumInits = ILE->getNumInits();
14532 for (
unsigned I = 0; I < NumInits; ++I) {
14533 const auto *
Init = ILE->getInit(I);
14536 const auto *SL = dyn_cast<StringLiteral>(
Init->IgnoreImpCasts());
14540 unsigned NumConcat = SL->getNumConcatenated();
14544 if (NumConcat == 2 && !SL->getBeginLoc().isMacroID()) {
14545 bool OnlyOneMissingComma =
true;
14546 for (
unsigned J = I + 1; J < NumInits; ++J) {
14547 const auto *
Init = ILE->getInit(J);
14550 const auto *SLJ = dyn_cast<StringLiteral>(
Init->IgnoreImpCasts());
14551 if (!SLJ || SLJ->getNumConcatenated() > 1) {
14552 OnlyOneMissingComma =
false;
14557 if (OnlyOneMissingComma) {
14559 for (
unsigned i = 0; i < NumConcat - 1; ++i)
14563 Diag(SL->getStrTokenLoc(1),
14564 diag::warn_concatenated_literal_array_init)
14566 Diag(SL->getBeginLoc(),
14567 diag::note_concatenated_string_literal_silence);
14578 if (var->
hasAttr<BlocksAttr>())
14585 bool HasConstInit =
true;
14588 Diag(var->
getLocation(), diag::err_constexpr_var_requires_const_init)
14593 !
type->isDependentType() &&
Init && !
Init->isValueDependent() &&
14607 HasConstInit = checkConstInit();
14611 if (HasConstInit) {
14614 }
else if (CacheCulprit) {
14615 Notes.emplace_back(CacheCulprit->
getExprLoc(),
14616 PDiag(diag::note_invalid_subexpr_in_const_expr));
14624 if (HasConstInit) {
14630 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
14631 diag::note_invalid_subexpr_in_const_expr) {
14632 DiagLoc = Notes[0].first;
14635 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
14636 << var <<
Init->getSourceRange();
14637 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
14638 Diag(Notes[I].first, Notes[I].second);
14639 }
else if (GlobalStorage && var->
hasAttr<ConstInitAttr>()) {
14642 <<
Init->getSourceRange();
14645 for (
auto &it : Notes)
14646 Diag(it.first, it.second);
14647 }
else if (IsGlobal &&
14658 if (!checkConstInit())
14660 <<
Init->getSourceRange();
14672 std::optional<QualType::NonConstantStorageReason> Reason;
14673 if (HasConstInit &&
14680 if (
const SectionAttr *SA = var->
getAttr<SectionAttr>()) {
14684 }
else if (Stack->CurrentValue) {
14689 NonConstNonReferenceType) &&
14690 "This case should've already been handled elsewhere");
14697 auto SectionName = Stack->CurrentValue->getString();
14699 Stack->CurrentPragmaLocation,
14700 SectionAttr::Declspec_allocate));
14723 if (!
type->isDependentType())
14733 if (
auto *DD = dyn_cast<DecompositionDecl>(var))
14746 !FD->
hasAttr<DLLExportStaticLocalAttr>() &&
14747 !FD->
hasAttr<DLLImportStaticLocalAttr>()) {
14756 auto *NewAttr = cast<InheritableAttr>(A->clone(
getASTContext()));
14757 NewAttr->setInherited(
true);
14759 }
else if (
Attr *A = FD->
getAttr<DLLExportStaticLocalAttr>()) {
14760 auto *NewAttr = DLLExportAttr::CreateImplicit(
getASTContext(), *A);
14761 NewAttr->setInherited(
true);
14766 if (!FD->
hasAttr<DLLExportAttr>())
14769 }
else if (
Attr *A = FD->
getAttr<DLLImportStaticLocalAttr>()) {
14770 auto *NewAttr = DLLImportAttr::CreateImplicit(
getASTContext(), *A);
14771 NewAttr->setInherited(
true);
14802 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
14810 VD->
addAttr(PragmaClangBSSSectionAttr::CreateImplicit(
14814 VD->
addAttr(PragmaClangDataSectionAttr::CreateImplicit(
14818 VD->
addAttr(PragmaClangRodataSectionAttr::CreateImplicit(
14822 VD->
addAttr(PragmaClangRelroSectionAttr::CreateImplicit(
14827 if (
auto *DD = dyn_cast<DecompositionDecl>(ThisDecl)) {
14828 for (
auto *BD : DD->bindings()) {
14853 if (
const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
14860 bool IsClassTemplateMember =
14861 isa<ClassTemplatePartialSpecializationDecl>(
Context) ||
14862 Context->getDescribedClassTemplate();
14865 IsClassTemplateMember
14866 ? diag::warn_attribute_dllimport_static_field_definition
14867 : diag::err_attribute_dllimport_static_field_definition);
14868 Diag(IA->getLocation(), diag::note_attribute);
14869 if (!IsClassTemplateMember)
14897 if (RetainAttr *
Attr = VD->
getAttr<RetainAttr>()) {
14912 if (VD->
isFileVarDecl() && !isa<VarTemplatePartialSpecializationDecl>(VD))
14917 if (!VD->
hasAttr<TypeTagForDatatypeAttr>() ||
14921 for (
const auto *I : ThisDecl->
specific_attrs<TypeTagForDatatypeAttr>()) {
14923 if (!MagicValueExpr) {
14926 std::optional<llvm::APSInt> MagicValueInt;
14928 Diag(I->getRange().getBegin(),
14929 diag::err_type_tag_for_datatype_not_ice)
14933 if (MagicValueInt->getActiveBits() > 64) {
14934 Diag(I->getRange().getBegin(),
14935 diag::err_type_tag_for_datatype_too_large)
14939 uint64_t MagicValue = MagicValueInt->getZExtValue();
14942 I->getMatchingCType(),
14943 I->getLayoutCompatible(),
14944 I->getMustBeNull());
14949 auto *VD = dyn_cast<VarDecl>(DD);
14950 return VD && !VD->getType()->hasAutoForTrailingReturnType();
14962 bool DiagnosedMultipleDecomps =
false;
14964 bool DiagnosedNonDeducedAuto =
false;
14966 for (
unsigned i = 0, e = Group.size(); i != e; ++i) {
14967 if (
Decl *D = Group[i]) {
14970 if (
auto *VD = dyn_cast<VarDecl>(D);
14971 LangOpts.OpenMP && VD && VD->hasAttr<OMPDeclareTargetDeclAttr>() &&
14972 VD->hasGlobalStorage())
14976 if (
auto *DD = dyn_cast<DeclaratorDecl>(D)) {
14977 if (!FirstDeclaratorInGroup)
14978 FirstDeclaratorInGroup = DD;
14979 if (!FirstDecompDeclaratorInGroup)
14980 FirstDecompDeclaratorInGroup = dyn_cast<DecompositionDecl>(D);
14983 FirstNonDeducedAutoInGroup = DD;
14985 if (FirstDeclaratorInGroup != DD) {
14988 if (FirstDecompDeclaratorInGroup && !DiagnosedMultipleDecomps) {
14990 diag::err_decomp_decl_not_alone)
14992 << DD->getSourceRange();
14993 DiagnosedMultipleDecomps =
true;
14999 if (FirstNonDeducedAutoInGroup && !DiagnosedNonDeducedAuto) {
15001 diag::err_auto_non_deduced_not_alone)
15002 << FirstNonDeducedAutoInGroup->
getType()
15005 << DD->getSourceRange();
15006 DiagnosedNonDeducedAuto =
true;
15011 Decls.push_back(D);
15018 if (FirstDeclaratorInGroup && !Tag->hasNameForLinkage() &&
15034 if (Group.size() > 1) {
15036 VarDecl *DeducedDecl =
nullptr;
15037 for (
unsigned i = 0, e = Group.size(); i != e; ++i) {
15038 VarDecl *D = dyn_cast<VarDecl>(Group[i]);
15048 auto *AT = dyn_cast<AutoType>(DT);
15050 diag::err_auto_different_deductions)
15051 << (AT ? (
unsigned)AT->getKeyword() : 3) << Deduced
15076 if (Group.empty() || !Group[0])
15080 Group[0]->getLocation()) &&
15082 Group[0]->getLocation()))
15085 if (Group.size() >= 2) {
15093 Decl *MaybeTagDecl = Group[0];
15094 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
15095 Group = Group.slice(1);
15146 if (!ExplicitThisLoc.
isValid())
15149 "explicit parameter in non-cplusplus mode");
15151 S.
Diag(ExplicitThisLoc, diag::err_cxx20_deducing_this)
15152 <<
P->getSourceRange();
15156 if (
P->isParameterPack()) {
15157 S.
Diag(
P->getBeginLoc(), diag::err_explicit_object_parameter_pack)
15158 <<
P->getSourceRange();
15161 P->setExplicitObjectParameterLoc(ExplicitThisLoc);
15163 LSI->ExplicitObjectParameter =
P;
15183 : diag::warn_deprecated_register)
15191 diag::err_invalid_storage_class_in_func_decl);
15216 RedeclarationKind::ForVisibleRedeclaration);
15224 PrevDecl =
nullptr;
15226 if (PrevDecl && S->isDeclScope(PrevDecl)) {
15249 assert(S->isFunctionPrototypeScope());
15250 assert(S->getFunctionPrototypeDepth() >= 1);
15252 S->getNextFunctionPrototypeIndex());
15266 if (New->
hasAttr<BlocksAttr>()) {
15300 !
Parameter->getIdentifier()->isPlaceholder()) {
15301 Diag(
Parameter->getLocation(), diag::warn_unused_parameter)
15309 if (
LangOpts.NumLargeByValueCopy == 0)
15316 if (Size >
LangOpts.NumLargeByValueCopy)
15327 if (Size >
LangOpts.NumLargeByValueCopy)
15347 if (!
T.isConstQualified()) {
15350 NameLoc, diag::err_arc_array_param_no_ownership,
T,
false));
15352 Diag(NameLoc, diag::err_arc_array_param_no_ownership)
15379 if (!
T.isConstQualified()) {
15383 NameLoc, diag::err_arc_array_param_no_ownership,
T,
false));
15385 Diag(NameLoc, diag::err_arc_array_param_no_ownership)
15397 TSInfo, SC,
nullptr);
15404 LSI->LocalPacks.push_back(New);
15417 diag::err_object_cannot_be_passed_returned_by_value) << 1 <<
T
15436 Diag(NameLoc, diag::err_arg_with_address_space);
15464 for (
int i = FTI.
NumParams; i != 0; ) {
15469 llvm::raw_svector_ostream(Code)
15480 const char* PrevSpec;
15512 if (
LangOpts.OpenMP &&
OpenMP().isInOpenMPDeclareVariantScope())
15514 ParentScope, D, TemplateParameterLists, Bases);
15520 if (!Bases.empty())
15537 if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
15540 PossiblePrototype = Prev;
15558 if (isa<CXXMethodDecl>(FD))
15564 if (II->isStr(
"main") || II->isStr(
"efi_main"))
15580 if (FD->
hasAttr<OpenCLKernelAttr>())
15634 Definition->getNumTemplateParameterLists())) {
15637 if (
auto *TD =
Definition->getDescribedFunctionTemplate())
15650 Diag(
Definition->getLocation(), diag::note_previous_definition);
15659 LSI->
Lambda = LambdaClass;
15683 for (
const auto &
C : LambdaClass->
captures()) {
15684 if (
C.capturesVariable()) {
15688 const bool ByRef =
C.getCaptureKind() ==
LCK_ByRef;
15690 true,
C.getLocation(),
15691 C.isPackExpansion()
15693 I->getType(),
false);
15695 }
else if (
C.capturesThis()) {
15721 FD = FunTmpl->getTemplatedDecl();
15723 FD = cast<FunctionDecl>(D);
15748 if (
const auto *
Attr = FD->
getAttr<AliasAttr>()) {
15753 if (
const auto *
Attr = FD->
getAttr<IFuncAttr>()) {
15758 if (
const auto *
Attr = FD->
getAttr<TargetVersionAttr>()) {
15760 !
Attr->isDefaultVersion()) {
15769 if (
auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
15771 Ctor->isDefaultConstructor() &&
15814 "There should be an active template instantiation on the stack "
15815 "when instantiating a generic lambda!");
15841 diag::err_func_def_incomplete_result) ||
15843 diag::err_abstract_type_in_decl,
15859 auto *NonParmDecl = dyn_cast<NamedDecl>(NPD);
15862 assert(!isa<ParmVarDecl>(NonParmDecl) &&
15863 "parameters should not be in newly created FD yet");
15866 if (NonParmDecl->getDeclName())
15871 if (
auto *ED = dyn_cast<EnumDecl>(NonParmDecl)) {
15872 for (
auto *EI : ED->enumerators())
15880 Param->setOwningFunction(FD);
15883 if (Param->getIdentifier() && FnBodyScope) {
15912 assert(!FD->
hasAttr<DLLExportAttr>());
15913 Diag(FD->
getLocation(), diag::err_attribute_dllimport_function_definition);
15936 if (
auto *TD = dyn_cast<FunctionTemplateDecl>(FD))
15937 FD = TD->getTemplatedDecl();
15938 if (FD && FD->
hasAttr<OptimizeNoneAttr>()) {
15962 for (
unsigned I = 0, E =
Scope->Returns.size(); I != E; ++I) {
15963 if (
const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
15964 if (!NRVOCandidate->isNRVOVariable())
15983 Outer.Fun.hasTrailingReturnType()) {
16001 if (FD->isConstexpr())
16006 if (FD->getReturnType()->getContainedDeducedType())
16016 FD->setHasSkippedBody();
16038 bool IsLambda =
false;
16042 llvm::DenseMap<const BlockDecl *, bool> EscapeInfo;
16044 auto IsOrNestedInEscapingBlock = [&](
const BlockDecl *BD) {
16045 if (EscapeInfo.count(BD))
16046 return EscapeInfo[BD];
16058 return EscapeInfo[BD] = R;
16063 for (
const std::pair<SourceLocation, const BlockDecl *> &
P :
16065 if (IsOrNestedInEscapingBlock(
P.second))
16066 S.
Diag(
P.first, diag::warn_implicitly_retains_self)
16071 return isa<CXXMethodDecl>(FD) && FD->
param_empty() &&
16081 methodHasName(FD,
"get_return_object_on_allocation_failure");
16091 if (!FD->
hasAttr<CoroWrapperAttr>())
16096 bool IsInstantiation) {
16146 Expr *Dummy =
nullptr;
16157 if (LSI->HasImplicitReturnType) {
16164 LSI->ReturnType.isNull() ?
Context.
VoidTy : LSI->ReturnType;
16169 Proto->getExtProtoInfo()));
16197 dyn_cast<CXXDestructorDecl>(FD))
16217 if (PossiblePrototype) {
16221 TypeLoc TL = TI->getTypeLoc();
16224 diag::note_declaration_not_a_prototype)
16227 FTL.getRParenLoc(),
"void")
16234 std::pair<FileID, unsigned> LocInfo =
SM.getDecomposedLoc(Loc);
16235 if (LocInfo.first.isInvalid())
16239 StringRef Buffer =
SM.getBufferData(LocInfo.first, &
Invalid);
16243 if (LocInfo.second > Buffer.size())
16246 const char *LexStart = Buffer.data() + LocInfo.second;
16247 StringRef StartTok(LexStart, Buffer.size() - LocInfo.second);
16249 return StartTok.consume_front(
"const") &&
16251 StartTok.starts_with(
"/*") || StartTok.starts_with(
"//"));
16254 auto findBeginLoc = [&]() {
16270 diag::note_static_for_internal_linkage)
16281 if (!PossiblePrototype)
16327 if (PossiblePrototype)
16329 diag::warn_non_prototype_changes_behavior)
16336 if (
const auto *CmpndBody = dyn_cast<CompoundStmt>(Body))
16337 if (!CmpndBody->body_empty())
16338 Diag(CmpndBody->body_front()->getBeginLoc(),
16339 diag::warn_dispatch_body_ignored);
16341 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
16366 "Function parsing confused");
16367 }
else if (
ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
16379 << MD->getSelector().getAsString();
16384 bool isDesignated =
16385 MD->isDesignatedInitializerForTheInterface(&InitMethod);
16386 assert(isDesignated && InitMethod);
16387 (void)isDesignated;
16390 auto IFace = MD->getClassInterface();
16393 auto SuperD = IFace->getSuperClass();
16403 diag::warn_objc_designated_init_missing_super_call);
16405 diag::note_objc_designated_init_marked_here);
16413 diag::warn_objc_secondary_init_missing_init_call);
16429 "This should only be set for ObjC methods, which should have been "
16430 "handled in the block above.");
16437 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
16445 if (!
Destructor->getParent()->isDependentType())
16463 ActivePolicy = &WP;
16466 if (!IsInstantiation && FD &&
16472 if (FD && FD->
hasAttr<NakedAttr>()) {
16476 bool RegisterVariables =
false;
16477 if (
auto *DS = dyn_cast<DeclStmt>(S)) {
16478 for (
const auto *
Decl : DS->decls()) {
16479 if (
const auto *Var = dyn_cast<VarDecl>(
Decl)) {
16480 RegisterVariables =
16481 Var->hasAttr<AsmLabelAttr>() && !Var->hasInit();
16482 if (!RegisterVariables)
16487 if (RegisterVariables)
16489 if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
16490 Diag(S->getBeginLoc(), diag::err_non_asm_stmt_in_naked_function);
16491 Diag(FD->
getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
16500 "Leftover temporaries in function");
16502 "Unaccounted cleanups in function");
16504 "Leftover expressions for odr-use checking");
16510 if (!IsInstantiation)
16527 DeclsToCheckForDeferredDiags.insert(FD);
16542 D = TD->getTemplatedDecl();
16546 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
16547 if (Method->isStatic())
16557 "Implicit function declarations aren't allowed in this language mode");
16564 Scope *BlockScope = S;
16572 Scope *ContextScope = BlockScope;
16576 ContextScope = ContextScope->
getParent();
16592 if (!isa<FunctionDecl>(ExternCPrev) ||
16594 cast<FunctionDecl>(ExternCPrev)->getType(),
16596 Diag(Loc, diag::ext_use_out_of_scope_declaration)
16599 return ExternCPrev;
16605 if (II.
getName().starts_with(
"__builtin_"))
16606 diag_id = diag::warn_builtin_unknown;
16609 diag_id = diag::ext_implicit_function_decl_c99;
16611 diag_id = diag::warn_implicit_function_decl;
16619 if (S && !ExternCPrev &&
16626 Diag(Loc, diag_id) << &II;
16642 return ExternCPrev;
16652 assert(!Error &&
"Error setting up implicit decl!");
16700 std::optional<unsigned> AlignmentParam;
16701 bool IsNothrow =
false;
16713 if (!IsNothrow && !FD->
hasAttr<ReturnsNonNullAttr>() &&
16731 if (!FD->
hasAttr<AllocSizeAttr>()) {
16732 FD->
addAttr(AllocSizeAttr::CreateImplicit(
16743 if (AlignmentParam && !FD->
hasAttr<AllocAlignAttr>()) {
16744 FD->
addAttr(AllocAlignAttr::CreateImplicit(
16777 unsigned FormatIdx;
16780 if (!FD->
hasAttr<FormatAttr>()) {
16781 const char *fmt =
"printf";
16783 if (FormatIdx < NumParams &&
16789 HasVAListArg ? 0 : FormatIdx+2,
16795 if (!FD->
hasAttr<FormatAttr>())
16799 HasVAListArg ? 0 : FormatIdx+2,
16805 if (!FD->
hasAttr<CallbackAttr>() &&
16807 FD->
addAttr(CallbackAttr::CreateImplicit(
16813 bool NoExceptions =
16815 bool ConstWithoutErrnoAndExceptions =
16817 bool ConstWithoutExceptions =
16819 if (!FD->
hasAttr<ConstAttr>() &&
16820 (ConstWithoutErrnoAndExceptions || ConstWithoutExceptions) &&
16821 (!ConstWithoutErrnoAndExceptions ||
16823 (!ConstWithoutExceptions || NoExceptions))
16830 if ((Trip.isGNUEnvironment() || Trip.isOSMSVCRT()) &&
16832 switch (BuiltinID) {
16833 case Builtin::BI__builtin_fma:
16834 case Builtin::BI__builtin_fmaf:
16835 case Builtin::BI__builtin_fmal:
16836 case Builtin::BIfma:
16837 case Builtin::BIfmaf:
16838 case Builtin::BIfmal:
16847 !FD->
hasAttr<ReturnsTwiceAttr>())
16857 !FD->
hasAttr<CUDADeviceAttr>() && !FD->
hasAttr<CUDAHostAttr>()) {
16869 switch (BuiltinID) {
16870 case Builtin::BImemalign:
16871 case Builtin::BIaligned_alloc:
16872 if (!FD->
hasAttr<AllocAlignAttr>())
16881 switch (BuiltinID) {
16882 case Builtin::BIcalloc:
16883 FD->
addAttr(AllocSizeAttr::CreateImplicit(
16886 case Builtin::BImemalign:
16887 case Builtin::BIaligned_alloc:
16888 case Builtin::BIrealloc:
16892 case Builtin::BImalloc:
16901 switch (BuiltinID) {
16902 case Builtin::BIaddressof:
16903 case Builtin::BI__addressof:
16904 case Builtin::BI__builtin_addressof:
16905 case Builtin::BIas_const:
16906 case Builtin::BIforward:
16907 case Builtin::BIforward_like:
16908 case Builtin::BImove:
16909 case Builtin::BImove_if_noexcept:
16911 !
P->hasAttr<LifetimeBoundAttr>())
16928 if (!FPT || FPT->getExceptionSpecType() ==
EST_None)
16944 if (Name->isStr(
"asprintf") || Name->isStr(
"vasprintf")) {
16947 if (!FD->
hasAttr<FormatAttr>())
16950 Name->isStr(
"vasprintf") ? 0 : 3,
16954 if (Name->isStr(
"__CFStringMakeConstantString")) {
16957 if (!FD->
hasAttr<FormatArgAttr>())
16965 assert(D.
getIdentifier() &&
"Wrong callback for declspec without declarator");
16966 assert(!
T.isNull() &&
"GetTypeForDeclarator() returned null type");
16969 assert(D.
isInvalidType() &&
"no declarator info for valid type");
17030 if (BT->isInteger())
17033 return Diag(UnderlyingLoc, diag::err_enum_invalid_underlying)
17040 QualType EnumUnderlyingTy,
bool IsFixed,
17042 if (IsScoped != Prev->
isScoped()) {
17043 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
17049 if (IsFixed && Prev->
isFixed()) {
17055 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
17061 }
else if (IsFixed != Prev->
isFixed()) {
17062 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
17084 default: llvm_unreachable(
"Invalid tag kind for redecl diagnostic!");
17100 if (isa<TypedefDecl>(PrevDecl))
17102 else if (isa<TypeAliasDecl>(PrevDecl))
17104 else if (isa<ClassTemplateDecl>(PrevDecl))
17106 else if (isa<TypeAliasTemplateDecl>(PrevDecl))
17108 else if (isa<TemplateTemplateParmDecl>(PrevDecl))
17120 llvm_unreachable(
"invalid TTK");
17145 if (OldTag != NewTag &&
17163 if (IsIgnoredLoc(NewTagLoc))
17166 auto IsIgnored = [&](
const TagDecl *Tag) {
17167 return IsIgnoredLoc(Tag->getLocation());
17181 if (OldTag != NewTag) {
17184 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
17192 if (isDefinition) {
17200 bool previousMismatch =
false;
17202 if (I->getTagKind() != NewTag) {
17207 if (!previousMismatch) {
17208 previousMismatch =
true;
17209 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
17213 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
17226 if (PrevDef && IsIgnored(PrevDef))
17230 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
17237 Diag(NewTagLoc, diag::note_struct_class_suggestion)
17267 if (!Namespace || Namespace->isAnonymousNamespace())
17270 Namespaces.push_back(II);
17273 if (Lookup == Namespace)
17280 llvm::raw_svector_ostream OS(Insertion);
17283 std::reverse(Namespaces.begin(), Namespaces.end());
17284 for (
auto *II : Namespaces)
17285 OS << II->getName() <<
"::";
17298 if (OldDC->
Equals(NewDC))
17327 bool ScopedEnumUsesClassTag,
TypeResult UnderlyingType,
17328 bool IsTypeSpecifier,
bool IsTemplateParamOrArg,
17333 "Nameless record must be a definition!");
17334 assert(TemplateParameterLists.size() == 0 || TUK !=
TUK_Reference);
17338 bool ScopedEnum = ScopedEnumKWLoc.
isValid();
17341 bool isMemberSpecialization =
false;
17347 if (TemplateParameterLists.size() > 0 ||
17351 KWLoc, NameLoc, SS,
nullptr, TemplateParameterLists,
17368 Diag(SS.
getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
17371 if (TemplateParams) {
17373 Diag(KWLoc, diag::err_enum_template);
17377 if (TemplateParams->
size() > 0) {
17386 S, TagSpec, TUK, KWLoc, SS, Name, NameLoc, Attrs, TemplateParams,
17387 AS, ModulePrivateLoc,
17389 TemplateParameterLists.data(), SkipBody);
17395 isMemberSpecialization =
true;
17399 if (!TemplateParameterLists.empty() && isMemberSpecialization &&
17418 ScopedEnum ?
SourceRange(KWLoc, ScopedEnumKWLoc) : KWLoc);
17419 assert(ScopedEnum || !ScopedEnumUsesClassTag);
17420 Diag(KWLoc, diag::note_enum_friend)
17421 << (ScopedEnum + ScopedEnumUsesClassTag);
17427 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
17428 bool IsFixed = !UnderlyingType.
isUnset() || ScopedEnum;
17431 if (UnderlyingType.
isInvalid() || (!UnderlyingType.
get() && ScopedEnum)) {
17435 }
else if (UnderlyingType.
get()) {
17440 EnumUnderlying = TI;
17462 bool isStdBadAlloc =
false;
17463 bool isStdAlignValT =
false;
17467 Redecl = RedeclarationKind::NotForRedeclaration;
17472 auto createTagFromNewDecl = [&]() ->
TagDecl * {
17482 ScopedEnum, ScopedEnumUsesClassTag, IsFixed);
17486 if (EnumUnderlying) {
17487 EnumDecl *ED = cast<EnumDecl>(New);
17502 if (
RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
17528 goto CreateNewDecl;
17536 IsDependent =
true;
17565 if (
Previous.wasNotFoundInCurrentInstantiation() &&
17567 IsDependent =
true;
17572 Diag(NameLoc, diag::err_not_tag_in_scope)
17573 << llvm::to_underlying(Kind) << Name << DC << SS.
getRange();
17576 goto CreateNewDecl;
17624 bool FriendSawTagOutsideEnclosingNamespace =
false;
17631 FriendSawTagOutsideEnclosingNamespace =
true;
17640 if (
Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
17642 Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
17656 while (isa<RecordDecl, EnumDecl, ObjCContainerDecl>(SearchDC))
17662 while (isa<ObjCContainerDecl>(SearchDC))
17668 while (isa<ObjCContainerDecl>(SearchDC))
17673 Previous.getFoundDecl()->isTemplateParameter()) {
17682 if (Name->isStr(
"bad_alloc")) {
17684 isStdBadAlloc =
true;
17691 }
else if (Name->isStr(
"align_val_t")) {
17692 isStdAlignValT =
true;
17704 if (
Invalid)
goto CreateNewDecl;
17788 TagDecl *Tag = TT->getDecl();
17791 ->
Equals(TD->getDeclContext()->getRedeclContext())) {
17804 if (
auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
17805 auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
17807 isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) &&
17809 *
this, OldTag->getDeclContext(), SearchDC))) {
17810 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
17811 Diag(Shadow->getTargetDecl()->getLocation(),
17812 diag::note_using_decl_target);
17813 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
17817 goto CreateNewDecl;
17821 if (
TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
17827 SS.
isNotEmpty() || isMemberSpecialization)) {
17833 bool SafeToContinue =
17836 if (SafeToContinue)
17837 Diag(KWLoc, diag::err_use_with_wrong_tag)
17840 PrevTagDecl->getKindName());
17842 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
17843 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
17845 if (SafeToContinue)
17846 Kind = PrevTagDecl->getTagKind();
17857 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
17859 return PrevTagDecl;
17863 EnumUnderlyingTy = TI->getType().getUnqualifiedType();
17864 else if (
const Type *
T = EnumUnderlying.dyn_cast<
const Type*>())
17871 ScopedEnum, EnumUnderlyingTy,
17872 IsFixed, PrevEnum))
17881 S->isDeclScope(PrevDecl)) {
17882 Diag(NameLoc, diag::ext_member_redeclared);
17883 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
17890 if (!Attrs.
empty()) {
17894 (PrevTagDecl->getFriendObjectKind() ==
17907 return PrevTagDecl;
17912 return PrevTagDecl;
17918 if (
NamedDecl *Def = PrevTagDecl->getDefinition()) {
17922 bool IsExplicitSpecializationAfterInstantiation =
false;
17923 if (isMemberSpecialization) {
17925 IsExplicitSpecializationAfterInstantiation =
17926 RD->getTemplateSpecializationKind() !=
17928 else if (
EnumDecl *ED = dyn_cast<EnumDecl>(Def))
17929 IsExplicitSpecializationAfterInstantiation =
17930 ED->getTemplateSpecializationKind() !=
17950 SkipBody->
New = createTagFromNewDecl();
17960 }
else if (!IsExplicitSpecializationAfterInstantiation) {
17964 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
17966 Diag(NameLoc, diag::err_redefinition) << Name;
17968 NameLoc.
isValid() ? NameLoc : KWLoc);
17980 if (TD->isBeingDefined()) {
17981 Diag(NameLoc, diag::err_nested_redefinition) << Name;
17982 Diag(PrevTagDecl->getLocation(),
17983 diag::note_previous_definition);
17998 SearchDC = PrevTagDecl->getDeclContext();
18026 Diag(NameLoc, diag::err_tag_reference_non_tag)
18027 << PrevDecl << NTK << llvm::to_underlying(Kind);
18033 SS.
isNotEmpty() || isMemberSpecialization)) {
18039 Diag(NameLoc, diag::err_tag_reference_conflict) << NTK;
18045 }
else if (
TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
18047 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
18048 Diag(NameLoc, diag::err_tag_definition_of_typedef)
18049 << Name << Kind << TND->getUnderlyingType();
18057 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
18073 PrevDecl = cast<TagDecl>(
Previous.getFoundDecl());
18089 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
18090 ScopedEnumUsesClassTag, IsFixed);
18098 if (IsFixed && cast<EnumDecl>(New)->isFixed()) {
18102 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->
getDefinition())) {
18103 Diag(Loc, diag::ext_forward_ref_enum_def)
18107 unsigned DiagID = diag::ext_forward_ref_enum;
18109 DiagID = diag::ext_ms_forward_ref_enum;
18111 DiagID = diag::err_forward_ref_enum;
18116 if (EnumUnderlying) {
18117 EnumDecl *ED = cast<EnumDecl>(New);
18126 assert(ED->
isComplete() &&
"enum with type should be complete");
18136 cast_or_null<CXXRecordDecl>(PrevDecl));
18142 cast_or_null<RecordDecl>(PrevDecl));
18154 (IsTypeSpecifier || IsTemplateParamOrArg) && TUK ==
TUK_Definition) {
18175 isMemberSpecialization))
18179 if (TemplateParameterLists.size() > 0) {
18187 if (
RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
18203 if (ModulePrivateLoc.
isValid()) {
18204 if (isMemberSpecialization)
18229 Diag(Loc, diag::err_type_defined_in_param_type)
18233 }
else if (!PrevDecl) {
18294 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(New)) {
18311 if (
auto RD = dyn_cast<RecordDecl>(New))
18314 }
else if (SkipBody && SkipBody->
ShouldSkip) {
18323 TagDecl *Tag = cast<TagDecl>(TagD);
18346 "The next DeclContext should be lexically contained in the current one.");
18352 bool IsFinalSpelledSealed,
18360 if (!
Record->getIdentifier())
18368 IsFinalSpelledSealed
18369 ? FinalAttr::Keyword_sealed
18370 : FinalAttr::Keyword_final));
18389 "Broken injected-class-name");
18395 TagDecl *Tag = cast<TagDecl>(TagD);
18400 assert(Tag->
isInvalidDecl() &&
"We should already have completed it");
18401 if (
RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
18405 if (
auto *RD = dyn_cast<CXXRecordDecl>(Tag)) {
18407 if (RD->
hasAttr<SYCLSpecialClassAttr>()) {
18409 assert(Def &&
"The record is expected to have a completed definition");
18410 unsigned NumInitMethods = 0;
18411 for (
auto *Method : Def->methods()) {
18412 if (!Method->getIdentifier())
18414 if (Method->getName() ==
"__init")
18417 if (NumInitMethods > 1 || !Def->hasInitMethod())
18418 Diag(RD->
getLocation(), diag::err_sycl_special_type_num_init_method);
18441 const RecordDecl *RD = dyn_cast<RecordDecl>(Tag);
18445 if (llvm::any_of(RD->
fields(),
18446 [](
const FieldDecl *FD) { return FD->isBitField(); }))
18447 Diag(BraceRange.
getBegin(), diag::warn_pragma_align_not_xl_compatible);
18457 assert(ObjCCtx ==
CurContext &&
"Mismatch of container contexts");
18469 TagDecl *Tag = cast<TagDecl>(TagD);
18474 if (
RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
18488 QualType FieldTy,
bool IsMsStruct,
18499 diag::err_field_incomplete_or_sizeless))
18502 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
18504 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
18515 llvm::APSInt
Value;
18519 BitWidth = ICE.
get();
18522 if (
Value == 0 && FieldName)
18523 return Diag(FieldLoc, diag::err_bitfield_has_zero_width)
18526 if (
Value.isSigned() &&
Value.isNegative()) {
18528 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
18530 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
18537 return Diag(FieldLoc, diag::err_bitfield_too_wide)
18544 bool BitfieldIsOverwide =
Value.ugt(TypeWidth);
18548 bool CStdConstraintViolation =
18550 bool MSBitfieldViolation =
18551 Value.ugt(TypeStorageSize) &&
18553 if (CStdConstraintViolation || MSBitfieldViolation) {
18554 unsigned DiagWidth =
18555 CStdConstraintViolation ? TypeWidth : TypeStorageSize;
18556 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_width)
18558 << !CStdConstraintViolation << DiagWidth;
18564 if (BitfieldIsOverwide && !FieldTy->
isBooleanType() && FieldName) {
18565 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_width)
18622 diag::err_invalid_thread)
18628 RedeclarationKind::ForVisibleRedeclaration);
18630 switch (
Previous.getResultKind()) {
18637 PrevDecl =
Previous.getRepresentativeDecl();
18651 PrevDecl =
nullptr;
18655 PrevDecl =
nullptr;
18662 TSSL, AS, PrevDecl, &D);
18665 Record->setInvalidDecl();
18694 bool Mutable,
Expr *BitWidth,
18700 bool InvalidDecl =
false;
18706 InvalidDecl =
true;
18713 diag::err_field_incomplete_or_sizeless)) {
18715 Record->setInvalidDecl();
18716 InvalidDecl =
true;
18721 Record->setInvalidDecl();
18722 InvalidDecl =
true;
18730 Diag(Loc, diag::err_field_with_address_space);
18731 Record->setInvalidDecl();
18732 InvalidDecl =
true;
18740 Diag(Loc, diag::err_opencl_type_struct_or_union_field) <<
T;
18741 Record->setInvalidDecl();
18742 InvalidDecl =
true;
18747 "__cl_clang_bitfields",
LangOpts)) {
18748 Diag(Loc, diag::err_opencl_bitfields);
18749 InvalidDecl =
true;
18755 T.hasQualifiers()) {
18756 InvalidDecl =
true;
18757 Diag(Loc, diag::err_anon_bitfield_qualifiers);
18764 TInfo,
T, Loc, diag::err_typecheck_field_variable_size))
18765 InvalidDecl =
true;
18770 diag::err_abstract_type_in_decl,
18772 InvalidDecl =
true;
18775 BitWidth =
nullptr;
18781 InvalidDecl =
true;
18782 BitWidth =
nullptr;
18787 if (!InvalidDecl && Mutable) {
18788 unsigned DiagID = 0;
18790 DiagID =
getLangOpts().MSVCCompat ? diag::ext_mutable_reference
18791 : diag::err_mutable_reference;
18792 else if (
T.isConstQualified())
18793 DiagID = diag::err_mutable_const;
18799 Diag(ErrLoc, DiagID);
18800 if (DiagID != diag::ext_mutable_reference) {
18802 InvalidDecl =
true;
18814 BitWidth, Mutable, InitStyle);
18818 if (PrevDecl && !isa<TagDecl>(PrevDecl) &&
18820 Diag(Loc, diag::err_duplicate_member) << II;
18826 if (
Record->isUnion()) {
18845 diag::ext_union_member_of_reference_type :
18846 diag::err_union_member_of_reference_type)
18869 if (
T.isObjCGCWeak())
18870 Diag(Loc, diag::warn_attribute_weak_on_field);
18921 if (!FD->
hasAttr<UnavailableAttr>())
18923 UnavailableAttr::IR_ARCFieldWithOwnership, Loc));
18931 ? diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member
18932 : diag::err_illegal_union_or_anon_struct_member)
18934 << llvm::to_underlying(member);
18948 switch (ivarVisibility) {
18949 default: llvm_unreachable(
"Unknown visitibility kind");
18984 Diag(Loc, diag::err_ivar_reference_type);
18991 TInfo,
T, Loc, diag::err_typecheck_ivar_variable_size))
19005 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
19008 EnclosingContext = IMPDecl->getClassInterface();
19009 assert(EnclosingContext &&
"Implementation has no class interface!");
19012 EnclosingContext = EnclosingDecl;
19015 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
19017 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
19021 EnclosingContext = EnclosingDecl;
19026 Context, EnclosingContext, DeclStart, Loc, II,
T, TInfo, ac, BitWidth);
19034 RedeclarationKind::ForVisibleRedeclaration);
19035 if (PrevDecl &&
isDeclInScope(PrevDecl, EnclosingContext, S)
19036 && !isa<TagDecl>(PrevDecl)) {
19037 Diag(Loc, diag::err_duplicate_member) << II;
19064 !NewID->
isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl))
19065 Diag(Loc, diag::warn_ivars_in_interface);
19079 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
19087 if (!CD->IsClassExtension())
19099 DeclLoc, DeclLoc,
nullptr,
19105 AllIvarDecls.push_back(Ivar);
19117 if (!
Record->hasUserDeclaredDestructor()) {
19125 if (
auto *DD = dyn_cast<CXXDestructorDecl>(
Decl)) {
19126 if (DD->isInvalidDecl())
19130 assert(DD->isIneligibleOrNotSelected() &&
"Selecting a destructor but a destructor was already selected.");
19144 Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(Best->Function));
19148 Msg = diag::err_ambiguous_destructor;
19153 Msg = diag::err_no_viable_destructor;
19164 Record->setInvalidDecl();
19171 Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(OCS.
begin()->Function));
19215 const Expr *Constraints = Method->getTrailingRequiresClause();
19217 SatisfactionStatus.push_back(
true);
19221 SatisfactionStatus.push_back(
false);
19223 SatisfactionStatus.push_back(Satisfaction.
IsSatisfied);
19227 for (
size_t i = 0; i < Methods.size(); i++) {
19228 if (!SatisfactionStatus[i])
19233 OrigMethod = cast<CXXMethodDecl>(MF);
19236 bool AnotherMethodIsMoreConstrained =
false;
19237 for (
size_t j = 0; j < Methods.size(); j++) {
19238 if (i == j || !SatisfactionStatus[j])
19242 OtherMethod = cast<CXXMethodDecl>(MF);
19249 if (!OtherConstraints)
19251 if (!Constraints) {
19252 AnotherMethodIsMoreConstrained =
true;
19257 AnotherMethodIsMoreConstrained)) {
19260 AnotherMethodIsMoreConstrained =
true;
19262 if (AnotherMethodIsMoreConstrained)
19267 if (!AnotherMethodIsMoreConstrained) {
19269 Record->addedEligibleSpecialMemberFunction(Method,
19270 1 << llvm::to_underlying(CSM));
19284 auto *MD = dyn_cast<CXXMethodDecl>(
Decl);
19286 auto *FTD = dyn_cast<FunctionTemplateDecl>(
Decl);
19288 MD = dyn_cast<CXXMethodDecl>(FTD->getTemplatedDecl());
19292 if (
auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
19293 if (CD->isInvalidDecl())
19295 if (CD->isDefaultConstructor())
19296 DefaultConstructors.push_back(MD);
19297 else if (CD->isCopyConstructor())
19298 CopyConstructors.push_back(MD);
19299 else if (CD->isMoveConstructor())
19300 MoveConstructors.push_back(MD);
19302 CopyAssignmentOperators.push_back(MD);
19304 MoveAssignmentOperators.push_back(MD);
19324 assert(EnclosingDecl &&
"missing record or interface decl");
19329 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
19333 case Decl::ObjCCategory:
19336 case Decl::ObjCImplementation:
19338 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
19344 CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(EnclosingDecl);
19348 unsigned NumNamedMembers = 0;
19350 for (
const auto *I :
Record->decls()) {
19351 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
19352 if (IFD->getDeclName())
19369 RecFields.push_back(FD);
19389 bool IsLastField = (i + 1 == Fields.end());
19398 (
Record || isa<ObjCContainerDecl>(EnclosingDecl))) {
19404 unsigned DiagID = 0;
19405 if (!
Record->isUnion() && !IsLastField) {
19408 << llvm::to_underlying(
Record->getTagKind());
19409 Diag((*(i + 1))->getLocation(), diag::note_next_field_declaration);
19413 }
else if (
Record->isUnion())
19415 ? diag::ext_flexible_array_union_ms
19416 : diag::ext_flexible_array_union_gnu;
19417 else if (NumNamedMembers < 1)
19419 ? diag::ext_flexible_array_empty_aggregate_ms
19420 : diag::ext_flexible_array_empty_aggregate_gnu;
19430 if (CXXRecord && CXXRecord->getNumVBases() != 0)
19444 Diag(FD->
getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
19451 Record->setHasFlexibleArrayMember(
true);
19460 diag::err_field_incomplete_or_sizeless)) {
19466 if (
Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
19469 Record->setHasFlexibleArrayMember(
true);
19470 if (!
Record->isUnion()) {
19485 if (isa<ObjCContainerDecl>(EnclosingDecl) &&
19487 diag::err_abstract_type_in_decl,
19492 if (
Record && FDTTy->getDecl()->hasObjectMember())
19493 Record->setHasObjectMember(
true);
19494 if (
Record && FDTTy->getDecl()->hasVolatileMember())
19495 Record->setHasVolatileMember(
true);
19514 FD->
addAttr(UnavailableAttr::CreateImplicit(
19515 Context,
"", UnavailableAttr::IR_ARCFieldWithOwnership,
19519 !
Record->hasObjectMember()) {
19522 Record->setHasObjectMember(
true);
19527 Record->setHasObjectMember(
true);
19530 Record->setHasObjectMember(
true);
19535 !shouldIgnoreForRecordTriviality(FD)) {
19538 Record->setNonTrivialToPrimitiveDefaultInitialize(
true);
19541 Record->setHasNonTrivialToPrimitiveDefaultInitializeCUnion(
true);
19545 Record->setNonTrivialToPrimitiveCopy(
true);
19547 Record->setHasNonTrivialToPrimitiveCopyCUnion(
true);
19550 Record->setNonTrivialToPrimitiveDestroy(
true);
19551 Record->setParamDestroyedInCallee(
true);
19553 Record->setHasNonTrivialToPrimitiveDestructCUnion(
true);
19557 if (RT->getDecl()->getArgPassingRestrictions() ==
19559 Record->setArgPassingRestrictions(
19562 Record->setArgPassingRestrictions(
19567 Record->setHasVolatileMember(
true);
19575 bool Completed =
false;
19579 Parent->isTemplateParamScope())
19580 Record->setInvalidDecl();
19584 if (!CXXRecord->isInvalidDecl()) {
19587 I = CXXRecord->conversion_begin(),
19588 E = CXXRecord->conversion_end(); I != E; ++I)
19589 I.setAccess((*I)->getAccess());
19595 if (!CXXRecord->isDependentType()) {
19596 if (!CXXRecord->isInvalidDecl()) {
19600 if (CXXRecord->getNumVBases()) {
19602 CXXRecord->getFinalOverriders(FinalOverriders);
19604 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
19605 MEnd = FinalOverriders.end();
19608 SOEnd = M->second.end();
19609 SO != SOEnd; ++SO) {
19610 assert(SO->second.size() > 0 &&
19611 "Virtual function without overriding functions?");
19612 if (SO->second.size() == 1)
19619 Diag(
Record->getLocation(), diag::err_multiple_final_overriders)
19621 Diag(M->first->getLocation(),
19622 diag::note_overridden_virtual_function);
19624 OM = SO->second.begin(),
19625 OMEnd = SO->second.end();
19627 Diag(OM->Method->getLocation(), diag::note_final_overrider)
19628 << (
const NamedDecl *)M->first << OM->Method->getParent();
19630 Record->setInvalidDecl();
19633 CXXRecord->completeDefinition(&FinalOverriders);
19643 Record->completeDefinition();
19649 auto IsFunctionPointerOrForwardDecl = [&](
const Decl *D) {
19650 const FieldDecl *FD = dyn_cast<FieldDecl>(D);
19663 if (
const auto *TD = dyn_cast<TagDecl>(D))
19664 return !TD->isCompleteDefinition();
19668 if (isa<PointerType>(FieldType)) {
19678 (
Record->hasAttr<RandomizeLayoutAttr>() ||
19679 (!
Record->hasAttr<NoRandomizeLayoutAttr>() &&
19680 llvm::all_of(
Record->decls(), IsFunctionPointerOrForwardDecl))) &&
19682 !
Record->isRandomized()) {
19686 Record->reorderDecls(NewDeclOrdering);
19691 auto *Dtor = CXXRecord->getDestructor();
19692 if (Dtor && Dtor->isImplicit() &&
19694 CXXRecord->setImplicitDestructorIsDeleted();
19699 if (
Record->hasAttrs()) {
19702 if (
const MSInheritanceAttr *IA =
Record->getAttr<MSInheritanceAttr>())
19704 IA->getRange(), IA->getBestCase(),
19705 IA->getInheritanceModel());
19711 bool CheckForZeroSize;
19713 CheckForZeroSize =
true;
19718 CXXRecord->getLexicalDeclContext()->isExternCContext() &&
19720 CXXRecord->isCLike();
19722 if (CheckForZeroSize) {
19723 bool ZeroSize =
true;
19724 bool IsEmpty =
true;
19725 unsigned NonBitFields = 0;
19727 E =
Record->field_end();
19728 (NonBitFields == 0 || ZeroSize) && I != E; ++I) {
19730 if (I->isUnnamedBitField()) {
19731 if (!I->isZeroLengthBitField(
Context))
19735 QualType FieldType = I->getType();
19747 diag::warn_zero_size_struct_union_in_extern_c :
19748 diag::warn_zero_size_struct_union_compat)
19749 << IsEmpty <<
Record->isUnion() << (NonBitFields > 1);
19754 if (NonBitFields == 0 && !
getLangOpts().CPlusPlus) {
19755 Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
19756 diag::ext_no_named_members_in_struct_union)
19764 ID->setEndOfDefinitionLoc(RBrac);
19766 for (
unsigned i = 0, e = RecFields.size(); i != e; ++i) {
19768 ID->addDecl(ClsFields[i]);
19772 if (ID->getSuperClass())
19775 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
19776 assert(IMPDecl &&
"ActOnFields - missing ObjCImplementationDecl");
19777 for (
unsigned I = 0, N = RecFields.size(); I != N; ++I)
19782 IMPDecl->setIvarLBraceLoc(LBrac);
19783 IMPDecl->setIvarRBraceLoc(RBrac);
19785 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
19793 for (
unsigned i = 0, e = RecFields.size(); i != e; ++i) {
19797 Diag(ClsFields[i]->getLocation(),
19798 diag::err_duplicate_ivar_declaration);
19799 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
19805 Diag(ClsFields[i]->getLocation(),
19806 diag::err_duplicate_ivar_declaration);
19807 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
19813 CDecl->addDecl(ClsFields[i]);
19815 CDecl->setIvarLBraceLoc(LBrac);
19816 CDecl->setIvarRBraceLoc(RBrac);
19825 llvm::APSInt &
Value,
19828 "Integral type required!");
19831 if (
Value.isUnsigned() ||
Value.isNonNegative()) {
19834 return Value.getActiveBits() <= BitWidth;
19836 return Value.getSignificantBits() <= BitWidth;
19846 const unsigned NumTypes = 4;
19847 QualType SignedIntegralTypes[NumTypes] = {
19850 QualType UnsignedIntegralTypes[NumTypes] = {
19857 : UnsignedIntegralTypes;
19858 for (
unsigned I = 0; I != NumTypes; ++I)
19871 llvm::APSInt EnumVal(IntWidth);
19891 EltTy =
Enum->getIntegerType();
19898 Val = Converted.
get();
19905 if (
Enum->isComplete()) {
19906 EltTy =
Enum->getIntegerType();
19915 .isWindowsMSVCEnvironment()) {
19916 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
19918 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
19942 Diag(IdLoc, diag::ext_enum_value_not_int)
19944 << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
19956 if (
Enum->isDependentType())
19958 else if (!LastEnumConst) {
19967 if (
Enum->isFixed()) {
19968 EltTy =
Enum->getIntegerType();
19977 EltTy = LastEnumConst->
getType();
19980 if (EnumVal < LastEnumConst->getInitVal()) {
19992 if (
T.isNull() ||
Enum->isFixed()) {
19996 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
19998 if (
Enum->isFixed())
20000 Diag(IdLoc, diag::err_enumerator_wrapped)
20004 Diag(IdLoc, diag::ext_enumerator_increment_too_large)
20024 Diag(IdLoc, diag::warn_enum_value_overflow);
20029 Diag(IdLoc, diag::ext_enum_value_not_int)
20057 auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl);
20061 EnumDecl *PrevED = cast<EnumDecl>(PrevECD->getDeclContext());
20076 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
20078 cast_or_null<EnumConstantDecl>(lastEnumConst);
20087 RedeclarationKind::ForVisibleRedeclaration);
20095 PrevDecl =
nullptr;
20113 if (!TheEnumDecl->
isScoped() && isa<ValueDecl>(PrevDecl)) {
20121 "Received TagDecl when not in C++!");
20123 if (isa<EnumConstantDecl>(PrevDecl))
20124 Diag(IdLoc, diag::err_redefinition_of_enumerator) <<
Id;
20126 Diag(IdLoc, diag::err_redefinition) <<
Id;
20159 if (!BO->isAdditiveOp())
20167 InitExpr = BO->getLHS();
20171 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
20191 if (!
Enum->getIdentifier())
20195 if (
Enum->getNumPositiveBits() > 63 ||
Enum->getNumNegativeBits() > 64)
20204 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
20207 typedef std::unordered_map<int64_t, DeclOrVector> ValueToVectorMap;
20211 llvm::APSInt Val = D->getInitVal();
20212 return Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue();
20215 DuplicatesVector DupVector;
20216 ValueToVectorMap EnumMap;
20220 for (
auto *Element : Elements) {
20234 EnumMap.insert({EnumConstantToKey(ECD), ECD});
20237 if (EnumMap.size() == 0)
20241 for (
auto *Element : Elements) {
20247 auto Iter = EnumMap.find(EnumConstantToKey(ECD));
20248 if (
Iter == EnumMap.end())
20251 DeclOrVector& Entry =
Iter->second;
20258 auto Vec = std::make_unique<ECDVector>();
20260 Vec->push_back(ECD);
20267 DupVector.emplace_back(std::move(Vec));
20271 ECDVector *Vec = Entry.get<ECDVector*>();
20273 if (*Vec->begin() == ECD)
20276 Vec->push_back(ECD);
20280 for (
const auto &Vec : DupVector) {
20281 assert(Vec->size() > 1 &&
"ECDVector should have at least 2 elements.");
20284 auto *FirstECD = Vec->front();
20285 S.
Diag(FirstECD->getLocation(), diag::warn_duplicate_enum_values)
20286 << FirstECD <<
toString(FirstECD->getInitVal(), 10)
20287 << FirstECD->getSourceRange();
20291 for (
auto *ECD : llvm::drop_begin(*Vec))
20292 S.
Diag(ECD->getLocation(), diag::note_duplicate_element)
20293 << ECD <<
toString(ECD->getInitVal(), 10)
20294 << ECD->getSourceRange();
20299 bool AllowMask)
const {
20300 assert(ED->
isClosedFlag() &&
"looking for value in non-flag or open enum");
20303 auto R =
FlagBitsCache.insert(std::make_pair(ED, llvm::APInt()));
20304 llvm::APInt &FlagBits = R.first->second;
20308 const auto &EVal = E->getInitVal();
20310 if (EVal.isPowerOf2())
20311 FlagBits = FlagBits.zext(EVal.getBitWidth()) | EVal;
20323 llvm::APInt FlagMask = ~FlagBits.zextOrTrunc(Val.getBitWidth());
20324 return !(FlagMask & Val) || (AllowMask && !(FlagMask & ~Val));
20336 if (
Enum->isDependentType()) {
20337 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
20339 cast_or_null<EnumConstantDecl>(Elements[i]);
20340 if (!ECD)
continue;
20358 unsigned NumNegativeBits = 0;
20359 unsigned NumPositiveBits = 0;
20361 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
20363 cast_or_null<EnumConstantDecl>(Elements[i]);
20364 if (!ECD)
continue;
20366 const llvm::APSInt &InitVal = ECD->
getInitVal();
20369 if (InitVal.isUnsigned() || InitVal.isNonNegative()) {
20372 unsigned ActiveBits = InitVal.getActiveBits();
20373 NumPositiveBits = std::max({NumPositiveBits, ActiveBits, 1u});
20376 std::max(NumNegativeBits, (
unsigned)InitVal.getSignificantBits());
20384 if (!NumPositiveBits && !NumNegativeBits)
20385 NumPositiveBits = 1;
20389 unsigned BestWidth;
20402 bool Packed =
Enum->hasAttr<PackedAttr>();
20410 if (
Enum->isComplete()) {
20411 BestType =
Enum->getIntegerType();
20415 BestPromotionType = BestType;
20419 else if (NumNegativeBits) {
20423 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
20425 BestWidth = CharWidth;
20426 }
else if (Packed && NumNegativeBits <= ShortWidth &&
20427 NumPositiveBits < ShortWidth) {
20429 BestWidth = ShortWidth;
20430 }
else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
20432 BestWidth = IntWidth;
20436 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
20441 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
20442 Diag(
Enum->getLocation(), diag::ext_enum_too_large);
20446 BestPromotionType = (BestWidth <= IntWidth ?
Context.
IntTy : BestType);
20451 if (Packed && NumPositiveBits <= CharWidth) {
20454 BestWidth = CharWidth;
20455 }
else if (Packed && NumPositiveBits <= ShortWidth) {
20458 BestWidth = ShortWidth;
20459 }
else if (NumPositiveBits <= IntWidth) {
20461 BestWidth = IntWidth;
20463 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
20465 }
else if (NumPositiveBits <=
20469 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
20473 if (NumPositiveBits > BestWidth) {
20478 Diag(
Enum->getLocation(), diag::ext_enum_too_large);
20482 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
20489 for (
auto *D : Elements) {
20490 auto *ECD = cast_or_null<EnumConstantDecl>(D);
20491 if (!ECD)
continue;
20500 llvm::APSInt InitVal = ECD->getInitVal();
20508 !
Enum->isFixed() &&
20511 NewWidth = IntWidth;
20513 }
else if (ECD->getType() == BestType) {
20523 NewWidth = BestWidth;
20528 InitVal = InitVal.extOrTrunc(NewWidth);
20529 InitVal.setIsSigned(NewSign);
20530 ECD->setInitVal(
Context, InitVal);
20533 if (ECD->getInitExpr() &&
20536 Context, NewTy, CK_IntegralCast, ECD->getInitExpr(),
20544 ECD->setType(NewTy);
20547 Enum->completeDefinition(BestType, BestPromotionType,
20548 NumPositiveBits, NumNegativeBits);
20552 if (
Enum->isClosedFlag()) {
20553 for (
Decl *D : Elements) {
20555 if (!ECD)
continue;
20558 if (InitVal != 0 && !InitVal.isPowerOf2() &&
20566 if (
Enum->hasAttrs())
20576 AsmString, StartLoc,
20607 AsmLabelAttr *
Attr = AsmLabelAttr::CreateImplicit(
20614 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
20618 Diag(PrevDecl->
getLocation(), diag::warn_redefine_extname_not_applied)
20619 << (isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl;
20631 PrevDecl->
addAttr(WeakAttr::CreateImplicit(
Context, PragmaLoc));
20646 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
20647 if (!PrevDecl->
hasAttr<AliasAttr>())
20648 if (
NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
20656 return (dyn_cast_or_null<ObjCContainerDecl>(
CurContext));
20661 assert(FD &&
"Expected non-null FunctionDecl");
20673 auto IsEmittedForExternalSymbol = [
this, FD]() {
20683 if (
LangOpts.OpenMPIsTargetDevice) {
20686 std::optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
20693 if (*DevTy == OMPDeclareTargetDeclAttr::DT_Host)
20697 if (
OpenMP().isInOpenMPDeclareTargetContext() || DevTy)
20698 if (IsEmittedForExternalSymbol())
20704 }
else if (
LangOpts.OpenMP > 45) {
20708 std::optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
20711 if (*DevTy == OMPDeclareTargetDeclAttr::DT_NoHost)
20730 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.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
static bool isDeclExternC(const T &D)
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines helper utilities for supporting the HLSL runtime environment.
static const Decl * getCanonicalDecl(const Decl *D)
static const GlobalDecl isTemplate(GlobalDecl GD, const TemplateArgumentList *&TemplateArgs)
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Architecture Architecture
llvm::MachO::Record Record
static bool isExternC(const NamedDecl *ND)
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis for CUDA constructs.
static void diagnoseImplicitlyRetainedSelf(Sema &S)
static void SetNestedNameSpecifier(Sema &S, DeclaratorDecl *DD, Declarator &D)
static UnqualifiedTypeNameLookupResult lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc, const CXXRecordDecl *RD)
Tries to perform unqualified lookup of the type decls in bases for dependent class.
static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, const FunctionDecl *&PossiblePrototype)
static bool PreviousDeclsHaveMultiVersionAttribute(const FunctionDecl *FD)
static ParsedType recoverFromTypeInKnownDependentBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc)
static void mergeParamDeclTypes(ParmVarDecl *NewParam, const ParmVarDecl *OldParam, Sema &S)
static void adjustDeclContextForDeclaratorDecl(DeclaratorDecl *NewD, DeclaratorDecl *OldD)
If necessary, adjust the semantic declaration context for a qualified declaration to name the correct...
static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken)
Determine whether the given result set contains either a type name or.
static void FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL)
static bool AllowOverloadingOfFunction(const LookupResult &Previous, ASTContext &Context, const FunctionDecl *New)
Determine whether overloading is allowed for a new function declaration considering prior declaration...
static TypeSourceInfo * TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized)
Helper method to turn variable array types into constant array types in certain situations which woul...
static StringRef getHeaderName(Builtin::Context &BuiltinInfo, unsigned ID, ASTContext::GetBuiltinTypeError Error)
static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D)
static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS, ExpectedDecl *New)
Check whether a redeclaration of an entity introduced by a using-declaration is valid,...
static bool mergeDeclAttribute(Sema &S, NamedDecl *D, const InheritableAttr *Attr, Sema::AvailabilityMergeKind AMK)
static ShadowedDeclKind computeShadowedDeclKind(const NamedDecl *ShadowedDecl, const DeclContext *OldDC)
Determine what kind of declaration we're shadowing.
static void checkIsValidOpenCLKernelParameter(Sema &S, Declarator &D, ParmVarDecl *Param, llvm::SmallPtrSetImpl< const Type * > &ValidTypes)
static void mergeParamDeclAttributes(ParmVarDecl *newDecl, const ParmVarDecl *oldDecl, Sema &S)
mergeParamDeclAttributes - Copy attributes from the old parameter to the new one.
void emitReadOnlyPlacementAttrWarning(Sema &S, const VarDecl *VD)
static bool CheckC23ConstexprVarType(Sema &SemaRef, SourceLocation VarLoc, QualType T)
static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous)
Check the validity of a mulitversion function declaration.
static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old)
Merge alignment attributes from Old to New, taking into account the special semantics of C11's _Align...
static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, LookupResult &Previous)
static void CheckConstPureAttributesUsage(Sema &S, FunctionDecl *NewFD)
static bool FindPossiblePrototype(const FunctionDecl *FD, const FunctionDecl *&PossiblePrototype)
static bool MultiVersionTypesCompatible(FunctionDecl *Old, FunctionDecl *New)
static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, FixItHint &Hint)
static void CheckExplicitObjectParameter(Sema &S, ParmVarDecl *P, SourceLocation ExplicitThisLoc)
static NestedNameSpecifier * synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC)
static void patchDefaultTargetVersion(FunctionDecl *From, FunctionDecl *To)
static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD)
Given that we are within the definition of the given function, will that definition behave like C99's...
static bool isRepresentableIntegerValue(ASTContext &Context, llvm::APSInt &Value, QualType T)
Determine whether the given integral value is representable within the given type T.
static void CheckForDuplicateEnumValues(Sema &S, ArrayRef< Decl * > Elements, EnumDecl *Enum, QualType EnumType)
static unsigned GetDiagnosticTypeSpecifierID(const DeclSpec &DS)
static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old)
checkNewAttributesAfterDef - If we already have a definition, check that there are no new attributes ...
static bool isClassCompatTagKind(TagTypeKind Tag)
Determine if tag kind is a class-key compatible with class for redeclaration (class,...
static bool hasIdenticalPassObjectSizeAttrs(const FunctionDecl *A, const FunctionDecl *B)
static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND)
static bool hasSimilarParameters(ASTContext &Context, FunctionDecl *Declaration, FunctionDecl *Definition, SmallVectorImpl< unsigned > &Params)
hasSimilarParameters - Determine whether the C++ functions Declaration and Definition have "nearly" m...
static NonCLikeKind getNonCLikeKindForAnonymousStruct(const CXXRecordDecl *RD)
Determine whether a class is C-like, according to the rules of C++ [dcl.typedef] for anonymous classe...
static FunctionDecl * CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, DeclContext *DC, QualType &R, TypeSourceInfo *TInfo, StorageClass SC, bool &IsVirtualOkay)
static Scope * getTagInjectionScope(Scope *S, const LangOptions &LangOpts)
Find the Scope in which a tag is implicitly declared if we see an elaborated type specifier in the sp...
static bool methodHasName(const FunctionDecl *FD, StringRef Name)
static std::pair< diag::kind, SourceLocation > getNoteDiagForInvalidRedeclaration(const T *Old, const T *New)
static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, LookupResult &Previous)
Apply special rules for handling extern "C" declarations.
static bool DeclHasAttr(const Decl *D, const Attr *A)
DeclhasAttr - returns true if decl Declaration already has the target attribute.
static bool isOpenCLSizeDependentType(ASTContext &C, QualType Ty)
static void diagnoseMissingConstinit(Sema &S, const VarDecl *InitDecl, const ConstInitAttr *CIAttr, bool AttrBeforeInit)
static bool shouldWarnIfShadowedDecl(const DiagnosticsEngine &Diags, const LookupResult &R)
static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S, SourceLocation NameLoc)
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
static bool CheckAnonMemberRedeclaration(Sema &SemaRef, Scope *S, DeclContext *Owner, DeclarationName Name, SourceLocation NameLoc, bool IsUnion, StorageClass SC)
We are trying to inject an anonymous member into the given scope; check if there's an existing declar...
static bool checkGlobalOrExternCConflict(Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous)
Check for conflict between this global or extern "C" declaration and previous global or extern "C" de...
static bool ShouldDiagnoseUnusedDecl(const LangOptions &LangOpts, const NamedDecl *D)
static bool isStdBuiltin(ASTContext &Ctx, FunctionDecl *FD, unsigned BuiltinID)
Determine whether a declaration matches a known function in namespace std.
static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, DeclContext *Owner, RecordDecl *AnonRecord, AccessSpecifier AS, StorageClass SC, SmallVectorImpl< NamedDecl * > &Chaining)
InjectAnonymousStructOrUnionMembers - Inject the members of the anonymous struct or union AnonRecord ...
@ InvalidAddrSpacePtrKernelParam
static bool isFromSystemHeader(SourceManager &SM, const Decl *D)
Returns true if the declaration is declared in a system header or from a system macro.
static bool AreSpecialMemberFunctionsSameKind(ASTContext &Context, CXXMethodDecl *M1, CXXMethodDecl *M2, CXXSpecialMemberKind CSM)
[class.mem.special]p5 Two special member functions are of the same kind if:
static const CXXRecordDecl * findRecordWithDependentBasesOfEnclosingMethod(const DeclContext *DC)
Find the parent class with dependent bases of the innermost enclosing method context.
static void ComputeSelectedDestructor(Sema &S, CXXRecordDecl *Record)
[class.dtor]p4: At the end of the definition of a class, overload resolution is performed among the p...
static bool shouldConsiderLinkage(const VarDecl *VD)
static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record)
static bool CheckMultiVersionAdditionalRules(Sema &S, const FunctionDecl *OldFD, const FunctionDecl *NewFD, bool CausesMV, MultiVersionKind MVKind)
static DeclContext * getTagInjectionContext(DeclContext *DC)
Find the DeclContext in which a tag is implicitly declared if we see an elaborated type specifier in ...
static bool EquivalentArrayTypes(QualType Old, QualType New, const ASTContext &Ctx)
static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New)
static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for redeclaration diagnostic message.
static void CheckPoppedLabel(LabelDecl *L, Sema &S, Sema::DiagReceiverTy DiagReceiver)
static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl *Old)
static NamedDecl * DiagnoseInvalidRedeclaration(Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S)
Generate diagnostics for an invalid function redeclaration.
static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, DeclarationName Name)
RebuildDeclaratorInCurrentInstantiation - Checks whether the given declarator needs to be rebuilt in ...
static void SetEligibleMethods(Sema &S, CXXRecordDecl *Record, ArrayRef< CXXMethodDecl * > Methods, CXXSpecialMemberKind CSM)
[class.mem.special]p6: An eligible special member function is a special member function for which:
static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc)
static bool hasParsedAttr(Scope *S, const Declarator &PD, ParsedAttr::Kind Kind)
ShadowedDeclKind
Enum describing the select options in diag::warn_decl_shadow.
static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S)
static bool canRedefineFunction(const FunctionDecl *FD, const LangOptions &LangOpts)
canRedefineFunction - checks if a function can be redefined.
static ObjCIvarDecl::AccessControl TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility)
TranslateIvarVisibility - Translate visibility from a token ID to an AST enum value.
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 filterNonConflictingPreviousTypedefDecls(Sema &S, TypedefNameDecl *Decl, LookupResult &Previous)
Typedef declarations don't have linkage, but they still denote the same entity if their types are the...
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 CheckTargetCausesMultiVersioning(Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous)
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 bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum)
static QualType getNextLargerIntegralType(ASTContext &Context, QualType T)
static bool isIncompleteDeclExternC(Sema &S, const T *D)
Determine whether a variable is extern "C" prior to attaching an initializer.
static bool isAttributeTargetADefinition(Decl *D)
static Attr * getImplicitCodeSegAttrFromClass(Sema &S, const FunctionDecl *FD)
Return a CodeSegAttr from a containing class.
static bool 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 OpenMP constructs and clauses.
static CharSourceRange getRange(const CharSourceRange &EditRange, const SourceManager &SM, const LangOptions &LangOpts, bool IncludeMacroExpansion)
Defines the SourceManager interface.
C Language Family Type Representation.
const NestedNameSpecifier * Specifier
RAII object that pops an ExpressionEvaluationContext when exiting a function body.
ExitFunctionBodyRAII(Sema &S, bool IsLambda)
llvm::APInt getValue() const
virtual void HandleTagDeclDefinition(TagDecl *D)
HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.
virtual void HandleInlineFunctionDefinition(FunctionDecl *D)
This callback is invoked each time an inline (method or friend) function definition in a class is com...
virtual bool shouldSkipFunctionBody(Decl *D)
This callback is called for each function if the Parser was initialized with SkipFunctionBodies set t...
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
QualType getUsingType(const UsingShadowDecl *Found, QualType Underlying) const
SourceManager & getSourceManager()
TranslationUnitDecl * getTranslationUnitDecl() const
const ConstantArrayType * getAsConstantArrayType(QualType T) const
QualType getParenType(QualType NamedType) const
unsigned getIntWidth(QualType T) const
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
ExternCContextDecl * getExternCContextDecl() const
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
DeclarationNameTable DeclarationNames
QualType getObjCClassType() const
Represents the Objective-C Class type.
QualType getRecordType(const RecordDecl *Decl) const
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
void setObjCIdRedefinitionType(QualType RedefType)
Set the user-written type that redefines id.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
void setObjCSelRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U) const
Determine whether two function types are the same, ignoring exception specifications in cases where t...
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Builtin::Context & BuiltinInfo
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
void addModuleInitializer(Module *M, Decl *Init)
Add a declaration to the list of declarations that are initialized for a module.
const LangOptions & getLangOpts() const
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
void attachCommentsToJustParsedDecls(ArrayRef< Decl * > Decls, const Preprocessor *PP)
Searches existing comments for doc comments that should be attached to Decls.
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
void setucontext_tDecl(TypeDecl *ucontext_tDecl)
Set the type for the C ucontext_t type.
CanQualType UnsignedLongTy
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
MangleNumberingContext & getManglingNumberContext(const DeclContext *DC)
Retrieve the context for computing mangling numbers in the given DeclContext.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
void setNonKeyFunction(const CXXMethodDecl *method)
Observe that the given method cannot be a key function.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
const clang::PrintingPolicy & getPrintingPolicy() const
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false, bool IsConditionalOperator=false)
QualType getObjCIdType() const
Represents the Objective-CC id type.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
void setManglingNumber(const NamedDecl *ND, unsigned Number)
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
CanQualType UnsignedLongLongTy
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
CanQualType UnsignedShortTy
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
void setcudaConfigureCallDecl(FunctionDecl *FD)
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
const VariableArrayType * getAsVariableArrayType(QualType T) const
void setObjCClassRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
void ResetObjCLayout(const ObjCContainerDecl *CD)
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
const TargetInfo & getTargetInfo() const
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
void setjmp_bufDecl(TypeDecl *jmp_bufDecl)
Set the type for the C jmp_buf type.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
QualType mergeObjCGCQualifiers(QualType, QualType)
mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 'RHS' attributes and ret...
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
LangAS getLangASForBuiltinAddressSpace(unsigned AS) const
bool hasSameFunctionTypeIgnoringPtrSizes(QualType T, QualType U)
Determine whether two function types are the same, ignoring pointer sizes in the return type and para...
TemplateName getAssumedTemplateName(DeclarationName Name) const
Retrieve a template name representing an unqualified-id that has been assumed to name a template for ...
@ GE_Missing_stdio
Missing a type from <stdio.h>
@ GE_Missing_type
Missing a type.
@ GE_Missing_ucontext
Missing a type from <ucontext.h>
@ GE_Missing_setjmp
Missing a type from <setjmp.h>
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
The result of parsing/analyzing an expression, statement etc.
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
Wrapper for source info for arrays.
SourceLocation getLBracketLoc() const
Expr * getSizeExpr() const
TypeLoc getElementLoc() const
SourceLocation getRBracketLoc() const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
Attr - This represents one attribute.
attr::Kind getKind() const
Attr * clone(ASTContext &C) const
SourceLocation getLocation() const
@ AS_Declspec
__declspec(...)
SourceRange getRange() const
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
AttributeFactory & getFactory() const
Type source information for an attributed type.
TypeLoc getModifiedLoc() const
The modified type, which is generally canonically different from the attribute type.
An attributed type is a type to which a type attribute has been applied.
QualType getModifiedType() const
bool isCallingConv() const
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
AutoTypeKeyword getKeyword() const
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
Expr * getCond() const
getCond - Return the condition expression; this is defined in terms of the opaque value.
A builtin binary operation expression such as "x + y" or "x <= y".
static bool isCompoundAssignmentOp(Opcode Opc)
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 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.
Expr * getArg(unsigned Arg)
Return the specified argument.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Represents a C++ constructor within a class.
bool isCopyConstructor(unsigned &TypeQuals) const
Whether this constructor is a copy constructor (C++ [class.copy]p2, which can be used to copy the cla...
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor(), Expr *TrailingRequiresClause=nullptr)
Represents a C++ conversion function within a class.
static CXXConversionDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation, CXXConstructorDecl *Ctor=nullptr, DeductionCandidate Kind=DeductionCandidate::Normal)
Represents a C++ destructor within a class.
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
A mapping from each virtual member function to its set of final overriders.
Represents a static or instance method of a struct/union/class.
bool isExplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An explicit object member function is a non-static member function with an explic...
void addOverriddenMethod(const CXXMethodDecl *MD)
QualType getFunctionObjectParameterReferenceType() const
Return the type of the object pointed by this.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Qualifiers getMethodQualifiers() const
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
A call to an overloaded operator written using operator syntax.
Represents a C++ struct/union/class.
bool hasNonTrivialCopyAssignment() const
Determine whether this class has a non-trivial copy assignment operator (C++ [class....
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
base_class_iterator bases_end()
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
bool hasNonTrivialDestructor() const
Determine whether this class has a non-trivial destructor (C++ [class.dtor]p3)
CXXRecordDecl * getDefinition() const
unsigned getNumBases() const
Retrieves the number of base classes of this class.
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths, bool LookupInDependent=false) const
Look for entities within the base classes of this C++ class, transitively searching all base class su...
base_class_iterator bases_begin()
capture_const_range captures() const
bool hasDefinition() const
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
LambdaCaptureDefault getLambdaCaptureDefault() const
void setDescribedClassTemplate(ClassTemplateDecl *Template)
bool hasNonTrivialCopyConstructor() const
Determine whether this class has a non-trivial copy constructor (C++ [class.copy]p6,...
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Represents a C++ nested-name-specifier or a global scope specifier.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
char * location_data() const
Retrieve the data associated with the source-location information.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
SourceRange getRange() const
SourceLocation getBeginLoc() const
bool isSet() const
Deprecated.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
bool isEmpty() const
No scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
bool isCallToStdMove() const
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
CastKind getCastKind() const
static CharSourceRange getCharRange(SourceRange R)
CharUnits - This is an opaque type for sizes expressed in character units.
bool isZero() const
isZero - Test whether the quantity equals zero.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Declaration of a class template.
bool exprNeedsCleanups() const
ConditionalOperator - The ?: ternary operator.
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
llvm::APInt getSize() const
Return the constant array size as an APInt.
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isFileContext() const
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
bool isObjCContainer() const
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
const BlockDecl * getInnermostBlockDecl() const
Return this DeclContext if it is a BlockDecl.
bool isTranslationUnit() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void removeDecl(Decl *D)
Removes a declaration from this context.
void addDecl(Decl *D)
Add the declaration D into this context.
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Decl::Kind getDeclKind() const
DeclContext * getNonTransparentContext()
Simple template class for restricting typo correction candidates to ones having a single Decl* of the...
static DeclGroupRef Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
A reference to a declared variable, function, enum, etc.
SourceLocation getBeginLoc() const LLVM_READONLY
Captures information about "declaration specifiers".
bool isVirtualSpecified() const
bool isModulePrivateSpecified() const
static const TST TST_typeof_unqualType
bool hasAutoTypeSpec() const
static const TST TST_typename
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec and return false if there was no error.
void ClearStorageClassSpecs()
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
SourceRange getExplicitSpecRange() 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
void ClearConstexprSpec()
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
ExplicitSpecifier getExplicitSpecifier() const
bool isTypeSpecOwned() const
SourceLocation getInlineSpecLoc() const
SourceLocation getUnalignedSpecLoc() const
SourceLocation getVolatileSpecLoc() const
FriendSpecified isFriendSpecified() const
bool hasExplicitSpecifier() const
bool hasConstexprSpecifier() const
static const TST TST_typeofType
static const TST TST_auto
ConstexprSpecKind getConstexprSpecifier() const
static const TST TST_struct
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
const DeclContext * getParentFunctionOrMethod(bool LexicalParent=false) const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext,...
bool isInStdNamespace() const
SourceLocation getEndLoc() const LLVM_READONLY
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
void setAttrs(const AttrVec &Attrs)
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked 'unavailable'.
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).
Module * getOwningModuleForLinkage(bool IgnoreLinkage=false) const
Get the module that owns this declaration for linkage purposes.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
void setTopLevelDeclInObjCContainer(bool V=true)
bool isInIdentifierNamespace(unsigned NS) const
@ FOK_Undeclared
A friend of a previously-undeclared entity.
@ FOK_None
Not a friend object.
@ FOK_Declared
A friend of a previously-declared entity.
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
bool isInExportDeclContext() const
Whether this declaration was exported in a lexical context.
bool isReferenced() const
Whether any declaration of this entity was referenced.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
bool isFromExplicitGlobalModule() const
Whether this declaration comes from explicit global module.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
@ OBJC_TQ_CSNullability
The nullability qualifier is set when the nullability of the result or parameter was expressed via a ...
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it's the object of a friend declaration.
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
bool isInvalidDecl() const
bool isLocalExternDecl() const
Determine whether this is a block-scope declaration with linkage.
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
@ IDNS_Ordinary
Ordinary names.
void setLocalOwningModule(Module *M)
void setImplicit(bool I=true)
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool hasOwningModule() const
Is this declaration owned by some module?
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
void setLexicalDeclContext(DeclContext *DC)
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 isEmpty() const
Evaluates true when this declaration name is empty.
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.
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
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.
Expr * getAsmLabel() const
FunctionDefinitionKind getFunctionDefinitionKind() const
const ParsedAttributes & getAttributes() const
void setRedeclaration(bool Val)
SourceLocation getIdentifierLoc() const
void SetIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Set the name of this declarator to be the given identifier.
SourceLocation getEndLoc() const LLVM_READONLY
Expr * getTrailingRequiresClause()
Sets a trailing requires clause for this declarator.
void setInvalidType(bool Val=true)
TemplateParameterList * getInventedTemplateParameterList() const
The template parameter list generated from the explicit template parameters along with any invented t...
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
bool isRedeclaration() const
const ParsedAttributesView & getDeclarationAttributes() const
const DecompositionDeclarator & getDecompositionDeclarator() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isCtorOrDtor()
Returns true if this declares a constructor or a destructor.
bool isFunctionDefinition() const
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
bool hasInitializer() const
void setFunctionDefinitionKind(FunctionDefinitionKind Val)
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
void takeAttributes(ParsedAttributes &attrs)
takeAttributes - Takes attributes from the given parsed-attributes set and add them to this declarato...
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
bool isInvalidType() const
bool isExplicitObjectMemberFunction()
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
bool isDecompositionDeclarator() const
Return whether this declarator is a decomposition declarator.
bool isFirstDeclarationOfMember()
Returns true if this declares a real member and not a friend.
bool isStaticMember()
Returns true if this declares a static member.
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
const IdentifierInfo * getIdentifier() 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.
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant,...
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
Represents difference between two FPOptions values.
void setDisallowOptimizations()
void applyChanges(FPOptionsOverride FPO)
bool isFPConstrained() const
FPOptionsOverride getChangesFrom(const FPOptions &Base) const
Return difference with the given option set.
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
bool isZeroLengthBitField(const ASTContext &Ctx) const
Is this a zero-length bit-field? Such bit-fields aren't really bit-fields at all and instead act as a...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
static FileScopeAsmDecl * Create(ASTContext &C, DeclContext *DC, StringLiteral *Str, SourceLocation AsmLoc, SourceLocation RParenLoc)
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Represents a function declaration or definition.
bool isMultiVersion() const
True if this function is considered a multiversioned function.
const ParmVarDecl * getParamDecl(unsigned i) const
ConstexprSpecKind getConstexprKind() const
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
void setPreviousDeclaration(FunctionDecl *PrevDecl)
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
void setIsPureVirtual(bool P=true)
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
void setFriendConstraintRefersToEnclosingTemplate(bool V=true)
void setHasSkippedBody(bool Skipped=true)
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
param_iterator param_end()
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
void setIsMultiVersion(bool V=true)
Sets the multiversion state for this declaration and all of its redeclarations.
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
bool hasWrittenPrototype() const
Whether this function has a written prototype.
void setWillHaveBody(bool V=true)
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
param_iterator param_begin()
const ParmVarDecl * getNonObjectParameter(unsigned I) const
bool isVariadic() const
Whether this function is variadic.
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
bool isDeleted() const
Whether this function has been deleted.
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.
Represents a prototype with parameter type info, e.g.
unsigned getNumParams() const
QualType getParamType(unsigned i) const
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
ArrayRef< QualType > param_types() const
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
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.
Provides information about a function template specialization, which is a FunctionDecl that has been ...
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration,...
Wrapper for source info for functions.
A class which abstracts out some details necessary for making a call.
ExtInfo withCallingConv(CallingConv cc) const
CallingConv getCC() const
ExtInfo withProducesResult(bool producesResult) const
unsigned getRegParm() const
bool getNoCallerSavedRegs() const
ExtInfo withNoReturn(bool noReturn) const
bool getHasRegParm() const
bool getProducesResult() const
ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const
ExtInfo withRegParm(unsigned RegParm) const
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
static StringRef getNameForCallConv(CallingConv CC)
static ArmStateValue getArmZT0State(unsigned AttrBits)
static ArmStateValue getArmZAState(unsigned AttrBits)
unsigned getRegParmType() const
CallingConv getCallConv() const
QualType getReturnType() const
bool getCmseNSCallAttr() const
@ SME_PStateSMEnabledMask
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
bool isEditorPlaceholder() const
Return true if this identifier is an editor placeholder.
bool isPlaceholder() const
StringRef getName() const
Return the actual identifier string.
iterator - Iterate over the decls of a specified declaration name.
iterator begin(DeclarationName Name)
Returns an iterator over decls with the name 'Name'.
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
void InsertDeclAfter(iterator Pos, NamedDecl *D)
Insert the given declaration after the given iterator position.
iterator end()
Returns the end iterator.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
bool isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false) const
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Represents a C array with an unspecified size.
Represents a field injected from an anonymous union/struct into the parent scope.
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, const IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl * > CH)
void setInherited(bool I)
Description of a constructor that was inherited from a base class.
Describes an C or C++ initializer list.
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init)
Create an initialization from an initializer (which, for direct initialization from a parenthesized l...
Describes the sequence of initializations required to initialize a given object or reference with a s...
step_iterator step_begin() const
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
@ SK_ParenthesizedListInit
Initialize an aggreagate with parenthesized list of values.
Describes an entity that is being initialized.
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Represents the declaration of a label.
bool isResolvedMSAsmLabel() const
LabelStmt * getStmt() const
bool isMSAsmLabel() const
@ FPE_Ignore
Assume that floating-point exceptions are masked.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
FPExceptionModeKind getDefaultExceptionMode() const
bool requiresStrictPrototypes() const
Returns true if functions without prototypes or functions with an identifier list (aka K&R C function...
clang::ObjCRuntime ObjCRuntime
std::string getOpenCLVersionString() const
Return the OpenCL C or C++ for OpenCL language name and version as a string.
bool IsHeaderFile
Indicates whether the front-end is explicitly told that the input is a header file (i....
bool implicitFunctionsAllowed() const
Returns true if implicit function declarations are allowed in the current language mode.
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
std::vector< llvm::Triple > OMPTargetTriples
Triples of the OpenMP targets that the host code codegen should take into account in order to generat...
void push_back(const T &LocalValue)
static SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)
Checks that the given token is the first token that occurs after the given location (this excludes co...
Represents a linkage specification.
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LinkageSpecLanguageIDs Lang, bool HasBraces)
void InstantiatedLocal(const Decl *D, Decl *Inst)
A class for iterating through a result set and possibly filtering out results.
void erase()
Erase the last element returned from this iterator.
Represents the results of name lookup.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
@ NotFound
No entity found met the criteria.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
@ Found
Name lookup found a single declaration that met the criteria.
DeclClass * getAsSingle() const
bool empty() const
Return true if no decls were found.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Filter makeFilter()
Create a filter for this result set.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Sema & getSema() const
Get the Sema object that this lookup result is searching with.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
LookupResultKind getResultKind() const
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
@ AmbiguousTagHiding
Name lookup results in an ambiguity because an entity with a tag name was hidden by an entity with an...
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
virtual unsigned getManglingNumber(const CXXMethodDecl *CallOperator)=0
Retrieve the mangling number of a new lambda expression with the given call operator within this cont...
virtual unsigned getStaticLocalNumber(const VarDecl *VD)=0
Static locals are numbered by source order.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
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.
StringRef getPrimaryModuleInterfaceName() const
Get the primary module interface name from a partition.
bool isModulePartition() const
Is this a module partition.
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
Visibility getVisibility() const
Determines the visibility of this entity.
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.
bool declarationReplaces(const NamedDecl *OldD, bool IsKnownNewer=true) const
Determine whether this declaration, if known to be well-formed within its context,...
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
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const
Determine if the declaration obeys the reserved identifier rules of the given language.
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.
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
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.
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
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 isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
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 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.
std::optional< NonConstantStorageReason > isNonConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
Determine whether instances of this type can be placed in immutable storage.
PrimitiveDefaultInitializeKind isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C struct types.
bool isObjCGCStrong() const
true when Type is objc's strong.
bool isConstQualified() const
Determine whether this type is const-qualified.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool hasNonTrivialObjCLifetime() const
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
@ PCK_Trivial
The type does not fall into any of the following categories.
@ PCK_VolatileTrivial
The type would be trivial except that it is volatile-qualified.
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
A qualifier set is used to build a set of qualifiers.
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
ObjCLifetime getObjCLifetime() const
Represents a struct/union/class.
bool hasObjectMember() const
field_range fields() const
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
virtual void completeDefinition()
Note that the definition of this type is now complete.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
void setMemberSpecialization()
Note that this member template is a specialization.
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
redecl_iterator redecls_end() const
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Base for LValueReferenceType and RValueReferenceType.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
void setNRVOCandidate(const VarDecl *Var)
Set the variable that might be used for the named return value optimization.
Scope - A scope is a transient data structure that is used while parsing the program.
bool isDeclScope(const Decl *D) const
isDeclScope - Return true if this is the scope that the specified decl is declared in.
DeclContext * getEntity() const
Get the entity corresponding to this scope.
bool isCompoundStmtScope() const
Determine whether this scope is a compound statement scope.
const Scope * getParent() const
getParent - Return the scope that this is nested in.
@ TemplateParamScope
This is a scope that corresponds to the template parameters of a C++ template.
@ DeclScope
This is a scope that can contain a declaration.
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
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)
HLSLShaderAttr * mergeShaderAttr(Decl *D, const AttributeCommonInfo &AL, HLSLShaderAttr::ShaderType ShaderType)
void ActOnTopLevelFunction(FunctionDecl *FD)
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.
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.
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)
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.
void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D)
void ActOnObjCContainerStartDefinition(ObjCContainerDecl *IDecl)
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Scope * getCurScope() const
Retrieve the parser's current scope.
void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New, LookupResult &OldDecls)
MergeTypedefNameDecl - We just parsed a typedef 'New' which has the same name and scope as a previous...
bool hasStructuralCompatLayout(Decl *D, Decl *Suggested)
Determine if D and Suggested have a structurally compatible layout as described in C11 6....
void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S)
Register the given locally-scoped extern "C" declaration so that it can be found later for redeclarat...
BTFDeclTagAttr * mergeBTFDeclTagAttr(Decl *D, const BTFDeclTagAttr &AL)
bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New)
NamedDecl * ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope)
bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, const CXXMethodDecl *Old)
void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, const ObjCMethodDecl *Overridden)
Check whether the given new method is a valid override of the given overridden method,...
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)
ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV)
void ActOnTagDefinitionError(Scope *S, Decl *TagDecl)
ActOnTagDefinitionError - Invoked when there was an unrecoverable error parsing the definition of a t...
void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body)
TypeVisibilityAttr * mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, TypeVisibilityAttr::VisibilityType Vis)
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 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...
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
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.
WebAssemblyImportNameAttr * mergeImportNameAttr(Decl *D, const WebAssemblyImportNameAttr &AL)
bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, InheritedConstructorInfo *ICI=nullptr, bool Diagnose=false)
Determine if a special member function should have a deleted definition when it is defaulted.
void ActOnExitFunctionContext()
ExprResult RebuildExprInCurrentInstantiation(Expr *E)
DeclResult ActOnVarTemplateSpecialization(Scope *S, Declarator &D, TypeSourceInfo *DI, LookupResult &Previous, SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams, StorageClass SC, bool IsPartialSpecialization)
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
Preprocessor & getPreprocessor() const
void deduceOpenCLAddressSpace(ValueDecl *decl)
PragmaStack< FPOptionsOverride > FpPragmaStack
PragmaStack< StringLiteral * > CodeSegStack
void AddRangeBasedOptnone(FunctionDecl *FD)
Only called on function definitions; if there is a pragma in scope with the effect of a range-based o...
bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckForFunctionMarkedFinal - Checks whether a virtual member function overrides a virtual member fun...
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 ...
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)
void CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC)
CheckConversionDeclarator - Called by ActOnDeclarator to check the well-formednes of the conversion f...
VisibilityAttr * mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, VisibilityAttr::VisibilityType Vis)
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization, bool Disambiguation=false)
Decl * ActOnFileScopeAsmDecl(Expr *expr, SourceLocation AsmLoc, SourceLocation RParenLoc)
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
DiagnosticsEngine & getDiagnostics() const
void ActOnFinishTopLevelStmtDecl(TopLevelStmtDecl *D, Stmt *Statement)
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
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...
SmallVector< VarDecl *, 4 > ExternalDeclarations
All the external declarations encoutered and used in the TU.
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 CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, ObjCIvarDecl **Fields, unsigned nIvars, SourceLocation Loc)
CheckImplementationIvars - This routine checks if the instance variables listed in the implelementati...
void inferGslOwnerPointerAttribute(CXXRecordDecl *Record)
Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
ObjCInterfaceDecl * getObjCInterfaceDecl(const IdentifierInfo *&Id, SourceLocation IdLoc, bool TypoCorrection=false)
Look for an Objective-C class in the translation unit.
llvm::function_ref< void(SourceLocation Loc, PartialDiagnostic PD)> DiagReceiverTy
bool CheckEnumUnderlyingType(TypeSourceInfo *TI)
Check that this is a valid underlying type for an enum declaration.
bool FriendConstraintsDependOnEnclosingTemplate(const FunctionDecl *FD)
FPOptions & getCurFPFeatures()
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
sema::LambdaScopeInfo * PushLambdaScope()
SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, SourceLocation IILoc)
Determine whether the body of an anonymous enumeration should be skipped.
@ UPPC_FixedUnderlyingType
The fixed underlying type of an enumeration.
@ UPPC_EnumeratorValue
The enumerator value.
@ UPPC_Initializer
An initializer.
@ UPPC_FriendDeclaration
A friend declaration.
@ UPPC_DeclarationType
The type of an arbitrary declaration.
@ UPPC_ExplicitSpecialization
Explicit specialization.
@ UPPC_DeclarationQualifier
A declaration qualifier.
@ UPPC_DataMemberType
The type of a data member.
@ UPPC_BitFieldWidth
The size of a bit-field.
const LangOptions & getLangOpts() const
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl, bool SupportedForCompatibility=false)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter 'PrevD...
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
bool RebuildTemplateParamsInCurrentInstantiation(TemplateParameterList *Params)
Rebuild the template parameters now that we know we're in a current instantiation.
void DiagnoseInvalidJumps(Stmt *Body)
SourceLocation CurInitSegLoc
bool currentModuleIsHeaderUnit() const
Is the module scope we are in a C++ Header Unit?
void EnterTemplatedContext(Scope *S, DeclContext *DC)
Enter a template parameter scope, after it's been associated with a particular DeclContext.
bool tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo, QualType &T, SourceLocation Loc, unsigned FailedFoldDiagID)
Attempt to fold a variable-sized type to a constant-sized type, returning true if we were successful.
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
NamedDecl * findLocallyScopedExternCDecl(DeclarationName Name)
Look for a locally scoped extern "C" declaration by the given name.
bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old)
We've determined that New is a redeclaration of Old.
bool CheckConstexprFunctionDefinition(const FunctionDecl *FD, CheckConstexprKind Kind)
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
MinSizeAttr * mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI)
NamedDecl * getShadowedDeclaration(const TypedefNameDecl *D, const LookupResult &R)
Return the declaration shadowed by the given typedef D, or null if it doesn't shadow any declaration ...
void checkTypeSupport(QualType Ty, SourceLocation Loc, ValueDecl *D=nullptr)
Check if the type is allowed to be used for the current target.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD)
const LangOptions & LangOpts
void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock)
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
bool isReachable(const NamedDecl *D)
Determine whether a declaration is reachable.
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr, FnBodyKind BodyKind=FnBodyKind::Other)
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn)
Perform semantic checking of a new function declaration.
CXXRecordDecl * getStdBadAlloc() const
AlwaysInlineAttr * mergeAlwaysInlineAttr(Decl *D, const AttributeCommonInfo &CI, const IdentifierInfo *Ident)
FieldDecl * CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitfieldWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D=nullptr)
Build a new FieldDecl and check its well-formedness.
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
PragmaClangSection PragmaClangRelroSection
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD, SourceLocation ReturnLoc, Expr *RetExpr, const AutoType *AT)
Deduce the return type for a function from a returned expression, per C++1y [dcl.spec....
void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D)
void CheckCXXDefaultArguments(FunctionDecl *FD)
Helpers for dealing with blocks and functions.
bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS)
checkUnsafeAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained type.
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
WebAssemblyImportModuleAttr * mergeImportModuleAttr(Decl *D, const WebAssemblyImportModuleAttr &AL)
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...
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, 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...
void CheckConstructor(CXXConstructorDecl *Constructor)
CheckConstructor - Checks a fully-formed constructor for well-formedness, issuing any diagnostics req...
void AddCFAuditedAttribute(Decl *D)
AddCFAuditedAttribute - Check whether we're currently within '#pragma clang arc_cf_code_audited' and,...
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)
void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init)
bool ActOnDuplicateDefinition(Decl *Prev, SkipBodyInfo &SkipBody)
Perform ODR-like check for C/ObjC when merging tag types from modules.
void ActOnFinishInlineFunctionDef(FunctionDecl *D)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
TypeSourceInfo * RebuildTypeInCurrentInstantiation(TypeSourceInfo *T, SourceLocation Loc, DeclarationName Name)
Rebuilds a type within the context of the current instantiation.
void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, const IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)
Check whether the given function decl's trailing requires clause is satisfied, if any.
bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl)
CheckLiteralOperatorDeclaration - Check whether the declaration of this literal operator function is ...
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)
ObjCContainerDecl * getObjCDeclContext() const
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
void ActOnObjCContainerFinishDefinition()
SourceManager & getSourceManager() const
NamedDecl * ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists)
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams)
Handle a friend type declaration.
llvm::DenseMap< const EnumDecl *, llvm::APInt > FlagBitsCache
A cache of the flags available in enumerations with the flag_bits attribute.
bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, Scope *S, bool MergeTypeWithOld)
Completes the merge of two function declarations that are known to be compatible.
void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, Decl *EnumDecl, ArrayRef< Decl * > Elements, Scope *S, const ParsedAttributesView &Attr)
void EnterDeclaratorContext(Scope *S, DeclContext *DC)
EnterDeclaratorContext - Used when we must lookup names in the context of a declarator's nested name ...
bool areMultiversionVariantFunctionsCompatible(const FunctionDecl *OldFD, const FunctionDecl *NewFD, const PartialDiagnostic &NoProtoDiagID, const PartialDiagnosticAt &NoteCausedDiagIDAt, const PartialDiagnosticAt &NoSupportDiagIDAt, const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported, bool ConstexprSupported, bool CLinkageMayDiffer)
Checks if the variant/multiversion functions are compatible.
void ActOnTagStartDefinition(Scope *S, Decl *TagDecl)
ActOnTagStartDefinition - Invoked when we have entered the scope of a tag's definition (e....
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
PragmaClangSection PragmaClangTextSection
PragmaClangSection PragmaClangDataSection
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=std::nullopt, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
void FilterAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true)
ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name, SourceLocation NameLoc)
Act on the result of classifying a name as an undeclared (ADL-only) non-type declaration.
bool IsAtLeastAsConstrained(NamedDecl *D1, MutableArrayRef< const Expr * > AC1, NamedDecl *D2, MutableArrayRef< const Expr * > AC2, bool &Result)
Check whether the given declaration's associated constraints are at least as constrained than another...
void ActOnPragmaRedefineExtname(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaRedefineExtname - Called on well formed #pragma redefine_extname oldname newname.
bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams)
Check whether a template can be declared within this scope.
void AddMsStructLayoutForRecord(RecordDecl *RD)
AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
MaybeODRUseExprSet MaybeODRUseExprs
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
CheckParmsForFunctionDef - Check that the parameters of the given function are appropriate for the de...
TopLevelStmtDecl * ActOnStartTopLevelStmtDecl(Scope *S)
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don't have one.
bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
Perform semantic analysis for the given non-template member specialization.
TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc, ImplicitTypenameContext IsImplicitTypename=ImplicitTypenameContext::No)
Called when the parser has parsed a C++ typename specifier, e.g., "typename T::type".
void ActOnObjCReenterContainerContext(ObjCContainerDecl *ObjCCtx)
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 AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(FunctionDecl *FD)
If this function is a C++ replaceable global allocation function (C++2a [basic.stc....
bool inferObjCARCLifetime(ValueDecl *decl)
@ 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)
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
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)
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle.
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
QualType AdjustParameterTypeForObjCAutoRefCount(QualType T, SourceLocation NameLoc, TypeSourceInfo *TSInfo)
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 DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID)
DiagnoseDuplicateIvars - Check for duplicate ivars in the entire class at the start of @implementatio...
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
QualType CheckConstructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckConstructorDeclarator - Called by ActOnDeclarator to check the well-formedness of the constructo...
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D.
QualType SubstAutoTypeDependent(QualType TypeWithAuto)
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope.
void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, const WeakInfo &W)
DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak applied to it,...
bool IsInvalidSMECallConversion(QualType FromType, QualType ToType)
void ActOnUninitializedDecl(Decl *dcl)
void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc)
Emit diagnostics if the initializer or any of its explicit or implicitly-generated subexpressions req...
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope.
TypedefDecl * ParseTypedefDecl(Scope *S, Declarator &D, QualType T, TypeSourceInfo *TInfo)
Subroutines of ActOnDeclarator().
sema::LambdaScopeInfo * getEnclosingLambda() const
Get the innermost lambda enclosing the current location, if any.
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionExceptionSpec - Checks whether the exception spec is a subset of base spec.
Decl * ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth)
ActOnField - Each field of a C struct/union is passed into this in order to create a FieldDecl object...
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)
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.
SwiftNameAttr * mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA, StringRef Name)
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.
Decl * ActOnIvar(Scope *S, SourceLocation DeclStart, Declarator &D, Expr *BitWidth, tok::ObjCKeywordKind visibility)
ActOnIvar - Each ivar field of an objective-c class is passed into this in order to create an IvarDec...
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.
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 ActOnObjCTemporaryExitContainerContext(ObjCContainerDecl *ObjCCtx)
Invoked when we must temporarily exit the objective-c container scope for parsing/looking-up C constr...
void inferNullableClassAttribute(CXXRecordDecl *CRD)
Add _Nullable attributes for std:: types.
NamedDecl * ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef< BindingDecl * > Bindings=std::nullopt)
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
ExprResult ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *OverloadSet)
Act on the result of classifying a name as an overload set.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
OptionalFileEntryRef getFileEntryRefForID(FileID FID) const
Returns the FileEntryRef for the provided FileID.
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
SourceLocation getIncludeLoc(FileID FID) const
Returns the include location if FID is a #include'd file otherwise it returns an invalid location.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
StringRef getFilename(SourceLocation SpellingLoc) const
Return the filename of the file containing a SourceLocation.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getStrTokenLoc(unsigned TokNum) const
Get one of the string literal token.
StringRef getString() const
Represents the declaration of a struct/union/class/enum.
static TagDecl * castFromDeclContext(const DeclContext *DC)
bool isBeingDefined() const
Return true if this decl is currently being defined.
bool isThisDeclarationADefinition() const
Return true if this declaration is a completion definition of the type.
SourceLocation getInnerLocStart() const
Return SourceLocation representing start of source range ignoring outer template declarations.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
TypedefNameDecl * getTypedefNameForAnonDecl() const
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?
void setFreeStanding(bool isFreeStanding=true)
True if this tag is free standing, e.g. "struct foo;".
TagKind getTagKind() const
void setBraceRange(SourceRange R)
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
bool canKeyFunctionBeInline() const
Can an out-of-line inline function serve as a key function?
Exposes information about the current target.
virtual bool validateCpuIs(StringRef Name) const
unsigned getShortWidth() const
Return the size of 'signed short' and 'unsigned short' for this target, in bits.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
virtual bool allowDebugInfoForExternalRef() const
Whether target allows debuginfo types for decl only variables/functions.
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...
bool isTLSSupported() const
Whether the target supports thread-local storage.
unsigned getMaxTLSAlign() const
Return the maximum alignment (in bits) of a TLS variable.
virtual bool validateCpuSupports(StringRef Name) const
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool isValidFeatureName(StringRef Feature) const
Determine whether this TargetInfo supports the given feature.
unsigned getCharWidth() const
virtual ParsedTargetAttr parseTargetAttr(StringRef Str) const
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
bool supportsMultiVersioning() const
Identify whether this target supports multiversioning of functions, which requires support for cpu_su...
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
virtual bool isValidGCCRegisterName(StringRef Name) const
Returns whether the passed in string is a valid register name according to GCC.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Location wrapper for a TemplateArgument.
The base class of all kinds of template declarations (e.g., class, function, etc.).
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
Stores a list of template parameters for a TemplateDecl and its derived classes.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation getRAngleLoc() const
SourceLocation getTemplateLoc() const
Represents a type template specialization; the template must be a class template, a type alias templa...
static bool anyInstantiationDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args)
Token - This structure provides full information about a lexed token.
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
bool isNot(tok::TokenKind K) const
A declaration that models statements at global scope.
static TopLevelStmtDecl * Create(ASTContext &C, Stmt *Statement)
Represents a declaration of a type.
void setTypeForDecl(const Type *TD)
const Type * getTypeForDecl() const
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.
SourceLocation getTemplateKeywordLoc() const
Get the SourceLocation of the template keyword (if any).
SourceLocation getEndLoc() const
Get the end source location.
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
static StringRef getTagTypeKindName(TagTypeKind Kind)
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
The base class of the type hierarchy.
bool isSizelessType() const
As an extension, we classify types as one of "sized" or "sizeless"; every type is one or the other.
bool isStructureType() const
bool isDecltypeType() const
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isDependentSizedArrayType() const
bool isBlockPointerType() const
bool isBooleanType() const
bool isFunctionReferenceType() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
bool isIncompleteArrayType() const
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
bool isDependentAddressSpaceType() const
bool isConstantArrayType() const
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool isVoidPointerType() const
bool isFunctionPointerType() const
bool isPointerType() const
bool isSVESizelessBuiltinType() const
Returns true for SVE scalable vector types.
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isScalarType() const
bool isVariableArrayType() const
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isBitIntType() const
bool isOpenCLSpecificType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type.
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
const RecordType * getAsStructureType() const
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
bool containsErrors() const
Whether this type is an error type.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isAtomicType() const
bool isFunctionProtoType() const
bool isObjCIdType() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
const T * getAsAdjusted() const
Member-template getAsAdjusted<specific type>.
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isMemberFunctionPointerType() const
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
bool isFloatingType() const
bool isAnyPointerType() const
TypeClass getTypeClass() const
bool hasAutoForTrailingReturnType() const
Determine whether this type was written with a leading 'auto' corresponding to a trailing return type...
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isNullPtrType() const
bool isRecordType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
bool isFunctionNoProtoType() const
bool isReserveIDT() const
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
bool isSizelessVectorType() const
Returns true for all scalable vector types.
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
Base class for declarations which introduce a typedef-name.
TypeSourceInfo * getTypeSourceInfo() const
void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy)
QualType getUnderlyingType() const
void setTypeSourceInfo(TypeSourceInfo *newType)
TagDecl * getAnonDeclWithTypedefName(bool AnyRedecl=false) const
Retrieves the tag declaration for which this is the typedef name for linkage purposes,...
TypedefNameDecl * getDecl() const
Simple class containing the result of Sema::CorrectTypo.
IdentifierInfo * getCorrectionAsIdentifierInfo() const
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
SmallVectorImpl< NamedDecl * >::const_iterator const_decl_iterator
DeclarationName getCorrection() const
Gets the DeclarationName of the typo correction.
unsigned getEditDistance(bool Normalized=true) const
Gets the "edit distance" of the typo correction from the typo.
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
SmallVectorImpl< NamedDecl * >::iterator decl_iterator
void setCorrectionDecl(NamedDecl *CDecl)
Clears the list of NamedDecls before adding the new one.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Expr * getSubExpr() const
static bool isIncrementDecrementOp(Opcode Op)
Represents a C++ unqualified-id that has been parsed.
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent)
The iterator over UnresolvedSets.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
BaseUsingDecl * getIntroducer() const
Gets the (written or instantiated) using declaration that introduced this declaration.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Represents a variable declaration or definition.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
void setCXXForRangeDecl(bool FRD)
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
TLSKind getTLSKind() const
void setInitStyle(InitializationStyle Style)
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member.
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
bool isCXXCondDecl() const
@ ListInit
Direct list-initialization (C++11)
@ ParenListInit
Parenthesized list-initialization (C++20)
@ CallInit
Call-style initialization (C++98)
void setStorageClass(StorageClass SC)
void setPreviousDeclInSameBlockScope(bool Same)
bool isStaticDataMember() const
Determines whether this is a static data member.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
bool mightBeUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value might be usable in a constant expression, according to the re...
void setInlineSpecified()
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
bool isFileVarDecl() const
Returns true for file scoped variable declaration.
void setTSCSpec(ThreadStorageClassSpecifier TSC)
bool checkForConstantInitialization(SmallVectorImpl< PartialDiagnosticAt > &Notes) const
Evaluate the initializer of this variable to determine whether it's a constant initializer.
bool isInline() const
Whether this variable is (C++1z) inline.
ThreadStorageClassSpecifier getTSCSpec() const
const Expr * getInit() const
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
VarDecl * getInitializingDeclaration()
Get the initializing declaration of this variable, if any.
void setConstexpr(bool IC)
@ TLS_Static
TLS with a known-constant initializer.
@ TLS_Dynamic
TLS with a dynamic initializer.
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
@ TentativeDefinition
This declaration is a tentative definition.
@ DeclarationOnly
This declaration is only a declaration.
@ Definition
This declaration is definitely a definition.
void setDescribedVarTemplate(VarTemplateDecl *Template)
bool isExternC() const
Determines whether this variable is a variable with external, C linkage.
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
void setImplicitlyInline()
bool isThisDeclarationADemotedDefinition() const
If this definition should pretend to be a declaration.
bool isPreviousDeclInSameBlockScope() const
Whether this local extern variable declaration's previous declaration was declared in the same block ...
bool hasDependentAlignment() const
Determines if this variable's alignment is dependent.
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
void demoteThisDefinitionToDeclaration()
This is a definition which should be demoted to a declaration.
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
Declaration of a variable template.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
VarTemplateDecl * getInstantiatedFromMemberTemplate() const
static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)
Create a variable template node.
Represents a C array with a specified size that is not an integer-constant-expression.
Expr * getSizeExpr() const
Captures information about a #pragma weak directive.
void disableCheckFallThrough()
Policy getDefaultPolicy()
ValueDecl * getVariable() const
bool isVariableCapture() const
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
void addVLATypeCapture(SourceLocation Loc, const VariableArrayType *VLAType, QualType CaptureType)
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
SmallVector< Capture, 4 > Captures
Captures - The captures.
ImplicitCaptureStyle ImpCaptureStyle
bool isCXXThisCaptured() const
Determine whether the C++ 'this' is captured.
void addThisCapture(bool isNested, SourceLocation Loc, QualType CaptureType, bool ByCopy)
void addCapture(ValueDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
Retains information about a function, method, or block that is currently being parsed.
bool UsesFPIntrin
Whether this function uses constrained floating point intrinsics.
void addByrefBlockVar(VarDecl *VD)
bool NeedsScopeChecking() const
bool ObjCShouldCallSuper
A flag that is set when parsing a method that must call super's implementation, such as -dealloc,...
bool ObjCWarnForNoInitDelegation
This starts true for a secondary initializer method and will be set to false if there is an invocatio...
bool HasPotentialAvailabilityViolations
Whether we make reference to a declaration that could be unavailable.
bool ObjCWarnForNoDesignatedInitChain
This starts true for a method marked as designated initializer and will be set to false if there is a...
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
ParmVarDecl * ExplicitObjectParameter
llvm::SmallVector< ShadowedOuterDecl, 4 > ShadowingDecls
CXXRecordDecl * Lambda
The class that describes the lambda.
bool AfterParameterList
Indicate that we parsed the parameter list at which point the mutability of the lambda is known.
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
bool Mutable
Whether this is a mutable lambda.
Provides information about an attempted template argument deduction, whose success or failure was des...
Defines the clang::TargetInfo interface.
bool evaluateRequiredTargetFeatures(llvm::StringRef RequiredFatures, const llvm::StringMap< bool > &TargetFetureMap)
Returns true if the required target features of a builtin function are enabled.
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
bool randomizeStructureLayout(const ASTContext &Context, RecordDecl *RD, llvm::SmallVectorImpl< Decl * > &FinalOrdering)
ObjCKeywordKind
Provides a namespace for Objective-C keywords which start with an '@'.
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.
@ EST_None
no exception specification
@ EST_BasicNoexcept
noexcept
Visibility
Describes the different kinds of visibility that a declaration may have.
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.
enum clang::DeclaratorChunk::@221 Kind
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
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.
unsigned AArch64SMEAttributes
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.