48#include "llvm/ADT/SmallString.h"
49#include "llvm/TargetParser/Triple.h"
54#include <unordered_map>
61 Decl *Group[2] = { OwnedType, Ptr };
72 TypeNameValidatorCCC(
bool AllowInvalid,
bool WantClass =
false,
73 bool AllowTemplates =
false,
74 bool AllowNonTemplates =
true)
75 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
76 AllowTemplates(AllowTemplates), AllowNonTemplates(AllowNonTemplates) {
77 WantExpressionKeywords =
false;
78 WantCXXNamedCasts =
false;
79 WantRemainingKeywords =
false;
84 if (!AllowInvalidDecl && ND->isInvalidDecl())
88 return AllowTemplates;
90 bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
94 if (AllowNonTemplates)
100 auto *RD = dyn_cast<CXXRecordDecl>(ND);
101 if (!RD || !RD->isInjectedClassName())
103 RD = cast<CXXRecordDecl>(RD->getDeclContext());
104 return RD->getDescribedClassTemplate() ||
105 isa<ClassTemplateSpecializationDecl>(RD);
111 return !WantClassName && candidate.
isKeyword();
114 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
115 return std::make_unique<TypeNameValidatorCCC>(*
this);
119 bool AllowInvalidDecl;
122 bool AllowNonTemplates;
134 case tok::kw___int64:
135 case tok::kw___int128:
137 case tok::kw_unsigned:
145 case tok::kw__Float16:
146 case tok::kw___float128:
147 case tok::kw___ibm128:
148 case tok::kw_wchar_t:
150#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
151#include "clang/Basic/TransformTypeTraits.def"
152 case tok::kw___auto_type:
155 case tok::annot_typename:
156 case tok::kw_char16_t:
157 case tok::kw_char32_t:
159 case tok::annot_decltype:
160 case tok::kw_decltype:
163 case tok::kw_char8_t:
174enum class UnqualifiedTypeNameLookupResult {
185static UnqualifiedTypeNameLookupResult
190 return UnqualifiedTypeNameLookupResult::NotFound;
192 UnqualifiedTypeNameLookupResult FoundTypeDecl =
193 UnqualifiedTypeNameLookupResult::NotFound;
196 if (
auto *BaseTT =
Base.getType()->getAs<
TagType>())
197 BaseRD = BaseTT->getAsCXXRecordDecl();
201 if (!TST || !TST->isDependentType())
203 auto *TD = TST->getTemplateName().getAsTemplateDecl();
206 if (
auto *BasePrimaryTemplate =
207 dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) {
209 BaseRD = BasePrimaryTemplate;
210 else if (
auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
212 CTD->findPartialSpecialization(
Base.getType()))
220 if (!isa<TypeDecl>(ND))
221 return UnqualifiedTypeNameLookupResult::FoundNonType;
222 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
224 if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
226 case UnqualifiedTypeNameLookupResult::FoundNonType:
227 return UnqualifiedTypeNameLookupResult::FoundNonType;
228 case UnqualifiedTypeNameLookupResult::FoundType:
229 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
231 case UnqualifiedTypeNameLookupResult::NotFound:
238 return FoundTypeDecl;
246 UnqualifiedTypeNameLookupResult FoundTypeDecl =
247 UnqualifiedTypeNameLookupResult::NotFound;
249 DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
253 RD = dyn_cast<CXXRecordDecl>(DC);
257 if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
263 S.
Diag(NameLoc, diag::ext_found_in_dependent_base) << &II;
284 bool WantNontrivialTypeSourceInfo =
true) {
286 case Type::DeducedTemplateSpecialization:
288 case Type::InjectedClassName:
291 case Type::UnresolvedUsing:
296 case Type::ObjCInterface:
297 case Type::ObjCTypeParam:
298 case Type::TemplateTypeParm:
301 llvm_unreachable(
"Unexpected Type Class");
309 if (!WantNontrivialTypeSourceInfo)
313 Builder.pushTypeSpec(T).setNameLoc(NameLoc);
330 bool HasTrailingDot,
ParsedType ObjectTypePtr,
331 bool IsCtorOrDtorName,
332 bool WantNontrivialTypeSourceInfo,
333 bool IsClassTemplateDeductionContext,
337 bool AllowDeducedTemplate = IsClassTemplateDeductionContext &&
339 !isClassName && !HasTrailingDot;
364 !isClassName && !IsCtorOrDtorName)
366 bool IsImplicitTypename = !isClassName && !IsCtorOrDtorName;
367 if (IsImplicitTypename) {
370 Diag(QualifiedLoc, diag::warn_cxx17_compat_implicit_typename);
372 Diag(QualifiedLoc, diag::ext_implicit_typename)
379 if (WantNontrivialTypeSourceInfo)
411 if (ObjectTypePtr &&
Result.empty()) {
435 switch (
Result.getResultKind()) {
439 TypeNameValidatorCCC CCC(
true, isClassName,
440 AllowDeducedTemplate);
445 bool MemberOfUnknownSpecialization;
454 if (Correction && (NNS || NewII != &II) &&
460 Template, MemberOfUnknownSpecialization))) {
462 isClassName, HasTrailingDot, ObjectTypePtr,
464 WantNontrivialTypeSourceInfo,
465 IsClassTemplateDeductionContext);
468 PDiag(diag::err_unknown_type_or_class_name_suggest)
469 <<
Result.getLookupName() << isClassName);
472 *CorrectedII = NewII;
481 Result.suppressDiagnostics();
491 Result.suppressDiagnostics();
497 Res != ResEnd; ++Res) {
499 if (isa<TypeDecl, ObjCInterfaceDecl, UnresolvedUsingIfExistsDecl>(
506 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*Res);
518 Result.suppressDiagnostics();
529 IIDecl =
Result.getFoundDecl();
530 FoundUsingShadow = dyn_cast<UsingShadowDecl>(*
Result.begin());
534 assert(IIDecl &&
"Didn't find decl");
537 if (
TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
541 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
542 auto *FoundRD = dyn_cast<CXXRecordDecl>(TD);
543 if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD &&
544 FoundRD->isInjectedClassName() &&
546 Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor)
557 FoundUsingShadow =
nullptr;
558 }
else if (
auto *UD = dyn_cast<UnresolvedUsingIfExistsDecl>(IIDecl)) {
562 }
else if (AllowDeducedTemplate) {
564 assert(!FoundUsingShadow || FoundUsingShadow->
getTargetDecl() == TD);
570 FoundUsingShadow =
nullptr;
576 Result.suppressDiagnostics();
580 if (FoundUsingShadow)
583 return buildNamedType(*
this, SS, T, NameLoc, WantNontrivialTypeSourceInfo);
591 auto *ND = dyn_cast<NamespaceDecl>(DC);
592 if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
594 else if (
auto *RD = dyn_cast<CXXRecordDecl>(DC))
596 RD->getTypeForDecl());
597 else if (isa<TranslationUnitDecl>(DC))
600 llvm_unreachable(
"something isn't in TU scope?");
611 if (
const auto *MD = dyn_cast<CXXMethodDecl>(DC))
612 if (MD->getParent()->hasAnyDependentBases())
620 bool IsTemplateTypeArg) {
621 assert(
getLangOpts().MSVCCompat &&
"shouldn't be called in non-MSVC mode");
624 if (IsTemplateTypeArg &&
getCurScope()->isTemplateParamScope()) {
633 Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
639 RD->getTypeForDecl());
643 Diag(NameLoc, diag::ext_undeclared_unqual_id_with_dependent_base) << &II
678 switch (TD->getTagKind()) {
715 return S->isFunctionPrototypeScope();
725 bool IsTemplateName) {
730 SuggestedType =
nullptr;
734 TypeNameValidatorCCC CCC(
false,
false,
741 bool CanRecover = !IsTemplateName;
742 if (Corrected.isKeyword()) {
745 PDiag(IsTemplateName ? diag::err_no_template_suggest
746 : diag::err_unknown_typename_suggest)
748 II = Corrected.getCorrectionAsIdentifierInfo();
751 if (!SS || !SS->
isSet()) {
753 PDiag(IsTemplateName ? diag::err_no_template_suggest
754 : diag::err_unknown_typename_suggest)
757 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
758 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
759 II->
getName().equals(CorrectedStr);
762 ? diag::err_no_member_template_suggest
763 : diag::err_unknown_nested_typename_suggest)
764 << II << DC << DroppedSpecifier << SS->
getRange(),
767 llvm_unreachable(
"could not have corrected a typo here");
774 if (Corrected.getCorrectionSpecifier())
779 getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), IILoc, S,
780 tmpSS.
isSet() ? &tmpSS : SS,
false,
false,
nullptr,
790 Name.setIdentifier(II, IILoc);
793 bool MemberOfUnknownSpecialization;
795 Name,
nullptr,
true, TemplateResult,
806 Diag(IILoc, IsTemplateName ? diag::err_no_template
807 : diag::err_unknown_typename)
810 Diag(IILoc, IsTemplateName ? diag::err_no_member_template
811 : diag::err_typename_nested_not_found)
817 unsigned DiagID = diag::err_typename_missing;
819 DiagID = diag::ext_typename_missing;
826 *SS, *II, IILoc).
get();
829 "Invalid scope specifier has already been diagnosed");
837 NextToken.
is(tok::less);
840 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
843 if (CheckTemplate && isa<TemplateDecl>(*I))
857 StringRef FixItTagName;
858 switch (Tag->getTagKind()) {
860 FixItTagName =
"class ";
864 FixItTagName =
"enum ";
868 FixItTagName =
"struct ";
872 FixItTagName =
"__interface ";
876 FixItTagName =
"union ";
880 StringRef TagName = FixItTagName.drop_back();
881 SemaRef.
Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
882 << Name << TagName << SemaRef.
getLangOpts().CPlusPlus
887 SemaRef.
Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
902 const Token &NextToken,
907 assert(NextToken.
isNot(tok::coloncolon) &&
908 "parse nested name specifiers before calling ClassifyName");
948 bool SecondTry =
false;
949 bool IsFilteredTemplateName =
false;
952 switch (
Result.getResultKind()) {
956 if (SS.
isEmpty() && NextToken.
is(tok::l_paren)) {
1002 if (!SecondTry && CCC) {
1007 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
1008 unsigned QualifiedDiag = diag::err_no_member_suggest;
1011 NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl();
1013 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
1014 UnqualifiedDiag = diag::err_no_template_suggest;
1015 QualifiedDiag = diag::err_no_member_template_suggest;
1016 }
else if (UnderlyingFirstDecl &&
1017 (isa<TypeDecl>(UnderlyingFirstDecl) ||
1018 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
1019 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
1020 UnqualifiedDiag = diag::err_unknown_typename_suggest;
1021 QualifiedDiag = diag::err_unknown_nested_typename_suggest;
1027 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
1028 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
1029 Name->getName().equals(CorrectedStr);
1032 << DroppedSpecifier << SS.
getRange());
1036 Name = Corrected.getCorrectionAsIdentifierInfo();
1039 if (Corrected.isKeyword())
1045 Result.setLookupName(Corrected.getCorrection());
1067 Result.suppressDiagnostics();
1109 if (!
Result.isAmbiguous()) {
1110 IsFilteredTemplateName =
true;
1120 (IsFilteredTemplateName ||
1136 if (!IsFilteredTemplateName)
1139 bool IsFunctionTemplate;
1143 IsFunctionTemplate =
true;
1146 }
else if (!
Result.empty()) {
1150 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
1151 IsVarTemplate = isa<VarTemplateDecl>(TD);
1154 dyn_cast<UsingShadowDecl>(*
Result.begin());
1155 assert(!FoundUsingShadow ||
1156 TD == cast<TemplateDecl>(FoundUsingShadow->
getTargetDecl()));
1166 IsFunctionTemplate =
true;
1170 if (IsFunctionTemplate) {
1174 Result.suppressDiagnostics();
1185 if (
const auto *USD = dyn_cast<UsingShadowDecl>(Found))
1201 dyn_cast<ObjCCompatibleAliasDecl>(
FirstDecl))
1202 Class = Alias->getClassInterface();
1208 if (NextToken.
is(tok::period)) {
1211 Result.suppressDiagnostics();
1223 if (
auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(
FirstDecl)) {
1236 bool NextIsOp = NextToken.
isOneOf(tok::amp, tok::star);
1237 if ((NextToken.
is(tok::identifier) ||
1239 FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
1251 if (
Result.isSingleResult() && !ADL &&
1256 Result.suppressDiagnostics();
1259 Result.getLookupNameInfo(), ADL,
Result.isOverloadedResult(),
1276 bool IsAddressOfOperand) {
1279 NameInfo, IsAddressOfOperand,
1286 const Token &NextToken) {
1303 auto *ULE = cast<UnresolvedLookupExpr>(E);
1304 if ((*ULE->decls_begin())->isCXXClassMember()) {
1306 SS.
Adopt(ULE->getQualifierLoc());
1311 Result.setNamingClass(ULE->getNamingClass());
1312 for (
auto I = ULE->decls_begin(), E = ULE->decls_end(); I != E; ++I)
1313 Result.addDecl(*I, I.getAccess());
1326 auto *TD = Name.getAsTemplateDecl();
1329 if (isa<ClassTemplateDecl>(TD))
1331 if (isa<FunctionTemplateDecl>(TD))
1333 if (isa<VarTemplateDecl>(TD))
1335 if (isa<TypeAliasTemplateDecl>(TD))
1337 if (isa<TemplateTemplateParmDecl>(TD))
1339 if (isa<ConceptDecl>(TD))
1346 "The next DeclContext should be lexically contained in the current one.");
1352 assert(
CurContext &&
"DeclContext imbalance!");
1355 assert(
CurContext &&
"Popped translation unit!");
1364 CurContext = cast<TagDecl>(D)->getDefinition();
1365 assert(
CurContext &&
"skipping definition of undefined tag");
1396 assert(!S->getEntity() &&
"scope already has entity");
1399 Scope *Ancestor = S->getParent();
1407 if (S->getParent()->isTemplateParamScope()) {
1415 assert(S->getEntity() ==
CurContext &&
"Context imbalance!");
1419 Scope *Ancestor = S->getParent();
1428 assert(S->isTemplateParamScope() &&
1429 "expected to be initializing a template parameter scope");
1453 for (; S && S->isTemplateParamScope(); S = S->getParent(), --ScopeDepth) {
1457 cast<Decl>(DC)->getDescribedTemplateParams()) {
1458 unsigned DCDepth = TPL->getDepth() + 1;
1459 if (DCDepth > ScopeDepth)
1461 if (ScopeDepth == DCDepth)
1466 S->setLookupEntity(SearchDCAfterScope);
1480 "The next DeclContext should be lexically contained in the current one.");
1484 for (
unsigned P = 0, NumParams = FD->
getNumParams();
P < NumParams; ++
P) {
1497 assert(
CurContext &&
"DeclContext imbalance!");
1499 assert(
CurContext &&
"Popped translation unit!");
1528 return ND->
hasAttr<OverloadableAttr>();
1531 return Previous.getFoundDecl()->hasAttr<OverloadableAttr>();
1541 while (S->getEntity() && S->getEntity()->isTransparentContext())
1556 if (isa<FunctionDecl>(D) &&
1557 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
1563 for (; I != IEnd; ++I) {
1575 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1582 if (!S->isDeclScope(*I))
1596 bool AllowInlineNamespace)
const {
1604 if (ScopeDC->getPrimaryContext() == TargetDC)
1606 }
while ((S = S->getParent()));
1618 bool ConsiderLinkage,
1619 bool AllowInlineNamespace) {
1680 if (NewIsModuleInterface || OldIsModuleInterface) {
1686 << NewIsModuleInterface
1688 << OldIsModuleInterface
1719 if (!IsNewExported && !IsOldExported)
1725 assert(IsNewExported);
1733 Diag(New->
getLocation(), diag::err_redeclaration_non_exported) << New << S;
1769 "New and Old are not the same definition, we should diagnostic it "
1770 "immediately instead of checking it.");
1773 "We shouldn't see unreachable definitions here.");
1821 return OldM == NewM;
1825 return isa<UsingShadowDecl>(D) ||
1826 isa<UnresolvedUsingTypenameDecl>(D) ||
1827 isa<UnresolvedUsingValueDecl>(D);
1854 return CD->isCopyConstructor();
1873 if (
const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1874 if (!RD->hasNameForLinkage())
1903 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1909 FD->getMemberSpecializationInfo() && !FD->isOutOfLine())
1912 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1917 if (FD->isInlined() && !
isMainFileLoc(*
this, FD->getLocation()))
1921 if (FD->doesThisDeclarationHaveABody() &&
1924 }
else if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1934 if (VD->isStaticDataMember() &&
1937 if (VD->isStaticDataMember() &&
1939 VD->getMemberSpecializationInfo() && !VD->isOutOfLine())
1942 if (VD->isInline() && !
isMainFileLoc(*
this, VD->getLocation()))
1951 return mightHaveNonExternalLinkage(D);
1958 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1964 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1978 if (
auto *DD = dyn_cast<DecompositionDecl>(D)) {
1982 for (
auto *BD : DD->bindings())
1983 if (BD->isReferenced())
1991 if (D->
hasAttr<UnusedAttr>() || D->
hasAttr<ObjCPreciseLifetimeAttr>())
1994 if (isa<LabelDecl>(D))
2000 if (
const auto *R = dyn_cast<CXXRecordDecl>(D->
getDeclContext()))
2003 WithinFunction || (R->isLocalClass() && !R->isDependentType());
2004 if (!WithinFunction)
2007 if (isa<TypedefNameDecl>(D))
2011 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
2015 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2017 const Expr *Init = VD->getInit();
2018 if (
const auto *Cleanups = dyn_cast_or_null<ExprWithCleanups>(Init))
2019 Init = Cleanups->getSubExpr();
2021 const auto *Ty = VD->getType().getTypePtr();
2026 if (TT->getDecl()->hasAttr<UnusedAttr>())
2032 if (
const auto *MTE = dyn_cast_or_null<MaterializeTemporaryExpr>(Init)) {
2033 if (MTE->getExtendingDecl()) {
2034 Ty = VD->getType().getNonReferenceType().getTypePtr();
2035 Init = MTE->getSubExpr()->IgnoreImplicitAsWritten();
2041 if (Ty->isIncompleteType() || Ty->isDependentType())
2046 Ty = Ty->getBaseElementTypeUnsafe();
2049 const TagDecl *Tag = TT->getDecl();
2050 if (Tag->
hasAttr<UnusedAttr>())
2053 if (
const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
2054 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
2059 dyn_cast<CXXConstructExpr>(Init);
2062 if (!CD->
isTrivial() && !RD->hasAttr<WarnUnusedAttr>() &&
2063 (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
2069 if (Init->isTypeDependent()) {
2071 if (!Ctor->isTrivial())
2077 if (isa<CXXUnresolvedConstructExpr>(Init))
2091 if (isa<LabelDecl>(D)) {
2112 for (
auto *TmpD : D->
decls()) {
2113 if (
const auto *T = dyn_cast<TypedefNameDecl>(TmpD))
2115 else if(
const auto *R = dyn_cast<RecordDecl>(TmpD))
2131 if (
auto *TD = dyn_cast<TypedefNameDecl>(D)) {
2142 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
2143 DiagID = diag::warn_unused_exception_param;
2144 else if (isa<LabelDecl>(D))
2145 DiagID = diag::warn_unused_label;
2147 DiagID = diag::warn_unused_variable;
2162 if (Ty->isReferenceType() || Ty->isDependentType())
2166 const TagDecl *Tag = TT->getDecl();
2167 if (Tag->
hasAttr<UnusedAttr>())
2171 if (
const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
2172 if (!RD->hasAttr<WarnUnusedAttr>())
2180 if (VD->
hasAttr<BlocksAttr>() && Ty->isObjCObjectPointerType())
2186 if (VD->
hasAttr<ObjCPreciseLifetimeAttr>() && Ty->isObjCObjectPointerType())
2193 assert(iter->getSecond() >= 0 &&
2194 "Found a negative number of references to a VarDecl");
2195 if (iter->getSecond() != 0)
2197 unsigned DiagID = isa<ParmVarDecl>(VD) ? diag::warn_unused_but_set_parameter
2198 : diag::warn_unused_but_set_variable;
2208 bool Diagnose =
false;
2212 Diagnose = L->
getStmt() ==
nullptr;
2221 if (S->decl_empty())
return;
2223 "Scope shouldn't contain decls!");
2230 std::optional<SourceLocation> PreviousDeclLoc;
2235 DeclDiags.push_back(LocAndDiag{Loc, std::nullopt, std::move(PD)});
2240 DeclDiags.push_back(LocAndDiag{Loc, PreviousDeclLoc, std::move(PD)});
2243 for (
auto *TmpD : S->decls()) {
2244 assert(TmpD &&
"This decl didn't get pushed??");
2246 assert(isa<NamedDecl>(TmpD) &&
"Decl isn't NamedDecl?");
2250 if (!S->hasUnrecoverableErrorOccurred()) {
2252 if (
const auto *RD = dyn_cast<RecordDecl>(D))
2254 if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
2263 if (
LabelDecl *LD = dyn_cast<LabelDecl>(D))
2269 auto ShadowI = ShadowingDecls.find(D);
2270 if (ShadowI != ShadowingDecls.end()) {
2271 if (
const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
2272 addDiagWithPrev(D->
getLocation(), FD->getLocation(),
2273 PDiag(diag::warn_ctor_parm_shadows_field)
2274 << D << FD << FD->getParent());
2276 ShadowingDecls.erase(ShadowI);
2280 llvm::sort(DeclDiags,
2281 [](
const LocAndDiag &LHS,
const LocAndDiag &RHS) ->
bool {
2286 return LHS.Loc.getRawEncoding() < RHS.Loc.getRawEncoding();
2288 for (
const LocAndDiag &D : DeclDiags) {
2290 if (D.PreviousDeclLoc)
2291 Diag(*D.PreviousDeclLoc, diag::note_previous_declaration);
2310 bool DoTypoCorrection) {
2315 if (!IDecl && DoTypoCorrection) {
2359 (S->getEntity() && S->getEntity()->isTransparentContext()) ||
2377 return "ucontext.h";
2379 llvm_unreachable(
"unhandled error kind");
2390 Parent->addDecl(CLinkageDecl);
2405 for (
unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2408 FT->getParamType(i),
nullptr,
SC_None,
nullptr);
2410 Params.push_back(parm);
2412 New->setParams(Params);
2424 Scope *S,
bool ForRedeclaration,
2431 if (!ForRedeclaration)
2443 Diag(Loc, diag::warn_implicit_decl_no_jmp_buf)
2450 Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
2456 if (!ForRedeclaration &&
2459 Diag(Loc,
LangOpts.C99 ? diag::ext_implicit_lib_function_decl_c99
2460 : diag::ext_implicit_lib_function_decl)
2463 Diag(Loc, diag::note_include_header_or_declare)
2500 while (Filter.hasNext()) {
2509 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2511 Decl->getUnderlyingType()))
2516 if (OldTD->getAnonDeclWithTypedefName(
true) &&
2517 Decl->getAnonDeclWithTypedefName())
2530 OldType = OldTypedef->getUnderlyingType();
2537 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2538 Diag(New->
getLocation(), diag::err_redefinition_variably_modified_typedef)
2546 if (OldType != NewType &&
2550 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2552 << Kind << NewType << OldType;
2576 switch (TypeID->getLength()) {
2580 if (!TypeID->isStr(
"id"))
2596 if (!TypeID->isStr(
"Class"))
2603 if (!TypeID->isStr(
"SEL"))
2630 if (
auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2631 auto *OldTag = OldTD->getAnonDeclWithTypedefName(
true);
2634 if (OldTag && NewTag &&
2635 OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
2640 if (OldTD->isModed())
2642 OldTD->getUnderlyingType());
2651 if (isa<EnumDecl>(NewTag)) {
2653 for (
auto *D : NewTag->decls()) {
2654 auto *ED = cast<EnumConstantDecl>(D);
2658 ED->getLexicalDeclContext()->removeDecl(ED);
2708 if (!isa<TypedefNameDecl>(Old))
2740 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
2741 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
2742 for (
const auto *i : D->
attrs())
2743 if (i->getKind() == A->
getKind()) {
2745 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
2750 if (OA && isa<OwnershipAttr>(i))
2751 return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
2759 if (
VarDecl *VD = dyn_cast<VarDecl>(D))
2760 return VD->isThisDeclarationADefinition();
2761 if (
TagDecl *TD = dyn_cast<TagDecl>(D))
2762 return TD->isCompleteDefinition() || TD->isBeingDefined();
2773 AlignedAttr *OldAlignasAttr =
nullptr;
2774 AlignedAttr *OldStrictestAlignAttr =
nullptr;
2775 unsigned OldAlign = 0;
2783 if (I->isAlignmentDependent())
2789 unsigned Align = I->getAlignment(S.
Context);
2790 if (Align > OldAlign) {
2792 OldStrictestAlignAttr = I;
2797 AlignedAttr *NewAlignasAttr =
nullptr;
2798 unsigned NewAlign = 0;
2800 if (I->isAlignmentDependent())
2806 unsigned Align = I->getAlignment(S.
Context);
2807 if (Align > NewAlign)
2811 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2819 if (OldAlign == 0 || NewAlign == 0) {
2821 if (
ValueDecl *VD = dyn_cast<ValueDecl>(New))
2832 if (OldAlign != NewAlign) {
2833 S.
Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2836 S.
Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2851 S.
Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2855 bool AnyAdded =
false;
2858 if (OldAlign > NewAlign) {
2859 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.
Context);
2860 Clone->setInherited(
true);
2866 if (OldAlignasAttr && !NewAlignasAttr &&
2867 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2868 AlignedAttr *Clone = OldAlignasAttr->clone(S.
Context);
2869 Clone->setInherited(
true);
2877#define WANT_DECL_MERGE_LOGIC
2878#include "clang/Sema/AttrParsedAttrImpl.inc"
2879#undef WANT_DECL_MERGE_LOGIC
2886 if (!DiagnoseMutualExclusions(S, D,
Attr))
2897 if (
const auto *AA = dyn_cast<AvailabilityAttr>(
Attr))
2899 D, *AA, AA->getPlatform(), AA->
isImplicit(), AA->getIntroduced(),
2900 AA->getDeprecated(), AA->getObsoleted(), AA->getUnavailable(),
2901 AA->getMessage(), AA->getStrict(), AA->getReplacement(), AMK,
2903 else if (
const auto *VA = dyn_cast<VisibilityAttr>(
Attr))
2905 else if (
const auto *VA = dyn_cast<TypeVisibilityAttr>(
Attr))
2907 else if (
const auto *ImportA = dyn_cast<DLLImportAttr>(
Attr))
2909 else if (
const auto *ExportA = dyn_cast<DLLExportAttr>(
Attr))
2911 else if (
const auto *EA = dyn_cast<ErrorAttr>(
Attr))
2913 else if (
const auto *FA = dyn_cast<FormatAttr>(
Attr))
2914 NewAttr = S.
mergeFormatAttr(D, *FA, FA->getType(), FA->getFormatIdx(),
2916 else if (
const auto *SA = dyn_cast<SectionAttr>(
Attr))
2918 else if (
const auto *CSA = dyn_cast<CodeSegAttr>(
Attr))
2920 else if (
const auto *IA = dyn_cast<MSInheritanceAttr>(
Attr))
2922 IA->getInheritanceModel());
2923 else if (
const auto *AA = dyn_cast<AlwaysInlineAttr>(
Attr))
2926 else if (S.
getLangOpts().CUDA && isa<FunctionDecl>(D) &&
2927 (isa<CUDAHostAttr>(
Attr) || isa<CUDADeviceAttr>(
Attr) ||
2928 isa<CUDAGlobalAttr>(
Attr))) {
2932 }
else if (
const auto *MA = dyn_cast<MinSizeAttr>(
Attr))
2934 else if (
const auto *SNA = dyn_cast<SwiftNameAttr>(
Attr))
2936 else if (
const auto *OA = dyn_cast<OptimizeNoneAttr>(
Attr))
2938 else if (
const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(
Attr))
2940 else if (isa<AlignedAttr>(
Attr))
2944 else if ((isa<DeprecatedAttr>(
Attr) || isa<UnavailableAttr>(
Attr)) &&
2949 else if (
const auto *UA = dyn_cast<UuidAttr>(
Attr))
2950 NewAttr = S.
mergeUuidAttr(D, *UA, UA->getGuid(), UA->getGuidDecl());
2951 else if (
const auto *IMA = dyn_cast<WebAssemblyImportModuleAttr>(
Attr))
2953 else if (
const auto *INA = dyn_cast<WebAssemblyImportNameAttr>(
Attr))
2955 else if (
const auto *TCBA = dyn_cast<EnforceTCBAttr>(
Attr))
2957 else if (
const auto *TCBLA = dyn_cast<EnforceTCBLeafAttr>(
Attr))
2959 else if (
const auto *BTFA = dyn_cast<BTFDeclTagAttr>(
Attr))
2961 else if (
const auto *NT = dyn_cast<HLSLNumThreadsAttr>(
Attr))
2964 else if (
const auto *SA = dyn_cast<HLSLShaderAttr>(
Attr))
2972 if (isa<MSInheritanceAttr>(NewAttr))
2981 if (
const TagDecl *TD = dyn_cast<TagDecl>(D))
2982 return TD->getDefinition();
2983 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2989 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2991 if (FD->isDefined(Def,
true))
2998 for (
const auto *Attribute : D->
attrs())
2999 if (Attribute->getKind() == Kind)
3011 if (!Def || Def == New)
3015 for (
unsigned I = 0, E = NewAttributes.size(); I != E;) {
3016 const Attr *NewAttribute = NewAttributes[I];
3018 if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {
3025 NewAttributes.erase(NewAttributes.begin() + I);
3030 VarDecl *VD = cast<VarDecl>(New);
3031 unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
3033 ? diag::err_alias_after_tentative
3034 : diag::err_redefinition;
3036 if (
Diag == diag::err_redefinition)
3046 if (
const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
3059 if (isa<C11NoReturnAttr>(NewAttribute)) {
3063 }
else if (isa<UuidAttr>(NewAttribute)) {
3067 }
else if (
const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
3068 if (AA->isAlignas()) {
3079 S.
Diag(NewAttribute->
getLocation(), diag::note_alignas_on_declaration)
3081 NewAttributes.erase(NewAttributes.begin() + I);
3085 }
else if (isa<LoaderUninitializedAttr>(NewAttribute)) {
3091 diag::err_loader_uninitialized_redeclaration);
3093 NewAttributes.erase(NewAttributes.begin() + I);
3097 }
else if (isa<SelectAnyAttr>(NewAttribute) &&
3098 cast<VarDecl>(New)->isInline() &&
3099 !cast<VarDecl>(New)->isInlineSpecified()) {
3106 }
else if (isa<OMPDeclareVariantAttr>(NewAttribute)) {
3114 diag::warn_attribute_precede_definition);
3116 NewAttributes.erase(NewAttributes.begin() + I);
3122 const ConstInitAttr *CIAttr,
3123 bool AttrBeforeInit) {
3130 std::string SuitableSpelling;
3132 SuitableSpelling = std::string(
3134 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3136 InsertLoc, {tok::l_square, tok::l_square,
3137 S.PP.getIdentifierInfo(
"clang"), tok::coloncolon,
3138 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3139 tok::r_square, tok::r_square}));
3140 if (SuitableSpelling.empty())
3142 InsertLoc, {tok::kw___attribute, tok::l_paren, tok::r_paren,
3143 S.PP.getIdentifierInfo(
"require_constant_initialization"),
3144 tok::r_paren, tok::r_paren}));
3145 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus20)
3146 SuitableSpelling =
"constinit";
3147 if (SuitableSpelling.empty() && S.
getLangOpts().CPlusPlus11)
3148 SuitableSpelling =
"[[clang::require_constant_initialization]]";
3149 if (SuitableSpelling.empty())
3150 SuitableSpelling =
"__attribute__((require_constant_initialization))";
3151 SuitableSpelling +=
" ";
3153 if (AttrBeforeInit) {
3156 assert(CIAttr->isConstinit() &&
"should not diagnose this for attribute");
3159 S.
Diag(CIAttr->getLocation(), diag::note_constinit_specified_here);
3163 S.
Diag(CIAttr->getLocation(),
3164 CIAttr->isConstinit() ? diag::err_constinit_added_too_late
3165 : diag::warn_require_const_init_added_too_late)
3168 << CIAttr->isConstinit()
3177 UsedAttr *NewAttr = OldAttr->clone(
Context);
3178 NewAttr->setInherited(
true);
3182 RetainAttr *NewAttr = OldAttr->clone(
Context);
3183 NewAttr->setInherited(
true);
3193 const auto *OldConstInit = Old->
getAttr<ConstInitAttr>();
3194 const auto *NewConstInit = New->
getAttr<ConstInitAttr>();
3195 if (
bool(OldConstInit) !=
bool(NewConstInit)) {
3196 const auto *OldVD = cast<VarDecl>(Old);
3197 auto *NewVD = cast<VarDecl>(New);
3203 (NewVD->hasInit() || NewVD->isThisDeclarationADefinition()))
3206 if (InitDecl == NewVD) {
3210 if (OldConstInit && OldConstInit->isConstinit())
3213 }
else if (NewConstInit) {
3217 if (InitDecl && InitDecl != NewVD) {
3220 NewVD->dropAttr<ConstInitAttr>();
3228 if (AsmLabelAttr *NewA = New->
getAttr<AsmLabelAttr>()) {
3229 if (AsmLabelAttr *OldA = Old->
getAttr<AsmLabelAttr>()) {
3230 if (!OldA->isEquivalent(NewA)) {
3233 Diag(OldA->getLocation(), diag::note_previous_declaration);
3235 }
else if (Old->
isUsed()) {
3239 << isa<FunctionDecl>(Old) << New->
getAttr<AsmLabelAttr>()->
getRange();
3244 if (
const auto *NewAbiTagAttr = New->
getAttr<AbiTagAttr>()) {
3245 if (
const auto *OldAbiTagAttr = Old->
getAttr<AbiTagAttr>()) {
3246 for (
const auto &NewTag : NewAbiTagAttr->tags()) {
3247 if (!llvm::is_contained(OldAbiTagAttr->tags(), NewTag)) {
3248 Diag(NewAbiTagAttr->getLocation(),
3249 diag::err_new_abi_tag_on_redeclaration)
3251 Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
3255 Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
3261 if (New->
hasAttr<SectionAttr>() && !Old->
hasAttr<SectionAttr>()) {
3262 if (
auto *VD = dyn_cast<VarDecl>(New)) {
3264 Diag(New->
getLocation(), diag::warn_attribute_section_on_redeclaration);
3271 const auto *NewCSA = New->
getAttr<CodeSegAttr>();
3272 if (NewCSA && !Old->
hasAttr<CodeSegAttr>() &&
3273 !NewCSA->isImplicit() && isa<CXXMethodDecl>(New)) {
3291 if (isa<DeprecatedAttr>(I) ||
3292 isa<UnavailableAttr>(I) ||
3293 isa<AvailabilityAttr>(I)) {
3308 if (isa<UsedAttr>(I) || isa<RetainAttr>(I))
3330 const CarriesDependencyAttr *CDA = newDecl->
getAttr<CarriesDependencyAttr>();
3331 if (CDA && !oldDecl->
hasAttr<CarriesDependencyAttr>()) {
3332 S.
Diag(CDA->getLocation(),
3333 diag::err_carries_dependency_missing_on_first_decl) << 1;
3341 diag::note_carries_dependency_missing_first_decl) << 1;
3347 bool foundAny = newDecl->
hasAttrs();
3356 cast<InheritableParamAttr>(I->clone(S.
Context));
3369 auto NoSizeInfo = [&Ctx](
QualType Ty) {
3370 if (Ty->isIncompleteArrayType() || Ty->isPointerType())
3378 if (NoSizeInfo(Old) && NoSizeInfo(New))
3410 if (*Oldnullability != *Newnullability) {
3411 S.
Diag(NewParam->
getLocation(), diag::warn_mismatched_nullability_attr)
3430 const auto *OldParamDT = dyn_cast<DecayedType>(OldParam->
getType());
3431 const auto *NewParamDT = dyn_cast<DecayedType>(NewParam->
getType());
3432 if (OldParamDT && NewParamDT &&
3433 OldParamDT->getPointeeType() == NewParamDT->getPointeeType()) {
3434 QualType OldParamOT = OldParamDT->getOriginalType();
3435 QualType NewParamOT = NewParamDT->getOriginalType();
3438 << NewParam << NewParamOT;
3449struct GNUCompatibleParamWarning {
3459template <
typename T>
3460static std::pair<diag::kind, SourceLocation>
3464 if (Old->isThisDeclarationADefinition())
3465 PrevDiag = diag::note_previous_definition;
3466 else if (Old->isImplicit()) {
3467 PrevDiag = diag::note_previous_implicit_declaration;
3468 if (
const auto *FD = dyn_cast<FunctionDecl>(Old)) {
3469 if (FD->getBuiltinID())
3470 PrevDiag = diag::note_previous_builtin_declaration;
3473 OldLocation = New->getLocation();
3475 PrevDiag = diag::note_previous_declaration;
3476 return std::make_pair(PrevDiag, OldLocation);
3484 return ((FD->
hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
3485 !LangOpts.CPlusPlus &&
3497template <
typename T>
3511template<
typename T>
static bool isExternC(T *D) {
return D->isExternC(); }
3518template<
typename ExpectedDecl>
3540 !Old->getDeclContext()->getRedeclContext()->Equals(
3541 New->getDeclContext()->getRedeclContext()) &&
3546 S.
Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
3559 const auto *AttrA = A->
getAttr<PassObjectSizeAttr>();
3560 const auto *AttrB = B->
getAttr<PassObjectSizeAttr>();
3563 return AttrA && AttrB && AttrA->getType() == AttrB->getType() &&
3564 AttrA->isDynamic() == AttrB->isDynamic();
3590 if (NamedDC->Equals(SemaDC))
3593 assert((NamedDC->InEnclosingNamespaceSetOf(SemaDC) ||
3595 "unexpected context for redeclaration");
3606 if (
auto *FD = dyn_cast<FunctionDecl>(NewD))
3607 FixSemaDC(FD->getDescribedFunctionTemplate());
3608 else if (
auto *VD = dyn_cast<VarDecl>(NewD))
3609 FixSemaDC(VD->getDescribedVarTemplate());
3624 bool MergeTypeWithOld,
bool NewDeclIsDefn) {
3631 Diag(Shadow->getTargetDecl()->getLocation(),
3632 diag::note_using_decl_target);
3633 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
3642 if (checkUsingShadowRedecl<FunctionTemplateDecl>(*
this, Shadow,
3645 OldD = Old = cast<FunctionTemplateDecl>(Shadow->getTargetDecl())
3648 if (checkUsingShadowRedecl<FunctionDecl>(*
this, Shadow, New))
3650 OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
3678 std::tie(PrevDiag, OldLocation) =
3685 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
3692 Diag(OldLocation, PrevDiag);
3695 Diag(OldLocation, PrevDiag);
3700 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
3701 if (!Old->
hasAttr<InternalLinkageAttr>()) {
3705 New->
dropAttr<InternalLinkageAttr>();
3708 if (
auto *EA = New->
getAttr<ErrorAttr>()) {
3709 if (!Old->
hasAttr<ErrorAttr>()) {
3710 Diag(EA->getLocation(), diag::err_attribute_missing_on_first_decl) << EA;
3720 bool OldOvl = Old->
hasAttr<OverloadableAttr>();
3731 const Decl *DiagOld = Old;
3733 auto OldIter = llvm::find_if(Old->
redecls(), [](
const Decl *D) {
3734 const auto *A = D->getAttr<OverloadableAttr>();
3735 return A && !A->isImplicit();
3739 DiagOld = OldIter == Old->
redecls_end() ? nullptr : *OldIter;
3744 diag::note_attribute_overloadable_prev_overload)
3769 const FunctionType *OldType = cast<FunctionType>(OldQType);
3770 const FunctionType *NewType = cast<FunctionType>(NewQType);
3773 bool RequiresAdjustment =
false;
3775 if (OldTypeInfo.
getCC() != NewTypeInfo.
getCC()) {
3781 if (!NewCCExplicit) {
3785 RequiresAdjustment =
true;
3797 RequiresAdjustment =
true;
3804 << (!FirstCCExplicit ?
"" :
3808 Diag(
First->getLocation(), diag::note_previous_declaration);
3816 RequiresAdjustment =
true;
3826 Diag(OldLocation, diag::note_previous_declaration);
3831 RequiresAdjustment =
true;
3838 <<
"'ns_returns_retained'";
3839 Diag(OldLocation, diag::note_previous_declaration);
3844 RequiresAdjustment =
true;
3850 AnyX86NoCallerSavedRegistersAttr *
Attr =
3851 New->
getAttr<AnyX86NoCallerSavedRegistersAttr>();
3853 Diag(OldLocation, diag::note_previous_declaration);
3858 RequiresAdjustment =
true;
3861 if (RequiresAdjustment) {
3871 !New->
hasAttr<GNUInlineAttr>() &&
3880 if (New->
hasAttr<GNUInlineAttr>() &&
3891 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)
4033 if (
const auto *NRA = New->
getAttr<CXX11NoReturnAttr>())
4034 if (!Old->
hasAttr<CXX11NoReturnAttr>()) {
4035 Diag(NRA->getLocation(), diag::err_attribute_missing_on_first_decl)
4044 const CarriesDependencyAttr *CDA = New->
getAttr<CarriesDependencyAttr>();
4045 if (CDA && !Old->
hasAttr<CarriesDependencyAttr>()) {
4046 Diag(CDA->getLocation(),
4047 diag::err_carries_dependency_missing_on_first_decl) << 0;
4049 diag::note_carries_dependency_missing_first_decl) << 0;
4058 QualType OldQTypeForComparison = OldQType;
4063 OldQTypeForComparison =
QualType(OldTypeForComparison, 0);
4078 Diag(OldLocation, PrevDiag);
4080 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4081 Diag(OldLocation, PrevDiag);
4152 bool IsWithoutProtoADef =
false, IsWithProtoADef =
false;
4153 if (WithoutProto == New)
4154 IsWithoutProtoADef = NewDeclIsDefn;
4156 IsWithProtoADef = NewDeclIsDefn;
4158 diag::warn_non_prototype_changes_behavior)
4159 << IsWithoutProtoADef << (WithoutProto->
getNumParams() ? 0 : 1)
4160 << (WithoutProto == Old) << IsWithProtoADef;
4170 !IsWithoutProtoADef)
4180 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
4181 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
4184 assert(!OldProto->hasExceptionSpec() &&
"Exception spec in C");
4186 OldProto->getParamTypes(),
4187 OldProto->getExtProtoInfo());
4193 for (
const auto &ParamType : OldProto->param_types()) {
4196 ParamType,
nullptr,
SC_None,
nullptr);
4199 Params.push_back(Param);
4202 New->setParams(Params);
4238 NewProto->getReturnType());
4239 bool LooseCompatible = !MergedReturn.
isNull();
4241 LooseCompatible && Idx != End; ++Idx) {
4245 NewProto->getParamType(Idx))) {
4246 ArgTypes.push_back(NewParm->
getType());
4250 GNUCompatibleParamWarning Warn = { OldParm, NewParm,
4251 NewProto->getParamType(Idx) };
4252 Warnings.push_back(Warn);
4253 ArgTypes.push_back(NewParm->
getType());
4255 LooseCompatible =
false;
4258 if (LooseCompatible) {
4259 for (
unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
4260 Diag(Warnings[Warn].NewParm->getLocation(),
4261 diag::ext_param_promoted_not_compatible_with_prototype)
4262 << Warnings[Warn].PromotedType
4263 << Warnings[Warn].OldParm->getType();
4264 if (Warnings[Warn].OldParm->getLocation().isValid())
4265 Diag(Warnings[Warn].OldParm->getLocation(),
4266 diag::note_previous_declaration);
4269 if (MergeTypeWithOld)
4289 Diag(OldLocation, diag::note_previous_builtin_declaration)
4294 PrevDiag = diag::note_previous_builtin_declaration;
4298 Diag(OldLocation, PrevDiag) << Old << Old->
getType();
4312 Scope *S,
bool MergeTypeWithOld) {
4327 for (
unsigned i = 0, e = New->
getNumParams(); i != e; ++i) {
4341 if (!Merged.isNull() && MergeTypeWithOld)
4364 ni != ne && oi != oe; ++ni, ++oi)
4374 ? diag::err_redefinition_different_type
4375 : diag::err_redeclaration_different_type)
4380 std::tie(PrevDiag, OldLocation)
4382 S.
Diag(OldLocation, PrevDiag);
4394 bool MergeTypeWithOld) {
4422 QualType PrevVDTy = PrevVD->getType();
4476 if (MergeTypeWithOld)
4522 if (!shouldLinkPossiblyHiddenDecl(
Previous, New))
4532 OldTemplate = dyn_cast<VarTemplateDecl>(
Previous.getFoundDecl());
4536 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4537 if (checkUsingShadowRedecl<VarTemplateDecl>(*
this, Shadow, NewTemplate))
4540 Old = dyn_cast<VarDecl>(
Previous.getFoundDecl());
4543 dyn_cast<UsingShadowDecl>(
Previous.getRepresentativeDecl()))
4544 if (checkUsingShadowRedecl<VarDecl>(*
this, Shadow, New))
4581 if (New->
hasAttr<WeakImportAttr>() &&
4583 !Old->
hasAttr<WeakImportAttr>()) {
4590 if (
const auto *ILA = New->
getAttr<InternalLinkageAttr>())
4591 if (!Old->
hasAttr<InternalLinkageAttr>()) {
4595 New->
dropAttr<InternalLinkageAttr>();
4600 if (MostRecent != Old) {
4613 std::tie(PrevDiag, OldLocation) =
4623 Diag(OldLocation, PrevDiag);
4627 Diag(OldLocation, PrevDiag);
4646 Diag(OldLocation, PrevDiag);
4654 Diag(OldLocation, PrevDiag);
4660 Diag(OldLocation, PrevDiag);
4676 Diag(OldLocation, PrevDiag);
4686 Diag(Def->getLocation(), diag::note_previous_definition);
4700 Diag(OldLocation, PrevDiag);
4703 Diag(OldLocation, PrevDiag);
4711 Diag(OldLocation, PrevDiag);
4721 diag::warn_deprecated_redundant_constexpr_static_def);
4730 Diag(New->
getLocation(), diag::err_different_language_linkage) << New;
4731 Diag(OldLocation, PrevDiag);
4761 StringRef HdrFilename =
4764 auto noteFromModuleOrInclude = [&](
Module *Mod,
4770 if (IncLoc.isValid()) {
4772 Diag(IncLoc, diag::note_redefinition_modules_same_file)
4778 Diag(IncLoc, diag::note_redefinition_include_same_file)
4779 << HdrFilename.str();
4789 if (FNew == FOld && FNewDecLoc.second == FOldDecLoc.second) {
4797 if (FOld && !HSI.isFileMultipleIncludeGuarded(FOld))
4815 isa<VarTemplateSpecializationDecl>(New) ||
4854 ? S->getMSCurManglingNumber()
4855 : S->getMSLastManglingNumber();
4862 if (isa<CXXRecordDecl>(Tag->
getParent())) {
4877 Decl *ManglingContextDecl;
4878 std::tie(MCtx, ManglingContextDecl) =
4888struct NonCLikeKind {
4900 explicit operator bool() {
return Kind !=
None; }
4908 return {NonCLikeKind::Invalid, {}};
4915 return {NonCLikeKind::BaseClass,
4927 if (
auto *FD = dyn_cast<FieldDecl>(D)) {
4928 if (FD->hasInClassInitializer()) {
4929 auto *Init = FD->getInClassInitializer();
4930 return {NonCLikeKind::DefaultMemberInit,
4938 if (isa<FriendDecl>(D))
4943 if (isa<StaticAssertDecl>(D) || isa<IndirectFieldDecl>(D) ||
4946 auto *MemberRD = dyn_cast<CXXRecordDecl>(D);
4954 if (MemberRD->isLambda())
4955 return {NonCLikeKind::Lambda, MemberRD->getSourceRange()};
4959 if (MemberRD->isThisDeclarationADefinition()) {
4965 return {
Invalid ? NonCLikeKind::Invalid : NonCLikeKind::None, {}};