50#include "llvm/ADT/SmallString.h"
51#include "llvm/ADT/StringExtras.h"
52#include "llvm/TargetParser/Triple.h"
57#include <unordered_map>
64 Decl *Group[2] = { OwnedType, Ptr };
75 TypeNameValidatorCCC(
bool AllowInvalid,
bool WantClass =
false,
76 bool AllowTemplates =
false,
77 bool AllowNonTemplates =
true)
78 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
79 AllowTemplates(AllowTemplates), AllowNonTemplates(AllowNonTemplates) {
80 WantExpressionKeywords =
false;
81 WantCXXNamedCasts =
false;
82 WantRemainingKeywords =
false;
87 if (!AllowInvalidDecl && ND->isInvalidDecl())
91 return AllowTemplates;
93 bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
97 if (AllowNonTemplates)
102 if (AllowTemplates) {
103 auto *RD = dyn_cast<CXXRecordDecl>(ND);
104 if (!RD || !RD->isInjectedClassName())
106 RD = cast<CXXRecordDecl>(RD->getDeclContext());
107 return RD->getDescribedClassTemplate() ||
108 isa<ClassTemplateSpecializationDecl>(RD);
114 return !WantClassName && candidate.
isKeyword();
117 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
118 return std::make_unique<TypeNameValidatorCCC>(*
this);
122 bool AllowInvalidDecl;
125 bool AllowNonTemplates;
131enum class UnqualifiedTypeNameLookupResult {
142static UnqualifiedTypeNameLookupResult
147 return UnqualifiedTypeNameLookupResult::NotFound;
149 UnqualifiedTypeNameLookupResult FoundTypeDecl =
150 UnqualifiedTypeNameLookupResult::NotFound;
153 if (
auto *BaseTT =
Base.getType()->getAs<
TagType>())
154 BaseRD = BaseTT->getAsCXXRecordDecl();
158 if (!TST || !TST->isDependentType())
160 auto *TD = TST->getTemplateName().getAsTemplateDecl();
163 if (
auto *BasePrimaryTemplate =
164 dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) {
166 BaseRD = BasePrimaryTemplate;
167 else if (
auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
169 CTD->findPartialSpecialization(
Base.getType()))
177 if (!isa<TypeDecl>(ND))
178 return UnqualifiedTypeNameLookupResult::FoundNonType;
179 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
181 if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
183 case UnqualifiedTypeNameLookupResult::FoundNonType:
184 return UnqualifiedTypeNameLookupResult::FoundNonType;
185 case UnqualifiedTypeNameLookupResult::FoundType:
186 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
188 case UnqualifiedTypeNameLookupResult::NotFound:
195 return FoundTypeDecl;
203 UnqualifiedTypeNameLookupResult FoundTypeDecl =
204 UnqualifiedTypeNameLookupResult::NotFound;
206 DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
210 RD = dyn_cast<CXXRecordDecl>(DC);
214 if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
220 S.
Diag(NameLoc, diag::ext_found_in_dependent_base) << &II;
242 bool WantNontrivialTypeSourceInfo =
true) {
244 case Type::DeducedTemplateSpecialization:
246 case Type::InjectedClassName:
249 case Type::UnresolvedUsing:
254 case Type::ObjCInterface:
255 case Type::ObjCTypeParam:
256 case Type::TemplateTypeParm:
259 llvm_unreachable(
"Unexpected Type Class");
267 if (!WantNontrivialTypeSourceInfo)
271 Builder.pushTypeSpec(T).setNameLoc(NameLoc);
288 bool HasTrailingDot,
ParsedType ObjectTypePtr,
289 bool IsCtorOrDtorName,
290 bool WantNontrivialTypeSourceInfo,
291 bool IsClassTemplateDeductionContext,
295 bool AllowDeducedTemplate = IsClassTemplateDeductionContext &&
297 !isClassName && !HasTrailingDot;
322 !isClassName && !IsCtorOrDtorName)
324 bool IsImplicitTypename = !isClassName && !IsCtorOrDtorName;
325 if (IsImplicitTypename) {
328 Diag(QualifiedLoc, diag::warn_cxx17_compat_implicit_typename);
330 Diag(QualifiedLoc, diag::ext_implicit_typename)
337 if (WantNontrivialTypeSourceInfo)
370 if (ObjectTypePtr &&
Result.empty()) {
394 switch (
Result.getResultKind()) {
397 TypeNameValidatorCCC CCC(
true, isClassName,
398 AllowDeducedTemplate);
403 bool MemberOfUnknownSpecialization;
412 if (Correction && (NNS || NewII != &II) &&
418 Template, MemberOfUnknownSpecialization))) {
420 isClassName, HasTrailingDot, ObjectTypePtr,
422 WantNontrivialTypeSourceInfo,
423 IsClassTemplateDeductionContext);
426 PDiag(diag::err_unknown_type_or_class_name_suggest)
427 <<
Result.getLookupName() << isClassName);
430 *CorrectedII = NewII;
435 Result.suppressDiagnostics();
451 Result.suppressDiagnostics();
461 Result.suppressDiagnostics();
467 Res != ResEnd; ++Res) {
469 if (isa<TypeDecl, ObjCInterfaceDecl, UnresolvedUsingIfExistsDecl>(
476 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*Res);
488 Result.suppressDiagnostics();
499 IIDecl =
Result.getFoundDecl();
500 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*
Result.begin());
504 assert(IIDecl &&
"Didn't find decl");
507 if (
TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
511 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
512 auto *FoundRD = dyn_cast<CXXRecordDecl>(TD);
513 if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD &&
514 FoundRD->isInjectedClassName() &&
516 Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor)
527 FoundUsingShadow =
nullptr;
528 }
else if (
auto *UD = dyn_cast<UnresolvedUsingIfExistsDecl>(IIDecl)) {
532 }
else if (AllowDeducedTemplate) {
534 assert(!FoundUsingShadow || FoundUsingShadow->
getTargetDecl() == TD);
540 FoundUsingShadow =
nullptr;
546 Result.suppressDiagnostics();
550 if (FoundUsingShadow)
553 return buildNamedType(*
this, SS, T, NameLoc, WantNontrivialTypeSourceInfo);
561 auto *ND = dyn_cast<NamespaceDecl>(DC);
562 if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
564 else if (
auto *RD = dyn_cast<CXXRecordDecl>(DC))
566 RD->getTypeForDecl());
567 else if (isa<TranslationUnitDecl>(DC))
570 llvm_unreachable(
"something isn't in TU scope?");
581 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
582 if (MD->getParent()->hasAnyDependentBases())
590 bool IsTemplateTypeArg) {
591 assert(
getLangOpts().MSVCCompat &&
"shouldn't be called in non-MSVC mode");
594 if (IsTemplateTypeArg &&
getCurScope()->isTemplateParamScope()) {
603 Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
609 RD->getTypeForDecl());
613 Diag(NameLoc, diag::ext_undeclared_unqual_id_with_dependent_base) << &II
649 switch (TD->getTagKind()) {
691 return S->isFunctionPrototypeScope();
701 bool IsTemplateName) {
706 SuggestedType =
nullptr;
710 TypeNameValidatorCCC CCC(
false,
false,
717 bool CanRecover = !IsTemplateName;
718 if (Corrected.isKeyword()) {
721 PDiag(IsTemplateName ? diag::err_no_template_suggest
722 : diag::err_unknown_typename_suggest)
724 II = Corrected.getCorrectionAsIdentifierInfo();
727 if (!SS || !SS->
isSet()) {
729 PDiag(IsTemplateName ? diag::err_no_template_suggest
730 : diag::err_unknown_typename_suggest)
733 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
734 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
735 II->
getName().equals(CorrectedStr);
738 ? diag::err_no_member_template_suggest
739 : diag::err_unknown_nested_typename_suggest)
740 << II << DC << DroppedSpecifier << SS->
getRange(),
743 llvm_unreachable(
"could not have corrected a typo here");
750 if (Corrected.getCorrectionSpecifier())
755 getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), IILoc, S,
756 tmpSS.
isSet() ? &tmpSS : SS,
false,
false,
nullptr,
766 Name.setIdentifier(II, IILoc);
769 bool MemberOfUnknownSpecialization;
771 Name,
nullptr,
true, TemplateResult,
782 Diag(IILoc, IsTemplateName ? diag::err_no_template
783 : diag::err_unknown_typename)
786 Diag(IILoc, IsTemplateName ? diag::err_no_member_template
787 : diag::err_typename_nested_not_found)
793 unsigned DiagID = diag::err_typename_missing;
795 DiagID = diag::ext_typename_missing;
802 *SS, *II, IILoc).
get();
805 "Invalid scope specifier has already been diagnosed");
813 NextToken.
is(tok::less);
816 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
819 if (CheckTemplate && isa<TemplateDecl>(*I))
833 StringRef FixItTagName;
834 switch (Tag->getTagKind()) {
836 FixItTagName =
"class ";
840 FixItTagName =
"enum ";
844 FixItTagName =
"struct ";
848 FixItTagName =
"__interface ";
852 FixItTagName =
"union ";
856 StringRef TagName = FixItTagName.drop_back();
857 SemaRef.
Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
858 << Name << TagName << SemaRef.
getLangOpts().CPlusPlus
863 SemaRef.
Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
878 const Token &NextToken,
883 assert(NextToken.
isNot(tok::coloncolon) &&
884 "parse nested name specifiers before calling ClassifyName");
924 bool SecondTry =
false;
925 bool IsFilteredTemplateName =
false;
928 switch (
Result.getResultKind()) {
932 if (SS.
isEmpty() && NextToken.
is(tok::l_paren)) {
978 if (!SecondTry && CCC) {
983 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
984 unsigned QualifiedDiag = diag::err_no_member_suggest;
987 NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl();
989 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
990 UnqualifiedDiag = diag::err_no_template_suggest;
991 QualifiedDiag = diag::err_no_member_template_suggest;
992 }
else if (UnderlyingFirstDecl &&
993 (isa<TypeDecl>(UnderlyingFirstDecl) ||
994 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
995 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
996 UnqualifiedDiag = diag::err_unknown_typename_suggest;
997 QualifiedDiag = diag::err_unknown_nested_typename_suggest;
1003 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
1004 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
1005 Name->getName().equals(CorrectedStr);
1008 << DroppedSpecifier << SS.
getRange());
1012 Name = Corrected.getCorrectionAsIdentifierInfo();
1015 if (Corrected.isKeyword())
1021 Result.setLookupName(Corrected.getCorrection());
1043 Result.suppressDiagnostics();
1085 if (!
Result.isAmbiguous()) {
1086 IsFilteredTemplateName =
true;
1096 (IsFilteredTemplateName ||
1112 if (!IsFilteredTemplateName)
1115 bool IsFunctionTemplate;
1119 IsFunctionTemplate =
true;
1122 }
else if (!
Result.empty()) {
1126 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
1127 IsVarTemplate = isa<VarTemplateDecl>(TD);
1130 dyn_cast<UsingShadowDecl>(*
Result.begin());
1131 assert(!FoundUsingShadow ||
1132 TD == cast<TemplateDecl>(FoundUsingShadow->
getTargetDecl()));
1142 IsFunctionTemplate =
true;
1146 if (IsFunctionTemplate) {
1150 Result.suppressDiagnostics();
1161 if (
const auto *USD = dyn_cast<UsingShadowDecl>(Found))
1177 dyn_cast<ObjCCompatibleAliasDecl>(
FirstDecl))
1178 Class = Alias->getClassInterface();
1184 if (NextToken.
is(tok::period)) {
1187 Result.suppressDiagnostics();
1197 if (
auto *USD = dyn_cast<UsingShadowDecl>(
Result.getRepresentativeDecl()))
1203 if (
auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(
FirstDecl)) {
1216 bool NextIsOp = NextToken.
isOneOf(tok::amp, tok::star);
1217 if ((NextToken.
is(tok::identifier) ||
1219 FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
1231 if (
Result.isSingleResult() && !ADL &&
1236 Result.suppressDiagnostics();
1239 Result.getLookupNameInfo(), ADL,
Result.isOverloadedResult(),
1256 bool IsAddressOfOperand) {
1259 NameInfo, IsAddressOfOperand,
1266 const Token &NextToken) {
1283 auto *ULE = cast<UnresolvedLookupExpr>(E);
1284 if ((*ULE->decls_begin())->isCXXClassMember()) {
1286 SS.
Adopt(ULE->getQualifierLoc());
1291 Result.setNamingClass(ULE->getNamingClass());
1292 for (
auto I = ULE->decls_begin(), E = ULE->decls_end(); I != E; ++I)
1293 Result.addDecl(*I, I.getAccess());
1306 auto *TD = Name.getAsTemplateDecl();
1309 if (isa<ClassTemplateDecl>(TD))
1311 if (isa<FunctionTemplateDecl>(TD))
1313 if (isa<VarTemplateDecl>(TD))
1315 if (isa<TypeAliasTemplateDecl>(TD))
1317 if (isa<TemplateTemplateParmDecl>(TD))
1319 if (isa<ConceptDecl>(TD))
1326 "The next DeclContext should be lexically contained in the current one.");
1332 assert(
CurContext &&
"DeclContext imbalance!");
1335 assert(
CurContext &&
"Popped translation unit!");
1344 CurContext = cast<TagDecl>(D)->getDefinition();
1345 assert(
CurContext &&
"skipping definition of undefined tag");
1376 assert(!S->getEntity() &&
"scope already has entity");
1379 Scope *Ancestor = S->getParent();
1387 if (S->getParent()->isTemplateParamScope()) {
1395 assert(S->getEntity() ==
CurContext &&
"Context imbalance!");
1399 Scope *Ancestor = S->getParent();
1408 assert(S->isTemplateParamScope() &&
1409 "expected to be initializing a template parameter scope");
1433 for (; S && S->isTemplateParamScope(); S = S->getParent(), --ScopeDepth) {
1437 cast<Decl>(DC)->getDescribedTemplateParams()) {
1438 unsigned DCDepth = TPL->getDepth() + 1;
1439 if (DCDepth > ScopeDepth)
1441 if (ScopeDepth == DCDepth)
1446 S->setLookupEntity(SearchDCAfterScope);
1460 "The next DeclContext should be lexically contained in the current one.");
1464 for (
unsigned P = 0, NumParams = FD->
getNumParams();
P < NumParams; ++
P) {
1477 assert(
CurContext &&
"DeclContext imbalance!");
1479 assert(
CurContext &&
"Popped translation unit!");
1508 return ND->
hasAttr<OverloadableAttr>();
1511 return Previous.getFoundDecl()->hasAttr<OverloadableAttr>();
1521 while (S->getEntity() && S->getEntity()->isTransparentContext())
1536 if (isa<FunctionDecl>(D) &&
1537 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
1543 for (; I != IEnd; ++I) {
1555 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1562 if (!S->isDeclScope(*I))
1576 bool AllowInlineNamespace)
const {
1584 if (ScopeDC->getPrimaryContext() == TargetDC)
1586 }
while ((S = S->getParent()));
1598 bool ConsiderLinkage,
1599 bool AllowInlineNamespace) {
1660 if (NewIsModuleInterface || OldIsModuleInterface) {
1666 << NewIsModuleInterface
1668 << OldIsModuleInterface
1699 if (!IsNewExported && !IsOldExported)
1705 assert(IsNewExported);
1713 Diag(New->
getLocation(), diag::err_redeclaration_non_exported) << New << S;
1749 "New and Old are not the same definition, we should diagnostic it "
1750 "immediately instead of checking it.");
1753 "We shouldn't see unreachable definitions here.");
1801 return OldM == NewM;
1808 return isa<UsingShadowDecl>(D) ||
1809 isa<UnresolvedUsingTypenameDecl>(D) ||
1810 isa<UnresolvedUsingValueDecl>(D);
1838 return CD->isCopyConstructor();
1857 if (
const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1858 if (!RD->hasNameForLinkage())
1887 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1893 FD->getMemberSpecializationInfo() && !FD->isOutOfLine())
1896 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1901 if (FD->isInlined() && !
isMainFileLoc(*
this, FD->getLocation()))
1905 if (FD->doesThisDeclarationHaveABody() &&
1908 }
else if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1918 if (VD->isStaticDataMember() &&
1921 if (VD->isStaticDataMember() &&
1923 VD->getMemberSpecializationInfo() && !VD->isOutOfLine())
1926 if (VD->isInline() && !
isMainFileLoc(*
this, VD->getLocation()))
1935 return mightHaveNonExternalLinkage(D);
1942 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1948 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1963 if (
const auto *DD = dyn_cast<DecompositionDecl>(D)) {
1967 bool IsAllPlaceholders =
true;
1968 for (
const auto *BD : DD->bindings()) {
1969 if (BD->isReferenced())
1971 IsAllPlaceholders = IsAllPlaceholders && BD->isPlaceholderVar(LangOpts);
1973 if (IsAllPlaceholders)
1984 if (D->
hasAttr<UnusedAttr>() || D->
hasAttr<ObjCPreciseLifetimeAttr>() ||
1988 if (isa<LabelDecl>(D))
1994 if (
const auto *R = dyn_cast<CXXRecordDecl>(D->
getDeclContext()))
1997 WithinFunction || (R->isLocalClass() && !R->isDependentType());
1998 if (!WithinFunction)
2001 if (isa<TypedefNameDecl>(D))
2005 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
2009 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2012 if (
const auto *Cleanups = dyn_cast_if_present<ExprWithCleanups>(
Init))
2013 Init = Cleanups->getSubExpr();
2015 const auto *Ty = VD->getType().getTypePtr();
2020 if (TT->getDecl()->hasAttr<UnusedAttr>())
2026 if (
const auto *MTE = dyn_cast_if_present<MaterializeTemporaryExpr>(
Init);
2027 MTE && MTE->getExtendingDecl()) {
2028 Ty = VD->getType().getNonReferenceType().getTypePtr();
2029 Init = MTE->getSubExpr()->IgnoreImplicitAsWritten();
2034 if (Ty->isIncompleteType() || Ty->isDependentType())
2039 Ty = Ty->getBaseElementTypeUnsafe();
2042 const TagDecl *Tag = TT->getDecl();
2043 if (Tag->
hasAttr<UnusedAttr>())
2046 if (
const auto *RD = dyn_cast<CXXRecordDecl>(Tag)) {
2047 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
2051 const auto *Construct =
2052 dyn_cast<CXXConstructExpr>(
Init->IgnoreImpCasts());
2053 if (Construct && !Construct->isElidable()) {
2055 if (!CD->
isTrivial() && !RD->hasAttr<WarnUnusedAttr>() &&
2056 (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
2062 if (
Init->isTypeDependent()) {
2064 if (!Ctor->isTrivial())
2070 if (isa<CXXUnresolvedConstructExpr>(
Init))
2084 if (isa<LabelDecl>(D)) {
2105 for (
auto *TmpD : D->
decls()) {
2106 if (
const auto *T = dyn_cast<TypedefNameDecl>(TmpD))
2108 else if(
const auto *R = dyn_cast<RecordDecl>(TmpD))
2124 if (
auto *TD = dyn_cast<TypedefNameDecl>(D)) {
2135 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
2136 DiagID = diag::warn_unused_exception_param;
2137 else if (isa<LabelDecl>(D))
2138 DiagID = diag::warn_unused_label;
2140 DiagID = diag::warn_unused_variable;
2159 if (Ty->isReferenceType() || Ty->isDependentType())
2163 const TagDecl *Tag = TT->getDecl();
2164 if (Tag->
hasAttr<UnusedAttr>())
2168 if (
const auto *RD = dyn_cast<CXXRecordDecl>(Tag);
2169 RD && !RD->hasAttr<WarnUnusedAttr>())
2176 if (VD->
hasAttr<BlocksAttr>() && Ty->isObjCObjectPointerType())
2182 if (VD->
hasAttr<ObjCPreciseLifetimeAttr>() && Ty->isObjCObjectPointerType())
2189 assert(iter->getSecond() >= 0 &&
2190 "Found a negative number of references to a VarDecl");
2191 if (iter->getSecond() != 0)
2193 unsigned DiagID = isa<ParmVarDecl>(VD) ? diag::warn_unused_but_set_parameter
2194 : diag::warn_unused_but_set_variable;
2204 bool Diagnose =
false;
2208 Diagnose = L->
getStmt() ==
nullptr;
2217 if (S->decl_empty())
return;
2219 "Scope shouldn't contain decls!");
2226 std::optional<SourceLocation> PreviousDeclLoc;
2231 DeclDiags.push_back(LocAndDiag{Loc, std::nullopt, std::move(PD)});
2236 DeclDiags.push_back(LocAndDiag{Loc, PreviousDeclLoc, std::move(PD)});
2239 for (
auto *TmpD : S->decls()) {
2240 assert(TmpD &&
"This decl didn't get pushed??");
2242 assert(isa<NamedDecl>(TmpD) &&
"Decl isn't NamedDecl?");
2246 if (!S->hasUnrecoverableErrorOccurred()) {
2248 if (
const auto *RD = dyn_cast<RecordDecl>(D))
2250 if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
2259 if (
LabelDecl *LD = dyn_cast<LabelDecl>(D))
2265 auto ShadowI = ShadowingDecls.find(D);
2266 if (ShadowI != ShadowingDecls.end()) {
2267 if (
const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
2268 addDiagWithPrev(D->
getLocation(), FD->getLocation(),
2269 PDiag(diag::warn_ctor_parm_shadows_field)
2270 << D << FD << FD->getParent());
2272 ShadowingDecls.erase(ShadowI);
2276 if (
auto *FD = dyn_cast<FieldDecl>(TmpD);
2277 FD && FD->hasAttr<CountedByAttr>())
2282 llvm::sort(DeclDiags,
2283 [](
const LocAndDiag &LHS,
const LocAndDiag &RHS) ->
bool {
2288 return LHS.Loc.getRawEncoding() < RHS.Loc.getRawEncoding();
2290 for (
const LocAndDiag &D : DeclDiags) {
2292 if (D.PreviousDeclLoc)
2293 Diag(*D.PreviousDeclLoc, diag::note_previous_declaration);
2312 bool DoTypoCorrection) {
2317 if (!IDecl && DoTypoCorrection) {
2361 (S->getEntity() && S->getEntity()->isTransparentContext()) ||
2379 return "ucontext.h";
2381 llvm_unreachable(
"unhandled error kind");
2392 Parent->addDecl(CLinkageDecl);
2407 for (
unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2410 FT->getParamType(i),
nullptr,
SC_None,
nullptr);
2412 Params.push_back(parm);
2414 New->setParams(Params);
2426 Scope *S,
bool ForRedeclaration,
2433 if (!ForRedeclaration)
2445 Diag(Loc, diag::warn_implicit_decl_no_jmp_buf)
2452 Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
2458 if (!ForRedeclaration &&
2461 Diag(Loc,
LangOpts.C99 ? diag::ext_implicit_lib_function_decl_c99
2462 : diag::ext_implicit_lib_function_decl)
2465 Diag(Loc, diag::note_include_header_or_declare)
2502 while (Filter.hasNext()) {
2511 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2513 Decl->getUnderlyingType()))
2518 if (OldTD->getAnonDeclWithTypedefName(
true) &&
2519 Decl->getAnonDeclWithTypedefName())
2532 OldType = OldTypedef->getUnderlyingType();
2539 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2540 Diag(New->
getLocation(), diag::err_redefinition_variably_modified_typedef)
2548 if (OldType != NewType &&
2552 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2554 << Kind << NewType << OldType;
2578 switch (TypeID->getLength()) {
2582 if (!TypeID->isStr(
"id"))
2598 if (!TypeID->isStr(
"Class"))
2605 if (!TypeID->isStr(
"SEL"))
2632 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2633 auto *OldTag = OldTD->getAnonDeclWithTypedefName(
true);
2636 if (OldTag && NewTag &&
2637 OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
2642 if (OldTD->isModed())
2644 OldTD->getUnderlyingType());
2653 if (isa<EnumDecl>(NewTag)) {
2655 for (
auto *D : NewTag->decls()) {
2656 auto *ED = cast<EnumConstantDecl>(D);
2660 ED->getLexicalDeclContext()->removeDecl(ED);
2710 if (!isa<TypedefNameDecl>(Old))
2742 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
2743 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
2744 for (
const auto *i : D->
attrs())
2745 if (i->getKind() == A->
getKind()) {
2747 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
2752 if (OA && isa<OwnershipAttr>(i))
2753 return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
2761 if (
VarDecl *VD = dyn_cast<VarDecl>(D))
2762 return VD->isThisDeclarationADefinition();
2763 if (
TagDecl *TD = dyn_cast<TagDecl>(D))
2764 return TD->isCompleteDefinition() || TD->isBeingDefined();
2775 AlignedAttr *OldAlignasAttr =
nullptr;
2776 AlignedAttr *OldStrictestAlignAttr =
nullptr;
2777 unsigned OldAlign = 0;
2785 if (I->isAlignmentDependent())
2791 unsigned Align = I->getAlignment(S.
Context);
2792 if (Align > OldAlign) {
2794 OldStrictestAlignAttr = I;
2799 AlignedAttr *NewAlignasAttr =
nullptr;
2800 unsigned NewAlign = 0;
2802 if (I->isAlignmentDependent())
2808 unsigned Align = I->getAlignment(S.
Context);
2809 if (Align > NewAlign)
2813 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2821 if (OldAlign == 0 || NewAlign == 0) {
2823 if (
ValueDecl *VD = dyn_cast<ValueDecl>(New))
2834 if (OldAlign != NewAlign) {
2835 S.
Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2838 S.
Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2853 S.
Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2857 bool AnyAdded =
false;
2860 if (OldAlign > NewAlign) {
2861 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.
Context);
2862 Clone->setInherited(
true);
2868 if (OldAlignasAttr && !NewAlignasAttr &&
2869 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2870 AlignedAttr *Clone = OldAlignasAttr->clone(S.
Context);
2871 Clone->setInherited(
true);
2879#define WANT_DECL_MERGE_LOGIC
2880#include "clang/Sema/AttrParsedAttrImpl.inc"
2881#undef WANT_DECL_MERGE_LOGIC
2888 if (!DiagnoseMutualExclusions(S, D,
Attr))
2899 if (
const auto *AA = dyn_cast<AvailabilityAttr>(
Attr))
2901 D, *AA, AA->getPlatform(), AA->
isImplicit(), AA->getIntroduced(),
2902 AA->getDeprecated(), AA->getObsoleted(), AA->getUnavailable(),
2903 AA->getMessage(), AA->getStrict(), AA->getReplacement(), AMK,
2905 else if (
const auto *VA = dyn_cast<VisibilityAttr>(
Attr))
2907 else if (
const auto *VA = dyn_cast<TypeVisibilityAttr>(
Attr))
2909 else if (
const auto *ImportA = dyn_cast<DLLImportAttr>(
Attr))
2911 else if (
const auto *ExportA = dyn_cast<DLLExportAttr>(
Attr))
2913 else if (
const auto *EA = dyn_cast<ErrorAttr>(
Attr))
2915 else if (
const auto *FA = dyn_cast<FormatAttr>(
Attr))
2916 NewAttr = S.
mergeFormatAttr(D, *FA, FA->getType(), FA->getFormatIdx(),
2918 else if (
const auto *SA = dyn_cast<SectionAttr>(
Attr))
2920 else if (
const auto *CSA = dyn_cast<CodeSegAttr>(
Attr))
2922 else if (
const auto *IA = dyn_cast<MSInheritanceAttr>(
Attr))
2924 IA->getInheritanceModel());
2925 else if (
const auto *AA = dyn_cast<AlwaysInlineAttr>(
Attr))
2928 else if (S.
getLangOpts().CUDA && isa<FunctionDecl>(D) &&
2929 (isa<CUDAHostAttr>(
Attr) || isa<CUDADeviceAttr>(
Attr) ||
2930 isa<CUDAGlobalAttr>(
Attr))) {
2934 }
else if (
const auto *MA = dyn_cast<MinSizeAttr>(
Attr))
2936 else if (
const auto *SNA = dyn_cast<SwiftNameAttr>(
Attr))
2938 else if (
const auto *OA = dyn_cast<OptimizeNoneAttr>(
Attr))
2940 else if (
const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(
Attr))
2942 else if (isa<AlignedAttr>(
Attr))
2946 else if ((isa<DeprecatedAttr>(
Attr) || isa<UnavailableAttr>(
Attr)) &&
2951 else if (
const auto *UA = dyn_cast<UuidAttr>(
Attr))
2952 NewAttr = S.
mergeUuidAttr(D, *UA, UA->getGuid(), UA->getGuidDecl());
2953 else if (
const auto *IMA = dyn_cast<WebAssemblyImportModuleAttr>(
Attr))
2955 else if (
const auto *INA = dyn_cast<WebAssemblyImportNameAttr>(
Attr))
2957 else if (
const auto *TCBA = dyn_cast<EnforceTCBAttr>(
Attr))
2959 else if (
const auto *TCBLA = dyn_cast<EnforceTCBLeafAttr>(
Attr))
2961 else if (
const auto *BTFA = dyn_cast<BTFDeclTagAttr>(
Attr))
2963 else if (
const auto *NT = dyn_cast<HLSLNumThreadsAttr>(
Attr))
2966 else if (
const auto *SA = dyn_cast<HLSLShaderAttr>(
Attr))
2968 else if (isa<SuppressAttr>(
Attr))
2977 if (isa<MSInheritanceAttr>(NewAttr))
2986 if (
const TagDecl *TD = dyn_cast<TagDecl>(D))
2987 return TD->getDefinition();
2988 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2994 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2996 if (FD->isDefined(Def,
true))
3003 for (
const auto *Attribute : D->
attrs())
3004 if (Attribute->getKind() == Kind)
3016 if (!Def || Def == New)
3020 for (
unsigned I = 0, E = NewAttributes.size(); I != E;) {
3021 const Attr *NewAttribute = NewAttributes[I];
3023 if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {
3030 NewAttributes.erase(NewAttributes.begin() + I);
3035 VarDecl *VD = cast<VarDecl>(New);
3036 unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
3038 ? diag::err_alias_after_tentative
3039 : diag::err_redefinition;
3041 if (
Diag == diag::err_redefinition)
3051 if (
const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
3064 if (isa<C11NoReturnAttr>(NewAttribute)) {
3068 }
else if (isa<UuidAttr>(NewAttribute)) {
3072 }
else if (
const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
3073 if (AA->isAlignas()) {
3084 S.
Diag(NewAttribute->
getLocation(), diag::note_alignas_on_declaration)
3086 NewAttributes.erase(NewAttributes.begin() + I);
3090 }
else if (isa<LoaderUninitializedAttr>(NewAttribute)) {
3096 diag::err_loader_uninitialized_redeclaration);
3098 NewAttributes.erase(NewAttributes.begin() + I);
3102 }
else if (isa<SelectAnyAttr>(NewAttribute) &&
3103 cast<VarDecl>(New)->isInline() &&
3104 !cast<VarDecl>(New)->isInlineSpecified()) {
3111 }
else if (isa<OMPDeclareVariantAttr>(NewAttribute)) {
3119 diag::warn_attribute_precede_definition);
3121 NewAttributes.erase(NewAttributes.begin() + I);
3127 const ConstInitAttr *CIAttr,
3128 bool AttrBeforeInit) {
3135 std::string SuitableSpelling;
3137 SuitableSpelling = std::string(
3139 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3141 InsertLoc, {tok::l_square, tok::l_square,
3142 S.PP.getIdentifierInfo(
"clang"), tok::coloncolon,
3143 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3144 tok::r_square, tok::r_square}));
3145 if (SuitableSpelling.empty())
3147 InsertLoc, {tok::kw___attribute, tok::l_paren, tok::r_paren,
3148 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3149 tok::r_paren, tok::r_paren}));
3150 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus20)
3151 SuitableSpelling =
"constinit";
3152 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3153 SuitableSpelling =
"[[clang::require_constant_initialization]]";
3154 if (SuitableSpelling.empty())
3155 SuitableSpelling =
"__attribute__((require_constant_initialization))";
3156 SuitableSpelling +=
" ";
3158 if (AttrBeforeInit) {
3161 assert(CIAttr->isConstinit() &&
"should not diagnose this for attribute");
3164 S.
Diag(CIAttr->getLocation(), diag::note_constinit_specified_here);
3168 S.
Diag(CIAttr->getLocation(),
3169 CIAttr->isConstinit() ? diag::err_constinit_added_too_late
3170 : diag::warn_require_const_init_added_too_late)
3173 << CIAttr->isConstinit()
3182 UsedAttr *NewAttr = OldAttr->clone(
Context);
3183 NewAttr->setInherited(
true);
3187 RetainAttr *NewAttr = OldAttr->clone(
Context);
3188 NewAttr->setInherited(
true);
3198 const auto *OldConstInit = Old->
getAttr<ConstInitAttr>();
3199 const auto *NewConstInit = New->
getAttr<ConstInitAttr>();
3200 if (
bool(OldConstInit) !=
bool(NewConstInit)) {
3201 const auto *OldVD = cast<VarDecl>(Old);
3202 auto *NewVD = cast<VarDecl>(New);
3208 (NewVD->hasInit() || NewVD->isThisDeclarationADefinition()))
3211 if (InitDecl == NewVD) {
3215 if (OldConstInit && OldConstInit->isConstinit())
3218 }
else if (NewConstInit) {
3222 if (InitDecl && InitDecl != NewVD) {
3225 NewVD->dropAttr<ConstInitAttr>();
3233 if (AsmLabelAttr *NewA = New->
getAttr<AsmLabelAttr>()) {
3234 if (AsmLabelAttr *OldA = Old->
getAttr<AsmLabelAttr>()) {
3235 if (!OldA->isEquivalent(NewA)) {
3238 Diag(OldA->getLocation(), diag::note_previous_declaration);
3240 }
else if (Old->
isUsed()) {
3244 << isa<FunctionDecl>(Old) << New->
getAttr<AsmLabelAttr>()->
getRange();
3249 if (
const auto *NewAbiTagAttr = New->
getAttr<AbiTagAttr>()) {
3250 if (
const auto *OldAbiTagAttr = Old->
getAttr<AbiTagAttr>()) {
3251 for (
const auto &NewTag : NewAbiTagAttr->tags()) {
3252 if (!llvm::is_contained(OldAbiTagAttr->tags(), NewTag)) {
3253 Diag(NewAbiTagAttr->getLocation(),
3254 diag::err_new_abi_tag_on_redeclaration)
3256 Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
3260 Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
3266 if (New->
hasAttr<SectionAttr>() && !Old->
hasAttr<SectionAttr>()) {
3267 if (
auto *VD = dyn_cast<VarDecl>(New)) {
3269 Diag(New->
getLocation(), diag::warn_attribute_section_on_redeclaration);
3276 const auto *NewCSA = New->
getAttr<CodeSegAttr>();
3277 if (NewCSA && !Old->
hasAttr<CodeSegAttr>() &&
3278 !NewCSA->isImplicit() && isa<CXXMethodDecl>(New)) {
3296 if (isa<DeprecatedAttr>(I) ||
3297 isa<UnavailableAttr>(I) ||
3298 isa<AvailabilityAttr>(I)) {
3313 if (isa<UsedAttr>(I) || isa<RetainAttr>(I))
3335 const CarriesDependencyAttr *CDA = newDecl->
getAttr<CarriesDependencyAttr>();
3336 if (CDA && !oldDecl->
hasAttr<CarriesDependencyAttr>()) {
3337 S.
Diag(CDA->getLocation(),
3338 diag::err_carries_dependency_missing_on_first_decl) << 1;
3346 diag::note_carries_dependency_missing_first_decl) << 1;
3354 const auto *NDAttr = newDecl->
getAttr<HLSLParamModifierAttr>();
3355 const auto *ODAttr = oldDecl->
getAttr<HLSLParamModifierAttr>();
3360 if (NDAttr && ODAttr &&
3361 NDAttr->getSpellingListIndex() != ODAttr->getSpellingListIndex()) {
3362 S.
Diag(newDecl->
getLocation(), diag::err_hlsl_param_qualifier_mismatch)
3363 << NDAttr << newDecl;
3372 bool foundAny = newDecl->
hasAttrs();
3381 cast<InheritableParamAttr>(I->clone(S.
Context));
3394 auto NoSizeInfo = [&Ctx](
QualType Ty) {
3395 if (Ty->isIncompleteArrayType() || Ty->isPointerType())
3403 if (NoSizeInfo(Old) && NoSizeInfo(New))
3435 if (*Oldnullability != *Newnullability) {
3436 S.
Diag(NewParam->
getLocation(), diag::warn_mismatched_nullability_attr)
3455 const auto *OldParamDT = dyn_cast<DecayedType>(OldParam->
getType());
3456 const auto *NewParamDT = dyn_cast<DecayedType>(NewParam->
getType());
3457 if (OldParamDT && NewParamDT &&
3458 OldParamDT->getPointeeType() == NewParamDT->getPointeeType()) {
3459 QualType OldParamOT = OldParamDT->getOriginalType();
3460 QualType NewParamOT = NewParamDT->getOriginalType();
3463 << NewParam << NewParamOT;
3474struct GNUCompatibleParamWarning {
3484template <
typename T>
3485static std::pair<diag::kind, SourceLocation>
3489 if (Old->isThisDeclarationADefinition())
3490 PrevDiag = diag::note_previous_definition;
3491 else if (Old->isImplicit()) {
3492 PrevDiag = diag::note_previous_implicit_declaration;
3493 if (
const auto *FD = dyn_cast<FunctionDecl>(Old)) {
3494 if (FD->getBuiltinID())
3495 PrevDiag = diag::note_previous_builtin_declaration;
3498 OldLocation = New->getLocation();
3500 PrevDiag = diag::note_previous_declaration;
3501 return std::make_pair(PrevDiag, OldLocation);
3509 return ((FD->
hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
3510 !LangOpts.CPlusPlus &&
3522template <
typename T>
3536template<
typename T>
static bool isExternC(T *D) {
return D->isExternC(); }
3543template<
typename ExpectedDecl>
3565 !Old->getDeclContext()->getRedeclContext()->Equals(
3566 New->getDeclContext()->getRedeclContext()) &&
3571 S.
Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
3584 const auto *AttrA = A->
getAttr<PassObjectSizeAttr>();
3585 const auto *AttrB = B->
getAttr<PassObjectSizeAttr>();
3588 return AttrA && AttrB && AttrA->getType() == AttrB->getType() &&
3589 AttrA->isDynamic() == AttrB->isDynamic();
3615 if (NamedDC->Equals(SemaDC))
3618 assert((NamedDC->InEnclosingNamespaceSetOf(SemaDC) ||
3620 "unexpected context for redeclaration");
3631 if (
auto *FD = dyn_cast<FunctionDecl>(NewD))
3632 FixSemaDC(FD->getDescribedFunctionTemplate());
3633 else if (
auto *VD = dyn_cast<VarDecl>(NewD))
3634 FixSemaDC(VD->getDescribedVarTemplate());
3649 bool MergeTypeWithOld,
bool NewDeclIsDefn) {
3656 Diag(Shadow->getTargetDecl()->getLocation(),
3657 diag::note_using_decl_target);
3658 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
3667 if (checkUsingShadowRedecl<FunctionTemplateDecl>(*
this, Shadow,
3670 OldD = Old = cast<FunctionTemplateDecl>(Shadow->getTargetDecl())
3673 if (checkUsingShadowRedecl<FunctionDecl>(*
this, Shadow, New))
3675 OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
3703 std::tie(PrevDiag, OldLocation) =
3710 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
3717 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3720 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3725 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
3726 if (!Old->
hasAttr<InternalLinkageAttr>()) {
3730 New->
dropAttr<InternalLinkageAttr>();
3733 if (
auto *EA = New->
getAttr<ErrorAttr>()) {
3734 if (!Old->
hasAttr<ErrorAttr>()) {
3735 Diag(EA->getLocation(), diag::err_attribute_missing_on_first_decl) << EA;
3745 bool OldOvl = Old->
hasAttr<OverloadableAttr>();
3756 const Decl *DiagOld = Old;
3758 auto OldIter = llvm::find_if(Old->
redecls(), [](
const Decl *D) {
3759 const auto *A = D->getAttr<OverloadableAttr>();
3760 return A && !A->isImplicit();
3764 DiagOld = OldIter == Old->
redecls_end() ? nullptr : *OldIter;
3769 diag::note_attribute_overloadable_prev_overload)
3784 Diag(OldLocation, diag::note_previous_declaration);
3803 const FunctionType *OldType = cast<FunctionType>(OldQType);
3804 const FunctionType *NewType = cast<FunctionType>(NewQType);
3807 bool RequiresAdjustment =
false;
3809 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC()) {
3815 if (!NewCCExplicit) {
3819 RequiresAdjustment =
true;
3831 RequiresAdjustment =
true;
3838 << (!FirstCCExplicit ?
"" :
3842 Diag(
First->getLocation(), diag::note_previous_declaration);
3850 RequiresAdjustment =
true;
3860 Diag(OldLocation, diag::note_previous_declaration);
3865 RequiresAdjustment =
true;
3872 <<
"'ns_returns_retained'";
3873 Diag(OldLocation, diag::note_previous_declaration);
3878 RequiresAdjustment =
true;
3884 AnyX86NoCallerSavedRegistersAttr *
Attr =
3885 New->
getAttr<AnyX86NoCallerSavedRegistersAttr>();
3887 Diag(OldLocation, diag::note_previous_declaration);
3892 RequiresAdjustment =
true;
3895 if (RequiresAdjustment) {
3905 !New->
hasAttr<GNUInlineAttr>() &&
3914 if (New->
hasAttr<GNUInlineAttr>() &&
3925 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3942 OldDeclaredReturnType)) {
3950 Diag(New->
getLocation(), diag::err_member_def_does_not_match_ret_type)
3955 Diag(OldLocation, PrevDiag) << Old << Old->
getType()
3964 QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
3965 if (OldReturnType != NewReturnType) {
3981 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
3983 if (OldMethod && NewMethod) {
3990 bool IsClassScopeExplicitSpecialization =
3996 !IsClassScopeExplicitSpecialization) {
4002 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4012 if (isa<CXXConstructorDecl>(OldMethod))
4013 NewDiag = diag::err_constructor_redeclared;
4014 else if (isa<CXXDestructorDecl>(NewMethod))
4015 NewDiag = diag::err_destructor_redeclared;
4016 else if (isa<CXXConversionDecl>(NewMethod))
4017 NewDiag = diag::err_conv_function_redeclared;
4019 NewDiag = diag::err_member_redeclared;
4023 Diag(New->
getLocation(), diag::err_member_redeclared_in_instantiation)
4026 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4039 diag::err_definition_of_implicitly_declared_member)
4045 diag::err_definition_of_explicitly_defaulted_member)
4068 if (
const auto *NRA = New->
getAttr<CXX11NoReturnAttr>())
4069 if (!Old->
hasAttr<CXX11NoReturnAttr>()) {
4070 Diag(NRA->getLocation(), diag::err_attribute_missing_on_first_decl)
4079 const CarriesDependencyAttr *CDA = New->
getAttr<CarriesDependencyAttr>();
4080 if (CDA && !Old->
hasAttr<CarriesDependencyAttr>()) {
4081 Diag(CDA->getLocation(),
4082 diag::err_carries_dependency_missing_on_first_decl) << 0;
4084 diag::note_carries_dependency_missing_first_decl) << 0;
4093 QualType OldQTypeForComparison = OldQType;
4098 OldQTypeForComparison =
QualType(OldTypeForComparison, 0);
4113 Diag(OldLocation, PrevDiag);
4115 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4116 Diag(OldLocation, PrevDiag);
4187 bool IsWithoutProtoADef =
false, IsWithProtoADef =
false;
4188 if (WithoutProto == New)
4189 IsWithoutProtoADef = NewDeclIsDefn;
4191 IsWithProtoADef = NewDeclIsDefn;
4193 diag::warn_non_prototype_changes_behavior)
4194 << IsWithoutProtoADef << (WithoutProto->
getNumParams() ? 0 : 1)
4195 << (WithoutProto == Old) << IsWithProtoADef;
4205 !IsWithoutProtoADef)
4215 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
4216 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
4219 assert(!OldProto->hasExceptionSpec() &&
"Exception spec in C");
4221 OldProto->getParamTypes(),
4222 OldProto->getExtProtoInfo());
4228 for (
const auto &ParamType : OldProto->param_types()) {
4231 ParamType,
nullptr,
SC_None,
nullptr);
4234 Params.push_back(Param);
4237 New->setParams(Params);
4273 NewProto->getReturnType());
4274 bool LooseCompatible = !MergedReturn.
isNull();
4276 LooseCompatible && Idx != End; ++Idx) {
4280 NewProto->getParamType(Idx))) {
4281 ArgTypes.push_back(NewParm->
getType());
4285 GNUCompatibleParamWarning Warn = { OldParm, NewParm,
4286 NewProto->getParamType(Idx) };
4287 Warnings.push_back(Warn);
4288 ArgTypes.push_back(NewParm->
getType());
4290 LooseCompatible =
false;
4293 if (LooseCompatible) {
4294 for (
unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
4295 Diag(Warnings[Warn].NewParm->getLocation(),
4296 diag::ext_param_promoted_not_compatible_with_prototype)
4297 << Warnings[Warn].PromotedType
4298 << Warnings[Warn].OldParm->getType();
4299 if (Warnings[Warn].OldParm->getLocation().isValid())
4300 Diag(Warnings[Warn].OldParm->getLocation(),
4301 diag::note_previous_declaration);
4304 if (MergeTypeWithOld)
4324 Diag(OldLocation, diag::note_previous_builtin_declaration)
4329 PrevDiag = diag::note_previous_builtin_declaration;
4333 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4347 Scope *S,
bool MergeTypeWithOld) {
4362 for (
unsigned i = 0, e = New->
getNumParams(); i != e; ++i) {
4376 if (!Merged.isNull() && MergeTypeWithOld)
4399 ni != ne && oi != oe; ++ni, ++oi)
4409 ? diag::err_redefinition_different_type
4410 : diag::err_redeclaration_different_type)
4415 std::tie(PrevDiag, OldLocation)
4417 S.
Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4429 bool MergeTypeWithOld) {
4457 QualType PrevVDTy = PrevVD->getType();
4511 if (MergeTypeWithOld)
4557 if (!shouldLinkPossiblyHiddenDecl(
Previous, New))
4567 OldTemplate = dyn_cast<VarTemplateDecl>(
Previous.getFoundDecl());
4571 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4572 if (checkUsingShadowRedecl<VarTemplateDecl>(*
this, Shadow, NewTemplate))
4575 Old = dyn_cast<VarDecl>(
Previous.getFoundDecl());
4578 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4579 if (checkUsingShadowRedecl<VarDecl>(*
this, Shadow, New))
4616 if (New->
hasAttr<WeakImportAttr>() &&
4618 !Old->
hasAttr<WeakImportAttr>()) {
4625 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
4626 if (!Old->
hasAttr<InternalLinkageAttr>()) {
4630 New->
dropAttr<InternalLinkageAttr>();
4635 if (MostRecent != Old) {
4648 std::tie(PrevDiag, OldLocation) =
4658 Diag(OldLocation, PrevDiag);
4662 Diag(OldLocation, PrevDiag);
4681 Diag(OldLocation, PrevDiag);
4689 Diag(OldLocation, PrevDiag);
4695 Diag(OldLocation, PrevDiag);
4711 Diag(OldLocation, PrevDiag);
4721 Diag(Def->getLocation(), diag::note_previous_definition);
4735 Diag(OldLocation, PrevDiag);
4738 Diag(OldLocation, PrevDiag);
4746 Diag(OldLocation, PrevDiag);
4756 diag::warn_deprecated_redundant_constexpr_static_def);
4765 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4766 Diag(OldLocation, PrevDiag);
4796 StringRef HdrFilename =
4799 auto noteFromModuleOrInclude = [&](
Module *Mod,
4805 if (IncLoc.isValid()) {
4807 Diag(IncLoc, diag::note_redefinition_modules_same_file)
4813 Diag(IncLoc, diag::note_redefinition_include_same_file)
4814 << HdrFilename.str();
4824 if (FNew == FOld && FNewDecLoc.second == FOldDecLoc.second) {
4832 if (FOld && !HSI.isFileMultipleIncludeGuarded(*FOld))
4849 isa<VarTemplateSpecializationDecl>(New) ||
4887 ? S->getMSCurManglingNumber()
4888 : S->getMSLastManglingNumber();
4895 if (isa<CXXRecordDecl>(Tag->
getParent())) {
4910 Decl *ManglingContextDecl;
4911 std::tie(MCtx, ManglingContextDecl) =
4921struct NonCLikeKind {
4933 explicit operator bool() {
return Kind !=
None; }
4941 return {NonCLikeKind::Invalid, {}};
4948 return {NonCLikeKind::BaseClass,
4960 if (
auto *FD = dyn_cast<FieldDecl>(D)) {
4961 if (FD->hasInClassInitializer()) {
4962 auto *
Init = FD->getInClassInitializer();
4963 return {NonCLikeKind::DefaultMemberInit,
4971 if (isa<FriendDecl>(D))
4976 if (isa<StaticAssertDecl>(D) || isa<IndirectFieldDecl>(D) ||
4979 auto *MemberRD = dyn_cast<CXXRecordDecl>(D);
4987 if (MemberRD->isLambda())
4988 return {NonCLikeKind::Lambda, MemberRD->getSourceRange()};
4992 if (MemberRD->isThisDeclarationADefinition()) {
4998 return {
Invalid ? NonCLikeKind::Invalid : NonCLikeKind::None, {}};
5028 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TagFromDeclSpec);
5032 if (NonCLike || ChangesLinkage) {
5033 if (NonCLike.Kind == NonCLikeKind::Invalid)
5036 unsigned DiagID = diag::ext_non_c_like_anon_struct_in_typedef;
5037 if (ChangesLinkage) {
5039 if (NonCLike.Kind == NonCLikeKind::None)
5040 DiagID = diag::err_typedef_changes_linkage;
5042 DiagID = diag::err_non_c_like_anon_struct_in_typedef;
5048 TextToInsert +=
' ';
5051 Diag(FixitLoc, DiagID)
5052 << isa<TypeAliasDecl>(NewTD)
5054 if (NonCLike.Kind != NonCLikeKind::None) {
5055 Diag(NonCLike.Range.getBegin(), diag::note_non_c_like_anon_struct)
5056 << NonCLike.Kind - 1 << NonCLike.Range;
5059 << NewTD << isa<TypeAliasDecl>(NewTD);
5081 if (
const auto *ED = dyn_cast<EnumDecl>(DS.
getRepAsDecl())) {
5082 if (ED->isScopedUsingClassTag())
5089 llvm_unreachable(
"unexpected type specifier");
5099 bool IsExplicitInstantiation,
5101 Decl *TagD =
nullptr;
5116 if (isa<TagDecl>(TagD))
5117 Tag = cast<TagDecl>(TagD);
5119 Tag = CTD->getTemplatedDecl();
5134 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
5171 bool DeclaresAnything =
true;
5175 if (!
Record->getDeclName() &&
Record->isCompleteDefinition() &&
5178 Record->getDeclContext()->isRecord()) {
5192 DeclaresAnything =
false;
5215 Record = dyn_cast<RecordDecl>(Tag);
5228 DeclaresAnything =
false;
5240 if (
Enum->enumerator_begin() ==
Enum->enumerator_end() &&
5241 !
Enum->getIdentifier() && !
Enum->isInvalidDecl())
5242 DeclaresAnything =
false;
5250 DeclaresAnything =
false;
5269 if (!DeclaresAnything) {
5272 Diag(DS.
getBeginLoc(), (IsExplicitInstantiation || !TemplateParams.empty())
5273 ? diag::err_no_declarators
5274 : diag::ext_no_declarators)
5287 unsigned DiagID = diag::warn_standalone_specifier;
5289 DiagID = diag::ext_standalone_specifier;
5330 auto EmitAttributeDiagnostic = [
this, &DS](
const ParsedAttr &AL) {
5331 unsigned DiagnosticId = diag::warn_declspec_attribute_ignored;
5333 DiagnosticId = diag::warn_attribute_ignored;
5334 else if (AL.isRegularKeywordAttribute())
5335 DiagnosticId = diag::err_declspec_keyword_has_no_effect;
5337 DiagnosticId = diag::warn_declspec_attribute_ignored;
5338 Diag(AL.getLoc(), DiagnosticId)
5342 llvm::for_each(DS.
getAttributes(), EmitAttributeDiagnostic);
5343 llvm::for_each(DeclAttrs, EmitAttributeDiagnostic);
5367 assert(PrevDecl &&
"Expected a non-null Decl");
5380 SemaRef.
Diag(NameLoc, diag::err_anonymous_record_member_redecl)
5382 SemaRef.
Diag(PrevDecl->
getLocation(), diag::note_previous_declaration);
5388 if (
auto *RD = dyn_cast_if_present<RecordDecl>(D))
5402 if (
Record->isAnonymousStructOrUnion())
5407 const NamedDecl *ND = dyn_cast<NamedDecl>(D);
5441 for (
auto *D : AnonRecord->
decls()) {
5442 if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) &&
5443 cast<NamedDecl>(D)->getDeclName()) {
5459 unsigned OldChainingSize = Chaining.size();
5461 Chaining.append(IF->chain_begin(), IF->chain_end());
5463 Chaining.push_back(VD);
5465 assert(Chaining.size() >= 2);
5468 for (
unsigned i = 0; i < Chaining.size(); i++)
5469 NamedChain[i] = Chaining[i];
5473 VD->
getType(), {NamedChain, Chaining.size()});
5485 Chaining.resize(OldChainingSize);
5500 "Parser allowed 'typedef' as storage class VarDecl.");
5501 switch (StorageClassSpec) {
5515 llvm_unreachable(
"unknown storage class specifier");
5519 assert(
Record->hasInClassInitializer());
5521 for (
const auto *I :
Record->decls()) {
5522 const auto *FD = dyn_cast<FieldDecl>(I);
5523 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
5524 FD = IFD->getAnonField();
5525 if (FD && FD->hasInClassInitializer())
5526 return FD->getLocation();
5529 llvm_unreachable(
"couldn't find in-class initializer");
5534 if (!
Parent->isUnion() || !
Parent->hasInClassInitializer())
5537 S.
Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
5543 if (!
Parent->isUnion() || !
Parent->hasInClassInitializer())
5561 Diag(
Record->getLocation(), diag::ext_anonymous_union);
5563 Diag(
Record->getLocation(), diag::ext_gnu_anonymous_struct);
5565 Diag(
Record->getLocation(), diag::ext_c11_anonymous_struct);
5571 const char *PrevSpec =
nullptr;
5582 !cast<NamespaceDecl>(OwnerScope)->isAnonymousNamespace()))) {
5583 Diag(
Record->getLocation(), diag::err_anonymous_union_not_static)
5588 PrevSpec, DiagID, Policy);
5594 isa<RecordDecl>(Owner)) {
5596 diag::err_anonymous_union_with_storage_spec)
5610 <<
Record->isUnion() <<
"const"
5614 diag::ext_anonymous_struct_union_qualified)
5615 <<
Record->isUnion() <<
"volatile"
5619 diag::ext_anonymous_struct_union_qualified)
5620 <<
Record->isUnion() <<
"restrict"
5624 diag::ext_anonymous_struct_union_qualified)
5625 <<
Record->isUnion() <<
"_Atomic"
5629 diag::ext_anonymous_struct_union_qualified)
5630 <<
Record->isUnion() <<
"__unaligned"
5640 for (
auto *Mem :
Record->decls()) {
5642 if (Mem->isInvalidDecl())
5645 if (
auto *FD = dyn_cast<FieldDecl>(Mem)) {
5649 assert(FD->getAccess() !=
AS_none);
5651 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
5663 }
else if (Mem->isImplicit()) {
5665 }
else if (isa<TagDecl>(Mem) && Mem->getDeclContext() !=
Record) {
5670 }
else if (
auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
5671 if (!MemRecord->isAnonymousStructOrUnion() &&
5672 MemRecord->getDeclName()) {
5675 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
5679 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
5687 Diag(MemRecord->getLocation(),
5688 diag::ext_anonymous_record_with_anonymous_type)
5691 }
else if (isa<AccessSpecDecl>(Mem)) {
5693 }
else if (isa<StaticAssertDecl>(Mem)) {
5698 unsigned DK = diag::err_anonymous_record_bad_member;
5699 if (isa<TypeDecl>(Mem))
5700 DK = diag::err_anonymous_record_with_type;
5701 else if (isa<FunctionDecl>(Mem))
5702 DK = diag::err_anonymous_record_with_function;
5703 else if (isa<VarDecl>(Mem))
5704 DK = diag::err_anonymous_record_with_static;
5708 DK == diag::err_anonymous_record_with_type)
5709 Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
5712 Diag(Mem->getLocation(), DK) <<
Record->isUnion();
5721 if (cast<CXXRecordDecl>(
Record)->hasInClassInitializer() &&
5724 cast<CXXRecordDecl>(
Record));
5728 Diag(
Record->getLocation(), diag::err_anonymous_struct_not_member)
5749 assert(TInfo &&
"couldn't build declarator info for anonymous struct/union");
5753 if (
RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
5769 Diag(
Record->getLocation(), diag::err_mutable_nonmember);
5775 Record->getLocation(),
nullptr,
5788 Record->setAnonymousStructOrUnion(
true);
5799 Chain.push_back(Anon);
5805 if (
VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
5808 Decl *ManglingContextDecl;
5809 std::tie(MCtx, ManglingContextDecl) =
5841 assert(
Record &&
"expected a record!");
5846 assert(TInfo &&
"couldn't build declarator info for anonymous struct");
5848 auto *ParentDecl = cast<RecordDecl>(
CurContext);
5854 nullptr, RecTy, TInfo,
5866 Chain.push_back(Anon);
5870 diag::err_field_incomplete_or_sizeless) ||
5875 ParentDecl->setInvalidDecl();
5891 NameInfo.
setLoc(Name.StartLocation);
5893 switch (Name.getKind()) {
5897 NameInfo.
setName(Name.Identifier);
5913 if (!Template || !isa<ClassTemplateDecl>(Template)) {
5914 Diag(Name.StartLocation,
5915 diag::err_deduction_guide_name_not_class_template)
5929 Name.OperatorFunctionId.Operator));
5931 Name.OperatorFunctionId.SymbolLocations[0], Name.EndLocation));
5967 if (!CurClass || CurClass->
getIdentifier() != Name.TemplateId->Name)
6003 llvm_unreachable(
"Unknown name kind");
6031 for (
unsigned Idx = 0; Idx <
Declaration->param_size(); ++Idx) {
6045 (DeclTyName && DeclTyName == DefTyName))
6046 Params.push_back(Idx);
6073#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case DeclSpec::TST_##Trait:
6074#include "clang/Basic/TransformTypeTraits.def"
6089 if (!TSI)
return true;
6102 if (
Result.isInvalid())
return true;
6147 << D << static_cast<int>(Status);
6158 if (getOMPTraitInfoForSurroundingScope()->isExtensionActive(llvm::omp::TraitProperty::
6159 implementation_extension_bind_to_declaration))
6190 Diag(NameInfo.
getLoc(), diag::err_member_name_of_class) << Name;
6219 bool IsMemberSpecialization) {
6220 assert(SS.
isValid() &&
"diagnoseQualifiedDeclaration called for declaration "
6221 "without nested-name-specifier");
6223 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
6237 Diag(Loc,
LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
6238 : diag::err_member_extra_qualification)
6242 Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name;
6250 if (!Cur->
Encloses(DC) && !(TemplateId || IsMemberSpecialization)) {
6252 Diag(Loc, diag::err_member_qualification)
6254 else if (isa<TranslationUnitDecl>(DC))
6255 Diag(Loc, diag::err_invalid_declarator_global_scope)
6257 else if (isa<FunctionDecl>(Cur))
6258 Diag(Loc, diag::err_invalid_declarator_in_function)
6260 else if (isa<BlockDecl>(Cur))
6261 Diag(Loc, diag::err_invalid_declarator_in_block)
6263 else if (isa<ExportDecl>(Cur)) {
6264 if (!isa<NamespaceDecl>(DC))
6265 Diag(Loc, diag::err_export_non_namespace_scope_name)
6272 Diag(Loc, diag::err_invalid_declarator_scope)
6273 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.
getRange();
6280 Diag(Loc, diag::err_member_qualification)
6306 Diag(Loc, diag::ext_template_after_declarative_nns)
6313 Diag(Loc, diag::ext_template_after_declarative_nns)
6324 if (TST->isDependentType() && TST->isTypeAlias())
6325 Diag(Loc, diag::ext_alias_template_in_declarative_nns)
6327 }
else if (T->isDecltypeType()) {
6335 Diag(Loc, diag::err_decltype_in_declarator)
6339 }
while ((SpecLoc = SpecLoc.
getPrefix()));
6372 if (!DC || isa<EnumDecl>(DC)) {
6378 diag::err_template_qualified_declarator_no_match)
6385 if (!IsDependentContext &&
6390 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->
hasDefinition()) {
6392 diag::err_member_def_undefined_record)
6413 if (EnteringContext && IsDependentContext &&
6414 TemplateParamLists.size() != 0) {
6433 bool IsLinkageLookup =
false;
6434 bool CreateBuiltins =
false;
6448 IsLinkageLookup =
true;
6453 CreateBuiltins =
true;
6455 if (IsLinkageLookup) {
6496 bool AllowForCompatibility =
false;
6497 if (
Scope *DeclParent = S->getDeclParent();
6498 Scope *TemplateParamParent = S->getTemplateParamParent()) {
6499 AllowForCompatibility = DeclParent->Contains(*TemplateParamParent) &&
6500 TemplateParamParent->isDeclScope(TPD);
6503 AllowForCompatibility);
6529 S = S->getDeclParent();
6533 bool AddToScope =
true;
6535 if (TemplateParamLists.size()) {
6569 bool &SizeIsNegative,
6570 llvm::APSInt &Oversized) {
6575 SizeIsNegative =
false;
6584 if (
const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
6589 if (FixedType.
isNull())
return FixedType;
6591 return Qs.
apply(Context, FixedType);
6593 if (
const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
6594 QualType Inner = PTy->getInnerType();
6598 if (FixedType.
isNull())
return FixedType;
6600 return Qs.
apply(Context, FixedType);
6610 SizeIsNegative, Oversized);
6620 llvm::APSInt Res =
Result.Val.getInt();
6623 if (Res.isSigned() && Res.isNegative()) {
6624 SizeIsNegative =
true;
6629 unsigned ActiveSizeBits =
6633 : Res.getActiveBits();
6641 return Qs.
apply(Context, FoldedArrayType);
6666 TypeLoc DstElemTL = DstATL.getElementLoc();
6685 bool &SizeIsNegative,
6686 llvm::APSInt &Oversized) {
6689 SizeIsNegative, Oversized);
6702 unsigned FailedFoldDiagID) {
6703 bool SizeIsNegative;
6704 llvm::APSInt Oversized;
6706 TInfo,
Context, SizeIsNegative, Oversized);
6708 Diag(Loc, diag::ext_vla_folded_to_constant);
6715 Diag(Loc, diag::err_typecheck_negative_array_size);
6716 else if (Oversized.getBoolValue())
6717 Diag(Loc, diag::err_array_too_large) <<
toString(Oversized, 10);
6718 else if (FailedFoldDiagID)
6719 Diag(Loc, FailedFoldDiagID);
6751 diag::err_virtual_non_function);
6755 diag::err_explicit_non_function);
6759 diag::err_noreturn_non_function);
6787 diag::err_deduction_guide_invalid_specifier)
6796 if (!NewTD)
return nullptr;
6820 if (S->getFnParent() ==
nullptr) {
6821 bool SizeIsNegative;
6822 llvm::APSInt Oversized;
6835 else if (Oversized.getBoolValue())
6862 Redeclaration =
true;
6868 if (ShadowedDecl && !Redeclaration)
6875 switch (II->getNotableIdentifierID()) {
6876 case tok::NotableIdentifierKind::FILE:
6879 case tok::NotableIdentifierKind::jmp_buf:
6882 case tok::NotableIdentifierKind::sigjmp_buf:
6885 case tok::NotableIdentifierKind::ucontext_t:
6888 case tok::NotableIdentifierKind::float_t:
6889 case tok::NotableIdentifierKind::double_t:
6890 NewTD->
addAttr(AvailableOnlyInDefaultEvalMethodAttr::Create(
Context));
6951 if (!OuterContext->
Equals(PrevOuterContext))
6960 if (!SS.
isSet())
return;
6969 unsigned kind = -1U;
6971 if (var->hasAttr<BlocksAttr>())
6973 else if (!var->hasLocalStorage())
6975 }
else if (isa<ObjCIvarDecl>(
decl)) {
6977 }
else if (isa<FieldDecl>(
decl)) {
6982 Diag(
decl->getLocation(), diag::err_arc_autoreleasing_var)
6987 if (!
type->isObjCLifetimeType())
6990 lifetime =
type->getObjCARCImplicitLifetime();
6998 var->getTLSKind()) {
6999 Diag(var->getLocation(), diag::err_arc_thread_ownership)
7009 if (
Decl->getType().hasAddressSpace())
7011 if (
Decl->getType()->isDependentType())
7023 Var->hasGlobalStorage())
7027 if (
auto DT = dyn_cast<DecayedType>(
Type)) {
7028 auto OrigTy = DT->getOriginalType();
7029 if (!OrigTy.hasAddressSpace() && OrigTy->isArrayType()) {
7061 if (WeakRefAttr *
Attr = ND.
getAttr<WeakRefAttr>()) {
7068 if (
auto *VD = dyn_cast<VarDecl>(&ND)) {
7069 if (VD->hasInit()) {
7070 if (
const auto *
Attr = VD->getAttr<AliasAttr>()) {
7071 assert(VD->isThisDeclarationADefinition() &&
7072 !VD->isExternallyVisible() &&
"Broken AliasAttr handled late!");
7074 VD->dropAttr<AliasAttr>();
7081 if (SelectAnyAttr *
Attr = ND.
getAttr<SelectAnyAttr>()) {
7084 diag::err_attribute_selectany_non_extern_data);
7090 auto *VD = dyn_cast<VarDecl>(&ND);
7091 bool IsAnonymousNS =
false;
7094 const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(VD->getDeclContext());
7095 while (NS && !IsAnonymousNS) {
7097 NS = dyn_cast<NamespaceDecl>(NS->
getParent());
7104 bool AnonNSInMicrosoftMode = IsAnonymousNS && IsMicrosoft;
7106 (!AnonNSInMicrosoftMode &&
7115 if (
const auto *FD = dyn_cast<FunctionDecl>(&ND)) {
7120 for (
TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc();
7126 if (
const auto *A = ATL.
getAttrAs<LifetimeBoundAttr>()) {
7127 const auto *MD = dyn_cast<CXXMethodDecl>(FD);
7128 if (!MD || MD->isStatic()) {
7129 S.
Diag(A->getLocation(), diag::err_lifetimebound_no_object_param)
7130 << !MD << A->getRange();
7131 }
else if (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)) {
7132 S.
Diag(A->getLocation(), diag::err_lifetimebound_ctor_dtor)
7133 << isa<CXXDestructorDecl>(MD) << A->getRange();
7142 bool IsSpecialization,
7143 bool IsDefinition) {
7147 bool IsTemplate =
false;
7148 if (
TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl)) {
7149 OldDecl = OldTD->getTemplatedDecl();
7151 if (!IsSpecialization)
7152 IsDefinition =
false;
7154 if (
TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl)) {
7155 NewDecl = NewTD->getTemplatedDecl();
7159 if (!OldDecl || !NewDecl)
7162 const DLLImportAttr *OldImportAttr = OldDecl->
getAttr<DLLImportAttr>();
7163 const DLLExportAttr *OldExportAttr = OldDecl->
getAttr<DLLExportAttr>();
7164 const DLLImportAttr *NewImportAttr = NewDecl->
getAttr<DLLImportAttr>();
7165 const DLLExportAttr *NewExportAttr = NewDecl->
getAttr<DLLExportAttr>();
7169 bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
7170 (NewExportAttr && !NewExportAttr->isInherited());
7176 bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
7178 if (AddsAttr && !IsSpecialization && !OldDecl->
isImplicit()) {
7180 bool JustWarn =
false;
7182 auto *VD = dyn_cast<VarDecl>(OldDecl);
7183 if (VD && !VD->getDescribedVarTemplate())
7185 auto *FD = dyn_cast<FunctionDecl>(OldDecl);
7194 if (!isa<FunctionDecl>(OldDecl) || !NewImportAttr)
7197 unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
7198 : diag::err_attribute_dll_redeclaration;
7201 << (NewImportAttr ? (
const Attr *)NewImportAttr : NewExportAttr);
7214 bool IsInline =
false, IsStaticDataMember =
false, IsQualifiedFriend =
false;
7216 if (
const auto *VD = dyn_cast<VarDecl>(NewDecl)) {
7219 IsStaticDataMember = VD->isStaticDataMember();
7220 IsDefinition = VD->isThisDeclarationADefinition(S.
Context) !=
7222 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
7223 IsInline = FD->isInlined();
7224 IsQualifiedFriend = FD->getQualifier() &&
7228 if (OldImportAttr && !HasNewAttr &&
7229 (!IsInline || (IsMicrosoftABI && IsTemplate)) && !IsStaticDataMember &&
7231 if (IsMicrosoftABI && IsDefinition) {
7232 if (IsSpecialization) {
7235 diag::err_attribute_dllimport_function_specialization_definition);
7236 S.
Diag(OldImportAttr->getLocation(), diag::note_attribute);
7237 NewDecl->
dropAttr<DLLImportAttr>();
7240 diag::warn_redeclaration_without_import_attribute)
7243 NewDecl->
dropAttr<DLLImportAttr>();
7244 NewDecl->
addAttr(DLLExportAttr::CreateImplicit(
7245 S.
Context, NewImportAttr->getRange()));
7247 }
else if (IsMicrosoftABI && IsSpecialization) {
7248 assert(!IsDefinition);
7252 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
7253 << NewDecl << OldImportAttr;
7255 S.
Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
7256 OldDecl->
dropAttr<DLLImportAttr>();
7257 NewDecl->
dropAttr<DLLImportAttr>();
7259 }
else if (IsInline && OldImportAttr && !IsMicrosoftABI) {
7262 OldDecl->
dropAttr<DLLImportAttr>();
7263 NewDecl->
dropAttr<DLLImportAttr>();
7265 diag::warn_dllimport_dropped_from_inline_function)
7266 << NewDecl << OldImportAttr;
7273 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDecl)) {
7275 !NewImportAttr && !NewExportAttr) {
7276 if (
const DLLExportAttr *ParentExportAttr =
7277 MD->getParent()->getAttr<DLLExportAttr>()) {
7278 DLLExportAttr *NewAttr = ParentExportAttr->clone(S.
Context);
7279 NewAttr->setInherited(
true);
7323 if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>())
7327 if (S.
getLangOpts().CUDA && (D->template hasAttr<CUDADeviceAttr>() ||
7328 D->template hasAttr<CUDAHostAttr>()))
7331 return D->isExternC();
7337 isa<OMPDeclareMapperDecl>(DC))
7346 if (isa<RequiresExprBodyDecl>(DC))
7348 llvm_unreachable(
"Unexpected context");
7354 isa<OMPDeclareReductionDecl>(DC) || isa<OMPDeclareMapperDecl>(DC))
7358 llvm_unreachable(
"Unexpected context");
7405 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
7406 return FD->isExternC();
7407 if (
const auto *VD = dyn_cast<VarDecl>(D))
7408 return VD->isExternC();
7410 llvm_unreachable(
"Unknown type of decl!");
7423 diag::err_opencl_type_can_only_be_used_as_function_parameter)
7437 diag::err_invalid_type_for_program_scope_var)
7466 Se.
Diag(NewVD->
getLocation(), diag::err_opencl_half_declaration) << R;
7499 Se.
Diag(NewVD->
getLocation(), diag::err_opencl_nonconst_global_sampler);
7509template <
typename AttrTy>
7512 if (
const auto *Attribute = TND->
getAttr<AttrTy>()) {
7513 AttrTy *Clone = Attribute->clone(S.
Context);
7514 Clone->setInherited(
true);
7542 if (
const auto *ConstDecl = RD->
getAttr<ReadOnlyPlacementAttr>()) {
7544 S.
Diag(ConstDecl->getLocation(), diag::note_enforce_read_only_placement);
7557 bool IsPlaceholderVariable =
false;
7563 if (!Decomp.bindings().empty()) {
7564 II = Decomp.bindings()[0].Name;
7578 IsPlaceholderVariable =
true;
7596 bool IsLocalExternDecl = SC ==
SC_Extern &&
7615 : diag::warn_deprecated_register)
7621 if (!DC->
isRecord() && S->getFnParent() ==
nullptr) {
7637 bool IsMemberSpecialization =
false;
7638 bool IsVariableTemplateSpecialization =
false;
7640 bool IsVariableTemplate =
false;
7668 diag::err_static_out_of_line)
7680 diag::err_storage_class_for_static_member)
7684 llvm_unreachable(
"C storage class in c++!");
7689 if (
const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
7695 if (Ctxt->isFunctionOrMethod()) {
7696 FunctionOrMethod = Ctxt;
7699 const CXXRecordDecl *ParentDecl = dyn_cast<CXXRecordDecl>(Ctxt);
7701 AnonStruct = ParentDecl;
7705 if (FunctionOrMethod) {
7709 diag::err_static_data_member_not_allowed_in_local_class)
7710 << Name << RD->getDeclName()
7711 << llvm::to_underlying(RD->getTagKind());
7712 }
else if (AnonStruct) {
7717 diag::err_static_data_member_not_allowed_in_anon_struct)
7718 << Name << llvm::to_underlying(AnonStruct->
getTagKind());
7720 }
else if (RD->isUnion()) {
7725 ? diag::warn_cxx98_compat_static_data_member_in_union
7726 : diag::ext_static_data_member_in_union) << Name;
7733 bool InvalidScope =
false;
7741 false, IsMemberSpecialization, InvalidScope);
7744 if (TemplateParams) {
7745 if (!TemplateParams->
size() &&
7750 diag::err_template_variable_noparams)
7754 TemplateParams =
nullptr;
7762 IsVariableTemplateSpecialization =
true;
7766 IsVariableTemplate =
true;
7771 ? diag::warn_cxx11_compat_variable_template
7772 : diag::ext_variable_template);
7777 if (!TemplateParamLists.empty() && IsMemberSpecialization &&
7782 "should have a 'template<>' for this decl");
7785 if (IsVariableTemplateSpecialization) {
7787 TemplateParamLists.size() > 0
7788 ? TemplateParamLists[0]->getTemplateLoc()
7791 S, D, TInfo,
Previous, TemplateKWLoc, TemplateParams, SC,
7795 NewVD = cast<VarDecl>(Res.
get());
7806 if (IsVariableTemplate) {
7809 TemplateParams, NewVD);
7830 bool IsExplicitSpecialization =
7832 unsigned VDTemplateParamLists =
7833 (TemplateParams && !IsExplicitSpecialization) ? 1 : 0;
7834 if (TemplateParamLists.size() > VDTemplateParamLists)
7836 Context, TemplateParamLists.drop_back(VDTemplateParamLists));
7846 diag::err_inline_declaration_block_scope) << Name
7851 : diag::ext_inline_variable);
7862 if (IsLocalExternDecl) {
7865 B->setLocalExternDecl();
7870 bool EmitTLSUnsupportedError =
false;
7883 diag::err_thread_non_global)
7891 EmitTLSUnsupportedError =
true;
7898 diag::err_thread_unsupported);
7909 diag::err_constexpr_wrong_decl_kind)
7927 diag::err_constinit_local_variable);
7931 ConstInitAttr::Keyword_constinit));
7944 if (SC ==
SC_Static && S->getFnParent() !=
nullptr &&
7949 diag::warn_static_local_in_extern_inline);
7955 if (IsVariableTemplateSpecialization)
7960 else if (IsMemberSpecialization)
7975 B->setModulePrivate();
7985 diag::err_opencl_unknown_type_specifier)
7995 if (
const auto *ATy = dyn_cast<ArrayType>(NewVD->
getType())) {
7996 if (ATy && ATy->getElementType().isWebAssemblyReferenceType() &&
8013 copyAttrFromTypedefToDecl<AllocSizeAttr>(*
this, NewVD, TT);
8017 if (EmitTLSUnsupportedError &&
8020 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(NewVD))))
8022 diag::err_thread_unsupported);
8024 if (EmitTLSUnsupportedError &&
8030 if (SC ==
SC_None && S->getFnParent() !=
nullptr &&
8031 (NewVD->
hasAttr<CUDASharedAttr>() ||
8032 NewVD->
hasAttr<CUDAConstantAttr>())) {
8040 assert(!NewVD->
hasAttr<DLLImportAttr>() ||
8041 NewVD->
getAttr<DLLImportAttr>()->isInherited() ||
8054 if (S->getFnParent() !=
nullptr) {
8058 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) <<
Label;
8064 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) <<
Label;
8075 bool HasSizeMismatch;
8077 if (!TI.isValidGCCRegisterName(
Label))
8078 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) <<
Label;
8079 else if (!TI.validateGlobalRegisterVariable(
Label,
8082 Diag(E->getExprLoc(), diag::err_asm_invalid_global_var_reg) <<
Label;
8083 else if (HasSizeMismatch)
8084 Diag(E->getExprLoc(), diag::err_asm_register_size_mismatch) <<
Label;
8097 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
8119 IsMemberSpecialization ||
8120 IsVariableTemplateSpecialization);
8134 if (IsMemberSpecialization && !IsVariableTemplateSpecialization &&
8141 isa<FieldDecl>(
Previous.getFoundDecl()) &&
8151 !IsVariableTemplateSpecialization) {
8159 if (!IsPlaceholderVariable)
8190 if (PrevVarTemplate &&
8210 Decl *ManglingContextDecl;
8211 std::tie(MCtx, ManglingContextDecl) =
8222 if (Name.getAsIdentifierInfo() && Name.getAsIdentifierInfo()->isStr(
"main") &&
8272 if (isa<TypeAliasDecl>(ShadowedDecl))
8274 else if (isa<TypedefDecl>(ShadowedDecl))
8276 else if (isa<BindingDecl>(ShadowedDecl))
8278 else if (isa<RecordDecl>(OldDC))
8317 return isa<VarDecl, FieldDecl, BindingDecl>(ShadowedDecl) ? ShadowedDecl
8333 return isa<TypedefNameDecl>(ShadowedDecl) ? ShadowedDecl :
nullptr;
8344 return isa<VarDecl, FieldDecl, BindingDecl>(ShadowedDecl) ? ShadowedDecl
8361 if (
FieldDecl *FD = dyn_cast<FieldDecl>(ShadowedDecl)) {
8369 if (isa<CXXConstructorDecl>(NewDC))
8370 if (
const auto PVD = dyn_cast<ParmVarDecl>(D)) {
8373 ShadowingDecls.insert({PVD->getCanonicalDecl(), FD});
8378 if (
VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
8379 if (shadowedVar->isExternC()) {
8382 for (
auto *I : shadowedVar->redecls())
8383 if (I->isFileVarDecl()) {
8391 unsigned WarningDiag = diag::warn_decl_shadow;
8393 if (isa<VarDecl>(D) && NewDC && isa<CXXMethodDecl>(NewDC)) {
8394 if (
const auto *RD = dyn_cast<CXXRecordDecl>(NewDC->
getParent())) {
8396 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl)) {
8398 if (RD->getLambdaCaptureDefault() ==
LCD_None) {
8404 WarningDiag = diag::warn_decl_shadow_uncaptured_local;
8410 ->ShadowingDecls.push_back({D, VD});
8414 if (isa<FieldDecl>(ShadowedDecl)) {
8421 ->ShadowingDecls.push_back({D, ShadowedDecl});
8425 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl);
8426 VD && VD->hasLocalStorage()) {
8430 ParentDC && !ParentDC->
Equals(OldDC);
8434 if (!isa<BlockDecl>(ParentDC) && !isa<CapturedDecl>(ParentDC) &&
8468 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
8477 const NamedDecl *ShadowedDecl = Shadow.ShadowedDecl;
8480 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl)) {
8482 Diag(Shadow.VD->getLocation(),
8483 CaptureLoc.
isInvalid() ? diag::warn_decl_shadow_uncaptured_local
8484 : diag::warn_decl_shadow)
8485 << Shadow.VD->getDeclName()
8488 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
8489 << Shadow.VD->getDeclName() << 0;
8491 }
else if (isa<FieldDecl>(ShadowedDecl)) {
8492 Diag(Shadow.VD->getLocation(),
8494 : diag::warn_decl_shadow_uncaptured_local)
8495 << Shadow.VD->getDeclName()
8521 auto *DRE = dyn_cast<DeclRefExpr>(E);
8524 const NamedDecl *D = cast<NamedDecl>(DRE->getDecl()->getCanonicalDecl());
8525 auto I = ShadowingDecls.find(D);
8526 if (I == ShadowingDecls.end())
8528 const NamedDecl *ShadowedDecl = I->second;
8530 Diag(Loc, diag::warn_modifying_shadowing_decl) << D << OldDC;
8535 ShadowingDecls.erase(I);
8543 assert(S.
getLangOpts().CPlusPlus &&
"only C++ has extern \"C\"");
8564 if (!isa<VarDecl>(ND))
8574 if (isa<VarDecl>(*I)) {
8584 if (isa<VarDecl>(*I)) {
8602 assert(Prev &&
"should have found a previous declaration to diagnose");
8604 Prev = FD->getFirstDecl();
8606 Prev = cast<VarDecl>(Prev)->getFirstDecl();
8608 S.
Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
8630 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
8642 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
8662 SemaRef.
Diag(VarLoc, diag::err_c23_constexpr_invalid_type) << T;
8672 SemaRef.
Diag(VarLoc, diag::err_c23_constexpr_invalid_type) << T;
8678 if (llvm::any_of(RD->
fields(), [&SemaRef, VarLoc](
const FieldDecl *F) {
8679 return CheckC23ConstexprVarType(SemaRef, VarLoc, F->getType());
8735 if (NewVD->
hasAttr<BlocksAttr>()) {
8744 Diag(NewVD->
getLocation(), diag::err_opencl_invalid_block_declaration)
8750 Diag(NewVD->
getLocation(), diag::err_opencl_extern_block_declaration);
8766 Diag(NewVD->
getLocation(), diag::err_opencl_global_invalid_addr_space)
8767 <<
Scope <<
"global or constant";
8769 Diag(NewVD->
getLocation(), diag::err_opencl_global_invalid_addr_space)
8770 <<
Scope <<
"constant";
8786 if (FD && !FD->
hasAttr<OpenCLKernelAttr>()) {
8798 if (FD && FD->
hasAttr<OpenCLKernelAttr>()) {
8823 && !NewVD->
hasAttr<BlocksAttr>()) {
8845 const auto *ATy = dyn_cast<ConstantArrayType>(T.
getTypePtr());
8846 if (!ATy || ATy->getSize().getSExtValue() != 0) {
8848 diag::err_typecheck_wasm_table_must_have_zero_length);
8855 if (isVM || NewVD->
hasAttr<CleanupAttr>() ||
8861 bool SizeIsNegative;
8862 llvm::APSInt Oversized;
8867 FixedT = FixedTInfo->
getType();
8868 else if (FixedTInfo) {
8931 if (isVM && NewVD->
hasAttr<BlocksAttr>()) {
8945 diag::err_constexpr_var_non_literal)) {
8961 llvm::StringMap<bool> CallerFeatureMap;
8964 "sve", CallerFeatureMap)) {
8965 Diag(NewVD->
getLocation(), diag::err_sve_vector_in_non_sve_target) << T;
9028 dyn_cast<CXXMethodDecl>(BaseND->getCanonicalDecl());
9035 if (Overridden.insert(BaseMD).second) {
9052 return !Overridden.empty();
9058 struct ActOnFDArgs {
9074 : Context(Context), OriginalFD(TypoFD),
9077 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
9083 CDeclEnd = candidate.
end();
9084 CDecl != CDeclEnd; ++CDecl) {
9091 if (
Parent &&
Parent->getCanonicalDecl() == ExpectedParent)
9093 }
else if (!ExpectedParent) {
9102 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
9103 return std::make_unique<DifferentNameValidatorCCC>(*
this);
9129 ActOnFDArgs &ExtraArgs,
bool IsLocalFriend,
Scope *S) {
9135 bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
9137 IsLocalFriend ? diag::err_no_matching_local_friend :
9139 diag::err_member_decl_does_not_match;
9151 "Cannot have an ambiguity in previous-declaration lookup");
9153 DifferentNameValidatorCCC CCC(SemaRef.
Context, NewFD,
9155 if (!Prev.
empty()) {
9164 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
9165 NearMatches.push_back(std::make_pair(FD, ParamNum));
9172 IsLocalFriend ?
nullptr : NewDC))) {
9175 ExtraArgs.D.getIdentifierLoc());
9179 CDeclEnd = Correction.
end();
9180 CDecl != CDeclEnd; ++CDecl) {
9187 bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
9200 ExtraArgs.S, ExtraArgs.D,
9203 ExtraArgs.AddToScope);
9211 Decl *Canonical =
Result->getCanonicalDecl();
9214 if ((*I)->getCanonicalDecl() == Canonical)
9221 SemaRef.
PDiag(IsLocalFriend
9222 ? diag::err_no_matching_local_friend_suggest
9223 : diag::err_member_decl_does_not_match_suggest)
9224 << Name << NewDC << IsDefinition);
9229 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
9230 ExtraArgs.D.getIdentifierLoc());
9231 ExtraArgs.D.setRedeclaration(wasRedeclaration);
9237 << Name << NewDC << IsDefinition << NewFD->
getLocation();
9239 bool NewFDisConst =
false;
9241 NewFDisConst = NewMD->isConst();
9244 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
9245 NearMatch != NearMatchEnd; ++NearMatch) {
9248 bool FDisConst = MD && MD->
isConst();
9249 bool IsMember = MD || !IsLocalFriend;
9252 if (
unsigned Idx = NearMatch->second) {
9256 SemaRef.
Diag(Loc, IsMember ? diag::note_member_def_close_param_match
9257 : diag::note_local_decl_close_param_match)
9260 }
else if (FDisConst != NewFDisConst) {
9261 SemaRef.
Diag(FD->
getLocation(), diag::note_member_def_close_const_match)
9265 .getConstQualifierLoc())
9268 .getLocWithOffset(1),
9272 IsMember ? diag::note_member_def_close_match
9273 : diag::note_local_decl_close_match);
9280 default: llvm_unreachable(
"Unknown storage class!");
9285 diag::err_typecheck_sclass_func);
9302 diag::err_static_block_func);
9318 bool &IsVirtualOkay) {
9332 diag::err_c23_constexpr_not_variable);
9335 diag::err_constexpr_wrong_decl_kind)
9336 <<
static_cast<int>(ConstexprKind);
9356 ->isFunctionProtoType()) ||
9360 "Strict prototypes are required");
9381 "Constructors can only be declared in a member context");
9387 isInline,
false, ConstexprKind,
9398 false, ConstexprKind,
9399 TrailingRequiresClause);
9402 if (
Record->isBeingDefined())
9411 IsVirtualOkay =
true;
9423 true, ConstexprKind, TrailingRequiresClause);
9429 diag::err_conv_function_not_member);
9437 IsVirtualOkay =
true;
9442 TrailingRequiresClause);
9445 if (TrailingRequiresClause)
9447 diag::err_trailing_requires_clause_on_deduction_guide)
9459 if (Name.getAsIdentifierInfo() &&
9460 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
9472 IsVirtualOkay = !Ret->isStatic();
9486 true , ConstexprKind, TrailingRequiresClause);
9503 StringRef SizeTypeNames[] = {
"size_t",
"intptr_t",
"uintptr_t",
"ptrdiff_t"};
9511 if (Names.end() != Match)
9516 }
while (DesugaredTy != Ty);
9555 "__cl_clang_non_portable_kernel_param_types", S.
getLangOpts())) {
9557 bool IsStandardLayoutType =
true;
9563 if (!CXXRec->hasDefinition())
9565 if (!CXXRec || !CXXRec->hasDefinition() || !CXXRec->isStandardLayout())
9566 IsStandardLayoutType =
false;
9569 !IsStandardLayoutType)
9617 "__cl_clang_non_portable_kernel_param_types", S.
getLangOpts()) &&
9631 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
9678 S.
Diag(Loc, diag::note_entity_declared_at) << PT;
9701 HistoryStack.push_back(
nullptr);
9710 VisitStack.push_back(RecTy->
getDecl());
9711 assert(VisitStack.back() &&
"First decl null?");
9714 const Decl *Next = VisitStack.pop_back_val();
9716 assert(!HistoryStack.empty());
9718 if (
const FieldDecl *Hist = HistoryStack.pop_back_val())
9719 ValidTypes.insert(Hist->getType().getTypePtr());
9727 if (
const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
9728 HistoryStack.push_back(Field);
9730 QualType FieldTy = Field->getType();
9734 "Unexpected type.");
9739 RD = cast<RecordDecl>(Next);
9743 VisitStack.push_back(
nullptr);
9745 for (
const auto *FD : RD->
fields()) {
9756 VisitStack.push_back(FD);
9768 diag::err_record_with_pointers_kernel_param)
9775 S.
Diag(OrigRecDecl->getLocation(), diag::note_within_field_of_type)
9776 << OrigRecDecl->getDeclName();
9781 I = HistoryStack.begin() + 1,
9782 E = HistoryStack.end();
9795 }
while (!VisitStack.empty());
9811 while (S->isClassScope() ||
9812 (LangOpts.CPlusPlus &&
9813 S->isFunctionPrototypeScope()) ||
9815 (S->getEntity() && S->getEntity()->isTransparentContext()))
9822 unsigned BuiltinID) {
9823 switch (BuiltinID) {
9824 case Builtin::BI__GetExceptionInfo:
9828 case Builtin::BIaddressof:
9829 case Builtin::BI__addressof:
9830 case Builtin::BIforward:
9831 case Builtin::BIforward_like:
9832 case Builtin::BImove:
9833 case Builtin::BImove_if_noexcept:
9834 case Builtin::BIas_const: {
9859 llvm::append_range(TemplateParamLists, TemplateParamListsRef);
9861 if (!TemplateParamLists.empty() && !TemplateParamLists.back()->empty() &&
9862 Invented->getDepth() == TemplateParamLists.back()->getDepth())
9863 TemplateParamLists.back() = Invented;
9865 TemplateParamLists.push_back(Invented);
9875 diag::err_invalid_thread)
9883 bool isFriend =
false;
9885 bool isMemberSpecialization =
false;
9886 bool isFunctionTemplateSpecialization =
false;
9888 bool HasExplicitTemplateArgs =
false;
9891 bool isVirtualOkay =
false;
9898 if (!NewFD)
return nullptr;
9908 if (IsLocalExternDecl)
9917 bool ImplicitInlineCXX20 = !
getLangOpts().CPlusPlusModules ||
9940 if (
Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
9945 if (isVirtual &&
Parent->isUnion()) {
9950 Parent->hasAttr<SYCLSpecialClassAttr>() &&
9953 if (
auto *Def =
Parent->getDefinition())
9954 Def->setInitMethod(
true);
9959 isMemberSpecialization =
false;
9960 isFunctionTemplateSpecialization =
false;
9975 isMemberSpecialization,
Invalid);
9976 if (TemplateParams) {
9981 if (TemplateParams->
size() > 0) {
9989 }
else if (TemplateId) {
10006 Name, TemplateParams,
10012 if (TemplateParamLists.size() > 1) {
10019 isFunctionTemplateSpecialization =
true;
10021 if (TemplateParamLists.size() > 0)
10041 << Name << RemoveRange
10047 HasExplicitTemplateArgs =
true;
10054 if (!TemplateParamLists.empty() && isMemberSpecialization &&
10060 if (TemplateParamLists.size() > 0)
10065 if (isFriend && TemplateId)
10066 isFunctionTemplateSpecialization =
true;
10072 if (isFunctionTemplateSpecialization && TemplateId) {
10073 HasExplicitTemplateArgs =
true;
10104 if (!isVirtualOkay) {
10106 diag::err_virtual_non_function);
10110 diag::err_virtual_out_of_class)
10116 diag::err_virtual_member_function_template)
10152 diag::err_inline_declaration_block_scope) << Name
10162 !isa<CXXDeductionGuideDecl>(NewFD)) {
10166 diag::err_explicit_out_of_class)
10168 }
else if (!isa<CXXConstructorDecl>(NewFD) &&
10169 !isa<CXXConversionDecl>(NewFD)) {
10173 diag::err_explicit_non_ctor_or_conv_function)
10187 if (isa<CXXDestructorDecl>(NewFD) &&
10191 <<
static_cast<int>(ConstexprKind);
10205 diag::err_invalid_consteval_decl_kind)
10213 if (isFunctionTemplateSpecialization) {
10216 Diag(ModulePrivateLoc, diag::err_module_private_specialization)
10251 if (isa<CXXMethodDecl>(NewFD) && DC ==
CurContext &&
10262 if (SC ==
SC_Static && isa<CXXMethodDecl>(NewFD) &&
10277 cast<CXXRecordDecl>(DC)->getDescribedClassTemplate()) ||
10279 ? diag::ext_static_out_of_line : diag::err_static_out_of_line)
10287 if ((Name.getCXXOverloadedOperator() == OO_Delete ||
10288 Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
10303 PendingInlineFuncDecls.insert(NewFD);
10310 isMemberSpecialization ||
10311 isFunctionTemplateSpecialization);
10321 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
10346 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
10350 Params.push_back(Param);
10365 auto *TD = dyn_cast<TagDecl>(NonParmDecl);
10370 if (
auto *ECD = dyn_cast<EnumConstantDecl>(NonParmDecl))
10371 TD = cast<EnumDecl>(ECD->getDeclContext());
10375 DeclContext *TagDC = TD->getLexicalDeclContext();
10379 TD->setDeclContext(NewFD);
10387 if (TagDC != PrototypeTagContext)
10388 TD->setLexicalDeclContext(TagDC);
10402 for (
const auto &AI : FT->param_types()) {
10406 Params.push_back(Param);
10410 "Should not need args for typedef of non-prototype fn");
10414 NewFD->setParams(Params);
10430 !NewFD->
hasAttr<SectionAttr>())
10431 NewFD->
addAttr(PragmaClangTextSectionAttr::CreateImplicit(
10437 !NewFD->
hasAttr<SectionAttr>()) {
10438 NewFD->
addAttr(SectionAttr::CreateImplicit(
10440 CodeSegStack.CurrentPragmaLocation, SectionAttr::Declspec_allocate));
10451 !NewFD->
hasAttr<StrictGuardStackCheckAttr>())
10452 NewFD->
addAttr(StrictGuardStackCheckAttr::CreateImplicit(
10457 if (!NewFD->
hasAttr<CodeSegAttr>()) {
10466 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
10467 if (NewTVA && !NewTVA->isDefaultVersion() &&
10470 AddToScope =
false;
10482 Diag(NewFD->
getLocation(), diag::err_return_value_with_address_space);
10497 isMemberSpecialization,
10504 "previous declaration set still overloaded");
10516 CC ==
CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
10539 diag::ext_operator_new_delete_declared_inline)
10566 if (isFunctionTemplateSpecialization || isMemberSpecialization) {
10578 Diag(TRC->getBeginLoc(), diag::err_non_temp_spec_requires_clause)
10586 diag::err_non_temp_friend_decl_with_requires_clause_must_be_def);
10590 Diag(TRC->getBeginLoc(),
10591 diag::err_constrained_non_templated_function);
10608 if (isFunctionTemplateSpecialization) {
10609 bool isDependentSpecialization =
false;
10614 isDependentSpecialization =
10616 (HasExplicitTemplateArgs &&
10620 assert((!isDependentSpecialization ||
10621 (HasExplicitTemplateArgs == isDependentSpecialization)) &&
10622 "dependent friend function specialization without template "
10628 isDependentSpecialization =
10633 HasExplicitTemplateArgs ? &TemplateArgs :
nullptr;
10634 if (isDependentSpecialization) {
10641 NewFD, ExplicitTemplateArgs,
Previous))
10658 diag::err_explicit_specialization_inconsistent_storage_class)
10665 diag::ext_explicit_specialization_storage_class)
10669 }
else if (isMemberSpecialization && isa<CXXMethodDecl>(NewFD)) {
10683 isMemberSpecialization,
10692 "previous declaration set still overloaded");
10733 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
10779 *
this,
Previous, NewFD, ExtraArgs,
false,
nullptr)) {
10780 AddToScope = ExtraArgs.AddToScope;
10787 }
else if (isFriend && cast<CXXRecordDecl>(
CurContext)->isLocalClass()) {
10789 *
this,
Previous, NewFD, ExtraArgs,
true, S)) {
10790 AddToScope = ExtraArgs.AddToScope;
10795 isa<CXXMethodDecl>(NewFD) && NewFD->
isOutOfLine() &&
10796 !isFriend && !isFunctionTemplateSpecialization &&
10797 !isMemberSpecialization) {
10812 if (!NewFD->
isInvalidDecl() && S->getDepth() == 0 && Name.isIdentifier())
10815 if (NewFD->
hasAttr<HLSLShaderAttr>())
10823 if (
unsigned BuiltinID = II->getBuiltinID()) {
10825 if (!InStdNamespace &&
10831 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10840 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10845 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10856 if (NewFD->
hasAttr<OverloadableAttr>() &&
10859 diag::err_attribute_overloadable_no_prototype)
10861 NewFD->
dropAttr<OverloadableAttr>();
10894 isMemberSpecialization ||
10895 isFunctionTemplateSpecialization,
10914 (NewFD->
hasAttr<CUDADeviceAttr>() ||
10915 NewFD->
hasAttr<CUDAGlobalAttr>()) &&
10970 diag::err_friend_decl_with_enclosing_temp_constraint_must_be_def);
10990 if (
getLangOpts().getOpenCLCompatibleVersion() >= 200) {
10992 QualType ElemTy = PipeTy->getElementType();
10994 Diag(Param->getTypeSpecStartLoc(), diag::err_reference_pipe_type );
11002 Diag(Param->getTypeSpecStartLoc(),
11003 diag::err_wasm_table_as_function_parameter);
11011 if (
const auto *
attr = NewFD->
getAttr<AvailabilityAttr>()) {
11012 if (NewFD->
hasAttr<ConstructorAttr>()) {
11013 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
11015 NewFD->
dropAttr<AvailabilityAttr>();
11017 if (NewFD->
hasAttr<DestructorAttr>()) {
11018 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
11020 NewFD->
dropAttr<AvailabilityAttr>();
11031 if (
const auto *NBA = NewFD->
getAttr<NoBuiltinAttr>())
11035 Diag(NBA->getLocation(),
11036 diag::err_attribute_no_builtin_on_defaulted_deleted_function)
11037 << NBA->getSpelling();
11040 Diag(NBA->getLocation(), diag::err_attribute_no_builtin_on_non_definition)
11041 << NBA->getSpelling();
11061 const auto *Method = dyn_cast<CXXMethodDecl>(FD);
11065 if (
const auto *SAttr =
Parent->getAttr<CodeSegAttr>()) {
11076 while ((
Parent = dyn_cast<CXXRecordDecl>(
Parent->getParent()))) {
11077 if (
const auto *SAttr =
Parent->getAttr<CodeSegAttr>()) {
11096 bool IsDefinition) {
11099 if (!FD->
hasAttr<SectionAttr>() && IsDefinition &&
11101 return SectionAttr::CreateImplicit(
11103 CodeSegStack.CurrentPragmaLocation, SectionAttr::Declspec_allocate);
11168 auto *VD = dyn_cast<ValueDecl>(D);
11169 auto *PrevVD = dyn_cast<ValueDecl>(PrevDecl);
11170 return !VD || !PrevVD ||
11172 PrevVD->getType());
11180 const auto *TA = FD->
getAttr<TargetAttr>();
11181 const auto *TVA = FD->
getAttr<TargetVersionAttr>();
11184 "MultiVersion candidate requires a target or target_version attribute");
11186 enum ErrType { Feature = 0, Architecture = 1 };
11193 << Architecture << ParseInfo.
CPU;
11196 for (
const auto &Feat : ParseInfo.
Features) {
11197 auto BareFeat = StringRef{Feat}.substr(1);
11198 if (Feat[0] ==
'-') {
11200 << Feature << (
"no-" + BareFeat).str();
11207 << Feature << BareFeat;
11215 TVA->getFeatures(Feats);
11216 for (
const auto &Feat : Feats) {
11219 << Feature << Feat;
11238 case attr::NonNull:
11239 case attr::NoThrow:
11248 const auto Diagnose = [FD, CausedFD, MVKind](
Sema &S,
const Attr *A) {
11249 S.
Diag(FD->
getLocation(), diag::err_multiversion_disallowed_other_attr)
11250 <<
static_cast<unsigned>(MVKind) << A;
11252 S.
Diag(CausedFD->
getLocation(), diag::note_multiversioning_caused_here);
11257 switch (A->getKind()) {
11258 case attr::CPUDispatch:
11259 case attr::CPUSpecific:
11262 return Diagnose(S, A);
11266 return Diagnose(S, A);
11268 case attr::TargetVersion:
11270 return Diagnose(S, A);
11272 case attr::TargetClones:
11274 return Diagnose(S, A);
11278 return Diagnose(S, A);
11291 bool ConstexprSupported,
bool CLinkageMayDiffer) {
11292 enum DoesntSupport {
11299 DefaultedFuncs = 6,
11300 ConstexprFuncs = 7,
11301 ConstevalFuncs = 8,
11313 if (NoProtoDiagID.
getDiagID() != 0 && OldFD &&
11316 Diag(NoteCausedDiagIDAt.first, NoteCausedDiagIDAt.second);
11324 if (!TemplatesSupported &&
11326 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11329 if (
const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) {
11330 if (NewCXXFD->isVirtual())
11331 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11334 if (isa<CXXConstructorDecl>(NewCXXFD))
11335 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11338 if (isa<CXXDestructorDecl>(NewCXXFD))
11339 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11344 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11348 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11352 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11353 << (NewFD->
isConsteval() ? ConstevalFuncs : ConstexprFuncs);
11356 const auto *NewType = cast<FunctionType>(NewQType);
11357 QualType NewReturnType = NewType->getReturnType();
11360 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11366 const auto *OldType = cast<FunctionType>(OldQType);
11370 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC())
11373 QualType OldReturnType = OldType->getReturnType();
11375 if (OldReturnType != NewReturnType)
11376 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ReturnType;
11379 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ConstexprSpec;
11382 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << InlineSpec;
11385 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) <<
Linkage;
11409 bool IsCPUSpecificCPUDispatchMVKind =
11413 if (CausesMV && OldFD &&
11421 if (OldFD && CausesMV && OldFD->
isUsed(
false))
11422 return S.
Diag(NewFD->
getLocation(), diag::err_multiversion_after_used);
11425 OldFD, NewFD, S.
PDiag(diag::err_multiversion_noproto),
11427 S.
PDiag(diag::note_multiversioning_caused_here)),
11429 S.
PDiag(diag::err_multiversion_doesnt_support)
11430 <<
static_cast<unsigned>(MVKind)),
11432 S.
PDiag(diag::err_multiversion_diff)),
11434 !IsCPUSpecificCPUDispatchMVKind,
11447 "Function lacks multiversion attribute");
11448 const auto *TA = FD->
getAttr<TargetAttr>();
11449 const auto *TVA = FD->
getAttr<TargetVersionAttr>();
11452 if ((TA && !TA->isDefaultVersion()) || (TVA && !TVA->isDefaultVersion()))
11480 bool &Redeclaration,
11490 OldFD->
addAttr(TargetVersionAttr::CreateImplicit(S.
Context,
"default",
11493 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11494 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11495 const auto *OldTA = OldFD->
getAttr<TargetAttr>();
11496 const auto *OldTVA = OldFD->
getAttr<TargetVersionAttr>();
11499 if ((NewTA && !NewTA->isDefaultVersion() &&
11500 (!OldTA || OldTA->getFeaturesStr() == NewTA->getFeaturesStr())) ||
11501 (NewTVA && !NewTVA->isDefaultVersion() &&
11502 (!OldTVA || OldTVA->getName() == NewTVA->getName())))
11519 if ((NewTA && NewTA->isDefaultVersion() && !OldTA) ||
11520 (NewTVA && NewTVA->isDefaultVersion() && !OldTVA)) {
11521 Redeclaration =
true;
11529 S.
Diag(NewFD->
getLocation(), diag::note_multiversioning_caused_here);
11537 OldTA->getFeaturesStr());
11541 NewTA->getFeaturesStr());
11544 if (OldParsed == NewParsed) {
11554 OldTVA->getFeatures(Feats);
11557 NewTVA->getFeatures(NewFeats);
11558 llvm::sort(NewFeats);
11560 if (Feats == NewFeats) {
11568 for (
const auto *FD : OldFD->
redecls()) {
11569 const auto *CurTA = FD->
getAttr<TargetAttr>();
11570 const auto *CurTVA = FD->
getAttr<TargetVersionAttr>();
11574 ((NewTA && (!CurTA || CurTA->isInherited())) ||
11575 (NewTVA && (!CurTVA || CurTVA->isInherited())))) {
11577 << (NewTA ? 0 : 2);
11578 S.
Diag(NewFD->
getLocation(), diag::note_multiversioning_caused_here);
11586 Redeclaration =
false;
11609 const CPUSpecificAttr *NewCPUSpec,
const TargetClonesAttr *NewClones,
11611 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11612 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11625 NewTA->getFeaturesStr());
11630 NewTVA->getFeatures(NewFeats);
11631 llvm::sort(NewFeats);
11634 bool UseMemberUsingDeclRules =
11637 bool MayNeedOverloadableChecks =
11646 if (MayNeedOverloadableChecks &&
11647 S.
IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
11652 NewFD->
addAttr(TargetVersionAttr::CreateImplicit(
11657 NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11658 NewTVA->getFeatures(NewFeats);
11659 llvm::sort(NewFeats);
11663 switch (NewMVKind) {
11666 "Only target_clones can be omitted in subsequent declarations");
11669 const auto *CurTA = CurFD->
getAttr<TargetAttr>();
11670 if (CurTA->getFeaturesStr() == NewTA->getFeaturesStr()) {
11672 Redeclaration =
true;
11679 CurTA->getFeaturesStr());
11681 if (CurParsed == NewParsed) {
11690 const auto *CurTVA = CurFD->
getAttr<TargetVersionAttr>();
11691 if (CurTVA->getName() == NewTVA->getName()) {
11693 Redeclaration =
true;
11699 CurTVA->getFeatures(CurFeats);
11700 llvm::sort(CurFeats);
11702 if (CurFeats == NewFeats) {
11711 const auto *CurClones = CurFD->
getAttr<TargetClonesAttr>();
11712 Redeclaration =
true;
11716 if (CurClones && NewClones &&
11717 (CurClones->featuresStrs_size() != NewClones->featuresStrs_size() ||
11718 !std::equal(CurClones->featuresStrs_begin(),
11719 CurClones->featuresStrs_end(),
11720 NewClones->featuresStrs_begin()))) {
11731 const auto *CurCPUSpec = CurFD->
getAttr<CPUSpecificAttr>();
11732 const auto *CurCPUDisp = CurFD->
getAttr<CPUDispatchAttr>();
11737 CurFD->
hasAttr<CPUDispatchAttr>()) {
11738 if (CurCPUDisp->cpus_size() == NewCPUDisp->cpus_size() &&
11740 CurCPUDisp->cpus_begin(), CurCPUDisp->cpus_end(),
11741 NewCPUDisp->cpus_begin(),
11743 return Cur->getName() == New->getName();
11746 Redeclaration =
true;
11758 if (CurCPUSpec->cpus_size() == NewCPUSpec->cpus_size() &&
11760 CurCPUSpec->cpus_begin(), CurCPUSpec->cpus_end(),
11761 NewCPUSpec->cpus_begin(),
11763 return Cur->getName() == New->getName();
11766 Redeclaration =
true;
11774 if (CurII == NewII) {
11809 Redeclaration =
true;
11815 Redeclaration =
false;
11828 bool &Redeclaration,
NamedDecl *&OldDecl,
11830 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11831 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11832 const auto *NewCPUDisp = NewFD->
getAttr<CPUDispatchAttr>();
11833 const auto *NewCPUSpec = NewFD->
getAttr<CPUSpecificAttr>();
11834 const auto *NewClones = NewFD->
getAttr<TargetClonesAttr>();
11844 NewTVA->isDefaultVersion())) {
11845 S.
Diag(NewFD->
getLocation(), diag::err_multiversion_not_allowed_on_main);
11869 if (NewTVA || !OldFD->
getAttr<TargetVersionAttr>())
11877 NewFD->
addAttr(TargetVersionAttr::CreateImplicit(
11882 Redeclaration =
true;
11892 S.
Diag(NewFD->
getLocation(), diag::err_multiversion_required_in_redecl)
11905 if (OldFD->
isUsed(
false)) {
11907 return S.
Diag(NewFD->
getLocation(), diag::err_multiversion_after_used);
11923 NewCPUSpec, NewClones, Redeclaration,
11928 bool IsPure = NewFD->
hasAttr<PureAttr>();
11929 bool IsConst = NewFD->
hasAttr<ConstAttr>();
11932 if (!IsPure && !IsConst)
11939 if (IsPure && IsConst) {
11949 NewFD->
dropAttrs<PureAttr, ConstAttr>();
11972 bool IsMemberSpecialization,
11975 "Variably modified return types are not handled here");
11980 bool MergeTypeWithPrevious = !
getLangOpts().CPlusPlus &&
11983 bool Redeclaration =
false;
11985 bool MayNeedOverloadableChecks =
false;
11996 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
11997 Redeclaration =
true;
11998 OldDecl = Candidate;
12001 MayNeedOverloadableChecks =
true;
12005 Redeclaration =
true;
12009 Redeclaration =
true;
12013 Redeclaration =
false;
12020 if (!Redeclaration &&
12025 Redeclaration =
true;
12026 OldDecl =
Previous.getFoundDecl();
12027 MergeTypeWithPrevious =
false;
12030 if (OldDecl->
hasAttr<OverloadableAttr>() ||
12031 NewFD->
hasAttr<OverloadableAttr>()) {
12032 if (
IsOverload(NewFD, cast<FunctionDecl>(OldDecl),
false)) {
12033 MayNeedOverloadableChecks =
true;
12034 Redeclaration =
false;
12042 return Redeclaration;
12063 !MD->
isStatic() && !isa<CXXConstructorDecl>(MD) &&
12067 OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->
getAsFunction());
12068 if (!OldMD || !OldMD->
isStatic()) {
12090 if (Redeclaration) {
12096 return Redeclaration;
12103 dyn_cast<FunctionTemplateDecl>(OldDecl)) {
12104 auto *OldFD = OldTemplateDecl->getTemplatedDecl();
12107 assert(NewTemplateDecl &&
"Template/non-template mismatch");
12116 NewFD->
setAccess(OldTemplateDecl->getAccess());
12117 NewTemplateDecl->
setAccess(OldTemplateDecl->getAccess());
12122 if (IsMemberSpecialization &&
12125 assert(OldTemplateDecl->isMemberSpecialization());
12128 if (OldFD->isDeleted()) {
12130 assert(OldFD->getCanonicalDecl() == OldFD);
12132 OldFD->setDeletedAsWritten(
false);
12138 auto *OldFD = cast<FunctionDecl>(OldDecl);
12146 !NewFD->
getAttr<OverloadableAttr>()) {
12150 return ND->hasAttr<OverloadableAttr>();
12152 "Non-redecls shouldn't happen without overloadable present");
12155 const auto *FD = dyn_cast<FunctionDecl>(ND);
12156 return FD && !FD->
hasAttr<OverloadableAttr>();
12159 if (OtherUnmarkedIter !=
Previous.end()) {
12161 diag::err_attribute_overloadable_multiple_unmarked_overloads);
12162 Diag((*OtherUnmarkedIter)->getLocation(),
12163 diag::note_attribute_overloadable_prev_overload)
12180 dyn_cast<CXXDestructorDecl>(NewFD)) {
12188 !Destructor->getFunctionObjectParameterType()->isDependentType()) {
12197 return Redeclaration;
12200 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(NewFD)) {
12201 if (
auto *TD = Guide->getDescribedFunctionTemplate())
12207 Diag(Guide->getBeginLoc(), diag::err_deduction_guide_specialized)
12212 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
12213 if (!Method->isFunctionTemplateSpecialization() &&
12214 !Method->getDescribedFunctionTemplate() &&
12215 Method->isCanonicalDecl()) {
12222 diag::err_constrained_virtual_method);
12224 if (Method->isStatic())
12235 return Redeclaration;
12242 return Redeclaration;
12262 Diag(NewFD->
getLocation(), diag::warn_return_value_udt) << NewFD << R;
12275 auto HasNoexcept = [&](
QualType T) ->
bool {
12281 else if (T->isAnyPointerType())
12286 if (FPT->isNothrow())
12292 bool AnyNoexcept = HasNoexcept(FPT->getReturnType());
12293 for (
QualType T : FPT->param_types())
12294 AnyNoexcept |= HasNoexcept(T);
12297 diag::warn_cxx17_compat_exception_spec_in_signature)
12301 if (!Redeclaration &&
LangOpts.CUDA)
12309 bool UsesSM = NewFD->
hasAttr<ArmLocallyStreamingAttr>();
12310 bool UsesZA =
Attr &&
Attr->isNewZA();
12311 bool UsesZT0 =
Attr &&
Attr->isNewZT0();
12322 if (UsesSM || UsesZA) {
12323 llvm::StringMap<bool> FeatureMap;
12325 if (!FeatureMap.contains(
"sme")) {
12328 diag::err_sme_definition_using_sm_in_non_sme_target);
12331 diag::err_sme_definition_using_za_in_non_sme_target);
12335 llvm::StringMap<bool> FeatureMap;
12337 if (!FeatureMap.contains(
"sme2")) {
12339 diag::err_sme_definition_using_zt0_in_non_sme2_target);
12344 return Redeclaration;
12357 ? diag::err_static_main : diag::warn_static_main)
12365 Diag(NoreturnLoc, diag::ext_noreturn_main);
12366 Diag(NoreturnLoc, diag::note_main_remove_noreturn)
12378 << FD->
hasAttr<OpenCLKernelAttr>();
12389 assert(T->
isFunctionType() &&
"function decl is not of function type");
12411 Diag(RTRange.
getBegin(), diag::note_main_change_return_type)
12433 if (isa<FunctionNoProtoType>(FT))
return;
12439 bool HasExtraParameters = (nparams > 3);
12451 HasExtraParameters =
false;
12453 if (HasExtraParameters) {
12466 for (
unsigned i = 0; i < nparams; ++i) {
12469 bool mismatch =
true;
12486 mismatch = !qs.
empty();
12515 if (T.isWindowsGNUEnvironment())
12520 if (T.isOSWindows() && T.getArch() == llvm::Triple::x86)
12528 assert(T->
isFunctionType() &&
"function decl is not of function type");
12537 if (FD->
getName() !=
"DllMain")
12568 HLSLShaderAttr::ShaderType ShaderType;
12569 if (HLSLShaderAttr::ConvertStrToShaderType(
Env, ShaderType)) {
12570 if (
const auto *Shader = FD->
getAttr<HLSLShaderAttr>()) {
12573 if (Shader->getType() != ShaderType) {
12574 Diag(Shader->getLocation(), diag::err_hlsl_entry_shader_attr_mismatch)
12586 case llvm::Triple::UnknownEnvironment:
12587 case llvm::Triple::Library:
12590 llvm_unreachable(
"Unhandled environment in triple");
12596 const auto *ShaderAttr = FD->
getAttr<HLSLShaderAttr>();
12597 assert(ShaderAttr &&
"Entry point has no shader attribute");
12598 HLSLShaderAttr::ShaderType ST = ShaderAttr->getType();
12601 case HLSLShaderAttr::Pixel:
12602 case HLSLShaderAttr::Vertex:
12603 case HLSLShaderAttr::Geometry:
12604 case HLSLShaderAttr::Hull:
12605 case HLSLShaderAttr::Domain:
12606 case HLSLShaderAttr::RayGeneration:
12607 case HLSLShaderAttr::Intersection:
12608 case HLSLShaderAttr::AnyHit:
12609 case HLSLShaderAttr::ClosestHit:
12610 case HLSLShaderAttr::Miss:
12611 case HLSLShaderAttr::Callable:
12612 if (
const auto *NT = FD->
getAttr<HLSLNumThreadsAttr>()) {
12614 {HLSLShaderAttr::Compute,
12615 HLSLShaderAttr::Amplification,
12616 HLSLShaderAttr::Mesh});
12621 case HLSLShaderAttr::Compute:
12622 case HLSLShaderAttr::Amplification:
12623 case HLSLShaderAttr::Mesh:
12624 if (!FD->
hasAttr<HLSLNumThreadsAttr>()) {
12626 << HLSLShaderAttr::ConvertShaderTypeToStr(ST);
12639 Diag(Param->getLocation(), diag::note_previous_decl) << Param;
12649 auto *ShaderAttr = EntryPoint->
getAttr<HLSLShaderAttr>();
12650 assert(ShaderAttr &&
"Entry point has no shader attribute");
12651 HLSLShaderAttr::ShaderType ST = ShaderAttr->getType();
12653 switch (AnnotationAttr->
getKind()) {
12654 case attr::HLSLSV_DispatchThreadID:
12655 case attr::HLSLSV_GroupIndex:
12656 if (ST == HLSLShaderAttr::Compute)
12659 {HLSLShaderAttr::Compute});
12662 llvm_unreachable(
"Unknown HLSLAnnotationAttr");
12667 const Attr *A, HLSLShaderAttr::ShaderType Stage,
12668 std::initializer_list<HLSLShaderAttr::ShaderType> AllowedStages) {
12670 llvm::transform(AllowedStages, std::back_inserter(StageStrings),
12671 [](HLSLShaderAttr::ShaderType ST) {
12673 HLSLShaderAttr::ConvertShaderTypeToStr(ST));
12675 Diag(A->
getLoc(), diag::err_hlsl_attr_unsupported_in_stage)
12676 << A << HLSLShaderAttr::ConvertShaderTypeToStr(Stage)
12677 << (AllowedStages.size() != 1) << join(StageStrings,
", ");
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))
12698 Diag(Culprit->
getExprLoc(), diag::err_init_element_not_constant)
12706 class SelfReferenceChecker
12712 bool isReferenceType;
12720 SelfReferenceChecker(
Sema &S,
Decl *OrigDecl) : Inherited(S.Context),
12721 S(S), OrigDecl(OrigDecl) {
12724 isReferenceType =
false;
12725 isInitList =
false;
12726 if (
ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
12727 isPODType = VD->getType().isPODType(S.
Context);
12729 isReferenceType = VD->getType()->isReferenceType();
12736 void CheckExpr(
Expr *E) {
12745 InitFieldIndex.push_back(0);
12746 for (
auto *Child : InitList->
children()) {
12747 CheckExpr(cast<Expr>(Child));
12748 ++InitFieldIndex.back();
12750 InitFieldIndex.pop_back();
12755 bool CheckInitListMemberExpr(
MemberExpr *E,
bool CheckReference) {
12758 bool ReferenceField =
false;
12762 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
12765 Fields.push_back(FD);
12767 ReferenceField =
true;
12768 Base = ME->getBase()->IgnoreParenImpCasts();
12773 if (!DRE || DRE->
getDecl() != OrigDecl)
12777 if (CheckReference && !ReferenceField)
12782 for (
const FieldDecl *I : llvm::reverse(Fields))
12783 UsedFieldIndex.push_back(I->getFieldIndex());
12788 for (
auto UsedIter = UsedFieldIndex.begin(),
12789 UsedEnd = UsedFieldIndex.end(),
12790 OrigIter = InitFieldIndex.begin(),
12791 OrigEnd = InitFieldIndex.end();
12792 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
12793 if (*UsedIter < *OrigIter)
12795 if (*UsedIter > *OrigIter)
12800 HandleDeclRefExpr(DRE);
12807 void HandleValue(
Expr *E) {
12809 if (
DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
12810 HandleDeclRefExpr(DRE);
12815 Visit(CO->getCond());
12816 HandleValue(CO->getTrueExpr());
12817 HandleValue(CO->getFalseExpr());
12822 dyn_cast<BinaryConditionalOperator>(E)) {
12823 Visit(BCO->getCond());
12824 HandleValue(BCO->getFalseExpr());
12829 if (
Expr *SE = OVE->getSourceExpr())
12835 if (BO->getOpcode() == BO_Comma) {
12836 Visit(BO->getLHS());
12837 HandleValue(BO->getRHS());
12842 if (isa<MemberExpr>(E)) {
12844 if (CheckInitListMemberExpr(cast<MemberExpr>(E),
12852 if (!isa<FieldDecl>(ME->getMemberDecl()))
12854 Base = ME->getBase()->IgnoreParenImpCasts();
12857 HandleDeclRefExpr(DRE);
12867 if (isReferenceType)
12868 HandleDeclRefExpr(E);
12877 Inherited::VisitImplicitCastExpr(E);
12882 if (CheckInitListMemberExpr(E,
true ))
12892 bool Warn = (MD && !MD->
isStatic());
12895 if (!isa<FieldDecl>(ME->getMemberDecl()))
12897 Base = ME->getBase()->IgnoreParenImpCasts();
12902 HandleDeclRefExpr(DRE);
12914 if (isa<UnresolvedLookupExpr>(Callee))
12915 return Inherited::VisitCXXOperatorCallExpr(E);
12919 HandleValue(Arg->IgnoreParenImpCasts());
12936 Inherited::VisitUnaryOperator(E);
12944 if (
InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
12945 if (ILE->getNumInits() == 1)
12946 ArgExpr = ILE->getInit(0);
12948 if (ICE->getCastKind() == CK_NoOp)
12949 ArgExpr = ICE->getSubExpr();
12950 HandleValue(ArgExpr);
12953 Inherited::VisitCXXConstructExpr(E);
12959 HandleValue(E->
getArg(0));
12963 Inherited::VisitCallExpr(E);
12968 HandleValue(E->
getLHS());
12973 Inherited::VisitBinaryOperator(E);
12986 if (OrigDecl != ReferenceDecl)
return;
12988 if (isReferenceType) {
12989 diag = diag::warn_uninit_self_reference_in_reference_init;
12990 }
else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
12991 diag = diag::warn_static_self_reference_in_init;
12992 }
else if (isa<TranslationUnitDecl>(OrigDecl->
getDeclContext()) ||
12995 diag = diag::warn_uninit_self_reference_in_init;
13009 static void CheckSelfReference(
Sema &S,
Decl* OrigDecl,
Expr *E,
13013 if (isa<ParmVarDecl>(OrigDecl))
13022 if (ICE->getCastKind() == CK_LValueToRValue)
13023 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
13024 if (DRE->
getDecl() == OrigDecl)
13027 SelfReferenceChecker(S, OrigDecl).CheckExpr(E);
13034 struct VarDeclOrName {
13040 return VN.VDecl ?
Diag << VN.VDecl :
Diag << VN.Name;
13050 bool IsInitCapture = !VDecl;
13052 "init captures are expected to be deduced prior to initialization");
13054 VarDeclOrName VN{VDecl, Name};
13057 assert(Deduced &&
"deduceVarTypeFromInitializer for non-deduced type");
13061 !isa_and_present<StringLiteral, InitListExpr>(
Init)) {
13062 Diag(Range.getBegin(), diag::err_auto_not_allowed)
13070 assert(VDecl &&
"no init for init capture deduction?");
13074 if (!isa<DeducedTemplateSpecializationType>(Deduced) ||
13085 DeduceInits =
Init;
13087 auto *PL = dyn_cast_if_present<ParenListExpr>(
Init);
13089 DeduceInits = PL->exprs();
13091 if (isa<DeducedTemplateSpecializationType>(Deduced)) {
13092 assert(VDecl &&
"non-auto type for init capture deduction?");
13103 if (
auto *IL = dyn_cast<InitListExpr>(
Init))
13104 DeduceInits = IL->inits();
13108 if (DeduceInits.empty()) {
13111 Diag(
Init->getBeginLoc(), IsInitCapture
13112 ? diag::err_init_capture_no_expression
13113 : diag::err_auto_var_init_no_expression)
13114 << VN <<
Type << Range;
13118 if (DeduceInits.size() > 1) {
13119 Diag(DeduceInits[1]->getBeginLoc(),
13120 IsInitCapture ? diag::err_init_capture_multiple_expressions
13121 : diag::err_auto_var_init_multiple_expressions)
13122 << VN <<
Type << Range;
13126 Expr *DeduceInit = DeduceInits[0];
13127 if (
DirectInit && isa<InitListExpr>(DeduceInit)) {
13128 Diag(
Init->getBeginLoc(), IsInitCapture
13129 ? diag::err_init_capture_paren_braces
13130 : diag::err_auto_var_init_paren_braces)
13131 << isa<InitListExpr>(
Init) << VN <<
Type << Range;
13136 bool DefaultedAnyToId =
false;
13140 if (
Result.isInvalid()) {
13144 DefaultedAnyToId =
true;
13150 if (VDecl && isa<DecompositionDecl>(VDecl) &&
13154 Type.getQualifiers());
13162 if (!IsInitCapture)
13164 else if (isa<InitListExpr>(
Init))
13165 Diag(Range.getBegin(),
13166 diag::err_init_capture_deduction_failure_from_init_list)
13172 Diag(Range.getBegin(), diag::err_init_capture_deduction_failure)
13187 Diag(Loc, diag::warn_auto_var_is_id) << VN << Range;
13195 assert(!
Init || !
Init->containsErrors());
13229 if (
auto *EWC = dyn_cast<ExprWithCleanups>(
Init))
13230 Init = EWC->getSubExpr();
13232 if (
auto *CE = dyn_cast<ConstantExpr>(
Init))
13233 Init = CE->getSubExpr();
13238 "shouldn't be called if type doesn't have a non-trivial C struct");
13239 if (
auto *ILE = dyn_cast<InitListExpr>(
Init)) {
13240 for (
auto *I : ILE->inits()) {
13241 if (!I->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion() &&
13242 !I->getType().hasNonTrivialToPrimitiveCopyCUnion())
13250 if (isa<ImplicitValueInitExpr>(
Init)) {
13266bool shouldIgnoreForRecordTriviality(
const FieldDecl *FD) {
13272 return FD->
hasAttr<UnavailableAttr>();
13275struct DiagNonTrivalCUnionDefaultInitializeVisitor
13282 DiagNonTrivalCUnionDefaultInitializeVisitor(
13285 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13288 const FieldDecl *FD,
bool InNonTrivialUnion) {
13291 InNonTrivialUnion);
13292 return Super::visitWithKind(PDIK, QT, FD, InNonTrivialUnion);
13296 bool InNonTrivialUnion) {
13297 if (InNonTrivialUnion)
13299 << 1 << 0 << QT << FD->
getName();
13303 if (InNonTrivialUnion)
13305 << 1 << 0 << QT << FD->
getName();
13311 if (OrigLoc.isValid()) {
13312 bool IsUnion =
false;
13313 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13314 IsUnion = OrigRD->isUnion();
13315 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13316 << 0 << OrigTy << IsUnion << UseContext;
13320 InNonTrivialUnion =
true;
13323 if (InNonTrivialUnion)
13328 if (!shouldIgnoreForRecordTriviality(FD))
13329 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13342struct DiagNonTrivalCUnionDestructedTypeVisitor
13347 DiagNonTrivalCUnionDestructedTypeVisitor(
13350 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13353 const FieldDecl *FD,
bool InNonTrivialUnion) {
13356 InNonTrivialUnion);
13357 return Super::visitWithKind(DK, QT, FD, InNonTrivialUnion);
13361 bool InNonTrivialUnion) {
13362 if (InNonTrivialUnion)
13364 << 1 << 1 << QT << FD->
getName();
13368 if (InNonTrivialUnion)
13370 << 1 << 1 << QT << FD->
getName();
13376 if (OrigLoc.isValid()) {
13377 bool IsUnion =
false;
13378 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13379 IsUnion = OrigRD->isUnion();
13380 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13381 << 1 << OrigTy << IsUnion << UseContext;
13385 InNonTrivialUnion =
true;
13388 if (InNonTrivialUnion)
13393 if (!shouldIgnoreForRecordTriviality(FD))
13394 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13399 bool InNonTrivialUnion) {}
13409struct DiagNonTrivalCUnionCopyVisitor
13416 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13419 const FieldDecl *FD,
bool InNonTrivialUnion) {
13422 InNonTrivialUnion);
13423 return Super::visitWithKind(PCK, QT, FD, InNonTrivialUnion);
13427 bool InNonTrivialUnion) {
13428 if (InNonTrivialUnion)
13430 << 1 << 2 << QT << FD->
getName();
13434 if (InNonTrivialUnion)
13436 << 1 << 2 << QT << FD->
getName();
13442 if (OrigLoc.isValid()) {
13443 bool IsUnion =
false;
13444 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13445 IsUnion = OrigRD->isUnion();
13446 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13447 << 2 << OrigTy << IsUnion << UseContext;
13451 InNonTrivialUnion =
true;
13454 if (InNonTrivialUnion)
13459 if (!shouldIgnoreForRecordTriviality(FD))
13460 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13464 const FieldDecl *FD,
bool InNonTrivialUnion) {}
13467 bool InNonTrivialUnion) {}
13481 unsigned NonTrivialKind) {
13485 "shouldn't be called if type doesn't have a non-trivial C union");
13489 DiagNonTrivalCUnionDefaultInitializeVisitor(QT, Loc, UseContext, *
this)
13490 .
visit(QT,
nullptr,
false);
13493 DiagNonTrivalCUnionDestructedTypeVisitor(QT, Loc, UseContext, *
this)
13494 .visit(QT,
nullptr,
false);
13496 DiagNonTrivalCUnionCopyVisitor(QT, Loc, UseContext, *
this)
13497 .visit(QT,
nullptr,
false);
13511 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
13513 Diag(Method->getLocation(), diag::err_member_function_initialization)
13514 << Method->getDeclName() <<
Init->getSourceRange();
13515 Method->setInvalidDecl();
13519 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
13521 assert(!isa<FieldDecl>(RealDecl) &&
"field init shouldn't get here");
13528 if (
Init && !
Init->getType().isNull() &&
13529 Init->getType()->isWebAssemblyTableType()) {
13530 Diag(
Init->getExprLoc(), diag::err_wasm_table_art) << 0;
13561 Diag(VDecl->
getLocation(), diag::err_attribute_dllimport_data_definition);
13582 BaseDeclType = Array->getElementType();
13584 diag::err_typecheck_decl_incomplete_type)) {
13591 diag::err_abstract_type_in_decl,
13601 !VDecl->
isTemplated() && !isa<VarTemplateSpecializationDecl>(VDecl)) {
13610 if (Def != VDecl &&
13630 Diag(
Init->getExprLoc(), diag::err_static_data_member_reinitialization)
13633 diag::note_previous_initializer)
13656 if (VDecl->
hasAttr<LoaderUninitializedAttr>()) {
13657 Diag(VDecl->
getLocation(), diag::err_loader_uninitialized_cant_init);
13671 if (
Result.isInvalid()) {
13680 bool IsParenListInit =
false;
13692 for (
size_t Idx = 0; Idx < Args.size(); ++Idx) {
13694 Args[Idx], VDecl,
true,
13695 [
this, Entity, Kind](
Expr *E) {
13701 }
else if (Res.
get() != Args[Idx]) {
13702 Args[Idx] = Res.
get();
13712 if (
Result.isInvalid()) {
13726 if (isa<DecompositionDecl>(VDecl))
13732 IsParenListInit = !InitSeq.
steps().empty() &&
13736 if (
Init && !
Init->getType().isNull() &&
13768 if (VDecl->
hasAttr<BlocksAttr>())
13782 Init->getBeginLoc()))
13783 FSI->markSafeWeakUse(
Init);
13800 if (
Result.isInvalid()) {
13833 isa<InitListExpr>(
Init)) {
13834 const Expr *Culprit;
13835 if (!
Init->isConstantInitializer(
Context,
false, &Culprit)) {
13837 diag::ext_aggregate_init_not_constant)
13842 if (
auto *E = dyn_cast<ExprWithCleanups>(
Init))
13843 if (
auto *BE = dyn_cast<BlockExpr>(E->getSubExpr()->
IgnoreParens()))
13845 BE->getBlockDecl()->setCanAvoidCopyToHeap();
13880 <<
Init->getSourceRange();
13891 else if (
Init->isValueDependent())
13893 else if (
Init->isIntegerConstantExpr(
Context, &Loc))
13895 else if (
Init->getType()->isScopedEnumeralType() &&
13901 Diag(Loc, diag::ext_in_class_initializer_non_constant)
13902 <<
Init->getSourceRange();
13906 Diag(Loc, diag::err_in_class_initializer_non_constant)
13907 <<
Init->getSourceRange();
13917 diag::ext_in_class_initializer_float_type_cxx11)
13918 << DclT <<
Init->getSourceRange();
13920 diag::note_in_class_initializer_float_type_cxx11)
13923 Diag(VDecl->
getLocation(), diag::ext_in_class_initializer_float_type)
13924 << DclT <<
Init->getSourceRange();
13927 Diag(
Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
13928 <<
Init->getSourceRange();
13935 Diag(VDecl->
getLocation(), diag::err_in_class_initializer_literal_type)
13936 << DclT <<
Init->getSourceRange()
13942 << DclT <<
Init->getSourceRange();
13976 if (!InitType.
isNull() &&
13995 if (CXXDirectInit) {
13996 assert(
DirectInit &&
"Call-style initializer must be direct init.");
14007 DeclsToCheckForDeferredDiags.insert(VDecl);
14020 VarDecl *VD = dyn_cast<VarDecl>(D);
14024 if (
auto *DD = dyn_cast<DecompositionDecl>(D))
14025 for (
auto *BD : DD->bindings())
14026 BD->setInvalidDecl();
14040 diag::err_typecheck_decl_incomplete_type)) {
14047 diag::err_abstract_type_in_decl,
14062 if (
VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
14066 if (isa<DecompositionDecl>(RealDecl)) {
14067 Diag(Var->getLocation(), diag::err_decomp_decl_requires_init) << Var;
14068 Var->setInvalidDecl();
14082 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition() &&
14083 !Var->isThisDeclarationADemotedDefinition()) {
14084 if (Var->isStaticDataMember()) {
14089 Diag(Var->getLocation(),
14090 diag::err_constexpr_static_mem_var_requires_init)
14092 Var->setInvalidDecl();
14096 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
14097 Var->setInvalidDecl();
14104 if (!Var->isInvalidDecl() &&
14106 Var->getStorageClass() !=
SC_Extern && !Var->getInit()) {
14107 bool HasConstExprDefaultConstructor =
false;
14108 if (
CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
14109 for (
auto *Ctor : RD->ctors()) {
14110 if (Ctor->isConstexpr() && Ctor->getNumParams() == 0 &&
14111 Ctor->getMethodQualifiers().getAddressSpace() ==
14113 HasConstExprDefaultConstructor =
true;
14117 if (!HasConstExprDefaultConstructor) {
14118 Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
14119 Var->setInvalidDecl();
14124 if (!Var->isInvalidDecl() && RealDecl->
hasAttr<LoaderUninitializedAttr>()) {
14125 if (Var->getStorageClass() ==
SC_Extern) {
14126 Diag(Var->getLocation(), diag::err_loader_uninitialized_extern_decl)
14128 Var->setInvalidDecl();
14132 diag::err_typecheck_decl_incomplete_type)) {
14133 Var->setInvalidDecl();
14136 if (
CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
14137 if (!RD->hasTrivialDefaultConstructor()) {
14138 Diag(Var->getLocation(), diag::err_loader_uninitialized_trivial_ctor);
14139 Var->setInvalidDecl();
14149 Var->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion())
14156 if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
14172 !Var->hasLinkage() && !Var->isInvalidDecl() &&
14174 diag::err_typecheck_decl_incomplete_type))
14175 Var->setInvalidDecl();
14180 diag::err_abstract_type_in_decl,
14182 Var->setInvalidDecl();
14185 Diag(Var->getLocation(), diag::warn_private_extern);
14186 Diag(Var->getLocation(), diag::note_private_extern);
14190 !Var->isInvalidDecl())
14201 if (!Var->isInvalidDecl()) {
14205 Var->getLocation(), ArrayT->getElementType(),
14206 diag::err_array_incomplete_or_sizeless_type))
14207 Var->setInvalidDecl();
14208 }
else if (Var->getStorageClass() ==
SC_Static) {
14218 if (Var->isFirstDecl())
14220 diag::ext_typecheck_decl_incomplete_type);
14225 if (!Var->isInvalidDecl())
14233 if (Var->isConstexpr())
14234 Diag(Var->getLocation(), diag::err_constexpr_var_requires_const_init)
14237 Diag(Var->getLocation(),
14238 diag::err_typecheck_incomplete_array_needs_initializer);
14239 Var->setInvalidDecl();
14246 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
14247 << Var <<
SourceRange(Var->getLocation(), Var->getLocation());
14256 if (Var->isInvalidDecl())
14259 if (!Var->hasAttr<AliasAttr>()) {
14262 diag::err_typecheck_decl_incomplete_type)) {
14263 Var->setInvalidDecl();
14272 diag::err_abstract_type_in_decl,
14274 Var->setInvalidDecl();
14295 if (!CXXRecord->isPOD())
14329 }
else if (
Init.isInvalid()) {
14347 VarDecl *VD = dyn_cast<VarDecl>(D);
14406 const char *PrevSpec;
14418 cast<VarDecl>(Var)->setCXXForRangeDecl(
true);
14473 !isa<VarTemplatePartialSpecializationDecl>(var) &&
14475 !
getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
14483 Diag(var->
getLocation(), diag::warn_missing_variable_declarations) << var;
14490 std::optional<bool> CacheHasConstInit;
14491 const Expr *CacheCulprit =
nullptr;
14492 auto checkConstInit = [&]()
mutable {
14493 if (!CacheHasConstInit)
14496 return *CacheHasConstInit;
14508 if (!checkConstInit()) {
14523 isa<InitListExpr>(var->
getInit())) {
14524 const auto *ILE = cast<InitListExpr>(var->
getInit());
14525 unsigned NumInits = ILE->getNumInits();
14527 for (
unsigned I = 0; I < NumInits; ++I) {
14528 const auto *
Init = ILE->getInit(I);
14531 const auto *SL = dyn_cast<StringLiteral>(
Init->IgnoreImpCasts());
14535 unsigned NumConcat = SL->getNumConcatenated();
14539 if (NumConcat == 2 && !SL->getBeginLoc().isMacroID()) {
14540 bool OnlyOneMissingComma =
true;
14541 for (
unsigned J = I + 1; J < NumInits; ++J) {
14542 const auto *
Init = ILE->getInit(J);
14545 const auto *SLJ = dyn_cast<StringLiteral>(
Init->IgnoreImpCasts());
14546 if (!SLJ || SLJ->getNumConcatenated() > 1) {
14547 OnlyOneMissingComma =
false;
14552 if (OnlyOneMissingComma) {
14554 for (
unsigned i = 0; i < NumConcat - 1; ++i)
14558 Diag(SL->getStrTokenLoc(1),
14559 diag::warn_concatenated_literal_array_init)
14561 Diag(SL->getBeginLoc(),
14562 diag::note_concatenated_string_literal_silence);
14573 if (var->
hasAttr<BlocksAttr>())
14580 bool HasConstInit =
true;
14583 Diag(var->
getLocation(), diag::err_constexpr_var_requires_const_init)
14588 !
type->isDependentType() &&
Init && !
Init->isValueDependent() &&
14602 HasConstInit = checkConstInit();
14606 if (HasConstInit) {
14609 }
else if (CacheCulprit) {
14610 Notes.emplace_back(CacheCulprit->
getExprLoc(),
14611 PDiag(diag::note_invalid_subexpr_in_const_expr));
14619 if (HasConstInit) {
14625 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
14626 diag::note_invalid_subexpr_in_const_expr) {
14627 DiagLoc = Notes[0].first;
14630 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
14631 << var <<
Init->getSourceRange();
14632 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
14633 Diag(Notes[I].first, Notes[I].second);
14634 }
else if (GlobalStorage && var->
hasAttr<ConstInitAttr>()) {
14637 <<
Init->getSourceRange();
14640 for (
auto &it : Notes)
14641 Diag(it.first, it.second);
14642 }
else if (IsGlobal &&
14653 if (!checkConstInit())
14655 <<
Init->getSourceRange();
14667 std::optional<QualType::NonConstantStorageReason> Reason;
14668 if (HasConstInit &&
14675 if (
const SectionAttr *SA = var->
getAttr<SectionAttr>()) {
14679 }
else if (Stack->CurrentValue) {
14684 NonConstNonReferenceType) &&
14685 "This case should've already been handled elsewhere");
14692 auto SectionName = Stack->CurrentValue->getString();
14694 Stack->CurrentPragmaLocation,
14695 SectionAttr::Declspec_allocate));
14718 if (!
type->isDependentType())
14728 if (
auto *DD = dyn_cast<DecompositionDecl>(var))
14741 !FD->
hasAttr<DLLExportStaticLocalAttr>() &&
14742 !FD->
hasAttr<DLLImportStaticLocalAttr>()) {
14751 auto *NewAttr = cast<InheritableAttr>(A->clone(
getASTContext()));
14752 NewAttr->setInherited(
true);
14754 }
else if (
Attr *A = FD->
getAttr<DLLExportStaticLocalAttr>()) {
14755 auto *NewAttr = DLLExportAttr::CreateImplicit(
getASTContext(), *A);
14756 NewAttr->setInherited(
true);
14761 if (!FD->
hasAttr<DLLExportAttr>())
14764 }
else if (
Attr *A = FD->
getAttr<DLLImportStaticLocalAttr>()) {
14765 auto *NewAttr = DLLImportAttr::CreateImplicit(
getASTContext(), *A);
14766 NewAttr->setInherited(
true);
14797 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
14805 VD->
addAttr(PragmaClangBSSSectionAttr::CreateImplicit(
14809 VD->
addAttr(PragmaClangDataSectionAttr::CreateImplicit(
14813 VD->
addAttr(PragmaClangRodataSectionAttr::CreateImplicit(
14817 VD->
addAttr(PragmaClangRelroSectionAttr::CreateImplicit(
14822 if (
auto *DD = dyn_cast<DecompositionDecl>(ThisDecl)) {
14823 for (
auto *BD : DD->bindings()) {
14848 if (
const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
14855 bool IsClassTemplateMember =
14856 isa<ClassTemplatePartialSpecializationDecl>(
Context) ||
14857 Context->getDescribedClassTemplate();
14860 IsClassTemplateMember
14861 ? diag::warn_attribute_dllimport_static_field_definition
14862 : diag::err_attribute_dllimport_static_field_definition);
14863 Diag(IA->getLocation(), diag::note_attribute);
14864 if (!IsClassTemplateMember)
14892 if (RetainAttr *
Attr = VD->
getAttr<RetainAttr>()) {
14907 if (VD->
isFileVarDecl() && !isa<VarTemplatePartialSpecializationDecl>(VD))
14912 if (!VD->
hasAttr<TypeTagForDatatypeAttr>() ||
14916 for (
const auto *I : ThisDecl->
specific_attrs<TypeTagForDatatypeAttr>()) {
14918 if (!MagicValueExpr) {
14921 std::optional<llvm::APSInt> MagicValueInt;
14923 Diag(I->getRange().getBegin(),
14924 diag::err_type_tag_for_datatype_not_ice)
14928 if (MagicValueInt->getActiveBits() > 64) {
14929 Diag(I->getRange().getBegin(),
14930 diag::err_type_tag_for_datatype_too_large)
14934 uint64_t MagicValue = MagicValueInt->getZExtValue();
14937 I->getMatchingCType(),
14938 I->getLayoutCompatible(),
14939 I->getMustBeNull());
14944 auto *VD = dyn_cast<VarDecl>(DD);
14945 return VD && !VD->getType()->hasAutoForTrailingReturnType();
14957 bool DiagnosedMultipleDecomps =
false;
14959 bool DiagnosedNonDeducedAuto =
false;
14961 for (
unsigned i = 0, e = Group.size(); i != e; ++i) {
14962 if (
Decl *D = Group[i]) {
14965 if (
auto *VD = dyn_cast<VarDecl>(D);
14966 LangOpts.OpenMP && VD && VD->hasAttr<OMPDeclareTargetDeclAttr>() &&
14967 VD->hasGlobalStorage())
14971 if (
auto *DD = dyn_cast<DeclaratorDecl>(D)) {
14972 if (!FirstDeclaratorInGroup)
14973 FirstDeclaratorInGroup = DD;
14974 if (!FirstDecompDeclaratorInGroup)
14975 FirstDecompDeclaratorInGroup = dyn_cast<DecompositionDecl>(D);
14978 FirstNonDeducedAutoInGroup = DD;
14980 if (FirstDeclaratorInGroup != DD) {
14983 if (FirstDecompDeclaratorInGroup && !DiagnosedMultipleDecomps) {
14985 diag::err_decomp_decl_not_alone)
14987 << DD->getSourceRange();
14988 DiagnosedMultipleDecomps =
true;
14994 if (FirstNonDeducedAutoInGroup && !DiagnosedNonDeducedAuto) {
14996 diag::err_auto_non_deduced_not_alone)
14997 << FirstNonDeducedAutoInGroup->
getType()
15000 << DD->getSourceRange();
15001 DiagnosedNonDeducedAuto =
true;
15006 Decls.push_back(D);
15013 if (FirstDeclaratorInGroup && !Tag->hasNameForLinkage() &&
15029 if (Group.size() > 1) {
15031 VarDecl *DeducedDecl =
nullptr;
15032 for (
unsigned i = 0, e = Group.size(); i != e; ++i) {
15033 VarDecl *D = dyn_cast<VarDecl>(Group[i]);
15043 auto *AT = dyn_cast<AutoType>(DT);
15045 diag::err_auto_different_deductions)
15046 << (AT ? (
unsigned)AT->getKeyword() : 3) << Deduced
15071 if (Group.empty() || !Group[0])
15075 Group[0]->getLocation()) &&
15077 Group[0]->getLocation()))
15080 if (Group.size() >= 2) {
15088 Decl *MaybeTagDecl = Group[0];
15089 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
15090 Group = Group.slice(1);
15141 if (!ExplicitThisLoc.
isValid())
15144 "explicit parameter in non-cplusplus mode");
15146 S.
Diag(ExplicitThisLoc, diag::err_cxx20_deducing_this)
15147 <<
P->getSourceRange();
15151 if (
P->isParameterPack()) {
15152 S.
Diag(
P->getBeginLoc(), diag::err_explicit_object_parameter_pack)
15153 <<
P->getSourceRange();
15156 P->setExplicitObjectParameterLoc(ExplicitThisLoc);
15158 LSI->ExplicitObjectParameter =
P;
15178 : diag::warn_deprecated_register)
15186 diag::err_invalid_storage_class_in_func_decl);
15219 PrevDecl =
nullptr;
15221 if (PrevDecl && S->isDeclScope(PrevDecl)) {
15244 assert(S->isFunctionPrototypeScope());
15245 assert(S->getFunctionPrototypeDepth() >= 1);
15247 S->getNextFunctionPrototypeIndex());
15261 if (New->
hasAttr<BlocksAttr>()) {
15295 !
Parameter->getIdentifier()->isPlaceholder()) {
15296 Diag(
Parameter->getLocation(), diag::warn_unused_parameter)
15304 if (
LangOpts.NumLargeByValueCopy == 0)
15311 if (Size >
LangOpts.NumLargeByValueCopy)
15322 if (Size >
LangOpts.NumLargeByValueCopy)
15345 NameLoc, diag::err_arc_array_param_no_ownership, T,
false));
15347 Diag(NameLoc, diag::err_arc_array_param_no_ownership)
15378 NameLoc, diag::err_arc_array_param_no_ownership, T,
false));
15380 Diag(NameLoc, diag::err_arc_array_param_no_ownership)
15392 TSInfo, SC,
nullptr);
15399 LSI->LocalPacks.push_back(New);
15412 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T
15431 Diag(NameLoc, diag::err_arg_with_address_space);
15459 for (
int i = FTI.
NumParams; i != 0; ) {
15464 llvm::raw_svector_ostream(Code)
15475 const char* PrevSpec;
15509 ParentScope, D, TemplateParameterLists, Bases);
15515 if (!Bases.empty())
15531 if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
15534 PossiblePrototype = Prev;
15552 if (isa<CXXMethodDecl>(FD))
15558 if (II->isStr(
"main") || II->isStr(
"efi_main"))
15574 if (FD->
hasAttr<OpenCLKernelAttr>())
15628 Definition->getNumTemplateParameterLists())) {
15631 if (
auto *TD =
Definition->getDescribedFunctionTemplate())
15644 Diag(
Definition->getLocation(), diag::note_previous_definition);
15653 LSI->
Lambda = LambdaClass;
15677 for (
const auto &
C : LambdaClass->
captures()) {
15678 if (
C.capturesVariable()) {
15682 const bool ByRef =
C.getCaptureKind() ==
LCK_ByRef;
15684 true,
C.getLocation(),
15685 C.isPackExpansion()
15687 I->getType(),
false);
15689 }
else if (
C.capturesThis()) {
15715 FD = FunTmpl->getTemplatedDecl();
15717 FD = cast<FunctionDecl>(D);
15742 if (
const auto *
Attr = FD->
getAttr<AliasAttr>()) {
15747 if (
const auto *
Attr = FD->
getAttr<IFuncAttr>()) {
15752 if (
const auto *
Attr = FD->
getAttr<TargetVersionAttr>()) {
15754 !
Attr->isDefaultVersion()) {
15763 if (
auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
15765 Ctor->isDefaultConstructor() &&
15808 "There should be an active template instantiation on the stack "
15809 "when instantiating a generic lambda!");
15835 diag::err_func_def_incomplete_result) ||
15837 diag::err_abstract_type_in_decl,
15853 auto *NonParmDecl = dyn_cast<NamedDecl>(NPD);
15856 assert(!isa<ParmVarDecl>(NonParmDecl) &&
15857 "parameters should not be in newly created FD yet");
15860 if (NonParmDecl->getDeclName())
15865 if (
auto *ED = dyn_cast<EnumDecl>(NonParmDecl)) {
15866 for (
auto *EI : ED->enumerators())
15874 Param->setOwningFunction(FD);
15877 if (Param->getIdentifier() && FnBodyScope) {
15906 assert(!FD->
hasAttr<DLLExportAttr>());
15907 Diag(FD->
getLocation(), diag::err_attribute_dllimport_function_definition);
15937 for (
unsigned I = 0, E =
Scope->Returns.size(); I != E; ++I) {
15938 if (
const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
15939 if (!NRVOCandidate->isNRVOVariable())
15958 Outer.Fun.hasTrailingReturnType()) {
15976 if (FD->isConstexpr())
15981 if (FD->getReturnType()->getContainedDeducedType())
15991 FD->setHasSkippedBody();
16013 bool IsLambda =
false;
16017 llvm::DenseMap<const BlockDecl *, bool> EscapeInfo;
16019 auto IsOrNestedInEscapingBlock = [&](
const BlockDecl *BD) {
16020 if (EscapeInfo.count(BD))
16021 return EscapeInfo[BD];
16033 return EscapeInfo[BD] = R;
16038 for (
const std::pair<SourceLocation, const BlockDecl *> &
P :
16040 if (IsOrNestedInEscapingBlock(
P.second))
16041 S.
Diag(
P.first, diag::warn_implicitly_retains_self)
16046 return isa<CXXMethodDecl>(FD) && FD->
param_empty() &&
16056 methodHasName(FD,
"get_return_object_on_allocation_failure");
16066 if (!FD->
hasAttr<CoroWrapperAttr>())
16071 bool IsInstantiation) {
16111 Expr *Dummy =
nullptr;
16122 if (LSI->HasImplicitReturnType) {
16129 LSI->ReturnType.isNull() ?
Context.
VoidTy : LSI->ReturnType;
16134 Proto->getExtProtoInfo()));
16162 dyn_cast<CXXDestructorDecl>(FD))
16182 if (PossiblePrototype) {
16186 TypeLoc TL = TI->getTypeLoc();
16189 diag::note_declaration_not_a_prototype)
16192 FTL.getRParenLoc(),
"void")
16199 std::pair<FileID, unsigned> LocInfo =
SM.getDecomposedLoc(Loc);
16200 if (LocInfo.first.isInvalid())
16204 StringRef Buffer =
SM.getBufferData(LocInfo.first, &
Invalid);
16208 if (LocInfo.second > Buffer.size())
16211 const char *LexStart = Buffer.data() + LocInfo.second;
16212 StringRef StartTok(LexStart, Buffer.size() - LocInfo.second);
16214 return StartTok.consume_front(
"const") &&
16216 StartTok.starts_with(
"/*") || StartTok.starts_with(
"//"));
16219 auto findBeginLoc = [&]() {
16235 diag::note_static_for_internal_linkage)
16246 if (!PossiblePrototype)
16292 if (PossiblePrototype)
16294 diag::warn_non_prototype_changes_behavior)
16301 if (
const auto *CmpndBody = dyn_cast<CompoundStmt>(Body))
16302 if (!CmpndBody->body_empty())
16303 Diag(CmpndBody->body_front()->getBeginLoc(),
16304 diag::warn_dispatch_body_ignored);
16306 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
16331 "Function parsing confused");
16332 }
else if (
ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
16344 << MD->getSelector().getAsString();
16349 bool isDesignated =
16350 MD->isDesignatedInitializerForTheInterface(&InitMethod);
16351 assert(isDesignated && InitMethod);
16352 (void)isDesignated;
16355 auto IFace = MD->getClassInterface();
16358 auto SuperD = IFace->getSuperClass();
16368 diag::warn_objc_designated_init_missing_super_call);
16370 diag::note_objc_designated_init_marked_here);
16378 diag::warn_objc_secondary_init_missing_init_call);
16394 "This should only be set for ObjC methods, which should have been "
16395 "handled in the block above.");
16402 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
16410 if (!Destructor->getParent()->isDependentType())
16414 Destructor->getParent());
16428 ActivePolicy = &WP;
16431 if (!IsInstantiation && FD &&
16437 if (FD && FD->
hasAttr<NakedAttr>()) {
16441 bool RegisterVariables =
false;
16442 if (
auto *DS = dyn_cast<DeclStmt>(S)) {
16443 for (
const auto *
Decl : DS->decls()) {
16444 if (
const auto *Var = dyn_cast<VarDecl>(
Decl)) {
16445 RegisterVariables =
16446 Var->hasAttr<AsmLabelAttr>() && !Var->hasInit();
16447 if (!RegisterVariables)
16452 if (RegisterVariables)
16454 if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
16455 Diag(S->getBeginLoc(), diag::err_non_asm_stmt_in_naked_function);
16456 Diag(FD->
getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
16465 "Leftover temporaries in function");
16467 "Unaccounted cleanups in function");
16469 "Leftover expressions for odr-use checking");
16475 if (!IsInstantiation)
16492 DeclsToCheckForDeferredDiags.insert(FD);
16507 D = TD->getTemplatedDecl();
16511 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
16512 if (Method->isStatic())
16522 "Implicit function declarations aren't allowed in this language mode");
16529 Scope *BlockScope = S;
16537 Scope *ContextScope = BlockScope;
16541 ContextScope = ContextScope->
getParent();
16557 if (!isa<FunctionDecl>(ExternCPrev) ||
16559 cast<FunctionDecl>(ExternCPrev)->getType(),
16561 Diag(Loc, diag::ext_use_out_of_scope_declaration)
16564 return ExternCPrev;
16570 if (II.
getName().starts_with(
"__builtin_"))
16571 diag_id = diag::warn_builtin_unknown;
16574 diag_id = diag::ext_implicit_function_decl_c99;
16576 diag_id = diag::warn_implicit_function_decl;
16584 if (S && !ExternCPrev &&
16591 Diag(Loc, diag_id) << &II;
16607 return ExternCPrev;
16617 assert(!Error &&
"Error setting up implicit decl!");
16665 std::optional<unsigned> AlignmentParam;
16666 bool IsNothrow =
false;
16678 if (!IsNothrow && !FD->
hasAttr<ReturnsNonNullAttr>() &&
16696 if (!FD->
hasAttr<AllocSizeAttr>()) {
16697 FD->
addAttr(AllocSizeAttr::CreateImplicit(
16708 if (AlignmentParam && !FD->
hasAttr<AllocAlignAttr>()) {
16709 FD->
addAttr(AllocAlignAttr::CreateImplicit(
16742 unsigned FormatIdx;
16745 if (!FD->
hasAttr<FormatAttr>()) {
16746 const char *fmt =
"printf";
16748 if (FormatIdx < NumParams &&
16754 HasVAListArg ? 0 : FormatIdx+2,
16760 if (!FD->
hasAttr<FormatAttr>())
16764 HasVAListArg ? 0 : FormatIdx+2,
16770 if (!FD->
hasAttr<CallbackAttr>() &&
16772 FD->
addAttr(CallbackAttr::CreateImplicit(
16778 bool NoExceptions =
16780 bool ConstWithoutErrnoAndExceptions =
16782 bool ConstWithoutExceptions =
16784 if (!FD->
hasAttr<ConstAttr>() &&
16785 (ConstWithoutErrnoAndExceptions || ConstWithoutExceptions) &&
16786 (!ConstWithoutErrnoAndExceptions ||
16788 (!ConstWithoutExceptions || NoExceptions))
16795 if ((Trip.isGNUEnvironment() || Trip.isOSMSVCRT()) &&
16797 switch (BuiltinID) {
16798 case Builtin::BI__builtin_fma:
16799 case Builtin::BI__builtin_fmaf:
16800 case Builtin::BI__builtin_fmal:
16801 case Builtin::BIfma:
16802 case Builtin::BIfmaf:
16803 case Builtin::BIfmal:
16812 !FD->
hasAttr<ReturnsTwiceAttr>())
16822 !FD->
hasAttr<CUDADeviceAttr>() && !FD->
hasAttr<CUDAHostAttr>()) {
16834 switch (BuiltinID) {
16835 case Builtin::BImemalign:
16836 case Builtin::BIaligned_alloc:
16837 if (!FD->
hasAttr<AllocAlignAttr>())
16846 switch (BuiltinID) {
16847 case Builtin::BIcalloc:
16848 FD->
addAttr(AllocSizeAttr::CreateImplicit(
16851 case Builtin::BImemalign:
16852 case Builtin::BIaligned_alloc:
16853 case Builtin::BIrealloc:
16857 case Builtin::BImalloc:
16866 switch (BuiltinID) {
16867 case Builtin::BIaddressof:
16868 case Builtin::BI__addressof:
16869 case Builtin::BI__builtin_addressof:
16870 case Builtin::BIas_const:
16871 case Builtin::BIforward:
16872 case Builtin::BIforward_like:
16873 case Builtin::BImove:
16874 case Builtin::BImove_if_noexcept:
16876 !
P->hasAttr<LifetimeBoundAttr>())
16893 if (!FPT || FPT->getExceptionSpecType() ==
EST_None)
16909 if (Name->isStr(
"asprintf") || Name->isStr(
"vasprintf")) {
16912 if (!FD->
hasAttr<FormatAttr>())
16915 Name->isStr(
"vasprintf") ? 0 : 3,
16919 if (Name->isStr(
"__CFStringMakeConstantString")) {
16922 if (!FD->
hasAttr<FormatArgAttr>())
16930 assert(D.
getIdentifier() &&
"Wrong callback for declspec without declarator");
16931 assert(!T.
isNull() &&
"GetTypeForDeclarator() returned null type");
16934 assert(D.
isInvalidType() &&
"no declarator info for valid type");
16995 if (BT->isInteger())
16998 return Diag(UnderlyingLoc, diag::err_enum_invalid_underlying)
17005 QualType EnumUnderlyingTy,
bool IsFixed,
17007 if (IsScoped != Prev->
isScoped()) {
17008 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
17014 if (IsFixed && Prev->
isFixed()) {
17020 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
17026 }
else if (IsFixed != Prev->
isFixed()) {
17027 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
17049 default: llvm_unreachable(
"Invalid tag kind for redecl diagnostic!");
17065 if (isa<TypedefDecl>(PrevDecl))
17067 else if (isa<TypeAliasDecl>(PrevDecl))
17069 else if (isa<ClassTemplateDecl>(PrevDecl))
17071 else if (isa<TypeAliasTemplateDecl>(PrevDecl))
17073 else if (isa<TemplateTemplateParmDecl>(PrevDecl))
17085 llvm_unreachable(
"invalid TTK");
17110 if (OldTag != NewTag &&
17128 if (IsIgnoredLoc(NewTagLoc))
17131 auto IsIgnored = [&](
const TagDecl *Tag) {
17132 return IsIgnoredLoc(Tag->getLocation());
17146 if (OldTag != NewTag) {
17149 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
17157 if (isDefinition) {
17165 bool previousMismatch =
false;
17167 if (I->getTagKind() != NewTag) {
17172 if (!previousMismatch) {
17173 previousMismatch =
true;
17174 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
17178 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
17191 if (PrevDef && IsIgnored(PrevDef))
17195 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
17202 Diag(NewTagLoc, diag::note_struct_class_suggestion)
17232 if (!Namespace || Namespace->isAnonymousNamespace())
17235 Namespaces.push_back(II);
17238 if (Lookup == Namespace)
17245 llvm::raw_svector_ostream OS(Insertion);
17248 std::reverse(Namespaces.begin(), Namespaces.end());
17249 for (
auto *II : Namespaces)
17250 OS << II->getName() <<
"::";
17263 if (OldDC->
Equals(NewDC))
17292 bool ScopedEnumUsesClassTag,
TypeResult UnderlyingType,
17293 bool IsTypeSpecifier,
bool IsTemplateParamOrArg,
17298 "Nameless record must be a definition!");
17299 assert(TemplateParameterLists.size() == 0 || TUK !=
TUK_Reference);
17303 bool ScopedEnum = ScopedEnumKWLoc.
isValid();
17306 bool isMemberSpecialization =
false;
17312 if (TemplateParameterLists.size() > 0 ||
17316 KWLoc, NameLoc, SS,
nullptr, TemplateParameterLists,
17333 Diag(SS.
getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
17336 if (TemplateParams) {
17338 Diag(KWLoc, diag::err_enum_template);
17342 if (TemplateParams->
size() > 0) {
17351 S, TagSpec, TUK, KWLoc, SS, Name, NameLoc, Attrs, TemplateParams,
17352 AS, ModulePrivateLoc,
17354 TemplateParameterLists.data(), SkipBody);
17360 isMemberSpecialization =
true;
17364 if (!TemplateParameterLists.empty() && isMemberSpecialization &&
17383 ScopedEnum ?
SourceRange(KWLoc, ScopedEnumKWLoc) : KWLoc);
17384 assert(ScopedEnum || !ScopedEnumUsesClassTag);
17385 Diag(KWLoc, diag::note_enum_friend)
17386 << (ScopedEnum + ScopedEnumUsesClassTag);
17392 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
17393 bool IsFixed = !UnderlyingType.
isUnset() || ScopedEnum;
17396 if (UnderlyingType.
isInvalid() || (!UnderlyingType.
get() && ScopedEnum)) {
17400 }
else if (UnderlyingType.
get()) {
17405 EnumUnderlying = TI;
17427 bool isStdBadAlloc =
false;
17428 bool isStdAlignValT =
false;
17437 auto createTagFromNewDecl = [&]() ->
TagDecl * {
17447 ScopedEnum, ScopedEnumUsesClassTag, IsFixed);
17451 if (EnumUnderlying) {
17452 EnumDecl *ED = cast<EnumDecl>(New);
17467 if (
RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
17493 goto CreateNewDecl;
17501 IsDependent =
true;
17530 if (
Previous.wasNotFoundInCurrentInstantiation() &&
17532 IsDependent =
true;
17537 Diag(NameLoc, diag::err_not_tag_in_scope)
17538 << llvm::to_underlying(Kind) << Name << DC << SS.
getRange();
17541 goto CreateNewDecl;
17589 bool FriendSawTagOutsideEnclosingNamespace =
false;
17596 FriendSawTagOutsideEnclosingNamespace =
true;
17605 if (
Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
17607 Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
17621 while (isa<RecordDecl, EnumDecl, ObjCContainerDecl>(SearchDC))
17627 while (isa<ObjCContainerDecl>(SearchDC))
17633 while (isa<ObjCContainerDecl>(SearchDC))
17638 Previous.getFoundDecl()->isTemplateParameter()) {
17647 if (Name->isStr(
"bad_alloc")) {
17649 isStdBadAlloc =
true;
17656 }
else if (Name->isStr(
"align_val_t")) {
17657 isStdAlignValT =
true;
17669 if (
Invalid)
goto CreateNewDecl;
17753 TagDecl *Tag = TT->getDecl();
17756 ->
Equals(TD->getDeclContext()->getRedeclContext())) {
17769 if (
auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
17770 auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
17772 isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) &&
17774 *
this, OldTag->getDeclContext(), SearchDC))) {
17775 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
17776 Diag(Shadow->getTargetDecl()->getLocation(),
17777 diag::note_using_decl_target);
17778 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
17782 goto CreateNewDecl;
17786 if (
TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
17792 SS.
isNotEmpty() || isMemberSpecialization)) {
17798 bool SafeToContinue =
17801 if (SafeToContinue)
17802 Diag(KWLoc, diag::err_use_with_wrong_tag)
17805 PrevTagDecl->getKindName());
17807 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
17808 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
17810 if (SafeToContinue)
17811 Kind = PrevTagDecl->getTagKind();
17822 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
17824 return PrevTagDecl;
17828 EnumUnderlyingTy = TI->getType().getUnqualifiedType();
17829 else if (
const Type *T = EnumUnderlying.dyn_cast<
const Type*>())
17830 EnumUnderlyingTy =
QualType(T, 0);
17836 ScopedEnum, EnumUnderlyingTy,
17837 IsFixed, PrevEnum))
17846 S->isDeclScope(PrevDecl)) {
17847 Diag(NameLoc, diag::ext_member_redeclared);
17848 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
17855 if (!Attrs.
empty()) {
17859 (PrevTagDecl->getFriendObjectKind() ==
17872 return PrevTagDecl;
17877 return PrevTagDecl;
17883 if (
NamedDecl *Def = PrevTagDecl->getDefinition()) {
17887 bool IsExplicitSpecializationAfterInstantiation =
false;
17888 if (isMemberSpecialization) {
17890 IsExplicitSpecializationAfterInstantiation =
17891 RD->getTemplateSpecializationKind() !=
17893 else if (
EnumDecl *ED = dyn_cast<EnumDecl>(Def))
17894 IsExplicitSpecializationAfterInstantiation =
17895 ED->getTemplateSpecializationKind() !=
17915 SkipBody->
New = createTagFromNewDecl();
17925 }
else if (!IsExplicitSpecializationAfterInstantiation) {
17929 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
17931 Diag(NameLoc, diag::err_redefinition) << Name;
17933 NameLoc.
isValid() ? NameLoc : KWLoc);
17945 if (TD->isBeingDefined()) {
17946 Diag(NameLoc, diag::err_nested_redefinition) << Name;
17947 Diag(PrevTagDecl->getLocation(),
17948 diag::note_previous_definition);
17963 SearchDC = PrevTagDecl->getDeclContext();
17991 Diag(NameLoc, diag::err_tag_reference_non_tag)
17992 << PrevDecl << NTK << llvm::to_underlying(Kind);
17998 SS.
isNotEmpty() || isMemberSpecialization)) {
18004 Diag(NameLoc, diag::err_tag_reference_conflict) << NTK;
18010 }
else if (
TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
18012 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
18013 Diag(NameLoc, diag::err_tag_definition_of_typedef)
18014 << Name << Kind << TND->getUnderlyingType();
18022 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
18038 PrevDecl = cast<TagDecl>(
Previous.getFoundDecl());
18054 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
18055 ScopedEnumUsesClassTag, IsFixed);
18063 if (IsFixed && cast<EnumDecl>(New)->isFixed()) {
18067 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->
getDefinition())) {
18068 Diag(Loc, diag::ext_forward_ref_enum_def)
18072 unsigned DiagID = diag::ext_forward_ref_enum;
18074 DiagID = diag::ext_ms_forward_ref_enum;
18076 DiagID = diag::err_forward_ref_enum;
18081 if (EnumUnderlying) {
18082 EnumDecl *ED = cast<EnumDecl>(New);
18091 assert(ED->
isComplete() &&
"enum with type should be complete");
18101 cast_or_null<CXXRecordDecl>(PrevDecl));
18107 cast_or_null<RecordDecl>(PrevDecl));
18117 (IsTypeSpecifier || IsTemplateParamOrArg) && TUK ==
TUK_Definition) {
18138 isMemberSpecialization))
18142 if (TemplateParameterLists.size() > 0) {
18150 if (
RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
18166 if (ModulePrivateLoc.
isValid()) {
18167 if (isMemberSpecialization)
18192 Diag(Loc, diag::err_type_defined_in_param_type)
18196 }
else if (!PrevDecl) {
18257 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(New))
18272 if (
auto RD = dyn_cast<RecordDecl>(New))
18275 }
else if (SkipBody && SkipBody->
ShouldSkip) {
18284 TagDecl *Tag = cast<TagDecl>(TagD);
18307 "The next DeclContext should be lexically contained in the current one.");
18313 bool IsFinalSpelledSealed,
18321 if (!
Record->getIdentifier())
18329 IsFinalSpelledSealed
18330 ? FinalAttr::Keyword_sealed
18331 : FinalAttr::Keyword_final));
18350 "Broken injected-class-name");
18356 TagDecl *Tag = cast<TagDecl>(TagD);
18361 assert(Tag->
isInvalidDecl() &&
"We should already have completed it");
18362 if (
RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
18366 if (
auto *RD = dyn_cast<CXXRecordDecl>(Tag)) {
18368 if (RD->
hasAttr<SYCLSpecialClassAttr>()) {
18370 assert(Def &&
"The record is expected to have a completed definition");
18371 unsigned NumInitMethods = 0;
18372 for (
auto *Method : Def->methods()) {
18373 if (!Method->getIdentifier())
18375 if (Method->getName() ==
"__init")
18378 if (NumInitMethods > 1 || !Def->hasInitMethod())
18379 Diag(RD->
getLocation(), diag::err_sycl_special_type_num_init_method);
18402 const RecordDecl *RD = dyn_cast<RecordDecl>(Tag);
18406 if (llvm::any_of(RD->
fields(),
18407 [](
const FieldDecl *FD) { return FD->isBitField(); }))
18408 Diag(BraceRange.
getBegin(), diag::warn_pragma_align_not_xl_compatible);
18418 assert(ObjCCtx ==
CurContext &&
"Mismatch of container contexts");
18430 TagDecl *Tag = cast<TagDecl>(TagD);
18435 if (
RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
18449 bool IsMsStruct,
Expr *BitWidth) {
18459 diag::err_field_incomplete_or_sizeless))
18462 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
18464 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
18475 llvm::APSInt
Value;
18479 BitWidth = ICE.
get();
18482 if (
Value == 0 && FieldName)
18483 return Diag(FieldLoc, diag::err_bitfield_has_zero_width)
18486 if (
Value.isSigned() &&
Value.isNegative()) {
18488 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
18490 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
18497 return Diag(FieldLoc, diag::err_bitfield_too_wide)
18504 bool BitfieldIsOverwide =
Value.ugt(TypeWidth);
18508 bool CStdConstraintViolation =
18510 bool MSBitfieldViolation =
18511 Value.ugt(TypeStorageSize) &&
18513 if (CStdConstraintViolation || MSBitfieldViolation) {
18514 unsigned DiagWidth =
18515 CStdConstraintViolation ? TypeWidth : TypeStorageSize;
18516 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_width)
18518 << !CStdConstraintViolation << DiagWidth;
18524 if (BitfieldIsOverwide && !FieldTy->
isBooleanType() && FieldName) {
18525 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_width)
18582 diag::err_invalid_thread)
18590 switch (
Previous.getResultKind()) {
18597 PrevDecl =
Previous.getRepresentativeDecl();
18611 PrevDecl =
nullptr;
18615 PrevDecl =
nullptr;
18622 TSSL, AS, PrevDecl, &D);
18625 Record->setInvalidDecl();
18654 bool Mutable,
Expr *BitWidth,
18660 bool InvalidDecl =
false;
18666 InvalidDecl =
true;
18673 diag::err_field_incomplete_or_sizeless)) {
18675 Record->setInvalidDecl();
18676 InvalidDecl =
true;
18681 Record->setInvalidDecl();
18682 InvalidDecl =
true;
18690 Diag(Loc, diag::err_field_with_address_space);
18691 Record->setInvalidDecl();
18692 InvalidDecl =
true;
18700 Diag(Loc, diag::err_opencl_type_struct_or_union_field) << T;
18701 Record->setInvalidDecl();
18702 InvalidDecl =
true;
18707 "__cl_clang_bitfields",
LangOpts)) {
18708 Diag(Loc, diag::err_opencl_bitfields);
18709 InvalidDecl =
true;
18716 InvalidDecl =
true;
18717 Diag(Loc, diag::err_anon_bitfield_qualifiers);
18724 TInfo, T, Loc, diag::err_typecheck_field_variable_size))
18725 InvalidDecl =
true;
18730 diag::err_abstract_type_in_decl,
18732 InvalidDecl =
true;
18735 BitWidth =
nullptr;
18741 InvalidDecl =
true;
18742 BitWidth =
nullptr;
18747 if (!InvalidDecl && Mutable) {
18748 unsigned DiagID = 0;
18750 DiagID =
getLangOpts().MSVCCompat ? diag::ext_mutable_reference
18751 : diag::err_mutable_reference;
18753 DiagID = diag::err_mutable_const;
18759 Diag(ErrLoc, DiagID);
18760 if (DiagID != diag::ext_mutable_reference) {
18762 InvalidDecl =
true;
18774 BitWidth, Mutable, InitStyle);
18778 if (PrevDecl && !isa<TagDecl>(PrevDecl) &&
18780 Diag(Loc, diag::err_duplicate_member) << II;
18786 if (
Record->isUnion()) {
18805 diag::ext_union_member_of_reference_type :
18806 diag::err_union_member_of_reference_type)
18830 Diag(Loc, diag::warn_attribute_weak_on_field);
18881 if (!FD->
hasAttr<UnavailableAttr>())
18883 UnavailableAttr::IR_ARCFieldWithOwnership, Loc));
18889 diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member :
18890 diag::err_illegal_union_or_anon_struct_member)
18905 switch (ivarVisibility) {
18906 default: llvm_unreachable(
"Unknown visitibility kind");
18941 Diag(Loc, diag::err_ivar_reference_type);
18948 TInfo, T, Loc, diag::err_typecheck_ivar_variable_size))
18962 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
18965 EnclosingContext = IMPDecl->getClassInterface();
18966 assert(EnclosingContext &&
"Implementation has no class interface!");
18969 EnclosingContext = EnclosingDecl;
18972 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
18974 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
18978 EnclosingContext = EnclosingDecl;
18983 Context, EnclosingContext, DeclStart, Loc, II, T, TInfo, ac, BitWidth);
18991 if (PrevDecl &&
isDeclInScope(PrevDecl, EnclosingContext, S)
18992 && !isa<TagDecl>(PrevDecl)) {
18993 Diag(Loc, diag::err_duplicate_member) << II;
19020 !NewID->
isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl))
19021 Diag(Loc, diag::warn_ivars_in_interface);
19035 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
19043 if (!CD->IsClassExtension())
19055 DeclLoc, DeclLoc,
nullptr,
19061 AllIvarDecls.push_back(Ivar);
19073 if (!
Record->hasUserDeclaredDestructor()) {
19081 if (
auto *DD = dyn_cast<CXXDestructorDecl>(
Decl)) {
19082 if (DD->isInvalidDecl())
19086 assert(DD->isIneligibleOrNotSelected() &&
"Selecting a destructor but a destructor was already selected.");
19100 Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(Best->Function));
19104 Msg = diag::err_ambiguous_destructor;
19109 Msg = diag::err_no_viable_destructor;
19120 Record->setInvalidDecl();
19127 Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(OCS.
begin()->Function));
19171 const Expr *Constraints = Method->getTrailingRequiresClause();
19173 SatisfactionStatus.push_back(
true);
19177 SatisfactionStatus.push_back(
false);
19179 SatisfactionStatus.push_back(Satisfaction.
IsSatisfied);
19183 for (
size_t i = 0; i < Methods.size(); i++) {
19184 if (!SatisfactionStatus[i])
19189 OrigMethod = cast<CXXMethodDecl>(MF);
19192 bool AnotherMethodIsMoreConstrained =
false;
19193 for (
size_t j = 0; j < Methods.size(); j++) {
19194 if (i == j || !SatisfactionStatus[j])
19198 OtherMethod = cast<CXXMethodDecl>(MF);
19205 if (!OtherConstraints)
19207 if (!Constraints) {
19208 AnotherMethodIsMoreConstrained =
true;
19213 AnotherMethodIsMoreConstrained)) {
19216 AnotherMethodIsMoreConstrained =
true;
19218 if (AnotherMethodIsMoreConstrained)
19223 if (!AnotherMethodIsMoreConstrained) {
19225 Record->addedEligibleSpecialMemberFunction(Method, 1 << CSM);
19239 auto *MD = dyn_cast<CXXMethodDecl>(
Decl);
19241 auto *FTD = dyn_cast<FunctionTemplateDecl>(
Decl);
19243 MD = dyn_cast<CXXMethodDecl>(FTD->getTemplatedDecl());
19247 if (
auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
19248 if (CD->isInvalidDecl())
19250 if (CD->isDefaultConstructor())
19251 DefaultConstructors.push_back(MD);
19252 else if (CD->isCopyConstructor())
19253 CopyConstructors.push_back(MD);
19254 else if (CD->isMoveConstructor())
19255 MoveConstructors.push_back(MD);
19257 CopyAssignmentOperators.push_back(MD);
19259 MoveAssignmentOperators.push_back(MD);
19277 assert(EnclosingDecl &&
"missing record or interface decl");
19282 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
19286 case Decl::ObjCCategory:
19289 case Decl::ObjCImplementation:
19291 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
19297 CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(EnclosingDecl);
19301 unsigned NumNamedMembers = 0;
19303 for (
const auto *I :
Record->decls()) {
19304 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
19305 if (IFD->getDeclName())
19322 RecFields.push_back(FD);
19342 bool IsLastField = (i + 1 == Fields.end());
19351 (
Record || isa<ObjCContainerDecl>(EnclosingDecl))) {
19357 unsigned DiagID = 0;
19358 if (!
Record->isUnion() && !IsLastField) {
19361 << llvm::to_underlying(
Record->getTagKind());
19362 Diag((*(i + 1))->getLocation(), diag::note_next_field_declaration);
19366 }
else if (
Record->isUnion())
19368 ? diag::ext_flexible_array_union_ms
19370 ? diag::ext_flexible_array_union_gnu
19371 : diag::err_flexible_array_union;
19372 else if (NumNamedMembers < 1)
19374 ? diag::ext_flexible_array_empty_aggregate_ms
19376 ? diag::ext_flexible_array_empty_aggregate_gnu
19377 : diag::err_flexible_array_empty_aggregate;
19387 if (CXXRecord && CXXRecord->getNumVBases() != 0)
19401 Diag(FD->
getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
19408 Record->setHasFlexibleArrayMember(
true);
19417 diag::err_field_incomplete_or_sizeless)) {
19423 if (
Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
19426 Record->setHasFlexibleArrayMember(
true);
19427 if (!
Record->isUnion()) {
19442 if (isa<ObjCContainerDecl>(EnclosingDecl) &&
19444 diag::err_abstract_type_in_decl,
19449 if (
Record && FDTTy->getDecl()->hasObjectMember())
19450 Record->setHasObjectMember(
true);
19451 if (
Record && FDTTy->getDecl()->hasVolatileMember())
19452 Record->setHasVolatileMember(
true);
19471 FD->
addAttr(UnavailableAttr::CreateImplicit(
19472 Context,
"", UnavailableAttr::IR_ARCFieldWithOwnership,
19476 !
Record->hasObjectMember()) {
19479 Record->setHasObjectMember(
true);
19484 Record->setHasObjectMember(
true);
19487 Record->setHasObjectMember(
true);
19492 !shouldIgnoreForRecordTriviality(FD)) {
19495 Record->setNonTrivialToPrimitiveDefaultInitialize(
true);
19498 Record->setHasNonTrivialToPrimitiveDefaultInitializeCUnion(
true);
19502 Record->setNonTrivialToPrimitiveCopy(
true);
19504 Record->setHasNonTrivialToPrimitiveCopyCUnion(
true);
19507 Record->setNonTrivialToPrimitiveDestroy(
true);
19508 Record->setParamDestroyedInCallee(
true);
19510 Record->setHasNonTrivialToPrimitiveDestructCUnion(
true);
19514 if (RT->getDecl()->getArgPassingRestrictions() ==
19516 Record->setArgPassingRestrictions(
19519 Record->setArgPassingRestrictions(
19524 Record->setHasVolatileMember(
true);
19532 bool Completed =
false;
19534 if (!CXXRecord->isInvalidDecl()) {
19537 I = CXXRecord->conversion_begin(),
19538 E = CXXRecord->conversion_end(); I != E; ++I)
19539 I.setAccess((*I)->getAccess());
19545 if (!CXXRecord->isDependentType()) {
19546 if (!CXXRecord->isInvalidDecl()) {
19550 if (CXXRecord->getNumVBases()) {
19552 CXXRecord->getFinalOverriders(FinalOverriders);
19554 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
19555 MEnd = FinalOverriders.end();
19558 SOEnd = M->second.end();
19559 SO != SOEnd; ++SO) {
19560 assert(SO->second.size() > 0 &&
19561 "Virtual function without overriding functions?");
19562 if (SO->second.size() == 1)
19569 Diag(
Record->getLocation(), diag::err_multiple_final_overriders)
19571 Diag(M->first->getLocation(),
19572 diag::note_overridden_virtual_function);
19574 OM = SO->second.begin(),
19575 OMEnd = SO->second.end();
19577 Diag(OM->Method->getLocation(), diag::note_final_overrider)
19578 << (
const NamedDecl *)M->first << OM->Method->getParent();
19580 Record->setInvalidDecl();
19583 CXXRecord->completeDefinition(&FinalOverriders);
19593 Record->completeDefinition();
19599 auto IsFunctionPointerOrForwardDecl = [&](
const Decl *D) {
19600 const FieldDecl *FD = dyn_cast<FieldDecl>(D);
19613 if (
const auto *TD = dyn_cast<TagDecl>(D))
19614 return !TD->isCompleteDefinition();
19618 if (isa<PointerType>(FieldType)) {
19628 (
Record->hasAttr<RandomizeLayoutAttr>() ||
19629 (!
Record->hasAttr<NoRandomizeLayoutAttr>() &&
19630 llvm::all_of(
Record->decls(), IsFunctionPointerOrForwardDecl))) &&
19632 !
Record->isRandomized()) {
19636 Record->reorderDecls(NewDeclOrdering);
19641 auto *Dtor = CXXRecord->getDestructor();
19642 if (Dtor && Dtor->isImplicit() &&
19644 CXXRecord->setImplicitDestructorIsDeleted();
19649 if (
Record->hasAttrs()) {
19652 if (
const MSInheritanceAttr *IA =
Record->getAttr<MSInheritanceAttr>())
19654 IA->getRange(), IA->getBestCase(),
19655 IA->getInheritanceModel());
19661 bool CheckForZeroSize;
19663 CheckForZeroSize =
true;
19668 CXXRecord->getLexicalDeclContext()->isExternCContext() &&
19670 CXXRecord->isCLike();
19672 if (CheckForZeroSize) {
19673 bool ZeroSize =
true;
19674 bool IsEmpty =
true;
19675 unsigned NonBitFields = 0;
19677 E =
Record->field_end();
19678 (NonBitFields == 0 || ZeroSize) && I != E; ++I) {
19680 if (I->isUnnamedBitfield()) {
19681 if (!I->isZeroLengthBitField(
Context))
19685 QualType FieldType = I->getType();
19697 diag::warn_zero_size_struct_union_in_extern_c :
19698 diag::warn_zero_size_struct_union_compat)
19699 << IsEmpty <<
Record->isUnion() << (NonBitFields > 1);
19704 if (NonBitFields == 0 && !
getLangOpts().CPlusPlus) {
19705 Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
19706 diag::ext_no_named_members_in_struct_union)
19714 ID->setEndOfDefinitionLoc(RBrac);
19716 for (
unsigned i = 0, e = RecFields.size(); i != e; ++i) {
19718 ID->addDecl(ClsFields[i]);
19722 if (ID->getSuperClass())
19725 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
19726 assert(IMPDecl &&
"ActOnFields - missing ObjCImplementationDecl");
19727 for (
unsigned I = 0, N = RecFields.size(); I != N; ++I)
19732 IMPDecl->setIvarLBraceLoc(LBrac);
19733 IMPDecl->setIvarRBraceLoc(RBrac);
19735 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
19743 for (
unsigned i = 0, e = RecFields.size(); i != e; ++i) {
19747 Diag(ClsFields[i]->getLocation(),
19748 diag::err_duplicate_ivar_declaration);
19749 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
19755 Diag(ClsFields[i]->getLocation(),
19756 diag::err_duplicate_ivar_declaration);
19757 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
19763 CDecl->addDecl(ClsFields[i]);
19765 CDecl->setIvarLBraceLoc(LBrac);
19766 CDecl->setIvarRBraceLoc(RBrac);
19775 llvm::APSInt &
Value,
19778 "Integral type required!");
19781 if (
Value.isUnsigned() ||
Value.isNonNegative()) {
19784 return Value.getActiveBits() <= BitWidth;
19786 return Value.getSignificantBits() <= BitWidth;
19796 const unsigned NumTypes = 4;
19797 QualType SignedIntegralTypes[NumTypes] = {
19800 QualType UnsignedIntegralTypes[NumTypes] = {
19807 : UnsignedIntegralTypes;
19808 for (
unsigned I = 0; I != NumTypes; ++I)
19821 llvm::APSInt EnumVal(IntWidth);
19841 EltTy =
Enum->getIntegerType();
19848 Val = Converted.
get();
19855 if (
Enum->isComplete()) {
19856 EltTy =
Enum->getIntegerType();
19865 .isWindowsMSVCEnvironment()) {
19866 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
19868 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
19892 Diag(IdLoc, diag::ext_enum_value_not_int)
19894 << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
19906 if (
Enum->isDependentType())
19908 else if (!LastEnumConst) {
19917 if (
Enum->isFixed()) {
19918 EltTy =
Enum->getIntegerType();
19927 EltTy = LastEnumConst->
getType();
19930 if (EnumVal < LastEnumConst->getInitVal()) {
19946 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
19948 if (
Enum->isFixed())
19950 Diag(IdLoc, diag::err_enumerator_wrapped)
19954 Diag(IdLoc, diag::ext_enumerator_increment_too_large)
19974 Diag(IdLoc, diag::warn_enum_value_overflow);
19979 Diag(IdLoc, diag::ext_enum_value_not_int)
20007 auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl);
20011 EnumDecl *PrevED = cast<EnumDecl>(PrevECD->getDeclContext());
20026 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
20028 cast_or_null<EnumConstantDecl>(lastEnumConst);
20044 PrevDecl =
nullptr;
20062 if (!TheEnumDecl->
isScoped() && isa<ValueDecl>(PrevDecl)) {
20070 "Received TagDecl when not in C++!");
20072 if (isa<EnumConstantDecl>(PrevDecl))
20073 Diag(IdLoc, diag::err_redefinition_of_enumerator) <<
Id;
20075 Diag(IdLoc, diag::err_redefinition) <<
Id;
20108 if (!BO->isAdditiveOp())
20116 InitExpr = BO->getLHS();
20120 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
20140 if (!
Enum->getIdentifier())
20144 if (
Enum->getNumPositiveBits() > 63 ||
Enum->getNumNegativeBits() > 64)
20153 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
20156 typedef std::unordered_map<int64_t, DeclOrVector> ValueToVectorMap;
20160 llvm::APSInt Val = D->getInitVal();
20161 return Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue();
20164 DuplicatesVector DupVector;
20165 ValueToVectorMap EnumMap;
20169 for (
auto *Element : Elements) {
20183 EnumMap.insert({EnumConstantToKey(ECD), ECD});
20186 if (EnumMap.size() == 0)
20190 for (
auto *Element : Elements) {
20196 auto Iter = EnumMap.find(EnumConstantToKey(ECD));
20197 if (
Iter == EnumMap.end())
20200 DeclOrVector& Entry =
Iter->second;
20207 auto Vec = std::make_unique<ECDVector>();
20209 Vec->push_back(ECD);
20216 DupVector.emplace_back(std::move(Vec));
20220 ECDVector *Vec = Entry.get<ECDVector*>();
20222 if (*Vec->begin() == ECD)
20225 Vec->push_back(ECD);
20229 for (
const auto &Vec : DupVector) {
20230 assert(Vec->size() > 1 &&
"ECDVector should have at least 2 elements.");
20233 auto *FirstECD = Vec->front();
20234 S.
Diag(FirstECD->getLocation(), diag::warn_duplicate_enum_values)
20235 << FirstECD <<
toString(FirstECD->getInitVal(), 10)
20236 << FirstECD->getSourceRange();
20240 for (
auto *ECD : llvm::drop_begin(*Vec))
20241 S.
Diag(ECD->getLocation(), diag::note_duplicate_element)
20242 << ECD <<
toString(ECD->getInitVal(), 10)
20243 << ECD->getSourceRange();
20248 bool AllowMask)
const {
20249 assert(ED->
isClosedFlag() &&
"looking for value in non-flag or open enum");
20252 auto R =
FlagBitsCache.insert(std::make_pair(ED, llvm::APInt()));
20253 llvm::APInt &FlagBits = R.first->second;
20257 const auto &EVal = E->getInitVal();
20259 if (EVal.isPowerOf2())
20260 FlagBits = FlagBits.zext(EVal.getBitWidth()) | EVal;
20272 llvm::APInt FlagMask = ~FlagBits.zextOrTrunc(Val.getBitWidth());
20273 return !(FlagMask & Val) || (AllowMask && !(FlagMask & ~Val));
20285 if (
Enum->isDependentType()) {
20286 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
20288 cast_or_null<EnumConstantDecl>(Elements[i]);
20289 if (!ECD)
continue;
20307 unsigned NumNegativeBits = 0;
20308 unsigned NumPositiveBits = 0;
20310 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
20312 cast_or_null<EnumConstantDecl>(Elements[i]);
20313 if (!ECD)
continue;
20315 const llvm::APSInt &InitVal = ECD->
getInitVal();
20318 if (InitVal.isUnsigned() || InitVal.isNonNegative()) {
20321 unsigned ActiveBits = InitVal.getActiveBits();
20322 NumPositiveBits = std::max({NumPositiveBits, ActiveBits, 1u});
20325 std::max(NumNegativeBits, (
unsigned)InitVal.getSignificantBits());
20333 if (!NumPositiveBits && !NumNegativeBits)
20334 NumPositiveBits = 1;
20338 unsigned BestWidth;
20351 bool Packed =
Enum->hasAttr<PackedAttr>();
20359 if (
Enum->isComplete()) {
20360 BestType =
Enum->getIntegerType();
20364 BestPromotionType = BestType;
20368 else if (NumNegativeBits) {
20372 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
20374 BestWidth = CharWidth;
20375 }
else if (Packed && NumNegativeBits <= ShortWidth &&
20376 NumPositiveBits < ShortWidth) {
20378 BestWidth = ShortWidth;
20379 }
else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
20381 BestWidth = IntWidth;
20385 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
20390 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
20391 Diag(
Enum->getLocation(), diag::ext_enum_too_large);
20395 BestPromotionType = (BestWidth <= IntWidth ?
Context.
IntTy : BestType);
20400 if (Packed && NumPositiveBits <= CharWidth) {
20403 BestWidth = CharWidth;
20404 }
else if (Packed && NumPositiveBits <= ShortWidth) {
20407 BestWidth = ShortWidth;
20408 }
else if (NumPositiveBits <= IntWidth) {
20410 BestWidth = IntWidth;
20412 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
20414 }
else if (NumPositiveBits <=
20418 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
20422 if (NumPositiveBits > BestWidth) {
20427 Diag(
Enum->getLocation(), diag::ext_enum_too_large);
20431 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
20438 for (
auto *D : Elements) {
20439 auto *ECD = cast_or_null<EnumConstantDecl>(D);
20440 if (!ECD)
continue;
20449 llvm::APSInt InitVal = ECD->getInitVal();
20457 !
Enum->isFixed() &&
20460 NewWidth = IntWidth;
20462 }
else if (ECD->getType() == BestType) {
20472 NewWidth = BestWidth;
20477 InitVal = InitVal.extOrTrunc(NewWidth);
20478 InitVal.setIsSigned(NewSign);
20479 ECD->setInitVal(
Context, InitVal);
20482 if (ECD->getInitExpr() &&
20485 Context, NewTy, CK_IntegralCast, ECD->getInitExpr(),
20493 ECD->setType(NewTy);
20496 Enum->completeDefinition(BestType, BestPromotionType,
20497 NumPositiveBits, NumNegativeBits);
20501 if (
Enum->isClosedFlag()) {
20502 for (
Decl *D : Elements) {
20504 if (!ECD)
continue;
20507 if (InitVal != 0 && !InitVal.isPowerOf2() &&
20515 if (
Enum->hasAttrs())
20525 AsmString, StartLoc,
20556 AsmLabelAttr *
Attr = AsmLabelAttr::CreateImplicit(
20563 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
20567 Diag(PrevDecl->
getLocation(), diag::warn_redefine_extname_not_applied)
20568 << (isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl;
20580 PrevDecl->
addAttr(WeakAttr::CreateImplicit(
Context, PragmaLoc));
20595 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
20596 if (!PrevDecl->
hasAttr<AliasAttr>())
20597 if (
NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
20605 return (dyn_cast_or_null<ObjCContainerDecl>(
CurContext));
20610 assert(FD &&
"Expected non-null FunctionDecl");
20622 auto IsEmittedForExternalSymbol = [
this, FD]() {
20632 if (
LangOpts.OpenMPIsTargetDevice) {
20635 std::optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
20642 if (*DevTy == OMPDeclareTargetDeclAttr::DT_Host)
20647 if (IsEmittedForExternalSymbol())
20653 }
else if (
LangOpts.OpenMP > 45) {
20657 std::optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
20660 if (*DevTy == OMPDeclareTargetDeclAttr::DT_NoHost)
20679 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::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.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
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 void SetEligibleMethods(Sema &S, CXXRecordDecl *Record, ArrayRef< CXXMethodDecl * > Methods, Sema::CXXSpecialMember CSM)
[class.mem.special]p6: An eligible special member function is a special member function for which:
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 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 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 AreSpecialMemberFunctionsSameKind(ASTContext &Context, CXXMethodDecl *M1, CXXMethodDecl *M2, Sema::CXXSpecialMember CSM)
[class.mem.special]p5 Two special member functions are of the same kind if:
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 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 bool MultiVersionTypesCompatible(MultiVersionKind Old, MultiVersionKind New)
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 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 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 CheckMultiVersionAdditionalDecl(Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, MultiVersionKind NewMVKind, 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 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)
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
SourceLocation getLoc() 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.
const llvm::APInt & getSize() const
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...
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,...
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).
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 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...
void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc)
Set the name of this declarator to be the given identifier.
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Expr * getAsmLabel() const
FunctionDefinitionKind getFunctionDefinitionKind() const
const ParsedAttributes & getAttributes() const
void setRedeclaration(bool Val)
SourceLocation getIdentifierLoc() const
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...
IdentifierInfo * getIdentifier() const
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).
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.
bool isFPConstrained() const
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, 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.
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.
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
void setDeletedAsWritten(bool D=true)
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
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, 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.
bool isGlobalModule() const
Does this Module scope describe a fragment of the global module within some C++ module.
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 * 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.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
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, 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, 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 hasQualifiers() const
Determine whether this type has any qualifiers.
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.
bool isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
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.
bool hasAddressSpace() const
Check if this type has any address space qualifier.
bool isObjCGCWeak() const
true when Type is objc's weak.
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.
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.
A generic diagnostic builder for errors which may or may not be deferred.
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)
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
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...
CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
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)
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)
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
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)
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)
void CheckHLSLEntryPoint(FunctionDecl *FD)
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.
bool CheckForConstantInitializer(Expr *e, QualType t)
type checking declaration initializers (C99 6.7.8)
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.
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)
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)
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
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
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 checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
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.
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()
@ 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.
void checkAllowedCUDAInitializer(VarDecl *VD)
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)
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...
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.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
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.
void ActOnHLSLTopLevelFunction(FunctionDecl *FD)
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)
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn)
Perform semantic checking of a new function declaration.
CXXRecordDecl * getStdBadAlloc() const
AlwaysInlineAttr * mergeAlwaysInlineAttr(Decl *D, const AttributeCommonInfo &CI, const IdentifierInfo *Ident)
FieldDecl * CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitfieldWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D=nullptr)
Build a new FieldDecl and check its well-formedness.
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
PragmaClangSection PragmaClangRelroSection
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM)
Diagnose why the specified class does not have a trivial special member of the given kind.
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 MaybeAddCUDAConstantAttr(VarDecl *VD)
May add implicit CUDAConstantAttr attribute to VD, depending on VD and current compilation settings.
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)
bool isInOpenMPDeclareTargetContext() const
Return true inside OpenMP declare target region.
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 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)
HLSLNumThreadsAttr * mergeHLSLNumThreadsAttr(Decl *D, const AttributeCommonInfo &AL, int X, int Y, int Z)
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.
bool CheckCountedByAttr(Scope *Scope, const FieldDecl *FD)
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)
ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName, QualType FieldTy, bool IsMsStruct, Expr *BitWidth)
VerifyBitField - verifies that a bit field expression is an ICE and has the correct width,...
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.
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
@ NotForRedeclaration
The lookup is a reference to this name that is not for the purpose of redeclaring the name.
@ ForVisibleRedeclaration
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
@ ForExternalRedeclaration
The lookup results will be used for redeclaration of a name with external linkage; non-visible lookup...
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D)
Act on D, a function definition inside of an omp [begin/end] assumes.
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)
void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD, const LookupResult &Previous)
May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD, depending on FD and the current co...
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.
SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, SourceLocation IILoc)
Determine whether the body of an anonymous enumeration should be skipped.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
void notePreviousDefinition(const NamedDecl *Old, SourceLocation New)
ObjCContainerDecl * getObjCDeclContext() const
DLLExportAttr * mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI)
bool isInOpenMPDeclareVariantScope() const
Can we exit an OpenMP declare variant scope at the moment.
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.
RedeclarationKind forRedeclarationInCurContext() const
void ActOnTagStartDefinition(Scope *S, Decl *TagDecl)
ActOnTagStartDefinition - Invoked when we have entered the scope of a tag's definition (e....
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 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 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 CheckHLSLSemanticAnnotation(FunctionDecl *EntryPoint, const Decl *Param, const HLSLAnnotationAttr *AnnotationAttr)
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)
ObjCInterfaceDecl * getObjCInterfaceDecl(IdentifierInfo *&Id, SourceLocation IdLoc, bool TypoCorrection=false)
Look for an Objective-C class in the translation unit.
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()
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)
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.
bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM, InheritedConstructorInfo *ICI=nullptr, bool Diagnose=false)
Determine if a special member function should have a deleted definition when it is defaulted.
@ 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...
void ActOnOpenMPDeclareTargetInitializer(Decl *D)
Adds OMPDeclareTargetDeclAttr to referenced variables in declare target directive.
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....
void DiagnoseHLSLAttrStageMismatch(const Attr *A, HLSLShaderAttr::ShaderType Stage, std::initializer_list< HLSLShaderAttr::ShaderType > AllowedStages)
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 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.
HLSLShaderAttr * mergeHLSLShaderAttr(Decl *D, const AttributeCommonInfo &AL, HLSLShaderAttr::ShaderType ShaderType)
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 SetDeclDeleted(Decl *dcl, SourceLocation DelLoc)
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...
CXXSpecialMember
Kinds of C++ special members.
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)
std::string getCudaConfigureFuncName() const
Returns the name of the launch configuration function.
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
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, UnresolvedLookupExpr *AsULE=nullptr)
Builds an expression which might be an implicit member expression.
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 checkCUDATargetOverload(FunctionDecl *NewFD, const LookupResult &Previous)
Check whether NewFD is a valid overload for CUDA.
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...
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.
TargetOptions & getTargetOpts() const
Retrieve the target options.
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.
std::string HLSLEntry
The entry point name for HLSL shader being compiled as specified by -E.
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
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...
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, 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, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
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.
@ 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...
@ 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.
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.
One instance of this struct is used for each type in a declarator that is parsed.
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
enum clang::DeclaratorChunk::@216 Kind
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl * > DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult(), SourceLocation TrailingReturnTypeLoc=SourceLocation(), DeclSpec *MethodQualifiers=nullptr)
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
MemberPointerTypeInfo Mem
static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc, bool lvalue)
Return a DeclaratorChunk for a reference.
RetTy visit(QualType FT, Ts &&... Args)
EvalResult is a struct with detailed info about an evaluated expression.
Extra information about a function prototype.
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.