47#include "llvm/ADT/ArrayRef.h"
48#include "llvm/ADT/STLExtras.h"
49#include "llvm/ADT/ScopeExit.h"
50#include "llvm/ADT/SmallString.h"
51#include "llvm/ADT/StringExtras.h"
52#include "llvm/Support/SaveAndRestore.h"
69class CheckDefaultArgumentVisitor
72 const Expr *DefaultArg;
75 CheckDefaultArgumentVisitor(
Sema &S,
const Expr *DefaultArg)
76 : S(S), DefaultArg(DefaultArg) {}
81 bool VisitLambdaExpr(
const LambdaExpr *Lambda);
86bool CheckDefaultArgumentVisitor::VisitExpr(
const Expr *
Node) {
87 bool IsInvalid =
false;
88 for (
const Stmt *SubStmt :
Node->children())
90 IsInvalid |= Visit(SubStmt);
97bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(
const DeclRefExpr *DRE) {
100 if (!isa<VarDecl, BindingDecl>(
Decl))
103 if (
const auto *Param = dyn_cast<ParmVarDecl>(
Decl)) {
114 diag::err_param_default_argument_references_param)
115 << Param->getDeclName() << DefaultArg->getSourceRange();
116 }
else if (
auto *VD =
Decl->getPotentiallyDecomposedVarDecl()) {
131 diag::err_param_default_argument_references_local)
138bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(
const CXXThisExpr *ThisE) {
143 diag::err_param_default_argument_references_this)
147bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(
152 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E)) {
153 E = OVE->getSourceExpr();
154 assert(E &&
"pseudo-object binding without source expression?");
162bool CheckDefaultArgumentVisitor::VisitLambdaExpr(
const LambdaExpr *Lambda) {
171 return S.
Diag(LC.getLocation(), diag::err_lambda_capture_default_arg);
173 auto *D = cast<VarDecl>(LC.getCapturedVar());
174 Invalid |= Visit(D->getInit());
206 llvm_unreachable(
"should not see unresolved exception specs here");
235 "should not generate implicit declarations for dependent cases");
239 assert(EST ==
EST_Dynamic &&
"EST case not considered earlier.");
241 "Shouldn't collect exceptions when throw-all is guaranteed.");
246 Exceptions.push_back(E);
274 if (Self->canThrow(S))
281 diag::err_typecheck_decl_incomplete_type))
300 CheckCompletedExpr(Arg, EqualLoc);
313 UnparsedDefaultArgInstantiationsMap::iterator InstPos
316 for (
unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
317 InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
330 if (!param || !DefaultArg)
338 Diag(EqualLoc, diag::err_param_default_argument)
351 Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
365 CheckDefaultArgumentVisitor DefaultArgChecker(*
this, DefaultArg);
366 if (DefaultArgChecker.Visit(DefaultArg))
403 Param->
getType().getNonReferenceType());
425 if (MightBeFunction) {
429 MightBeFunction =
false;
432 for (
unsigned argIdx = 0, e = chunk.
Fun.
NumParams; argIdx != e;
436 std::unique_ptr<CachedTokens> Toks =
439 if (Toks->size() > 1)
441 Toks->back().getLocation());
453 MightBeFunction =
false;
460 return P->hasDefaultArg() && !P->hasInheritedDefaultArg();
481 for (; PrevForDefaultArgs;
529 for (
unsigned p = 0, NumParams = PrevForDefaultArgs
532 p < NumParams; ++p) {
536 bool OldParamHasDfl = OldParam ? OldParam->
hasDefaultArg() :
false;
539 if (OldParamHasDfl && NewParamHasDfl) {
540 unsigned DiagDefaultParamID =
541 diag::err_param_default_argument_redefinition;
556 DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
574 for (
auto Older = PrevForDefaultArgs;
576 Older = Older->getPreviousDecl();
577 OldParam = Older->getParamDecl(p);
582 }
else if (OldParamHasDfl) {
600 }
else if (NewParamHasDfl) {
604 diag::err_param_default_argument_template_redecl)
607 diag::note_template_prev_declaration)
638 if (Record->getDescribedClassTemplate())
640 else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
647 diag::err_param_default_argument_member_template_redecl)
657 if (isa<CXXConstructorDecl>(New) &&
661 if (NewSM != OldSM) {
664 Diag(NewParam->
getLocation(), diag::err_default_arg_makes_ctor_special)
699 if (isa<CXXDeductionGuideDecl>(New) &&
711 Diag(New->
getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
732 ? diag::warn_cxx23_placeholder_var_definition
733 : diag::ext_placeholder_var_definition);
751 if (!TemplateParamLists.empty()) {
754 Diag(TemplateParamLists.front()->getTemplateLoc(),
755 diag::err_decomp_decl_template);
761 ? diag::ext_decomp_decl
763 ? diag::ext_decomp_decl_cond
764 : diag::warn_cxx14_compat_decomp_decl)
787 if (
auto SCS = DS.getStorageClassSpec()) {
790 CPlusPlus20SpecifierLocs.push_back(DS.getStorageClassSpecLoc());
793 BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
796 if (
auto TSCS = DS.getThreadStorageClassSpec()) {
798 CPlusPlus20SpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
800 if (DS.hasConstexprSpecifier()) {
801 BadSpecifiers.push_back(
803 BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());
805 if (DS.isInlineSpecified()) {
806 BadSpecifiers.push_back(
"inline");
807 BadSpecifierLocs.push_back(DS.getInlineSpecLoc());
810 if (!BadSpecifiers.empty()) {
811 auto &&Err =
Diag(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);
812 Err << (
int)BadSpecifiers.size()
813 << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(),
" ");
816 for (
auto Loc : BadSpecifierLocs)
818 }
else if (!CPlusPlus20Specifiers.empty()) {
819 auto &&Warn =
Diag(CPlusPlus20SpecifierLocs.front(),
821 ? diag::warn_cxx17_compat_decomp_decl_spec
822 : diag::ext_decomp_decl_spec);
823 Warn << (
int)CPlusPlus20Specifiers.size()
824 << llvm::join(CPlusPlus20Specifiers.begin(),
825 CPlusPlus20Specifiers.end(),
" ");
826 for (
auto Loc : CPlusPlus20SpecifierLocs)
838 Diag(DS.getVolatileSpecLoc(),
839 diag::warn_deprecated_volatile_structured_binding);
859 ? diag::err_decomp_decl_parens
860 : diag::err_decomp_decl_type)
871 if (DS.isConstrainedAuto()) {
874 "No other template kind should be possible for a constrained auto");
892 assert(VarName &&
"Cannot have an unnamed binding declaration");
901 Previous.getFoundDecl()->isTemplateParameter()) {
933 auto *Old =
Previous.getRepresentativeDecl();
934 Diag(B.NameLoc, diag::err_redefinition) << B.Name;
935 Diag(Old->getLocation(), diag::note_previous_definition);
953 bool AddToScope =
true;
972 if ((int64_t)
Bindings.size() != NumElems) {
973 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
986 E = GetInit(Loc, E.
get(), I++);
989 B->setBinding(ElemType, E.
get());
998 const llvm::APSInt &NumElems,
1001 S,
Bindings, Src, DecompType, NumElems, ElemType,
1032 S,
Bindings, Src, DecompType, llvm::APSInt::get(2),
1036 return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
1044 llvm::raw_svector_ostream
OS(SS);
1056 return std::string(
OS.str());
1063 auto DiagnoseMissing = [&] {
1073 return DiagnoseMissing();
1083 return DiagnoseMissing();
1084 if (
Result.isAmbiguous())
1089 Result.suppressDiagnostics();
1091 S.
Diag(Loc, diag::err_std_type_trait_not_class_template) << Trait;
1103 Loc, TraitTy, DiagID,
1110 assert(RD &&
"specialization of class template is not a class?");
1129namespace {
enum class IsTupleLike { TupleLike, NotTupleLike,
Error }; }
1132 llvm::APSInt &Size) {
1147 return IsTupleLike::NotTupleLike;
1156 : R(R), Args(Args) {}
1159 return S.
Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
1163 } Diagnoser(R, Args);
1168 return IsTupleLike::Error;
1172 return IsTupleLike::Error;
1174 return IsTupleLike::TupleLike;
1189 S, R, Loc,
"tuple_element", Args,
1190 diag::err_decomp_decl_std_tuple_element_not_specialized))
1196 S.
Diag(Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
1208struct InitializingBinding {
1217 ~InitializingBinding() {
1226 const llvm::APSInt &TupleSize) {
1227 if ((int64_t)
Bindings.size() != TupleSize) {
1228 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1244 bool UseMemberGet =
false;
1254 dyn_cast<FunctionTemplateDecl>(D->getUnderlyingDecl())) {
1256 if (TPL->
size() != 0 &&
1257 isa<NonTypeTemplateParmDecl>(TPL->
getParam(0))) {
1259 UseMemberGet =
true;
1268 InitializingBinding InitContext(S, B);
1291 MemberGet, &Args,
nullptr);
1325 B->getDeclName().getAsIdentifierInfo(), RefType,
1329 RefVD->setImplicit();
1331 RefVD->setInlineSpecified();
1332 RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);
1337 E = Seq.
Perform(S, Entity, Kind, Init);
1343 RefVD->setInit(E.
get());
1352 B->setBinding(T, E.
get());
1367 return Specifier->getType()->getAsCXXRecordDecl()->hasDirectFields();
1376 ClassWithFields = RD;
1388 for (
auto &
P : Paths) {
1392 BestPath->back().Base->getType())) {
1394 S.
Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1395 <<
false << RD << BestPath->back().Base->getType()
1396 <<
P.back().Base->getType();
1398 }
else if (
P.Access < BestPath->
Access) {
1404 QualType BaseType = BestPath->back().Base->getType();
1406 S.
Diag(Loc, diag::err_decomp_decl_ambiguous_base)
1413 *BestPath, diag::err_decomp_decl_inaccessible_base);
1424 S.
Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1425 << (ClassWithFields == RD) << RD << ClassWithFields
1426 << Paths.front().back().Base->getType();
1437 diag::err_incomplete_type))
1449 auto DiagnoseBadNumberOfBindings = [&]() ->
bool {
1450 unsigned NumFields = llvm::count_if(
1451 RD->
fields(), [](
FieldDecl *FD) { return !FD->isUnnamedBitfield(); });
1452 assert(
Bindings.size() != NumFields);
1453 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1463 for (
auto *FD : RD->
fields()) {
1464 if (FD->isUnnamedBitfield())
1469 if (!FD->getDeclName()) {
1476 if (FD->isAnonymousStructOrUnion()) {
1479 S.
Diag(FD->getLocation(), diag::note_declared_at);
1488 return DiagnoseBadNumberOfBindings();
1499 BasePair.
getAccess(), FD->getAccess())));
1522 if (FD->isMutable())
1528 return DiagnoseBadNumberOfBindings();
1570 llvm::APSInt TupleSize(32);
1572 case IsTupleLike::Error:
1576 case IsTupleLike::TupleLike:
1581 case IsTupleLike::NotTupleLike:
1590 << DD << !RD << DecompType;
1613 "Should only be called if types are otherwise the same.");
1624 NewType =
P->getPointeeType();
1657 if (FTD->isMemberSpecialization())
1681 diag::err_param_default_argument_missing_name)
1685 diag::err_param_default_argument_missing);
1693template <
typename... Ts>
1703 std::forward<Ts>(DiagArgs)...);
1709 llvm_unreachable(
"unknown CheckConstexprKind");
1718 T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1726 SemaRef.
Diag(Loc, diag::note_constexpr_dtor_subobject)
1734 if (!Check(B.getBaseTypeLoc(), B.getType(),
nullptr))
1737 if (!Check(FD->getLocation(), FD->getType(), FD))
1747 unsigned ArgIndex = 0;
1750 e = FT->param_type_end();
1751 i != e; ++i, ++ArgIndex) {
1753 assert(PD &&
"null in a parameter list");
1756 diag::err_constexpr_non_literal_param, ArgIndex + 1,
1769 diag::err_constexpr_non_literal_return,
1785 default: llvm_unreachable(
"Invalid tag kind for record diagnostic!");
1816 << isa<CXXConstructorDecl>(NewFD)
1818 for (
const auto &I : RD->
vbases())
1819 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
1820 << I.getSourceRange();
1825 if (!isa<CXXConstructorDecl>(NewFD)) {
1830 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
1834 Diag(Method->
getLocation(), diag::warn_cxx17_compat_constexpr_virtual);
1847 if (WrittenVirtual != Method)
1849 diag::note_overridden_virtual_function);
1859 if (
auto *Dtor = dyn_cast<CXXDestructorDecl>(NewFD)) {
1863 if (!Dtor->getParent()->defaultedDestructorIsConstexpr()) {
1877 "CheckConstexprFunctionDefinition called on function with no body");
1892 for (
const auto *DclIt : DS->
decls()) {
1893 switch (DclIt->getKind()) {
1894 case Decl::StaticAssert:
1896 case Decl::UsingShadow:
1897 case Decl::UsingDirective:
1898 case Decl::UnresolvedUsingTypename:
1899 case Decl::UnresolvedUsingValue:
1900 case Decl::UsingEnum:
1908 case Decl::TypeAlias: {
1911 const auto *TN = cast<TypedefNameDecl>(DclIt);
1912 if (TN->getUnderlyingType()->isVariablyModifiedType()) {
1915 TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
1918 << isa<CXXConstructorDecl>(Dcl);
1926 case Decl::CXXRecord:
1928 if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) {
1932 ? diag::warn_cxx11_compat_constexpr_type_definition
1933 : diag::ext_constexpr_type_definition)
1934 << isa<CXXConstructorDecl>(Dcl);
1941 case Decl::EnumConstant:
1942 case Decl::IndirectField:
1949 case Decl::Decomposition: {
1954 const auto *VD = cast<VarDecl>(DclIt);
1955 if (VD->isThisDeclarationADefinition()) {
1956 if (VD->isStaticLocal()) {
1958 SemaRef.
Diag(VD->getLocation(),
1960 ? diag::warn_cxx20_compat_constexpr_var
1961 : diag::ext_constexpr_static_var)
1962 << isa<CXXConstructorDecl>(Dcl)
1968 if (SemaRef.
LangOpts.CPlusPlus23) {
1970 diag::warn_cxx20_compat_constexpr_var,
1971 isa<CXXConstructorDecl>(Dcl),
1974 SemaRef, Kind, VD->getLocation(), VD->getType(),
1975 diag::err_constexpr_local_var_non_literal_type,
1976 isa<CXXConstructorDecl>(Dcl))) {
1979 if (!VD->getType()->isDependentType() &&
1980 !VD->hasInit() && !VD->isCXXForRangeDecl()) {
1985 ? diag::warn_cxx17_compat_constexpr_local_var_no_init
1986 : diag::ext_constexpr_local_var_no_init)
1987 << isa<CXXConstructorDecl>(Dcl);
1995 SemaRef.
Diag(VD->getLocation(),
1997 ? diag::warn_cxx11_compat_constexpr_local_var
1998 : diag::ext_constexpr_local_var)
1999 << isa<CXXConstructorDecl>(Dcl);
2006 case Decl::NamespaceAlias:
2007 case Decl::Function:
2016 SemaRef.
Diag(DS->
getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
2017 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval();
2042 llvm::SmallSet<Decl*, 16> &Inits,
2050 if (Field->isInvalidDecl())
2053 if (Field->isUnnamedBitfield())
2059 if (Field->isAnonymousStructOrUnion() &&
2060 (Field->getType()->isUnionType()
2061 ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
2062 : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
2065 if (!Inits.count(Field)) {
2070 ? diag::warn_cxx17_compat_constexpr_ctor_missing_init
2071 : diag::ext_constexpr_ctor_missing_init);
2074 SemaRef.
Diag(Field->getLocation(),
2075 diag::note_constexpr_ctor_missing_init);
2079 }
else if (Field->isAnonymousStructOrUnion()) {
2081 for (
auto *I : RD->
fields())
2084 if (!RD->
isUnion() || Inits.count(I))
2101 switch (S->getStmtClass()) {
2102 case Stmt::NullStmtClass:
2106 case Stmt::DeclStmtClass:
2116 case Stmt::ReturnStmtClass:
2118 if (isa<CXXConstructorDecl>(Dcl)) {
2121 Cxx1yLoc = S->getBeginLoc();
2125 ReturnStmts.push_back(S->getBeginLoc());
2128 case Stmt::AttributedStmtClass:
2132 SemaRef, Dcl, cast<AttributedStmt>(S)->getSubStmt(), ReturnStmts,
2133 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind);
2135 case Stmt::CompoundStmtClass: {
2138 Cxx1yLoc = S->getBeginLoc();
2141 for (
auto *BodyIt : CompStmt->
body()) {
2143 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2149 case Stmt::IfStmtClass: {
2152 Cxx1yLoc = S->getBeginLoc();
2154 IfStmt *If = cast<IfStmt>(S);
2156 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2160 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2165 case Stmt::WhileStmtClass:
2166 case Stmt::DoStmtClass:
2167 case Stmt::ForStmtClass:
2168 case Stmt::CXXForRangeStmtClass:
2169 case Stmt::ContinueStmtClass:
2175 Cxx1yLoc = S->getBeginLoc();
2176 for (
Stmt *SubStmt : S->children()) {
2179 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2184 case Stmt::SwitchStmtClass:
2185 case Stmt::CaseStmtClass:
2186 case Stmt::DefaultStmtClass:
2187 case Stmt::BreakStmtClass:
2191 Cxx1yLoc = S->getBeginLoc();
2192 for (
Stmt *SubStmt : S->children()) {
2195 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2200 case Stmt::LabelStmtClass:
2201 case Stmt::GotoStmtClass:
2203 Cxx2bLoc = S->getBeginLoc();
2204 for (
Stmt *SubStmt : S->children()) {
2207 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2212 case Stmt::GCCAsmStmtClass:
2213 case Stmt::MSAsmStmtClass:
2215 case Stmt::CXXTryStmtClass:
2217 Cxx2aLoc = S->getBeginLoc();
2218 for (
Stmt *SubStmt : S->children()) {
2221 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2226 case Stmt::CXXCatchStmtClass:
2230 SemaRef, Dcl, cast<CXXCatchStmt>(S)->getHandlerBlock(), ReturnStmts,
2231 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2241 Cxx1yLoc = S->getBeginLoc();
2246 SemaRef.
Diag(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
2247 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval();
2262 if (isa<CXXTryStmt>(Body)) {
2284 ? diag::ext_constexpr_function_try_block_cxx20
2285 : diag::warn_cxx17_compat_constexpr_function_try_block)
2286 << isa<CXXConstructorDecl>(Dcl);
2300 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2311 }
else if (Cxx2bLoc.
isValid()) {
2312 SemaRef.
Diag(Cxx2bLoc,
2314 ? diag::warn_cxx20_compat_constexpr_body_invalid_stmt
2315 : diag::ext_constexpr_body_invalid_stmt_cxx23)
2316 << isa<CXXConstructorDecl>(Dcl);
2317 }
else if (Cxx2aLoc.
isValid()) {
2318 SemaRef.
Diag(Cxx2aLoc,
2320 ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
2321 : diag::ext_constexpr_body_invalid_stmt_cxx20)
2322 << isa<CXXConstructorDecl>(Dcl);
2323 }
else if (Cxx1yLoc.
isValid()) {
2324 SemaRef.
Diag(Cxx1yLoc,
2326 ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
2327 : diag::ext_constexpr_body_invalid_stmt)
2328 << isa<CXXConstructorDecl>(Dcl);
2332 = dyn_cast<CXXConstructorDecl>(Dcl)) {
2341 if (Constructor->getNumCtorInitializers() == 0 &&
2347 ? diag::warn_cxx17_compat_constexpr_union_ctor_no_init
2348 : diag::ext_constexpr_union_ctor_no_init);
2353 }
else if (!Constructor->isDependentContext() &&
2354 !Constructor->isDelegatingConstructor()) {
2355 assert(RD->
getNumVBases() == 0 &&
"constexpr ctor with virtual bases");
2359 bool AnyAnonStructUnionMembers =
false;
2360 unsigned Fields = 0;
2362 E = RD->
field_end(); I != E; ++I, ++Fields) {
2363 if (I->isAnonymousStructOrUnion()) {
2364 AnyAnonStructUnionMembers =
true;
2372 if (AnyAnonStructUnionMembers ||
2373 Constructor->getNumCtorInitializers() != RD->
getNumBases() + Fields) {
2377 llvm::SmallSet<Decl*, 16> Inits;
2378 for (
const auto *I: Constructor->inits()) {
2382 Inits.insert(ID->chain_begin(), ID->chain_end());
2385 bool Diagnosed =
false;
2386 for (
auto *I : RD->
fields())
2393 if (ReturnStmts.empty()) {
2404 OK ? diag::warn_cxx11_compat_constexpr_body_no_return
2405 : diag::err_constexpr_body_no_return)
2419 }
else if (ReturnStmts.size() > 1) {
2425 ? diag::warn_cxx11_compat_constexpr_body_multiple_return
2426 : diag::ext_constexpr_body_multiple_return);
2427 for (
unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
2428 SemaRef.
Diag(ReturnStmts[I],
2429 diag::note_constexpr_body_previous_return);
2457 diag::ext_constexpr_function_never_constant_expr)
2458 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval();
2459 for (
size_t I = 0, N =
Diags.size(); I != N; ++I)
2477 Diag(it->second, diag::err_immediate_function_used_before_definition)
2490 "expected an immediate function");
2491 assert(FD->
hasBody() &&
"expected the function to have a body");
2492 struct ImmediateEscalatingExpressionsVisitor
2499 bool ImmediateFnIsConstructor;
2504 : SemaRef(SemaRef), ImmediateFn(FD),
2505 ImmediateFnIsConstructor(isa<CXXConstructorDecl>(FD)) {}
2507 bool shouldVisitImplicitCode()
const {
return true; }
2508 bool shouldVisitLambdaBody()
const {
return false; }
2513 if (CurrentConstructor && CurrentInit) {
2521 SemaRef.
Diag(Loc, diag::note_immediate_function_reason)
2522 << ImmediateFn << Fn << Fn->
isConsteval() << IsCall
2523 << isa<CXXConstructorDecl>(Fn) << ImmediateFnIsConstructor
2524 << (InitializedField !=
nullptr)
2525 << (CurrentInit && !CurrentInit->
isWritten())
2526 << InitializedField << Range;
2528 bool TraverseCallExpr(
CallExpr *E) {
2529 if (
const auto *DR =
2531 DR && DR->isImmediateEscalating()) {
2537 if (!getDerived().TraverseStmt(A))
2544 if (
const auto *ReferencedFn = dyn_cast<FunctionDecl>(E->
getDecl());
2546 Diag(E, ReferencedFn,
false);
2564 return Base::TraverseConstructorInitializer(Init);
2569 return Base::TraverseCXXConstructorDecl(Ctr);
2572 bool TraverseType(
QualType T) {
return true; }
2573 bool VisitBlockExpr(
BlockExpr *T) {
return true; }
2575 } Visitor(*
this, FD);
2576 Visitor.TraverseDecl(FD);
2595 return dyn_cast_or_null<CXXRecordDecl>(DC);
2598 return dyn_cast_or_null<CXXRecordDecl>(
CurContext);
2623 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
2625 CurDecl = dyn_cast_or_null<CXXRecordDecl>(
CurContext);
2643 Class = Class->getCanonicalDecl();
2645 for (
const auto &I : Current->bases()) {
2654 if (
Base->getCanonicalDecl() == Class)
2657 Queue.push_back(
Base);
2663 Current = Queue.pop_back_val();
2691 if (Class->isUnion()) {
2692 Diag(Class->getLocation(), diag::err_base_clause_on_union)
2699 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
2711 if (BaseDecl->getCanonicalDecl() == Class->getCanonicalDecl() ||
2712 ((BaseDecl = BaseDecl->getDefinition()) &&
2714 Diag(BaseLoc, diag::err_circular_inheritance)
2717 if (BaseDecl->getCanonicalDecl() != Class->getCanonicalDecl())
2718 Diag(BaseDecl->getLocation(), diag::note_previous_decl)
2731 if (!Class->getTypeForDecl()->isDependentType())
2732 Class->setInvalidDecl();
2735 Access, TInfo, EllipsisLoc);
2740 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
2747 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
2755 if (
auto *BaseTemplate = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
2767 diag::err_incomplete_base_class, SpecifierRange)) {
2768 Class->setInvalidDecl();
2774 assert(BaseDecl &&
"Record type has no declaration");
2776 assert(BaseDecl &&
"Base type is not incomplete, but has no definition");
2778 assert(CXXBaseDecl &&
"Base type is not a C++ type");
2783 const auto *BaseCSA = CXXBaseDecl->
getAttr<CodeSegAttr>();
2784 const auto *DerivedCSA = Class->getAttr<CodeSegAttr>();
2785 if ((DerivedCSA || BaseCSA) &&
2786 (!BaseCSA || !DerivedCSA || BaseCSA->getName() != DerivedCSA->getName())) {
2787 Diag(Class->getLocation(), diag::err_mismatched_code_seg_base);
2788 Diag(CXXBaseDecl->
getLocation(), diag::note_base_class_specified_here)
2800 Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
2808 if (FinalAttr *FA = CXXBaseDecl->
getAttr<FinalAttr>()) {
2809 Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
2811 << FA->isSpelledAsSealed();
2818 Class->setInvalidDecl();
2823 Access, TInfo, EllipsisLoc);
2845 Class->setIsParsingBaseSpecifiers();
2853 Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
2854 << AL << AL.getRange();
2856 Diag(AL.getLoc(), diag::err_base_specifier_attribute)
2857 << AL << AL.isRegularKeywordAttribute() << AL.getRange();
2873 Class->setInvalidDecl();
2890 auto Decl = Rec->getAsCXXRecordDecl();
2893 for (
const auto &BaseSpec :
Decl->bases()) {
2896 if (Set.insert(
Base).second)
2914 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
2921 unsigned NumGoodBases = 0;
2923 for (
unsigned idx = 0; idx < Bases.size(); ++idx) {
2933 Diag(Bases[idx]->getBeginLoc(), diag::err_duplicate_base_class)
2934 << KnownBase->
getType() << Bases[idx]->getSourceRange();
2943 KnownBase = Bases[idx];
2944 Bases[NumGoodBases++] = Bases[idx];
2949 if (Bases.size() > 1)
2953 const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
2954 if (Class->isInterface() &&
2965 Class->addAttr(WeakAttr::CreateImplicit(
Context));
2971 Class->setBases(Bases.data(), NumGoodBases);
2974 for (
unsigned idx = 0; idx < NumGoodBases; ++idx) {
2976 QualType BaseType = Bases[idx]->getType();
2986 if (IndirectBaseTypes.count(CanonicalBase)) {
2990 = Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
2994 if (Paths.isAmbiguous(CanonicalBase))
2995 Diag(Bases[idx]->getBeginLoc(), diag::warn_inaccessible_base_class)
2997 << Bases[idx]->getSourceRange();
2999 assert(Bases[idx]->isVirtual());
3015 if (!ClassDecl || Bases.empty())
3076 for (
unsigned I = Path.size(); I != 0; --I) {
3077 if (Path[I - 1].
Base->isVirtual()) {
3084 for (
unsigned I = Start, E = Path.size(); I != E; ++I)
3091 assert(BasePathArray.empty() &&
"Base path array must be empty!");
3092 assert(Paths.isRecordingPaths() &&
"Must record paths!");
3093 return ::BuildBasePathArray(Paths.front(), BasePathArray);
3109 unsigned InaccessibleBaseID,
3110 unsigned AmbiguousBaseConvID,
3114 bool IgnoreAccess) {
3122 if (!DerivationOkay)
3127 Path = &Paths.front();
3134 if (PossiblePath.size() == 1) {
3135 Path = &PossiblePath;
3136 if (AmbiguousBaseConvID)
3137 Diag(Loc, diag::ext_ms_ambiguous_direct_base)
3138 <<
Base << Derived << Range;
3145 if (!IgnoreAccess) {
3164 if (AmbiguousBaseConvID) {
3172 Paths.setRecordingPaths(
true);
3174 assert(StillOkay &&
"Can only be used with a derived-to-base conversion");
3183 Diag(Loc, AmbiguousBaseConvID)
3184 << Derived <<
Base << PathDisplayStr << Range << Name;
3193 bool IgnoreAccess) {
3195 Derived,
Base, diag::err_upcast_to_inaccessible_base,
3196 diag::err_ambiguous_derived_to_base_conv, Loc, Range,
DeclarationName(),
3197 BasePath, IgnoreAccess);
3214 std::string PathDisplayStr;
3215 std::set<unsigned> DisplayedPaths;
3217 Path != Paths.end(); ++Path) {
3218 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
3221 PathDisplayStr +=
"\n ";
3223 for (CXXBasePath::const_iterator Element = Path->begin();
3224 Element != Path->end(); ++Element)
3225 PathDisplayStr +=
" -> " + Element->Base->getType().getAsString();
3229 return PathDisplayStr;
3240 assert(Access !=
AS_none &&
"Invalid kind for syntactic access specifier!");
3270 if (!OverloadedMethods.empty()) {
3271 if (OverrideAttr *OA = D->
getAttr<OverrideAttr>()) {
3272 Diag(OA->getLocation(),
3273 diag::override_keyword_hides_virtual_member_function)
3274 <<
"override" << (OverloadedMethods.size() > 1);
3275 }
else if (FinalAttr *FA = D->
getAttr<FinalAttr>()) {
3276 Diag(FA->getLocation(),
3277 diag::override_keyword_hides_virtual_member_function)
3278 << (FA->isSpelledAsSealed() ?
"sealed" :
"final")
3279 << (OverloadedMethods.size() > 1);
3290 if (OverrideAttr *OA = D->
getAttr<OverrideAttr>()) {
3291 Diag(OA->getLocation(),
3292 diag::override_keyword_only_allowed_on_virtual_member_functions)
3296 if (FinalAttr *FA = D->
getAttr<FinalAttr>()) {
3297 Diag(FA->getLocation(),
3298 diag::override_keyword_only_allowed_on_virtual_member_functions)
3299 << (FA->isSpelledAsSealed() ?
"sealed" :
"final")
3311 if (MD->
hasAttr<OverrideAttr>() && !HasOverriddenMethods)
3312 Diag(MD->
getLocation(), diag::err_function_marked_override_not_overriding)
3332 auto EmitDiag = [&](
unsigned DiagInconsistent,
unsigned DiagSuggest) {
3341 if (isa<CXXDestructorDecl>(MD))
3343 diag::warn_inconsistent_destructor_marked_not_override_overriding,
3344 diag::warn_suggest_destructor_marked_not_override_overriding);
3346 EmitDiag(diag::warn_inconsistent_function_marked_not_override_overriding,
3347 diag::warn_suggest_function_marked_not_override_overriding);
3356 FinalAttr *FA = Old->
getAttr<FinalAttr>();
3362 << FA->isSpelledAsSealed();
3371 return !RD->isCompleteDefinition() ||
3372 !RD->hasTrivialDefaultConstructor() ||
3373 !RD->hasTrivialDestructor();
3386 std::map<CXXRecordDecl*, NamedDecl*> Bases;
3389 const auto Base =
Specifier->getType()->getAsCXXRecordDecl();
3391 if (Bases.find(
Base) != Bases.end())
3393 for (
const auto Field :
Base->lookup(FieldName)) {
3394 if ((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&
3397 assert(Bases.find(
Base) == Bases.end());
3410 for (
const auto &
P : Paths) {
3411 auto Base =
P.back().Base->getType()->getAsCXXRecordDecl();
3412 auto It = Bases.find(
Base);
3414 if (It == Bases.end())
3416 auto BaseField = It->second;
3417 assert(BaseField->getAccess() !=
AS_private);
3420 Diag(Loc, diag::warn_shadow_field)
3421 << FieldName << RD <<
Base << DeclIsField;
3422 Diag(BaseField->getLocation(), diag::note_shadow_field);
3447 Expr *BitWidth =
static_cast<Expr*
>(BW);
3456 if (cast<CXXRecordDecl>(
CurContext)->isInterface()) {
3460 unsigned InvalidDecl;
3461 bool ShowDeclName =
true;
3471 else switch (Name.getNameKind()) {
3474 ShowDeclName =
false;
3479 ShowDeclName =
false;
3494 Diag(Loc, diag::err_invalid_member_in_interface)
3495 << (InvalidDecl-1) << Name;
3497 Diag(Loc, diag::err_invalid_member_in_interface)
3498 << (InvalidDecl-1) <<
"";
3524 diag::err_storageclass_invalid_for_member);
3544 const char *PrevSpec;
3549 assert(!Failed &&
"Making a constexpr member const shouldn't fail");
3553 const char *PrevSpec;
3559 "This is the only DeclSpec that should fail to be applied");
3563 isInstField =
false;
3573 if (!Name.isIdentifier()) {
3574 Diag(Loc, diag::err_bad_variable_name)
3583 if (TemplateParameterLists.size()) {
3585 if (TemplateParams->
size()) {
3594 diag::err_template_member_noparams)
3629 if (MSPropertyAttr) {
3631 BitWidth, InitStyle, AS, *MSPropertyAttr);
3634 isInstField =
false;
3637 BitWidth, InitStyle, AS);
3642 CheckShadowInheritedFields(Loc, Name, cast<CXXRecordDecl>(
CurContext));
3650 if (
Member->isInvalidDecl()) {
3652 }
else if (isa<VarDecl>(
Member) || isa<VarTemplateDecl>(
Member)) {
3655 Diag(Loc, diag::err_static_not_bitfield)
3657 }
else if (isa<TypedefDecl>(
Member)) {
3659 Diag(Loc, diag::err_typedef_not_bitfield)
3664 Diag(Loc, diag::err_not_integral_type_bitfield)
3665 << Name << cast<ValueDecl>(
Member)->getType()
3670 Member->setInvalidDecl();
3675 NonTemplateMember = FunTmpl->getTemplatedDecl();
3677 NonTemplateMember = VarTmpl->getTemplatedDecl();
3683 if (NonTemplateMember !=
Member)
3689 if (
auto *DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {
3690 auto *TD = DG->getDeducedTemplate();
3693 if (AS != TD->getAccess() &&
3694 TD->getDeclContext()->getRedeclContext()->Equals(
3695 DG->getDeclContext()->getRedeclContext())) {
3696 Diag(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);
3697 Diag(TD->getBeginLoc(), diag::note_deduction_guide_template_access)
3700 for (
const auto *D : cast<CXXRecordDecl>(
CurContext)->decls()) {
3701 if (
const auto *AccessSpec = dyn_cast<AccessSpecDecl>(D))
3702 LastAccessSpec = AccessSpec;
3704 assert(LastAccessSpec &&
"differing access with no access specifier");
3705 Diag(LastAccessSpec->
getBeginLoc(), diag::note_deduction_guide_access)
3716 ? FinalAttr::Keyword_sealed
3717 : FinalAttr::Keyword_final));
3727 assert((Name || isInstField) &&
"No identifier for non-field ?");
3737 auto DeclHasUnusedAttr = [](
const QualType &T) {
3738 if (
const TagDecl *TD = T->getAsTagDecl())
3739 return TD->hasAttr<UnusedAttr>();
3741 return TDT->getDecl()->hasAttr<UnusedAttr>();
3749 !DeclHasUnusedAttr(FD->
getType()) &&
3759 class UninitializedFieldVisitor
3764 llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
3767 llvm::SmallPtrSetImpl<QualType> &BaseClasses;
3782 UninitializedFieldVisitor(
Sema &S,
3783 llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
3784 llvm::SmallPtrSetImpl<QualType> &BaseClasses)
3785 : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
3786 Constructor(nullptr), InitList(
false), InitListFieldDecl(nullptr) {}
3789 bool IsInitListMemberExprInitialized(
MemberExpr *ME,
3790 bool CheckReferenceOnly) {
3792 bool ReferenceField =
false;
3797 Fields.push_back(FD);
3799 ReferenceField =
true;
3805 if (CheckReferenceOnly && !ReferenceField)
3811 for (
const FieldDecl *FD : llvm::drop_begin(llvm::reverse(Fields)))
3814 for (
auto UsedIter = UsedFieldIndex.begin(),
3815 UsedEnd = UsedFieldIndex.end(),
3816 OrigIter = InitFieldIndex.begin(),
3817 OrigEnd = InitFieldIndex.end();
3818 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
3819 if (*UsedIter < *OrigIter)
3821 if (*UsedIter > *OrigIter)
3828 void HandleMemberExpr(
MemberExpr *ME,
bool CheckReferenceOnly,
3841 dyn_cast<MemberExpr>(
Base->IgnoreParenImpCasts())) {
3843 if (isa<VarDecl>(SubME->getMemberDecl()))
3846 if (
FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
3851 AllPODFields =
false;
3853 Base = SubME->getBase();
3856 if (!isa<CXXThisExpr>(
Base->IgnoreParenImpCasts())) {
3861 if (AddressOf && AllPODFields)
3867 while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
3868 BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
3871 if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
3881 if (!Decls.count(FoundVD))
3886 if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
3888 if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
3893 if (CheckReferenceOnly && !IsReference)
3897 unsigned diag = IsReference
3898 ? diag::warn_reference_field_is_uninit
3899 : diag::warn_field_is_uninit;
3903 diag::note_uninit_in_this_constructor)
3908 void HandleValue(
Expr *E,
bool AddressOf) {
3911 if (
MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3912 HandleMemberExpr(ME,
false ,
3918 Visit(CO->getCond());
3919 HandleValue(CO->getTrueExpr(), AddressOf);
3920 HandleValue(CO->getFalseExpr(), AddressOf);
3925 dyn_cast<BinaryConditionalOperator>(E)) {
3926 Visit(BCO->getCond());
3927 HandleValue(BCO->getFalseExpr(), AddressOf);
3932 HandleValue(OVE->getSourceExpr(), AddressOf);
3937 switch (BO->getOpcode()) {
3942 HandleValue(BO->getLHS(), AddressOf);
3943 Visit(BO->getRHS());
3946 Visit(BO->getLHS());
3947 HandleValue(BO->getRHS(), AddressOf);
3956 InitFieldIndex.push_back(0);
3957 for (
auto *Child : ILE->
children()) {
3958 if (
InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
3959 CheckInitListExpr(SubList);
3963 ++InitFieldIndex.back();
3965 InitFieldIndex.pop_back();
3974 DeclsToRemove.clear();
3981 InitListFieldDecl =
Field;
3982 InitFieldIndex.clear();
3983 CheckInitListExpr(ILE);
3997 HandleMemberExpr(ME,
true ,
false );
4006 Inherited::VisitImplicitCastExpr(E);
4012 if (
InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
4016 if (ICE->getCastKind() == CK_NoOp)
4017 ArgExpr = ICE->getSubExpr();
4018 HandleValue(ArgExpr,
false );
4021 Inherited::VisitCXXConstructExpr(E);
4026 if (isa<MemberExpr>(Callee)) {
4027 HandleValue(Callee,
false );
4033 Inherited::VisitCXXMemberCallExpr(E);
4039 HandleValue(E->
getArg(0),
false);
4043 Inherited::VisitCallExpr(E);
4049 if (isa<UnresolvedLookupExpr>(Callee))
4050 return Inherited::VisitCXXOperatorCallExpr(E);
4054 HandleValue(Arg->IgnoreParenImpCasts(),
false );
4064 DeclsToRemove.push_back(FD);
4067 HandleValue(E->
getLHS(),
false );
4072 Inherited::VisitBinaryOperator(E);
4082 HandleValue(ME->
getBase(),
true );
4087 Inherited::VisitUnaryOperator(E);
4097 static void DiagnoseUninitializedFields(
4117 for (
auto *I : RD->
decls()) {
4118 if (
auto *FD = dyn_cast<FieldDecl>(I)) {
4119 UninitializedFields.insert(FD);
4120 }
else if (
auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
4121 UninitializedFields.insert(IFD->getAnonField());
4126 for (
const auto &I : RD->
bases())
4127 UninitializedBaseClasses.insert(I.getType().getCanonicalType());
4129 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
4132 UninitializedFieldVisitor UninitializedChecker(SemaRef,
4133 UninitializedFields,
4134 UninitializedBaseClasses);
4136 for (
const auto *FieldInit :
Constructor->inits()) {
4137 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
4140 Expr *InitExpr = FieldInit->getInit();
4145 dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
4146 InitExpr =
Default->getExpr();
4150 UninitializedChecker.CheckInitializer(InitExpr, Constructor,
4151 FieldInit->getAnyMember(),
4152 FieldInit->getBaseClass());
4154 UninitializedChecker.CheckInitializer(InitExpr,
nullptr,
4155 FieldInit->getAnyMember(),
4156 FieldInit->getBaseClass());
4179 auto *ParamDecl = cast<NamedDecl>(Param.Param);
4180 if (ParamDecl->getDeclName())
4201 return ConstraintExpr;
4216 return Seq.
Perform(*
this, Entity, Kind, InitExpr);
4230 "must set init style when field is created");
4247 assert(Init.isUsable() &&
"Init should at least have a RecoveryExpr");
4253 if (!Init.isInvalid())
4255 if (Init.isInvalid()) {
4273 DirectBaseSpec =
nullptr;
4274 for (
const auto &
Base : ClassDecl->
bases()) {
4278 DirectBaseSpec = &
Base;
4286 VirtualBaseSpec =
nullptr;
4287 if (!DirectBaseSpec || !DirectBaseSpec->
isVirtual()) {
4296 Path != Paths.end(); ++Path) {
4297 if (Path->back().Base->isVirtual()) {
4298 VirtualBaseSpec = Path->back().Base;
4305 return DirectBaseSpec || VirtualBaseSpec;
4320 DS, IdLoc, InitList,
4339 DS, IdLoc, List, EllipsisLoc);
4348 explicit MemInitializerValidatorCCC(
CXXRecordDecl *ClassDecl)
4349 : ClassDecl(ClassDecl) {}
4351 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
4354 return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
4355 return isa<TypeDecl>(ND);
4360 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
4361 return std::make_unique<MemInitializerValidatorCCC>(*
this);
4376 return isa<FieldDecl, IndirectFieldDecl>(Elem) &&
4380 if (Found ==
Result.end())
4382 Diag(Loc, diag::err_using_placeholder_variable) << Name;
4387 if (isa<FieldDecl, IndirectFieldDecl>(ND) &&
4398 for (
auto *D : ClassDecl->
lookup(MemberOrBase)) {
4399 if (isa<FieldDecl, IndirectFieldDecl>(D)) {
4402 if (IsPlaceholder && D->getDeclContext() == ND->
getDeclContext())
4407 return cast<ValueDecl>(D);
4408 ND = cast<ValueDecl>(D);
4446 = dyn_cast<CXXConstructorDecl>(ConstructorD);
4470 ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {
4472 Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
4474 <<
SourceRange(IdLoc, Init->getSourceRange().getEnd());
4482 if (TemplateTypeTy) {
4503 bool NotUnknownSpecialization =
false;
4505 if (
CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
4506 NotUnknownSpecialization = !Record->hasAnyDependentBases();
4508 if (!NotUnknownSpecialization) {
4513 *MemberOrBase, IdLoc);
4533 auto *TempSpec = cast<TemplateSpecializationType>(
4534 UnqualifiedBase->getInjectedClassNameSpecialization());
4536 for (
auto const &
Base : ClassDecl->
bases()) {
4540 BaseTemplate->getTemplateName(), TN)) {
4541 Diag(IdLoc, diag::ext_unqualified_base_class)
4542 <<
SourceRange(IdLoc, Init->getSourceRange().getEnd());
4543 BaseType =
Base.getType();
4552 MemInitializerValidatorCCC CCC(ClassDecl);
4561 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4562 << MemberOrBase <<
true);
4569 DirectBaseSpec, VirtualBaseSpec)) {
4574 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4575 << MemberOrBase <<
false,
4588 if (!TyD && BaseType.
isNull()) {
4589 Diag(IdLoc, diag::err_mem_init_not_member_or_class)
4590 << MemberOrBase <<
SourceRange(IdLoc,Init->getSourceRange().getEnd());
4617 assert((DirectMember || IndirectMember) &&
4618 "Member must be a FieldDecl or IndirectFieldDecl");
4623 if (
Member->isInvalidDecl())
4627 if (
ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4628 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4629 }
else if (
InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
4630 Args =
MultiExprArg(InitList->getInits(), InitList->getNumInits());
4638 if (
Member->getType()->isDependentType() || Init->isTypeDependent()) {
4643 bool InitList =
false;
4644 if (isa<InitListExpr>(Init)) {
4656 IdLoc, Init->getBeginLoc(), Init->getEndLoc())
4680 Init = MemberInit.
get();
4700 return Diag(NameLoc, diag::err_delegating_ctor)
4702 Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
4704 bool InitList =
true;
4706 if (
ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4708 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4717 NameLoc, Init->getBeginLoc(), Init->getEndLoc())
4725 cast<CXXConstructExpr>(DelegationInit.
get())->getConstructor()) &&
4726 "Delegating constructor with no target?");
4732 DelegationInit.
get(), InitRange.
getBegin(),
false);
4750 DelegationInit = Init;
4765 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
4785 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
4814 if (!DirectBaseSpec && !VirtualBaseSpec) {
4823 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
4835 InitRange.
getEnd(), EllipsisLoc);
4842 if (DirectBaseSpec && VirtualBaseSpec)
4843 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
4848 BaseSpec = VirtualBaseSpec;
4851 bool InitList =
true;
4853 if (
ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4855 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4895 InitRange.
getEnd(), EllipsisLoc);
4905 TargetType, ExprLoc);
4925 bool IsInheritedVirtualBase,
4929 IsInheritedVirtualBase);
4933 switch (ImplicitInitKind) {
4939 BaseInit = InitSeq.
Perform(SemaRef, InitEntity, InitKind, std::nullopt);
4945 bool Moving = ImplicitInitKind ==
IIK_Move;
4946 ParmVarDecl *Param = Constructor->getParamDecl(0);
4952 Constructor->getLocation(), ParamType,
4967 BasePath.push_back(BaseSpec);
4969 CK_UncheckedDerivedToBase,
4977 BaseInit = InitSeq.
Perform(SemaRef, InitEntity, InitKind, CopyCtorArg);
5000 ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
5009 if (Field->isInvalidDecl())
5015 bool Moving = ImplicitInitKind ==
IIK_Move;
5016 ParmVarDecl *Param = Constructor->getParamDecl(0);
5020 if (Field->isZeroLengthBitField(SemaRef.
Context))
5023 Expr *MemberExprBase =
5036 LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
5038 MemberLookup.
addDecl(Indirect ? cast<ValueDecl>(Indirect)
5074 InitSeq.Perform(SemaRef, Entity, InitKind,
MultiExprArg(&CtorArgE, 1));
5089 "Unhandled implicit init kind!");
5105 InitSeq.
Perform(SemaRef, InitEntity, InitKind, std::nullopt);