54#include "llvm/ADT/STLForwardCompat.h"
55#include "llvm/ADT/SmallString.h"
56#include "llvm/ADT/StringExtras.h"
57#include "llvm/TargetParser/Triple.h"
62#include <unordered_map>
69 Decl *Group[2] = { OwnedType, Ptr };
80 TypeNameValidatorCCC(
bool AllowInvalid,
bool WantClass =
false,
81 bool AllowTemplates =
false,
82 bool AllowNonTemplates =
true)
83 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
84 AllowTemplates(AllowTemplates), AllowNonTemplates(AllowNonTemplates) {
85 WantExpressionKeywords =
false;
86 WantCXXNamedCasts =
false;
87 WantRemainingKeywords =
false;
92 if (!AllowInvalidDecl && ND->isInvalidDecl())
96 return AllowTemplates;
98 bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
102 if (AllowNonTemplates)
107 if (AllowTemplates) {
108 auto *RD = dyn_cast<CXXRecordDecl>(ND);
109 if (!RD || !RD->isInjectedClassName())
111 RD = cast<CXXRecordDecl>(RD->getDeclContext());
112 return RD->getDescribedClassTemplate() ||
113 isa<ClassTemplateSpecializationDecl>(RD);
119 return !WantClassName && candidate.
isKeyword();
122 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
123 return std::make_unique<TypeNameValidatorCCC>(*
this);
127 bool AllowInvalidDecl;
130 bool AllowNonTemplates;
136enum class UnqualifiedTypeNameLookupResult {
147static UnqualifiedTypeNameLookupResult
152 return UnqualifiedTypeNameLookupResult::NotFound;
154 UnqualifiedTypeNameLookupResult FoundTypeDecl =
155 UnqualifiedTypeNameLookupResult::NotFound;
158 if (
auto *BaseTT =
Base.getType()->getAs<
TagType>())
159 BaseRD = BaseTT->getAsCXXRecordDecl();
163 if (!TST || !TST->isDependentType())
165 auto *TD = TST->getTemplateName().getAsTemplateDecl();
168 if (
auto *BasePrimaryTemplate =
169 dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) {
171 BaseRD = BasePrimaryTemplate;
172 else if (
auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
174 CTD->findPartialSpecialization(
Base.getType()))
182 if (!isa<TypeDecl>(ND))
183 return UnqualifiedTypeNameLookupResult::FoundNonType;
184 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
186 if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
188 case UnqualifiedTypeNameLookupResult::FoundNonType:
189 return UnqualifiedTypeNameLookupResult::FoundNonType;
190 case UnqualifiedTypeNameLookupResult::FoundType:
191 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
193 case UnqualifiedTypeNameLookupResult::NotFound:
200 return FoundTypeDecl;
208 UnqualifiedTypeNameLookupResult FoundTypeDecl =
209 UnqualifiedTypeNameLookupResult::NotFound;
211 DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
215 RD = dyn_cast<CXXRecordDecl>(DC);
219 if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
225 S.
Diag(NameLoc, diag::ext_found_in_dependent_base) << &II;
247 bool WantNontrivialTypeSourceInfo =
true) {
249 case Type::DeducedTemplateSpecialization:
251 case Type::InjectedClassName:
254 case Type::UnresolvedUsing:
259 case Type::ObjCInterface:
260 case Type::ObjCTypeParam:
261 case Type::TemplateTypeParm:
264 llvm_unreachable(
"Unexpected Type Class");
272 if (!WantNontrivialTypeSourceInfo)
276 Builder.pushTypeSpec(
T).setNameLoc(NameLoc);
293 bool HasTrailingDot,
ParsedType ObjectTypePtr,
294 bool IsCtorOrDtorName,
295 bool WantNontrivialTypeSourceInfo,
296 bool IsClassTemplateDeductionContext,
300 bool AllowDeducedTemplate = IsClassTemplateDeductionContext &&
302 !isClassName && !HasTrailingDot;
327 !isClassName && !IsCtorOrDtorName)
329 bool IsImplicitTypename = !isClassName && !IsCtorOrDtorName;
330 if (IsImplicitTypename) {
333 Diag(QualifiedLoc, diag::warn_cxx17_compat_implicit_typename);
335 Diag(QualifiedLoc, diag::ext_implicit_typename)
342 if (WantNontrivialTypeSourceInfo)
375 if (ObjectTypePtr &&
Result.empty()) {
399 switch (
Result.getResultKind()) {
402 TypeNameValidatorCCC CCC(
true, isClassName,
403 AllowDeducedTemplate);
408 bool MemberOfUnknownSpecialization;
417 if (Correction && (NNS || NewII != &II) &&
423 Template, MemberOfUnknownSpecialization))) {
425 isClassName, HasTrailingDot, ObjectTypePtr,
427 WantNontrivialTypeSourceInfo,
428 IsClassTemplateDeductionContext);
431 PDiag(diag::err_unknown_type_or_class_name_suggest)
432 <<
Result.getLookupName() << isClassName);
435 *CorrectedII = NewII;
440 Result.suppressDiagnostics();
456 Result.suppressDiagnostics();
466 Result.suppressDiagnostics();
472 Res != ResEnd; ++Res) {
474 if (isa<TypeDecl, ObjCInterfaceDecl, UnresolvedUsingIfExistsDecl>(
481 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*Res);
493 Result.suppressDiagnostics();
504 IIDecl =
Result.getFoundDecl();
505 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*
Result.begin());
509 assert(IIDecl &&
"Didn't find decl");
512 if (
TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
516 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
517 auto *FoundRD = dyn_cast<CXXRecordDecl>(TD);
518 if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD &&
519 FoundRD->isInjectedClassName() &&
521 Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor)
532 FoundUsingShadow =
nullptr;
533 }
else if (
auto *UD = dyn_cast<UnresolvedUsingIfExistsDecl>(IIDecl)) {
537 }
else if (AllowDeducedTemplate) {
539 assert(!FoundUsingShadow || FoundUsingShadow->
getTargetDecl() == TD);
545 FoundUsingShadow =
nullptr;
551 Result.suppressDiagnostics();
555 if (FoundUsingShadow)
558 return buildNamedType(*
this, SS,
T, NameLoc, WantNontrivialTypeSourceInfo);
566 auto *ND = dyn_cast<NamespaceDecl>(DC);
567 if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
569 else if (
auto *RD = dyn_cast<CXXRecordDecl>(DC))
571 RD->getTypeForDecl());
572 else if (isa<TranslationUnitDecl>(DC))
575 llvm_unreachable(
"something isn't in TU scope?");
586 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
587 if (MD->getParent()->hasAnyDependentBases())
595 bool IsTemplateTypeArg) {
596 assert(
getLangOpts().MSVCCompat &&
"shouldn't be called in non-MSVC mode");
599 if (IsTemplateTypeArg &&
getCurScope()->isTemplateParamScope()) {
608 Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
614 RD->getTypeForDecl());
618 Diag(NameLoc, diag::ext_undeclared_unqual_id_with_dependent_base) << &II
654 switch (TD->getTagKind()) {
696 return S->isFunctionPrototypeScope();
706 bool IsTemplateName) {
711 SuggestedType =
nullptr;
715 TypeNameValidatorCCC CCC(
false,
false,
722 bool CanRecover = !IsTemplateName;
723 if (Corrected.isKeyword()) {
726 PDiag(IsTemplateName ? diag::err_no_template_suggest
727 : diag::err_unknown_typename_suggest)
729 II = Corrected.getCorrectionAsIdentifierInfo();
732 if (!SS || !SS->
isSet()) {
734 PDiag(IsTemplateName ? diag::err_no_template_suggest
735 : diag::err_unknown_typename_suggest)
738 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
739 bool DroppedSpecifier =
740 Corrected.WillReplaceSpecifier() && II->
getName() == CorrectedStr;
743 ? diag::err_no_member_template_suggest
744 : diag::err_unknown_nested_typename_suggest)
745 << II << DC << DroppedSpecifier << SS->
getRange(),
748 llvm_unreachable(
"could not have corrected a typo here");
755 if (Corrected.getCorrectionSpecifier())
760 getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), IILoc, S,
761 tmpSS.
isSet() ? &tmpSS : SS,
false,
false,
nullptr,
771 Name.setIdentifier(II, IILoc);
774 bool MemberOfUnknownSpecialization;
776 Name,
nullptr,
true, TemplateResult,
787 Diag(IILoc, IsTemplateName ? diag::err_no_template
788 : diag::err_unknown_typename)
791 Diag(IILoc, IsTemplateName ? diag::err_no_member_template
792 : diag::err_typename_nested_not_found)
798 unsigned DiagID = diag::err_typename_missing;
800 DiagID = diag::ext_typename_missing;
807 *SS, *II, IILoc).
get();
810 "Invalid scope specifier has already been diagnosed");
818 NextToken.
is(tok::less);
821 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
824 if (CheckTemplate && isa<TemplateDecl>(*I))
838 StringRef FixItTagName;
839 switch (Tag->getTagKind()) {
841 FixItTagName =
"class ";
845 FixItTagName =
"enum ";
849 FixItTagName =
"struct ";
853 FixItTagName =
"__interface ";
857 FixItTagName =
"union ";
861 StringRef TagName = FixItTagName.drop_back();
862 SemaRef.
Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
863 << Name << TagName << SemaRef.
getLangOpts().CPlusPlus
868 SemaRef.
Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
883 const Token &NextToken,
888 assert(NextToken.
isNot(tok::coloncolon) &&
889 "parse nested name specifiers before calling ClassifyName");
930 bool SecondTry =
false;
931 bool IsFilteredTemplateName =
false;
934 switch (
Result.getResultKind()) {
938 if (SS.
isEmpty() && NextToken.
is(tok::l_paren)) {
984 if (!SecondTry && CCC) {
989 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
990 unsigned QualifiedDiag = diag::err_no_member_suggest;
993 NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl();
995 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
996 UnqualifiedDiag = diag::err_no_template_suggest;
997 QualifiedDiag = diag::err_no_member_template_suggest;
998 }
else if (UnderlyingFirstDecl &&
999 (isa<TypeDecl>(UnderlyingFirstDecl) ||
1000 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
1001 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
1002 UnqualifiedDiag = diag::err_unknown_typename_suggest;
1003 QualifiedDiag = diag::err_unknown_nested_typename_suggest;
1009 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
1010 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
1011 Name->getName() == CorrectedStr;
1014 << DroppedSpecifier << SS.
getRange());
1018 Name = Corrected.getCorrectionAsIdentifierInfo();
1021 if (Corrected.isKeyword())
1027 Result.setLookupName(Corrected.getCorrection());
1049 Result.suppressDiagnostics();
1091 if (!
Result.isAmbiguous()) {
1092 IsFilteredTemplateName =
true;
1102 (IsFilteredTemplateName ||
1118 if (!IsFilteredTemplateName)
1121 bool IsFunctionTemplate;
1125 IsFunctionTemplate =
true;
1128 }
else if (!
Result.empty()) {
1132 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
1133 IsVarTemplate = isa<VarTemplateDecl>(TD);
1136 dyn_cast<UsingShadowDecl>(*
Result.begin());
1137 assert(!FoundUsingShadow ||
1138 TD == cast<TemplateDecl>(FoundUsingShadow->
getTargetDecl()));
1148 IsFunctionTemplate =
true;
1152 if (IsFunctionTemplate) {
1156 Result.suppressDiagnostics();
1167 if (
const auto *USD = dyn_cast<UsingShadowDecl>(Found))
1183 dyn_cast<ObjCCompatibleAliasDecl>(
FirstDecl))
1184 Class = Alias->getClassInterface();
1190 if (NextToken.
is(tok::period)) {
1193 Result.suppressDiagnostics();
1203 if (
auto *USD = dyn_cast<UsingShadowDecl>(
Result.getRepresentativeDecl()))
1209 if (
auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(
FirstDecl)) {
1222 bool NextIsOp = NextToken.
isOneOf(tok::amp, tok::star);
1223 if ((NextToken.
is(tok::identifier) ||
1225 FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
1237 if (
Result.isSingleResult() && !ADL &&
1242 Result.suppressDiagnostics();
1262 bool IsAddressOfOperand) {
1265 NameInfo, IsAddressOfOperand,
1272 const Token &NextToken) {
1289 auto *ULE = cast<UnresolvedLookupExpr>(E);
1290 if ((*ULE->decls_begin())->isCXXClassMember()) {
1292 SS.
Adopt(ULE->getQualifierLoc());
1297 Result.setNamingClass(ULE->getNamingClass());
1298 for (
auto I = ULE->decls_begin(), E = ULE->decls_end(); I != E; ++I)
1299 Result.addDecl(*I, I.getAccess());
1312 auto *TD = Name.getAsTemplateDecl();
1315 if (isa<ClassTemplateDecl>(TD))
1317 if (isa<FunctionTemplateDecl>(TD))
1319 if (isa<VarTemplateDecl>(TD))
1321 if (isa<TypeAliasTemplateDecl>(TD))
1323 if (isa<TemplateTemplateParmDecl>(TD))
1325 if (isa<ConceptDecl>(TD))
1332 "The next DeclContext should be lexically contained in the current one.");
1338 assert(
CurContext &&
"DeclContext imbalance!");
1341 assert(
CurContext &&
"Popped translation unit!");
1350 CurContext = cast<TagDecl>(D)->getDefinition();
1351 assert(
CurContext &&
"skipping definition of undefined tag");
1382 assert(!S->getEntity() &&
"scope already has entity");
1385 Scope *Ancestor = S->getParent();
1393 if (S->getParent()->isTemplateParamScope()) {
1401 assert(S->getEntity() ==
CurContext &&
"Context imbalance!");
1405 Scope *Ancestor = S->getParent();
1414 assert(S->isTemplateParamScope() &&
1415 "expected to be initializing a template parameter scope");
1439 for (; S && S->isTemplateParamScope(); S = S->getParent(), --ScopeDepth) {
1443 cast<Decl>(DC)->getDescribedTemplateParams()) {
1444 unsigned DCDepth = TPL->getDepth() + 1;
1445 if (DCDepth > ScopeDepth)
1447 if (ScopeDepth == DCDepth)
1452 S->setLookupEntity(SearchDCAfterScope);
1466 "The next DeclContext should be lexically contained in the current one.");
1470 for (
unsigned P = 0, NumParams = FD->
getNumParams();
P < NumParams; ++
P) {
1483 assert(
CurContext &&
"DeclContext imbalance!");
1485 assert(
CurContext &&
"Popped translation unit!");
1514 return ND->
hasAttr<OverloadableAttr>();
1517 return Previous.getFoundDecl()->hasAttr<OverloadableAttr>();
1527 while (S->getEntity() && S->getEntity()->isTransparentContext())
1542 if (isa<FunctionDecl>(D) &&
1543 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
1553 for (; I != IEnd; ++I) {
1565 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1572 if (!S->isDeclScope(*I))
1586 bool AllowInlineNamespace)
const {
1594 if (ScopeDC->getPrimaryContext() == TargetDC)
1596 }
while ((S = S->getParent()));
1608 bool ConsiderLinkage,
1609 bool AllowInlineNamespace) {
1670 if (NewIsModuleInterface || OldIsModuleInterface) {
1676 << NewIsModuleInterface
1678 << OldIsModuleInterface
1709 if (!IsNewExported && !IsOldExported)
1715 assert(IsNewExported);
1723 Diag(New->
getLocation(), diag::err_redeclaration_non_exported) << New << S;
1759 "New and Old are not the same definition, we should diagnostic it "
1760 "immediately instead of checking it.");
1763 "We shouldn't see unreachable definitions here.");
1811 return OldM == NewM;
1818 return isa<UsingShadowDecl>(D) ||
1819 isa<UnresolvedUsingTypenameDecl>(D) ||
1820 isa<UnresolvedUsingValueDecl>(D);
1848 return CD->isCopyConstructor();
1867 if (
const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1868 if (!RD->hasNameForLinkage())
1897 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1903 FD->getMemberSpecializationInfo() && !FD->isOutOfLine())
1906 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1911 if (FD->isInlined() && !
isMainFileLoc(*
this, FD->getLocation()))
1915 if (FD->doesThisDeclarationHaveABody() &&
1918 }
else if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1928 if (VD->isStaticDataMember() &&
1931 if (VD->isStaticDataMember() &&
1933 VD->getMemberSpecializationInfo() && !VD->isOutOfLine())
1936 if (VD->isInline() && !
isMainFileLoc(*
this, VD->getLocation()))
1945 return mightHaveNonExternalLinkage(D);
1952 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1958 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1973 if (
const auto *DD = dyn_cast<DecompositionDecl>(D)) {
1977 bool IsAllPlaceholders =
true;
1978 for (
const auto *BD : DD->bindings()) {
1979 if (BD->isReferenced() || BD->hasAttr<UnusedAttr>())
1981 IsAllPlaceholders = IsAllPlaceholders && BD->isPlaceholderVar(LangOpts);
1983 if (IsAllPlaceholders)
1994 if (D->
hasAttr<UnusedAttr>() || D->
hasAttr<ObjCPreciseLifetimeAttr>() ||
1998 if (isa<LabelDecl>(D))
2004 if (
const auto *R = dyn_cast<CXXRecordDecl>(D->
getDeclContext()))
2007 WithinFunction || (R->isLocalClass() && !R->isDependentType());
2008 if (!WithinFunction)
2011 if (isa<TypedefNameDecl>(D))
2015 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
2019 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2022 if (
const auto *Cleanups = dyn_cast_if_present<ExprWithCleanups>(
Init))
2023 Init = Cleanups->getSubExpr();
2025 const auto *Ty = VD->getType().getTypePtr();
2030 if (TT->getDecl()->hasAttr<UnusedAttr>())
2036 if (
const auto *MTE = dyn_cast_if_present<MaterializeTemporaryExpr>(
Init);
2037 MTE && MTE->getExtendingDecl()) {
2038 Ty = VD->getType().getNonReferenceType().getTypePtr();
2039 Init = MTE->getSubExpr()->IgnoreImplicitAsWritten();
2044 if (Ty->isIncompleteType() || Ty->isDependentType())
2049 Ty = Ty->getBaseElementTypeUnsafe();
2052 const TagDecl *Tag = TT->getDecl();
2053 if (Tag->
hasAttr<UnusedAttr>())
2056 if (
const auto *RD = dyn_cast<CXXRecordDecl>(Tag)) {
2057 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
2061 const auto *Construct =
2062 dyn_cast<CXXConstructExpr>(
Init->IgnoreImpCasts());
2063 if (Construct && !Construct->isElidable()) {
2065 if (!CD->
isTrivial() && !RD->hasAttr<WarnUnusedAttr>() &&
2066 (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
2072 if (
Init->isTypeDependent()) {
2074 if (!Ctor->isTrivial())
2080 if (isa<CXXUnresolvedConstructExpr>(
Init))
2094 if (isa<LabelDecl>(D)) {
2115 for (
auto *TmpD : D->
decls()) {
2116 if (
const auto *
T = dyn_cast<TypedefNameDecl>(TmpD))
2118 else if(
const auto *R = dyn_cast<RecordDecl>(TmpD))
2134 if (
auto *TD = dyn_cast<TypedefNameDecl>(D)) {
2145 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
2146 DiagID = diag::warn_unused_exception_param;
2147 else if (isa<LabelDecl>(D))
2148 DiagID = diag::warn_unused_label;
2150 DiagID = diag::warn_unused_variable;
2169 if (Ty->isReferenceType() || Ty->isDependentType())
2173 const TagDecl *Tag = TT->getDecl();
2174 if (Tag->
hasAttr<UnusedAttr>())
2178 if (
const auto *RD = dyn_cast<CXXRecordDecl>(Tag);
2179 RD && !RD->hasAttr<WarnUnusedAttr>())
2186 if (VD->
hasAttr<BlocksAttr>() && Ty->isObjCObjectPointerType())
2192 if (VD->
hasAttr<ObjCPreciseLifetimeAttr>() && Ty->isObjCObjectPointerType())
2199 assert(iter->getSecond() >= 0 &&
2200 "Found a negative number of references to a VarDecl");
2201 if (
int RefCnt = iter->getSecond(); RefCnt > 0) {
2211 bool UnusedCXXCondDecl = VD->
isCXXCondDecl() && (RefCnt == 1);
2212 if (!UnusedCXXCondDecl)
2216 unsigned DiagID = isa<ParmVarDecl>(VD) ? diag::warn_unused_but_set_parameter
2217 : diag::warn_unused_but_set_variable;
2227 bool Diagnose =
false;
2231 Diagnose = L->
getStmt() ==
nullptr;
2240 if (S->decl_empty())
return;
2242 "Scope shouldn't contain decls!");
2249 std::optional<SourceLocation> PreviousDeclLoc;
2254 DeclDiags.push_back(LocAndDiag{
Loc, std::nullopt, std::move(PD)});
2259 DeclDiags.push_back(LocAndDiag{
Loc, PreviousDeclLoc, std::move(PD)});
2262 for (
auto *TmpD : S->decls()) {
2263 assert(TmpD &&
"This decl didn't get pushed??");
2265 assert(isa<NamedDecl>(TmpD) &&
"Decl isn't NamedDecl?");
2269 if (!S->hasUnrecoverableErrorOccurred()) {
2271 if (
const auto *RD = dyn_cast<RecordDecl>(D))
2273 if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
2282 if (
LabelDecl *LD = dyn_cast<LabelDecl>(D))
2288 auto ShadowI = ShadowingDecls.find(D);
2289 if (ShadowI != ShadowingDecls.end()) {
2290 if (
const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
2291 addDiagWithPrev(D->
getLocation(), FD->getLocation(),
2292 PDiag(diag::warn_ctor_parm_shadows_field)
2293 << D << FD << FD->getParent());
2295 ShadowingDecls.erase(ShadowI);
2299 llvm::sort(DeclDiags,
2300 [](
const LocAndDiag &LHS,
const LocAndDiag &RHS) ->
bool {
2305 return LHS.Loc.getRawEncoding() < RHS.Loc.getRawEncoding();
2307 for (
const LocAndDiag &D : DeclDiags) {
2309 if (D.PreviousDeclLoc)
2310 Diag(*D.PreviousDeclLoc, diag::note_previous_declaration);
2339 (S->getEntity() && S->getEntity()->isTransparentContext()) ||
2357 return "ucontext.h";
2359 llvm_unreachable(
"unhandled error kind");
2370 Parent->addDecl(CLinkageDecl);
2385 for (
unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2388 FT->getParamType(i),
nullptr,
SC_None,
nullptr);
2390 Params.push_back(parm);
2392 New->setParams(Params);
2404 Scope *S,
bool ForRedeclaration,
2411 if (!ForRedeclaration)
2423 Diag(
Loc, diag::warn_implicit_decl_no_jmp_buf)
2430 Diag(
Loc, diag::warn_implicit_decl_requires_sysheader)
2436 if (!ForRedeclaration &&
2440 : diag::ext_implicit_lib_function_decl)
2443 Diag(
Loc, diag::note_include_header_or_declare)
2480 while (Filter.hasNext()) {
2489 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2491 Decl->getUnderlyingType()))
2496 if (OldTD->getAnonDeclWithTypedefName(
true) &&
2497 Decl->getAnonDeclWithTypedefName())
2509 if (
const TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
2510 OldType = OldTypedef->getUnderlyingType();
2517 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2518 Diag(New->
getLocation(), diag::err_redefinition_variably_modified_typedef)
2526 if (OldType != NewType &&
2530 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2532 << Kind << NewType << OldType;
2556 switch (TypeID->getLength()) {
2560 if (!TypeID->isStr(
"id"))
2576 if (!TypeID->isStr(
"Class"))
2583 if (!TypeID->isStr(
"SEL"))
2610 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2611 auto *OldTag = OldTD->getAnonDeclWithTypedefName(
true);
2614 if (OldTag && NewTag &&
2615 OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
2620 if (OldTD->isModed())
2622 OldTD->getUnderlyingType());
2631 if (isa<EnumDecl>(NewTag)) {
2633 for (
auto *D : NewTag->decls()) {
2634 auto *ED = cast<EnumConstantDecl>(D);
2638 ED->getLexicalDeclContext()->removeDecl(ED);
2688 if (!isa<TypedefNameDecl>(Old))
2720 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
2721 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
2722 for (
const auto *i : D->
attrs())
2723 if (i->getKind() == A->
getKind()) {
2725 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
2730 if (OA && isa<OwnershipAttr>(i))
2731 return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
2739 if (
VarDecl *VD = dyn_cast<VarDecl>(D))
2740 return VD->isThisDeclarationADefinition();
2741 if (
TagDecl *TD = dyn_cast<TagDecl>(D))
2742 return TD->isCompleteDefinition() || TD->isBeingDefined();
2753 AlignedAttr *OldAlignasAttr =
nullptr;
2754 AlignedAttr *OldStrictestAlignAttr =
nullptr;
2755 unsigned OldAlign = 0;
2763 if (I->isAlignmentDependent())
2769 unsigned Align = I->getAlignment(S.
Context);
2770 if (Align > OldAlign) {
2772 OldStrictestAlignAttr = I;
2777 AlignedAttr *NewAlignasAttr =
nullptr;
2778 unsigned NewAlign = 0;
2780 if (I->isAlignmentDependent())
2786 unsigned Align = I->getAlignment(S.
Context);
2787 if (Align > NewAlign)
2791 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2799 if (OldAlign == 0 || NewAlign == 0) {
2801 if (
ValueDecl *VD = dyn_cast<ValueDecl>(New))
2812 if (OldAlign != NewAlign) {
2813 S.
Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2816 S.
Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2831 S.
Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2835 bool AnyAdded =
false;
2838 if (OldAlign > NewAlign) {
2839 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.
Context);
2840 Clone->setInherited(
true);
2846 if (OldAlignasAttr && !NewAlignasAttr &&
2847 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2848 AlignedAttr *Clone = OldAlignasAttr->clone(S.
Context);
2849 Clone->setInherited(
true);
2857#define WANT_DECL_MERGE_LOGIC
2858#include "clang/Sema/AttrParsedAttrImpl.inc"
2859#undef WANT_DECL_MERGE_LOGIC
2866 if (!DiagnoseMutualExclusions(S, D,
Attr))
2877 if (
const auto *AA = dyn_cast<AvailabilityAttr>(
Attr))
2879 D, *AA, AA->getPlatform(), AA->
isImplicit(), AA->getIntroduced(),
2880 AA->getDeprecated(), AA->getObsoleted(), AA->getUnavailable(),
2881 AA->getMessage(), AA->getStrict(), AA->getReplacement(), AMK,
2882 AA->getPriority(), AA->getEnvironment());
2883 else if (
const auto *VA = dyn_cast<VisibilityAttr>(
Attr))
2885 else if (
const auto *VA = dyn_cast<TypeVisibilityAttr>(
Attr))
2887 else if (
const auto *ImportA = dyn_cast<DLLImportAttr>(
Attr))
2889 else if (
const auto *ExportA = dyn_cast<DLLExportAttr>(
Attr))
2891 else if (
const auto *EA = dyn_cast<ErrorAttr>(
Attr))
2893 else if (
const auto *FA = dyn_cast<FormatAttr>(
Attr))
2894 NewAttr = S.
mergeFormatAttr(D, *FA, FA->getType(), FA->getFormatIdx(),
2896 else if (
const auto *SA = dyn_cast<SectionAttr>(
Attr))
2898 else if (
const auto *CSA = dyn_cast<CodeSegAttr>(
Attr))
2900 else if (
const auto *IA = dyn_cast<MSInheritanceAttr>(
Attr))
2902 IA->getInheritanceModel());
2903 else if (
const auto *AA = dyn_cast<AlwaysInlineAttr>(
Attr))
2906 else if (S.
getLangOpts().CUDA && isa<FunctionDecl>(D) &&
2907 (isa<CUDAHostAttr>(
Attr) || isa<CUDADeviceAttr>(
Attr) ||
2908 isa<CUDAGlobalAttr>(
Attr))) {
2912 }
else if (
const auto *MA = dyn_cast<MinSizeAttr>(
Attr))
2914 else if (
const auto *SNA = dyn_cast<SwiftNameAttr>(
Attr))
2916 else if (
const auto *OA = dyn_cast<OptimizeNoneAttr>(
Attr))
2918 else if (
const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(
Attr))
2920 else if (isa<AlignedAttr>(
Attr))
2924 else if ((isa<DeprecatedAttr>(
Attr) || isa<UnavailableAttr>(
Attr)) &&
2929 else if (
const auto *UA = dyn_cast<UuidAttr>(
Attr))
2930 NewAttr = S.
mergeUuidAttr(D, *UA, UA->getGuid(), UA->getGuidDecl());
2931 else if (
const auto *IMA = dyn_cast<WebAssemblyImportModuleAttr>(
Attr))
2933 else if (
const auto *INA = dyn_cast<WebAssemblyImportNameAttr>(
Attr))
2935 else if (
const auto *TCBA = dyn_cast<EnforceTCBAttr>(
Attr))
2937 else if (
const auto *TCBLA = dyn_cast<EnforceTCBLeafAttr>(
Attr))
2939 else if (
const auto *BTFA = dyn_cast<BTFDeclTagAttr>(
Attr))
2941 else if (
const auto *NT = dyn_cast<HLSLNumThreadsAttr>(
Attr))
2944 else if (
const auto *SA = dyn_cast<HLSLShaderAttr>(
Attr))
2946 else if (isa<SuppressAttr>(
Attr))
2955 if (isa<MSInheritanceAttr>(NewAttr))
2964 if (
const TagDecl *TD = dyn_cast<TagDecl>(D))
2965 return TD->getDefinition();
2966 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2972 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2974 if (FD->isDefined(Def,
true))
2981 for (
const auto *Attribute : D->
attrs())
2982 if (Attribute->getKind() == Kind)
2994 if (!Def || Def == New)
2998 for (
unsigned I = 0, E = NewAttributes.size(); I != E;) {
2999 const Attr *NewAttribute = NewAttributes[I];
3001 if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {
3008 NewAttributes.erase(NewAttributes.begin() + I);
3013 VarDecl *VD = cast<VarDecl>(New);
3014 unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
3016 ? diag::err_alias_after_tentative
3017 : diag::err_redefinition;
3019 if (
Diag == diag::err_redefinition)
3029 if (
const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
3042 if (isa<C11NoReturnAttr>(NewAttribute)) {
3046 }
else if (isa<UuidAttr>(NewAttribute)) {
3050 }
else if (
const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
3051 if (AA->isAlignas()) {
3062 S.
Diag(NewAttribute->
getLocation(), diag::note_alignas_on_declaration)
3064 NewAttributes.erase(NewAttributes.begin() + I);
3068 }
else if (isa<LoaderUninitializedAttr>(NewAttribute)) {
3074 diag::err_loader_uninitialized_redeclaration);
3076 NewAttributes.erase(NewAttributes.begin() + I);
3080 }
else if (isa<SelectAnyAttr>(NewAttribute) &&
3081 cast<VarDecl>(New)->isInline() &&
3082 !cast<VarDecl>(New)->isInlineSpecified()) {
3089 }
else if (isa<OMPDeclareVariantAttr>(NewAttribute)) {
3097 diag::warn_attribute_precede_definition);
3099 NewAttributes.erase(NewAttributes.begin() + I);
3105 const ConstInitAttr *CIAttr,
3106 bool AttrBeforeInit) {
3113 std::string SuitableSpelling;
3115 SuitableSpelling = std::string(
3117 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3119 InsertLoc, {tok::l_square, tok::l_square,
3120 S.PP.getIdentifierInfo(
"clang"), tok::coloncolon,
3121 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3122 tok::r_square, tok::r_square}));
3123 if (SuitableSpelling.empty())
3125 InsertLoc, {tok::kw___attribute, tok::l_paren, tok::r_paren,
3126 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3127 tok::r_paren, tok::r_paren}));
3128 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus20)
3129 SuitableSpelling =
"constinit";
3130 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3131 SuitableSpelling =
"[[clang::require_constant_initialization]]";
3132 if (SuitableSpelling.empty())
3133 SuitableSpelling =
"__attribute__((require_constant_initialization))";
3134 SuitableSpelling +=
" ";
3136 if (AttrBeforeInit) {
3139 assert(CIAttr->isConstinit() &&
"should not diagnose this for attribute");
3142 S.
Diag(CIAttr->getLocation(), diag::note_constinit_specified_here);
3146 S.
Diag(CIAttr->getLocation(),
3147 CIAttr->isConstinit() ? diag::err_constinit_added_too_late
3148 : diag::warn_require_const_init_added_too_late)
3151 << CIAttr->isConstinit()
3160 UsedAttr *NewAttr = OldAttr->clone(
Context);
3161 NewAttr->setInherited(
true);
3165 RetainAttr *NewAttr = OldAttr->clone(
Context);
3166 NewAttr->setInherited(
true);
3176 const auto *OldConstInit = Old->
getAttr<ConstInitAttr>();
3177 const auto *NewConstInit = New->
getAttr<ConstInitAttr>();
3178 if (
bool(OldConstInit) !=
bool(NewConstInit)) {
3179 const auto *OldVD = cast<VarDecl>(Old);
3180 auto *NewVD = cast<VarDecl>(New);
3186 (NewVD->hasInit() || NewVD->isThisDeclarationADefinition()))
3189 if (InitDecl == NewVD) {
3193 if (OldConstInit && OldConstInit->isConstinit())
3196 }
else if (NewConstInit) {
3200 if (InitDecl && InitDecl != NewVD) {
3203 NewVD->dropAttr<ConstInitAttr>();
3211 if (AsmLabelAttr *NewA = New->
getAttr<AsmLabelAttr>()) {
3212 if (AsmLabelAttr *OldA = Old->
getAttr<AsmLabelAttr>()) {
3213 if (!OldA->isEquivalent(NewA)) {
3216 Diag(OldA->getLocation(), diag::note_previous_declaration);
3218 }
else if (Old->
isUsed()) {
3222 << isa<FunctionDecl>(Old) << New->
getAttr<AsmLabelAttr>()->
getRange();
3227 if (
const auto *NewAbiTagAttr = New->
getAttr<AbiTagAttr>()) {
3228 if (
const auto *OldAbiTagAttr = Old->
getAttr<AbiTagAttr>()) {
3229 for (
const auto &NewTag : NewAbiTagAttr->tags()) {
3230 if (!llvm::is_contained(OldAbiTagAttr->tags(), NewTag)) {
3231 Diag(NewAbiTagAttr->getLocation(),
3232 diag::err_new_abi_tag_on_redeclaration)
3234 Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
3238 Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
3244 if (New->
hasAttr<SectionAttr>() && !Old->
hasAttr<SectionAttr>()) {
3245 if (
auto *VD = dyn_cast<VarDecl>(New)) {
3247 Diag(New->
getLocation(), diag::warn_attribute_section_on_redeclaration);
3254 const auto *NewCSA = New->
getAttr<CodeSegAttr>();
3255 if (NewCSA && !Old->
hasAttr<CodeSegAttr>() &&
3256 !NewCSA->isImplicit() && isa<CXXMethodDecl>(New)) {
3274 if (isa<DeprecatedAttr>(I) ||
3275 isa<UnavailableAttr>(I) ||
3276 isa<AvailabilityAttr>(I)) {
3291 if (isa<UsedAttr>(I) || isa<RetainAttr>(I))
3313 const CarriesDependencyAttr *CDA = newDecl->
getAttr<CarriesDependencyAttr>();
3314 if (CDA && !oldDecl->
hasAttr<CarriesDependencyAttr>()) {
3315 S.
Diag(CDA->getLocation(),
3316 diag::err_carries_dependency_missing_on_first_decl) << 1;
3324 diag::note_carries_dependency_missing_first_decl) << 1;
3332 const auto *NDAttr = newDecl->
getAttr<HLSLParamModifierAttr>();
3333 const auto *ODAttr = oldDecl->
getAttr<HLSLParamModifierAttr>();
3338 if (NDAttr && ODAttr &&
3339 NDAttr->getSpellingListIndex() != ODAttr->getSpellingListIndex()) {
3340 S.
Diag(newDecl->
getLocation(), diag::err_hlsl_param_qualifier_mismatch)
3341 << NDAttr << newDecl;
3350 bool foundAny = newDecl->
hasAttrs();
3359 cast<InheritableParamAttr>(I->clone(S.
Context));
3372 auto NoSizeInfo = [&Ctx](
QualType Ty) {
3373 if (Ty->isIncompleteArrayType() || Ty->isPointerType())
3381 if (NoSizeInfo(Old) && NoSizeInfo(New))
3413 if (*Oldnullability != *Newnullability) {
3414 S.
Diag(NewParam->
getLocation(), diag::warn_mismatched_nullability_attr)
3433 const auto *OldParamDT = dyn_cast<DecayedType>(OldParam->
getType());
3434 const auto *NewParamDT = dyn_cast<DecayedType>(NewParam->
getType());
3435 if (OldParamDT && NewParamDT &&
3436 OldParamDT->getPointeeType() == NewParamDT->getPointeeType()) {
3437 QualType OldParamOT = OldParamDT->getOriginalType();
3438 QualType NewParamOT = NewParamDT->getOriginalType();
3441 << NewParam << NewParamOT;
3452struct GNUCompatibleParamWarning {
3462template <
typename T>
3463static std::pair<diag::kind, SourceLocation>
3467 if (Old->isThisDeclarationADefinition())
3468 PrevDiag = diag::note_previous_definition;
3469 else if (Old->isImplicit()) {
3470 PrevDiag = diag::note_previous_implicit_declaration;
3471 if (
const auto *FD = dyn_cast<FunctionDecl>(Old)) {
3472 if (FD->getBuiltinID())
3473 PrevDiag = diag::note_previous_builtin_declaration;
3476 OldLocation = New->getLocation();
3478 PrevDiag = diag::note_previous_declaration;
3479 return std::make_pair(PrevDiag, OldLocation);
3487 return ((FD->
hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
3488 !LangOpts.CPlusPlus &&
3500template <
typename T>
3514template<
typename T>
static bool isExternC(
T *D) {
return D->isExternC(); }
3521template<
typename ExpectedDecl>
3543 !Old->getDeclContext()->getRedeclContext()->Equals(
3544 New->getDeclContext()->getRedeclContext()) &&
3549 S.
Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
3562 const auto *AttrA = A->
getAttr<PassObjectSizeAttr>();
3563 const auto *AttrB = B->
getAttr<PassObjectSizeAttr>();
3566 return AttrA && AttrB && AttrA->getType() == AttrB->getType() &&
3567 AttrA->isDynamic() == AttrB->isDynamic();
3593 if (NamedDC->Equals(SemaDC))
3596 assert((NamedDC->InEnclosingNamespaceSetOf(SemaDC) ||
3598 "unexpected context for redeclaration");
3609 if (
auto *FD = dyn_cast<FunctionDecl>(NewD))
3610 FixSemaDC(FD->getDescribedFunctionTemplate());
3611 else if (
auto *VD = dyn_cast<VarDecl>(NewD))
3612 FixSemaDC(VD->getDescribedVarTemplate());
3627 bool MergeTypeWithOld,
bool NewDeclIsDefn) {
3634 Diag(Shadow->getTargetDecl()->getLocation(),
3635 diag::note_using_decl_target);
3636 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
3645 if (checkUsingShadowRedecl<FunctionTemplateDecl>(*
this, Shadow,
3648 OldD = Old = cast<FunctionTemplateDecl>(Shadow->getTargetDecl())
3651 if (checkUsingShadowRedecl<FunctionDecl>(*
this, Shadow, New))
3653 OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
3681 std::tie(PrevDiag, OldLocation) =
3688 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
3695 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3698 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3703 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
3704 if (!Old->
hasAttr<InternalLinkageAttr>()) {
3708 New->
dropAttr<InternalLinkageAttr>();
3711 if (
auto *EA = New->
getAttr<ErrorAttr>()) {
3712 if (!Old->
hasAttr<ErrorAttr>()) {
3713 Diag(EA->getLocation(), diag::err_attribute_missing_on_first_decl) << EA;
3723 bool OldOvl = Old->
hasAttr<OverloadableAttr>();
3734 const Decl *DiagOld = Old;
3736 auto OldIter = llvm::find_if(Old->
redecls(), [](
const Decl *D) {
3737 const auto *A = D->getAttr<OverloadableAttr>();
3738 return A && !A->isImplicit();
3742 DiagOld = OldIter == Old->
redecls_end() ? nullptr : *OldIter;
3747 diag::note_attribute_overloadable_prev_overload)
3762 Diag(OldLocation, diag::note_previous_declaration);
3781 const FunctionType *OldType = cast<FunctionType>(OldQType);
3782 const FunctionType *NewType = cast<FunctionType>(NewQType);
3785 bool RequiresAdjustment =
false;
3787 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC()) {
3793 if (!NewCCExplicit) {
3797 RequiresAdjustment =
true;
3809 RequiresAdjustment =
true;
3816 << (!FirstCCExplicit ?
"" :
3820 Diag(
First->getLocation(), diag::note_previous_declaration);
3828 RequiresAdjustment =
true;
3838 Diag(OldLocation, diag::note_previous_declaration);
3843 RequiresAdjustment =
true;
3850 <<
"'ns_returns_retained'";
3851 Diag(OldLocation, diag::note_previous_declaration);
3856 RequiresAdjustment =
true;
3862 AnyX86NoCallerSavedRegistersAttr *
Attr =
3863 New->
getAttr<AnyX86NoCallerSavedRegistersAttr>();
3865 Diag(OldLocation, diag::note_previous_declaration);
3870 RequiresAdjustment =
true;
3873 if (RequiresAdjustment) {
3883 !New->
hasAttr<GNUInlineAttr>() &&
3892 if (New->
hasAttr<GNUInlineAttr>() &&
3903 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3920 OldDeclaredReturnType)) {
3928 Diag(New->
getLocation(), diag::err_member_def_does_not_match_ret_type)
3933 Diag(OldLocation, PrevDiag) << Old << Old->
getType()
3942 QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
3943 if (OldReturnType != NewReturnType) {
3959 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
3961 if (OldMethod && NewMethod) {
3968 bool IsClassScopeExplicitSpecialization =
3974 !IsClassScopeExplicitSpecialization) {
3980 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
3990 if (isa<CXXConstructorDecl>(OldMethod))
3991 NewDiag = diag::err_constructor_redeclared;
3992 else if (isa<CXXDestructorDecl>(NewMethod))
3993 NewDiag = diag::err_destructor_redeclared;
3994 else if (isa<CXXConversionDecl>(NewMethod))
3995 NewDiag = diag::err_conv_function_redeclared;
3997 NewDiag = diag::err_member_redeclared;
4001 Diag(New->
getLocation(), diag::err_member_redeclared_in_instantiation)
4004 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4017 diag::err_definition_of_implicitly_declared_member)
4023 diag::err_definition_of_explicitly_defaulted_member)
4046 if (
const auto *NRA = New->
getAttr<CXX11NoReturnAttr>())
4047 if (!Old->
hasAttr<CXX11NoReturnAttr>()) {
4048 Diag(NRA->getLocation(), diag::err_attribute_missing_on_first_decl)
4057 const CarriesDependencyAttr *CDA = New->
getAttr<CarriesDependencyAttr>();
4058 if (CDA && !Old->
hasAttr<CarriesDependencyAttr>()) {
4059 Diag(CDA->getLocation(),
4060 diag::err_carries_dependency_missing_on_first_decl) << 0;
4062 diag::note_carries_dependency_missing_first_decl) << 0;
4071 QualType OldQTypeForComparison = OldQType;
4076 OldQTypeForComparison =
QualType(OldTypeForComparison, 0);
4091 Diag(OldLocation, PrevDiag);
4093 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4094 Diag(OldLocation, PrevDiag);
4165 bool IsWithoutProtoADef =
false, IsWithProtoADef =
false;
4166 if (WithoutProto == New)
4167 IsWithoutProtoADef = NewDeclIsDefn;
4169 IsWithProtoADef = NewDeclIsDefn;
4171 diag::warn_non_prototype_changes_behavior)
4172 << IsWithoutProtoADef << (WithoutProto->
getNumParams() ? 0 : 1)
4173 << (WithoutProto == Old) << IsWithProtoADef;
4183 !IsWithoutProtoADef)
4193 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
4194 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
4197 assert(!OldProto->hasExceptionSpec() &&
"Exception spec in C");
4199 OldProto->getParamTypes(),
4200 OldProto->getExtProtoInfo());
4206 for (
const auto &ParamType : OldProto->param_types()) {
4209 ParamType,
nullptr,
SC_None,
nullptr);
4212 Params.push_back(Param);
4215 New->setParams(Params);
4251 NewProto->getReturnType());
4252 bool LooseCompatible = !MergedReturn.
isNull();
4254 LooseCompatible && Idx != End; ++Idx) {
4258 NewProto->getParamType(Idx))) {
4259 ArgTypes.push_back(NewParm->
getType());
4263 GNUCompatibleParamWarning Warn = { OldParm, NewParm,
4264 NewProto->getParamType(Idx) };
4265 Warnings.push_back(Warn);
4266 ArgTypes.push_back(NewParm->
getType());
4268 LooseCompatible =
false;
4271 if (LooseCompatible) {
4272 for (
unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
4273 Diag(Warnings[Warn].NewParm->getLocation(),
4274 diag::ext_param_promoted_not_compatible_with_prototype)
4275 << Warnings[Warn].PromotedType
4276 << Warnings[Warn].OldParm->getType();
4277 if (Warnings[Warn].OldParm->getLocation().isValid())
4278 Diag(Warnings[Warn].OldParm->getLocation(),
4279 diag::note_previous_declaration);
4282 if (MergeTypeWithOld)
4302 Diag(OldLocation, diag::note_previous_builtin_declaration)
4307 PrevDiag = diag::note_previous_builtin_declaration;
4311 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4325 Scope *S,
bool MergeTypeWithOld) {
4340 for (
unsigned i = 0, e = New->
getNumParams(); i != e; ++i) {
4354 if (!Merged.isNull() && MergeTypeWithOld)
4377 ni != ne && oi != oe; ++ni, ++oi)
4387 ? diag::err_redefinition_different_type
4388 : diag::err_redeclaration_different_type)
4393 std::tie(PrevDiag, OldLocation)
4395 S.
Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4407 bool MergeTypeWithOld) {
4435 QualType PrevVDTy = PrevVD->getType();
4489 if (MergeTypeWithOld)
4535 if (!shouldLinkPossiblyHiddenDecl(
Previous, New))
4545 OldTemplate = dyn_cast<VarTemplateDecl>(
Previous.getFoundDecl());
4549 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4550 if (checkUsingShadowRedecl<VarTemplateDecl>(*
this, Shadow, NewTemplate))
4553 Old = dyn_cast<VarDecl>(
Previous.getFoundDecl());
4556 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4557 if (checkUsingShadowRedecl<VarDecl>(*
this, Shadow, New))
4594 if (New->
hasAttr<WeakImportAttr>() &&
4596 !Old->
hasAttr<WeakImportAttr>()) {
4603 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
4604 if (!Old->
hasAttr<InternalLinkageAttr>()) {
4608 New->
dropAttr<InternalLinkageAttr>();
4613 if (MostRecent != Old) {
4626 std::tie(PrevDiag, OldLocation) =
4636 Diag(OldLocation, PrevDiag);
4640 Diag(OldLocation, PrevDiag);
4659 Diag(OldLocation, PrevDiag);
4667 Diag(OldLocation, PrevDiag);
4673 Diag(OldLocation, PrevDiag);
4689 Diag(OldLocation, PrevDiag);
4699 Diag(Def->getLocation(), diag::note_previous_definition);
4713 Diag(OldLocation, PrevDiag);
4716 Diag(OldLocation, PrevDiag);
4724 Diag(OldLocation, PrevDiag);
4734 diag::warn_deprecated_redundant_constexpr_static_def);
4743 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4744 Diag(OldLocation, PrevDiag);
4774 StringRef HdrFilename =
4777 auto noteFromModuleOrInclude = [&](
Module *Mod,
4783 if (IncLoc.isValid()) {
4785 Diag(IncLoc, diag::note_redefinition_modules_same_file)
4791 Diag(IncLoc, diag::note_redefinition_include_same_file)
4792 << HdrFilename.str();
4802 if (FNew == FOld && FNewDecLoc.second == FOldDecLoc.second) {
4810 if (FOld && !HSI.isFileMultipleIncludeGuarded(*FOld))
4827 isa<VarTemplateSpecializationDecl>(New) ||
4865 ? S->getMSCurManglingNumber()
4866 : S->getMSLastManglingNumber();
4873 if (isa<CXXRecordDecl>(Tag->
getParent())) {
4888 Decl *ManglingContextDecl;
4889 std::tie(MCtx, ManglingContextDecl) =
4899struct NonCLikeKind {
4911 explicit operator bool() {
return Kind !=
None; }
4919 return {NonCLikeKind::Invalid, {}};
4926 return {NonCLikeKind::BaseClass,
4938 if (
auto *FD = dyn_cast<FieldDecl>(D)) {
4939 if (FD->hasInClassInitializer()) {
4940 auto *
Init = FD->getInClassInitializer();
4941 return {NonCLikeKind::DefaultMemberInit,
4949 if (isa<FriendDecl>(D))
4954 if (isa<StaticAssertDecl>(D) || isa<IndirectFieldDecl>(D) ||
4957 auto *MemberRD = dyn_cast<CXXRecordDecl>(D);
4965 if (MemberRD->isLambda())
4966 return {NonCLikeKind::Lambda, MemberRD->getSourceRange()};
4970 if (MemberRD->isThisDeclarationADefinition()) {
4976 return {
Invalid ? NonCLikeKind::Invalid : NonCLikeKind::None, {}};
5006 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TagFromDeclSpec);
5010 if (NonCLike || ChangesLinkage) {
5011 if (NonCLike.Kind == NonCLikeKind::Invalid)
5014 unsigned DiagID = diag::ext_non_c_like_anon_struct_in_typedef;
5015 if (ChangesLinkage) {
5017 if (NonCLike.Kind == NonCLikeKind::None)
5018 DiagID = diag::err_typedef_changes_linkage;
5020 DiagID = diag::err_non_c_like_anon_struct_in_typedef;
5026 TextToInsert +=
' ';
5029 Diag(FixitLoc, DiagID)
5030 << isa<TypeAliasDecl>(NewTD)
5032 if (NonCLike.Kind != NonCLikeKind::None) {
5033 Diag(NonCLike.Range.getBegin(), diag::note_non_c_like_anon_struct)
5034 << NonCLike.Kind - 1 << NonCLike.Range;
5037 << NewTD << isa<TypeAliasDecl>(NewTD);
5059 if (
const auto *ED = dyn_cast<EnumDecl>(DS.
getRepAsDecl())) {
5060 if (ED->isScopedUsingClassTag())
5067 llvm_unreachable(
"unexpected type specifier");
5077 bool IsExplicitInstantiation,
5079 Decl *TagD =
nullptr;
5094 if (isa<TagDecl>(TagD))
5095 Tag = cast<TagDecl>(TagD);
5097 Tag = CTD->getTemplatedDecl();
5112 diag::err_typecheck_invalid_restrict_not_pointer_noarg)
5149 bool DeclaresAnything =
true;
5153 if (!
Record->getDeclName() &&
Record->isCompleteDefinition() &&
5156 Record->getDeclContext()->isRecord()) {
5170 DeclaresAnything =
false;
5193 Record = dyn_cast<RecordDecl>(Tag);
5206 DeclaresAnything =
false;
5218 if (
Enum->enumerator_begin() ==
Enum->enumerator_end() &&
5219 !
Enum->getIdentifier() && !
Enum->isInvalidDecl())
5220 DeclaresAnything =
false;
5228 DeclaresAnything =
false;
5247 if (!DeclaresAnything) {
5250 Diag(DS.
getBeginLoc(), (IsExplicitInstantiation || !TemplateParams.empty())
5251 ? diag::err_no_declarators
5252 : diag::ext_no_declarators)
5265 unsigned DiagID = diag::warn_standalone_specifier;
5267 DiagID = diag::ext_standalone_specifier;
5308 auto EmitAttributeDiagnostic = [
this, &DS](
const ParsedAttr &AL) {
5309 unsigned DiagnosticId = diag::warn_declspec_attribute_ignored;
5311 DiagnosticId = diag::warn_attribute_ignored;
5312 else if (AL.isRegularKeywordAttribute())
5313 DiagnosticId = diag::err_declspec_keyword_has_no_effect;
5315 DiagnosticId = diag::warn_declspec_attribute_ignored;
5316 Diag(AL.getLoc(), DiagnosticId)
5320 llvm::for_each(DS.
getAttributes(), EmitAttributeDiagnostic);
5321 llvm::for_each(DeclAttrs, EmitAttributeDiagnostic);
5340 RedeclarationKind::ForVisibleRedeclaration);
5345 assert(PrevDecl &&
"Expected a non-null Decl");
5358 SemaRef.
Diag(NameLoc, diag::err_anonymous_record_member_redecl)
5360 SemaRef.
Diag(PrevDecl->
getLocation(), diag::note_previous_declaration);
5366 if (
auto *RD = dyn_cast_if_present<RecordDecl>(D))
5380 if (
Record->isAnonymousStructOrUnion())
5385 const NamedDecl *ND = dyn_cast<NamedDecl>(D);
5419 for (
auto *D : AnonRecord->
decls()) {
5420 if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) &&
5421 cast<NamedDecl>(D)->getDeclName()) {
5437 unsigned OldChainingSize = Chaining.size();
5439 Chaining.append(IF->chain_begin(), IF->chain_end());
5441 Chaining.push_back(VD);
5443 assert(Chaining.size() >= 2);
5446 for (
unsigned i = 0; i < Chaining.size(); i++)
5447 NamedChain[i] = Chaining[i];
5451 VD->
getType(), {NamedChain, Chaining.size()});
5463 Chaining.resize(OldChainingSize);
5478 "Parser allowed 'typedef' as storage class VarDecl.");
5479 switch (StorageClassSpec) {
5493 llvm_unreachable(
"unknown storage class specifier");
5497 assert(
Record->hasInClassInitializer());
5499 for (
const auto *I :
Record->decls()) {
5500 const auto *FD = dyn_cast<FieldDecl>(I);
5501 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
5502 FD = IFD->getAnonField();
5503 if (FD && FD->hasInClassInitializer())
5504 return FD->getLocation();
5507 llvm_unreachable(
"couldn't find in-class initializer");
5512 if (!
Parent->isUnion() || !
Parent->hasInClassInitializer())
5515 S.
Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
5521 if (!
Parent->isUnion() || !
Parent->hasInClassInitializer())
5539 Diag(
Record->getLocation(), diag::ext_anonymous_union);
5541 Diag(
Record->getLocation(), diag::ext_gnu_anonymous_struct);
5543 Diag(
Record->getLocation(), diag::ext_c11_anonymous_struct);
5549 const char *PrevSpec =
nullptr;
5560 !cast<NamespaceDecl>(OwnerScope)->isAnonymousNamespace()))) {
5561 Diag(
Record->getLocation(), diag::err_anonymous_union_not_static)
5566 PrevSpec, DiagID, Policy);
5572 isa<RecordDecl>(Owner)) {
5574 diag::err_anonymous_union_with_storage_spec)
5588 <<
Record->isUnion() <<
"const"
5592 diag::ext_anonymous_struct_union_qualified)
5593 <<
Record->isUnion() <<
"volatile"
5597 diag::ext_anonymous_struct_union_qualified)
5598 <<
Record->isUnion() <<
"restrict"
5602 diag::ext_anonymous_struct_union_qualified)
5603 <<
Record->isUnion() <<
"_Atomic"
5607 diag::ext_anonymous_struct_union_qualified)
5608 <<
Record->isUnion() <<
"__unaligned"
5618 for (
auto *Mem :
Record->decls()) {
5620 if (Mem->isInvalidDecl())
5623 if (
auto *FD = dyn_cast<FieldDecl>(Mem)) {
5627 assert(FD->getAccess() !=
AS_none);
5629 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
5641 }
else if (Mem->isImplicit()) {
5643 }
else if (isa<TagDecl>(Mem) && Mem->getDeclContext() !=
Record) {
5648 }
else if (
auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
5649 if (!MemRecord->isAnonymousStructOrUnion() &&
5650 MemRecord->getDeclName()) {
5653 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
5657 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
5665 Diag(MemRecord->getLocation(),
5666 diag::ext_anonymous_record_with_anonymous_type)
5669 }
else if (isa<AccessSpecDecl>(Mem)) {
5671 }
else if (isa<StaticAssertDecl>(Mem)) {
5676 unsigned DK = diag::err_anonymous_record_bad_member;
5677 if (isa<TypeDecl>(Mem))
5678 DK = diag::err_anonymous_record_with_type;
5679 else if (isa<FunctionDecl>(Mem))
5680 DK = diag::err_anonymous_record_with_function;
5681 else if (isa<VarDecl>(Mem))
5682 DK = diag::err_anonymous_record_with_static;
5686 DK == diag::err_anonymous_record_with_type)
5687 Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
5690 Diag(Mem->getLocation(), DK) <<
Record->isUnion();
5699 if (cast<CXXRecordDecl>(
Record)->hasInClassInitializer() &&
5702 cast<CXXRecordDecl>(
Record));
5706 Diag(
Record->getLocation(), diag::err_anonymous_struct_not_member)
5727 assert(TInfo &&
"couldn't build declarator info for anonymous struct/union");
5731 if (
RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
5747 Diag(
Record->getLocation(), diag::err_mutable_nonmember);
5753 Record->getLocation(),
nullptr,
5769 Record->setAnonymousStructOrUnion(
true);
5780 Chain.push_back(Anon);
5786 if (
VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
5789 Decl *ManglingContextDecl;
5790 std::tie(MCtx, ManglingContextDecl) =
5822 assert(
Record &&
"expected a record!");
5827 assert(TInfo &&
"couldn't build declarator info for anonymous struct");
5829 auto *ParentDecl = cast<RecordDecl>(
CurContext);
5835 nullptr, RecTy, TInfo,
5847 Chain.push_back(Anon);
5851 diag::err_field_incomplete_or_sizeless) ||
5856 ParentDecl->setInvalidDecl();
5872 NameInfo.
setLoc(Name.StartLocation);
5874 switch (Name.getKind()) {
5878 NameInfo.
setName(Name.Identifier);
5894 if (!Template || !isa<ClassTemplateDecl>(Template)) {
5895 Diag(Name.StartLocation,
5896 diag::err_deduction_guide_name_not_class_template)
5910 Name.OperatorFunctionId.Operator));
5912 Name.OperatorFunctionId.SymbolLocations[0], Name.EndLocation));
5948 if (!CurClass || CurClass->
getIdentifier() != Name.TemplateId->Name)
5984 llvm_unreachable(
"Unknown name kind");
6012 for (
unsigned Idx = 0; Idx <
Declaration->param_size(); ++Idx) {
6026 (DeclTyName && DeclTyName == DefTyName))
6027 Params.push_back(Idx);
6054#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case DeclSpec::TST_##Trait:
6055#include "clang/Basic/TransformTypeTraits.def"
6070 if (!TSI)
return true;
6083 if (
Result.isInvalid())
return true;
6128 << D << static_cast<int>(Status);
6139 if (
OpenMP().getOMPTraitInfoForSurroundingScope()->isExtensionActive(
6140 llvm::omp::TraitProperty::
6141 implementation_extension_bind_to_declaration))
6173 Diag(NameInfo.
getLoc(), diag::err_member_name_of_class) << Name;
6202 bool IsMemberSpecialization) {
6203 assert(SS.
isValid() &&
"diagnoseQualifiedDeclaration called for declaration "
6204 "without nested-name-specifier");
6206 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
6220 Diag(
Loc,
LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
6221 : diag::err_member_extra_qualification)
6225 Diag(
Loc, diag::warn_namespace_member_extra_qualification) << Name;
6233 if (!Cur->
Encloses(DC) && !(TemplateId || IsMemberSpecialization)) {
6235 Diag(
Loc, diag::err_member_qualification)
6237 else if (isa<TranslationUnitDecl>(DC))
6238 Diag(
Loc, diag::err_invalid_declarator_global_scope)
6240 else if (isa<FunctionDecl>(Cur))
6241 Diag(
Loc, diag::err_invalid_declarator_in_function)
6243 else if (isa<BlockDecl>(Cur))
6244 Diag(
Loc, diag::err_invalid_declarator_in_block)
6246 else if (isa<ExportDecl>(Cur)) {
6247 if (!isa<NamespaceDecl>(DC))
6248 Diag(
Loc, diag::err_export_non_namespace_scope_name)
6255 Diag(
Loc, diag::err_invalid_declarator_scope)
6256 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.
getRange();
6263 Diag(
Loc, diag::err_member_qualification)
6289 Diag(
Loc, diag::ext_template_after_declarative_nns)
6296 Diag(
Loc, diag::ext_template_after_declarative_nns)
6307 if (TST->isDependentType() && TST->isTypeAlias())
6308 Diag(
Loc, diag::ext_alias_template_in_declarative_nns)
6317 Diag(
Loc, diag::err_computed_type_in_declarative_nns)
6321 }
while ((SpecLoc = SpecLoc.
getPrefix()));
6354 if (!DC || isa<EnumDecl>(DC)) {
6360 diag::err_template_qualified_declarator_no_match)
6367 if (!IsDependentContext &&
6372 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->
hasDefinition()) {
6374 diag::err_member_def_undefined_record)
6395 if (EnteringContext && IsDependentContext &&
6396 TemplateParamLists.size() != 0) {
6415 bool IsLinkageLookup =
false;
6416 bool CreateBuiltins =
false;
6430 IsLinkageLookup =
true;
6435 CreateBuiltins =
true;
6437 if (IsLinkageLookup) {
6440 RedeclarationKind::ForExternalRedeclaration);
6479 bool AllowForCompatibility =
false;
6480 if (
Scope *DeclParent = S->getDeclParent();
6481 Scope *TemplateParamParent = S->getTemplateParamParent()) {
6482 AllowForCompatibility = DeclParent->Contains(*TemplateParamParent) &&
6483 TemplateParamParent->isDeclScope(TPD);
6486 AllowForCompatibility);
6512 S = S->getDeclParent();
6516 bool AddToScope =
true;
6518 if (TemplateParamLists.size()) {
6541 if (
OpenMP().isInOpenMPDeclareTargetContext())
6552 bool &SizeIsNegative,
6553 llvm::APSInt &Oversized) {
6558 SizeIsNegative =
false;
6567 if (
const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
6572 if (FixedType.
isNull())
return FixedType;
6574 return Qs.
apply(Context, FixedType);
6576 if (
const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
6577 QualType Inner = PTy->getInnerType();
6581 if (FixedType.
isNull())
return FixedType;
6583 return Qs.
apply(Context, FixedType);
6593 SizeIsNegative, Oversized);
6603 llvm::APSInt Res =
Result.Val.getInt();
6606 if (Res.isSigned() && Res.isNegative()) {
6607 SizeIsNegative =
true;
6612 unsigned ActiveSizeBits =
6616 : Res.getActiveBits();
6624 return Qs.
apply(Context, FoldedArrayType);
6649 TypeLoc DstElemTL = DstATL.getElementLoc();
6668 bool &SizeIsNegative,
6669 llvm::APSInt &Oversized) {
6672 SizeIsNegative, Oversized);
6685 unsigned FailedFoldDiagID) {
6686 bool SizeIsNegative;
6687 llvm::APSInt Oversized;
6689 TInfo,
Context, SizeIsNegative, Oversized);
6691 Diag(
Loc, diag::ext_vla_folded_to_constant);
6698 Diag(
Loc, diag::err_typecheck_negative_array_size);
6699 else if (Oversized.getBoolValue())
6701 else if (FailedFoldDiagID)
6734 diag::err_virtual_non_function);
6738 diag::err_explicit_non_function);
6742 diag::err_noreturn_non_function);
6770 diag::err_deduction_guide_invalid_specifier)
6779 if (!NewTD)
return nullptr;
6803 if (S->getFnParent() ==
nullptr) {
6804 bool SizeIsNegative;
6805 llvm::APSInt Oversized;
6818 else if (Oversized.getBoolValue())
6845 Redeclaration =
true;
6851 if (ShadowedDecl && !Redeclaration)
6858 switch (II->getNotableIdentifierID()) {
6859 case tok::NotableIdentifierKind::FILE:
6862 case tok::NotableIdentifierKind::jmp_buf:
6865 case tok::NotableIdentifierKind::sigjmp_buf:
6868 case tok::NotableIdentifierKind::ucontext_t:
6871 case tok::NotableIdentifierKind::float_t:
6872 case tok::NotableIdentifierKind::double_t:
6873 NewTD->
addAttr(AvailableOnlyInDefaultEvalMethodAttr::Create(
Context));
6934 if (!OuterContext->
Equals(PrevOuterContext))
6943 if (!SS.
isSet())
return;
6948 if (
Decl->getType().hasAddressSpace())
6950 if (
Decl->getType()->isDependentType())
6962 Var->hasGlobalStorage())
6966 if (
auto DT = dyn_cast<DecayedType>(
Type)) {
6967 auto OrigTy = DT->getOriginalType();
6968 if (!OrigTy.hasAddressSpace() && OrigTy->isArrayType()) {
7000 if (WeakRefAttr *
Attr = ND.
getAttr<WeakRefAttr>()) {
7007 if (
auto *VD = dyn_cast<VarDecl>(&ND)) {
7008 if (VD->hasInit()) {
7009 if (
const auto *
Attr = VD->getAttr<AliasAttr>()) {
7010 assert(VD->isThisDeclarationADefinition() &&
7011 !VD->isExternallyVisible() &&
"Broken AliasAttr handled late!");
7013 VD->dropAttr<AliasAttr>();
7020 if (SelectAnyAttr *
Attr = ND.
getAttr<SelectAnyAttr>()) {
7023 diag::err_attribute_selectany_non_extern_data);
7029 auto *VD = dyn_cast<VarDecl>(&ND);
7030 bool IsAnonymousNS =
false;
7033 const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(VD->getDeclContext());
7034 while (NS && !IsAnonymousNS) {
7036 NS = dyn_cast<NamespaceDecl>(NS->
getParent());
7043 bool AnonNSInMicrosoftMode = IsAnonymousNS && IsMicrosoft;
7045 (!AnonNSInMicrosoftMode &&
7054 if (
const auto *FD = dyn_cast<FunctionDecl>(&ND)) {
7059 for (
TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc();
7065 if (
const auto *A = ATL.
getAttrAs<LifetimeBoundAttr>()) {
7066 const auto *MD = dyn_cast<CXXMethodDecl>(FD);
7067 if (!MD || MD->isStatic()) {
7068 S.
Diag(A->getLocation(), diag::err_lifetimebound_no_object_param)
7069 << !MD << A->getRange();
7070 }
else if (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)) {
7071 S.
Diag(A->getLocation(), diag::err_lifetimebound_ctor_dtor)
7072 << isa<CXXDestructorDecl>(MD) << A->getRange();
7081 bool IsSpecialization,
7082 bool IsDefinition) {
7086 bool IsTemplate =
false;
7087 if (
TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl)) {
7088 OldDecl = OldTD->getTemplatedDecl();
7090 if (!IsSpecialization)
7091 IsDefinition =
false;
7093 if (
TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl)) {
7094 NewDecl = NewTD->getTemplatedDecl();
7098 if (!OldDecl || !NewDecl)
7101 const DLLImportAttr *OldImportAttr = OldDecl->
getAttr<DLLImportAttr>();
7102 const DLLExportAttr *OldExportAttr = OldDecl->
getAttr<DLLExportAttr>();
7103 const DLLImportAttr *NewImportAttr = NewDecl->
getAttr<DLLImportAttr>();
7104 const DLLExportAttr *NewExportAttr = NewDecl->
getAttr<DLLExportAttr>();
7108 bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
7109 (NewExportAttr && !NewExportAttr->isInherited());
7115 bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
7117 if (AddsAttr && !IsSpecialization && !OldDecl->
isImplicit()) {
7119 bool JustWarn =
false;
7121 auto *VD = dyn_cast<VarDecl>(OldDecl);
7122 if (VD && !VD->getDescribedVarTemplate())
7124 auto *FD = dyn_cast<FunctionDecl>(OldDecl);
7133 if (!isa<FunctionDecl>(OldDecl) || !NewImportAttr)
7136 unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
7137 : diag::err_attribute_dll_redeclaration;
7140 << (NewImportAttr ? (
const Attr *)NewImportAttr : NewExportAttr);
7153 bool IsInline =
false, IsStaticDataMember =
false, IsQualifiedFriend =
false;
7155 if (
const auto *VD = dyn_cast<VarDecl>(NewDecl)) {
7158 IsStaticDataMember = VD->isStaticDataMember();
7159 IsDefinition = VD->isThisDeclarationADefinition(S.
Context) !=
7161 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
7162 IsInline = FD->isInlined();
7163 IsQualifiedFriend = FD->getQualifier() &&
7167 if (OldImportAttr && !HasNewAttr &&
7168 (!IsInline || (IsMicrosoftABI && IsTemplate)) && !IsStaticDataMember &&
7170 if (IsMicrosoftABI && IsDefinition) {
7171 if (IsSpecialization) {
7174 diag::err_attribute_dllimport_function_specialization_definition);
7175 S.
Diag(OldImportAttr->getLocation(), diag::note_attribute);
7176 NewDecl->
dropAttr<DLLImportAttr>();
7179 diag::warn_redeclaration_without_import_attribute)
7182 NewDecl->
dropAttr<DLLImportAttr>();
7183 NewDecl->
addAttr(DLLExportAttr::CreateImplicit(
7184 S.
Context, NewImportAttr->getRange()));
7186 }
else if (IsMicrosoftABI && IsSpecialization) {
7187 assert(!IsDefinition);
7191 diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
7192 << NewDecl << OldImportAttr;
7194 S.
Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
7195 OldDecl->
dropAttr<DLLImportAttr>();
7196 NewDecl->
dropAttr<DLLImportAttr>();
7198 }
else if (IsInline && OldImportAttr && !IsMicrosoftABI) {
7201 OldDecl->
dropAttr<DLLImportAttr>();
7202 NewDecl->
dropAttr<DLLImportAttr>();
7204 diag::warn_dllimport_dropped_from_inline_function)
7205 << NewDecl << OldImportAttr;
7212 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDecl)) {
7214 !NewImportAttr && !NewExportAttr) {
7215 if (
const DLLExportAttr *ParentExportAttr =
7216 MD->getParent()->getAttr<DLLExportAttr>()) {
7217 DLLExportAttr *NewAttr = ParentExportAttr->clone(S.
Context);
7218 NewAttr->setInherited(
true);
7262 if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>())
7266 if (S.
getLangOpts().CUDA && (D->template hasAttr<CUDADeviceAttr>() ||
7267 D->template hasAttr<CUDAHostAttr>()))
7270 return D->isExternC();
7276 isa<OMPDeclareMapperDecl>(DC))
7285 if (isa<RequiresExprBodyDecl>(DC))
7287 llvm_unreachable(
"Unexpected context");
7293 isa<OMPDeclareReductionDecl>(DC) || isa<OMPDeclareMapperDecl>(DC))
7297 llvm_unreachable(
"Unexpected context");
7344 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
7345 return FD->isExternC();
7346 if (
const auto *VD = dyn_cast<VarDecl>(D))
7347 return VD->isExternC();
7349 llvm_unreachable(
"Unknown type of decl!");
7362 diag::err_opencl_type_can_only_be_used_as_function_parameter)
7376 diag::err_invalid_type_for_program_scope_var)
7405 Se.
Diag(NewVD->
getLocation(), diag::err_opencl_half_declaration) << R;
7438 Se.
Diag(NewVD->
getLocation(), diag::err_opencl_nonconst_global_sampler);
7448template <
typename AttrTy>
7451 if (
const auto *Attribute = TND->
getAttr<AttrTy>()) {
7452 AttrTy *Clone = Attribute->clone(S.
Context);
7453 Clone->setInherited(
true);
7481 if (
const auto *ConstDecl = RD->
getAttr<ReadOnlyPlacementAttr>()) {
7483 S.
Diag(ConstDecl->getLocation(), diag::note_enforce_read_only_placement);
7496 bool IsPlaceholderVariable =
false;
7502 if (!Decomp.bindings().empty()) {
7503 II = Decomp.bindings()[0].Name;
7517 IsPlaceholderVariable =
true;
7535 bool IsLocalExternDecl = SC ==
SC_Extern &&
7554 : diag::warn_deprecated_register)
7560 if (!DC->
isRecord() && S->getFnParent() ==
nullptr) {
7581 bool IsMemberSpecialization =
false;
7582 bool IsVariableTemplateSpecialization =
false;
7584 bool IsVariableTemplate =
false;
7612 diag::err_static_out_of_line)
7624 diag::err_storage_class_for_static_member)
7628 llvm_unreachable(
"C storage class in c++!");
7633 if (
const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
7639 if (Ctxt->isFunctionOrMethod()) {
7640 FunctionOrMethod = Ctxt;
7643 const CXXRecordDecl *ParentDecl = dyn_cast<CXXRecordDecl>(Ctxt);
7645 AnonStruct = ParentDecl;
7649 if (FunctionOrMethod) {
7653 diag::err_static_data_member_not_allowed_in_local_class)
7654 << Name << RD->getDeclName()
7655 << llvm::to_underlying(RD->getTagKind());
7656 }
else if (AnonStruct) {
7661 diag::err_static_data_member_not_allowed_in_anon_struct)
7662 << Name << llvm::to_underlying(AnonStruct->
getTagKind());
7664 }
else if (RD->isUnion()) {
7669 ? diag::warn_cxx98_compat_static_data_member_in_union
7670 : diag::ext_static_data_member_in_union) << Name;
7677 bool InvalidScope =
false;
7685 false, IsMemberSpecialization, InvalidScope);
7688 if (TemplateParams) {
7689 if (!TemplateParams->
size() &&
7694 diag::err_template_variable_noparams)
7698 TemplateParams =
nullptr;
7706 IsVariableTemplateSpecialization =
true;
7710 IsVariableTemplate =
true;
7715 ? diag::warn_cxx11_compat_variable_template
7716 : diag::ext_variable_template);
7721 if (!TemplateParamLists.empty() && IsMemberSpecialization &&
7726 "should have a 'template<>' for this decl");
7729 if (IsVariableTemplateSpecialization) {
7731 TemplateParamLists.size() > 0
7732 ? TemplateParamLists[0]->getTemplateLoc()
7735 S, D, TInfo,
Previous, TemplateKWLoc, TemplateParams, SC,
7739 NewVD = cast<VarDecl>(Res.
get());
7750 if (IsVariableTemplate) {
7753 TemplateParams, NewVD);
7774 bool IsExplicitSpecialization =
7776 unsigned VDTemplateParamLists =
7777 (TemplateParams && !IsExplicitSpecialization) ? 1 : 0;
7778 if (TemplateParamLists.size() > VDTemplateParamLists)
7780 Context, TemplateParamLists.drop_back(VDTemplateParamLists));
7790 diag::err_inline_declaration_block_scope) << Name
7795 : diag::ext_inline_variable);
7806 if (IsLocalExternDecl) {
7809 B->setLocalExternDecl();
7814 bool EmitTLSUnsupportedError =
false;
7827 diag::err_thread_non_global)
7835 EmitTLSUnsupportedError =
true;
7842 diag::err_thread_unsupported);
7853 diag::err_constexpr_wrong_decl_kind)
7871 diag::err_constinit_local_variable);
7875 ConstInitAttr::Keyword_constinit));
7888 if (SC ==
SC_Static && S->getFnParent() !=
nullptr &&
7893 diag::warn_static_local_in_extern_inline);
7899 if (IsVariableTemplateSpecialization)
7904 else if (IsMemberSpecialization)
7919 B->setModulePrivate();
7929 diag::err_opencl_unknown_type_specifier)
7939 if (
const auto *ATy = dyn_cast<ArrayType>(NewVD->
getType())) {
7940 if (ATy && ATy->getElementType().isWebAssemblyReferenceType() &&
7957 copyAttrFromTypedefToDecl<AllocSizeAttr>(*
this, NewVD, TT);
7961 if (EmitTLSUnsupportedError &&
7964 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(NewVD))))
7966 diag::err_thread_unsupported);
7968 if (EmitTLSUnsupportedError &&
7974 if (SC ==
SC_None && S->getFnParent() !=
nullptr &&
7975 (NewVD->
hasAttr<CUDASharedAttr>() ||
7976 NewVD->
hasAttr<CUDAConstantAttr>())) {
7984 assert(!NewVD->
hasAttr<DLLImportAttr>() ||
7985 NewVD->
getAttr<DLLImportAttr>()->isInherited() ||
7990 if (
getLangOpts().ObjCAutoRefCount &&
ObjC().inferObjCARCLifetime(NewVD))
7998 if (S->getFnParent() !=
nullptr) {
8002 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) <<
Label;
8008 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) <<
Label;
8019 bool HasSizeMismatch;
8021 if (!TI.isValidGCCRegisterName(
Label))
8022 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) <<
Label;
8023 else if (!TI.validateGlobalRegisterVariable(
Label,
8026 Diag(E->getExprLoc(), diag::err_asm_invalid_global_var_reg) <<
Label;
8027 else if (HasSizeMismatch)
8028 Diag(E->getExprLoc(), diag::err_asm_register_size_mismatch) <<
Label;
8041 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
8063 IsMemberSpecialization ||
8064 IsVariableTemplateSpecialization);
8078 if (IsMemberSpecialization && !IsVariableTemplateSpecialization &&
8085 isa<FieldDecl>(
Previous.getFoundDecl()) &&
8095 !IsVariableTemplateSpecialization) {
8103 if (!IsPlaceholderVariable)
8134 if (PrevVarTemplate &&
8154 Decl *ManglingContextDecl;
8155 std::tie(MCtx, ManglingContextDecl) =
8166 if (Name.getAsIdentifierInfo() && Name.getAsIdentifierInfo()->isStr(
"main") &&
8216 if (isa<TypeAliasDecl>(ShadowedDecl))
8218 else if (isa<TypedefDecl>(ShadowedDecl))
8220 else if (isa<BindingDecl>(ShadowedDecl))
8222 else if (isa<RecordDecl>(OldDC))
8261 return isa<VarDecl, FieldDecl, BindingDecl>(ShadowedDecl) ? ShadowedDecl
8277 return isa<TypedefNameDecl>(ShadowedDecl) ? ShadowedDecl :
nullptr;
8288 return isa<VarDecl, FieldDecl, BindingDecl>(ShadowedDecl) ? ShadowedDecl
8305 if (
FieldDecl *FD = dyn_cast<FieldDecl>(ShadowedDecl)) {
8313 if (isa<CXXConstructorDecl>(NewDC))
8314 if (
const auto PVD = dyn_cast<ParmVarDecl>(D)) {
8317 ShadowingDecls.insert({PVD->getCanonicalDecl(), FD});
8322 if (
VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
8323 if (shadowedVar->isExternC()) {
8326 for (
auto *I : shadowedVar->redecls())
8327 if (I->isFileVarDecl()) {
8335 unsigned WarningDiag = diag::warn_decl_shadow;
8337 if (isa<VarDecl>(D) && NewDC && isa<CXXMethodDecl>(NewDC)) {
8338 if (
const auto *RD = dyn_cast<CXXRecordDecl>(NewDC->
getParent())) {
8340 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl)) {
8342 if (RD->getLambdaCaptureDefault() ==
LCD_None) {
8348 WarningDiag = diag::warn_decl_shadow_uncaptured_local;
8354 ->ShadowingDecls.push_back({D, VD});
8358 if (isa<FieldDecl>(ShadowedDecl)) {
8365 ->ShadowingDecls.push_back({D, ShadowedDecl});
8369 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl);
8370 VD && VD->hasLocalStorage()) {
8374 ParentDC && !ParentDC->
Equals(OldDC);
8378 if (!isa<BlockDecl>(ParentDC) && !isa<CapturedDecl>(ParentDC) &&
8412 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
8421 const NamedDecl *ShadowedDecl = Shadow.ShadowedDecl;
8424 if (
const auto *VD = dyn_cast<VarDecl>(ShadowedDecl)) {
8426 Diag(Shadow.VD->getLocation(),
8427 CaptureLoc.
isInvalid() ? diag::warn_decl_shadow_uncaptured_local
8428 : diag::warn_decl_shadow)
8429 << Shadow.VD->getDeclName()
8432 Diag(CaptureLoc, diag::note_var_explicitly_captured_here)
8433 << Shadow.VD->getDeclName() << 0;
8435 }
else if (isa<FieldDecl>(ShadowedDecl)) {
8436 Diag(Shadow.VD->getLocation(),
8438 : diag::warn_decl_shadow_uncaptured_local)
8439 << Shadow.VD->getDeclName()
8453 RedeclarationKind::ForVisibleRedeclaration);
8466 auto *DRE = dyn_cast<DeclRefExpr>(E);
8469 const NamedDecl *D = cast<NamedDecl>(DRE->getDecl()->getCanonicalDecl());
8470 auto I = ShadowingDecls.find(D);
8471 if (I == ShadowingDecls.end())
8473 const NamedDecl *ShadowedDecl = I->second;
8475 Diag(
Loc, diag::warn_modifying_shadowing_decl) << D << OldDC;
8480 ShadowingDecls.erase(I);
8488 assert(S.
getLangOpts().CPlusPlus &&
"only C++ has extern \"C\"");
8509 if (!isa<VarDecl>(ND))
8519 if (isa<VarDecl>(*I)) {
8529 if (isa<VarDecl>(*I)) {
8547 assert(Prev &&
"should have found a previous declaration to diagnose");
8549 Prev = FD->getFirstDecl();
8551 Prev = cast<VarDecl>(Prev)->getFirstDecl();
8553 S.
Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
8575 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
8587 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
8607 SemaRef.
Diag(VarLoc, diag::err_c23_constexpr_invalid_type) <<
T;
8617 SemaRef.
Diag(VarLoc, diag::err_c23_constexpr_invalid_type) <<
T;
8623 if (llvm::any_of(RD->
fields(), [&SemaRef, VarLoc](
const FieldDecl *F) {
8624 return CheckC23ConstexprVarType(SemaRef, VarLoc, F->getType());
8680 if (NewVD->
hasAttr<BlocksAttr>()) {
8688 if (!
T.isConstQualified()) {
8689 Diag(NewVD->
getLocation(), diag::err_opencl_invalid_block_declaration)
8695 Diag(NewVD->
getLocation(), diag::err_opencl_extern_block_declaration);
8711 Diag(NewVD->
getLocation(), diag::err_opencl_global_invalid_addr_space)
8712 <<
Scope <<
"global or constant";
8714 Diag(NewVD->
getLocation(), diag::err_opencl_global_invalid_addr_space)
8715 <<
Scope <<
"constant";
8731 if (FD && !FD->
hasAttr<OpenCLKernelAttr>()) {
8743 if (FD && FD->
hasAttr<OpenCLKernelAttr>()) {
8768 && !NewVD->
hasAttr<BlocksAttr>()) {
8790 const auto *ATy = dyn_cast<ConstantArrayType>(
T.getTypePtr());
8791 if (!ATy || ATy->getZExtSize() != 0) {
8793 diag::err_typecheck_wasm_table_must_have_zero_length);
8800 if (isVM || NewVD->
hasAttr<CleanupAttr>() ||
8806 bool SizeIsNegative;
8807 llvm::APSInt Oversized;
8812 FixedT = FixedTInfo->
getType();
8813 else if (FixedTInfo) {
8870 !
T.isWebAssemblyReferenceType()) {
8876 if (isVM && NewVD->
hasAttr<BlocksAttr>()) {
8890 diag::err_constexpr_var_non_literal)) {
8906 llvm::StringMap<bool> CallerFeatureMap;
8917 diag::err_sve_vector_in_non_streaming_function)
8927 llvm::StringMap<bool> CallerFeatureMap;
8987 dyn_cast<CXXMethodDecl>(BaseND->getCanonicalDecl());
8994 if (Overridden.insert(BaseMD).second) {
9011 return !Overridden.empty();
9017 struct ActOnFDArgs {
9033 : Context(Context), OriginalFD(TypoFD),
9036 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
9042 CDeclEnd = candidate.
end();
9043 CDecl != CDeclEnd; ++CDecl) {
9050 if (
Parent &&
Parent->getCanonicalDecl() == ExpectedParent)
9052 }
else if (!ExpectedParent) {
9061 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
9062 return std::make_unique<DifferentNameValidatorCCC>(*
this);
9088 ActOnFDArgs &ExtraArgs,
bool IsLocalFriend,
Scope *S) {
9094 bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
9096 IsLocalFriend ? diag::err_no_matching_local_friend :
9098 diag::err_member_decl_does_not_match;
9102 RedeclarationKind::ForVisibleRedeclaration);
9110 "Cannot have an ambiguity in previous-declaration lookup");
9112 DifferentNameValidatorCCC CCC(SemaRef.
Context, NewFD,
9114 if (!Prev.
empty()) {
9123 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
9124 NearMatches.push_back(std::make_pair(FD, ParamNum));
9131 IsLocalFriend ?
nullptr : NewDC))) {
9134 ExtraArgs.D.getIdentifierLoc());
9138 CDeclEnd = Correction.
end();
9139 CDecl != CDeclEnd; ++CDecl) {
9146 bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
9159 ExtraArgs.S, ExtraArgs.D,
9162 ExtraArgs.AddToScope);
9170 Decl *Canonical =
Result->getCanonicalDecl();
9173 if ((*I)->getCanonicalDecl() == Canonical)
9180 SemaRef.
PDiag(IsLocalFriend
9181 ? diag::err_no_matching_local_friend_suggest
9182 : diag::err_member_decl_does_not_match_suggest)
9183 << Name << NewDC << IsDefinition);
9188 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
9189 ExtraArgs.D.getIdentifierLoc());
9190 ExtraArgs.D.setRedeclaration(wasRedeclaration);
9196 << Name << NewDC << IsDefinition << NewFD->
getLocation();
9198 bool NewFDisConst =
false;
9200 NewFDisConst = NewMD->isConst();
9203 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
9204 NearMatch != NearMatchEnd; ++NearMatch) {
9207 bool FDisConst = MD && MD->
isConst();
9208 bool IsMember = MD || !IsLocalFriend;
9211 if (
unsigned Idx = NearMatch->second) {
9215 SemaRef.
Diag(
Loc, IsMember ? diag::note_member_def_close_param_match
9216 : diag::note_local_decl_close_param_match)
9219 }
else if (FDisConst != NewFDisConst) {
9220 SemaRef.
Diag(FD->
getLocation(), diag::note_member_def_close_const_match)
9224 .getConstQualifierLoc())
9227 .getLocWithOffset(1),
9231 IsMember ? diag::note_member_def_close_match
9232 : diag::note_local_decl_close_match);
9239 default: llvm_unreachable(
"Unknown storage class!");
9244 diag::err_typecheck_sclass_func);
9261 diag::err_static_block_func);
9277 bool &IsVirtualOkay) {
9291 diag::err_c23_constexpr_not_variable);
9294 diag::err_constexpr_wrong_decl_kind)
9295 <<
static_cast<int>(ConstexprKind);
9315 ->isFunctionProtoType()) ||
9319 "Strict prototypes are required");
9340 "Constructors can only be declared in a member context");
9346 isInline,
false, ConstexprKind,
9357 false, ConstexprKind,
9358 TrailingRequiresClause);
9361 if (
Record->isBeingDefined())
9370 IsVirtualOkay =
true;
9382 true, ConstexprKind, TrailingRequiresClause);
9388 diag::err_conv_function_not_member);
9396 IsVirtualOkay =
true;
9401 TrailingRequiresClause);
9404 if (TrailingRequiresClause)
9406 diag::err_trailing_requires_clause_on_deduction_guide)
9418 if (Name.getAsIdentifierInfo() &&
9419 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
9431 IsVirtualOkay = !Ret->isStatic();
9445 true , ConstexprKind, TrailingRequiresClause);
9462 StringRef SizeTypeNames[] = {
"size_t",
"intptr_t",
"uintptr_t",
"ptrdiff_t"};
9470 if (Names.end() != Match)
9475 }
while (DesugaredTy != Ty);
9514 "__cl_clang_non_portable_kernel_param_types", S.
getLangOpts())) {
9516 bool IsStandardLayoutType =
true;
9522 if (!CXXRec->hasDefinition())
9524 if (!CXXRec || !CXXRec->hasDefinition() || !CXXRec->isStandardLayout())
9525 IsStandardLayoutType =
false;
9528 !IsStandardLayoutType)
9576 "__cl_clang_non_portable_kernel_param_types", S.
getLangOpts()) &&
9590 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
9637 S.
Diag(
Loc, diag::note_entity_declared_at) << PT;
9660 HistoryStack.push_back(
nullptr);
9669 VisitStack.push_back(RecTy->
getDecl());
9670 assert(VisitStack.back() &&
"First decl null?");
9673 const Decl *Next = VisitStack.pop_back_val();
9675 assert(!HistoryStack.empty());
9677 if (
const FieldDecl *Hist = HistoryStack.pop_back_val())
9678 ValidTypes.insert(Hist->getType().getTypePtr());
9686 if (
const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
9687 HistoryStack.push_back(Field);
9689 QualType FieldTy = Field->getType();
9693 "Unexpected type.");
9698 RD = cast<RecordDecl>(Next);
9702 VisitStack.push_back(
nullptr);
9704 for (
const auto *FD : RD->
fields()) {
9715 VisitStack.push_back(FD);
9727 diag::err_record_with_pointers_kernel_param)
9734 S.
Diag(OrigRecDecl->getLocation(), diag::note_within_field_of_type)
9735 << OrigRecDecl->getDeclName();
9740 I = HistoryStack.begin() + 1,
9741 E = HistoryStack.end();
9754 }
while (!VisitStack.empty());
9770 while (S->isClassScope() ||
9771 (LangOpts.CPlusPlus &&
9772 S->isFunctionPrototypeScope()) ||
9774 (S->getEntity() && S->getEntity()->isTransparentContext()))
9781 unsigned BuiltinID) {
9782 switch (BuiltinID) {
9783 case Builtin::BI__GetExceptionInfo:
9787 case Builtin::BIaddressof:
9788 case Builtin::BI__addressof:
9789 case Builtin::BIforward:
9790 case Builtin::BIforward_like:
9791 case Builtin::BImove:
9792 case Builtin::BImove_if_noexcept:
9793 case Builtin::BIas_const: {
9818 llvm::append_range(TemplateParamLists, TemplateParamListsRef);
9820 if (!TemplateParamLists.empty() && !TemplateParamLists.back()->empty() &&
9821 Invented->getDepth() == TemplateParamLists.back()->getDepth())
9822 TemplateParamLists.back() = Invented;
9824 TemplateParamLists.push_back(Invented);
9834 diag::err_invalid_thread)
9842 bool isFriend =
false;
9844 bool isMemberSpecialization =
false;
9845 bool isFunctionTemplateSpecialization =
false;
9847 bool HasExplicitTemplateArgs =
false;
9850 bool isVirtualOkay =
false;
9857 if (!NewFD)
return nullptr;
9867 if (IsLocalExternDecl)
9876 bool ImplicitInlineCXX20 = !
getLangOpts().CPlusPlusModules ||
9899 if (
Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
9904 if (isVirtual &&
Parent->isUnion()) {
9909 Parent->hasAttr<SYCLSpecialClassAttr>() &&
9912 if (
auto *Def =
Parent->getDefinition())
9913 Def->setInitMethod(
true);
9918 isMemberSpecialization =
false;
9919 isFunctionTemplateSpecialization =
false;
9934 isMemberSpecialization,
Invalid);
9935 if (TemplateParams) {
9940 if (TemplateParams->
size() > 0) {
9948 }
else if (TemplateId) {
9965 Name, TemplateParams,
9971 if (TemplateParamLists.size() > 1) {
9978 isFunctionTemplateSpecialization =
true;
9980 if (TemplateParamLists.size() > 0)
10000 << Name << RemoveRange
10006 HasExplicitTemplateArgs =
true;
10013 if (!TemplateParamLists.empty() && isMemberSpecialization &&
10019 if (TemplateParamLists.size() > 0)
10024 if (isFriend && TemplateId)
10025 isFunctionTemplateSpecialization =
true;
10031 if (isFunctionTemplateSpecialization && TemplateId) {
10032 HasExplicitTemplateArgs =
true;
10063 if (!isVirtualOkay) {
10065 diag::err_virtual_non_function);
10069 diag::err_virtual_out_of_class)
10075 diag::err_virtual_member_function_template)
10094 diag::err_inline_declaration_block_scope) << Name
10104 !isa<CXXDeductionGuideDecl>(NewFD)) {
10108 diag::err_explicit_out_of_class)
10110 }
else if (!isa<CXXConstructorDecl>(NewFD) &&
10111 !isa<CXXConversionDecl>(NewFD)) {
10115 diag::err_explicit_non_ctor_or_conv_function)
10129 if (isa<CXXDestructorDecl>(NewFD) &&
10133 <<
static_cast<int>(ConstexprKind);
10147 diag::err_invalid_consteval_decl_kind)
10155 if (isFunctionTemplateSpecialization) {
10158 Diag(ModulePrivateLoc, diag::err_module_private_specialization)
10193 if (isa<CXXMethodDecl>(NewFD) && DC ==
CurContext &&
10204 if (SC ==
SC_Static && isa<CXXMethodDecl>(NewFD) &&
10219 cast<CXXRecordDecl>(DC)->getDescribedClassTemplate()) ||
10221 ? diag::ext_static_out_of_line : diag::err_static_out_of_line)
10229 if ((Name.getCXXOverloadedOperator() == OO_Delete ||
10230 Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
10245 PendingInlineFuncDecls.insert(NewFD);
10252 isMemberSpecialization ||
10253 isFunctionTemplateSpecialization);
10263 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
10288 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
10292 Params.push_back(Param);
10307 auto *TD = dyn_cast<TagDecl>(NonParmDecl);
10312 if (
auto *ECD = dyn_cast<EnumConstantDecl>(NonParmDecl))
10313 TD = cast<EnumDecl>(ECD->getDeclContext());
10317 DeclContext *TagDC = TD->getLexicalDeclContext();
10321 TD->setDeclContext(NewFD);
10329 if (TagDC != PrototypeTagContext)
10330 TD->setLexicalDeclContext(TagDC);
10344 for (
const auto &AI : FT->param_types()) {
10348 Params.push_back(Param);
10352 "Should not need args for typedef of non-prototype fn");
10356 NewFD->setParams(Params);
10372 !NewFD->
hasAttr<SectionAttr>())
10373 NewFD->
addAttr(PragmaClangTextSectionAttr::CreateImplicit(
10379 !NewFD->
hasAttr<SectionAttr>()) {
10380 NewFD->
addAttr(SectionAttr::CreateImplicit(
10382 CodeSegStack.CurrentPragmaLocation, SectionAttr::Declspec_allocate));
10393 !NewFD->
hasAttr<StrictGuardStackCheckAttr>())
10394 NewFD->
addAttr(StrictGuardStackCheckAttr::CreateImplicit(
10399 if (!NewFD->
hasAttr<CodeSegAttr>()) {
10408 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
10409 if (NewTVA && !NewTVA->isDefaultVersion() &&
10412 AddToScope =
false;
10424 Diag(NewFD->
getLocation(), diag::err_return_value_with_address_space);
10439 isMemberSpecialization,
10446 "previous declaration set still overloaded");
10458 CC ==
CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
10481 diag::ext_operator_new_delete_declared_inline)
10508 if (isFunctionTemplateSpecialization || isMemberSpecialization) {
10520 Diag(TRC->getBeginLoc(), diag::err_non_temp_spec_requires_clause)
10528 diag::err_non_temp_friend_decl_with_requires_clause_must_be_def);
10532 Diag(TRC->getBeginLoc(),
10533 diag::err_constrained_non_templated_function);
10550 if (isFunctionTemplateSpecialization) {
10551 bool isDependentSpecialization =
false;
10556 isDependentSpecialization =
10558 (HasExplicitTemplateArgs &&
10562 assert((!isDependentSpecialization ||
10563 (HasExplicitTemplateArgs == isDependentSpecialization)) &&
10564 "dependent friend function specialization without template "
10570 isDependentSpecialization =
10575 HasExplicitTemplateArgs ? &TemplateArgs :
nullptr;
10576 if (isDependentSpecialization) {
10583 NewFD, ExplicitTemplateArgs,
Previous))
10600 diag::err_explicit_specialization_inconsistent_storage_class)
10607 diag::ext_explicit_specialization_storage_class)
10611 }
else if (isMemberSpecialization && isa<CXXMethodDecl>(NewFD)) {
10625 isMemberSpecialization,
10634 "previous declaration set still overloaded");
10675 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
10721 *
this,
Previous, NewFD, ExtraArgs,
false,
nullptr)) {
10722 AddToScope = ExtraArgs.AddToScope;
10729 }
else if (isFriend && cast<CXXRecordDecl>(
CurContext)->isLocalClass()) {
10731 *
this,
Previous, NewFD, ExtraArgs,
true, S)) {
10732 AddToScope = ExtraArgs.AddToScope;
10737 isa<CXXMethodDecl>(NewFD) && NewFD->
isOutOfLine() &&
10738 !isFriend && !isFunctionTemplateSpecialization &&
10739 !isMemberSpecialization) {
10754 if (!NewFD->
isInvalidDecl() && S->getDepth() == 0 && Name.isIdentifier())
10757 if (NewFD->
hasAttr<HLSLShaderAttr>())
10765 if (
unsigned BuiltinID = II->getBuiltinID()) {
10767 if (!InStdNamespace &&
10773 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10782 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10787 NewFD->
addAttr(BuiltinAttr::CreateImplicit(
Context, BuiltinID));
10798 if (NewFD->
hasAttr<OverloadableAttr>() &&
10801 diag::err_attribute_overloadable_no_prototype)
10803 NewFD->
dropAttr<OverloadableAttr>();
10836 isMemberSpecialization ||
10837 isFunctionTemplateSpecialization,
10843 if (II && II->
isStr(
CUDA().getConfigureFuncName()) &&
10856 (NewFD->
hasAttr<CUDADeviceAttr>() ||
10857 NewFD->
hasAttr<CUDAGlobalAttr>()) &&
10912 diag::err_friend_decl_with_enclosing_temp_constraint_must_be_def);
10932 if (
getLangOpts().getOpenCLCompatibleVersion() >= 200) {
10934 QualType ElemTy = PipeTy->getElementType();
10936 Diag(Param->getTypeSpecStartLoc(), diag::err_reference_pipe_type );
10944 Diag(Param->getTypeSpecStartLoc(),
10945 diag::err_wasm_table_as_function_parameter);
10953 if (
const auto *
attr = NewFD->
getAttr<AvailabilityAttr>()) {
10954 if (NewFD->
hasAttr<ConstructorAttr>()) {
10955 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
10957 NewFD->
dropAttr<AvailabilityAttr>();
10959 if (NewFD->
hasAttr<DestructorAttr>()) {
10960 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
10962 NewFD->
dropAttr<AvailabilityAttr>();
10973 if (
const auto *NBA = NewFD->
getAttr<NoBuiltinAttr>())
10977 Diag(NBA->getLocation(),
10978 diag::err_attribute_no_builtin_on_defaulted_deleted_function)
10979 << NBA->getSpelling();
10982 Diag(NBA->getLocation(), diag::err_attribute_no_builtin_on_non_definition)
10983 << NBA->getSpelling();
11003 const auto *Method = dyn_cast<CXXMethodDecl>(FD);
11007 if (
const auto *SAttr =
Parent->getAttr<CodeSegAttr>()) {
11018 while ((
Parent = dyn_cast<CXXRecordDecl>(
Parent->getParent()))) {
11019 if (
const auto *SAttr =
Parent->getAttr<CodeSegAttr>()) {
11038 bool IsDefinition) {
11041 if (!FD->
hasAttr<SectionAttr>() && IsDefinition &&
11043 return SectionAttr::CreateImplicit(
11045 CodeSegStack.CurrentPragmaLocation, SectionAttr::Declspec_allocate);
11110 auto *VD = dyn_cast<ValueDecl>(D);
11111 auto *PrevVD = dyn_cast<ValueDecl>(PrevDecl);
11112 return !VD || !PrevVD ||
11114 PrevVD->getType());
11122 const auto *TA = FD->
getAttr<TargetAttr>();
11123 const auto *TVA = FD->
getAttr<TargetVersionAttr>();
11126 "MultiVersion candidate requires a target or target_version attribute");
11138 for (
const auto &Feat : ParseInfo.
Features) {
11139 auto BareFeat = StringRef{Feat}.substr(1);
11140 if (Feat[0] ==
'-') {
11142 << Feature << (
"no-" + BareFeat).str();
11149 << Feature << BareFeat;
11157 TVA->getFeatures(Feats);
11158 for (
const auto &Feat : Feats) {
11161 << Feature << Feat;
11180 case attr::NonNull:
11181 case attr::NoThrow:
11190 const auto Diagnose = [FD, CausedFD, MVKind](
Sema &S,
const Attr *A) {
11191 S.
Diag(FD->
getLocation(), diag::err_multiversion_disallowed_other_attr)
11192 <<
static_cast<unsigned>(MVKind) << A;
11194 S.
Diag(CausedFD->
getLocation(), diag::note_multiversioning_caused_here);
11199 switch (A->getKind()) {
11200 case attr::CPUDispatch:
11201 case attr::CPUSpecific:
11204 return Diagnose(S, A);
11208 return Diagnose(S, A);
11210 case attr::TargetVersion:
11213 return Diagnose(S, A);
11215 case attr::TargetClones:
11218 return Diagnose(S, A);
11222 return Diagnose(S, A);
11235 bool ConstexprSupported,
bool CLinkageMayDiffer) {
11236 enum DoesntSupport {
11243 DefaultedFuncs = 6,
11244 ConstexprFuncs = 7,
11245 ConstevalFuncs = 8,
11257 if (NoProtoDiagID.
getDiagID() != 0 && OldFD &&
11260 Diag(NoteCausedDiagIDAt.first, NoteCausedDiagIDAt.second);
11268 if (!TemplatesSupported &&
11270 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11273 if (
const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) {
11274 if (NewCXXFD->isVirtual())
11275 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11278 if (isa<CXXConstructorDecl>(NewCXXFD))
11279 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11282 if (isa<CXXDestructorDecl>(NewCXXFD))
11283 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11288 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11292 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11296 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11297 << (NewFD->
isConsteval() ? ConstevalFuncs : ConstexprFuncs);
11300 const auto *NewType = cast<FunctionType>(NewQType);
11301 QualType NewReturnType = NewType->getReturnType();
11304 return Diag(NoSupportDiagIDAt.first, NoSupportDiagIDAt.second)
11310 const auto *OldType = cast<FunctionType>(OldQType);
11314 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC())
11317 QualType OldReturnType = OldType->getReturnType();
11319 if (OldReturnType != NewReturnType)
11320 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ReturnType;
11323 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ConstexprSpec;
11326 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << InlineSpec;
11329 return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) <<
Linkage;
11353 bool IsCPUSpecificCPUDispatchMVKind =
11357 if (CausesMV && OldFD &&
11365 if (OldFD && CausesMV && OldFD->
isUsed(
false))
11366 return S.
Diag(NewFD->
getLocation(), diag::err_multiversion_after_used);
11369 OldFD, NewFD, S.
PDiag(diag::err_multiversion_noproto),
11371 S.
PDiag(diag::note_multiversioning_caused_here)),
11373 S.
PDiag(diag::err_multiversion_doesnt_support)
11374 <<
static_cast<unsigned>(MVKind)),
11376 S.
PDiag(diag::err_multiversion_diff)),
11378 !IsCPUSpecificCPUDispatchMVKind,
11391 "Function lacks multiversion attribute");
11392 const auto *TA = FD->
getAttr<TargetAttr>();
11393 const auto *TVA = FD->
getAttr<TargetVersionAttr>();
11396 if (TA && !TA->isDefaultVersion())
11433 To->
addAttr(TargetVersionAttr::CreateImplicit(
11440 bool &Redeclaration,
11450 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11451 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11452 const auto *OldTA = OldFD->
getAttr<TargetAttr>();
11453 const auto *OldTVA = OldFD->
getAttr<TargetVersionAttr>();
11456 if ((NewTA && !NewTA->isDefaultVersion() &&
11457 (!OldTA || OldTA->getFeaturesStr() == NewTA->getFeaturesStr())) ||
11458 (NewTVA && !NewTVA->isDefaultVersion() &&
11459 (!OldTVA || OldTVA->getName() == NewTVA->getName())))
11476 if ((NewTA && NewTA->isDefaultVersion() && !OldTA) ||
11477 (NewTVA && NewTVA->isDefaultVersion() && !OldTVA)) {
11478 Redeclaration =
true;
11486 S.
Diag(NewFD->
getLocation(), diag::note_multiversioning_caused_here);
11494 OldTA->getFeaturesStr());
11498 NewTA->getFeaturesStr());
11501 if (OldParsed == NewParsed) {
11511 OldTVA->getFeatures(Feats);
11514 NewTVA->getFeatures(NewFeats);
11515 llvm::sort(NewFeats);
11517 if (Feats == NewFeats) {
11525 for (
const auto *FD : OldFD->
redecls()) {
11526 const auto *CurTA = FD->
getAttr<TargetAttr>();
11527 const auto *CurTVA = FD->
getAttr<TargetVersionAttr>();
11531 ((NewTA && (!CurTA || CurTA->isInherited())) ||
11532 (NewTVA && (!CurTVA || CurTVA->isInherited())))) {
11534 << (NewTA ? 0 : 2);
11535 S.
Diag(NewFD->
getLocation(), diag::note_multiversioning_caused_here);
11543 Redeclaration =
false;
11582 const CPUDispatchAttr *NewCPUDisp,
const CPUSpecificAttr *NewCPUSpec,
11583 const TargetClonesAttr *NewClones,
bool &Redeclaration,
NamedDecl *&OldDecl,
11598 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11599 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11606 NewTA->getFeaturesStr());
11611 NewTVA->getFeatures(NewFeats);
11612 llvm::sort(NewFeats);
11615 bool UseMemberUsingDeclRules =
11618 bool MayNeedOverloadableChecks =
11627 if (MayNeedOverloadableChecks &&
11628 S.
IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
11631 switch (NewMVKind) {
11634 "Only target_clones can be omitted in subsequent declarations");
11637 const auto *CurTA = CurFD->
getAttr<TargetAttr>();
11638 if (CurTA->getFeaturesStr() == NewTA->getFeaturesStr()) {
11640 Redeclaration =
true;
11647 CurTA->getFeaturesStr());
11649 if (CurParsed == NewParsed) {
11658 if (
const auto *CurTVA = CurFD->
getAttr<TargetVersionAttr>()) {
11659 if (CurTVA->getName() == NewTVA->getName()) {
11661 Redeclaration =
true;
11666 CurTVA->getFeatures(CurFeats);
11667 llvm::sort(CurFeats);
11669 if (CurFeats == NewFeats) {
11675 }
else if (
const auto *CurClones = CurFD->
getAttr<TargetClonesAttr>()) {
11677 if (NewFeats.empty())
11680 for (
unsigned I = 0; I < CurClones->featuresStrs_size(); ++I) {
11682 CurClones->getFeatures(CurFeats, I);
11683 llvm::sort(CurFeats);
11685 if (CurFeats == NewFeats) {
11696 assert(NewClones &&
"MultiVersionKind does not match attribute type");
11697 if (
const auto *CurClones = CurFD->
getAttr<TargetClonesAttr>()) {
11698 if (CurClones->featuresStrs_size() != NewClones->featuresStrs_size() ||
11699 !std::equal(CurClones->featuresStrs_begin(),
11700 CurClones->featuresStrs_end(),
11701 NewClones->featuresStrs_begin())) {
11707 }
else if (
const auto *CurTVA = CurFD->
getAttr<TargetVersionAttr>()) {
11709 CurTVA->getFeatures(CurFeats);
11710 llvm::sort(CurFeats);
11713 if (CurFeats.empty())
11716 for (
unsigned I = 0; I < NewClones->featuresStrs_size(); ++I) {
11718 NewClones->getFeatures(NewFeats, I);
11719 llvm::sort(NewFeats);
11721 if (CurFeats == NewFeats) {
11730 Redeclaration =
true;
11737 const auto *CurCPUSpec = CurFD->
getAttr<CPUSpecificAttr>();
11738 const auto *CurCPUDisp = CurFD->
getAttr<CPUDispatchAttr>();
11743 CurFD->
hasAttr<CPUDispatchAttr>()) {
11744 if (CurCPUDisp->cpus_size() == NewCPUDisp->cpus_size() &&
11746 CurCPUDisp->cpus_begin(), CurCPUDisp->cpus_end(),
11747 NewCPUDisp->cpus_begin(),
11749 return Cur->getName() == New->getName();
11752 Redeclaration =
true;
11764 if (CurCPUSpec->cpus_size() == NewCPUSpec->cpus_size() &&
11766 CurCPUSpec->cpus_begin(), CurCPUSpec->cpus_end(),
11767 NewCPUSpec->cpus_begin(),
11769 return Cur->getName() == New->getName();
11772 Redeclaration =
true;
11780 if (CurII == NewII) {
11815 Redeclaration =
true;
11821 Redeclaration =
false;
11834 bool &Redeclaration,
NamedDecl *&OldDecl,
11836 const auto *NewTA = NewFD->
getAttr<TargetAttr>();
11837 const auto *NewTVA = NewFD->
getAttr<TargetVersionAttr>();
11838 const auto *NewCPUDisp = NewFD->
getAttr<CPUDispatchAttr>();
11839 const auto *NewCPUSpec = NewFD->
getAttr<CPUSpecificAttr>();
11840 const auto *NewClones = NewFD->
getAttr<TargetClonesAttr>();
11850 NewTVA->isDefaultVersion())) {
11851 S.
Diag(NewFD->
getLocation(), diag::err_multiversion_not_allowed_on_main);
11861 if (NewTA &&
T.isAArch64())
11865 if (NewTA &&
T.isRISCV())
11881 if (NewTVA || !OldFD->
getAttr<TargetVersionAttr>())
11889 NewFD->
addAttr(TargetVersionAttr::CreateImplicit(
11894 Redeclaration =
true;
11904 S.
Diag(NewFD->
getLocation(), diag::err_multiversion_required_in_redecl)
11917 if (OldFD->
isUsed(
false)) {
11919 return S.
Diag(NewFD->
getLocation(), diag::err_multiversion_after_used);
11935 NewCPUSpec, NewClones, Redeclaration,
11940 bool IsPure = NewFD->
hasAttr<PureAttr>();
11941 bool IsConst = NewFD->
hasAttr<ConstAttr>();
11944 if (!IsPure && !IsConst)
11951 if (IsPure && IsConst) {
11961 NewFD->
dropAttrs<PureAttr, ConstAttr>();
11984 bool IsMemberSpecialization,
11987 "Variably modified return types are not handled here");
11992 bool MergeTypeWithPrevious = !
getLangOpts().CPlusPlus &&
11995 bool Redeclaration =
false;
11997 bool MayNeedOverloadableChecks =
false;
12008 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
12009 Redeclaration =
true;
12010 OldDecl = Candidate;
12013 MayNeedOverloadableChecks =
true;
12017 Redeclaration =
true;
12021 Redeclaration =
true;
12025 Redeclaration =
false;
12032 if (!Redeclaration &&
12037 Redeclaration =
true;
12038 OldDecl =
Previous.getFoundDecl();
12039 MergeTypeWithPrevious =
false;
12042 if (OldDecl->
hasAttr<OverloadableAttr>() ||
12043 NewFD->
hasAttr<OverloadableAttr>()) {
12044 if (
IsOverload(NewFD, cast<FunctionDecl>(OldDecl),
false)) {
12045 MayNeedOverloadableChecks =
true;
12046 Redeclaration =
false;
12054 return Redeclaration;
12104 !MD->
isStatic() && !isa<CXXConstructorDecl>(MD) &&
12108 OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->
getAsFunction());
12109 if (!OldMD || !OldMD->
isStatic()) {
12131 if (Redeclaration) {
12137 return Redeclaration;
12144 dyn_cast<FunctionTemplateDecl>(OldDecl)) {
12145 auto *OldFD = OldTemplateDecl->getTemplatedDecl();
12148 assert(NewTemplateDecl &&
"Template/non-template mismatch");
12157 NewFD->
setAccess(OldTemplateDecl->getAccess());
12158 NewTemplateDecl->
setAccess(OldTemplateDecl->getAccess());
12163 if (IsMemberSpecialization &&
12166 assert(OldTemplateDecl->isMemberSpecialization());
12169 if (OldFD->isDeleted()) {
12171 assert(OldFD->getCanonicalDecl() == OldFD);
12173 OldFD->setDeletedAsWritten(
false);
12179 auto *OldFD = cast<FunctionDecl>(OldDecl);
12187 !NewFD->
getAttr<OverloadableAttr>()) {
12191 return ND->hasAttr<OverloadableAttr>();
12193 "Non-redecls shouldn't happen without overloadable present");
12196 const auto *FD = dyn_cast<FunctionDecl>(ND);
12197 return FD && !FD->
hasAttr<OverloadableAttr>();
12200 if (OtherUnmarkedIter !=
Previous.end()) {
12202 diag::err_attribute_overloadable_multiple_unmarked_overloads);
12203 Diag((*OtherUnmarkedIter)->getLocation(),
12204 diag::note_attribute_overloadable_prev_overload)
12221 dyn_cast<CXXDestructorDecl>(NewFD)) {
12229 !
Destructor->getFunctionObjectParameterType()->isDependentType()) {
12238 return Redeclaration;
12241 }
else if (
auto *Guide = dyn_cast<CXXDeductionGuideDecl>(NewFD)) {
12242 if (
auto *TD = Guide->getDescribedFunctionTemplate())
12248 Diag(Guide->getBeginLoc(), diag::err_deduction_guide_specialized)
12253 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
12254 if (!Method->isFunctionTemplateSpecialization() &&
12255 !Method->getDescribedFunctionTemplate() &&
12256 Method->isCanonicalDecl()) {
12263 diag::err_constrained_virtual_method);
12265 if (Method->isStatic())
12276 return Redeclaration;
12283 return Redeclaration;
12303 Diag(NewFD->
getLocation(), diag::warn_return_value_udt) << NewFD << R;
12316 auto HasNoexcept = [&](
QualType T) ->
bool {
12327 if (FPT->isNothrow())
12333 bool AnyNoexcept = HasNoexcept(FPT->getReturnType());
12335 AnyNoexcept |= HasNoexcept(
T);
12338 diag::warn_cxx17_compat_exception_spec_in_signature)
12342 if (!Redeclaration &&
LangOpts.CUDA)
12351 bool UsesSM = NewFD->
hasAttr<ArmLocallyStreamingAttr>();
12352 bool UsesZA =
Attr &&
Attr->isNewZA();
12353 bool UsesZT0 =
Attr &&
Attr->isNewZT0();
12355 if (NewFD->
hasAttr<ArmLocallyStreamingAttr>()) {
12358 diag::warn_sme_locally_streaming_has_vl_args_returns)
12361 return P->getOriginalType()->isSizelessVectorType();
12364 diag::warn_sme_locally_streaming_has_vl_args_returns)
12377 if (UsesSM || UsesZA) {
12378 llvm::StringMap<bool> FeatureMap;
12380 if (!FeatureMap.contains(
"sme")) {
12383 diag::err_sme_definition_using_sm_in_non_sme_target);
12386 diag::err_sme_definition_using_za_in_non_sme_target);
12390 llvm::StringMap<bool> FeatureMap;
12392 if (!FeatureMap.contains(
"sme2")) {
12394 diag::err_sme_definition_using_zt0_in_non_sme2_target);
12399 return Redeclaration;
12412 ? diag::err_static_main : diag::warn_static_main)
12420 Diag(NoreturnLoc, diag::ext_noreturn_main);
12421 Diag(NoreturnLoc, diag::note_main_remove_noreturn)
12433 << FD->
hasAttr<OpenCLKernelAttr>();
12444 assert(
T->
isFunctionType() &&
"function decl is not of function type");
12466 Diag(RTRange.
getBegin(), diag::note_main_change_return_type)
12488 if (isa<FunctionNoProtoType>(FT))
return;
12494 bool HasExtraParameters = (nparams > 3);
12506 HasExtraParameters =
false;
12508 if (HasExtraParameters) {
12521 for (
unsigned i = 0; i < nparams; ++i) {
12524 bool mismatch =
true;
12541 mismatch = !qs.
empty();
12570 if (
T.isWindowsGNUEnvironment())
12575 if (
T.isOSWindows() &&
T.getArch() == llvm::Triple::x86)
12583 assert(
T->
isFunctionType() &&
"function decl is not of function type");
12592 if (FD->
getName() !=
"DllMain")
12626 if (
Init->isValueDependent()) {
12627 assert(
Init->containsErrors() &&
12628 "Dependent code should only occur in error-recovery path.");
12631 const Expr *Culprit;
12632 if (
Init->isConstantInitializer(
Context,
false, &Culprit))
12641 class SelfReferenceChecker
12647 bool isReferenceType;
12655 SelfReferenceChecker(
Sema &S,
Decl *OrigDecl) : Inherited(S.Context),
12656 S(S), OrigDecl(OrigDecl) {
12659 isReferenceType =
false;
12660 isInitList =
false;
12661 if (
ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
12662 isPODType = VD->getType().isPODType(S.
Context);
12664 isReferenceType = VD->getType()->isReferenceType();
12671 void CheckExpr(
Expr *E) {
12680 InitFieldIndex.push_back(0);
12681 for (
auto *Child : InitList->
children()) {
12682 CheckExpr(cast<Expr>(Child));
12683 ++InitFieldIndex.back();
12685 InitFieldIndex.pop_back();
12690 bool CheckInitListMemberExpr(
MemberExpr *E,
bool CheckReference) {
12693 bool ReferenceField =
false;
12697 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
12700 Fields.push_back(FD);
12702 ReferenceField =
true;
12703 Base = ME->getBase()->IgnoreParenImpCasts();
12708 if (!DRE || DRE->
getDecl() != OrigDecl)
12712 if (CheckReference && !ReferenceField)
12717 for (
const FieldDecl *I : llvm::reverse(Fields))
12718 UsedFieldIndex.push_back(I->getFieldIndex());
12723 for (
auto UsedIter = UsedFieldIndex.begin(),
12724 UsedEnd = UsedFieldIndex.end(),
12725 OrigIter = InitFieldIndex.begin(),
12726 OrigEnd = InitFieldIndex.end();
12727 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
12728 if (*UsedIter < *OrigIter)
12730 if (*UsedIter > *OrigIter)
12735 HandleDeclRefExpr(DRE);
12742 void HandleValue(
Expr *E) {
12744 if (
DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
12745 HandleDeclRefExpr(DRE);
12750 Visit(CO->getCond());
12751 HandleValue(CO->getTrueExpr());
12752 HandleValue(CO->getFalseExpr());
12757 dyn_cast<BinaryConditionalOperator>(E)) {
12758 Visit(BCO->getCond());
12759 HandleValue(BCO->getFalseExpr());
12764 if (
Expr *SE = OVE->getSourceExpr())
12770 if (BO->getOpcode() == BO_Comma) {
12771 Visit(BO->getLHS());
12772 HandleValue(BO->getRHS());
12777 if (isa<MemberExpr>(E)) {
12779 if (CheckInitListMemberExpr(cast<MemberExpr>(E),
12787 if (!isa<FieldDecl>(ME->getMemberDecl()))
12789 Base = ME->getBase()->IgnoreParenImpCasts();
12792 HandleDeclRefExpr(DRE);
12802 if (isReferenceType)
12803 HandleDeclRefExpr(E);
12812 Inherited::VisitImplicitCastExpr(E);
12817 if (CheckInitListMemberExpr(E,
true ))
12827 bool Warn = (MD && !MD->
isStatic());
12830 if (!isa<FieldDecl>(ME->getMemberDecl()))
12832 Base = ME->getBase()->IgnoreParenImpCasts();
12837 HandleDeclRefExpr(DRE);
12849 if (isa<UnresolvedLookupExpr>(Callee))
12850 return Inherited::VisitCXXOperatorCallExpr(E);
12854 HandleValue(Arg->IgnoreParenImpCasts());
12871 Inherited::VisitUnaryOperator(E);
12879 if (
InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
12880 if (ILE->getNumInits() == 1)
12881 ArgExpr = ILE->getInit(0);
12883 if (ICE->getCastKind() == CK_NoOp)
12884 ArgExpr = ICE->getSubExpr();
12885 HandleValue(ArgExpr);
12888 Inherited::VisitCXXConstructExpr(E);
12894 HandleValue(E->
getArg(0));
12898 Inherited::VisitCallExpr(E);
12903 HandleValue(E->
getLHS());
12908 Inherited::VisitBinaryOperator(E);
12921 if (OrigDecl != ReferenceDecl)
return;
12923 if (isReferenceType) {
12924 diag = diag::warn_uninit_self_reference_in_reference_init;
12925 }
else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
12926 diag = diag::warn_static_self_reference_in_init;
12927 }
else if (isa<TranslationUnitDecl>(OrigDecl->
getDeclContext()) ||
12930 diag = diag::warn_uninit_self_reference_in_init;
12944 static void CheckSelfReference(
Sema &S,
Decl* OrigDecl,
Expr *E,
12948 if (isa<ParmVarDecl>(OrigDecl))
12957 if (ICE->getCastKind() == CK_LValueToRValue)
12958 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
12959 if (DRE->
getDecl() == OrigDecl)
12962 SelfReferenceChecker(S, OrigDecl).CheckExpr(E);
12969 struct VarDeclOrName {
12975 return VN.VDecl ?
Diag << VN.VDecl :
Diag << VN.Name;
12985 bool IsInitCapture = !VDecl;
12987 "init captures are expected to be deduced prior to initialization");
12989 VarDeclOrName VN{VDecl, Name};
12992 assert(Deduced &&
"deduceVarTypeFromInitializer for non-deduced type");
12996 !isa_and_present<StringLiteral, InitListExpr>(
Init)) {
13005 assert(VDecl &&
"no init for init capture deduction?");
13009 if (!isa<DeducedTemplateSpecializationType>(Deduced) ||
13020 DeduceInits =
Init;
13022 auto *PL = dyn_cast_if_present<ParenListExpr>(
Init);
13024 DeduceInits = PL->exprs();
13026 if (isa<DeducedTemplateSpecializationType>(Deduced)) {
13027 assert(VDecl &&
"non-auto type for init capture deduction?");
13038 if (
auto *IL = dyn_cast<InitListExpr>(
Init))
13039 DeduceInits = IL->inits();
13043 if (DeduceInits.empty()) {
13046 Diag(
Init->getBeginLoc(), IsInitCapture
13047 ? diag::err_init_capture_no_expression
13048 : diag::err_auto_var_init_no_expression)
13053 if (DeduceInits.size() > 1) {
13054 Diag(DeduceInits[1]->getBeginLoc(),
13055 IsInitCapture ? diag::err_init_capture_multiple_expressions
13056 : diag::err_auto_var_init_multiple_expressions)
13061 Expr *DeduceInit = DeduceInits[0];
13062 if (
DirectInit && isa<InitListExpr>(DeduceInit)) {
13063 Diag(
Init->getBeginLoc(), IsInitCapture
13064 ? diag::err_init_capture_paren_braces
13065 : diag::err_auto_var_init_paren_braces)
13071 bool DefaultedAnyToId =
false;
13075 if (
Result.isInvalid()) {
13079 DefaultedAnyToId =
true;
13085 if (VDecl && isa<DecompositionDecl>(VDecl) &&
13089 Type.getQualifiers());
13097 if (!IsInitCapture)
13099 else if (isa<InitListExpr>(
Init))
13101 diag::err_init_capture_deduction_failure_from_init_list)
13130 assert(!
Init || !
Init->containsErrors());
13143 if (
getLangOpts().ObjCAutoRefCount &&
ObjC().inferObjCARCLifetime(VDecl))
13164 if (
auto *EWC = dyn_cast<ExprWithCleanups>(
Init))
13165 Init = EWC->getSubExpr();
13167 if (
auto *CE = dyn_cast<ConstantExpr>(
Init))
13168 Init = CE->getSubExpr();
13173 "shouldn't be called if type doesn't have a non-trivial C struct");
13174 if (
auto *ILE = dyn_cast<InitListExpr>(
Init)) {
13175 for (
auto *I : ILE->inits()) {
13176 if (!I->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion() &&
13177 !I->getType().hasNonTrivialToPrimitiveCopyCUnion())
13185 if (isa<ImplicitValueInitExpr>(
Init)) {
13201bool shouldIgnoreForRecordTriviality(
const FieldDecl *FD) {
13207 return FD->
hasAttr<UnavailableAttr>();
13210struct DiagNonTrivalCUnionDefaultInitializeVisitor
13217 DiagNonTrivalCUnionDefaultInitializeVisitor(
13220 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13223 const FieldDecl *FD,
bool InNonTrivialUnion) {
13226 InNonTrivialUnion);
13227 return Super::visitWithKind(PDIK, QT, FD, InNonTrivialUnion);
13231 bool InNonTrivialUnion) {
13232 if (InNonTrivialUnion)
13234 << 1 << 0 << QT << FD->
getName();
13238 if (InNonTrivialUnion)
13240 << 1 << 0 << QT << FD->
getName();
13246 if (OrigLoc.isValid()) {
13247 bool IsUnion =
false;
13248 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13249 IsUnion = OrigRD->isUnion();
13250 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13251 << 0 << OrigTy << IsUnion << UseContext;
13255 InNonTrivialUnion =
true;
13258 if (InNonTrivialUnion)
13263 if (!shouldIgnoreForRecordTriviality(FD))
13264 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13277struct DiagNonTrivalCUnionDestructedTypeVisitor
13282 DiagNonTrivalCUnionDestructedTypeVisitor(
13285 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13288 const FieldDecl *FD,
bool InNonTrivialUnion) {
13291 InNonTrivialUnion);
13292 return Super::visitWithKind(DK, QT, FD, InNonTrivialUnion);
13296 bool InNonTrivialUnion) {
13297 if (InNonTrivialUnion)
13299 << 1 << 1 << QT << FD->
getName();
13303 if (InNonTrivialUnion)
13305 << 1 << 1 << 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 << 1 << OrigTy << IsUnion << UseContext;
13320 InNonTrivialUnion =
true;
13323 if (InNonTrivialUnion)
13328 if (!shouldIgnoreForRecordTriviality(FD))
13329 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13334 bool InNonTrivialUnion) {}
13344struct DiagNonTrivalCUnionCopyVisitor
13351 : OrigTy(OrigTy), OrigLoc(OrigLoc), UseContext(UseContext), S(S) {}
13354 const FieldDecl *FD,
bool InNonTrivialUnion) {
13357 InNonTrivialUnion);
13358 return Super::visitWithKind(PCK, QT, FD, InNonTrivialUnion);
13362 bool InNonTrivialUnion) {
13363 if (InNonTrivialUnion)
13365 << 1 << 2 << QT << FD->
getName();
13369 if (InNonTrivialUnion)
13371 << 1 << 2 << QT << FD->
getName();
13377 if (OrigLoc.isValid()) {
13378 bool IsUnion =
false;
13379 if (
auto *OrigRD = OrigTy->getAsRecordDecl())
13380 IsUnion = OrigRD->isUnion();
13381 S.
Diag(OrigLoc, diag::err_non_trivial_c_union_in_invalid_context)
13382 << 2 << OrigTy << IsUnion << UseContext;
13386 InNonTrivialUnion =
true;
13389 if (InNonTrivialUnion)
13394 if (!shouldIgnoreForRecordTriviality(FD))
13395 asDerived().visit(FD->
getType(), FD, InNonTrivialUnion);
13399 const FieldDecl *FD,
bool InNonTrivialUnion) {}
13402 bool InNonTrivialUnion) {}
13416 unsigned NonTrivialKind) {
13420 "shouldn't be called if type doesn't have a non-trivial C union");
13424 DiagNonTrivalCUnionDefaultInitializeVisitor(QT,
Loc, UseContext, *
this)
13425 .
visit(QT,
nullptr,
false);
13428 DiagNonTrivalCUnionDestructedTypeVisitor(QT,
Loc, UseContext, *
this)
13429 .visit(QT,
nullptr,
false);
13431 DiagNonTrivalCUnionCopyVisitor(QT,
Loc, UseContext, *
this)
13432 .visit(QT,
nullptr,
false);
13446 if (
auto *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
13447 if (!Method->isInvalidDecl()) {
13449 Diag(Method->getLocation(), diag::err_member_function_initialization)
13450 << Method->getDeclName() <<
Init->getSourceRange();
13451 Method->setInvalidDecl();
13456 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
13458 assert(!isa<FieldDecl>(RealDecl) &&
"field init shouldn't get here");
13468 SubExprs.push_back(Res.
get());
13471 if (
Expr *E = Recovery.
get())
13477 if (
Init && !
Init->getType().isNull() &&
13478 Init->getType()->isWebAssemblyTableType()) {
13479 Diag(
Init->getExprLoc(), diag::err_wasm_table_art) << 0;
13510 Diag(VDecl->
getLocation(), diag::err_attribute_dllimport_data_definition);
13531 BaseDeclType = Array->getElementType();
13533 diag::err_typecheck_decl_incomplete_type)) {
13540 diag::err_abstract_type_in_decl,
13550 !VDecl->
isTemplated() && !isa<VarTemplateSpecializationDecl>(VDecl)) {
13559 if (Def != VDecl &&
13579 Diag(
Init->getExprLoc(), diag::err_static_data_member_reinitialization)
13582 diag::note_previous_initializer)
13605 if (VDecl->
hasAttr<LoaderUninitializedAttr>()) {
13606 Diag(VDecl->
getLocation(), diag::err_loader_uninitialized_cant_init);
13620 if (
Result.isInvalid()) {
13629 bool IsParenListInit =
false;
13641 for (
size_t Idx = 0; Idx < Args.size(); ++Idx) {
13643 Args[Idx], VDecl,
true,
13644 [
this, Entity, Kind](
Expr *E) {
13650 }
else if (Res.
get() != Args[Idx]) {
13651 Args[Idx] = Res.
get();
13661 if (
Result.isInvalid()) {
13675 if (isa<DecompositionDecl>(VDecl))
13681 IsParenListInit = !InitSeq.
steps().empty() &&
13685 if (
Init && !
Init->getType().isNull() &&
13717 if (VDecl->
hasAttr<BlocksAttr>())
13731 Init->getBeginLoc()))
13732 FSI->markSafeWeakUse(
Init);
13749 if (
Result.isInvalid()) {
13782 isa<InitListExpr>(
Init)) {
13786 if (
auto *E = dyn_cast<ExprWithCleanups>(
Init))
13787 if (
auto *BE = dyn_cast<BlockExpr>(E->getSubExpr()->
IgnoreParens()))
13789 BE->getBlockDecl()->setCanAvoidCopyToHeap();
13824 <<
Init->getSourceRange();
13835 else if (
Init->isValueDependent())
13839 else if (
Init->getType()->isScopedEnumeralType() &&
13845 Diag(
Loc, diag::ext_in_class_initializer_non_constant)
13846 <<
Init->getSourceRange();
13850 Diag(
Loc, diag::err_in_class_initializer_non_constant)
13851 <<
Init->getSourceRange();
13861 diag::ext_in_class_initializer_float_type_cxx11)
13862 << DclT <<
Init->getSourceRange();
13864 diag::note_in_class_initializer_float_type_cxx11)
13867 Diag(VDecl->
getLocation(), diag::ext_in_class_initializer_float_type)
13868 << DclT <<
Init->getSourceRange();
13871 Diag(
Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
13872 <<
Init->getSourceRange();
13879 Diag(VDecl->
getLocation(), diag::err_in_class_initializer_literal_type)
13880 << DclT <<
Init->getSourceRange()
13886 << DclT <<
Init->getSourceRange();
13920 if (!InitType.
isNull() &&
13939 if (CXXDirectInit) {
13940 assert(
DirectInit &&
"Call-style initializer must be direct init.");
13951 DeclsToCheckForDeferredDiags.insert(VDecl);
13964 VarDecl *VD = dyn_cast<VarDecl>(D);
13968 if (
auto *DD = dyn_cast<DecompositionDecl>(D))
13969 for (
auto *BD : DD->bindings())
13970 BD->setInvalidDecl();
13984 diag::err_typecheck_decl_incomplete_type)) {
13991 diag::err_abstract_type_in_decl,
14006 if (
VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
14010 if (isa<DecompositionDecl>(RealDecl)) {
14011 Diag(Var->getLocation(), diag::err_decomp_decl_requires_init) << Var;
14012 Var->setInvalidDecl();
14026 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition() &&
14027 !Var->isThisDeclarationADemotedDefinition()) {
14028 if (Var->isStaticDataMember()) {
14033 Diag(Var->getLocation(),
14034 diag::err_constexpr_static_mem_var_requires_init)
14036 Var->setInvalidDecl();
14040 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
14041 Var->setInvalidDecl();
14048 if (!Var->isInvalidDecl() &&
14050 Var->getStorageClass() !=
SC_Extern && !Var->getInit()) {
14051 bool HasConstExprDefaultConstructor =
false;
14052 if (
CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
14053 for (
auto *Ctor : RD->ctors()) {
14054 if (Ctor->isConstexpr() && Ctor->getNumParams() == 0 &&
14055 Ctor->getMethodQualifiers().getAddressSpace() ==
14057 HasConstExprDefaultConstructor =
true;
14061 if (!HasConstExprDefaultConstructor) {
14062 Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
14063 Var->setInvalidDecl();
14068 if (!Var->isInvalidDecl() && RealDecl->
hasAttr<LoaderUninitializedAttr>()) {
14069 if (Var->getStorageClass() ==
SC_Extern) {
14070 Diag(Var->getLocation(), diag::err_loader_uninitialized_extern_decl)
14072 Var->setInvalidDecl();
14076 diag::err_typecheck_decl_incomplete_type)) {
14077 Var->setInvalidDecl();
14080 if (
CXXRecordDecl *RD = Var->getType()->getAsCXXRecordDecl()) {
14081 if (!RD->hasTrivialDefaultConstructor()) {
14082 Diag(Var->getLocation(), diag::err_loader_uninitialized_trivial_ctor);
14083 Var->setInvalidDecl();
14093 Var->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion())
14100 if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
14116 !Var->hasLinkage() && !Var->isInvalidDecl() &&
14118 diag::err_typecheck_decl_incomplete_type))
14119 Var->setInvalidDecl();
14124 diag::err_abstract_type_in_decl,
14126 Var->setInvalidDecl();
14129 Diag(Var->getLocation(), diag::warn_private_extern);
14130 Diag(Var->getLocation(), diag::note_private_extern);
14134 !Var->isInvalidDecl())
14145 if (!Var->isInvalidDecl()) {
14149 Var->getLocation(), ArrayT->getElementType(),
14150 diag::err_array_incomplete_or_sizeless_type))
14151 Var->setInvalidDecl();
14152 }
else if (Var->getStorageClass() ==
SC_Static) {
14162 if (Var->isFirstDecl())
14164 diag::ext_typecheck_decl_incomplete_type);
14169 if (!Var->isInvalidDecl())
14177 if (Var->isConstexpr())
14178 Diag(Var->getLocation(), diag::err_constexpr_var_requires_const_init)
14181 Diag(Var->getLocation(),
14182 diag::err_typecheck_incomplete_array_needs_initializer);
14183 Var->setInvalidDecl();
14190 Diag(Var->getLocation(), diag::err_reference_var_requires_init)
14191 << Var <<
SourceRange(Var->getLocation(), Var->getLocation());
14200 if (Var->isInvalidDecl())
14203 if (!Var->hasAttr<AliasAttr>()) {
14206 diag::err_typecheck_decl_incomplete_type)) {
14207 Var->setInvalidDecl();
14216 diag::err_abstract_type_in_decl,
14218 Var->setInvalidDecl();
14239 if (!CXXRecord->isPOD())
14273 }
else if (
Init.isInvalid()) {
14291 VarDecl *VD = dyn_cast<VarDecl>(D);
14350 const char *PrevSpec;
14362 cast<VarDecl>(Var)->setCXXForRangeDecl(
true);
14417 !isa<VarTemplatePartialSpecializationDecl>(var) &&
14419 !
getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
14427 Diag(var->
getLocation(), diag::warn_missing_variable_declarations) << var;
14434 std::optional<bool> CacheHasConstInit;
14435 const Expr *CacheCulprit =
nullptr;
14436 auto checkConstInit = [&]()
mutable {
14437 if (!CacheHasConstInit)
14440 return *CacheHasConstInit;
14452 if (!checkConstInit()) {
14467 isa<InitListExpr>(var->
getInit())) {
14468 const auto *ILE = cast<InitListExpr>(var->
getInit());
14469 unsigned NumInits = ILE->getNumInits();
14471 for (
unsigned I = 0; I < NumInits; ++I) {
14472 const auto *
Init = ILE->getInit(I);
14475 const auto *SL = dyn_cast<StringLiteral>(
Init->IgnoreImpCasts());
14479 unsigned NumConcat = SL->getNumConcatenated();
14483 if (NumConcat == 2 && !SL->getBeginLoc().isMacroID()) {
14484 bool OnlyOneMissingComma =
true;
14485 for (
unsigned J = I + 1; J < NumInits; ++J) {
14486 const auto *
Init = ILE->getInit(J);
14489 const auto *SLJ = dyn_cast<StringLiteral>(
Init->IgnoreImpCasts());
14490 if (!SLJ || SLJ->getNumConcatenated() > 1) {
14491 OnlyOneMissingComma =
false;
14496 if (OnlyOneMissingComma) {
14498 for (
unsigned i = 0; i < NumConcat - 1; ++i)
14502 Diag(SL->getStrTokenLoc(1),
14503 diag::warn_concatenated_literal_array_init)
14505 Diag(SL->getBeginLoc(),
14506 diag::note_concatenated_string_literal_silence);
14517 if (var->
hasAttr<BlocksAttr>())
14524 bool HasConstInit =
true;
14527 Diag(var->
getLocation(), diag::err_constexpr_var_requires_const_init)
14532 !
type->isDependentType() &&
Init && !
Init->isValueDependent() &&
14546 HasConstInit = checkConstInit();
14550 if (HasConstInit) {
14553 }
else if (CacheCulprit) {
14554 Notes.emplace_back(CacheCulprit->
getExprLoc(),
14555 PDiag(diag::note_invalid_subexpr_in_const_expr));
14563 if (HasConstInit) {
14569 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
14570 diag::note_invalid_subexpr_in_const_expr) {
14571 DiagLoc = Notes[0].first;
14574 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
14575 << var <<
Init->getSourceRange();
14576 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
14577 Diag(Notes[I].first, Notes[I].second);
14578 }
else if (GlobalStorage && var->
hasAttr<ConstInitAttr>()) {
14581 <<
Init->getSourceRange();
14584 for (
auto &it : Notes)
14585 Diag(it.first, it.second);
14586 }
else if (IsGlobal &&
14597 if (!checkConstInit())
14599 <<
Init->getSourceRange();
14611 std::optional<QualType::NonConstantStorageReason> Reason;
14612 if (HasConstInit &&
14619 if (
const SectionAttr *SA = var->
getAttr<SectionAttr>()) {
14623 }
else if (Stack->CurrentValue) {
14628 NonConstNonReferenceType) &&
14629 "This case should've already been handled elsewhere");
14636 auto SectionName = Stack->CurrentValue->getString();
14638 Stack->CurrentPragmaLocation,
14639 SectionAttr::Declspec_allocate));
14662 if (!
type->isDependentType())
14672 if (
auto *DD = dyn_cast<DecompositionDecl>(var))
14685 !FD->
hasAttr<DLLExportStaticLocalAttr>() &&
14686 !FD->
hasAttr<DLLImportStaticLocalAttr>()) {
14695 auto *NewAttr = cast<InheritableAttr>(A->clone(
getASTContext()));
14696 NewAttr->setInherited(
true);
14698 }
else if (
Attr *A = FD->
getAttr<DLLExportStaticLocalAttr>()) {
14699 auto *NewAttr = DLLExportAttr::CreateImplicit(
getASTContext(), *A);
14700 NewAttr->setInherited(
true);
14705 if (!FD->
hasAttr<DLLExportAttr>())
14708 }
else if (
Attr *A = FD->
getAttr<DLLImportStaticLocalAttr>()) {
14709 auto *NewAttr = DLLImportAttr::CreateImplicit(
getASTContext(), *A);
14710 NewAttr->setInherited(
true);
14741 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
14749 VD->
addAttr(PragmaClangBSSSectionAttr::CreateImplicit(
14753 VD->
addAttr(PragmaClangDataSectionAttr::CreateImplicit(
14757 VD->
addAttr(PragmaClangRodataSectionAttr::CreateImplicit(
14761 VD->
addAttr(PragmaClangRelroSectionAttr::CreateImplicit(
14766 if (
auto *DD = dyn_cast<DecompositionDecl>(ThisDecl)) {
14767 for (
auto *BD : DD->bindings()) {
14792 if (
const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
14799 bool IsClassTemplateMember =
14800 isa<ClassTemplatePartialSpecializationDecl>(
Context) ||
14801 Context->getDescribedClassTemplate();
14804 IsClassTemplateMember
14805 ? diag::warn_attribute_dllimport_static_field_definition
14806 : diag::err_attribute_dllimport_static_field_definition);
14807 Diag(IA->getLocation(), diag::note_attribute);
14808 if (!IsClassTemplateMember)
14836 if (RetainAttr *
Attr = VD->
getAttr<RetainAttr>()) {
14851 if (VD->
isFileVarDecl() && !isa<VarTemplatePartialSpecializationDecl>(VD))
14856 if (!VD->
hasAttr<TypeTagForDatatypeAttr>() ||
14860 for (
const auto *I : ThisDecl->
specific_attrs<TypeTagForDatatypeAttr>()) {
14862 if (!MagicValueExpr) {
14865 std::optional<llvm::APSInt> MagicValueInt;
14867 Diag(I->getRange().getBegin(),
14868 diag::err_type_tag_for_datatype_not_ice)
14872 if (MagicValueInt->getActiveBits() > 64) {
14873 Diag(I->getRange().getBegin(),
14874 diag::err_type_tag_for_datatype_too_large)
14878 uint64_t MagicValue = MagicValueInt->getZExtValue();
14881 I->getMatchingCType(),
14882 I->getLayoutCompatible(),
14883 I->getMustBeNull());
14888 auto *VD = dyn_cast<VarDecl>(DD);
14889 return VD && !VD->getType()->hasAutoForTrailingReturnType();
14901 bool DiagnosedMultipleDecomps =
false;
14903 bool DiagnosedNonDeducedAuto =
false;
14905 for (
unsigned i = 0, e = Group.size(); i != e; ++i) {
14906 if (
Decl *D = Group[i]) {
14909 if (
auto *VD = dyn_cast<VarDecl>(D);
14910 LangOpts.OpenMP && VD && VD->hasAttr<OMPDeclareTargetDeclAttr>() &&
14911 VD->hasGlobalStorage())
14915 if (
auto *DD = dyn_cast<DeclaratorDecl>(D)) {
14916 if (!FirstDeclaratorInGroup)
14917 FirstDeclaratorInGroup = DD;
14918 if (!FirstDecompDeclaratorInGroup)
14919 FirstDecompDeclaratorInGroup = dyn_cast<DecompositionDecl>(D);
14922 FirstNonDeducedAutoInGroup = DD;
14924 if (FirstDeclaratorInGroup != DD) {
14927 if (FirstDecompDeclaratorInGroup && !DiagnosedMultipleDecomps) {
14929 diag::err_decomp_decl_not_alone)
14931 << DD->getSourceRange();
14932 DiagnosedMultipleDecomps =
true;
14938 if (FirstNonDeducedAutoInGroup && !DiagnosedNonDeducedAuto) {
14940 diag::err_auto_non_deduced_not_alone)
14941 << FirstNonDeducedAutoInGroup->
getType()
14944 << DD->getSourceRange();
14945 DiagnosedNonDeducedAuto =
true;
14950 Decls.push_back(D);
14957 if (FirstDeclaratorInGroup && !Tag->hasNameForLinkage() &&
14973 if (Group.size() > 1) {
14975 VarDecl *DeducedDecl =
nullptr;
14976 for (
unsigned i = 0, e = Group.size(); i != e; ++i) {
14977 VarDecl *D = dyn_cast<VarDecl>(Group[i]);
14987 auto *AT = dyn_cast<AutoType>(DT);
14989 diag::err_auto_different_deductions)
14990 << (AT ? (
unsigned)AT->getKeyword() : 3) << Deduced
15015 if (Group.empty() || !Group[0])
15019 Group[0]->getLocation()) &&
15021 Group[0]->getLocation()))
15024 if (Group.size() >= 2) {
15032 Decl *MaybeTagDecl = Group[0];
15033 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
15034 Group = Group.slice(1);
15085 if (!ExplicitThisLoc.
isValid())
15088 "explicit parameter in non-cplusplus mode");
15090 S.
Diag(ExplicitThisLoc, diag::err_cxx20_deducing_this)
15091 <<
P->getSourceRange();
15095 if (
P->isParameterPack()) {
15096 S.
Diag(
P->getBeginLoc(), diag::err_explicit_object_parameter_pack)
15097 <<
P->getSourceRange();
15100 P->setExplicitObjectParameterLoc(ExplicitThisLoc);
15102 LSI->ExplicitObjectParameter =
P;
15122 : diag::warn_deprecated_register)
15130 diag::err_invalid_storage_class_in_func_decl);
15155 RedeclarationKind::ForVisibleRedeclaration);
15163 PrevDecl =
nullptr;
15165 if (PrevDecl && S->isDeclScope(PrevDecl)) {
15188 assert(S->isFunctionPrototypeScope());
15189 assert(S->getFunctionPrototypeDepth() >= 1);
15191 S->getNextFunctionPrototypeIndex());
15205 if (New->
hasAttr<BlocksAttr>()) {
15239 !
Parameter->getIdentifier()->isPlaceholder()) {
15240 Diag(
Parameter->getLocation(), diag::warn_unused_parameter)
15248 if (
LangOpts.NumLargeByValueCopy == 0)
15255 if (Size >
LangOpts.NumLargeByValueCopy)
15266 if (Size >
LangOpts.NumLargeByValueCopy)
15287 if (!
T.isConstQualified()) {
15291 NameLoc, diag::err_arc_array_param_no_ownership,
T,
false));
15293 Diag(NameLoc, diag::err_arc_array_param_no_ownership)
15305 TSInfo, SC,
nullptr);
15312 LSI->LocalPacks.push_back(New);
15325 diag::err_object_cannot_be_passed_returned_by_value) << 1 <<
T
15344 Diag(NameLoc, diag::err_arg_with_address_space);
15372 for (
int i = FTI.
NumParams; i != 0; ) {
15377 llvm::raw_svector_ostream(Code)
15388 const char* PrevSpec;
15420 if (
LangOpts.OpenMP &&
OpenMP().isInOpenMPDeclareVariantScope())
15422 ParentScope, D, TemplateParameterLists, Bases);
15428 if (!Bases.empty())
15445 if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
15448 PossiblePrototype = Prev;
15466 if (isa<CXXMethodDecl>(FD))
15472 if (II->isStr(
"main") || II->isStr(
"efi_main"))
15488 if (FD->
hasAttr<OpenCLKernelAttr>())
15542 Definition->getNumTemplateParameterLists())) {
15545 if (
auto *TD =
Definition->getDescribedFunctionTemplate())
15558 Diag(
Definition->getLocation(), diag::note_previous_definition);
15567 LSI->
Lambda = LambdaClass;
15591 for (
const auto &
C : LambdaClass->
captures()) {
15592 if (
C.capturesVariable()) {
15596 const bool ByRef =
C.getCaptureKind() ==
LCK_ByRef;
15598 true,
C.getLocation(),
15599 C.isPackExpansion()
15601 I->getType(),
false);
15603 }
else if (
C.capturesThis()) {
15629 FD = FunTmpl->getTemplatedDecl();
15631 FD = cast<FunctionDecl>(D);
15656 if (
const auto *
Attr = FD->
getAttr<AliasAttr>()) {
15661 if (
const auto *
Attr = FD->
getAttr<IFuncAttr>()) {
15666 if (
const auto *
Attr = FD->
getAttr<TargetVersionAttr>()) {
15668 !
Attr->isDefaultVersion()) {
15677 if (
auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
15679 Ctor->isDefaultConstructor() &&
15722 "There should be an active template instantiation on the stack "
15723 "when instantiating a generic lambda!");
15749 diag::err_func_def_incomplete_result) ||
15751 diag::err_abstract_type_in_decl,
15767 auto *NonParmDecl = dyn_cast<NamedDecl>(NPD);
15770 assert(!isa<ParmVarDecl>(NonParmDecl) &&
15771 "parameters should not be in newly created FD yet");
15774 if (NonParmDecl->getDeclName())
15779 if (
auto *ED = dyn_cast<EnumDecl>(NonParmDecl)) {
15780 for (
auto *EI : ED->enumerators())
15788 Param->setOwningFunction(FD);
15791 if (Param->getIdentifier() && FnBodyScope) {
15820 assert(!FD->
hasAttr<DLLExportAttr>());
15821 Diag(FD->
getLocation(), diag::err_attribute_dllimport_function_definition);
15844 if (
auto *TD = dyn_cast<FunctionTemplateDecl>(FD))
15845 FD = TD->getTemplatedDecl();
15846 if (FD && FD->
hasAttr<OptimizeNoneAttr>()) {
15870 for (
unsigned I = 0, E =
Scope->Returns.size(); I != E; ++I) {
15871 if (
const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
15872 if (!NRVOCandidate->isNRVOVariable())
15891 Outer.Fun.hasTrailingReturnType()) {
15909 if (FD->isConstexpr())
15914 if (FD->getReturnType()->getContainedDeducedType())
15924 FD->setHasSkippedBody();
15946 bool IsLambda =
false;
15950 llvm::DenseMap<const BlockDecl *, bool> EscapeInfo;
15952 auto IsOrNestedInEscapingBlock = [&](
const BlockDecl *BD) {
15953 if (EscapeInfo.count(BD))
15954 return EscapeInfo[BD];
15966 return EscapeInfo[BD] = R;
15971 for (
const std::pair<SourceLocation, const BlockDecl *> &
P :
15973 if (IsOrNestedInEscapingBlock(
P.second))
15974 S.
Diag(
P.first, diag::warn_implicitly_retains_self)
15979 return isa<CXXMethodDecl>(FD) && FD->
param_empty() &&
15989 methodHasName(FD,
"get_return_object_on_allocation_failure");
15999 if (!FD->
hasAttr<CoroWrapperAttr>())
16004 bool IsInstantiation) {
16054 Expr *Dummy =
nullptr;
16065 if (LSI->HasImplicitReturnType) {
16072 LSI->ReturnType.isNull() ?
Context.
VoidTy : LSI->ReturnType;
16077 Proto->getExtProtoInfo()));
16105 dyn_cast<CXXDestructorDecl>(FD))
16125 if (PossiblePrototype) {
16129 TypeLoc TL = TI->getTypeLoc();
16132 diag::note_declaration_not_a_prototype)
16135 FTL.getRParenLoc(),
"void")
16142 std::pair<FileID, unsigned> LocInfo =
SM.getDecomposedLoc(
Loc);
16143 if (LocInfo.first.isInvalid())
16147 StringRef Buffer =
SM.getBufferData(LocInfo.first, &
Invalid);
16151 if (LocInfo.second > Buffer.size())
16154 const char *LexStart = Buffer.data() + LocInfo.second;
16155 StringRef StartTok(LexStart, Buffer.size() - LocInfo.second);
16157 return StartTok.consume_front(
"const") &&
16159 StartTok.starts_with(
"/*") || StartTok.starts_with(
"//"));
16162 auto findBeginLoc = [&]() {
16178 diag::note_static_for_internal_linkage)
16189 if (!PossiblePrototype)
16235 if (PossiblePrototype)
16237 diag::warn_non_prototype_changes_behavior)
16244 if (
const auto *CmpndBody = dyn_cast<CompoundStmt>(Body))
16245 if (!CmpndBody->body_empty())
16246 Diag(CmpndBody->body_front()->getBeginLoc(),
16247 diag::warn_dispatch_body_ignored);
16249 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
16274 "Function parsing confused");
16275 }
else if (
ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
16287 << MD->getSelector().getAsString();
16292 bool isDesignated =
16293 MD->isDesignatedInitializerForTheInterface(&InitMethod);
16294 assert(isDesignated && InitMethod);
16295 (void)isDesignated;
16298 auto IFace = MD->getClassInterface();
16301 auto SuperD = IFace->getSuperClass();
16311 diag::warn_objc_designated_init_missing_super_call);
16313 diag::note_objc_designated_init_marked_here);
16321 diag::warn_objc_secondary_init_missing_init_call);
16337 "This should only be set for ObjC methods, which should have been "
16338 "handled in the block above.");
16345 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
16353 if (!
Destructor->getParent()->isDependentType())
16371 ActivePolicy = &WP;
16374 if (!IsInstantiation && FD &&
16380 if (FD && FD->
hasAttr<NakedAttr>()) {
16384 bool RegisterVariables =
false;
16385 if (
auto *DS = dyn_cast<DeclStmt>(S)) {
16386 for (
const auto *
Decl : DS->decls()) {
16387 if (
const auto *Var = dyn_cast<VarDecl>(
Decl)) {
16388 RegisterVariables =
16389 Var->hasAttr<AsmLabelAttr>() && !Var->hasInit();
16390 if (!RegisterVariables)
16395 if (RegisterVariables)
16397 if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
16398 Diag(S->getBeginLoc(), diag::err_non_asm_stmt_in_naked_function);
16399 Diag(FD->
getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
16408 "Leftover temporaries in function");
16410 "Unaccounted cleanups in function");
16412 "Leftover expressions for odr-use checking");
16418 if (!IsInstantiation)
16435 DeclsToCheckForDeferredDiags.insert(FD);
16450 D = TD->getTemplatedDecl();
16454 if (
CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
16455 if (Method->isStatic())
16465 "Implicit function declarations aren't allowed in this language mode");
16472 Scope *BlockScope = S;
16480 Scope *ContextScope = BlockScope;
16484 ContextScope = ContextScope->
getParent();
16500 if (!isa<FunctionDecl>(ExternCPrev) ||
16502 cast<FunctionDecl>(ExternCPrev)->getType(),
16504 Diag(
Loc, diag::ext_use_out_of_scope_declaration)
16507 return ExternCPrev;
16513 if (II.
getName().starts_with(
"__builtin_"))
16514 diag_id = diag::warn_builtin_unknown;
16517 diag_id = diag::ext_implicit_function_decl_c99;
16519 diag_id = diag::warn_implicit_function_decl;
16527 if (S && !ExternCPrev &&
16550 return ExternCPrev;
16560 assert(!Error &&
"Error setting up implicit decl!");
16608 std::optional<unsigned> AlignmentParam;
16609 bool IsNothrow =
false;
16621 if (!IsNothrow && !FD->
hasAttr<ReturnsNonNullAttr>() &&
16639 if (!FD->
hasAttr<AllocSizeAttr>()) {
16640 FD->
addAttr(AllocSizeAttr::CreateImplicit(
16651 if (AlignmentParam && !FD->
hasAttr<AllocAlignAttr>()) {
16652 FD->
addAttr(AllocAlignAttr::CreateImplicit(
16685 unsigned FormatIdx;
16688 if (!FD->
hasAttr<FormatAttr>()) {
16689 const char *fmt =
"printf";
16691 if (FormatIdx < NumParams &&
16697 HasVAListArg ? 0 : FormatIdx+2,
16703 if (!FD->
hasAttr<FormatAttr>())
16707 HasVAListArg ? 0 : FormatIdx+2,
16713 if (!FD->
hasAttr<CallbackAttr>() &&
16715 FD->
addAttr(CallbackAttr::CreateImplicit(
16721 bool NoExceptions =
16723 bool ConstWithoutErrnoAndExceptions =
16725 bool ConstWithoutExceptions =
16727 if (!FD->
hasAttr<ConstAttr>() &&
16728 (ConstWithoutErrnoAndExceptions || ConstWithoutExceptions) &&
16729 (!ConstWithoutErrnoAndExceptions ||
16731 (!ConstWithoutExceptions || NoExceptions))
16738 if ((Trip.isGNUEnvironment() || Trip.isOSMSVCRT()) &&
16740 switch (BuiltinID) {
16741 case Builtin::BI__builtin_fma:
16742 case Builtin::BI__builtin_fmaf:
16743 case Builtin::BI__builtin_fmal:
16744 case Builtin::BIfma:
16745 case Builtin::BIfmaf:
16746 case Builtin::BIfmal:
16755 !FD->
hasAttr<ReturnsTwiceAttr>())
16765 !FD->
hasAttr<CUDADeviceAttr>() && !FD->
hasAttr<CUDAHostAttr>()) {
16777 switch (BuiltinID) {
16778 case Builtin::BImemalign:
16779 case Builtin::BIaligned_alloc:
16780 if (!FD->
hasAttr<AllocAlignAttr>())
16789 switch (BuiltinID) {
16790 case Builtin::BIcalloc:
16791 FD->
addAttr(AllocSizeAttr::CreateImplicit(
16794 case Builtin::BImemalign:
16795 case Builtin::BIaligned_alloc:
16796 case Builtin::BIrealloc:
16800 case Builtin::BImalloc:
16809 switch (BuiltinID) {
16810 case Builtin::BIaddressof:
16811 case Builtin::BI__addressof:
16812 case Builtin::BI__builtin_addressof:
16813 case Builtin::BIas_const:
16814 case Builtin::BIforward:
16815 case Builtin::BIforward_like:
16816 case Builtin::BImove:
16817 case Builtin::BImove_if_noexcept:
16819 !
P->hasAttr<LifetimeBoundAttr>())
16836 if (!FPT || FPT->getExceptionSpecType() ==
EST_None)
16852 if (Name->isStr(
"asprintf") || Name->isStr(
"vasprintf")) {
16855 if (!FD->
hasAttr<FormatAttr>())
16858 Name->isStr(
"vasprintf") ? 0 : 3,
16862 if (Name->isStr(
"__CFStringMakeConstantString")) {
16865 if (!FD->
hasAttr<FormatArgAttr>())
16873 assert(D.
getIdentifier() &&
"Wrong callback for declspec without declarator");
16874 assert(!
T.isNull() &&
"GetTypeForDeclarator() returned null type");
16877 assert(D.
isInvalidType() &&
"no declarator info for valid type");
16938 if (BT->isInteger())
16941 return Diag(UnderlyingLoc, diag::err_enum_invalid_underlying)
16948 QualType EnumUnderlyingTy,
bool IsFixed,
16950 if (IsScoped != Prev->
isScoped()) {
16951 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
16957 if (IsFixed && Prev->
isFixed()) {
16963 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
16969 }
else if (IsFixed != Prev->
isFixed()) {
16970 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
16992 default: llvm_unreachable(
"Invalid tag kind for redecl diagnostic!");
17008 if (isa<TypedefDecl>(PrevDecl))
17010 else if (isa<TypeAliasDecl>(PrevDecl))
17012 else if (isa<ClassTemplateDecl>(PrevDecl))
17014 else if (isa<TypeAliasTemplateDecl>(PrevDecl))
17016 else if (isa<TemplateTemplateParmDecl>(PrevDecl))
17028 llvm_unreachable(
"invalid TTK");
17053 if (OldTag != NewTag &&
17071 if (IsIgnoredLoc(NewTagLoc))
17074 auto IsIgnored = [&](
const TagDecl *Tag) {
17075 return IsIgnoredLoc(Tag->getLocation());
17089 if (OldTag != NewTag) {
17092 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
17100 if (isDefinition) {
17108 bool previousMismatch =
false;
17110 if (I->getTagKind() != NewTag) {
17115 if (!previousMismatch) {
17116 previousMismatch =
true;
17117 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
17121 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
17134 if (PrevDef && IsIgnored(PrevDef))
17138 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
17145 Diag(NewTagLoc, diag::note_struct_class_suggestion)
17175 if (!Namespace || Namespace->isAnonymousNamespace())
17178 Namespaces.push_back(II);
17181 if (Lookup == Namespace)
17188 llvm::raw_svector_ostream OS(Insertion);
17191 std::reverse(Namespaces.begin(), Namespaces.end());
17192 for (
auto *II : Namespaces)
17193 OS << II->getName() <<
"::";
17206 if (OldDC->
Equals(NewDC))
17235 bool ScopedEnumUsesClassTag,
TypeResult UnderlyingType,
17236 bool IsTypeSpecifier,
bool IsTemplateParamOrArg,
17241 "Nameless record must be a definition!");
17242 assert(TemplateParameterLists.size() == 0 || TUK !=
TUK_Reference);
17246 bool ScopedEnum = ScopedEnumKWLoc.
isValid();
17249 bool isMemberSpecialization =
false;
17255 if (TemplateParameterLists.size() > 0 ||
17259 KWLoc, NameLoc, SS,
nullptr, TemplateParameterLists,
17276 Diag(SS.
getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
17279 if (TemplateParams) {
17281 Diag(KWLoc, diag::err_enum_template);
17285 if (TemplateParams->
size() > 0) {
17294 S, TagSpec, TUK, KWLoc, SS, Name, NameLoc, Attrs, TemplateParams,
17295 AS, ModulePrivateLoc,
17297 TemplateParameterLists.data(), SkipBody);
17303 isMemberSpecialization =
true;
17307 if (!TemplateParameterLists.empty() && isMemberSpecialization &&
17326 ScopedEnum ?
SourceRange(KWLoc, ScopedEnumKWLoc) : KWLoc);
17327 assert(ScopedEnum || !ScopedEnumUsesClassTag);
17328 Diag(KWLoc, diag::note_enum_friend)
17329 << (ScopedEnum + ScopedEnumUsesClassTag);
17335 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
17336 bool IsFixed = !UnderlyingType.
isUnset() || ScopedEnum;
17339 if (UnderlyingType.
isInvalid() || (!UnderlyingType.
get() && ScopedEnum)) {
17343 }
else if (UnderlyingType.
get()) {
17348 EnumUnderlying = TI;
17370 bool isStdBadAlloc =
false;
17371 bool isStdAlignValT =
false;
17375 Redecl = RedeclarationKind::NotForRedeclaration;
17380 auto createTagFromNewDecl = [&]() ->
TagDecl * {
17390 ScopedEnum, ScopedEnumUsesClassTag, IsFixed);
17394 if (EnumUnderlying) {
17395 EnumDecl *ED = cast<EnumDecl>(New);
17410 if (
RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
17436 goto CreateNewDecl;
17444 IsDependent =
true;
17473 if (
Previous.wasNotFoundInCurrentInstantiation() &&
17475 IsDependent =
true;
17480 Diag(NameLoc, diag::err_not_tag_in_scope)
17481 << llvm::to_underlying(Kind) << Name << DC << SS.
getRange();
17484 goto CreateNewDecl;
17532 bool FriendSawTagOutsideEnclosingNamespace =
false;
17539 FriendSawTagOutsideEnclosingNamespace =
true;
17548 if (
Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
17550 Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
17564 while (isa<RecordDecl, EnumDecl, ObjCContainerDecl>(SearchDC))
17570 while (isa<ObjCContainerDecl>(SearchDC))
17576 while (isa<ObjCContainerDecl>(SearchDC))
17581 Previous.getFoundDecl()->isTemplateParameter()) {
17590 if (Name->isStr(
"bad_alloc")) {
17592 isStdBadAlloc =
true;
17599 }
else if (Name->isStr(
"align_val_t")) {
17600 isStdAlignValT =
true;
17612 if (
Invalid)
goto CreateNewDecl;
17696 TagDecl *Tag = TT->getDecl();
17699 ->
Equals(TD->getDeclContext()->getRedeclContext())) {
17712 if (
auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
17713 auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
17715 isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) &&
17717 *
this, OldTag->getDeclContext(), SearchDC))) {
17718 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
17719 Diag(Shadow->getTargetDecl()->getLocation(),
17720 diag::note_using_decl_target);
17721 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
17725 goto CreateNewDecl;
17729 if (
TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
17735 SS.
isNotEmpty() || isMemberSpecialization)) {
17741 bool SafeToContinue =
17744 if (SafeToContinue)
17745 Diag(KWLoc, diag::err_use_with_wrong_tag)
17748 PrevTagDecl->getKindName());
17750 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
17751 Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
17753 if (SafeToContinue)
17754 Kind = PrevTagDecl->getTagKind();
17765 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
17767 return PrevTagDecl;
17771 EnumUnderlyingTy = TI->getType().getUnqualifiedType();
17772 else if (
const Type *
T = EnumUnderlying.dyn_cast<
const Type*>())
17779 ScopedEnum, EnumUnderlyingTy,
17780 IsFixed, PrevEnum))
17789 S->isDeclScope(PrevDecl)) {
17790 Diag(NameLoc, diag::ext_member_redeclared);
17791 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
17798 if (!Attrs.
empty()) {
17802 (PrevTagDecl->getFriendObjectKind() ==
17815 return PrevTagDecl;
17820 return PrevTagDecl;
17826 if (
NamedDecl *Def = PrevTagDecl->getDefinition()) {
17830 bool IsExplicitSpecializationAfterInstantiation =
false;
17831 if (isMemberSpecialization) {
17833 IsExplicitSpecializationAfterInstantiation =
17834 RD->getTemplateSpecializationKind() !=
17836 else if (
EnumDecl *ED = dyn_cast<EnumDecl>(Def))
17837 IsExplicitSpecializationAfterInstantiation =
17838 ED->getTemplateSpecializationKind() !=
17858 SkipBody->
New = createTagFromNewDecl();
17868 }
else if (!IsExplicitSpecializationAfterInstantiation) {
17872 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
17874 Diag(NameLoc, diag::err_redefinition) << Name;
17876 NameLoc.
isValid() ? NameLoc : KWLoc);
17888 if (TD->isBeingDefined()) {
17889 Diag(NameLoc, diag::err_nested_redefinition) << Name;
17890 Diag(PrevTagDecl->getLocation(),
17891 diag::note_previous_definition);
17906 SearchDC = PrevTagDecl->getDeclContext();
17934 Diag(NameLoc, diag::err_tag_reference_non_tag)
17935 << PrevDecl << NTK << llvm::to_underlying(Kind);
17941 SS.
isNotEmpty() || isMemberSpecialization)) {
17947 Diag(NameLoc, diag::err_tag_reference_conflict) << NTK;
17953 }
else if (
TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
17955 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
17956 Diag(NameLoc, diag::err_tag_definition_of_typedef)
17957 << Name << Kind << TND->getUnderlyingType();
17965 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
17981 PrevDecl = cast<TagDecl>(
Previous.getFoundDecl());
17997 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
17998 ScopedEnumUsesClassTag, IsFixed);
18006 if (IsFixed && cast<EnumDecl>(New)->isFixed()) {
18010 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->
getDefinition())) {
18011 Diag(
Loc, diag::ext_forward_ref_enum_def)
18015 unsigned DiagID = diag::ext_forward_ref_enum;
18017 DiagID = diag::ext_ms_forward_ref_enum;
18019 DiagID = diag::err_forward_ref_enum;
18024 if (EnumUnderlying) {
18025 EnumDecl *ED = cast<EnumDecl>(New);
18034 assert(ED->
isComplete() &&
"enum with type should be complete");
18044 cast_or_null<CXXRecordDecl>(PrevDecl));
18050 cast_or_null<RecordDecl>(PrevDecl));
18062 (IsTypeSpecifier || IsTemplateParamOrArg) && TUK ==
TUK_Definition) {
18083 isMemberSpecialization))
18087 if (TemplateParameterLists.size() > 0) {
18095 if (
RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
18111 if (ModulePrivateLoc.
isValid()) {
18112 if (isMemberSpecialization)
18137 Diag(
Loc, diag::err_type_defined_in_param_type)
18141 }
else if (!PrevDecl) {
18202 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(New)) {
18219 if (
auto RD = dyn_cast<RecordDecl>(New))
18222 }
else if (SkipBody && SkipBody->
ShouldSkip) {
18231 TagDecl *Tag = cast<TagDecl>(TagD);
18254 bool IsFinalSpelledSealed,
18262 if (!
Record->getIdentifier())
18270 IsFinalSpelledSealed
18271 ? FinalAttr::Keyword_sealed
18272 : FinalAttr::Keyword_final));
18291 "Broken injected-class-name");
18297 TagDecl *Tag = cast<TagDecl>(TagD);
18302 assert(Tag->
isInvalidDecl() &&
"We should already have completed it");
18303 if (
RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
18307 if (
auto *RD = dyn_cast<CXXRecordDecl>(Tag)) {
18309 if (RD->
hasAttr<SYCLSpecialClassAttr>()) {
18311 assert(Def &&
"The record is expected to have a completed definition");
18312 unsigned NumInitMethods = 0;
18313 for (
auto *Method : Def->methods()) {
18314 if (!Method->getIdentifier())
18316 if (Method->getName() ==
"__init")
18319 if (NumInitMethods > 1 || !Def->hasInitMethod())
18320 Diag(RD->
getLocation(), diag::err_sycl_special_type_num_init_method);
18343 const RecordDecl *RD = dyn_cast<RecordDecl>(Tag);
18347 if (llvm::any_of(RD->
fields(),
18348 [](
const FieldDecl *FD) { return FD->isBitField(); }))
18349 Diag(BraceRange.
getBegin(), diag::warn_pragma_align_not_xl_compatible);
18355 TagDecl *Tag = cast<TagDecl>(TagD);
18360 if (
RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
18374 QualType FieldTy,
bool IsMsStruct,
18385 diag::err_field_incomplete_or_sizeless))
18388 return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
18390 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
18401 llvm::APSInt
Value;
18405 BitWidth = ICE.
get();
18408 if (
Value == 0 && FieldName)
18409 return Diag(FieldLoc, diag::err_bitfield_has_zero_width)
18412 if (
Value.isSigned() &&
Value.isNegative()) {
18414 return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
18416 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
18423 return Diag(FieldLoc, diag::err_bitfield_too_wide)
18430 bool BitfieldIsOverwide =
Value.ugt(TypeWidth);
18434 bool CStdConstraintViolation =
18436 bool MSBitfieldViolation =
18437 Value.ugt(TypeStorageSize) &&
18439 if (CStdConstraintViolation || MSBitfieldViolation) {
18440 unsigned DiagWidth =
18441 CStdConstraintViolation ? TypeWidth : TypeStorageSize;
18442 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_width)
18444 << !CStdConstraintViolation << DiagWidth;
18450 if (BitfieldIsOverwide && !FieldTy->
isBooleanType() && FieldName) {
18451 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_width)
18508 diag::err_invalid_thread)
18514 RedeclarationKind::ForVisibleRedeclaration);
18516 switch (
Previous.getResultKind()) {
18523 PrevDecl =
Previous.getRepresentativeDecl();
18537 PrevDecl =
nullptr;
18541 PrevDecl =
nullptr;
18548 TSSL, AS, PrevDecl, &D);
18551 Record->setInvalidDecl();
18580 bool Mutable,
Expr *BitWidth,
18586 bool InvalidDecl =
false;
18592 InvalidDecl =
true;
18599 diag::err_field_incomplete_or_sizeless)) {
18601 Record->setInvalidDecl();
18602 InvalidDecl =
true;
18607 Record->setInvalidDecl();
18608 InvalidDecl =
true;
18616 Diag(
Loc, diag::err_field_with_address_space);
18617 Record->setInvalidDecl();
18618 InvalidDecl =
true;
18626 Diag(
Loc, diag::err_opencl_type_struct_or_union_field) <<
T;
18627 Record->setInvalidDecl();
18628 InvalidDecl =
true;
18633 "__cl_clang_bitfields",
LangOpts)) {
18634 Diag(
Loc, diag::err_opencl_bitfields);
18635 InvalidDecl =
true;
18641 T.hasQualifiers()) {
18642 InvalidDecl =
true;
18643 Diag(
Loc, diag::err_anon_bitfield_qualifiers);
18650 TInfo,
T,
Loc, diag::err_typecheck_field_variable_size))
18651 InvalidDecl =
true;
18656 diag::err_abstract_type_in_decl,
18658 InvalidDecl =
true;
18661 BitWidth =
nullptr;
18667 InvalidDecl =
true;
18668 BitWidth =
nullptr;
18673 if (!InvalidDecl && Mutable) {
18674 unsigned DiagID = 0;
18676 DiagID =
getLangOpts().MSVCCompat ? diag::ext_mutable_reference
18677 : diag::err_mutable_reference;
18678 else if (
T.isConstQualified())
18679 DiagID = diag::err_mutable_const;
18685 Diag(ErrLoc, DiagID);
18686 if (DiagID != diag::ext_mutable_reference) {
18688 InvalidDecl =
true;
18700 BitWidth, Mutable, InitStyle);
18704 if (PrevDecl && !isa<TagDecl>(PrevDecl) &&
18706 Diag(
Loc, diag::err_duplicate_member) << II;
18712 if (
Record->isUnion()) {
18731 diag::ext_union_member_of_reference_type :
18732 diag::err_union_member_of_reference_type)
18752 if (
getLangOpts().ObjCAutoRefCount &&
ObjC().inferObjCARCLifetime(NewFD))
18755 if (
T.isObjCGCWeak())
18756 Diag(
Loc, diag::warn_attribute_weak_on_field);
18807 if (!FD->
hasAttr<UnavailableAttr>())
18809 UnavailableAttr::IR_ARCFieldWithOwnership,
Loc));
18817 ? diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member
18818 : diag::err_illegal_union_or_anon_struct_member)
18820 << llvm::to_underlying(member);
18839 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
18847 if (!CD->IsClassExtension())
18859 DeclLoc, DeclLoc,
nullptr,
18865 AllIvarDecls.push_back(Ivar);
18877 if (!
Record->hasUserDeclaredDestructor()) {
18885 if (
auto *DD = dyn_cast<CXXDestructorDecl>(
Decl)) {
18886 if (DD->isInvalidDecl())
18890 assert(DD->isIneligibleOrNotSelected() &&
"Selecting a destructor but a destructor was already selected.");
18904 Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(Best->Function));
18908 Msg = diag::err_ambiguous_destructor;
18913 Msg = diag::err_no_viable_destructor;
18924 Record->setInvalidDecl();
18931 Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(OCS.
begin()->Function));
18975 const Expr *Constraints = Method->getTrailingRequiresClause();
18977 SatisfactionStatus.push_back(
true);
18981 SatisfactionStatus.push_back(
false);
18983 SatisfactionStatus.push_back(Satisfaction.
IsSatisfied);
18987 for (
size_t i = 0; i < Methods.size(); i++) {
18988 if (!SatisfactionStatus[i])
18993 OrigMethod = cast<CXXMethodDecl>(MF);
18996 bool AnotherMethodIsMoreConstrained =
false;
18997 for (
size_t j = 0; j < Methods.size(); j++) {
18998 if (i == j || !SatisfactionStatus[j])
19002 OtherMethod = cast<CXXMethodDecl>(MF);
19009 if (!OtherConstraints)
19011 if (!Constraints) {
19012 AnotherMethodIsMoreConstrained =
true;
19017 AnotherMethodIsMoreConstrained)) {
19020 AnotherMethodIsMoreConstrained =
true;
19022 if (AnotherMethodIsMoreConstrained)
19027 if (!AnotherMethodIsMoreConstrained) {
19029 Record->addedEligibleSpecialMemberFunction(Method,
19030 1 << llvm::to_underlying(CSM));
19044 auto *MD = dyn_cast<CXXMethodDecl>(
Decl);
19046 auto *FTD = dyn_cast<FunctionTemplateDecl>(
Decl);
19048 MD = dyn_cast<CXXMethodDecl>(FTD->getTemplatedDecl());
19052 if (
auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
19053 if (CD->isInvalidDecl())
19055 if (CD->isDefaultConstructor())
19056 DefaultConstructors.push_back(MD);
19057 else if (CD->isCopyConstructor())
19058 CopyConstructors.push_back(MD);
19059 else if (CD->isMoveConstructor())
19060 MoveConstructors.push_back(MD);
19062 CopyAssignmentOperators.push_back(MD);
19064 MoveAssignmentOperators.push_back(MD);
19084 assert(EnclosingDecl &&
"missing record or interface decl");
19089 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
19093 case Decl::ObjCCategory:
19096 case Decl::ObjCImplementation:
19098 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
19104 CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(EnclosingDecl);
19108 unsigned NumNamedMembers = 0;
19110 for (
const auto *I :
Record->decls()) {
19111 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
19112 if (IFD->getDeclName())
19129 RecFields.push_back(FD);
19149 bool IsLastField = (i + 1 == Fields.end());
19158 (
Record || isa<ObjCContainerDecl>(EnclosingDecl))) {
19164 unsigned DiagID = 0;
19165 if (!
Record->isUnion() && !IsLastField) {
19168 << llvm::to_underlying(
Record->getTagKind());
19169 Diag((*(i + 1))->getLocation(), diag::note_next_field_declaration);
19173 }
else if (
Record->isUnion())
19175 ? diag::ext_flexible_array_union_ms
19176 : diag::ext_flexible_array_union_gnu;
19177 else if (NumNamedMembers < 1)
19179 ? diag::ext_flexible_array_empty_aggregate_ms
19180 : diag::ext_flexible_array_empty_aggregate_gnu;
19190 if (CXXRecord && CXXRecord->getNumVBases() != 0)
19204 Diag(FD->
getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
19211 Record->setHasFlexibleArrayMember(
true);
19220 diag::err_field_incomplete_or_sizeless)) {
19226 if (
Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
19229 Record->setHasFlexibleArrayMember(
true);
19230 if (!
Record->isUnion()) {
19245 if (isa<ObjCContainerDecl>(EnclosingDecl) &&
19247 diag::err_abstract_type_in_decl,
19252 if (
Record && FDTTy->getDecl()->hasObjectMember())
19253 Record->setHasObjectMember(
true);
19254 if (
Record && FDTTy->getDecl()->hasVolatileMember())
19255 Record->setHasVolatileMember(
true);
19274 FD->
addAttr(UnavailableAttr::CreateImplicit(
19275 Context,
"", UnavailableAttr::IR_ARCFieldWithOwnership,
19279 !
Record->hasObjectMember()) {
19282 Record->setHasObjectMember(
true);
19287 Record->setHasObjectMember(
true);
19290 Record->setHasObjectMember(
true);
19295 !shouldIgnoreForRecordTriviality(FD)) {
19298 Record->setNonTrivialToPrimitiveDefaultInitialize(
true);
19301 Record->setHasNonTrivialToPrimitiveDefaultInitializeCUnion(
true);
19305 Record->setNonTrivialToPrimitiveCopy(
true);
19307 Record->setHasNonTrivialToPrimitiveCopyCUnion(
true);
19310 Record->setNonTrivialToPrimitiveDestroy(
true);
19311 Record->setParamDestroyedInCallee(
true);
19313 Record->setHasNonTrivialToPrimitiveDestructCUnion(
true);
19317 if (RT->getDecl()->getArgPassingRestrictions() ==
19319 Record->setArgPassingRestrictions(
19322 Record->setArgPassingRestrictions(
19327 Record->setHasVolatileMember(
true);
19335 bool Completed =
false;
19339 Parent->isTemplateParamScope())
19340 Record->setInvalidDecl();
19344 if (!CXXRecord->isInvalidDecl()) {
19347 I = CXXRecord->conversion_begin(),
19348 E = CXXRecord->conversion_end(); I != E; ++I)
19349 I.setAccess((*I)->getAccess());
19355 if (!CXXRecord->isDependentType()) {
19356 if (!CXXRecord->isInvalidDecl()) {
19360 if (CXXRecord->getNumVBases()) {
19362 CXXRecord->getFinalOverriders(FinalOverriders);
19364 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
19365 MEnd = FinalOverriders.end();
19368 SOEnd = M->second.end();
19369 SO != SOEnd; ++SO) {
19370 assert(SO->second.size() > 0 &&
19371 "Virtual function without overriding functions?");
19372 if (SO->second.size() == 1)
19379 Diag(
Record->getLocation(), diag::err_multiple_final_overriders)
19381 Diag(M->first->getLocation(),
19382 diag::note_overridden_virtual_function);
19384 OM = SO->second.begin(),
19385 OMEnd = SO->second.end();
19387 Diag(OM->Method->getLocation(), diag::note_final_overrider)
19388 << (
const NamedDecl *)M->first << OM->Method->getParent();
19390 Record->setInvalidDecl();
19393 CXXRecord->completeDefinition(&FinalOverriders);
19403 Record->completeDefinition();
19409 auto IsFunctionPointerOrForwardDecl = [&](
const Decl *D) {
19410 const FieldDecl *FD = dyn_cast<FieldDecl>(D);
19423 if (
const auto *TD = dyn_cast<TagDecl>(D))
19424 return !TD->isCompleteDefinition();
19428 if (isa<PointerType>(FieldType)) {
19438 (
Record->hasAttr<RandomizeLayoutAttr>() ||
19439 (!
Record->hasAttr<NoRandomizeLayoutAttr>() &&
19440 llvm::all_of(
Record->decls(), IsFunctionPointerOrForwardDecl))) &&
19442 !
Record->isRandomized()) {
19446 Record->reorderDecls(NewDeclOrdering);
19451 auto *Dtor = CXXRecord->getDestructor();
19452 if (Dtor && Dtor->isImplicit() &&
19454 CXXRecord->setImplicitDestructorIsDeleted();
19459 if (
Record->hasAttrs()) {
19462 if (
const MSInheritanceAttr *IA =
Record->getAttr<MSInheritanceAttr>())
19464 IA->getRange(), IA->getBestCase(),
19465 IA->getInheritanceModel());
19471 bool CheckForZeroSize;
19473 CheckForZeroSize =
true;
19478 CXXRecord->getLexicalDeclContext()->isExternCContext() &&
19480 CXXRecord->isCLike();
19482 if (CheckForZeroSize) {
19483 bool ZeroSize =
true;
19484 bool IsEmpty =
true;
19485 unsigned NonBitFields = 0;
19487 E =
Record->field_end();
19488 (NonBitFields == 0 || ZeroSize) && I != E; ++I) {
19490 if (I->isUnnamedBitField()) {
19491 if (!I->isZeroLengthBitField(
Context))
19495 QualType FieldType = I->getType();
19507 diag::warn_zero_size_struct_union_in_extern_c :
19508 diag::warn_zero_size_struct_union_compat)
19509 << IsEmpty <<
Record->isUnion() << (NonBitFields > 1);
19514 if (NonBitFields == 0 && !
getLangOpts().CPlusPlus) {
19515 Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
19516 diag::ext_no_named_members_in_struct_union)
19524 ID->setEndOfDefinitionLoc(RBrac);
19526 for (
unsigned i = 0, e = RecFields.size(); i != e; ++i) {
19528 ID->addDecl(ClsFields[i]);
19532 if (ID->getSuperClass())
19535 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
19536 assert(IMPDecl &&
"ActOnFields - missing ObjCImplementationDecl");
19537 for (
unsigned I = 0, N = RecFields.size(); I != N; ++I)
19543 IMPDecl->setIvarLBraceLoc(LBrac);
19544 IMPDecl->setIvarRBraceLoc(RBrac);
19546 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
19554 for (
unsigned i = 0, e = RecFields.size(); i != e; ++i) {
19558 Diag(ClsFields[i]->getLocation(),
19559 diag::err_duplicate_ivar_declaration);
19560 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
19566 Diag(ClsFields[i]->getLocation(),
19567 diag::err_duplicate_ivar_declaration);
19568 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
19574 CDecl->addDecl(ClsFields[i]);
19576 CDecl->setIvarLBraceLoc(LBrac);
19577 CDecl->setIvarRBraceLoc(RBrac);
19586 llvm::APSInt &
Value,
19589 "Integral type required!");
19592 if (
Value.isUnsigned() ||
Value.isNonNegative()) {
19595 return Value.getActiveBits() <= BitWidth;
19597 return Value.getSignificantBits() <= BitWidth;
19607 const unsigned NumTypes = 4;
19608 QualType SignedIntegralTypes[NumTypes] = {
19611 QualType UnsignedIntegralTypes[NumTypes] = {
19618 : UnsignedIntegralTypes;
19619 for (
unsigned I = 0; I != NumTypes; ++I)
19632 llvm::APSInt EnumVal(IntWidth);
19652 EltTy =
Enum->getIntegerType();
19659 Val = Converted.
get();
19666 if (
Enum->isComplete()) {
19667 EltTy =
Enum->getIntegerType();
19676 .isWindowsMSVCEnvironment()) {
19677 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
19679 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
19703 Diag(IdLoc, diag::ext_enum_value_not_int)
19705 << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
19717 if (
Enum->isDependentType())
19719 else if (!LastEnumConst) {
19728 if (
Enum->isFixed()) {
19729 EltTy =
Enum->getIntegerType();
19738 EltTy = LastEnumConst->
getType();
19741 if (EnumVal < LastEnumConst->getInitVal()) {
19753 if (
T.isNull() ||
Enum->isFixed()) {
19757 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
19759 if (
Enum->isFixed())
19761 Diag(IdLoc, diag::err_enumerator_wrapped)
19765 Diag(IdLoc, diag::ext_enumerator_increment_too_large)
19785 Diag(IdLoc, diag::warn_enum_value_overflow);
19790 Diag(IdLoc, diag::ext_enum_value_not_int)
19818 auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl);
19822 EnumDecl *PrevED = cast<EnumDecl>(PrevECD->getDeclContext());
19837 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
19839 cast_or_null<EnumConstantDecl>(lastEnumConst);
19848 RedeclarationKind::ForVisibleRedeclaration);
19856 PrevDecl =
nullptr;
19874 if (!TheEnumDecl->
isScoped() && isa<ValueDecl>(PrevDecl)) {
19882 "Received TagDecl when not in C++!");
19884 if (isa<EnumConstantDecl>(PrevDecl))
19885 Diag(IdLoc, diag::err_redefinition_of_enumerator) <<
Id;
19887 Diag(IdLoc, diag::err_redefinition) <<
Id;
19920 if (!BO->isAdditiveOp())
19928 InitExpr = BO->getLHS();
19932 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
19952 if (!
Enum->getIdentifier())
19956 if (
Enum->getNumPositiveBits() > 63 ||
Enum->getNumNegativeBits() > 64)
19965 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
19968 typedef std::unordered_map<int64_t, DeclOrVector> ValueToVectorMap;
19972 llvm::APSInt Val = D->getInitVal();
19973 return Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue();
19976 DuplicatesVector DupVector;
19977 ValueToVectorMap EnumMap;
19981 for (
auto *Element : Elements) {
19995 EnumMap.insert({EnumConstantToKey(ECD), ECD});
19998 if (EnumMap.size() == 0)
20002 for (
auto *Element : Elements) {
20008 auto Iter = EnumMap.find(EnumConstantToKey(ECD));
20009 if (
Iter == EnumMap.end())
20012 DeclOrVector& Entry =
Iter->second;
20019 auto Vec = std::make_unique<ECDVector>();
20021 Vec->push_back(ECD);
20028 DupVector.emplace_back(std::move(Vec));
20032 ECDVector *Vec = Entry.get<ECDVector*>();
20034 if (*Vec->begin() == ECD)
20037 Vec->push_back(ECD);
20041 for (
const auto &Vec : DupVector) {
20042 assert(Vec->size() > 1 &&
"ECDVector should have at least 2 elements.");
20045 auto *FirstECD = Vec->front();
20046 S.
Diag(FirstECD->getLocation(), diag::warn_duplicate_enum_values)
20047 << FirstECD <<
toString(FirstECD->getInitVal(), 10)
20048 << FirstECD->getSourceRange();
20052 for (
auto *ECD : llvm::drop_begin(*Vec))
20053 S.
Diag(ECD->getLocation(), diag::note_duplicate_element)
20054 << ECD <<
toString(ECD->getInitVal(), 10)
20055 << ECD->getSourceRange();
20060 bool AllowMask)
const {
20061 assert(ED->
isClosedFlag() &&
"looking for value in non-flag or open enum");
20064 auto R =
FlagBitsCache.insert(std::make_pair(ED, llvm::APInt()));
20065 llvm::APInt &FlagBits = R.first->second;
20069 const auto &EVal = E->getInitVal();
20071 if (EVal.isPowerOf2())
20072 FlagBits = FlagBits.zext(EVal.getBitWidth()) | EVal;
20084 llvm::APInt FlagMask = ~FlagBits.zextOrTrunc(Val.getBitWidth());
20085 return !(FlagMask & Val) || (AllowMask && !(FlagMask & ~Val));
20097 if (
Enum->isDependentType()) {
20098 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
20100 cast_or_null<EnumConstantDecl>(Elements[i]);
20101 if (!ECD)
continue;
20119 unsigned NumNegativeBits = 0;
20120 unsigned NumPositiveBits = 0;
20122 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
20124 cast_or_null<EnumConstantDecl>(Elements[i]);
20125 if (!ECD)
continue;
20127 const llvm::APSInt &InitVal = ECD->
getInitVal();
20130 if (InitVal.isUnsigned() || InitVal.isNonNegative()) {
20133 unsigned ActiveBits = InitVal.getActiveBits();
20134 NumPositiveBits = std::max({NumPositiveBits, ActiveBits, 1u});
20137 std::max(NumNegativeBits, (
unsigned)InitVal.getSignificantBits());
20145 if (!NumPositiveBits && !NumNegativeBits)
20146 NumPositiveBits = 1;
20150 unsigned BestWidth;
20163 bool Packed =
Enum->hasAttr<PackedAttr>();
20171 if (
Enum->isComplete()) {
20172 BestType =
Enum->getIntegerType();
20176 BestPromotionType = BestType;
20180 else if (NumNegativeBits) {
20184 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
20186 BestWidth = CharWidth;
20187 }
else if (Packed && NumNegativeBits <= ShortWidth &&
20188 NumPositiveBits < ShortWidth) {
20190 BestWidth = ShortWidth;
20191 }
else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
20193 BestWidth = IntWidth;
20197 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
20202 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
20203 Diag(
Enum->getLocation(), diag::ext_enum_too_large);
20207 BestPromotionType = (BestWidth <= IntWidth ?
Context.
IntTy : BestType);
20212 if (Packed && NumPositiveBits <= CharWidth) {
20215 BestWidth = CharWidth;
20216 }
else if (Packed && NumPositiveBits <= ShortWidth) {
20219 BestWidth = ShortWidth;
20220 }
else if (NumPositiveBits <= IntWidth) {
20222 BestWidth = IntWidth;
20224 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
20226 }
else if (NumPositiveBits <=
20230 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
20234 if (NumPositiveBits > BestWidth) {
20239 Diag(
Enum->getLocation(), diag::ext_enum_too_large);
20243 = (NumPositiveBits == BestWidth || !
getLangOpts().CPlusPlus)
20250 for (
auto *D : Elements) {
20251 auto *ECD = cast_or_null<EnumConstantDecl>(D);
20252 if (!ECD)
continue;
20261 llvm::APSInt InitVal = ECD->getInitVal();
20269 !
Enum->isFixed() &&
20272 NewWidth = IntWidth;
20274 }
else if (ECD->getType() == BestType) {
20284 NewWidth = BestWidth;
20289 InitVal = InitVal.extOrTrunc(NewWidth);
20290 InitVal.setIsSigned(NewSign);
20291 ECD->setInitVal(
Context, InitVal);
20294 if (ECD->getInitExpr() &&
20297 Context, NewTy, CK_IntegralCast, ECD->getInitExpr(),
20305 ECD->setType(NewTy);
20308 Enum->completeDefinition(BestType, BestPromotionType,
20309 NumPositiveBits, NumNegativeBits);
20313 if (
Enum->isClosedFlag()) {
20314 for (
Decl *D : Elements) {
20316 if (!ECD)
continue;
20319 if (InitVal != 0 && !InitVal.isPowerOf2() &&
20327 if (
Enum->hasAttrs())
20337 AsmString, StartLoc,
20368 AsmLabelAttr *
Attr = AsmLabelAttr::CreateImplicit(
20375 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
20379 Diag(PrevDecl->
getLocation(), diag::warn_redefine_extname_not_applied)
20380 << (isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl;
20392 PrevDecl->
addAttr(WeakAttr::CreateImplicit(
Context, PragmaLoc));
20407 if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
20408 if (!PrevDecl->
hasAttr<AliasAttr>())
20409 if (
NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
20418 assert(FD &&
"Expected non-null FunctionDecl");
20430 auto IsEmittedForExternalSymbol = [
this, FD]() {
20440 if (
LangOpts.OpenMPIsTargetDevice) {
20443 std::optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
20450 if (*DevTy == OMPDeclareTargetDeclAttr::DT_Host)
20454 if (
OpenMP().isInOpenMPDeclareTargetContext() || DevTy)
20455 if (IsEmittedForExternalSymbol())
20461 }
else if (
LangOpts.OpenMP > 45) {
20465 std::optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
20468 if (*DevTy == OMPDeclareTargetDeclAttr::DT_NoHost)
20487 if (IsEmittedForExternalSymbol())
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
static constexpr Builtin::Info BuiltinInfo[]
Defines enum values for all the target-independent builtin functions.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
static bool isDeclExternC(const T &D)
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines helper utilities for supporting the HLSL runtime environment.
static const Decl * getCanonicalDecl(const Decl *D)
static const GlobalDecl isTemplate(GlobalDecl GD, const TemplateArgumentList *&TemplateArgs)
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Architecture Architecture
llvm::MachO::Record Record
static bool isExternC(const NamedDecl *ND)
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis for CUDA constructs.
static void diagnoseImplicitlyRetainedSelf(Sema &S)
static void SetNestedNameSpecifier(Sema &S, DeclaratorDecl *DD, Declarator &D)
static UnqualifiedTypeNameLookupResult lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc, const CXXRecordDecl *RD)
Tries to perform unqualified lookup of the type decls in bases for dependent class.
static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, const FunctionDecl *&PossiblePrototype)
static bool PreviousDeclsHaveMultiVersionAttribute(const FunctionDecl *FD)
static ParsedType recoverFromTypeInKnownDependentBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc)
static void mergeParamDeclTypes(ParmVarDecl *NewParam, const ParmVarDecl *OldParam, Sema &S)
static void adjustDeclContextForDeclaratorDecl(DeclaratorDecl *NewD, DeclaratorDecl *OldD)
If necessary, adjust the semantic declaration context for a qualified declaration to name the correct...
static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken)
Determine whether the given result set contains either a type name or.
static void FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL)
static bool AllowOverloadingOfFunction(const LookupResult &Previous, ASTContext &Context, const FunctionDecl *New)
Determine whether overloading is allowed for a new function declaration considering prior declaration...
static TypeSourceInfo * TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized)
Helper method to turn variable array types into constant array types in certain situations which woul...
static StringRef getHeaderName(Builtin::Context &BuiltinInfo, unsigned ID, ASTContext::GetBuiltinTypeError Error)
static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D)
static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS, ExpectedDecl *New)
Check whether a redeclaration of an entity introduced by a using-declaration is valid,...
static bool mergeDeclAttribute(Sema &S, NamedDecl *D, const InheritableAttr *Attr, Sema::AvailabilityMergeKind AMK)
static ShadowedDeclKind computeShadowedDeclKind(const NamedDecl *ShadowedDecl, const DeclContext *OldDC)
Determine what kind of declaration we're shadowing.
static void checkIsValidOpenCLKernelParameter(Sema &S, Declarator &D, ParmVarDecl *Param, llvm::SmallPtrSetImpl< const Type * > &ValidTypes)
static void mergeParamDeclAttributes(ParmVarDecl *newDecl, const ParmVarDecl *oldDecl, Sema &S)
mergeParamDeclAttributes - Copy attributes from the old parameter to the new one.
void emitReadOnlyPlacementAttrWarning(Sema &S, const VarDecl *VD)
static bool CheckC23ConstexprVarType(Sema &SemaRef, SourceLocation VarLoc, QualType T)
static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous)
Check the validity of a mulitversion function declaration.
static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old)
Merge alignment attributes from Old to New, taking into account the special semantics of C11's _Align...
static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, LookupResult &Previous)
static void CheckConstPureAttributesUsage(Sema &S, FunctionDecl *NewFD)
static bool FindPossiblePrototype(const FunctionDecl *FD, const FunctionDecl *&PossiblePrototype)
static bool MultiVersionTypesCompatible(FunctionDecl *Old, FunctionDecl *New)
static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, FixItHint &Hint)
static void CheckExplicitObjectParameter(Sema &S, ParmVarDecl *P, SourceLocation ExplicitThisLoc)
static NestedNameSpecifier * synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC)
static void patchDefaultTargetVersion(FunctionDecl *From, FunctionDecl *To)
static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD)
Given that we are within the definition of the given function, will that definition behave like C99's...
static bool isRepresentableIntegerValue(ASTContext &Context, llvm::APSInt &Value, QualType T)
Determine whether the given integral value is representable within the given type T.
static void CheckForDuplicateEnumValues(Sema &S, ArrayRef< Decl * > Elements, EnumDecl *Enum, QualType EnumType)
static unsigned GetDiagnosticTypeSpecifierID(const DeclSpec &DS)
static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old)
checkNewAttributesAfterDef - If we already have a definition, check that there are no new attributes ...
static bool isClassCompatTagKind(TagTypeKind Tag)
Determine if tag kind is a class-key compatible with class for redeclaration (class,...
static bool hasIdenticalPassObjectSizeAttrs(const FunctionDecl *A, const FunctionDecl *B)
static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND)
static bool hasSimilarParameters(ASTContext &Context, FunctionDecl *Declaration, FunctionDecl *Definition, SmallVectorImpl< unsigned > &Params)
hasSimilarParameters - Determine whether the C++ functions Declaration and Definition have "nearly" m...
static NonCLikeKind getNonCLikeKindForAnonymousStruct(const CXXRecordDecl *RD)
Determine whether a class is C-like, according to the rules of C++ [dcl.typedef] for anonymous classe...
static FunctionDecl * CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, DeclContext *DC, QualType &R, TypeSourceInfo *TInfo, StorageClass SC, bool &IsVirtualOkay)
static Scope * getTagInjectionScope(Scope *S, const LangOptions &LangOpts)
Find the Scope in which a tag is implicitly declared if we see an elaborated type specifier in the sp...
static bool methodHasName(const FunctionDecl *FD, StringRef Name)
static std::pair< diag::kind, SourceLocation > getNoteDiagForInvalidRedeclaration(const T *Old, const T *New)
static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, LookupResult &Previous)
Apply special rules for handling extern "C" declarations.
static bool DeclHasAttr(const Decl *D, const Attr *A)
DeclhasAttr - returns true if decl Declaration already has the target attribute.
static bool isOpenCLSizeDependentType(ASTContext &C, QualType Ty)
static void diagnoseMissingConstinit(Sema &S, const VarDecl *InitDecl, const ConstInitAttr *CIAttr, bool AttrBeforeInit)
static bool shouldWarnIfShadowedDecl(const DiagnosticsEngine &Diags, const LookupResult &R)
static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S, SourceLocation NameLoc)
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
static bool CheckAnonMemberRedeclaration(Sema &SemaRef, Scope *S, DeclContext *Owner, DeclarationName Name, SourceLocation NameLoc, bool IsUnion, StorageClass SC)
We are trying to inject an anonymous member into the given scope; check if there's an existing declar...
static bool checkGlobalOrExternCConflict(Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous)
Check for conflict between this global or extern "C" declaration and previous global or extern "C" de...
static bool ShouldDiagnoseUnusedDecl(const LangOptions &LangOpts, const NamedDecl *D)
static bool isStdBuiltin(ASTContext &Ctx, FunctionDecl *FD, unsigned BuiltinID)
Determine whether a declaration matches a known function in namespace std.
static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, DeclContext *Owner, RecordDecl *AnonRecord, AccessSpecifier AS, StorageClass SC, SmallVectorImpl< NamedDecl * > &Chaining)
InjectAnonymousStructOrUnionMembers - Inject the members of the anonymous struct or union AnonRecord ...
@ InvalidAddrSpacePtrKernelParam
static bool isFromSystemHeader(SourceManager &SM, const Decl *D)
Returns true if the declaration is declared in a system header or from a system macro.
static bool AreSpecialMemberFunctionsSameKind(ASTContext &Context, CXXMethodDecl *M1, CXXMethodDecl *M2, CXXSpecialMemberKind CSM)
[class.mem.special]p5 Two special member functions are of the same kind if:
static const CXXRecordDecl * findRecordWithDependentBasesOfEnclosingMethod(const DeclContext *DC)
Find the parent class with dependent bases of the innermost enclosing method context.
static void ComputeSelectedDestructor(Sema &S, CXXRecordDecl *Record)
[class.dtor]p4: At the end of the definition of a class, overload resolution is performed among the p...
static bool shouldConsiderLinkage(const VarDecl *VD)
static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record)
static bool CheckMultiVersionAdditionalRules(Sema &S, const FunctionDecl *OldFD, const FunctionDecl *NewFD, bool CausesMV, MultiVersionKind MVKind)
static DeclContext * getTagInjectionContext(DeclContext *DC)
Find the DeclContext in which a tag is implicitly declared if we see an elaborated type specifier in ...
static bool EquivalentArrayTypes(QualType Old, QualType New, const ASTContext &Ctx)
static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New)
static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for redeclaration diagnostic message.
static void CheckPoppedLabel(LabelDecl *L, Sema &S, Sema::DiagReceiverTy DiagReceiver)
static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl *Old)
static NamedDecl * DiagnoseInvalidRedeclaration(Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S)
Generate diagnostics for an invalid function redeclaration.
static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, DeclarationName Name)
RebuildDeclaratorInCurrentInstantiation - Checks whether the given declarator needs to be rebuilt in ...
static void SetEligibleMethods(Sema &S, CXXRecordDecl *Record, ArrayRef< CXXMethodDecl * > Methods, CXXSpecialMemberKind CSM)
[class.mem.special]p6: An eligible special member function is a special member function for which:
static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc)
static bool hasParsedAttr(Scope *S, const Declarator &PD, ParsedAttr::Kind Kind)
ShadowedDeclKind
Enum describing the select options in diag::warn_decl_shadow.
static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S)
static bool canRedefineFunction(const FunctionDecl *FD, const LangOptions &LangOpts)
canRedefineFunction - checks if a function can be redefined.
static OpenCLParamType getOpenCLKernelParameterType(Sema &S, QualType PT)
static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, SourceLocation DefaultInitLoc)
static bool isDefaultStdCall(FunctionDecl *FD, Sema &S)
static bool diagnoseOpenCLTypes(Sema &Se, VarDecl *NewVD)
Returns true if there hasn't been any invalid type diagnosed.
static void RemoveUsingDecls(LookupResult &R)
Removes using shadow declarations not at class scope from the lookup results.
static void ComputeSpecialMemberFunctionsEligiblity(Sema &S, CXXRecordDecl *Record)
static bool AttrCompatibleWithMultiVersion(attr::Kind Kind, MultiVersionKind MVKind)
static bool isUsingDeclNotAtClassScope(NamedDecl *D)
static const NamedDecl * getDefinition(const Decl *D)
static QualType TryToFixInvalidVariablyModifiedType(QualType T, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized)
Helper method to turn variable array types into constant array types in certain situations which woul...
static bool hasDeducedAuto(DeclaratorDecl *DD)
static void copyAttrFromTypedefToDecl(Sema &S, Decl *D, const TypedefType *TT)
static QualType getCoreType(QualType Ty)
static bool CheckTargetCausesMultiVersioning(Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous)
static bool isMainFileLoc(const Sema &S, SourceLocation Loc)
static bool CheckMultiVersionValue(Sema &S, const FunctionDecl *FD)
Check the target or target_version attribute of the function for MultiVersion validity.
static bool isOutOfScopePreviousDeclaration(NamedDecl *, DeclContext *, ASTContext &)
Determines whether the given declaration is an out-of-scope previous declaration.
static StorageClass StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS)
StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to a VarDecl::StorageClass.
static ParsedType buildNamedType(Sema &S, const CXXScopeSpec *SS, QualType T, SourceLocation NameLoc, bool WantNontrivialTypeSourceInfo=true)
Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
static bool CheckMultiVersionAdditionalDecl(Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, const CPUDispatchAttr *NewCPUDisp, const CPUSpecificAttr *NewCPUSpec, const TargetClonesAttr *NewClones, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous)
Check the validity of a new function declaration being added to an existing multiversioned declaratio...
static SourceLocation getCaptureLocation(const LambdaScopeInfo *LSI, const VarDecl *VD)
Return the location of the capture if the given lambda captures the given variable VD,...
static bool CheckMultiVersionFirstFunction(Sema &S, FunctionDecl *FD)
Check the validity of a multiversion function declaration that is the first of its kind.
static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, NamedDecl *NewDecl, bool IsSpecialization, bool IsDefinition)
static bool checkNonMultiVersionCompatAttributes(Sema &S, const FunctionDecl *FD, const FunctionDecl *CausedFD, MultiVersionKind MVKind)
static void filterNonConflictingPreviousTypedefDecls(Sema &S, const TypedefNameDecl *Decl, LookupResult &Previous)
Typedef declarations don't have linkage, but they still denote the same entity if their types are the...
static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum)
static QualType getNextLargerIntegralType(ASTContext &Context, QualType T)
static bool isIncompleteDeclExternC(Sema &S, const T *D)
Determine whether a variable is extern "C" prior to attaching an initializer.
static bool isAttributeTargetADefinition(Decl *D)
static Attr * getImplicitCodeSegAttrFromClass(Sema &S, const FunctionDecl *FD)
Return a CodeSegAttr from a containing class.
static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D)
Check for this common pattern:
static bool isAcceptableTagRedeclContext(Sema &S, DeclContext *OldDC, DeclContext *NewDC)
Determine whether a tag originally declared in context OldDC can be redeclared with an unqualified na...
static bool isRecordType(QualType T)
This file declares semantic analysis for HLSL constructs.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
static CharSourceRange getRange(const CharSourceRange &EditRange, const SourceManager &SM, const LangOptions &LangOpts, bool IncludeMacroExpansion)
Defines the SourceManager interface.
C Language Family Type Representation.
const NestedNameSpecifier * Specifier
RAII object that pops an ExpressionEvaluationContext when exiting a function body.
ExitFunctionBodyRAII(Sema &S, bool IsLambda)
llvm::APInt getValue() const
virtual void HandleTagDeclDefinition(TagDecl *D)
HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.
virtual void HandleInlineFunctionDefinition(FunctionDecl *D)
This callback is invoked each time an inline (method or friend) function definition in a class is com...
virtual bool shouldSkipFunctionBody(Decl *D)
This callback is called for each function if the Parser was initialized with SkipFunctionBodies set t...
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
QualType getUsingType(const UsingShadowDecl *Found, QualType Underlying) const
SourceManager & getSourceManager()
TranslationUnitDecl * getTranslationUnitDecl() const
const ConstantArrayType * getAsConstantArrayType(QualType T) const
QualType getParenType(QualType NamedType) const
unsigned getIntWidth(QualType T) const
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
ExternCContextDecl * getExternCContextDecl() const
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
DeclarationNameTable DeclarationNames
QualType getObjCClassType() const
Represents the Objective-C Class type.
QualType getRecordType(const RecordDecl *Decl) const
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
void setObjCIdRedefinitionType(QualType RedefType)
Set the user-written type that redefines id.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
void setObjCSelRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U) const
Determine whether two function types are the same, ignoring exception specifications in cases where t...
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Builtin::Context & BuiltinInfo
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
void addModuleInitializer(Module *M, Decl *Init)
Add a declaration to the list of declarations that are initialized for a module.
const LangOptions & getLangOpts() const
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
void attachCommentsToJustParsedDecls(ArrayRef< Decl * > Decls, const Preprocessor *PP)
Searches existing comments for doc comments that should be attached to Decls.
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
void setucontext_tDecl(TypeDecl *ucontext_tDecl)
Set the type for the C ucontext_t type.
CanQualType UnsignedLongTy
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
MangleNumberingContext & getManglingNumberContext(const DeclContext *DC)
Retrieve the context for computing mangling numbers in the given DeclContext.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
void setNonKeyFunction(const CXXMethodDecl *method)
Observe that the given method cannot be a key function.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
const clang::PrintingPolicy & getPrintingPolicy() const
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false, bool IsConditionalOperator=false)
QualType getObjCIdType() const
Represents the Objective-CC id type.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
void setManglingNumber(const NamedDecl *ND, unsigned Number)
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
CanQualType UnsignedLongLongTy
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
CanQualType UnsignedShortTy
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
void setcudaConfigureCallDecl(FunctionDecl *FD)
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
const VariableArrayType * getAsVariableArrayType(QualType T) const
void setObjCClassRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
void ResetObjCLayout(const ObjCContainerDecl *CD)
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
const TargetInfo & getTargetInfo() const
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
void setjmp_bufDecl(TypeDecl *jmp_bufDecl)
Set the type for the C jmp_buf type.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
QualType mergeObjCGCQualifiers(QualType, QualType)
mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 'RHS' attributes and ret...
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
LangAS getLangASForBuiltinAddressSpace(unsigned AS) const
bool hasSameFunctionTypeIgnoringPtrSizes(QualType T, QualType U)
Determine whether two function types are the same, ignoring pointer sizes in the return type and para...
TemplateName getAssumedTemplateName(DeclarationName Name) const
Retrieve a template name representing an unqualified-id that has been assumed to name a template for ...
@ GE_Missing_stdio
Missing a type from <stdio.h>
@ GE_Missing_type
Missing a type.
@ GE_Missing_ucontext
Missing a type from <ucontext.h>
@ GE_Missing_setjmp
Missing a type from <setjmp.h>
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
The result of parsing/analyzing an expression, statement etc.
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
Wrapper for source info for arrays.
SourceLocation getLBracketLoc() const
Expr * getSizeExpr() const
TypeLoc getElementLoc() const
SourceLocation getRBracketLoc() const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
Attr - This represents one attribute.
attr::Kind getKind() const
Attr * clone(ASTContext &C) const
SourceLocation getLocation() const
@ AS_Declspec
__declspec(...)
SourceRange getRange() const
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
AttributeFactory & getFactory() const
Type source information for an attributed type.
TypeLoc getModifiedLoc() const
The modified type, which is generally canonically different from the attribute type.
An attributed type is a type to which a type attribute has been applied.
QualType getModifiedType() const
bool isCallingConv() const
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
SourceLocation getConceptNameLoc() const
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
AutoTypeKeyword getKeyword() const
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
Expr * getCond() const
getCond - Return the condition expression; this is defined in terms of the opaque value.
A builtin binary operation expression such as "x + y" or "x <= y".
static bool isCompoundAssignmentOp(Opcode Opc)
A binding in a decomposition declaration.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
bool doesNotEscape() const
This class is used for builtin types like 'int'.
Holds information about both target-independent and target-specific builtins, allowing easy queries b...
bool performsCallback(unsigned ID, llvm::SmallVectorImpl< int > &Encoding) const
Determine whether this builtin has callback behavior (see llvm::AbstractCallSites for details).
bool isAuxBuiltinID(unsigned ID) const
Return true if builtin ID belongs to AuxTarget.
const char * getHeaderName(unsigned ID) const
If this is a library function that comes from a specific header, retrieve that header name.
llvm::StringRef getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
bool isReturnsTwice(unsigned ID) const
Return true if we know this builtin can return twice.
bool isConstWithoutErrnoAndExceptions(unsigned ID) const
Return true if this function has no side effects and doesn't read memory, except for possibly errno o...
bool allowTypeMismatch(unsigned ID) const
Determines whether a declaration of this builtin should be recognized even if the type doesn't match ...
bool isTSBuiltin(unsigned ID) const
Return true if this function is a target-specific builtin.
bool isHeaderDependentFunction(unsigned ID) const
Returns true if this builtin requires appropriate header in other compilers.
bool isScanfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg)
Determine whether this builtin is like scanf in its formatting rules and, if so, set the index to the...
bool isInStdNamespace(unsigned ID) const
Determines whether this builtin is a C++ standard library function that lives in (possibly-versioned)...
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc",...
bool isPrintfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg)
Determine whether this builtin is like printf in its formatting rules and, if so, set the index to th...
bool isConstWithoutExceptions(unsigned ID) const
bool isPredefinedRuntimeFunction(unsigned ID) const
Determines whether this builtin is a predefined compiler-rt/libgcc function, such as "__clear_cache",...
bool isPure(unsigned ID) const
Return true if this function has no side effects.
bool isNoThrow(unsigned ID) const
Return true if we know this builtin never throws an exception.
bool isConst(unsigned ID) const
Return true if this function has no side effects and doesn't read memory.
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
Represents a base class of a C++ class.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getEndLoc() const LLVM_READONLY
Represents a call to a C++ constructor.
Expr * getArg(unsigned Arg)
Return the specified argument.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Represents a C++ constructor within a class.
bool isCopyConstructor(unsigned &TypeQuals) const
Whether this constructor is a copy constructor (C++ [class.copy]p2, which can be used to copy the cla...
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor(), Expr *TrailingRequiresClause=nullptr)
Represents a C++ conversion function within a class.
static CXXConversionDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation, CXXConstructorDecl *Ctor=nullptr, DeductionCandidate Kind=DeductionCandidate::Normal)
Represents a C++ destructor within a class.
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
A mapping from each virtual member function to its set of final overriders.
Represents a static or instance method of a struct/union/class.
bool isExplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An explicit object member function is a non-static member function with an explic...
void addOverriddenMethod(const CXXMethodDecl *MD)
QualType getFunctionObjectParameterReferenceType() const
Return the type of the object pointed by this.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Qualifiers getMethodQualifiers() const
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
A call to an overloaded operator written using operator syntax.
Represents a C++ struct/union/class.
bool hasNonTrivialCopyAssignment() const
Determine whether this class has a non-trivial copy assignment operator (C++ [class....
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
base_class_iterator bases_end()
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
bool hasNonTrivialDestructor() const
Determine whether this class has a non-trivial destructor (C++ [class.dtor]p3)
CXXRecordDecl * getDefinition() const
unsigned getNumBases() const
Retrieves the number of base classes of this class.
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths, bool LookupInDependent=false) const
Look for entities within the base classes of this C++ class, transitively searching all base class su...
base_class_iterator bases_begin()
capture_const_range captures() const
bool hasDefinition() const
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
LambdaCaptureDefault getLambdaCaptureDefault() const
void setDescribedClassTemplate(ClassTemplateDecl *Template)
bool hasNonTrivialCopyConstructor() const
Determine whether this class has a non-trivial copy constructor (C++ [class.copy]p6,...
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Represents a C++ nested-name-specifier or a global scope specifier.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
char * location_data() const
Retrieve the data associated with the source-location information.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
SourceRange getRange() const
SourceLocation getBeginLoc() const
bool isSet() const
Deprecated.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
bool isEmpty() const
No scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
bool isCallToStdMove() const
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
CastKind getCastKind() const
static CharSourceRange getCharRange(SourceRange R)
CharUnits - This is an opaque type for sizes expressed in character units.
bool isZero() const
isZero - Test whether the quantity equals zero.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Declaration of a class template.
bool exprNeedsCleanups() const
ConditionalOperator - The ?: ternary operator.
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
llvm::APInt getSize() const
Return the constant array size as an APInt.
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isFileContext() const
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
bool isObjCContainer() const
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
const BlockDecl * getInnermostBlockDecl() const
Return this DeclContext if it is a BlockDecl.
bool isTranslationUnit() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void removeDecl(Decl *D)
Removes a declaration from this context.
void addDecl(Decl *D)
Add the declaration D into this context.
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Decl::Kind getDeclKind() const
DeclContext * getNonTransparentContext()
Simple template class for restricting typo correction candidates to ones having a single Decl* of the...
static DeclGroupRef Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
A reference to a declared variable, function, enum, etc.
SourceLocation getBeginLoc() const LLVM_READONLY
Captures information about "declaration specifiers".
bool isVirtualSpecified() const
bool isModulePrivateSpecified() const
static const TST TST_typeof_unqualType
bool hasAutoTypeSpec() const
static const TST TST_typename
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec and return false if there was no error.
void ClearStorageClassSpecs()
bool isNoreturnSpecified() const
TST getTypeSpecType() const
SourceLocation getStorageClassSpecLoc() const
SCS getStorageClassSpec() const
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
SourceLocation getBeginLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
void SetRangeEnd(SourceLocation Loc)
static const TST TST_interface
static const TST TST_typeofExpr
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
void SetRangeStart(SourceLocation Loc)
SourceLocation getNoreturnSpecLoc() const
bool isExternInLinkageSpec() const
static const TST TST_union
SCS
storage-class-specifier
SourceLocation getExplicitSpecLoc() const
SourceLocation getModulePrivateSpecLoc() const
bool isMissingDeclaratorOk()
Checks if this DeclSpec can stand alone, without a Declarator.
ParsedType getRepAsType() const
void UpdateTypeRep(ParsedType Rep)
TSCS getThreadStorageClassSpec() const
ParsedAttributes & getAttributes()
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
SourceLocation getConstSpecLoc() const
SourceRange getExplicitSpecRange() const
Expr * getRepAsExpr() const
static const TST TST_enum
static const TST TST_decltype
static bool isDeclRep(TST T)
bool isInlineSpecified() const
SourceLocation getRestrictSpecLoc() const
static const TST TST_typeof_unqualExpr
static const TST TST_class
void ClearConstexprSpec()
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
static const TST TST_atomic
SourceLocation getThreadStorageClassSpecLoc() const
Decl * getRepAsDecl() const
static const TST TST_unspecified
SourceLocation getAtomicSpecLoc() const
SourceLocation getVirtualSpecLoc() const
SourceLocation getConstexprSpecLoc() const
SourceLocation getTypeSpecTypeLoc() const
void UpdateExprRep(Expr *Rep)
static const TSCS TSCS_thread_local
static const TST TST_error
ExplicitSpecifier getExplicitSpecifier() const
bool isTypeSpecOwned() const
SourceLocation getInlineSpecLoc() const
SourceLocation getUnalignedSpecLoc() const
SourceLocation getVolatileSpecLoc() const
FriendSpecified isFriendSpecified() const
bool hasExplicitSpecifier() const
bool hasConstexprSpecifier() const
static const TST TST_typeofType
static const TST TST_auto
ConstexprSpecKind getConstexprSpecifier() const
static const TST TST_struct
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
const DeclContext * getParentFunctionOrMethod(bool LexicalParent=false) const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext,...
bool isInStdNamespace() const
SourceLocation getEndLoc() const LLVM_READONLY
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
void setAttrs(const AttrVec &Attrs)
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked 'unavailable'.
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it's a function-local extern declaration.
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Module * getOwningModuleForLinkage(bool IgnoreLinkage=false) const
Get the module that owns this declaration for linkage purposes.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
void setTopLevelDeclInObjCContainer(bool V=true)
bool isInIdentifierNamespace(unsigned NS) const
@ FOK_Undeclared
A friend of a previously-undeclared entity.
@ FOK_None
Not a friend object.
@ FOK_Declared
A friend of a previously-declared entity.
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
bool isInExportDeclContext() const
Whether this declaration was exported in a lexical context.
bool isReferenced() const
Whether any declaration of this entity was referenced.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
bool isFromExplicitGlobalModule() const
Whether this declaration comes from explicit global module.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
@ OBJC_TQ_CSNullability
The nullability qualifier is set when the nullability of the result or parameter was expressed via a ...
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it's the object of a friend declaration.
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
bool isInvalidDecl() const
bool isLocalExternDecl() const
Determine whether this is a block-scope declaration with linkage.
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
@ IDNS_Ordinary
Ordinary names.
void setLocalOwningModule(Module *M)
void setImplicit(bool I=true)
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool hasOwningModule() const
Is this declaration owned by some module?
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
void setLexicalDeclContext(DeclContext *DC)
The name of a declaration.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
@ CXXConversionFunctionName
bool isEmpty() const
Evaluates true when this declaration name is empty.
bool isIdentifier() const
Predicate functions for querying what type of name this is.
Represents a ValueDecl that came out of a declarator.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
SourceLocation getOuterLocStart() const
Return start of source range taking into account any outer template declarations.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getNumTemplateParameterLists() const
void setTypeSourceInfo(TypeSourceInfo *TI)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
TypeSourceInfo * getTypeSourceInfo() const
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Information about one declarator, including the parsed type information and the identifier.
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Expr * getAsmLabel() const
FunctionDefinitionKind getFunctionDefinitionKind() const
const ParsedAttributes & getAttributes() const
void setRedeclaration(bool Val)
SourceLocation getIdentifierLoc() const
void SetIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Set the name of this declarator to be the given identifier.
SourceLocation getEndLoc() const LLVM_READONLY
Expr * getTrailingRequiresClause()
Sets a trailing requires clause for this declarator.
void setInvalidType(bool Val=true)
TemplateParameterList * getInventedTemplateParameterList() const
The template parameter list generated from the explicit template parameters along with any invented t...
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
bool isRedeclaration() const
const ParsedAttributesView & getDeclarationAttributes() const
const DecompositionDeclarator & getDecompositionDeclarator() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isCtorOrDtor()
Returns true if this declares a constructor or a destructor.
bool isFunctionDefinition() const
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
bool hasInitializer() const
void setFunctionDefinitionKind(FunctionDefinitionKind Val)
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
void takeAttributes(ParsedAttributes &attrs)
takeAttributes - Takes attributes from the given parsed-attributes set and add them to this declarato...
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
bool isInvalidType() const
bool isExplicitObjectMemberFunction()
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
bool isDecompositionDeclarator() const
Return whether this declarator is a decomposition declarator.
bool isFirstDeclarationOfMember()
Returns true if this declares a real member and not a friend.
bool isStaticMember()
Returns true if this declares a static member.
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
const IdentifierInfo * getIdentifier() const
A decomposition declaration.
static DecompositionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation LSquareLoc, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< BindingDecl * > Bindings)
A parsed C++17 decomposition declarator of the form '[' identifier-list ']'.
SourceRange getSourceRange() const
SourceLocation getLSquareLoc() const
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it has not been deduced.
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Concrete class used by the front-end to report problems and issues.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
An instance of this object exists for each enum constant that is defined.
llvm::APSInt getInitVal() const
static EnumConstantDecl * Create(ASTContext &C, EnumDecl *DC, SourceLocation L, IdentifierInfo *Id, QualType T, Expr *E, const llvm::APSInt &V)
const Expr * getInitExpr() const
enumerator_range enumerators() const
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
void setIntegerType(QualType T)
Set the underlying integer type.
void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo)
Set the underlying integer type source info.
bool isComplete() const
Returns true if this can be considered a complete type.
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
bool isClosedFlag() const
Returns true if this enum is annotated with flag_enum and isn't annotated with enum_extensibility(ope...
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
SourceRange getIntegerTypeRange() const LLVM_READONLY
Retrieve the source range that covers the underlying type if specified.
void setPromotionType(QualType T)
Set the promotion type.
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EvaluatedExprVisitor - This class visits 'Expr *'s.
Store information needed for an explicit specifier.
This represents one expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant,...
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
Represents difference between two FPOptions values.
void setDisallowOptimizations()
void applyChanges(FPOptionsOverride FPO)
bool isFPConstrained() const
FPOptionsOverride getChangesFrom(const FPOptions &Base) const
Return difference with the given option set.
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
bool isZeroLengthBitField(const ASTContext &Ctx) const
Is this a zero-length bit-field? Such bit-fields aren't really bit-fields at all and instead act as a...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
static FileScopeAsmDecl * Create(ASTContext &C, DeclContext *DC, StringLiteral *Str, SourceLocation AsmLoc, SourceLocation RParenLoc)
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Represents a function declaration or definition.
bool isMultiVersion() const
True if this function is considered a multiversioned function.
const ParmVarDecl * getParamDecl(unsigned i) const
ConstexprSpecKind getConstexprKind() const
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
void setPreviousDeclaration(FunctionDecl *PrevDecl)
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
void setIsPureVirtual(bool P=true)
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
void setFriendConstraintRefersToEnclosingTemplate(bool V=true)
void setHasSkippedBody(bool Skipped=true)
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
param_iterator param_end()
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
void setIsMultiVersion(bool V=true)
Sets the multiversion state for this declaration and all of its redeclarations.
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
bool hasWrittenPrototype() const
Whether this function has a written prototype.
void setWillHaveBody(bool V=true)
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
param_iterator param_begin()
const ParmVarDecl * getNonObjectParameter(unsigned I) const
bool isVariadic() const
Whether this function is variadic.
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
bool isDeleted() const
Whether this function has been deleted.
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
@ TK_MemberSpecialization
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function.
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
bool isDeletedAsWritten() const
void setHasInheritedPrototype(bool P=true)
State that this function inherited its prototype from a previous declaration.
bool isPureVirtual() const
Whether this virtual function is pure, i.e.
bool isExternC() const
Determines whether this function is a function with external, C linkage.
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
bool hasImplicitReturnZero() const
Whether falling off this function implicitly returns null/zero.
bool isImmediateEscalating() const
void setVirtualAsWritten(bool V)
State that this function is marked as virtual explicitly.
bool hasSkippedBody() const
True if the function was a definition but its body was skipped.
FunctionDecl * getDefinition()
Get the definition for this declaration.
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program.
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, Expr *TrailingRequiresClause=nullptr)
bool isThisDeclarationInstantiatedFromAFriendDefinition() const
Determine whether this specific declaration of the function is a friend declaration that was instanti...
void setRangeEnd(SourceLocation E)
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
bool isDefaulted() const
Whether this function is defaulted.
void setIneligibleOrNotSelected(bool II)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
const IdentifierInfo * getLiteralIdentifier() const
getLiteralIdentifier - The literal suffix identifier this function represents, if any.
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
void setConstexprKind(ConstexprSpecKind CSK)
void setDefaulted(bool D=true)
QualType getDeclaredReturnType() const
Get the declared return type, which may differ from the actual return type if the return type is dedu...
bool isGlobal() const
Determines whether this is a global function.
void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)
bool hasInheritedPrototype() const
Whether this function inherited its prototype from a previous declaration.
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization,...
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
DeclarationNameInfo getNameInfo() const
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
void setHasImplicitReturnZero(bool IRZ)
State that falling off this function implicitly returns null/zero.
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
MultiVersionKind getMultiVersionKind() const
Gets the kind of multiversioning attribute this declaration has.
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
Represents a prototype with parameter type info, e.g.
unsigned getNumParams() const
QualType getParamType(unsigned i) const
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
ArrayRef< QualType > param_types() const
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
void mergePrevDecl(FunctionTemplateDecl *Prev)
Merge Prev with our RedeclarableTemplateDecl::Common.
Provides information about a function template specialization, which is a FunctionDecl that has been ...
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration,...
Wrapper for source info for functions.
A class which abstracts out some details necessary for making a call.
ExtInfo withCallingConv(CallingConv cc) const
CallingConv getCC() const
ExtInfo withProducesResult(bool producesResult) const
unsigned getRegParm() const
bool getNoCallerSavedRegs() const
ExtInfo withNoReturn(bool noReturn) const
bool getHasRegParm() const
bool getProducesResult() const
ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const
ExtInfo withRegParm(unsigned RegParm) const
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
static StringRef getNameForCallConv(CallingConv CC)
static ArmStateValue getArmZT0State(unsigned AttrBits)
static ArmStateValue getArmZAState(unsigned AttrBits)
unsigned getRegParmType() const
CallingConv getCallConv() const
QualType getReturnType() const
bool getCmseNSCallAttr() const
@ SME_PStateSMEnabledMask
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
bool isEditorPlaceholder() const
Return true if this identifier is an editor placeholder.
bool isPlaceholder() const
StringRef getName() const
Return the actual identifier string.
iterator - Iterate over the decls of a specified declaration name.
iterator begin(DeclarationName Name)
Returns an iterator over decls with the name 'Name'.
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
void InsertDeclAfter(iterator Pos, NamedDecl *D)
Insert the given declaration after the given iterator position.
iterator end()
Returns the end iterator.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
bool isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false) const
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Represents a C array with an unspecified size.
Represents a field injected from an anonymous union/struct into the parent scope.
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, const IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl * > CH)
void setInherited(bool I)
Description of a constructor that was inherited from a base class.
Describes an C or C++ initializer list.
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init)
Create an initialization from an initializer (which, for direct initialization from a parenthesized l...
Describes the sequence of initializations required to initialize a given object or reference with a s...
step_iterator step_begin() const
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
@ SK_ParenthesizedListInit
Initialize an aggreagate with parenthesized list of values.
Describes an entity that is being initialized.
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Represents the declaration of a label.
bool isResolvedMSAsmLabel() const
LabelStmt * getStmt() const
bool isMSAsmLabel() const
@ FPE_Ignore
Assume that floating-point exceptions are masked.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
FPExceptionModeKind getDefaultExceptionMode() const
bool requiresStrictPrototypes() const
Returns true if functions without prototypes or functions with an identifier list (aka K&R C function...
clang::ObjCRuntime ObjCRuntime
std::string getOpenCLVersionString() const
Return the OpenCL C or C++ for OpenCL language name and version as a string.
bool IsHeaderFile
Indicates whether the front-end is explicitly told that the input is a header file (i....
bool implicitFunctionsAllowed() const
Returns true if implicit function declarations are allowed in the current language mode.
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
std::vector< llvm::Triple > OMPTargetTriples
Triples of the OpenMP targets that the host code codegen should take into account in order to generat...
void push_back(const T &LocalValue)
static SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)
Checks that the given token is the first token that occurs after the given location (this excludes co...
Represents a linkage specification.
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LinkageSpecLanguageIDs Lang, bool HasBraces)
void InstantiatedLocal(const Decl *D, Decl *Inst)
A class for iterating through a result set and possibly filtering out results.
void erase()
Erase the last element returned from this iterator.
Represents the results of name lookup.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
@ NotFound
No entity found met the criteria.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
@ Found
Name lookup found a single declaration that met the criteria.
DeclClass * getAsSingle() const
bool empty() const
Return true if no decls were found.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Filter makeFilter()
Create a filter for this result set.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Sema & getSema() const
Get the Sema object that this lookup result is searching with.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
LookupResultKind getResultKind() const
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
@ AmbiguousTagHiding
Name lookup results in an ambiguity because an entity with a tag name was hidden by an entity with an...
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
virtual unsigned getManglingNumber(const CXXMethodDecl *CallOperator)=0
Retrieve the mangling number of a new lambda expression with the given call operator within this cont...
virtual unsigned getStaticLocalNumber(const VarDecl *VD)=0
Static locals are numbered by source order.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
A pointer to member type per C++ 8.3.3 - Pointers to members.
Describes a module or submodule.
SourceLocation DefinitionLoc
The location of the module definition.
Module * Parent
The parent of this module.
bool isPrivateModule() const
bool isHeaderLikeModule() const
Is this module have similar semantics as headers.
bool isModuleImplementation() const
Is this a module implementation.
StringRef getPrimaryModuleInterfaceName() const
Get the primary module interface name from a partition.
bool isModulePartition() const
Is this a module partition.
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
bool isNamedModule() const
Does this Module is a named module of a standard named module?
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
bool isLinkageValid() const
True if the computed linkage is valid.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
bool isPlaceholderVar(const LangOptions &LangOpts) const
Visibility getVisibility() const
Determines the visibility of this entity.
bool hasLinkageBeenComputed() const
True if something has required us to compute the linkage of this declaration.
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
bool declarationReplaces(const NamedDecl *OldD, bool IsKnownNewer=true) const
Determine whether this declaration, if known to be well-formed within its context,...
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined.
bool hasLinkage() const
Determine whether this declaration has linkage.
bool isExternallyVisible() const
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const
Determine if the declaration obeys the reserved identifier rules of the given language.
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Represent a C++ namespace.
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
Class that aids in the construction of nested-name-specifiers along with source-location information ...
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
A C++ nested-name-specifier augmented with source location information.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
SourceRange getLocalSourceRange() const
Retrieve the source range covering just the last part of this nested-name-specifier,...
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool containsErrors() const
Whether this nested name specifier contains an error.
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)
Returns the nested name specifier representing the global scope.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
ObjCCategoryDecl - Represents a category declaration.
ObjCCompatibleAliasDecl - Represents alias of a class.
ObjCContainerDecl - Represents a container for method declarations.
ObjCIvarDecl * getIvarDecl(IdentifierInfo *Id) const
getIvarDecl - This method looks up an ivar in this ContextDecl.
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Represents an ObjC class declaration.
known_extensions_range known_extensions() const
ObjCIvarDecl - Represents an ObjC instance variable.
static ObjCIvarDecl * Create(ASTContext &C, ObjCContainerDecl *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, AccessControl ac, Expr *BW=nullptr, bool synthesized=false)
An expression that sends a message to the given Objective-C object or class.
ObjCMethodDecl - Represents an instance or class method declaration.
param_const_iterator param_end() const
param_const_iterator param_begin() const
const ParmVarDecl *const * param_const_iterator
ParmVarDecl *const * param_iterator
bool isFragile() const
The inverse of isNonFragile(): does this runtime follow the set of implied behaviors for a "fragile" ...
Wrapper for void* pointer.
static OpaquePtr make(PtrTy P)
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
bool isAvailableOption(llvm::StringRef Ext, const LangOptions &LO) const
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
@ CSK_Normal
Normal lookup.
SmallVectorImpl< OverloadCandidate >::iterator iterator
void NoteCandidates(PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
When overload resolution fails, prints diagnostic messages containing the candidates in the candidate...
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
SmallVectorImpl< UniqueVirtualMethod >::iterator overriding_iterator
MapType::iterator iterator
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
unsigned getNumExprs() const
Return the number of expressions in this paren list.
void setRParenLoc(SourceLocation Loc)
TypeLoc getInnerLoc() const
void setLParenLoc(SourceLocation Loc)
Sugar for parentheses used when specifying types.
Represents a parameter to a function.
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
ObjCDeclQualifier getObjCDeclQualifier() const
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
QualType getOriginalType() const
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
ParsedAttr - Represents a syntactic attribute.
static const ParsedAttributesView & none()
bool hasAttribute(ParsedAttr::Kind K) const
ParsedAttributes - A collection of parsed attributes.
AttributePool & getPool() const
unsigned getDiagID() const
TypeLoc getPointeeLoc() const
Wrapper for source info for pointers.
void setStarLoc(SourceLocation Loc)
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
HeaderSearch & getHeaderSearchInfo() const
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
StringRef getLastMacroWithSpelling(SourceLocation Loc, ArrayRef< TokenValue > Tokens) const
Return the name of the macro defined before Loc that has spelling Tokens.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
PrimitiveDefaultInitializeKind
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const
const IdentifierInfo * getBaseTypeIdentifier() const
Retrieves a pointer to the name of the base type.
QualType withoutLocalFastQualifiers() const
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
std::optional< NonConstantStorageReason > isNonConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
Determine whether instances of this type can be placed in immutable storage.
PrimitiveDefaultInitializeKind isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C struct types.
bool isObjCGCStrong() const
true when Type is objc's strong.
bool isConstQualified() const
Determine whether this type is const-qualified.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool hasNonTrivialObjCLifetime() const
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
@ PCK_Trivial
The type does not fall into any of the following categories.
@ PCK_VolatileTrivial
The type would be trivial except that it is volatile-qualified.
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
A qualifier set is used to build a set of qualifiers.
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
ObjCLifetime getObjCLifetime() const
Represents a struct/union/class.
bool hasObjectMember() const
field_range fields() const
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
virtual void completeDefinition()
Note that the definition of this type is now complete.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
void setMemberSpecialization()
Note that this member template is a specialization.
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
redecl_iterator redecls_end() const
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Base for LValueReferenceType and RValueReferenceType.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
void setNRVOCandidate(const VarDecl *Var)
Set the variable that might be used for the named return value optimization.
Scope - A scope is a transient data structure that is used while parsing the program.
bool isDeclScope(const Decl *D) const
isDeclScope - Return true if this is the scope that the specified decl is declared in.
DeclContext * getEntity() const
Get the entity corresponding to this scope.
bool isCompoundStmtScope() const
Determine whether this scope is a compound statement scope.
const Scope * getParent() const
getParent - Return the scope that this is nested in.
@ TemplateParamScope
This is a scope that corresponds to the template parameters of a C++ template.
@ DeclScope
This is a scope that can contain a declaration.
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
void checkAllowedInitializer(VarDecl *VD)
std::string getConfigureFuncName() const
Returns the name of the launch configuration function.
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
void maybeAddHostDeviceAttrs(FunctionDecl *FD, const LookupResult &Previous)
May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD, depending on FD and the current co...
void checkTargetOverload(FunctionDecl *NewFD, const LookupResult &Previous)
Check whether NewFD is a valid overload for CUDA.
void MaybeAddConstantAttr(VarDecl *VD)
May add implicit CUDAConstantAttr attribute to VD, depending on VD and current compilation settings.
void CheckEntryPoint(FunctionDecl *FD)
HLSLNumThreadsAttr * mergeNumThreadsAttr(Decl *D, const AttributeCommonInfo &AL, int X, int Y, int Z)
HLSLShaderAttr * mergeShaderAttr(Decl *D, const AttributeCommonInfo &AL, HLSLShaderAttr::ShaderType ShaderType)
void ActOnTopLevelFunction(FunctionDecl *FD)
void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID)
DiagnoseDuplicateIvars - Check for duplicate ivars in the entire class at the start of @implementatio...
void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, const ObjCMethodDecl *Overridden)
Check whether the given new method is a valid override of the given overridden method,...
DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S, IdentifierInfo *II)
The parser has read a name in, and Sema has detected that we're currently inside an ObjC method.
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle.
ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV)
void AddCFAuditedAttribute(Decl *D)
AddCFAuditedAttribute - Check whether we're currently within '#pragma clang arc_cf_code_audited' and,...
void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, ObjCIvarDecl **Fields, unsigned nIvars, SourceLocation Loc)
CheckImplementationIvars - This routine checks if the instance variables listed in the implelementati...
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D)
Act on D, a function definition inside of an omp [begin/end] assumes.
void ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope(Decl *D, SmallVectorImpl< FunctionDecl * > &Bases)
Register D as specialization of all base functions in Bases in the current omp begin/end declare vari...
void ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, SmallVectorImpl< FunctionDecl * > &Bases)
The declarator D defines a function in the scope S which is nested in an omp begin/end declare varian...
void ActOnOpenMPDeclareTargetInitializer(Decl *D)
Adds OMPDeclareTargetDeclAttr to referenced variables in declare target directive.
void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
Mode getAlignMode() const
A class which encapsulates the logic for delaying diagnostics during parsing and other processing.
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
static NameClassification DependentNonType()
static NameClassification VarTemplate(TemplateName Name)
static NameClassification Unknown()
static NameClassification OverloadSet(ExprResult E)
static NameClassification UndeclaredTemplate(TemplateName Name)
static NameClassification FunctionTemplate(TemplateName Name)
static NameClassification NonType(NamedDecl *D)
static NameClassification Concept(TemplateName Name)
static NameClassification UndeclaredNonType()
static NameClassification TypeTemplate(TemplateName Name)
static NameClassification Error()
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Sema - This implements semantic analysis and AST building for C.
StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, IdentifierInfo *Ident, ParsedAttributes &Attrs)
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S)
MergeCXXFunctionDecl - Merge two declarations of the same C++ function, once we already know that the...
Attr * getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD, bool IsDefinition)
Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a containing class.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D)
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Scope * getCurScope() const
Retrieve the parser's current scope.
void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New, LookupResult &OldDecls)
MergeTypedefNameDecl - We just parsed a typedef 'New' which has the same name and scope as a previous...
bool hasStructuralCompatLayout(Decl *D, Decl *Suggested)
Determine if D and Suggested have a structurally compatible layout as described in C11 6....
void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S)
Register the given locally-scoped extern "C" declaration so that it can be found later for redeclarat...
BTFDeclTagAttr * mergeBTFDeclTagAttr(Decl *D, const BTFDeclTagAttr &AL)
NamedDecl * ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope)
bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, const CXXMethodDecl *Old)
bool CheckExplicitObjectOverride(CXXMethodDecl *New, const CXXMethodDecl *Old)
bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false) const
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs=true)
void DiagnoseUnusedParameters(ArrayRef< ParmVarDecl * > Parameters)
Diagnose any unused parameters in the given sequence of ParmVarDecl pointers.
void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old)
Merge the exception specifications of two variable declarations.
bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &...Args)
CXXSpecialMemberKind getSpecialMember(const CXXMethodDecl *MD)
LookupNameKind
Describes the kind of name lookup to perform.
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupNestedNameSpecifierName
Look up of a name that precedes the '::' scope resolution operator in C++.
@ LookupLocalFriendName
Look up a friend of a local class.
@ LookupRedeclarationWithLinkage
Look up an ordinary name that is going to be redeclared as a name with linkage.
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function.
void ActOnPopScope(SourceLocation Loc, Scope *S)
void ActOnDefinedDeclarationSpecifier(Decl *D)
Called once it is known whether a tag declaration is an anonymous union or struct.
EnforceTCBAttr * mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL)
Decl * ActOnSkippedFunctionBody(Decl *Decl)
QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name, QualType Type, TypeSourceInfo *TSI, SourceRange Range, bool DirectInit, Expr *Init)
bool SetMemberAccessSpecifier(NamedDecl *MemberDecl, NamedDecl *PrevMemberDecl, AccessSpecifier LexicalAS)
SetMemberAccessSpecifier - Set the access specifier of a member.
@ NTCUC_DefaultInitializedObject
bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn)
MergeFunctionDecl - We just parsed a function 'New' from declarator D which has the same name and sco...
void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind, uint64_t MagicValue, QualType Type, bool LayoutCompatible, bool MustBeNull)
Register a magic integral constant to be used as a type tag.
bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc, TemplateIdAnnotation *TemplateId, bool IsMemberSpecialization)
Diagnose a declaration whose declarator-id has the given nested-name-specifier.
void LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID)
void ActOnTagDefinitionError(Scope *S, Decl *TagDecl)
ActOnTagDefinitionError - Invoked when there was an unrecoverable error parsing the definition of a t...
void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body)
TypeVisibilityAttr * mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, TypeVisibilityAttr::VisibilityType Vis)
void CheckExplicitObjectMemberFunction(Declarator &D, DeclarationName Name, QualType R, bool IsLambda, DeclContext *DC=nullptr)
bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info)
DiagnoseClassNameShadow - Implement C++ [class.mem]p13: If T is the name of a class,...
void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc, CXXRecordDecl *Record)
MarkBaseAndMemberDestructorsReferenced - Given a record decl, mark all the non-trivial destructors of...
const TranslationUnitKind TUKind
The kind of translation unit we are processing.
void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl, SourceRange BraceRange)
ActOnTagFinishDefinition - Invoked once we have finished parsing the definition of a tag (enumeration...
FunctionEmissionStatus
Status of the function emission on the CUDA/HIP/OpenMP host/device attrs.
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
PragmaClangSection PragmaClangRodataSection
NamedDecl * ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II, Scope *S)
ImplicitlyDefineFunction - An undeclared identifier was used in a function call, forming a call to an...
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
Decl * ActOnParamDeclarator(Scope *S, Declarator &D, SourceLocation ExplicitThisLoc={})
ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() to introduce parameters into fun...
void AddPragmaAttributes(Scope *S, Decl *D)
Adds the attributes that have been specified using the '#pragma clang attribute push' directives to t...
TemplateDecl * AdjustDeclIfTemplate(Decl *&Decl)
AdjustDeclIfTemplate - If the given decl happens to be a template, reset the parameter D to reference...
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
bool TemplateParameterListsAreEqual(const TemplateCompareNewDeclInfo &NewInstFrom, TemplateParameterList *New, const NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
WebAssemblyImportNameAttr * mergeImportNameAttr(Decl *D, const WebAssemblyImportNameAttr &AL)
bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, InheritedConstructorInfo *ICI=nullptr, bool Diagnose=false)
Determine if a special member function should have a deleted definition when it is defaulted.
void ActOnExitFunctionContext()
ExprResult RebuildExprInCurrentInstantiation(Expr *E)
DeclResult ActOnVarTemplateSpecialization(Scope *S, Declarator &D, TypeSourceInfo *DI, LookupResult &Previous, SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams, StorageClass SC, bool IsPartialSpecialization)
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
Preprocessor & getPreprocessor() const
void deduceOpenCLAddressSpace(ValueDecl *decl)
PragmaStack< FPOptionsOverride > FpPragmaStack
PragmaStack< StringLiteral * > CodeSegStack
void AddRangeBasedOptnone(FunctionDecl *FD)
Only called on function definitions; if there is a pragma in scope with the effect of a range-based o...
bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckForFunctionMarkedFinal - Checks whether a virtual member function overrides a virtual member fun...
DLLImportAttr * mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI)
static NamedDecl * getAsTemplateNameDecl(NamedDecl *D, bool AllowFunctionTemplates=true, bool AllowDependent=true)
Try to interpret the lookup result D as a template-name.
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
TemplateParameterList * MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, ArrayRef< TemplateParameterList * > ParamLists, bool IsFriend, bool &IsMemberSpecialization, bool &Invalid, bool SuppressDiagnostic=false)
Match the given template parameter lists to the given scope specifier, returning the template paramet...
void handleTagNumbering(const TagDecl *Tag, Scope *TagScope)
void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl)
AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared special functions,...
void AddAlignmentAttributesForRecord(RecordDecl *RD)
AddAlignmentAttributesForRecord - Adds any needed alignment attributes to a the record decl,...
ErrorAttr * mergeErrorAttr(Decl *D, const AttributeCommonInfo &CI, StringRef NewUserDiagnostic)
Decl * ActOnConversionDeclarator(CXXConversionDecl *Conversion)
ActOnConversionDeclarator - Called by ActOnDeclarator to complete the declaration of the given C++ co...
void CheckMain(FunctionDecl *FD, const DeclSpec &D)
void AddKnownFunctionAttributes(FunctionDecl *FD)
Adds any function attributes that we know a priori based on the declaration of this function.
void DiagnoseUnusedButSetDecl(const VarDecl *VD, DiagReceiverTy DiagReceiver)
If VD is set but not otherwise used, diagnose, for a parameter or a variable.
@ Delete
deleted-function-body
ExprResult VerifyBitField(SourceLocation FieldLoc, const IdentifierInfo *FieldName, QualType FieldTy, bool IsMsStruct, Expr *BitWidth)
VerifyBitField - verifies that a bit field expression is an ICE and has the correct width,...
FieldDecl * HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS)
HandleField - Analyze a field of a C struct or a C++ data member.
ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, bool isAddressOfOperand, const TemplateArgumentListInfo *TemplateArgs)
ActOnDependentIdExpression - Handle a dependent id-expression that was just parsed.
void CheckThreadLocalForLargeAlignment(VarDecl *VD)
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Look up a name, looking for a single declaration.
void ActOnReenterFunctionContext(Scope *S, Decl *D)
Push the parameters of D, which must be a function, into scope.
sema::LambdaScopeInfo * RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator)
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
const AttributedType * getCallingConvAttributedType(QualType T) const
Get the outermost AttributedType node that sets a calling convention.
TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S)
isTagName() - This method is called for error recovery purposes only to determine if the specified na...
bool CheckRedeclarationExported(NamedDecl *New, NamedDecl *Old)
void CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC)
CheckConversionDeclarator - Called by ActOnDeclarator to check the well-formednes of the conversion f...
VisibilityAttr * mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, VisibilityAttr::VisibilityType Vis)
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization, bool Disambiguation=false)
Decl * ActOnFileScopeAsmDecl(Expr *expr, SourceLocation AsmLoc, SourceLocation RParenLoc)
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
DiagnosticsEngine & getDiagnostics() const
void ActOnFinishTopLevelStmtDecl(TopLevelStmtDecl *D, Stmt *Statement)
void * SkippedDefinitionContext
bool LookupBuiltin(LookupResult &R)
Lookup a builtin function, when name lookup would otherwise fail.
void DiagPlaceholderFieldDeclDefinitions(RecordDecl *Record)
Emit diagnostic warnings for placeholder members.
void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TypedefNameDecl *NewTD)
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
PragmaStack< bool > StrictGuardStackCheckStack
UnusedFileScopedDeclsType UnusedFileScopedDecls
The set of file scoped decls seen so far that have not been used and must warn if not used.
NamedDecl * LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, Scope *S, bool ForRedeclaration, SourceLocation Loc)
LazilyCreateBuiltin - The specified Builtin-ID was first used at file scope.
ASTContext & getASTContext() const
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
void CheckCoroutineWrapper(FunctionDecl *FD)
bool isCurrentClassName(const IdentifierInfo &II, Scope *S, const CXXScopeSpec *SS=nullptr)
isCurrentClassName - Determine whether the identifier II is the name of the class type currently bein...
bool IsRedefinitionInModule(const NamedDecl *New, const NamedDecl *Old) const
bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method)
Check whether 'this' shows up in the type of a static member function after the (naturally empty) cv-...
void DiagnoseUnguardedAvailabilityViolations(Decl *FD)
Issue any -Wunguarded-availability warnings in FD.
void PopExpressionEvaluationContext()
PragmaStack< StringLiteral * > ConstSegStack
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S)
isMicrosoftMissingTypename - In Microsoft mode, within class scope, if a CXXScopeSpec's type is equal...
SmallVector< VarDecl *, 4 > ExternalDeclarations
All the external declarations encoutered and used in the TU.
bool UseArgumentDependentLookup(const CXXScopeSpec &SS, const LookupResult &R, bool HasTrailingLParen)
void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord)
Add gsl::Pointer attribute to std::container::iterator.
bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn)
We've just determined that Old and New both appear to be definitions of the same variable.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
void ProcessPragmaWeak(Scope *S, Decl *D)
bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Decl * BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy)
BuildAnonymousStructOrUnion - Handle the declaration of an anonymous structure or union.
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)
Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...
void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
EnumDecl * getStdAlignValT() const
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend=false)
Perform semantic analysis for the given function template specialization.
bool UnifySection(StringRef SectionName, int SectionFlags, NamedDecl *TheDecl)
void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld)
MergeVarDeclTypes - We parsed a variable 'New' which has the same name and scope as a previous declar...
void PushFunctionScope()
Enter a new function scope.
ExprResult ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS, NamedDecl *Found, SourceLocation NameLoc, const Token &NextToken)
Act on the result of classifying a name as a specific non-type declaration.
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
void inferGslOwnerPointerAttribute(CXXRecordDecl *Record)
Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
llvm::function_ref< void(SourceLocation Loc, PartialDiagnostic PD)> DiagReceiverTy
bool CheckEnumUnderlyingType(TypeSourceInfo *TI)
Check that this is a valid underlying type for an enum declaration.
bool FriendConstraintsDependOnEnclosingTemplate(const FunctionDecl *FD)
FPOptions & getCurFPFeatures()
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
sema::LambdaScopeInfo * PushLambdaScope()
SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, SourceLocation IILoc)
Determine whether the body of an anonymous enumeration should be skipped.
@ UPPC_FixedUnderlyingType
The fixed underlying type of an enumeration.
@ UPPC_EnumeratorValue
The enumerator value.
@ UPPC_Initializer
An initializer.
@ UPPC_FriendDeclaration
A friend declaration.
@ UPPC_DeclarationType
The type of an arbitrary declaration.
@ UPPC_ExplicitSpecialization
Explicit specialization.
@ UPPC_DeclarationQualifier
A declaration qualifier.
@ UPPC_DataMemberType
The type of a data member.
@ UPPC_BitFieldWidth
The size of a bit-field.
const LangOptions & getLangOpts() const
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl, bool SupportedForCompatibility=false)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter 'PrevD...
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
bool RebuildTemplateParamsInCurrentInstantiation(TemplateParameterList *Params)
Rebuild the template parameters now that we know we're in a current instantiation.
void DiagnoseInvalidJumps(Stmt *Body)
SourceLocation CurInitSegLoc
bool currentModuleIsHeaderUnit() const
Is the module scope we are in a C++ Header Unit?
void EnterTemplatedContext(Scope *S, DeclContext *DC)
Enter a template parameter scope, after it's been associated with a particular DeclContext.
bool tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo, QualType &T, SourceLocation Loc, unsigned FailedFoldDiagID)
Attempt to fold a variable-sized type to a constant-sized type, returning true if we were successful.
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
NamedDecl * findLocallyScopedExternCDecl(DeclarationName Name)
Look for a locally scoped extern "C" declaration by the given name.
bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old)
We've determined that New is a redeclaration of Old.
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, QualType ObjectType, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
bool CheckConstexprFunctionDefinition(const FunctionDecl *FD, CheckConstexprKind Kind)
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
MinSizeAttr * mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI)
NamedDecl * getShadowedDeclaration(const TypedefNameDecl *D, const LookupResult &R)
Return the declaration shadowed by the given typedef D, or null if it doesn't shadow any declaration ...
void checkTypeSupport(QualType Ty, SourceLocation Loc, ValueDecl *D=nullptr)
Check if the type is allowed to be used for the current target.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD)
const LangOptions & LangOpts
void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock)
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
bool isReachable(const NamedDecl *D)
Determine whether a declaration is reachable.
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr, FnBodyKind BodyKind=FnBodyKind::Other)
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn)
Perform semantic checking of a new function declaration.
CXXRecordDecl * getStdBadAlloc() const
AlwaysInlineAttr * mergeAlwaysInlineAttr(Decl *D, const AttributeCommonInfo &CI, const IdentifierInfo *Ident)
FieldDecl * CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitfieldWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D=nullptr)
Build a new FieldDecl and check its well-formedness.
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
PragmaClangSection PragmaClangRelroSection
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD, SourceLocation ReturnLoc, Expr *RetExpr, const AutoType *AT)
Deduce the return type for a function from a returned expression, per C++1y [dcl.spec....
void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D)
void CheckCXXDefaultArguments(FunctionDecl *FD)
Helpers for dealing with blocks and functions.
bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS)
checkUnsafeAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained type.
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
WebAssemblyImportModuleAttr * mergeImportModuleAttr(Decl *D, const WebAssemblyImportModuleAttr &AL)
void AddImplicitMSFunctionNoBuiltinAttr(FunctionDecl *FD)
Only called on function definitions; if there is a pragma in scope with the effect of a range-based n...
PragmaStack< AlignPackInfo > AlignPackStack
bool canDelayFunctionBody(const Declarator &D)
Determine whether we can delay parsing the body of a function or function template until it is used,...
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
PragmaStack< StringLiteral * > BSSSegStack
bool hasAnyAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true, bool AllowNonTemplateFunctions=false)
DeclContext * getCurLexicalContext() const
bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD, const TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous)
Perform semantic analysis for the given dependent function template specialization.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
OverloadKind CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &OldDecls, NamedDecl *&OldDecl, bool UseMemberUsingDeclRules)
Determine whether the given New declaration is an overload of the declarations in Old.
bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl)
CheckOverloadedOperatorDeclaration - Check whether the declaration of this overloaded operator is wel...
bool hasExplicitCallingConv(QualType T)
NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc, const Token &NextToken, CorrectionCandidateCallback *CCC=nullptr)
Perform name lookup on the given name, classifying it based on the results of name lookup and the fol...
NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK)
Given a non-tag type declaration, returns an enum useful for indicating what kind of non-tag type thi...
void ExitDeclaratorContext(Scope *S)
void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI)
Diagnose shadowing for variables shadowed in the lambda record LambdaRD when these variables are capt...
void CheckConstructor(CXXConstructorDecl *Constructor)
CheckConstructor - Checks a fully-formed constructor for well-formedness, issuing any diagnostics req...
void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMemberKind CSM)
Diagnose why the specified class does not have a trivial special member of the given kind.
void CheckMSVCRTEntryPoint(FunctionDecl *FD)
Decl * ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant, SourceLocation IdLoc, IdentifierInfo *Id, const ParsedAttributesView &Attrs, SourceLocation EqualLoc, Expr *Val)
sema::FunctionScopeInfo * getCurFunction() const
void PushCompoundScope(bool IsStmtExpr)
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
FunctionDecl * CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID, SourceLocation Loc)
Scope * getNonFieldDeclScope(Scope *S)
getNonFieldDeclScope - Retrieves the innermost scope, starting from S, where a non-field would be dec...
void ActOnPragmaWeakID(IdentifierInfo *WeakName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc)
ActOnPragmaWeakID - Called on well formed #pragma weak ident.
bool CheckNontrivialField(FieldDecl *FD)
llvm::DenseMap< const VarDecl *, int > RefsMinusAssignments
Increment when we find a reference; decrement when we find an ignored assignment.
void AddPushedVisibilityAttribute(Decl *RD)
AddPushedVisibilityAttribute - If '#pragma GCC visibility' was used, add an appropriate visibility at...
bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method)
Check whether 'this' shows up in the attributes of the given static member function.
void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl, SourceLocation FinalLoc, bool IsFinalSpelledSealed, bool IsAbstract, SourceLocation LBraceLoc)
ActOnStartCXXMemberDeclarations - Invoked when we have parsed a C++ record definition's base-specifie...
DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous)
Perform semantic checking on a newly-created variable declaration.
ExprResult DefaultLvalueConversion(Expr *E)
MSInheritanceAttr * mergeMSInheritanceAttr(Decl *D, const AttributeCommonInfo &CI, bool BestCase, MSInheritanceModel Model)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
StringLiteral * CurInitSeg
Last section used with #pragma init_seg.
FunctionEmissionStatus getEmissionStatus(const FunctionDecl *Decl, bool Final=false)
Module * getCurrentModule() const
Get the module unit whose scope we are currently within.
bool CheckDeductionGuideDeclarator(Declarator &D, QualType &R, StorageClass &SC)
Check the validity of a declarator that we parsed for a deduction-guide.
bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD)
AddOverriddenMethods - See if a method overrides any in the base classes, and if so,...
InternalLinkageAttr * mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL)
void DiagPlaceholderVariableDefinition(SourceLocation Loc)
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init)
bool ActOnDuplicateDefinition(Decl *Prev, SkipBodyInfo &SkipBody)
Perform ODR-like check for C/ObjC when merging tag types from modules.
void ActOnFinishInlineFunctionDef(FunctionDecl *D)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
TypeSourceInfo * RebuildTypeInCurrentInstantiation(TypeSourceInfo *T, SourceLocation Loc, DeclarationName Name)
Rebuilds a type within the context of the current instantiation.
void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, const IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)
Check whether the given function decl's trailing requires clause is satisfied, if any.
bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl)
CheckLiteralOperatorDeclaration - Check whether the declaration of this literal operator function is ...
void CheckShadowingDeclModification(Expr *E, SourceLocation Loc)
Warn if 'E', which is an expression that is about to be modified, refers to a shadowing declaration.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
void notePreviousDefinition(const NamedDecl *Old, SourceLocation New)
void applyFunctionAttributesBeforeParsingBody(Decl *FD)
DLLExportAttr * mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI)
DeclContext * OriginalLexicalContext
Generally null except when we temporarily switch decl contexts, like in.
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
CodeSegAttr * mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Name)
SectionAttr * mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Name)
bool canSkipFunctionBody(Decl *D)
Determine whether we can skip parsing the body of a function definition, assuming we don't care about...
bool canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD, QualType NewT, QualType OldT)
Determines if we can perform a correct type check for D as a redeclaration of PrevDecl.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
@ NTK_TemplateTemplateArgument
SourceManager & getSourceManager() const
NamedDecl * ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists)
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams)
Handle a friend type declaration.
llvm::DenseMap< const EnumDecl *, llvm::APInt > FlagBitsCache
A cache of the flags available in enumerations with the flag_bits attribute.
bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, Scope *S, bool MergeTypeWithOld)
Completes the merge of two function declarations that are known to be compatible.
void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, Decl *EnumDecl, ArrayRef< Decl * > Elements, Scope *S, const ParsedAttributesView &Attr)
void EnterDeclaratorContext(Scope *S, DeclContext *DC)
EnterDeclaratorContext - Used when we must lookup names in the context of a declarator's nested name ...
bool areMultiversionVariantFunctionsCompatible(const FunctionDecl *OldFD, const FunctionDecl *NewFD, const PartialDiagnostic &NoProtoDiagID, const PartialDiagnosticAt &NoteCausedDiagIDAt, const PartialDiagnosticAt &NoSupportDiagIDAt, const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported, bool ConstexprSupported, bool CLinkageMayDiffer)
Checks if the variant/multiversion functions are compatible.
void ActOnTagStartDefinition(Scope *S, Decl *TagDecl)
ActOnTagStartDefinition - Invoked when we have entered the scope of a tag's definition (e....
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
PragmaClangSection PragmaClangTextSection
PragmaClangSection PragmaClangDataSection
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=std::nullopt, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
void FilterAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true)
ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name, SourceLocation NameLoc)
Act on the result of classifying a name as an undeclared (ADL-only) non-type declaration.
bool IsAtLeastAsConstrained(NamedDecl *D1, MutableArrayRef< const Expr * > AC1, NamedDecl *D2, MutableArrayRef< const Expr * > AC2, bool &Result)
Check whether the given declaration's associated constraints are at least as constrained than another...
void ActOnPragmaRedefineExtname(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaRedefineExtname - Called on well formed #pragma redefine_extname oldname newname.
bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams)
Check whether a template can be declared within this scope.
void AddMsStructLayoutForRecord(RecordDecl *RD)
AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
MaybeODRUseExprSet MaybeODRUseExprs
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
CheckParmsForFunctionDef - Check that the parameters of the given function are appropriate for the de...
TopLevelStmtDecl * ActOnStartTopLevelStmtDecl(Scope *S)
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don't have one.
bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
Perform semantic analysis for the given non-template member specialization.
TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc, ImplicitTypenameContext IsImplicitTypename=ImplicitTypenameContext::No)
Called when the parser has parsed a C++ typename specifier, e.g., "typename T::type".
OptimizeNoneAttr * mergeOptimizeNoneAttr(Decl *D, const AttributeCommonInfo &CI)
bool CheckImmediateEscalatingFunctionDefinition(FunctionDecl *FD, const sema::FunctionScopeInfo *FSI)
void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor)
In the MS ABI, we need to instantiate default arguments of dllexported default constructors along wit...
void CheckCompleteVariableDeclaration(VarDecl *VD)
bool IsOverride(FunctionDecl *MD, FunctionDecl *BaseMD, bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs=true)
DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, ArrayRef< Decl * > Group)
void setFunctionHasBranchProtectedScope()
RedeclarationKind forRedeclarationInCurContext() const
void MergeVarDecl(VarDecl *New, LookupResult &Previous)
MergeVarDecl - We just parsed a variable 'New' which has the same name and scope as a previous declar...
LazyDeclPtr StdNamespace
The C++ "std" namespace, where the standard library resides.
ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II, SourceLocation NameLoc, bool IsTemplateTypeArg)
Attempt to behave like MSVC in situations where lookup of an unqualified type name has failed in a de...
EnforceTCBLeafAttr * mergeEnforceTCBLeafAttr(Decl *D, const EnforceTCBLeafAttr &AL)
@ CCEK_Enumerator
Enumerator value with fixed underlying type.
void ActOnLastBitfield(SourceLocation DeclStart, SmallVectorImpl< Decl * > &AllIvarDecls)
ActOnLastBitfield - This routine handles synthesized bitfields rules for class and class extensions.
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
void MarkUnusedFileScopedDecl(const DeclaratorDecl *D)
If it's a file scoped decl that must warn if not used, keep track of it.
llvm::DenseMap< IdentifierInfo *, AsmLabelAttr * > ExtnameUndeclaredIdentifiers
ExtnameUndeclaredIdentifiers - Identifiers contained in #pragma redefine_extname before declared.
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type.
EnumConstantDecl * CheckEnumConstant(EnumDecl *Enum, EnumConstantDecl *LastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, Expr *val)
bool CheckForConstantInitializer(Expr *Init, unsigned DiagID=diag::err_init_element_not_constant)
type checking declaration initializers (C99 6.7.8)
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
@ Ovl_NonFunction
This is not an overload because the lookup results contain a non-function.
@ Ovl_Overload
This is a legitimate overload: the existing declarations are functions or function templates with dif...
@ Ovl_Match
This is not an overload because the signature exactly matches an existing declaration.
SmallVector< ExprWithCleanups::CleanupObject, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
void DiagnoseUnusedNestedTypedefs(const RecordDecl *D)
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
bool hasUncompilableErrorOccurred() const
Whether uncompilable error has occurred.
@ FirstDecl
Parsing the first decl in a TU.
void CheckConstrainedAuto(const AutoType *AutoT, SourceLocation Loc)
void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(FunctionDecl *FD)
If this function is a C++ replaceable global allocation function (C++2a [basic.stc....
@ ImmediateFunctionContext
In addition of being constant evaluated, the current expression occurs in an immediate function conte...
FormatAttr * mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Format, int FormatIdx, int FirstArg)
AvailabilityMergeKind
Describes the kind of merge to perform for availability attributes (including "deprecated",...
@ AMK_None
Don't merge availability attributes at all.
@ AMK_Override
Merge availability attributes for an override, which requires an exact match or a weakening of constr...
@ AMK_ProtocolImplementation
Merge availability attributes for an implementation of a protocol requirement.
@ AMK_OptionalProtocolImplementation
Merge availability attributes for an implementation of an optional protocol requirement.
@ AMK_Redeclaration
Merge availability attributes for a redeclaration, which requires an exact match.
void ActOnDocumentableDecls(ArrayRef< Decl * > Group)
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
void CheckStaticLocalForDllExport(VarDecl *VD)
Check if VD needs to be dllexport/dllimport due to being in a dllexport/import function.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
DeclResult ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, OffsetOfKind OOK, SkipBodyInfo *SkipBody=nullptr)
This is invoked when we see 'struct foo' or 'struct {'.
Decl * ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, const ParsedAttributesView &DeclAttrs, RecordDecl *&AnonRecord)
ParsedFreeStandingDeclSpec - This method is invoked when a declspec with no declarator (e....
StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, SourceLocation LocAfterDecls)
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context)
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void ModifyFnAttributesMSPragmaOptimize(FunctionDecl *FD)
Only called on function definitions; if there is a MSVC #pragma optimize in scope,...
bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl)
Checks if the new declaration declared in dependent context must be put in the same redeclaration cha...
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
void DiscardCleanupsInEvaluationContext()
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
void makeMergedDefinitionVisible(NamedDecl *ND)
Make a merged definition of an existing hidden definition ND visible at the specified location.
UuidAttr * mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI, StringRef UuidAsWritten, MSGuidDecl *GuidDecl)
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
SourceManager & SourceMgr
bool CheckDestructor(CXXDestructorDecl *Destructor)
CheckDestructor - Checks a fully-formed destructor definition for well-formedness,...
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc, StringLiteral *Message=nullptr)
Decl * BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, RecordDecl *Record)
BuildMicrosoftCAnonymousStruct - Handle the declaration of an Microsoft C anonymous structure.
static bool CanBeGetReturnTypeOnAllocFailure(const FunctionDecl *FD)
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
static bool CanBeGetReturnObject(const FunctionDecl *FD)
NamespaceDecl * getStdNamespace() const
NamedDecl * ActOnTypedefDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous)
PragmaStack< StringLiteral * > DataSegStack
void deduceClosureReturnType(sema::CapturingScopeInfo &CSI)
Deduce a block or lambda's return type based on the return statements present in the body.
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc)
void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D)
Common checks for a parameter-declaration that should apply to both function parameters and non-type ...
@ TPC_FriendFunctionTemplate
@ TPC_ClassTemplateMember
@ TPC_FriendFunctionTemplateDefinition
NamedDecl * ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *D, LookupResult &Previous, bool &Redeclaration)
ActOnTypedefNameDecl - Perform semantic checking for a declaration which declares a typedef-name,...
void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs)
ActOnFinishDelayedAttribute - Invoked when we have finished parsing an attribute for which parsing is...
void DiagnoseUnusedDecl(const NamedDecl *ND)
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
QualType CheckConstructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckConstructorDeclarator - Called by ActOnDeclarator to check the well-formedness of the constructo...
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D.
QualType SubstAutoTypeDependent(QualType TypeWithAuto)
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope.
void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, const WeakInfo &W)
DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak applied to it,...
bool IsInvalidSMECallConversion(QualType FromType, QualType ToType)
void ActOnUninitializedDecl(Decl *dcl)
void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc)
Emit diagnostics if the initializer or any of its explicit or implicitly-generated subexpressions req...
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope.
TypedefDecl * ParseTypedefDecl(Scope *S, Declarator &D, QualType T, TypeSourceInfo *TInfo)
Subroutines of ActOnDeclarator().
sema::LambdaScopeInfo * getEnclosingLambda() const
Get the innermost lambda enclosing the current location, if any.
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionExceptionSpec - Checks whether the exception spec is a subset of base spec.
Decl * ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth)
ActOnField - Each field of a C struct/union is passed into this in order to create a FieldDecl object...
AvailabilityAttr * mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI, IdentifierInfo *Platform, bool Implicit, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool IsUnavailable, StringRef Message, bool IsStrict, StringRef Replacement, AvailabilityMergeKind AMK, int Priority, IdentifierInfo *IIEnvironment)
void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old)
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC, SkipBodyInfo *SkipBody=nullptr)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
void ActOnCXXForRangeDecl(Decl *D)
bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionReturnType - Checks whether the return types are covariant,...
std::tuple< MangleNumberingContext *, Decl * > getCurrentMangleNumberContext(const DeclContext *DC)
Compute the mangling number context for a lambda expression or block literal.
llvm::MapVector< IdentifierInfo *, llvm::SetVector< WeakInfo, llvm::SmallVector< WeakInfo, 1u >, llvm::SmallDenseSet< WeakInfo, 2u, WeakInfo::DenseMapInfoByAliasOnly > > > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD=nullptr)
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
PragmaClangSection PragmaClangBSSSection
Decl * ActOnDeclarator(Scope *S, Declarator &D)
void ProcessAPINotes(Decl *D)
Map any API notes provided for this declaration to attributes on the declaration.
void CheckAlignasUnderalignment(Decl *D)
bool CheckRedeclarationInModule(NamedDecl *New, NamedDecl *Old)
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
ExprResult ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, bool IsAddressOfOperand)
Act on the result of classifying a name as an undeclared member of a dependent base class.
void adjustMemberFunctionCC(QualType &T, bool HasThisPointer, bool IsCtorOrDtor, SourceLocation Loc)
Adjust the calling convention of a method to be the ABI default if it wasn't specified explicitly.
SwiftNameAttr * mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA, StringRef Name)
void ActOnPragmaWeakAlias(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
void CheckVariableDeclarationType(VarDecl *NewVD)
unsigned getTemplateDepth(Scope *S) const
Determine the number of levels of enclosing template parameters.
SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD)
Invoked when we enter a tag definition that we're skipping.
bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit, Expr *Init)
TemplateDeductionResult DeduceAutoType(TypeLoc AutoTypeLoc, Expr *Initializer, QualType &Result, sema::TemplateDeductionInfo &Info, bool DependentDeduction=false, bool IgnoreConstraints=false, TemplateSpecCandidateSet *FailedTSC=nullptr)
Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
bool isIncompatibleTypedef(const TypeDecl *Old, TypedefNameDecl *New)
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
llvm::SmallPtrSet< const NamedDecl *, 4 > TypoCorrectedFunctionDefinitions
The function definitions which were renamed as part of typo-correction to match their respective decl...
void AddSectionMSAllocText(FunctionDecl *FD)
Only called on function definitions; if there is a #pragma alloc_text that decides which code section...
void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope)
Given the set of return statements within a function body, compute the variables that are subject to ...
void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind)
Emit diagnostics if a non-trivial C union type or a struct that contains a non-trivial C union is use...
IdentifierResolver IdResolver
bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, bool AllowMask) const
IsValueInFlagEnum - Determine if a value is allowed as part of a flag enum.
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
void DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, CXXScopeSpec *SS, ParsedType &SuggestedType, bool IsTemplateName=false)
void DiagnoseSizeOfParametersAndReturnValue(ArrayRef< ParmVarDecl * > Parameters, QualType ReturnTy, NamedDecl *D)
Diagnose whether the size of parameters or return value of a function or obj-c method definition is p...
void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD)
llvm::SmallVector< std::pair< SourceLocation, const BlockDecl * >, 1 > ImplicitlyRetainedSelfLocs
List of SourceLocations where 'self' is implicitly retained inside a block.
bool checkMSInheritanceAttrOnDefinition(CXXRecordDecl *RD, SourceRange Range, bool BestCase, MSInheritanceModel SemanticSpelling)
TemplateNameKindForDiagnostics
Describes the detailed kind of a template name. Used in diagnostics.
void warnOnReservedIdentifier(const NamedDecl *D)
bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy, bool IsFixed, const EnumDecl *Prev)
Check whether this is a valid redeclaration of a previous enumeration.
void inferNullableClassAttribute(CXXRecordDecl *CRD)
Add _Nullable attributes for std:: types.
NamedDecl * ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef< BindingDecl * > Bindings=std::nullopt)
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
ExprResult ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *OverloadSet)
Act on the result of classifying a name as an overload set.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
OptionalFileEntryRef getFileEntryRefForID(FileID FID) const
Returns the FileEntryRef for the provided FileID.
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
SourceLocation getIncludeLoc(FileID FID) const
Returns the include location if FID is a #include'd file otherwise it returns an invalid location.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
StringRef getFilename(SourceLocation SpellingLoc) const
Return the filename of the file containing a SourceLocation.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getStrTokenLoc(unsigned TokNum) const
Get one of the string literal token.
StringRef getString() const
Represents the declaration of a struct/union/class/enum.
static TagDecl * castFromDeclContext(const DeclContext *DC)
bool isBeingDefined() const
Return true if this decl is currently being defined.
bool isThisDeclarationADefinition() const
Return true if this declaration is a completion definition of the type.
SourceLocation getInnerLocStart() const
Return SourceLocation representing start of source range ignoring outer template declarations.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
TypedefNameDecl * getTypedefNameForAnonDecl() const
void startDefinition()
Starts the definition of this tag declaration.
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type?
void setFreeStanding(bool isFreeStanding=true)
True if this tag is free standing, e.g. "struct foo;".
TagKind getTagKind() const
void setBraceRange(SourceRange R)
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
bool canKeyFunctionBeInline() const
Can an out-of-line inline function serve as a key function?
Exposes information about the current target.
virtual bool validateCpuIs(StringRef Name) const
unsigned getShortWidth() const
Return the size of 'signed short' and 'unsigned short' for this target, in bits.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
virtual bool allowDebugInfoForExternalRef() const
Whether target allows debuginfo types for decl only variables/functions.
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...
bool isTLSSupported() const
Whether the target supports thread-local storage.
unsigned getMaxTLSAlign() const
Return the maximum alignment (in bits) of a TLS variable.
virtual bool validateCpuSupports(StringRef Name) const
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool isValidFeatureName(StringRef Feature) const
Determine whether this TargetInfo supports the given feature.
unsigned getCharWidth() const
virtual ParsedTargetAttr parseTargetAttr(StringRef Str) const
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
bool supportsMultiVersioning() const
Identify whether this target supports multiversioning of functions, which requires support for cpu_su...
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
virtual bool isValidGCCRegisterName(StringRef Name) const
Returns whether the passed in string is a valid register name according to GCC.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Location wrapper for a TemplateArgument.
The base class of all kinds of template declarations (e.g., class, function, etc.).
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
Stores a list of template parameters for a TemplateDecl and its derived classes.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation getRAngleLoc() const
SourceLocation getTemplateLoc() const
Represents a type template specialization; the template must be a class template, a type alias templa...
static bool anyInstantiationDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args)
Token - This structure provides full information about a lexed token.
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
bool isNot(tok::TokenKind K) const
A declaration that models statements at global scope.
static TopLevelStmtDecl * Create(ASTContext &C, Stmt *Statement)
Represents a declaration of a type.
void setTypeForDecl(const Type *TD)
const Type * getTypeForDecl() const
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
Base wrapper for a particular "section" of type source info.
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
TypeLoc IgnoreParens() const
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
void initializeFullCopy(TypeLoc Other)
Initializes this by copying its information from another TypeLoc of the same type.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
AutoTypeLoc getContainedAutoTypeLoc() const
Get the typeloc of an AutoType whose type will be deduced for a variable with an initializer of this ...
SourceLocation getTemplateKeywordLoc() const
Get the SourceLocation of the template keyword (if any).
SourceLocation getEndLoc() const
Get the end source location.
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
static StringRef getTagTypeKindName(TagTypeKind Kind)
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
The base class of the type hierarchy.
bool isSizelessType() const
As an extension, we classify types as one of "sized" or "sizeless"; every type is one or the other.
bool isStructureType() const
bool isDecltypeType() const
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isDependentSizedArrayType() const
bool isBlockPointerType() const
bool isBooleanType() const
bool isFunctionReferenceType() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
bool isIncompleteArrayType() const
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
bool isDependentAddressSpaceType() const
bool isConstantArrayType() const
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool isVoidPointerType() const
bool isFunctionPointerType() const
bool isPointerType() const
bool isSVESizelessBuiltinType() const
Returns true for SVE scalable vector types.
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isScalarType() const
bool isVariableArrayType() const
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isBitIntType() const
bool isOpenCLSpecificType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type.
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
const RecordType * getAsStructureType() const
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
bool containsErrors() const
Whether this type is an error type.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isAtomicType() const
bool isFunctionProtoType() const
bool isObjCIdType() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
const T * getAsAdjusted() const
Member-template getAsAdjusted<specific type>.
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isMemberFunctionPointerType() const
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
bool isFloatingType() const
bool isAnyPointerType() const
TypeClass getTypeClass() const
bool hasAutoForTrailingReturnType() const
Determine whether this type was written with a leading 'auto' corresponding to a trailing return type...
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isNullPtrType() const
bool isRecordType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
bool isFunctionNoProtoType() const
bool isReserveIDT() const
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
bool isSizelessVectorType() const
Returns true for all scalable vector types.
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
Base class for declarations which introduce a typedef-name.
TypeSourceInfo * getTypeSourceInfo() const
void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy)
QualType getUnderlyingType() const
void setTypeSourceInfo(TypeSourceInfo *newType)
TagDecl * getAnonDeclWithTypedefName(bool AnyRedecl=false) const
Retrieves the tag declaration for which this is the typedef name for linkage purposes,...
TypedefNameDecl * getDecl() const
Simple class containing the result of Sema::CorrectTypo.
IdentifierInfo * getCorrectionAsIdentifierInfo() const
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
SmallVectorImpl< NamedDecl * >::const_iterator const_decl_iterator
DeclarationName getCorrection() const
Gets the DeclarationName of the typo correction.
unsigned getEditDistance(bool Normalized=true) const
Gets the "edit distance" of the typo correction from the typo.
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
SmallVectorImpl< NamedDecl * >::iterator decl_iterator
void setCorrectionDecl(NamedDecl *CDecl)
Clears the list of NamedDecls before adding the new one.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Expr * getSubExpr() const
static bool isIncrementDecrementOp(Opcode Op)
Represents a C++ unqualified-id that has been parsed.
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent)
The iterator over UnresolvedSets.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
BaseUsingDecl * getIntroducer() const
Gets the (written or instantiated) using declaration that introduced this declaration.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Represents a variable declaration or definition.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
void setCXXForRangeDecl(bool FRD)
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
TLSKind getTLSKind() const
void setInitStyle(InitializationStyle Style)
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member.
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
bool isCXXCondDecl() const
@ ListInit
Direct list-initialization (C++11)
@ ParenListInit
Parenthesized list-initialization (C++20)
@ CallInit
Call-style initialization (C++98)
void setStorageClass(StorageClass SC)
void setPreviousDeclInSameBlockScope(bool Same)
bool isStaticDataMember() const
Determines whether this is a static data member.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
bool mightBeUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value might be usable in a constant expression, according to the re...
void setInlineSpecified()
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
bool isFileVarDecl() const
Returns true for file scoped variable declaration.
void setTSCSpec(ThreadStorageClassSpecifier TSC)
bool checkForConstantInitialization(SmallVectorImpl< PartialDiagnosticAt > &Notes) const
Evaluate the initializer of this variable to determine whether it's a constant initializer.
bool isInline() const
Whether this variable is (C++1z) inline.
ThreadStorageClassSpecifier getTSCSpec() const
const Expr * getInit() const
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
VarDecl * getInitializingDeclaration()
Get the initializing declaration of this variable, if any.
void setConstexpr(bool IC)
@ TLS_Static
TLS with a known-constant initializer.
@ TLS_Dynamic
TLS with a dynamic initializer.
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
@ TentativeDefinition
This declaration is a tentative definition.
@ DeclarationOnly
This declaration is only a declaration.
@ Definition
This declaration is definitely a definition.
void setDescribedVarTemplate(VarTemplateDecl *Template)
bool isExternC() const
Determines whether this variable is a variable with external, C linkage.
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
void setImplicitlyInline()
bool isThisDeclarationADemotedDefinition() const
If this definition should pretend to be a declaration.
bool isPreviousDeclInSameBlockScope() const
Whether this local extern variable declaration's previous declaration was declared in the same block ...
bool hasDependentAlignment() const
Determines if this variable's alignment is dependent.
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
void demoteThisDefinitionToDeclaration()
This is a definition which should be demoted to a declaration.
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
Declaration of a variable template.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
VarTemplateDecl * getInstantiatedFromMemberTemplate() const
static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)
Create a variable template node.
Represents a C array with a specified size that is not an integer-constant-expression.
Expr * getSizeExpr() const
Captures information about a #pragma weak directive.
void disableCheckFallThrough()
Policy getDefaultPolicy()
ValueDecl * getVariable() const
bool isVariableCapture() const
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
void addVLATypeCapture(SourceLocation Loc, const VariableArrayType *VLAType, QualType CaptureType)
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
SmallVector< Capture, 4 > Captures
Captures - The captures.
ImplicitCaptureStyle ImpCaptureStyle
bool isCXXThisCaptured() const
Determine whether the C++ 'this' is captured.
void addThisCapture(bool isNested, SourceLocation Loc, QualType CaptureType, bool ByCopy)
void addCapture(ValueDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
Retains information about a function, method, or block that is currently being parsed.
bool UsesFPIntrin
Whether this function uses constrained floating point intrinsics.
void addByrefBlockVar(VarDecl *VD)
bool NeedsScopeChecking() const
bool ObjCShouldCallSuper
A flag that is set when parsing a method that must call super's implementation, such as -dealloc,...
bool ObjCWarnForNoInitDelegation
This starts true for a secondary initializer method and will be set to false if there is an invocatio...
bool HasPotentialAvailabilityViolations
Whether we make reference to a declaration that could be unavailable.
bool ObjCWarnForNoDesignatedInitChain
This starts true for a method marked as designated initializer and will be set to false if there is a...
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
ParmVarDecl * ExplicitObjectParameter
llvm::SmallVector< ShadowedOuterDecl, 4 > ShadowingDecls
CXXRecordDecl * Lambda
The class that describes the lambda.
bool AfterParameterList
Indicate that we parsed the parameter list at which point the mutability of the lambda is known.
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
bool Mutable
Whether this is a mutable lambda.
Provides information about an attempted template argument deduction, whose success or failure was des...
Defines the clang::TargetInfo interface.
bool evaluateRequiredTargetFeatures(llvm::StringRef RequiredFatures, const llvm::StringMap< bool > &TargetFetureMap)
Returns true if the required target features of a builtin function are enabled.
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
bool randomizeStructureLayout(const ASTContext &Context, RecordDecl *RD, llvm::SmallVectorImpl< Decl * > &FinalOrdering)
The JSON file list parser is used to communicate input to InstallAPI.
bool FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI)
TypeSpecifierType
Specifies the kind of type.
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
@ OR_Deleted
Succeeded, but refers to a deleted function.
@ OR_Success
Overload resolution succeeded.
@ OR_Ambiguous
Ambiguous candidates found.
@ OR_No_Viable_Function
No viable function found.
@ GVA_AvailableExternally
SmallVector< Attr *, 4 > AttrVec
AttrVec - A vector of Attr, which is how they are stored on the AST.
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
ConstexprSpecKind
Define the kind of constexpr specifier.
InClassInitStyle
In-class initialization styles for non-static data members.
@ ICIS_NoInit
No in-class initializer.
OverloadCandidateDisplayKind
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
@ LCK_ByRef
Capturing by reference.
@ LCK_StarThis
Capturing the *this object by copy.
@ IK_DeductionGuideName
A deduction-guide name (a template-name)
@ IK_ImplicitSelfParam
An implicit 'self' parameter.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_ConstructorTemplateId
A constructor named via a template-id.
@ IK_ConstructorName
A constructor name.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
@ IK_DestructorName
A destructor name.
@ IK_OperatorFunctionId
An overloaded operator name, e.g., operator+.
@ IK_ConversionFunctionId
A conversion function name, e.g., operator int.
bool DeclAttrsMatchCUDAMode(const LangOptions &LangOpts, Decl *D)
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have.
StorageClass
Storage classes.
ThreadStorageClassSpecifier
Thread storage-class-specifier.
@ TSCS_thread_local
C++11 thread_local.
@ TSCS__Thread_local
C11 _Thread_local.
@ TSCS___thread
GNU __thread.
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)
Insertion operator for diagnostics.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ External
External linkage, which indicates that the entity can be referred to from other translation units.
@ Module
Module linkage, which indicates that the entity can be referred to from other translation units withi...
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Parameter
The parameter type of a method or function.
@ Result
The result type of a method or function.
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
bool supportsVariadicCall(CallingConv CC)
Checks whether the given calling convention supports variadic calls.
TagTypeKind
The kind of a tag type.
@ Interface
The "__interface" keyword.
@ Struct
The "struct" keyword.
@ Class
The "class" keyword.
@ Union
The "union" keyword.
@ Enum
The "enum" keyword.
LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t',...
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
bool isDiscardableGVALinkage(GVALinkage L)
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword.
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ CanNeverPassInRegs
The argument of this type cannot be passed directly in registers.
@ TU_Complete
The translation unit is a complete translation unit.
int hasAttribute(AttributeCommonInfo::Syntax Syntax, const IdentifierInfo *Scope, const IdentifierInfo *Attr, const TargetInfo &Target, const LangOptions &LangOpts)
Return the version number associated with the attribute if we recognize and implement the attribute s...
CXXSpecialMemberKind
Kinds of C++ special members.
@ TNK_Type_template
The name refers to a template whose specialization produces a type.
LambdaCaptureDefault
The default, if any, capture method for a lambda expression.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
const FunctionProtoType * T
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
TemplateDeductionResult
Describes the result of template argument deduction.
@ Success
Template argument deduction was successful.
@ AlreadyDiagnosed
Some error which was already diagnosed.
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ None
The alignment was not explicit in code.
@ None
No keyword precedes the qualified type name.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
bool IsArmStreamingFunction(const FunctionDecl *FD, bool IncludeLocallyStreaming)
Returns whether the given FunctionDecl has an __arm[_locally]_streaming attribute.
@ EST_None
no exception specification
@ EST_BasicNoexcept
noexcept
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
MutableArrayRef< Expr * > MultiExprArg
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setLoc(SourceLocation L)
setLoc - Sets the main location of the declaration name.
void setCXXLiteralOperatorNameLoc(SourceLocation Loc)
setCXXLiteralOperatorNameLoc - Sets the location of the literal operator name (not the operator keywo...
void setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
void setCXXOperatorNameRange(SourceRange R)
setCXXOperatorNameRange - Sets the range of the operator name (without the operator keyword).
SourceRange getCXXOperatorNameRange() const
getCXXOperatorNameRange - Gets the range of the operator name (without the operator keyword).
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
ArrayRef< NamedDecl * > getDeclsInPrototype() const
Get the non-parameter decls defined within this function prototype.
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
const IdentifierInfo * Ident
One instance of this struct is used for each type in a declarator that is parsed.
enum clang::DeclaratorChunk::@221 Kind
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl * > DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult(), SourceLocation TrailingReturnTypeLoc=SourceLocation(), DeclSpec *MethodQualifiers=nullptr)
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
MemberPointerTypeInfo Mem
static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc, bool lvalue)
Return a DeclaratorChunk for a reference.
RetTy visit(QualType FT, Ts &&... Args)
EvalResult is a struct with detailed info about an evaluated expression.
Extra information about a function prototype.
unsigned AArch64SMEAttributes
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI)
Contains information gathered from parsing the contents of TargetAttr.
std::vector< std::string > Features
Describes how types, statements, expressions, and declarations should be printed.
SourceLocation PragmaLocation
Information about a template-id annotation token.
unsigned NumArgs
NumArgs - The number of template arguments.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
SourceLocation TemplateKWLoc
TemplateKWLoc - The location of the template keyword.