49#include "llvm/ADT/ArrayRef.h"
50#include "llvm/ADT/STLExtras.h"
51#include "llvm/ADT/STLForwardCompat.h"
52#include "llvm/ADT/StringExtras.h"
53#include "llvm/Support/ConvertUTF.h"
54#include "llvm/Support/SaveAndRestore.h"
71class CheckDefaultArgumentVisitor
74 const Expr *DefaultArg;
77 CheckDefaultArgumentVisitor(
Sema &S,
const Expr *DefaultArg)
78 : S(S), DefaultArg(DefaultArg) {}
83 bool VisitLambdaExpr(
const LambdaExpr *Lambda);
88bool CheckDefaultArgumentVisitor::VisitExpr(
const Expr *
Node) {
89 bool IsInvalid =
false;
90 for (
const Stmt *SubStmt :
Node->children())
92 IsInvalid |= Visit(SubStmt);
99bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(
const DeclRefExpr *DRE) {
102 if (!isa<VarDecl, BindingDecl>(
Decl))
105 if (
const auto *Param = dyn_cast<ParmVarDecl>(
Decl)) {
116 diag::err_param_default_argument_references_param)
117 << Param->getDeclName() << DefaultArg->getSourceRange();
118 }
else if (
auto *VD =
Decl->getPotentiallyDecomposedVarDecl()) {
133 diag::err_param_default_argument_references_local)
140bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(
const CXXThisExpr *ThisE) {
145 diag::err_param_default_argument_references_this)
149bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(
154 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(
E)) {
155 E = OVE->getSourceExpr();
156 assert(
E &&
"pseudo-object binding without source expression?");
164bool CheckDefaultArgumentVisitor::VisitLambdaExpr(
const LambdaExpr *Lambda) {
173 return S.
Diag(LC.getLocation(), diag::err_lambda_capture_default_arg);
175 auto *
D = cast<VarDecl>(LC.getCapturedVar());
208 llvm_unreachable(
"should not see unresolved exception specs here");
237 "should not generate implicit declarations for dependent cases");
241 assert(EST ==
EST_Dynamic &&
"EST case not considered earlier.");
243 "Shouldn't collect exceptions when throw-all is guaranteed.");
248 Exceptions.push_back(
E);
276 if (
Self->canThrow(S))
283 diag::err_typecheck_decl_incomplete_type))
302 CheckCompletedExpr(Arg, EqualLoc);
315 UnparsedDefaultArgInstantiationsMap::iterator InstPos
318 for (
unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
319 InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
329 if (!param || !DefaultArg)
337 Diag(EqualLoc, diag::err_param_default_argument)
350 Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
364 CheckDefaultArgumentVisitor DefaultArgChecker(*
this, DefaultArg);
365 if (DefaultArgChecker.Visit(DefaultArg))
396 Param->
getType().getNonReferenceType());
409 bool MightBeFunction =
D.isFunctionDeclarationContext();
410 for (
unsigned i = 0, e =
D.getNumTypeObjects(); i != e; ++i) {
413 if (MightBeFunction) {
417 MightBeFunction =
false;
420 for (
unsigned argIdx = 0, e = chunk.
Fun.
NumParams; argIdx != e;
424 std::unique_ptr<CachedTokens> Toks =
427 if (Toks->size() > 1)
429 Toks->back().getLocation());
441 MightBeFunction =
false;
448 return P->hasDefaultArg() && !P->hasInheritedDefaultArg();
465 for (; PrevForDefaultArgs;
513 for (
unsigned p = 0, NumParams = PrevForDefaultArgs
516 p < NumParams; ++p) {
520 bool OldParamHasDfl = OldParam ? OldParam->
hasDefaultArg() :
false;
523 if (OldParamHasDfl && NewParamHasDfl) {
524 unsigned DiagDefaultParamID =
525 diag::err_param_default_argument_redefinition;
540 DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
558 for (
auto Older = PrevForDefaultArgs;
560 Older = Older->getPreviousDecl();
561 OldParam = Older->getParamDecl(p);
566 }
else if (OldParamHasDfl) {
584 }
else if (NewParamHasDfl) {
588 diag::err_param_default_argument_template_redecl)
591 diag::note_template_prev_declaration)
622 if (
Record->getDescribedClassTemplate())
624 else if (isa<ClassTemplatePartialSpecializationDecl>(
Record))
631 diag::err_param_default_argument_member_template_redecl)
641 if (isa<CXXConstructorDecl>(New) &&
645 if (NewSM != OldSM) {
648 Diag(NewParam->
getLocation(), diag::err_default_arg_makes_ctor_special)
683 if (isa<CXXDeductionGuideDecl>(New) &&
695 Diag(New->
getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
716 ? diag::warn_cxx23_placeholder_var_definition
717 : diag::ext_placeholder_var_definition);
723 assert(
D.isDecompositionDeclarator());
729 if (!
D.mayHaveDecompositionDeclarator()) {
735 if (!TemplateParamLists.empty()) {
738 Diag(TemplateParamLists.front()->getTemplateLoc(),
739 diag::err_decomp_decl_template);
745 ? diag::ext_decomp_decl
747 ? diag::ext_decomp_decl_cond
748 : diag::warn_cxx14_compat_decomp_decl)
763 auto &DS =
D.getDeclSpec();
771 if (
auto SCS = DS.getStorageClassSpec()) {
774 CPlusPlus20SpecifierLocs.push_back(DS.getStorageClassSpecLoc());
777 BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
780 if (
auto TSCS = DS.getThreadStorageClassSpec()) {
782 CPlusPlus20SpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
784 if (DS.hasConstexprSpecifier()) {
785 BadSpecifiers.push_back(
787 BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());
789 if (DS.isInlineSpecified()) {
790 BadSpecifiers.push_back(
"inline");
791 BadSpecifierLocs.push_back(DS.getInlineSpecLoc());
794 if (!BadSpecifiers.empty()) {
795 auto &&Err =
Diag(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);
796 Err << (
int)BadSpecifiers.size()
797 << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(),
" ");
800 for (
auto Loc : BadSpecifierLocs)
802 }
else if (!CPlusPlus20Specifiers.empty()) {
803 auto &&Warn =
Diag(CPlusPlus20SpecifierLocs.front(),
805 ? diag::warn_cxx17_compat_decomp_decl_spec
806 : diag::ext_decomp_decl_spec);
807 Warn << (
int)CPlusPlus20Specifiers.size()
808 << llvm::join(CPlusPlus20Specifiers.begin(),
809 CPlusPlus20Specifiers.end(),
" ");
810 for (
auto Loc : CPlusPlus20SpecifierLocs)
822 Diag(DS.getVolatileSpecLoc(),
823 diag::warn_deprecated_volatile_structured_binding);
836 D.hasGroupingParens() ||
D.getNumTypeObjects() > 1 ||
837 (
D.getNumTypeObjects() == 1 &&
840 (
D.hasGroupingParens() ||
841 (
D.getNumTypeObjects() &&
843 ? diag::err_decomp_decl_parens
844 : diag::err_decomp_decl_type)
855 if (DS.isConstrainedAuto()) {
858 "No other template kind should be possible for a constrained auto");
872 for (
auto &B :
D.getDecompositionDeclarator().bindings()) {
876 assert(VarName &&
"Cannot have an unnamed binding declaration");
879 RedeclarationKind::ForVisibleRedeclaration);
885 Previous.getFoundDecl()->isTemplateParameter()) {
896 NamedDecl *ShadowedDecl =
D.getCXXScopeSpec().isEmpty()
919 auto *Old =
Previous.getRepresentativeDecl();
920 Diag(B.NameLoc, diag::err_redefinition) << B.Name;
921 Diag(Old->getLocation(), diag::note_previous_definition);
923 }
else if (ShadowedDecl && !
D.isRedeclaration()) {
936 RedeclarationKind::ForVisibleRedeclaration);
939 bool AddToScope =
true;
948 if (
OpenMP().isInOpenMPDeclareTargetContext())
958 if ((int64_t)
Bindings.size() != NumElems) {
959 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
972 E = GetInit(
Loc,
E.get(), I++);
975 B->setBinding(ElemType,
E.get());
984 const llvm::APSInt &NumElems,
987 S,
Bindings, Src, DecompType, NumElems, ElemType,
1018 S,
Bindings, Src, DecompType, llvm::APSInt::get(2),
1022 return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
1030 llvm::raw_svector_ostream
OS(SS);
1042 return std::string(
OS.str());
1049 auto DiagnoseMissing = [&] {
1059 return DiagnoseMissing();
1069 return DiagnoseMissing();
1070 if (
Result.isAmbiguous())
1075 Result.suppressDiagnostics();
1077 S.
Diag(
Loc, diag::err_std_type_trait_not_class_template) << Trait;
1078 S.
Diag(
Found->getLocation(), diag::note_declared_at);
1089 Loc, TraitTy, DiagID,
1096 assert(RD &&
"specialization of class template is not a class?");
1115namespace {
enum class IsTupleLike { TupleLike, NotTupleLike,
Error }; }
1118 llvm::APSInt &Size) {
1133 return IsTupleLike::NotTupleLike;
1142 : R(R), Args(Args) {}
1145 return S.
Diag(
Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
1149 } Diagnoser(R, Args);
1154 return IsTupleLike::Error;
1158 return IsTupleLike::Error;
1160 return IsTupleLike::TupleLike;
1175 S, R,
Loc,
"tuple_element", Args,
1176 diag::err_decomp_decl_std_tuple_element_not_specialized))
1182 S.
Diag(
Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
1194struct InitializingBinding {
1203 ~InitializingBinding() {
1212 const llvm::APSInt &TupleSize) {
1213 if ((int64_t)
Bindings.size() != TupleSize) {
1214 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1230 bool UseMemberGet =
false;
1240 dyn_cast<FunctionTemplateDecl>(
D->getUnderlyingDecl())) {
1242 if (TPL->
size() != 0 &&
1243 isa<NonTypeTemplateParmDecl>(TPL->
getParam(0))) {
1245 UseMemberGet =
true;
1254 InitializingBinding InitContext(S, B);
1277 MemberGet, &Args,
nullptr);
1291 Expr *Arg =
E.get();
1312 B->getDeclName().getAsIdentifierInfo(), RefType,
1316 RefVD->setImplicit();
1318 RefVD->setInlineSpecified();
1319 RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);
1324 E =
Seq.Perform(S, Entity, Kind,
Init);
1330 RefVD->setInit(
E.get());
1339 B->setBinding(
T,
E.get());
1354 return Specifier->getType()->getAsCXXRecordDecl()->hasDirectFields();
1363 ClassWithFields = RD;
1375 for (
auto &
P : Paths) {
1379 BestPath->back().Base->getType())) {
1381 S.
Diag(
Loc, diag::err_decomp_decl_multiple_bases_with_members)
1382 <<
false << RD << BestPath->back().Base->getType()
1383 <<
P.back().Base->getType();
1385 }
else if (
P.Access < BestPath->
Access) {
1391 QualType BaseType = BestPath->back().Base->getType();
1393 S.
Diag(
Loc, diag::err_decomp_decl_ambiguous_base)
1400 *BestPath, diag::err_decomp_decl_inaccessible_base);
1411 S.
Diag(
Loc, diag::err_decomp_decl_multiple_bases_with_members)
1412 << (ClassWithFields == RD) << RD << ClassWithFields
1413 << Paths.front().back().Base->getType();
1424 diag::err_incomplete_type))
1436 auto DiagnoseBadNumberOfBindings = [&]() ->
bool {
1437 unsigned NumFields = llvm::count_if(
1438 RD->
fields(), [](
FieldDecl *FD) { return !FD->isUnnamedBitField(); });
1439 assert(
Bindings.size() != NumFields);
1440 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1450 for (
auto *FD : RD->
fields()) {
1451 if (FD->isUnnamedBitField())
1456 if (!FD->getDeclName()) {
1463 if (FD->isAnonymousStructOrUnion()) {
1466 S.
Diag(FD->getLocation(), diag::note_declared_at);
1475 return DiagnoseBadNumberOfBindings();
1486 BasePair.
getAccess(), FD->getAccess())));
1509 if (FD->isMutable())
1515 return DiagnoseBadNumberOfBindings();
1557 llvm::APSInt TupleSize(32);
1559 case IsTupleLike::Error:
1563 case IsTupleLike::TupleLike:
1568 case IsTupleLike::NotTupleLike:
1577 << DD << !RD << DecompType;
1595 "Should only be called if types are otherwise the same.");
1606 NewType =
P->getPointeeType();
1636 if (FTD->isMemberSpecialization())
1663 Diag(Param->
getLocation(), diag::err_param_default_argument_missing_name)
1673template <
typename... Ts>
1683 std::forward<Ts>(DiagArgs)...);
1689 llvm_unreachable(
"unknown CheckConstexprKind");
1697 "this check is obsolete for C++23");
1716 if (!Check(B.getBaseTypeLoc(), B.getType(),
nullptr))
1719 if (!Check(FD->getLocation(), FD->getType(), FD))
1730 "this check is obsolete for C++23");
1731 unsigned ArgIndex = 0;
1734 e = FT->param_type_end();
1735 i != e; ++i, ++ArgIndex) {
1737 assert(PD &&
"null in a parameter list");
1740 diag::err_constexpr_non_literal_param, ArgIndex + 1,
1753 "this check is obsolete for C++23");
1755 diag::err_constexpr_non_literal_return,
1774 default: llvm_unreachable(
"Invalid tag kind for record diagnostic!");
1800 << isa<CXXConstructorDecl>(NewFD)
1802 for (
const auto &I : RD->
vbases())
1803 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
1804 << I.getSourceRange();
1809 if (!isa<CXXConstructorDecl>(NewFD)) {
1814 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
1818 Diag(Method->
getLocation(), diag::warn_cxx17_compat_constexpr_virtual);
1831 if (WrittenVirtual != Method)
1833 diag::note_overridden_virtual_function);
1844 if (
auto *Dtor = dyn_cast<CXXDestructorDecl>(NewFD)) {
1849 !Dtor->getParent()->defaultedDestructorIsConstexpr()) {
1864 "CheckConstexprFunctionDefinition called on function with no body");
1879 for (
const auto *DclIt : DS->
decls()) {
1880 switch (DclIt->getKind()) {
1881 case Decl::StaticAssert:
1883 case Decl::UsingShadow:
1884 case Decl::UsingDirective:
1885 case Decl::UnresolvedUsingTypename:
1886 case Decl::UnresolvedUsingValue:
1887 case Decl::UsingEnum:
1895 case Decl::TypeAlias: {
1898 const auto *TN = cast<TypedefNameDecl>(DclIt);
1899 if (TN->getUnderlyingType()->isVariablyModifiedType()) {
1902 TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
1905 << isa<CXXConstructorDecl>(Dcl);
1913 case Decl::CXXRecord:
1915 if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) {
1919 ? diag::warn_cxx11_compat_constexpr_type_definition
1920 : diag::ext_constexpr_type_definition)
1921 << isa<CXXConstructorDecl>(Dcl);
1928 case Decl::EnumConstant:
1929 case Decl::IndirectField:
1936 case Decl::Decomposition: {
1941 const auto *VD = cast<VarDecl>(DclIt);
1942 if (VD->isThisDeclarationADefinition()) {
1943 if (VD->isStaticLocal()) {
1947 ? diag::warn_cxx20_compat_constexpr_var
1948 : diag::ext_constexpr_static_var)
1949 << isa<CXXConstructorDecl>(Dcl)
1957 diag::warn_cxx20_compat_constexpr_var,
1958 isa<CXXConstructorDecl>(Dcl),
1961 SemaRef, Kind, VD->getLocation(), VD->getType(),
1962 diag::err_constexpr_local_var_non_literal_type,
1963 isa<CXXConstructorDecl>(Dcl))) {
1966 if (!VD->getType()->isDependentType() &&
1967 !VD->hasInit() && !VD->isCXXForRangeDecl()) {
1972 ? diag::warn_cxx17_compat_constexpr_local_var_no_init
1973 : diag::ext_constexpr_local_var_no_init)
1974 << isa<CXXConstructorDecl>(Dcl);
1984 ? diag::warn_cxx11_compat_constexpr_local_var
1985 : diag::ext_constexpr_local_var)
1986 << isa<CXXConstructorDecl>(Dcl);
1993 case Decl::NamespaceAlias:
1994 case Decl::Function:
2004 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval();
2029 llvm::SmallSet<Decl*, 16> &Inits,
2037 if (Field->isInvalidDecl())
2040 if (Field->isUnnamedBitField())
2046 if (Field->isAnonymousStructOrUnion() &&
2047 (Field->getType()->isUnionType()
2048 ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
2049 : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
2052 if (!Inits.count(Field)) {
2057 ? diag::warn_cxx17_compat_constexpr_ctor_missing_init
2058 : diag::ext_constexpr_ctor_missing_init);
2062 diag::note_constexpr_ctor_missing_init);
2066 }
else if (Field->isAnonymousStructOrUnion()) {
2068 for (
auto *I : RD->
fields())
2071 if (!RD->
isUnion() || Inits.count(I))
2088 switch (S->getStmtClass()) {
2089 case Stmt::NullStmtClass:
2093 case Stmt::DeclStmtClass:
2103 case Stmt::ReturnStmtClass:
2105 if (isa<CXXConstructorDecl>(Dcl)) {
2108 Cxx1yLoc = S->getBeginLoc();
2112 ReturnStmts.push_back(S->getBeginLoc());
2115 case Stmt::AttributedStmtClass:
2119 SemaRef, Dcl, cast<AttributedStmt>(S)->getSubStmt(), ReturnStmts,
2120 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind);
2122 case Stmt::CompoundStmtClass: {
2125 Cxx1yLoc = S->getBeginLoc();
2128 for (
auto *BodyIt : CompStmt->
body()) {
2130 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2136 case Stmt::IfStmtClass: {
2139 Cxx1yLoc = S->getBeginLoc();
2143 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2145 if (
If->getElse() &&
2147 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2152 case Stmt::WhileStmtClass:
2153 case Stmt::DoStmtClass:
2154 case Stmt::ForStmtClass:
2155 case Stmt::CXXForRangeStmtClass:
2156 case Stmt::ContinueStmtClass:
2162 Cxx1yLoc = S->getBeginLoc();
2163 for (
Stmt *SubStmt : S->children()) {
2166 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2171 case Stmt::SwitchStmtClass:
2172 case Stmt::CaseStmtClass:
2173 case Stmt::DefaultStmtClass:
2174 case Stmt::BreakStmtClass:
2178 Cxx1yLoc = S->getBeginLoc();
2179 for (
Stmt *SubStmt : S->children()) {
2182 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2187 case Stmt::LabelStmtClass:
2188 case Stmt::GotoStmtClass:
2190 Cxx2bLoc = S->getBeginLoc();
2191 for (
Stmt *SubStmt : S->children()) {
2194 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2199 case Stmt::GCCAsmStmtClass:
2200 case Stmt::MSAsmStmtClass:
2202 case Stmt::CXXTryStmtClass:
2204 Cxx2aLoc = S->getBeginLoc();
2205 for (
Stmt *SubStmt : S->children()) {
2208 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2213 case Stmt::CXXCatchStmtClass:
2217 SemaRef, Dcl, cast<CXXCatchStmt>(S)->getHandlerBlock(), ReturnStmts,
2218 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2228 Cxx1yLoc = S->getBeginLoc();
2233 SemaRef.
Diag(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
2234 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval();
2249 if (isa<CXXTryStmt>(Body)) {
2271 ? diag::ext_constexpr_function_try_block_cxx20
2272 : diag::warn_cxx17_compat_constexpr_function_try_block)
2273 << isa<CXXConstructorDecl>(Dcl);
2287 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2298 }
else if (Cxx2bLoc.
isValid()) {
2301 ? diag::warn_cxx20_compat_constexpr_body_invalid_stmt
2302 : diag::ext_constexpr_body_invalid_stmt_cxx23)
2303 << isa<CXXConstructorDecl>(Dcl);
2304 }
else if (Cxx2aLoc.
isValid()) {
2307 ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
2308 : diag::ext_constexpr_body_invalid_stmt_cxx20)
2309 << isa<CXXConstructorDecl>(Dcl);
2310 }
else if (Cxx1yLoc.
isValid()) {
2313 ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
2314 : diag::ext_constexpr_body_invalid_stmt)
2315 << isa<CXXConstructorDecl>(Dcl);
2319 = dyn_cast<CXXConstructorDecl>(Dcl)) {
2328 if (Constructor->getNumCtorInitializers() == 0 &&
2334 ? diag::warn_cxx17_compat_constexpr_union_ctor_no_init
2335 : diag::ext_constexpr_union_ctor_no_init);
2340 }
else if (!Constructor->isDependentContext() &&
2341 !Constructor->isDelegatingConstructor()) {
2342 assert(RD->
getNumVBases() == 0 &&
"constexpr ctor with virtual bases");
2346 bool AnyAnonStructUnionMembers =
false;
2347 unsigned Fields = 0;
2350 if (I->isAnonymousStructOrUnion()) {
2351 AnyAnonStructUnionMembers =
true;
2359 if (AnyAnonStructUnionMembers ||
2360 Constructor->getNumCtorInitializers() != RD->
getNumBases() + Fields) {
2364 llvm::SmallSet<Decl*, 16> Inits;
2365 for (
const auto *I: Constructor->inits()) {
2369 Inits.insert(ID->chain_begin(), ID->chain_end());
2372 bool Diagnosed =
false;
2373 for (
auto *I : RD->
fields())
2380 if (ReturnStmts.empty()) {
2395 }
else if (ReturnStmts.size() > 1) {
2401 ? diag::warn_cxx11_compat_constexpr_body_multiple_return
2402 : diag::ext_constexpr_body_multiple_return);
2403 for (
unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
2405 diag::note_constexpr_body_previous_return);
2436 diag::ext_constexpr_function_never_constant_expr, Dcl->
getLocation());
2441 diag::ext_constexpr_function_never_constant_expr)
2442 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval()
2444 for (
size_t I = 0, N =
Diags.size(); I != N; ++I)
2469 OK ? diag::warn_cxx11_compat_constexpr_body_no_return
2470 : diag::err_constexpr_body_no_return)
2484 Diag(it->second, diag::err_immediate_function_used_before_definition)
2497 "expected an immediate function");
2498 assert(FD->
hasBody() &&
"expected the function to have a body");
2503 bool ImmediateFnIsConstructor;
2508 : SemaRef(SemaRef), ImmediateFn(FD),
2509 ImmediateFnIsConstructor(isa<CXXConstructorDecl>(FD)) {
2510 ShouldVisitImplicitCode =
true;
2511 ShouldVisitLambdaBody =
false;
2517 if (CurrentConstructor && CurrentInit) {
2525 SemaRef.
Diag(
Loc, diag::note_immediate_function_reason)
2526 << ImmediateFn << Fn << Fn->isConsteval() << IsCall
2527 << isa<CXXConstructorDecl>(Fn) << ImmediateFnIsConstructor
2528 << (InitializedField !=
nullptr)
2529 << (CurrentInit && !CurrentInit->
isWritten())
2530 << InitializedField <<
Range;
2532 bool TraverseCallExpr(
CallExpr *
E)
override {
2533 if (
const auto *DR =
2535 DR && DR->isImmediateEscalating()) {
2536 Diag(
E,
E->getDirectCallee(),
true);
2540 for (
Expr *A :
E->arguments())
2541 if (!TraverseStmt(A))
2548 if (
const auto *ReferencedFn = dyn_cast<FunctionDecl>(
E->getDecl());
2549 ReferencedFn &&
E->isImmediateEscalating()) {
2550 Diag(
E, ReferencedFn,
false);
2559 if (
E->isImmediateEscalating()) {
2573 return DynamicRecursiveASTVisitor::TraverseCXXConstructorDecl(Ctr);
2576 bool TraverseType(
QualType T)
override {
return true; }
2577 bool VisitBlockExpr(
BlockExpr *
T)
override {
return true; }
2579 } Visitor(*
this, FD);
2580 Visitor.TraverseDecl(FD);
2591 return dyn_cast_or_null<CXXRecordDecl>(DC);
2594 return dyn_cast_or_null<CXXRecordDecl>(
CurContext);
2612 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
2614 CurDecl = dyn_cast_or_null<CXXRecordDecl>(
CurContext);
2639 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
2653 if (BaseDecl->isUnion()) {
2654 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
2662 if (
auto *BaseSpec =
2663 dyn_cast<ClassTemplateSpecializationDecl>(BaseDecl)) {
2672 Class->setInvalidDecl();
2676 BaseDecl = BaseDecl->getDefinition();
2677 assert(BaseDecl &&
"Base type is not incomplete, but has no definition");
2682 const auto *BaseCSA = BaseDecl->getAttr<CodeSegAttr>();
2683 const auto *DerivedCSA =
Class->getAttr<CodeSegAttr>();
2684 if ((DerivedCSA || BaseCSA) &&
2685 (!BaseCSA || !DerivedCSA ||
2686 BaseCSA->getName() != DerivedCSA->getName())) {
2687 Diag(
Class->getLocation(), diag::err_mismatched_code_seg_base);
2688 Diag(BaseDecl->getLocation(), diag::note_base_class_specified_here)
2699 if (BaseDecl->hasFlexibleArrayMember()) {
2700 Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
2701 << BaseDecl->getDeclName();
2708 if (FinalAttr *FA = BaseDecl->getAttr<FinalAttr>()) {
2709 Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
2710 << BaseDecl->getDeclName() << FA->isSpelledAsSealed();
2711 Diag(BaseDecl->getLocation(), diag::note_entity_declared_at)
2712 << BaseDecl->getDeclName() << FA->getRange();
2717 if (BaseDecl->isInvalidDecl())
2718 Class->setInvalidDecl();
2726 if (!
Class->isDependentContext())
2727 Class->setInvalidDecl();
2730 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
2742 Access, TInfo, EllipsisLoc);
2759 Class->setIsParsingBaseSpecifiers();
2767 Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
2768 << AL << AL.getRange();
2770 Diag(AL.getLoc(), diag::err_base_specifier_attribute)
2771 << AL << AL.isRegularKeywordAttribute() << AL.getRange();
2784 if (
Class->isUnion()) {
2785 Diag(
Class->getLocation(), diag::err_base_clause_on_union)
2795 Class->setInvalidDecl();
2811 auto Decl = Rec->getAsCXXRecordDecl();
2814 for (
const auto &BaseSpec :
Decl->bases()) {
2833 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
2840 unsigned NumGoodBases = 0;
2842 for (
unsigned idx = 0; idx < Bases.size(); ++idx) {
2852 Diag(Bases[idx]->getBeginLoc(), diag::err_duplicate_base_class)
2853 << KnownBase->
getType() << Bases[idx]->getSourceRange();
2862 KnownBase = Bases[idx];
2863 Bases[NumGoodBases++] = Bases[idx];
2868 if (Bases.size() > 1)
2873 if (
Class->isInterface() &&
2890 Class->setBases(Bases.data(), NumGoodBases);
2893 for (
unsigned idx = 0; idx < NumGoodBases; ++idx) {
2895 QualType BaseType = Bases[idx]->getType();
2905 if (IndirectBaseTypes.count(CanonicalBase)) {
2909 =
Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
2913 if (Paths.isAmbiguous(CanonicalBase))
2914 Diag(Bases[idx]->getBeginLoc(), diag::warn_inaccessible_base_class)
2916 << Bases[idx]->getSourceRange();
2918 assert(Bases[idx]->isVirtual());
2931 if (!ClassDecl || Bases.empty())
2988 for (
unsigned I =
Path.size(); I != 0; --I) {
2989 if (
Path[I - 1].
Base->isVirtual()) {
2996 for (
unsigned I = Start,
E =
Path.size(); I !=
E; ++I)
3003 assert(BasePathArray.empty() &&
"Base path array must be empty!");
3004 assert(Paths.isRecordingPaths() &&
"Must record paths!");
3005 return ::BuildBasePathArray(Paths.front(), BasePathArray);
3010 unsigned InaccessibleBaseID,
3011 unsigned AmbiguousBaseConvID,
3015 bool IgnoreAccess) {
3023 if (!DerivationOkay)
3028 Path = &Paths.front();
3035 if (PossiblePath.size() == 1) {
3036 Path = &PossiblePath;
3037 if (AmbiguousBaseConvID)
3038 Diag(
Loc, diag::ext_ms_ambiguous_direct_base)
3046 if (!IgnoreAccess) {
3065 if (AmbiguousBaseConvID) {
3073 Paths.setRecordingPaths(
true);
3075 assert(StillOkay &&
"Can only be used with a derived-to-base conversion");
3084 Diag(
Loc, AmbiguousBaseConvID)
3085 << Derived <<
Base << PathDisplayStr <<
Range << Name;
3094 bool IgnoreAccess) {
3096 Derived,
Base, diag::err_upcast_to_inaccessible_base,
3098 BasePath, IgnoreAccess);
3102 std::string PathDisplayStr;
3103 std::set<unsigned> DisplayedPaths;
3106 if (DisplayedPaths.insert(
Path->back().SubobjectNumber).second) {
3109 PathDisplayStr +=
"\n ";
3111 for (CXXBasePath::const_iterator Element =
Path->begin();
3112 Element !=
Path->end(); ++Element)
3113 PathDisplayStr +=
" -> " + Element->Base->getType().getAsString();
3117 return PathDisplayStr;
3127 assert(Access !=
AS_none &&
"Invalid kind for syntactic access specifier!");
3156 if (!OverloadedMethods.empty()) {
3157 if (OverrideAttr *OA =
D->
getAttr<OverrideAttr>()) {
3158 Diag(OA->getLocation(),
3159 diag::override_keyword_hides_virtual_member_function)
3160 <<
"override" << (OverloadedMethods.size() > 1);
3161 }
else if (FinalAttr *FA =
D->
getAttr<FinalAttr>()) {
3162 Diag(FA->getLocation(),
3163 diag::override_keyword_hides_virtual_member_function)
3164 << (FA->isSpelledAsSealed() ?
"sealed" :
"final")
3165 << (OverloadedMethods.size() > 1);
3176 if (OverrideAttr *OA =
D->
getAttr<OverrideAttr>()) {
3177 Diag(OA->getLocation(),
3178 diag::override_keyword_only_allowed_on_virtual_member_functions)
3182 if (FinalAttr *FA =
D->
getAttr<FinalAttr>()) {
3183 Diag(FA->getLocation(),
3184 diag::override_keyword_only_allowed_on_virtual_member_functions)
3185 << (FA->isSpelledAsSealed() ?
"sealed" :
"final")
3197 if (MD->
hasAttr<OverrideAttr>() && !HasOverriddenMethods)
3198 Diag(MD->
getLocation(), diag::err_function_marked_override_not_overriding)
3218 auto EmitDiag = [&](
unsigned DiagInconsistent,
unsigned DiagSuggest) {
3227 if (isa<CXXDestructorDecl>(MD))
3229 diag::warn_inconsistent_destructor_marked_not_override_overriding,
3230 diag::warn_suggest_destructor_marked_not_override_overriding);
3232 EmitDiag(diag::warn_inconsistent_function_marked_not_override_overriding,
3233 diag::warn_suggest_function_marked_not_override_overriding);
3239 FinalAttr *FA = Old->
getAttr<FinalAttr>();
3245 << FA->isSpelledAsSealed();
3254 return !RD->isCompleteDefinition() ||
3255 !RD->hasTrivialDefaultConstructor() ||
3256 !RD->hasTrivialDestructor();
3268 std::map<CXXRecordDecl*, NamedDecl*> Bases;
3271 const auto Base =
Specifier->getType()->getAsCXXRecordDecl();
3273 if (Bases.find(
Base) != Bases.end())
3275 for (
const auto Field :
Base->lookup(FieldName)) {
3276 if ((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&
3279 assert(Bases.find(
Base) == Bases.end());
3292 for (
const auto &
P : Paths) {
3293 auto Base =
P.back().Base->getType()->getAsCXXRecordDecl();
3294 auto It = Bases.find(
Base);
3296 if (It == Bases.end())
3298 auto BaseField = It->second;
3299 assert(BaseField->getAccess() !=
AS_private);
3302 Diag(
Loc, diag::warn_shadow_field)
3303 << FieldName << RD <<
Base << DeclIsField;
3304 Diag(BaseField->getLocation(), diag::note_shadow_field);
3324 Expr *BitWidth =
static_cast<Expr*
>(BW);
3329 bool isFunc =
D.isDeclarationOfFunction();
3331 D.getDeclSpec().getAttributes().getMSPropertyAttr();
3333 if (cast<CXXRecordDecl>(
CurContext)->isInterface()) {
3337 unsigned InvalidDecl;
3338 bool ShowDeclName =
true;
3348 else switch (Name.getNameKind()) {
3351 ShowDeclName =
false;
3356 ShowDeclName =
false;
3371 Diag(
Loc, diag::err_invalid_member_in_interface)
3372 << (InvalidDecl-1) << Name;
3374 Diag(
Loc, diag::err_invalid_member_in_interface)
3375 << (InvalidDecl-1) <<
"";
3396 D.getMutableDeclSpec().ClearStorageClassSpecs();
3401 diag::err_storageclass_invalid_for_member);
3402 D.getMutableDeclSpec().ClearStorageClassSpecs();
3408 !isFunc && TemplateParameterLists.empty();
3420 D.getMutableDeclSpec().ClearConstexprSpec();
3421 const char *PrevSpec;
3423 bool Failed =
D.getMutableDeclSpec().SetTypeQual(
3426 assert(!Failed &&
"Making a constexpr member const shouldn't fail");
3430 const char *PrevSpec;
3432 if (
D.getMutableDeclSpec().SetStorageClassSpec(
3436 "This is the only DeclSpec that should fail to be applied");
3440 isInstField =
false;
3450 if (!Name.isIdentifier()) {
3451 Diag(
Loc, diag::err_bad_variable_name)
3458 Diag(
D.getIdentifierLoc(), diag::err_member_with_template_arguments)
3461 D.getName().TemplateId->RAngleLoc)
3462 <<
D.getName().TemplateId->LAngleLoc;
3463 D.SetIdentifier(II,
Loc);
3476 ?
D.getName().TemplateId
3482 Diag(
D.getIdentifierLoc(), diag::err_member_qualification)
3488 if (MSPropertyAttr) {
3490 BitWidth, InitStyle, AS, *MSPropertyAttr);
3493 isInstField =
false;
3496 BitWidth, InitStyle, AS);
3501 CheckShadowInheritedFields(
Loc, Name, cast<CXXRecordDecl>(
CurContext));
3509 if (
Member->isInvalidDecl()) {
3511 }
else if (isa<VarDecl>(
Member) || isa<VarTemplateDecl>(
Member)) {
3514 Diag(
Loc, diag::err_static_not_bitfield)
3516 }
else if (isa<TypedefDecl>(
Member)) {
3518 Diag(
Loc, diag::err_typedef_not_bitfield)
3523 Diag(
Loc, diag::err_not_integral_type_bitfield)
3524 << Name << cast<ValueDecl>(
Member)->getType()
3529 Member->setInvalidDecl();
3534 NonTemplateMember = FunTmpl->getTemplatedDecl();
3536 NonTemplateMember = VarTmpl->getTemplatedDecl();
3542 if (NonTemplateMember !=
Member)
3548 if (
auto *DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {
3549 auto *TD = DG->getDeducedTemplate();
3552 if (AS != TD->getAccess() &&
3553 TD->getDeclContext()->getRedeclContext()->Equals(
3554 DG->getDeclContext()->getRedeclContext())) {
3555 Diag(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);
3556 Diag(TD->getBeginLoc(), diag::note_deduction_guide_template_access)
3559 for (
const auto *
D : cast<CXXRecordDecl>(
CurContext)->decls()) {
3560 if (
const auto *AccessSpec = dyn_cast<AccessSpecDecl>(
D))
3561 LastAccessSpec = AccessSpec;
3563 assert(LastAccessSpec &&
"differing access with no access specifier");
3564 Diag(LastAccessSpec->
getBeginLoc(), diag::note_deduction_guide_access)
3575 ? FinalAttr::Keyword_sealed
3576 : FinalAttr::Keyword_final));
3586 assert((Name || isInstField) &&
"No identifier for non-field ?");
3596 auto DeclHasUnusedAttr = [](
const QualType &
T) {
3598 return TD->hasAttr<UnusedAttr>();
3600 return TDT->getDecl()->hasAttr<UnusedAttr>();
3608 !DeclHasUnusedAttr(FD->
getType()) &&
3618 class UninitializedFieldVisitor
3623 llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
3626 llvm::SmallPtrSetImpl<QualType> &BaseClasses;
3641 UninitializedFieldVisitor(
Sema &S,
3642 llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
3643 llvm::SmallPtrSetImpl<QualType> &BaseClasses)
3644 : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
3645 Constructor(nullptr), InitList(
false), InitListFieldDecl(nullptr) {}
3648 bool IsInitListMemberExprInitialized(
MemberExpr *ME,
3649 bool CheckReferenceOnly) {
3651 bool ReferenceField =
false;
3656 Fields.push_back(FD);
3658 ReferenceField =
true;
3664 if (CheckReferenceOnly && !ReferenceField)
3670 for (
const FieldDecl *FD : llvm::drop_begin(llvm::reverse(Fields)))
3673 for (
auto UsedIter = UsedFieldIndex.begin(),
3674 UsedEnd = UsedFieldIndex.end(),
3675 OrigIter = InitFieldIndex.begin(),
3676 OrigEnd = InitFieldIndex.end();
3677 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
3678 if (*UsedIter < *OrigIter)
3680 if (*UsedIter > *OrigIter)
3687 void HandleMemberExpr(
MemberExpr *ME,
bool CheckReferenceOnly,
3700 dyn_cast<MemberExpr>(
Base->IgnoreParenImpCasts())) {
3702 if (isa<VarDecl>(SubME->getMemberDecl()))
3705 if (
FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
3710 AllPODFields =
false;
3712 Base = SubME->getBase();
3715 if (!isa<CXXThisExpr>(
Base->IgnoreParenImpCasts())) {
3720 if (AddressOf && AllPODFields)
3726 while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
3727 BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
3730 if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
3740 if (!Decls.count(FoundVD))
3745 if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
3747 if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
3752 if (CheckReferenceOnly && !IsReference)
3756 unsigned diag = IsReference
3757 ? diag::warn_reference_field_is_uninit
3758 : diag::warn_field_is_uninit;
3762 diag::note_uninit_in_this_constructor)
3767 void HandleValue(
Expr *
E,
bool AddressOf) {
3771 HandleMemberExpr(ME,
false ,
3777 Visit(CO->getCond());
3778 HandleValue(CO->getTrueExpr(), AddressOf);
3779 HandleValue(CO->getFalseExpr(), AddressOf);
3784 dyn_cast<BinaryConditionalOperator>(
E)) {
3785 Visit(BCO->getCond());
3786 HandleValue(BCO->getFalseExpr(), AddressOf);
3791 HandleValue(OVE->getSourceExpr(), AddressOf);
3796 switch (BO->getOpcode()) {
3801 HandleValue(BO->getLHS(), AddressOf);
3802 Visit(BO->getRHS());
3805 Visit(BO->getLHS());
3806 HandleValue(BO->getRHS(), AddressOf);
3815 InitFieldIndex.push_back(0);
3816 for (
auto *Child : ILE->
children()) {
3817 if (
InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
3818 CheckInitListExpr(SubList);
3822 ++InitFieldIndex.back();
3824 InitFieldIndex.pop_back();
3833 DeclsToRemove.clear();
3840 InitListFieldDecl =
Field;
3841 InitFieldIndex.clear();
3842 CheckInitListExpr(ILE);
3856 HandleMemberExpr(ME,
true ,
false );
3860 if (
E->getCastKind() == CK_LValueToRValue) {
3861 HandleValue(
E->getSubExpr(),
false );
3865 Inherited::VisitImplicitCastExpr(
E);
3869 if (
E->getConstructor()->isCopyConstructor()) {
3870 Expr *ArgExpr =
E->getArg(0);
3871 if (
InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
3875 if (ICE->getCastKind() == CK_NoOp)
3876 ArgExpr = ICE->getSubExpr();
3877 HandleValue(ArgExpr,
false );
3880 Inherited::VisitCXXConstructExpr(
E);
3885 if (isa<MemberExpr>(Callee)) {
3886 HandleValue(Callee,
false );
3887 for (
auto *Arg :
E->arguments())
3892 Inherited::VisitCXXMemberCallExpr(
E);
3897 if (
E->isCallToStdMove()) {
3898 HandleValue(
E->getArg(0),
false);
3902 Inherited::VisitCallExpr(
E);
3908 if (isa<UnresolvedLookupExpr>(Callee))
3909 return Inherited::VisitCXXOperatorCallExpr(
E);
3912 for (
auto *Arg :
E->arguments())
3913 HandleValue(Arg->IgnoreParenImpCasts(),
false );
3919 if (
E->getOpcode() == BO_Assign)
3920 if (
MemberExpr *ME = dyn_cast<MemberExpr>(
E->getLHS()))
3923 DeclsToRemove.push_back(FD);
3925 if (
E->isCompoundAssignmentOp()) {
3926 HandleValue(
E->getLHS(),
false );
3931 Inherited::VisitBinaryOperator(
E);
3935 if (
E->isIncrementDecrementOp()) {
3936 HandleValue(
E->getSubExpr(),
false );
3939 if (
E->getOpcode() == UO_AddrOf) {
3940 if (
MemberExpr *ME = dyn_cast<MemberExpr>(
E->getSubExpr())) {
3941 HandleValue(ME->
getBase(),
true );
3946 Inherited::VisitUnaryOperator(
E);
3956 static void DiagnoseUninitializedFields(
3976 for (
auto *I : RD->
decls()) {
3977 if (
auto *FD = dyn_cast<FieldDecl>(I)) {
3978 UninitializedFields.insert(FD);
3979 }
else if (
auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
3980 UninitializedFields.insert(IFD->getAnonField());
3985 for (
const auto &I : RD->
bases())
3986 UninitializedBaseClasses.insert(I.getType().getCanonicalType());
3988 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
3991 UninitializedFieldVisitor UninitializedChecker(
SemaRef,
3992 UninitializedFields,
3993 UninitializedBaseClasses);
3995 for (
const auto *FieldInit :
Constructor->inits()) {
3996 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
3999 Expr *InitExpr = FieldInit->getInit();
4004 dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
4005 InitExpr =
Default->getExpr();
4009 UninitializedChecker.CheckInitializer(InitExpr, Constructor,
4010 FieldInit->getAnyMember(),
4011 FieldInit->getBaseClass());
4013 UninitializedChecker.CheckInitializer(InitExpr,
nullptr,
4014 FieldInit->getAnyMember(),
4015 FieldInit->getBaseClass());
4028 if (!
D.isFunctionDeclarator())
4030 auto &FTI =
D.getFunctionTypeInfo();
4035 auto *ParamDecl = cast<NamedDecl>(Param.Param);
4036 if (ParamDecl->getDeclName())
4057 return ConstraintExpr;
4072 return Seq.Perform(*
this, Entity, Kind, InitExpr);
4083 if (isa<MSPropertyDecl>(
D)) {
4090 "must set init style when field is created");
4104 assert(
Init.isUsable() &&
"Init should at least have a RecoveryExpr");
4110 if (!
Init.isInvalid())
4112 if (
Init.isInvalid()) {
4130 DirectBaseSpec =
nullptr;
4131 for (
const auto &
Base : ClassDecl->
bases()) {
4135 DirectBaseSpec = &
Base;
4143 VirtualBaseSpec =
nullptr;
4144 if (!DirectBaseSpec || !DirectBaseSpec->
isVirtual()) {
4154 if (
Path->back().Base->isVirtual()) {
4155 VirtualBaseSpec =
Path->back().Base;
4162 return DirectBaseSpec || VirtualBaseSpec;
4176 DS, IdLoc, InitList,
4194 DS, IdLoc, List, EllipsisLoc);
4203 explicit MemInitializerValidatorCCC(
CXXRecordDecl *ClassDecl)
4204 : ClassDecl(ClassDecl) {}
4206 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
4209 return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
4210 return isa<TypeDecl>(ND);
4215 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
4216 return std::make_unique<MemInitializerValidatorCCC>(*
this);
4231 return isa<FieldDecl, IndirectFieldDecl>(Elem) &&
4237 Diag(
Loc, diag::err_using_placeholder_variable) << Name;
4242 if (isa<FieldDecl, IndirectFieldDecl>(ND) &&
4253 for (
auto *
D : ClassDecl->
lookup(MemberOrBase)) {
4254 if (isa<FieldDecl, IndirectFieldDecl>(
D)) {
4255 bool IsPlaceholder =
D->isPlaceholderVar(
getLangOpts());
4262 return cast<ValueDecl>(
D);
4263 ND = cast<ValueDecl>(
D);
4300 = dyn_cast<CXXConstructorDecl>(ConstructorD);
4324 ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {
4326 Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
4336 if (TemplateTypeTy) {
4361 bool NotUnknownSpecialization =
false;
4364 NotUnknownSpecialization = !
Record->hasAnyDependentBases();
4366 if (!NotUnknownSpecialization) {
4391 auto *TempSpec = cast<TemplateSpecializationType>(
4392 UnqualifiedBase->getInjectedClassNameSpecialization());
4394 for (
auto const &
Base : ClassDecl->
bases()) {
4400 Diag(IdLoc, diag::ext_unqualified_base_class)
4402 BaseType =
Base.getType();
4411 MemInitializerValidatorCCC CCC(ClassDecl);
4420 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4421 << MemberOrBase <<
true);
4428 DirectBaseSpec, VirtualBaseSpec)) {
4433 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4434 << MemberOrBase <<
false,
4447 if (!TyD && BaseType.
isNull()) {
4448 Diag(IdLoc, diag::err_mem_init_not_member_or_class)
4449 << MemberOrBase <<
SourceRange(IdLoc,
Init->getSourceRange().getEnd());
4477 assert((DirectMember || IndirectMember) &&
4478 "Member must be a FieldDecl or IndirectFieldDecl");
4483 if (
Member->isInvalidDecl())
4488 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4490 Args =
MultiExprArg(InitList->getInits(), InitList->getNumInits());
4498 if (
Member->getType()->isDependentType() ||
Init->isTypeDependent()) {
4503 bool InitList =
false;
4504 if (isa<InitListExpr>(
Init)) {
4516 IdLoc,
Init->getBeginLoc(),
Init->getEndLoc())
4560 return Diag(NameLoc, diag::err_delegating_ctor)
4562 Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
4564 bool InitList =
true;
4568 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4577 NameLoc,
Init->getBeginLoc(),
Init->getEndLoc())
4585 cast<CXXConstructExpr>(DelegationInit.
get())->getConstructor()) &&
4586 "Delegating constructor with no target?");
4592 DelegationInit.
get(), InitRange.
getBegin(),
false);
4610 DelegationInit =
Init;
4625 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
4645 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
4674 if (!DirectBaseSpec && !VirtualBaseSpec) {
4683 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
4695 InitRange.
getEnd(), EllipsisLoc);
4702 if (DirectBaseSpec && VirtualBaseSpec)
4703 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
4708 BaseSpec = VirtualBaseSpec;
4711 bool InitList =
true;
4715 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4755 InitRange.
getEnd(), EllipsisLoc);
4765 TargetType, ExprLoc);
4785 bool IsInheritedVirtualBase,
4789 IsInheritedVirtualBase);
4793 switch (ImplicitInitKind) {
4799 BaseInit = InitSeq.Perform(
SemaRef, InitEntity, InitKind, {});
4805 bool Moving = ImplicitInitKind ==
IIK_Move;
4806 ParmVarDecl *Param = Constructor->getParamDecl(0);
4812 Constructor->getLocation(), ParamType,
4827 BasePath.push_back(BaseSpec);
4829 CK_UncheckedDerivedToBase,
4837 BaseInit = InitSeq.
Perform(
SemaRef, InitEntity, InitKind, CopyCtorArg);
4860 ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
4869 if (Field->isInvalidDecl())
4875 bool Moving = ImplicitInitKind ==
IIK_Move;
4876 ParmVarDecl *Param = Constructor->getParamDecl(0);
4880 if (Field->isZeroLengthBitField())
4883 Expr *MemberExprBase =
4949 "Unhandled implicit init kind!");
4967 if (MemberInit.isInvalid())
4984 if (!Field->getParent()->isUnion()) {
4987 diag::err_uninitialized_member_in_ctor)
4988 << (
int)Constructor->isImplicit()
4990 << 0 << Field->getDeclName();
4991 SemaRef.
Diag(Field->getLocation(), diag::note_declared_at);
4997 diag::err_uninitialized_member_in_ctor)
4998 << (
int)Constructor->isImplicit()
5000 << 1 << Field->getDeclName();
5001 SemaRef.
Diag(Field->getLocation(), diag::note_declared_at);
5018 CXXMemberInit =
nullptr;
5023struct BaseAndFieldInfo {
5026 bool AnyErrorsInInits;
5028 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
5030 llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
5033 : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
5045 bool isImplicitCopyOrMove()
const {
5056 llvm_unreachable(
"Invalid ImplicitInitializerKind!");
5060 AllToInit.push_back(
Init);
5069 bool isInactiveUnionMember(
FieldDecl *Field) {
5075 ActiveUnionMember.lookup(
Record->getCanonicalDecl()))
5076 return Active !=
Field->getCanonicalDecl();
5079 if (isImplicitCopyOrMove())
5084 if (
Field->hasInClassInitializer())
5088 if (!
Field->isAnonymousStructOrUnion())
5097 bool isWithinInactiveUnionMember(
FieldDecl *Field,
5100 return isInactiveUnionMember(Field);
5104 if (Field && isInactiveUnionMember(Field))
5119 if (ArrayT->isZeroSize())
5122 T = ArrayT->getElementType();
5131 if (Field->isInvalidDecl())
5136 Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
5137 return Info.addFieldInitializer(
Init);
5151 if (Info.isWithinInactiveUnionMember(Field,
Indirect))
5154 if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
5172 return Info.addFieldInitializer(
Init);
5182 if (Info.AnyErrorsInInits)
5193 return Info.addFieldInitializer(
Init);
5200 Constructor->setNumCtorInitializers(1);
5204 Constructor->setCtorInitializers(initializer);
5213 DiagnoseUninitializedFields(*
this, Constructor);
5220 if (Constructor->isDependentContext()) {
5223 if (!Initializers.empty()) {
5224 Constructor->setNumCtorInitializers(Initializers.size());
5227 memcpy(baseOrMemberInitializers, Initializers.data(),
5229 Constructor->setCtorInitializers(baseOrMemberInitializers);
5234 Constructor->setInvalidDecl();
5239 BaseAndFieldInfo Info(*
this, Constructor, AnyErrors);
5243 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
5247 bool HadError =
false;
5249 for (
unsigned i = 0; i < Initializers.size(); i++) {
5252 if (
Member->isBaseInitializer())
5255 Info.AllBaseFields[
Member->getAnyMember()->getCanonicalDecl()] =
Member;
5258 for (
auto *
C : F->chain()) {
5261 Info.ActiveUnionMember.insert(std::make_pair(
5266 Info.ActiveUnionMember.insert(std::make_pair(
5274 for (
auto &I : ClassDecl->
bases()) {
5276 DirectVBases.insert(&I);
5280 for (
auto &VBase : ClassDecl->
vbases()) {
5282 = Info.AllBaseFields.lookup(VBase.getType()->getAs<
RecordType>())) {
5290 Diag(
Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
5291 << VBase.getType() << ClassDecl;
5295 Info.AllToInit.push_back(
Value);
5296 }
else if (!AnyErrors && !ClassDecl->
isAbstract()) {
5301 bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
5304 &VBase, IsInheritedVirtualBase,
5310 Info.AllToInit.push_back(CXXBaseInit);
5317 if (
Base.isVirtual())
5321 = Info.AllBaseFields.lookup(
Base.getType()->getAs<
RecordType>())) {
5322 Info.AllToInit.push_back(
Value);
5323 }
else if (!AnyErrors) {
5332 Info.AllToInit.push_back(CXXBaseInit);
5337 for (
auto *Mem : ClassDecl->
decls()) {
5338 if (
auto *F = dyn_cast<FieldDecl>(Mem)) {
5343 if (F->isUnnamedBitField())
5349 if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
5358 if (Info.isImplicitCopyOrMove())
5361 if (
auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
5362 if (F->getType()->isIncompleteArrayType()) {
5364 "Incomplete array type is not valid");
5376 unsigned NumInitializers = Info.AllToInit.size();
5377 if (NumInitializers > 0) {
5378 Constructor->setNumCtorInitializers(NumInitializers);
5381 memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
5383 Constructor->setCtorInitializers(baseOrMemberInitializers);
5388 Constructor->getParent());
5398 for (
auto *Field : RD->
fields())
5403 IdealInits.push_back(Field->getCanonicalDecl());
5412 if (!
Member->isAnyMemberInitializer())
5415 return Member->getAnyMember()->getCanonicalDecl();
5421 if (
Previous->isAnyMemberInitializer())
5426 if (Current->isAnyMemberInitializer())
5427 Diag << 0 << Current->getAnyMember();
5429 Diag << 1 << Current->getTypeSourceInfo()->getType();
5435 if (Constructor->getDeclContext()->isDependentContext())
5440 bool ShouldCheckOrder =
false;
5441 for (
unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5444 Init->getSourceLocation())) {
5445 ShouldCheckOrder =
true;
5449 if (!ShouldCheckOrder)
5460 for (
const auto &VBase : ClassDecl->
vbases())
5464 for (
const auto &
Base : ClassDecl->
bases()) {
5465 if (
Base.isVirtual())
5471 for (
auto *Field : ClassDecl->
fields()) {
5472 if (Field->isUnnamedBitField())
5478 unsigned NumIdealInits = IdealInitKeys.size();
5479 unsigned IdealIndex = 0;
5488 for (
unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5493 for (; IdealIndex != NumIdealInits; ++IdealIndex)
5494 if (InitKey == IdealInitKeys[IdealIndex])
5500 if (IdealIndex == NumIdealInits && InitIndex) {
5501 WarnIndexes.push_back(InitIndex);
5504 for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
5505 if (InitKey == IdealInitKeys[IdealIndex])
5508 assert(IdealIndex < NumIdealInits &&
5509 "initializer not found in initializer list");
5511 CorrelatedInitOrder.emplace_back(IdealIndex, InitIndex);
5514 if (WarnIndexes.empty())
5518 llvm::sort(CorrelatedInitOrder, llvm::less_first());
5524 Inits[WarnIndexes.front() - 1]->getSourceLocation(),
5525 WarnIndexes.size() == 1 ? diag::warn_initializer_out_of_order
5526 : diag::warn_some_initializers_out_of_order);
5528 for (
unsigned I = 0; I < CorrelatedInitOrder.size(); ++I) {
5529 if (CorrelatedInitOrder[I].second == I)
5535 Inits[I]->getSourceRange(),
5538 Inits[CorrelatedInitOrder[I].second]->getSourceRange()),
5544 if (WarnIndexes.size() == 1) {
5546 Inits[WarnIndexes.front()]);
5552 for (
unsigned WarnIndex : WarnIndexes) {
5555 diag::note_initializer_out_of_order);
5562bool CheckRedundantInit(
Sema &S,
5572 diag::err_multiple_mem_initialization)
5573 <<
Field->getDeclName()
5574 <<
Init->getSourceRange();
5576 const Type *BaseClass =
Init->getBaseClass();
5577 assert(BaseClass &&
"neither field nor base");
5579 diag::err_multiple_base_initialization)
5581 <<
Init->getSourceRange();
5589typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
5590typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
5592bool CheckRedundantUnionInit(
Sema &S,
5594 RedundantUnionMap &Unions) {
5599 while (
Parent->isAnonymousStructOrUnion() ||
Parent->isUnion()) {
5601 UnionEntry &En = Unions[
Parent];
5602 if (En.first && En.first != Child) {
5604 diag::err_multiple_mem_union_initialization)
5605 <<
Field->getDeclName()
5606 <<
Init->getSourceRange();
5607 S.
Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
5608 << 0 << En.second->getSourceRange();
5615 if (!
Parent->isAnonymousStructOrUnion())
5631 if (!ConstructorDecl)
5637 = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
5640 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
5647 llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
5650 RedundantUnionMap MemberUnions;
5652 bool HadError =
false;
5653 for (
unsigned i = 0; i < MemInits.size(); i++) {
5657 Init->setSourceOrder(i);
5659 if (
Init->isAnyMemberInitializer()) {
5661 if (CheckRedundantInit(*
this,
Init, Members[Key]) ||
5662 CheckRedundantUnionInit(*
this,
Init, MemberUnions))
5664 }
else if (
Init->isBaseInitializer()) {
5666 if (CheckRedundantInit(*
this,
Init, Members[Key]))
5669 assert(
Init->isDelegatingInitializer());
5671 if (MemInits.size() != 1) {
5673 diag::err_delegating_initializer_alone)
5674 <<
Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
5690 DiagnoseUninitializedFields(*
this, Constructor);
5707 for (
auto *Field : ClassDecl->
fields()) {
5708 if (Field->isInvalidDecl())
5735 PDiag(diag::err_access_dtor_field)
5736 << Field->getDeclName()
5745 bool VisitVirtualBases = !ClassDecl->
isAbstract();
5752 if (Dtor && Dtor->
isUsed())
5753 VisitVirtualBases =
false;
5759 for (
const auto &
Base : ClassDecl->
bases()) {
5765 if (
Base.isVirtual()) {
5766 if (!VisitVirtualBases)
5768 DirectVirtualBases.insert(RT);
5785 PDiag(diag::err_access_dtor_base)
5786 <<
Base.getType() <<
Base.getSourceRange(),
5793 if (VisitVirtualBases)
5795 &DirectVirtualBases);
5800 llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases) {
5802 for (
const auto &VBase : ClassDecl->
vbases()) {
5807 if (DirectVirtualBases && DirectVirtualBases->count(RT))
5823 PDiag(diag::err_access_dtor_vbase)
5829 diag::err_access_dtor_vbase, 0, ClassDecl->
getLocation(),
5843 = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
5845 !ClassDecl || ClassDecl->isInvalidDecl()) {
5849 DiagnoseUninitializedFields(*
this, Constructor);
5904 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
5905 MEnd = FinalOverriders.end();
5909 SOEnd = M->second.end();
5910 SO != SOEnd; ++SO) {
5917 if (SO->second.size() != 1)
5920 if (!SO->second.front().Method->isPureVirtual())
5923 if (!SeenPureMethods.insert(SO->second.front().Method).second)
5926 Diag(SO->second.front().Method->getLocation(),
5927 diag::note_pure_virtual_function)
5928 << SO->second.front().Method->getDeclName() << RD->
getDeclName();
5938struct AbstractUsageInfo {
5946 AbstractType(S.Context.getCanonicalType(
5947 S.Context.getTypeDeclType(
Record))),
5950 void DiagnoseAbstractType() {
5959struct CheckAbstractUsage {
5960 AbstractUsageInfo &Info;
5963 CheckAbstractUsage(AbstractUsageInfo &Info,
const NamedDecl *Ctx)
5964 : Info(Info), Ctx(Ctx) {}
5968#define ABSTRACT_TYPELOC(CLASS, PARENT)
5969#define TYPELOC(CLASS, PARENT) \
5970 case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
5971#include "clang/AST/TypeLocNodes.def"
5992 for (
unsigned I = 0,
E = TL.
getNumArgs(); I !=
E; ++I) {
6002#define CheckPolymorphic(Type) \
6003 void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
6004 Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
6019 return Visit(Next, Sel);
6029 T = Info.S.Context.getBaseElementType(
T);
6032 if (CT != Info.AbstractType)
return;
6037 Info.S.Diag(Ctx->
getLocation(), diag::err_array_of_abstract_type)
6040 Info.S.Diag(Ctx->
getLocation(), diag::err_abstract_type_in_decl)
6043 Info.DiagnoseAbstractType();
6049 CheckAbstractUsage(*
this,
D).Visit(TL, Sel);
6084 for (
auto *
D : RD->
decls()) {
6088 if (
auto *FD = dyn_cast<FriendDecl>(
D)) {
6089 D = FD->getFriendDecl();
6094 if (
auto *FD = dyn_cast<FunctionDecl>(
D)) {
6096 }
else if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(
D)) {
6100 }
else if (
auto *FD = dyn_cast<FieldDecl>(
D)) {
6103 }
else if (
auto *VD = dyn_cast<VarDecl>(
D)) {
6105 }
else if (
auto *VTD = dyn_cast<VarTemplateDecl>(
D)) {
6109 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(
D)) {
6111 }
else if (
auto *CTD = dyn_cast<ClassTemplateDecl>(
D)) {
6122 assert(ClassAttr->
getKind() == attr::DLLExport);
6132 struct MarkingClassDllexported {
6143 ~MarkingClassDllexported() {
6153 if (!
Member->hasAttr<DLLExportAttr>())
6158 auto *VD = dyn_cast<VarDecl>(
Member);
6159 if (VD && VD->getStorageClass() ==
SC_Static &&
6163 auto *MD = dyn_cast<CXXMethodDecl>(
Member);
6167 if (MD->isUserProvided()) {
6177 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
6187 }
else if (MD->isExplicitlyDefaulted()) {
6196 }
else if (!MD->isTrivial() ||
6197 MD->isCopyAssignmentOperator() ||
6198 MD->isMoveAssignmentOperator()) {
6222 auto *CD = dyn_cast<CXXConstructorDecl>(
Member);
6223 if (!CD || !CD->isDefaultConstructor())
6225 auto *
Attr = CD->getAttr<DLLExportAttr>();
6231 if (!
Class->isDependentContext()) {
6238 if (LastExportedDefaultCtor) {
6240 diag::err_attribute_dll_ambiguous_default_ctor)
6242 S.
Diag(CD->getLocation(), diag::note_entity_declared_at)
6243 << CD->getDeclName();
6246 LastExportedDefaultCtor = CD;
6252 bool ErrorReported =
false;
6253 auto reportIllegalClassTemplate = [&ErrorReported](
Sema &S,
6257 S.
Diag(TD->getLocation(),
6258 diag::err_cuda_device_builtin_surftex_cls_template)
6260 ErrorReported =
true;
6265 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(
Class);
6268 diag::err_cuda_device_builtin_surftex_ref_decl)
6271 diag::note_cuda_device_builtin_surftex_should_be_template_class)
6275 TD = SD->getSpecializedTemplate();
6279 unsigned N = Params->
size();
6282 reportIllegalClassTemplate(S, TD);
6284 diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6287 if (N > 0 && !isa<TemplateTypeParmDecl>(Params->
getParam(0))) {
6288 reportIllegalClassTemplate(S, TD);
6290 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6294 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(1));
6295 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6296 reportIllegalClassTemplate(S, TD);
6298 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6306 bool ErrorReported =
false;
6307 auto reportIllegalClassTemplate = [&ErrorReported](
Sema &S,
6311 S.
Diag(TD->getLocation(),
6312 diag::err_cuda_device_builtin_surftex_cls_template)
6314 ErrorReported =
true;
6319 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(
Class);
6322 diag::err_cuda_device_builtin_surftex_ref_decl)
6325 diag::note_cuda_device_builtin_surftex_should_be_template_class)
6329 TD = SD->getSpecializedTemplate();
6333 unsigned N = Params->
size();
6336 reportIllegalClassTemplate(S, TD);
6338 diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6341 if (N > 0 && !isa<TemplateTypeParmDecl>(Params->
getParam(0))) {
6342 reportIllegalClassTemplate(S, TD);
6344 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6348 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(1));
6349 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6350 reportIllegalClassTemplate(S, TD);
6352 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6357 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(2));
6358 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6359 reportIllegalClassTemplate(S, TD);
6361 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6369 for (
auto *Method :
Class->methods()) {
6370 if (Method->isUserProvided())
6382 if (
auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(
Class)) {
6383 if (
Attr *TemplateAttr =
6384 getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
6385 auto *A = cast<InheritableAttr>(TemplateAttr->clone(
getASTContext()));
6386 A->setInherited(
true);
6401 (!
Class->isExternallyVisible() &&
Class->hasExternalFormalLinkage())) {
6402 Class->dropAttrs<DLLExportAttr, DLLImportAttr>();
6406 if (!
Class->isExternallyVisible()) {
6407 Diag(
Class->getLocation(), diag::err_attribute_dll_not_extern)
6408 <<
Class << ClassAttr;
6416 if (!isa<VarDecl>(
Member) && !isa<CXXMethodDecl>(
Member))
6423 diag::err_attribute_dll_member_of_dll_class)
6424 << MemberAttr << ClassAttr;
6425 Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
6426 Member->setInvalidDecl();
6430 if (
Class->getDescribedClassTemplate())
6435 const bool ClassExported = ClassAttr->
getKind() == attr::DLLExport;
6440 const bool PropagatedImport =
6442 cast<DLLImportAttr>(ClassAttr)->wasPropagatedToBaseTemplate();
6451 Class->dropAttr<DLLExportAttr>();
6485 auto *Ctor = dyn_cast<CXXConstructorDecl>(MD);
6494 (Ctor || isa<CXXDestructorDecl>(MD)) && MD->
isTrivial())
6501 if (VD && PropagatedImport)
6515 if (ClassExported) {
6527 Member->addAttr(NewAttr);
6537 "friend re-decl should not already have a DLLAttr");
6567 NewAttr->setInherited(
true);
6568 BaseTemplateSpec->
addAttr(NewAttr);
6572 if (
auto *ImportAttr = dyn_cast<DLLImportAttr>(NewAttr))
6573 ImportAttr->setPropagatedToBaseTemplate();
6594 Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
6599 diag::note_template_class_explicit_specialization_was_here)
6600 << BaseTemplateSpec;
6603 diag::note_template_class_instantiation_was_here)
6604 << BaseTemplateSpec;
6610 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
6622 if (MD->isCopyAssignmentOperator())
6625 if (MD->isMoveAssignmentOperator())
6628 if (isa<CXXDestructorDecl>(FD))
6636 case OO_ExclaimEqual:
6648 case OO_GreaterEqual:
6671 cast<CXXConstructorDecl>(FD));
6689 llvm_unreachable(
"Invalid special member.");
6703 return !
D->hasNonTrivialDestructorForCall() &&
6704 !
D->hasNonTrivialCopyConstructorForCall();
6707 bool CopyCtorIsTrivial =
false, CopyCtorIsTrivialForCall =
false;
6708 bool DtorIsTrivialForCall =
false;
6716 if (
D->needsImplicitCopyConstructor()) {
6717 if (!
D->defaultedCopyConstructorIsDeleted()) {
6718 if (
D->hasTrivialCopyConstructor())
6719 CopyCtorIsTrivial =
true;
6720 if (
D->hasTrivialCopyConstructorForCall())
6721 CopyCtorIsTrivialForCall =
true;
6725 if (CD->isCopyConstructor() && !CD->isDeleted() &&
6726 !CD->isIneligibleOrNotSelected()) {
6727 if (CD->isTrivial())
6728 CopyCtorIsTrivial =
true;
6729 if (CD->isTrivialForCall())
6730 CopyCtorIsTrivialForCall =
true;
6735 if (
D->needsImplicitDestructor()) {
6736 if (!
D->defaultedDestructorIsDeleted() &&
6737 D->hasTrivialDestructorForCall())
6738 DtorIsTrivialForCall =
true;
6739 }
else if (
const auto *DD =
D->getDestructor()) {
6740 if (!DD->isDeleted() && DD->isTrivialForCall())
6741 DtorIsTrivialForCall =
true;
6745 if (CopyCtorIsTrivialForCall && DtorIsTrivialForCall)
6759 uint64_t TypeSize = isAArch64 ? 128 : 64;
6761 if (CopyCtorIsTrivial &&
6771 bool HasNonDeletedCopyOrMove =
false;
6773 if (
D->needsImplicitCopyConstructor() &&
6774 !
D->defaultedCopyConstructorIsDeleted()) {
6775 if (!
D->hasTrivialCopyConstructorForCall())
6777 HasNonDeletedCopyOrMove =
true;
6780 if (S.
getLangOpts().CPlusPlus11 &&
D->needsImplicitMoveConstructor() &&
6781 !
D->defaultedMoveConstructorIsDeleted()) {
6782 if (!
D->hasTrivialMoveConstructorForCall())
6784 HasNonDeletedCopyOrMove =
true;
6787 if (
D->needsImplicitDestructor() && !
D->defaultedDestructorIsDeleted() &&
6788 !
D->hasTrivialDestructorForCall())
6792 if (MD->isDeleted() || MD->isIneligibleOrNotSelected())
6795 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
6796 if (CD && CD->isCopyOrMoveConstructor())
6797 HasNonDeletedCopyOrMove =
true;
6798 else if (!isa<CXXDestructorDecl>(MD))
6801 if (!MD->isTrivialForCall())
6805 return HasNonDeletedCopyOrMove;
6816 bool IssuedDiagnostic =
false;
6819 if (!IssuedDiagnostic) {
6821 IssuedDiagnostic =
true;
6823 S.
Diag(O->getLocation(), diag::note_overridden_virtual_function);
6826 return IssuedDiagnostic;
6833 if (
Record->isAbstract() && !
Record->isInvalidDecl()) {
6834 AbstractUsageInfo Info(*
this,
Record);
6841 if (!
Record->isInvalidDecl() && !
Record->isDependentType() &&
6842 !
Record->isAggregate() && !
Record->hasUserDeclaredConstructor() &&
6844 bool Complained =
false;
6845 for (
const auto *F :
Record->fields()) {
6846 if (F->hasInClassInitializer() || F->isUnnamedBitField())
6849 if (F->getType()->isReferenceType() ||
6850 (F->getType().isConstQualified() && F->getType()->isScalarType())) {
6852 Diag(
Record->getLocation(), diag::warn_no_constructor_for_refconst)
6853 << llvm::to_underlying(
Record->getTagKind()) <<
Record;
6857 Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
6858 << F->getType()->isReferenceType()
6859 << F->getDeclName();
6864 if (
Record->getIdentifier()) {
6877 if (((isa<FieldDecl>(
D) || isa<UnresolvedUsingValueDecl>(
D)) &&
6878 Record->hasUserDeclaredConstructor()) ||
6879 isa<IndirectFieldDecl>(
D)) {
6880 Diag((*I)->getLocation(), diag::err_member_name_of_class)
6881 <<
D->getDeclName();
6888 if (
Record->isPolymorphic() && !
Record->isDependentType()) {
6891 !
Record->hasAttr<FinalAttr>())
6896 if (
Record->isAbstract()) {
6897 if (FinalAttr *FA =
Record->getAttr<FinalAttr>()) {
6898 Diag(
Record->getLocation(), diag::warn_abstract_final_class)
6899 << FA->isSpelledAsSealed();
6905 if (!
Record->hasAttr<FinalAttr>()) {
6907 if (
const FinalAttr *FA = dtor->getAttr<FinalAttr>()) {
6908 Diag(FA->getLocation(), diag::warn_final_dtor_non_final_class)
6909 << FA->isSpelledAsSealed()
6912 (FA->isSpelledAsSealed() ?
" sealed" :
" final"));
6914 diag::note_final_dtor_non_final_class_silence)
6921 if (
Record->hasAttr<TrivialABIAttr>())
6926 bool HasTrivialABI =
Record->hasAttr<TrivialABIAttr>();
6929 Record->setHasTrivialSpecialMemberForCall();
6939 auto CheckCompletedMemberFunction = [&](
CXXMethodDecl *MD) {
6950 MD->
isDeleted() ? diag::err_deleted_override
6951 : diag::err_non_deleted_override,
6955 if (MD->isDefaulted() && MD->isDeleted())
6964 MD->isConsteval() ? diag::err_consteval_override
6965 : diag::err_non_consteval_override,
6967 return MD->isConsteval() !=
V->isConsteval();
6969 if (MD->isDefaulted() && MD->isDeleted())
6976 auto CheckForDefaultedFunction = [&](
FunctionDecl *FD) ->
bool {
6977 if (!FD || FD->
isInvalidDecl() || !FD->isExplicitlyDefaulted())
6983 DefaultedSecondaryComparisons.push_back(FD);
6991 if (!
Record->isInvalidDecl() &&
6992 Record->hasAttr<VTablePointerAuthenticationAttr>())
6997 bool Incomplete = CheckForDefaultedFunction(M);
7000 if (
Record->isDependentType())
7006 if (!M->isImplicit() && !M->isUserProvided()) {
7010 Record->finishedDefaultedOrDeletedMember(M);
7011 M->setTrivialForCall(
7014 Record->setTrivialForCallFlags(M);
7023 M->isUserProvided()) {
7024 M->setTrivialForCall(HasTrivialABI);
7025 Record->setTrivialForCallFlags(M);
7028 if (!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&
7029 M->hasAttr<DLLExportAttr>()) {
7035 M->dropAttr<DLLExportAttr>();
7037 if (M->hasAttr<DLLExportAttr>()) {
7043 bool EffectivelyConstexprDestructor =
true;
7047 if (isa<CXXDestructorDecl>(M)) {
7048 auto Check = [](
QualType T,
auto &&Check) ->
bool {
7057 QualType CanUnqualT =
T.getCanonicalType().getUnqualifiedType();
7059 if (B.getType().getCanonicalType().getUnqualifiedType() !=
7061 !Check(B.getType(), Check))
7070 EffectivelyConstexprDestructor =
7078 M->isDefaulted() && M->isConstexpr() && M->size_overridden_methods() &&
7079 EffectivelyConstexprDestructor)
7083 CheckCompletedMemberFunction(M);
7092 CompleteMemberFunction(Dtor);
7094 bool HasMethodWithOverrideControl =
false,
7095 HasOverridingMethodWithoutOverrideControl =
false;
7096 for (
auto *
D :
Record->decls()) {
7097 if (
auto *M = dyn_cast<CXXMethodDecl>(
D)) {
7100 if (!
Record->isDependentType()) {
7105 if (M->hasAttr<OverrideAttr>())
7106 HasMethodWithOverrideControl =
true;
7107 else if (M->size_overridden_methods() > 0)
7108 HasOverridingMethodWithoutOverrideControl =
true;
7111 if (!isa<CXXDestructorDecl>(M))
7112 CompleteMemberFunction(M);
7113 }
else if (
auto *F = dyn_cast<FriendDecl>(
D)) {
7114 CheckForDefaultedFunction(
7115 dyn_cast_or_null<FunctionDecl>(F->getFriendDecl()));
7119 if (HasOverridingMethodWithoutOverrideControl) {
7120 bool HasInconsistentOverrideControl = HasMethodWithOverrideControl;
7121 for (
auto *M :
Record->methods())
7126 for (
FunctionDecl *FD : DefaultedSecondaryComparisons) {
7130 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD))
7131 CheckCompletedMemberFunction(MD);
7149 Diag(
Record->getLocation(), diag::warn_cxx_ms_struct);
7155 bool ClangABICompat4 =
7163 if (
Record->getArgPassingRestrictions() !=
7165 Record->setArgPassingRestrictions(
7174 Record->setParamDestroyedInCallee(
true);
7175 else if (
Record->hasNonTrivialDestructor())
7176 Record->setParamDestroyedInCallee(CanPass);
7185 if (
Record->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>())
7187 else if (
Record->hasAttr<CUDADeviceBuiltinTextureTypeAttr>())
7205 unsigned LHSQuals = 0;
7208 LHSQuals = FieldQuals;
7210 unsigned RHSQuals = FieldQuals;
7232 llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
7238 : S(S), UseLoc(UseLoc) {
7239 bool DiagnosedMultipleConstructedBases =
false;
7245 for (
auto *
D : Shadow->
redecls()) {
7246 auto *DShadow = cast<ConstructorUsingShadowDecl>(
D);
7247 auto *DNominatedBase = DShadow->getNominatedBaseClass();
7248 auto *DConstructedBase = DShadow->getConstructedBaseClass();
7250 InheritedFromBases.insert(
7251 std::make_pair(DNominatedBase->getCanonicalDecl(),
7252 DShadow->getNominatedBaseClassShadowDecl()));
7253 if (DShadow->constructsVirtualBase())
7254 InheritedFromBases.insert(
7255 std::make_pair(DConstructedBase->getCanonicalDecl(),
7256 DShadow->getConstructedBaseClassShadowDecl()));
7258 assert(DNominatedBase == DConstructedBase);
7263 if (!ConstructedBase) {
7264 ConstructedBase = DConstructedBase;
7265 ConstructedBaseIntroducer =
D->getIntroducer();
7266 }
else if (ConstructedBase != DConstructedBase &&
7268 if (!DiagnosedMultipleConstructedBases) {
7269 S.
Diag(UseLoc, diag::err_ambiguous_inherited_constructor)
7272 diag::note_ambiguous_inherited_constructor_using)
7274 DiagnosedMultipleConstructedBases =
true;
7277 diag::note_ambiguous_inherited_constructor_using)
7278 << DConstructedBase;
7282 if (DiagnosedMultipleConstructedBases)
7289 std::pair<CXXConstructorDecl *, bool>
7291 auto It = InheritedFromBases.find(
Base->getCanonicalDecl());
7292 if (It == InheritedFromBases.end())
7293 return std::make_pair(
nullptr,
false);
7297 return std::make_pair(
7299 It->second->constructsVirtualBase());
7302 return std::make_pair(Ctor,
false);
7319 if (InheritedCtor) {
7322 Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;
7324 return BaseCtor->isConstexpr();
7392 if (Ctor && ClassDecl->
isUnion())
7412 for (
const auto &B : ClassDecl->
bases()) {
7418 InheritedCtor, Inherited))
7431 for (
const auto *F : ClassDecl->
fields()) {
7432 if (F->isInvalidDecl())
7435 F->hasInClassInitializer())
7439 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
7442 ConstArg && !F->isMutable()))
7457struct ComputingExceptionSpec {
7468 ~ComputingExceptionSpec() {
7488 if (DFK.isSpecialMember())
7490 S,
Loc, cast<CXXMethodDecl>(FD), DFK.asSpecialMember(),
nullptr);
7491 if (DFK.isComparison())
7493 DFK.asComparison());
7495 auto *CD = cast<CXXConstructorDecl>(FD);
7496 assert(CD->getInheritedConstructor() &&
7497 "only defaulted functions and inherited constructors have implicit "
7500 S,
Loc, CD->getInheritedConstructor().getShadowDecl());
7527 auto ESI = IES.getExceptionSpec();
7545 PT.getNonReferenceType()->getAsCXXRecordDecl()) {
7566 "not an explicitly-defaulted special member");
7576 bool HadError =
false;
7589 bool ShouldDeleteForTypeMismatch =
false;
7590 unsigned ExpectedParams = 1;
7602 if (DeleteOnTypeMismatch)
7603 ShouldDeleteForTypeMismatch =
true;
7613 bool CanHaveConstParam =
false;
7623 ReturnType =
Type->getReturnType();
7634 Diag(MD->
getLocation(), diag::err_defaulted_special_member_return_type)
7636 << ExpectedReturnType;
7642 if (DeleteOnTypeMismatch)
7643 ShouldDeleteForTypeMismatch =
true;
7660 if (!ExplicitObjectParameter.
isNull() &&
7664 if (DeleteOnTypeMismatch)
7665 ShouldDeleteForTypeMismatch =
true;
7668 diag::err_defaulted_special_member_explicit_object_mismatch)
7681 bool HasConstParam =
false;
7688 if (DeleteOnTypeMismatch)
7689 ShouldDeleteForTypeMismatch =
true;
7692 diag::err_defaulted_special_member_volatile_param)
7693 << llvm::to_underlying(CSM);
7698 if (HasConstParam && !CanHaveConstParam) {
7699 if (DeleteOnTypeMismatch)
7700 ShouldDeleteForTypeMismatch =
true;
7704 diag::err_defaulted_special_member_copy_const_param)
7710 diag::err_defaulted_special_member_move_const_param)
7715 }
else if (ExpectedParams) {
7719 "unexpected non-ref argument");
7748 : isa<CXXConstructorDecl>(MD))) &&
7753 diag::err_incorrect_defaulted_constexpr_with_vb)
7754 << llvm::to_underlying(CSM);
7755 for (
const auto &I : RD->
vbases())
7756 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here);
7775 if (!
Type->hasExceptionSpec()) {
7793 << llvm::to_underlying(CSM);
7794 if (ShouldDeleteForTypeMismatch) {
7796 << llvm::to_underlying(CSM);
7800 Diag(DefaultLoc, diag::note_replace_equals_default_to_delete)
7804 if (ShouldDeleteForTypeMismatch && !HadError) {
7806 diag::warn_cxx17_compat_defaulted_method_type_mismatch)
7807 << llvm::to_underlying(CSM);
7814 << llvm::to_underlying(CSM);
7815 assert(!ShouldDeleteForTypeMismatch &&
"deleted non-first decl");
7837template<
typename Derived,
typename ResultList,
typename Result,
7839class DefaultedComparisonVisitor {
7844 DefaultedComparisonKind DCK)
7845 : S(S), RD(RD), FD(FD), DCK(DCK) {
7849 Fns.assign(Info->getUnqualifiedLookups().begin(),
7850 Info->getUnqualifiedLookups().end());
7854 ResultList visit() {
7862 case DefaultedComparisonKind::None:
7863 llvm_unreachable(
"not a defaulted comparison");
7865 case DefaultedComparisonKind::Equal:
7866 case DefaultedComparisonKind::ThreeWay:
7867 getDerived().visitSubobjects(Results, RD, ParamLvalType.
getQualifiers());
7870 case DefaultedComparisonKind::NotEqual:
7871 case DefaultedComparisonKind::Relational:
7872 Results.add(getDerived().visitExpandedSubobject(
7873 ParamLvalType, getDerived().getCompleteObject()));
7876 llvm_unreachable(
"");
7880 Derived &getDerived() {
return static_cast<Derived&
>(*this); }
7891 if (Results.add(getDerived().visitSubobject(
7893 getDerived().getBase(&
Base))))
7900 if (
Field->isUnnamedBitField())
7903 if (
Field->isAnonymousStructOrUnion()) {
7904 if (visitSubobjects(Results,
Field->getType()->getAsCXXRecordDecl(),
7912 if (
Field->isMutable())
7917 if (Results.add(getDerived().visitSubobject(
7918 FieldType, getDerived().getField(Field))))
7926 Result visitSubobject(
QualType Type, Subobject Subobj) {
7929 if (
auto *CAT = dyn_cast_or_null<ConstantArrayType>(AT))
7930 return getDerived().visitSubobjectArray(CAT->getElementType(),
7931 CAT->getSize(), Subobj);
7932 return getDerived().visitExpandedSubobject(
Type, Subobj);
7935 Result visitSubobjectArray(
QualType Type,
const llvm::APInt &Size,
7937 return getDerived().visitSubobject(
Type, Subobj);
7944 DefaultedComparisonKind DCK;
7950struct DefaultedComparisonInfo {
7955 static DefaultedComparisonInfo deleted() {
7956 DefaultedComparisonInfo
Deleted;
7961 bool add(
const DefaultedComparisonInfo &R) {
7971struct DefaultedComparisonSubobject {
7979class DefaultedComparisonAnalyzer
7980 :
public DefaultedComparisonVisitor<DefaultedComparisonAnalyzer,
7981 DefaultedComparisonInfo,
7982 DefaultedComparisonInfo,
7983 DefaultedComparisonSubobject> {
7985 enum DiagnosticKind { NoDiagnostics, ExplainDeleted, ExplainConstexpr };
7988 DiagnosticKind Diagnose;
7991 using Base = DefaultedComparisonVisitor;
7992 using Result = DefaultedComparisonInfo;
7993 using Subobject = DefaultedComparisonSubobject;
7998 DefaultedComparisonKind DCK,
7999 DiagnosticKind Diagnose = NoDiagnostics)
8000 :
Base(S, RD, FD, DCK), Diagnose(Diagnose) {}
8003 if ((DCK == DefaultedComparisonKind::Equal ||
8004 DCK == DefaultedComparisonKind::ThreeWay) &&
8009 if (Diagnose == ExplainDeleted) {
8013 return Result::deleted();
8016 return Base::visit();
8020 Subobject getCompleteObject() {
8021 return Subobject{Subobject::CompleteObject, RD, FD->
getLocation()};
8025 return Subobject{Subobject::Base,
Base->getType()->getAsCXXRecordDecl(),
8026 Base->getBaseTypeLoc()};
8030 return Subobject{Subobject::Member,
Field,
Field->getLocation()};
8033 Result visitExpandedSubobject(
QualType Type, Subobject Subobj) {
8038 if (Diagnose == ExplainDeleted) {
8039 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_reference_member)
8042 return Result::deleted();
8047 Expr *Args[] = {&Xi, &Xi};
8051 assert(OO !=
OO_None &&
"not an overloaded operator!");
8052 return visitBinaryOperator(OO, Args, Subobj);
8066 !SpaceshipCandidates));
8071 CandidateSet.exclude(FD);
8073 if (Args[0]->getType()->isOverloadableType())
8084 switch (CandidateSet.BestViableFunction(S, FD->
getLocation(), Best)) {
8090 if ((DCK == DefaultedComparisonKind::NotEqual ||
8091 DCK == DefaultedComparisonKind::Relational) &&
8092 !Best->RewriteKind) {
8093 if (Diagnose == ExplainDeleted) {
8094 if (Best->Function) {
8095 S.
Diag(Best->Function->getLocation(),
8096 diag::note_defaulted_comparison_not_rewritten_callee)
8099 assert(Best->Conversions.size() == 2 &&
8100 Best->Conversions[0].isUserDefined() &&
8101 "non-user-defined conversion from class to built-in "
8103 S.
Diag(Best->Conversions[0]
8104 .UserDefined.FoundConversionFunction.getDecl()
8106 diag::note_defaulted_comparison_not_rewritten_conversion)
8110 return Result::deleted();
8120 CXXRecordDecl *ArgClass = Args[0]->getType()->getAsCXXRecordDecl();
8121 if (ArgClass && Best->FoundDecl.getDecl() &&
8122 Best->FoundDecl.getDecl()->isCXXClassMember()) {
8123 QualType ObjectType = Subobj.Kind == Subobject::Member
8124 ? Args[0]->getType()
8127 ArgClass, Best->FoundDecl, ObjectType, Subobj.Loc,
8128 Diagnose == ExplainDeleted
8129 ? S.
PDiag(diag::note_defaulted_comparison_inaccessible)
8130 << FD << Subobj.Kind << Subobj.Decl
8132 return Result::deleted();
8135 bool NeedsDeducing =
8143 assert(!BestFD->isDeleted() &&
"wrong overload resolution result");
8145 if (Diagnose == ExplainConstexpr && !BestFD->isConstexpr()) {
8146 if (Subobj.Kind != Subobject::CompleteObject)
8147 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_not_constexpr)
8148 << Subobj.
Kind << Subobj.Decl;
8149 S.
Diag(BestFD->getLocation(),
8150 diag::note_defaulted_comparison_not_constexpr_here);
8152 return Result::deleted();
8154 R.Constexpr &= BestFD->isConstexpr();
8156 if (NeedsDeducing) {
8161 if (BestFD->getReturnType()->isUndeducedType() &&
8167 if (Diagnose == NoDiagnostics) {
8170 diag::err_defaulted_comparison_cannot_deduce_undeduced_auto)
8171 << Subobj.
Kind << Subobj.Decl;
8174 diag::note_defaulted_comparison_cannot_deduce_undeduced_auto)
8175 << Subobj.
Kind << Subobj.Decl;
8176 S.
Diag(BestFD->getLocation(),
8177 diag::note_defaulted_comparison_cannot_deduce_callee)
8178 << Subobj.
Kind << Subobj.Decl;
8180 return Result::deleted();
8183 BestFD->getCallResultType());
8185 if (Diagnose == ExplainDeleted) {
8186 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_cannot_deduce)
8187 << Subobj.
Kind << Subobj.Decl
8188 << BestFD->getCallResultType().withoutLocalFastQualifiers();
8189 S.
Diag(BestFD->getLocation(),
8190 diag::note_defaulted_comparison_cannot_deduce_callee)
8191 << Subobj.
Kind << Subobj.Decl;
8193 return Result::deleted();
8195 R.Category = Info->Kind;
8198 QualType T = Best->BuiltinParamTypes[0];
8199 assert(
T == Best->BuiltinParamTypes[1] &&
8200 "builtin comparison for different types?");
8201 assert(Best->BuiltinParamTypes[2].isNull() &&
8202 "invalid builtin comparison");
8204 if (NeedsDeducing) {
8205 std::optional<ComparisonCategoryType> Cat =
8207 assert(Cat &&
"no category for builtin comparison?");
8218 if (Diagnose == ExplainDeleted) {
8221 Kind = OO == OO_EqualEqual ? 1 : 2;
8222 CandidateSet.NoteCandidates(
8224 Subobj.Loc, S.
PDiag(diag::note_defaulted_comparison_ambiguous)
8225 << FD <<
Kind << Subobj.Kind << Subobj.Decl),
8228 R = Result::deleted();
8232 if (Diagnose == ExplainDeleted) {
8233 if ((DCK == DefaultedComparisonKind::NotEqual ||
8234 DCK == DefaultedComparisonKind::Relational) &&
8235 !Best->RewriteKind) {
8236 S.
Diag(Best->Function->getLocation(),
8237 diag::note_defaulted_comparison_not_rewritten_callee)
8241 diag::note_defaulted_comparison_calls_deleted)
8242 << FD << Subobj.
Kind << Subobj.Decl;
8246 R = Result::deleted();
8252 if (OO == OO_Spaceship &&
8256 if (!R.add(visitBinaryOperator(OO_EqualEqual, Args, Subobj,
8258 R.add(visitBinaryOperator(OO_Less, Args, Subobj, &CandidateSet));
8262 if (Diagnose == ExplainDeleted) {
8263 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_no_viable_function)
8264 << FD << (OO == OO_EqualEqual || OO == OO_ExclaimEqual)
8265 << Subobj.
Kind << Subobj.Decl;
8269 if (SpaceshipCandidates) {
8270 SpaceshipCandidates->NoteCandidates(
8275 diag::note_defaulted_comparison_no_viable_function_synthesized)
8276 << (OO == OO_EqualEqual ? 0 : 1);
8279 CandidateSet.NoteCandidates(
8284 R = Result::deleted();
8293struct StmtListResult {
8294 bool IsInvalid =
false;
8298 IsInvalid |= S.isInvalid();
8301 Stmts.push_back(S.get());
8308class DefaultedComparisonSynthesizer
8309 :
public DefaultedComparisonVisitor<DefaultedComparisonSynthesizer,
8310 StmtListResult, StmtResult,
8311 std::pair<ExprResult, ExprResult>> {
8313 unsigned ArrayDepth = 0;
8316 using Base = DefaultedComparisonVisitor;
8317 using ExprPair = std::pair<ExprResult, ExprResult>;
8322 DefaultedComparisonKind DCK,
8324 :
Base(S, RD, FD, DCK),
Loc(BodyLoc) {}
8330 StmtListResult Stmts = visit();
8331 if (Stmts.IsInvalid)
8336 case DefaultedComparisonKind::None:
8337 llvm_unreachable(
"not a defaulted comparison");
8339 case DefaultedComparisonKind::Equal: {
8348 auto OldStmts = std::move(Stmts.Stmts);
8349 Stmts.Stmts.clear();
8352 auto FinishCmp = [&] {
8353 if (
Expr *Prior = CmpSoFar.
get()) {
8355 if (RetVal.
isUnset() && Stmts.Stmts.empty())
8358 else if (Stmts.add(buildIfNotCondReturnFalse(Prior)))
8364 for (
Stmt *EAsStmt : llvm::reverse(OldStmts)) {
8365 Expr *
E = dyn_cast<Expr>(EAsStmt);
8368 if (FinishCmp() || Stmts.add(EAsStmt))
8383 std::reverse(Stmts.Stmts.begin(), Stmts.Stmts.end());
8390 case DefaultedComparisonKind::ThreeWay: {
8394 ComparisonCategoryType::StrongOrdering,
Loc,
8395 Sema::ComparisonCategoryUsage::DefaultedOperator);
8401 RetVal = getDecl(EqualVD);
8404 RetVal = buildStaticCastToR(RetVal.
get());
8408 case DefaultedComparisonKind::NotEqual:
8409 case DefaultedComparisonKind::Relational:
8410 RetVal = cast<Expr>(Stmts.Stmts.pop_back_val());
8436 ExprPair getCompleteObject() {
8439 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD);
8446 LHS = getParam(Param++);
8454 ExprPair Obj = getCompleteObject();
8455 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8458 const auto CastToBase = [&](
Expr *
E) {
8463 return {CastToBase(Obj.first.get()), CastToBase(Obj.second.get())};
8467 ExprPair Obj = getCompleteObject();
8468 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8491 assert(!
False.isInvalid() &&
"should never fail");
8498 Sema::ConditionKind::Boolean),
8511 llvm::raw_svector_ostream OS(Str);
8512 OS <<
"i" << ArrayDepth;
8523 auto IterRef = [&] {
8527 assert(!Ref.
isInvalid() &&
"can't reference our own variable?");
8533 Loc, BO_NE, IterRef(),
8535 assert(!Cond.
isInvalid() &&
"should never fail");
8539 assert(!
Inc.isInvalid() &&
"should never fail");
8547 Subobj.first = Index(Subobj.first);
8548 Subobj.second = Index(Subobj.second);
8561 if (
Expr *ElemCmp = dyn_cast<Expr>(Substmt.
get())) {
8562 assert(DCK == DefaultedComparisonKind::Equal &&
8563 "should have non-expression statement");
8564 Substmt = buildIfNotCondReturnFalse(ElemCmp);
8572 Sema::ConditionKind::Boolean),
8578 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8586 Obj.second.get(),
true,
8594 case DefaultedComparisonKind::None:
8595 llvm_unreachable(
"not a defaulted comparison");
8597 case DefaultedComparisonKind::Equal:
8605 case DefaultedComparisonKind::ThreeWay: {
8610 Op = buildStaticCastToR(Op.
get());
8635 if (
Comp.isInvalid())
8638 nullptr,
Loc,
Comp.get(), Sema::ConditionKind::Boolean);
8643 VDRef = getDecl(VD);
8656 case DefaultedComparisonKind::NotEqual:
8657 case DefaultedComparisonKind::Relational:
8662 llvm_unreachable(
"");
8668 assert(!R->
isUndeducedType() &&
"type should have been deduced already");
8686 Self.LookupOverloadedOperatorName(OO, S, Operators);
8699 if (Op == OO_Spaceship) {
8700 Lookup(OO_ExclaimEqual);
8702 Lookup(OO_EqualEqual);
8730 bool IsMethod = isa<CXXMethodDecl>(FD);
8732 auto *MD = cast<CXXMethodDecl>(FD);
8733 assert(!MD->
isStatic() &&
"comparison function cannot be a static member");
8743 FPT->getParamTypes(), EPI));
8750 if (!
T.getNonReferenceType().isConstQualified() &&
8760 InsertLoc =
Loc.getRParenLoc();
8765 Diag(
Loc, diag::err_defaulted_comparison_non_const)
8773 T.getNonReferenceType().withConst()));
8779 FPT->getParamTypes(), EPI));
8791 FPT->getParamTypes(), EPI));
8797 (IsMethod ? 1 : 2)) {
8801 <<
int(IsMethod) <<
int(DCK);
8807 QualType ParmTy = Param->getType();
8816 CTy = Ref->getPointeeType();
8826 RD = CTy->getAsCXXRecordDecl();
8827 Ok &= RD !=
nullptr;
8841 <<
int(DCK) << ParmTy << RefTy <<
int(!IsMethod) << PlainTy
8842 << Param->getSourceRange();
8844 assert(!IsMethod &&
"should know expected type for method");
8846 diag::err_defaulted_comparison_param_unknown)
8847 <<
int(DCK) << ParmTy << Param->getSourceRange();
8853 Diag(FD->
getLocation(), diag::err_defaulted_comparison_param_mismatch)
8855 << ParmTy << Param->getSourceRange();
8860 assert(RD &&
"must have determined class");
8869 diag::err_defaulted_comparison_not_friend,
int(DCK),
8874 return FD->getCanonicalDecl() ==
8875 F->getFriendDecl()->getCanonicalDecl();
8878 <<
int(DCK) <<
int(0) << RD;
8890 Diag(FD->
getLocation(), diag::err_defaulted_comparison_return_type_not_bool)
8900 RT->getContainedDeducedType() &&
8902 RT->getContainedAutoType()->isConstrained())) {
8904 diag::err_defaulted_comparison_deduced_return_type_not_auto)
8916 DefaultedComparisonInfo Info =
8917 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK).visit();
8931 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK,
8932 DefaultedComparisonAnalyzer::ExplainDeleted)
8943 diag::note_previous_declaration);
8955 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK,
8956 DefaultedComparisonAnalyzer::ExplainDeleted)
9006 Diag(FD->
getBeginLoc(), diag::err_defaulted_comparison_constexpr_mismatch)
9008 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK,
9009 DefaultedComparisonAnalyzer::ExplainConstexpr)
9030 EPI.ExceptionSpec.SourceDecl = FD;
9032 FPT->getParamTypes(), EPI));
9047 EqualEqual->setImplicit();
9062 Scope.addContextNote(UseLoc);
9069 CXXRecordDecl *RD = PT.getNonReferenceType()->getAsCXXRecordDecl();
9073 DefaultedComparisonSynthesizer(*
this, RD, FD, DCK, BodyLoc).build();
9087 L->CompletedImplicitDefinition(FD);
9094 ComputingExceptionSpec CES(S, FD,
Loc);
9124 DefaultedComparisonSynthesizer(S, RD, FD, DCK, BodyLoc).build();
9146 for (
auto &Check : Overriding)
9158template<
typename Derived>
9159struct SpecialMemberVisitor {
9166 bool IsConstructor =
false, IsAssignment =
false, ConstArg =
false;
9170 : S(S), MD(MD), CSM(CSM), ICI(ICI) {
9172 case CXXSpecialMemberKind::DefaultConstructor:
9173 case CXXSpecialMemberKind::CopyConstructor:
9174 case CXXSpecialMemberKind::MoveConstructor:
9175 IsConstructor =
true;
9177 case CXXSpecialMemberKind::CopyAssignment:
9178 case CXXSpecialMemberKind::MoveAssignment:
9179 IsAssignment =
true;
9181 case CXXSpecialMemberKind::Destructor:
9183 case CXXSpecialMemberKind::Invalid:
9184 llvm_unreachable(
"invalid special member kind");
9190 ConstArg = RT->getPointeeType().isConstQualified();
9194 Derived &getDerived() {
return static_cast<Derived&
>(*this); }
9197 bool isMove()
const {
9198 return CSM == CXXSpecialMemberKind::MoveConstructor ||
9199 CSM == CXXSpecialMemberKind::MoveAssignment;
9204 unsigned Quals,
bool IsMutable) {
9206 ConstArg && !IsMutable);
9214 assert(CSM == CXXSpecialMemberKind::DefaultConstructor);
9216 cast<CXXConstructorDecl>(MD)->getInheritedConstructor().getConstructor();
9223 typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
9230 return B->getBaseTypeLoc();
9232 return cast<FieldDecl *>(Subobj)->getLocation();
9237 VisitNonVirtualBases,
9242 VisitPotentiallyConstructedBases,
9248 bool visit(BasesToVisit Bases) {
9251 if (Bases == VisitPotentiallyConstructedBases)
9252 Bases = RD->
isAbstract() ? VisitNonVirtualBases : VisitAllBases;
9254 for (
auto &B : RD->
bases())
9255 if ((Bases == VisitDirectBases || !B.isVirtual()) &&
9256 getDerived().visitBase(&B))
9259 if (Bases == VisitAllBases)
9260 for (
auto &B : RD->
vbases())
9261 if (getDerived().visitBase(&B))
9264 for (
auto *F : RD->
fields())
9265 if (!F->isInvalidDecl() && !F->isUnnamedBitField() &&
9266 getDerived().visitField(F))
9275struct SpecialMemberDeletionInfo
9276 : SpecialMemberVisitor<SpecialMemberDeletionInfo> {
9281 bool AllFieldsAreConst;
9286 : SpecialMemberVisitor(S, MD, CSM, ICI), Diagnose(Diagnose),
9287 Loc(MD->getLocation()), AllFieldsAreConst(
true) {}
9292 return ICI ? CXXSpecialMemberKind::Invalid : CSM;
9298 bool visitField(
FieldDecl *Field) {
return shouldDeleteForField(Field); }
9301 bool shouldDeleteForField(
FieldDecl *FD);
9302 bool shouldDeleteForAllConstMembers();
9304 bool shouldDeleteForClassSubobject(
CXXRecordDecl *Class, Subobject Subobj,
9306 bool shouldDeleteForSubobjectCall(Subobject Subobj,
9308 bool IsDtorCallInCtor);
9316bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
9337bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
9339 bool IsDtorCallInCtor) {
9346 DiagKind = !
Decl ? 0 : 1;
9349 else if (!isAccessible(Subobj,
Decl))
9351 else if (!IsDtorCallInCtor && Field &&
Field->getParent()->isUnion() &&
9352 !
Decl->isTrivial()) {
9364 const auto *RD = cast<CXXRecordDecl>(
Field->getParent());
9378 diag::note_deleted_special_member_class_subobject)
9379 << llvm::to_underlying(getEffectiveCSM()) << MD->
getParent()
9380 <<
true <<
Field << DiagKind << IsDtorCallInCtor
9385 diag::note_deleted_special_member_class_subobject)
9386 << llvm::to_underlying(getEffectiveCSM()) << MD->
getParent()
9387 <<
false <<
Base->getType() << DiagKind
9388 << IsDtorCallInCtor <<
false;
9401bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
9404 bool IsMutable =
Field &&
Field->isMutable();
9421 Field->hasInClassInitializer()) &&
9422 shouldDeleteForSubobjectCall(Subobj, lookupIn(
Class, Quals, IsMutable),
9429 if (IsConstructor) {
9432 false,
false,
false,
false);
9433 if (shouldDeleteForSubobjectCall(Subobj, SMOR,
true))
9440bool SpecialMemberDeletionInfo::shouldDeleteForVariantObjCPtrMember(
9455 auto *ParentClass = cast<CXXRecordDecl>(FD->
getParent());
9456 S.
Diag(FD->
getLocation(), diag::note_deleted_special_member_class_subobject)
9457 << llvm::to_underlying(getEffectiveCSM()) << ParentClass
9458 <<
true << FD << 4 <<
false
9476 if (
auto *BaseCtor = SMOR.
getMethod()) {
9481 if (BaseCtor->isDeleted() &&
Diagnose) {
9483 diag::note_deleted_special_member_class_subobject)
9484 << llvm::to_underlying(getEffectiveCSM()) << MD->
getParent()
9485 <<
false <<
Base->getType() << 1
9489 return BaseCtor->isDeleted();
9491 return shouldDeleteForClassSubobject(BaseClass,
Base, 0);
9496bool SpecialMemberDeletionInfo::shouldDeleteForField(
FieldDecl *FD) {
9500 if (inUnion() && shouldDeleteForVariantObjCPtrMember(FD, FieldType))
9508 S.
Diag(FD->
getLocation(), diag::note_deleted_default_ctor_uninit_field)
9509 << !!ICI << MD->
getParent() << FD << FieldType << 0;
9519 S.
Diag(FD->
getLocation(), diag::note_deleted_default_ctor_uninit_field)
9525 AllFieldsAreConst =
false;
9531 S.
Diag(FD->
getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
9535 }
else if (IsAssignment) {
9540 << isMove() << MD->
getParent() << FD << FieldType << 0;
9555 if (!inUnion() && FieldRecord->
isUnion() &&
9557 bool AllVariantFieldsAreConst =
true;
9560 for (
auto *UI : FieldRecord->
fields()) {
9563 if (shouldDeleteForVariantObjCPtrMember(&*UI, UnionFieldType))
9567 AllVariantFieldsAreConst =
false;
9570 if (UnionFieldRecord &&
9571 shouldDeleteForClassSubobject(UnionFieldRecord, UI,
9578 AllVariantFieldsAreConst && !FieldRecord->
field_empty()) {
9581 diag::note_deleted_default_ctor_all_const)
9592 if (shouldDeleteForClassSubobject(FieldRecord, FD,
9603bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
9607 AllFieldsAreConst) {
9608 bool AnyFields =
false;
9610 if ((AnyFields = !F->isUnnamedBitField()))
9616 diag::note_deleted_default_ctor_all_const)
9669 bool DeletesOnlyMatchingCopy =
9674 (!DeletesOnlyMatchingCopy ||
9679 for (
auto *I : RD->
ctors()) {
9680 if (I->isMoveConstructor()) {
9681 UserDeclaredMove = I;
9685 assert(UserDeclaredMove);
9687 (!DeletesOnlyMatchingCopy ||
9692 for (
auto *I : RD->
methods()) {
9693 if (I->isMoveAssignmentOperator()) {
9694 UserDeclaredMove = I;
9698 assert(UserDeclaredMove);
9701 if (UserDeclaredMove) {
9703 diag::note_deleted_copy_user_declared_move)
9721 OperatorDelete,
false)) {
9728 SpecialMemberDeletionInfo SMI(*
this, MD, CSM, ICI,
Diagnose);
9736 if (SMI.visit(SMI.IsAssignment ? SMI.VisitDirectBases
9737 : SMI.VisitPotentiallyConstructedBases))
9740 if (SMI.shouldDeleteForAllConstMembers())
9764 assert(DFK &&
"not a defaultable function");
9771 DefaultedComparisonAnalyzer(
9773 DFK.
asComparison(), DefaultedComparisonAnalyzer::ExplainDeleted)
9795 *Selected =
nullptr;
9799 llvm_unreachable(
"not a special member");
9817 for (
auto *CI : RD->
ctors()) {
9818 if (!CI->isDefaultConstructor())
9825 *Selected = DefCtor;
9858 }
else if (!Selected) {
9866 goto NeedOverloadResolution;
9876 }
else if (!Selected) {
9881 goto NeedOverloadResolution;
9885 NeedOverloadResolution:
9914 llvm_unreachable(
"unknown special method kind");
9918 for (
auto *CI : RD->
ctors())
9919 if (!CI->isImplicit())
9926 dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
9957 ConstRHS, TAH,
Diagnose ? &Selected :
nullptr))
9965 S.
Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
9968 S.
Diag(CD->getLocation(), diag::note_user_declared_ctor);
9969 }
else if (!Selected)
9970 S.
Diag(SubobjLoc, diag::note_nontrivial_no_copy)
9978 S.
Diag(SubobjLoc, diag::note_nontrivial_user_provided)
9984 S.
Diag(SubobjLoc, diag::note_nontrivial_subobject)
10002 for (
const auto *FI : RD->
fields()) {
10003 if (FI->isInvalidDecl() || FI->isUnnamedBitField())
10009 if (FI->isAnonymousStructOrUnion()) {
10021 FI->hasInClassInitializer()) {
10023 S.
Diag(FI->getLocation(), diag::note_nontrivial_default_member_init)
10034 S.
Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
10039 bool ConstRHS = ConstArg && !FI->isMutable();
10062 "not special enough");
10066 bool ConstArg =
false;
10094 ClangABICompat14)) {
10124 llvm_unreachable(
"not a special member");
10130 diag::note_nontrivial_default_arg)
10149 for (
const auto &BI : RD->
bases())
10191 Diag(BS.
getBeginLoc(), diag::note_nontrivial_has_virtual) << RD << 1;
10196 for (
const auto *MI : RD->
methods()) {
10197 if (MI->isVirtual()) {
10199 Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
10204 llvm_unreachable(
"dynamic class with no vbases and no virtual functions");
10212struct FindHiddenVirtualMethod {
10220 static bool CheckMostOverridenMethods(
10222 const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
10226 if (CheckMostOverridenMethods(O, Methods))
10242 bool foundSameNameMethod =
false;
10249 foundSameNameMethod =
true;
10266 if (!CheckMostOverridenMethods(MD, OverridenAndUsingBaseMethods))
10267 overloadedMethods.push_back(MD);
10271 if (foundSameNameMethod)
10272 OverloadedMethods.append(overloadedMethods.begin(),
10273 overloadedMethods.end());
10274 return foundSameNameMethod;
10281 llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
10297 FindHiddenVirtualMethod FHVM;
10308 ND = shad->getTargetDecl();
10314 OverloadedMethods = FHVM.OverloadedMethods;
10319 for (
unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
10322 diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
10337 if (!OverloadedMethods.empty()) {
10339 << MD << (OverloadedMethods.size() > 1);
10346 auto PrintDiagAndRemoveAttr = [&](
unsigned N) {
10349 Diag(RD.
getAttr<TrivialABIAttr>()->getLocation(),
10350 diag::ext_cannot_use_trivial_abi) << &RD;
10351 Diag(RD.
getAttr<TrivialABIAttr>()->getLocation(),
10352 diag::note_cannot_use_trivial_abi_reason) << &RD << N;
10358 auto HasNonDeletedCopyOrMoveConstructor = [&]() {
10370 if (CD->isCopyOrMoveConstructor() && !CD->isDeleted())
10375 if (!HasNonDeletedCopyOrMoveConstructor()) {
10376 PrintDiagAndRemoveAttr(0);
10382 PrintDiagAndRemoveAttr(1);
10386 for (
const auto &B : RD.
bases()) {
10389 if (!B.getType()->isDependentType() &&
10390 !B.getType()->getAsCXXRecordDecl()->canPassInRegisters()) {
10391 PrintDiagAndRemoveAttr(2);
10395 if (B.isVirtual()) {
10396 PrintDiagAndRemoveAttr(3);
10401 for (
const auto *FD : RD.
fields()) {
10406 PrintDiagAndRemoveAttr(4);
10411 if (!RT->isDependentType() &&
10412 !cast<CXXRecordDecl>(RT->getDecl())->canPassInRegisters()) {
10413 PrintDiagAndRemoveAttr(5);
10422 diag::err_incomplete_type_vtable_pointer_auth))
10430 assert(PrimaryBase);
10433 if (!BasePtr.getType()->getAsCXXRecordDecl()->isDynamicClass())
10435 Base = BasePtr.getType()->getAsCXXRecordDecl();
10438 if (!
Base ||
Base == PrimaryBase || !
Base->isPolymorphic())
10440 Diag(RD.
getAttr<VTablePointerAuthenticationAttr>()->getLocation(),
10441 diag::err_non_top_level_vtable_pointer_auth)
10443 PrimaryBase =
Base;
10447 Diag(RD.
getAttr<VTablePointerAuthenticationAttr>()->getLocation(),
10448 diag::err_non_polymorphic_vtable_pointer_auth)
10461 if (AL.getKind() != ParsedAttr::AT_Visibility)
10464 Diag(AL.getLoc(), diag::warn_attribute_after_definition_ignored) << AL;
10472 LBrac, RBrac, AttrList);
10494 Spaceships.clear();
10500 Spaceships.push_back(FD);
10509 if (
auto *FD = dyn_cast<FunctionDecl>(ND))
10510 if (FD->isExplicitlyDefaulted())
10511 Spaceships.push_back(FD);
10606 DefaultedSpaceships);
10607 for (
auto *FD : DefaultedSpaceships)
10614 llvm::function_ref<
Scope *()> EnterScope) {
10625 for (
unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
10626 ParameterLists.push_back(DD->getTemplateParameterList(i));
10630 ParameterLists.push_back(FTD->getTemplateParameters());
10631 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(
D)) {
10635 ParameterLists.push_back(VTD->getTemplateParameters());
10636 else if (
auto *PSD = dyn_cast<VarTemplatePartialSpecializationDecl>(
D))
10637 ParameterLists.push_back(PSD->getTemplateParameters());
10639 }
else if (
TagDecl *TD = dyn_cast<TagDecl>(
D)) {
10640 for (
unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
10641 ParameterLists.push_back(TD->getTemplateParameterList(i));
10645 ParameterLists.push_back(CTD->getTemplateParameters());
10646 else if (
auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(
D))
10647 ParameterLists.push_back(PSD->getTemplateParameters());
10652 unsigned Count = 0;
10653 Scope *InnermostTemplateScope =
nullptr;
10657 if (Params->size() == 0)
10660 InnermostTemplateScope = EnterScope();
10662 if (Param->getDeclName()) {
10663 InnermostTemplateScope->
AddDecl(Param);
10671 if (InnermostTemplateScope) {
10672 assert(LookupDC &&
"no enclosing DeclContext for template lookup");
10680 if (!RecordD)
return;
10687 if (!RecordD)
return;
10744 bool DiagOccured =
false;
10746 [DiagID, &S, &DiagOccured](
DeclSpec::TQ, StringRef QualName,
10753 DiagOccured =
true;
10756 D.setInvalidType();
10762 if (
D.isInvalidType() ||
D.getNumTypeObjects() <= 1)
10771 S.
Diag(PointerLoc, diag::err_invalid_ctor_dtor_decl)
10773 D.setInvalidType();
10778 bool isVirtual =
D.getDeclSpec().isVirtualSpecified();
10786 if (!
D.isInvalidType())
10787 Diag(
D.getIdentifierLoc(), diag::err_constructor_cannot_be)
10788 <<
"virtual" <<
SourceRange(
D.getDeclSpec().getVirtualSpecLoc())
10790 D.setInvalidType();
10793 if (!
D.isInvalidType())
10794 Diag(
D.getIdentifierLoc(), diag::err_constructor_cannot_be)
10795 <<
"static" <<
SourceRange(
D.getDeclSpec().getStorageClassSpecLoc())
10797 D.setInvalidType();
10801 if (
unsigned TypeQuals =
D.getDeclSpec().getTypeQualifiers()) {
10804 D.getDeclSpec().getConstSpecLoc(),
D.getDeclSpec().getVolatileSpecLoc(),
10805 D.getDeclSpec().getRestrictSpecLoc(),
10806 D.getDeclSpec().getAtomicSpecLoc());
10807 D.setInvalidType();
10820 D.setInvalidType();
10839 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
10841 return Constructor->setInvalidDecl();
10848 if (!Constructor->isInvalidDecl() &&
10849 Constructor->hasOneParamOrDefaultArgs() &&
10850 Constructor->getTemplateSpecializationKind() !=
10852 QualType ParamType = Constructor->getParamDecl(0)->getType();
10855 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
10856 const char *ConstRef
10857 = Constructor->getParamDecl(0)->getIdentifier() ?
"const &"
10859 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
10864 Constructor->setInvalidDecl();
10883 Expr *ThisArg =
nullptr;
10888 if (OperatorDelete->isDestroyingOperatorDelete()) {
10889 QualType ParamType = OperatorDelete->getParamDecl(0)->getType();
10896 ActOnCXXThis(OperatorDelete->getParamDecl(0)->getLocation());
10897 assert(!This.isInvalid() &&
"couldn't form 'this' expr in dtor?");
10900 if (This.isInvalid()) {
10903 Diag(
Loc, diag::note_implicit_delete_this_in_destructor_here);
10906 ThisArg = This.get();
10912 Destructor->setOperatorDelete(OperatorDelete, ThisArg);
10928 Diag(
D.getIdentifierLoc(), diag::ext_destructor_typedef_name)
10929 << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
10932 if (TST->isTypeAlias())
10933 Diag(
D.getIdentifierLoc(), diag::ext_destructor_typedef_name)
10934 << DeclaratorType << 1;
10945 if (!
D.isInvalidType())
10946 Diag(
D.getIdentifierLoc(), diag::err_destructor_cannot_be)
10947 <<
"static" <<
SourceRange(
D.getDeclSpec().getStorageClassSpecLoc())
10953 if (!
D.isInvalidType()) {
10962 if (
D.getDeclSpec().hasTypeSpecifier())
10963 Diag(
D.getIdentifierLoc(), diag::err_destructor_return_type)
10966 else if (
unsigned TypeQuals =
D.getDeclSpec().getTypeQualifiers()) {
10969 D.getDeclSpec().getConstSpecLoc(),
10970 D.getDeclSpec().getVolatileSpecLoc(),
10971 D.getDeclSpec().getRestrictSpecLoc(),
10972 D.getDeclSpec().getAtomicSpecLoc());
10973 D.setInvalidType();
10987 D.setInvalidType();
10992 Diag(
D.getIdentifierLoc(), diag::err_destructor_with_params);
10996 D.setInvalidType();
11001 Diag(
D.getIdentifierLoc(), diag::err_destructor_variadic);
11002 D.setInvalidType();
11009 if (!
D.isInvalidType())
11029 if (After.isInvalid())
11033 R.
setEnd(After.getEnd());
11043 if (!
D.isInvalidType())
11044 Diag(
D.getIdentifierLoc(), diag::err_conv_function_not_member)
11045 <<
SourceRange(
D.getDeclSpec().getStorageClassSpecLoc())
11047 D.setInvalidType();
11065 Diag(
D.getIdentifierLoc(), diag::err_conv_function_return_type)
11068 D.setInvalidType();
11075 Diag(
D.getIdentifierLoc(), diag::err_conv_function_with_complex_decl)
11077 D.setInvalidType();
11082 unsigned NumParam = Proto->getNumParams();
11086 if (NumParam == 1) {
11088 if (
const auto *
First =
11089 dyn_cast_if_present<ParmVarDecl>(FTI.
Params[0].
Param);
11090 First &&
First->isExplicitObjectParameter())
11094 if (NumParam != 0) {
11095 Diag(
D.getIdentifierLoc(), diag::err_conv_function_with_params);
11098 D.setInvalidType();
11099 }
else if (Proto->isVariadic()) {
11100 Diag(
D.getIdentifierLoc(), diag::err_conv_function_variadic);
11101 D.setInvalidType();
11106 if (Proto->getReturnType() != ConvType) {
11107 bool NeedsTypedef =
false;
11111 bool PastFunctionChunk =
false;
11112 for (
auto &Chunk :
D.type_objects()) {
11113 switch (Chunk.Kind) {
11115 if (!PastFunctionChunk) {
11116 if (Chunk.Fun.HasTrailingReturnType) {
11121 PastFunctionChunk =
true;
11126 NeedsTypedef =
true;
11146 After.isValid() ? After.getBegin() :
11147 D.getIdentifierLoc();
11148 auto &&DB =
Diag(
Loc, diag::err_conv_function_with_complex_decl);
11149 DB << Before << After;
11151 if (!NeedsTypedef) {
11155 if (After.isInvalid() && ConvTSI) {
11163 }
else if (!Proto->getReturnType()->isDependentType()) {
11164 DB << 1 << Proto->getReturnType();
11166 DB << 2 << Proto->getReturnType();
11177 ConvType = Proto->getReturnType();
11184 Diag(
D.getIdentifierLoc(), diag::err_conv_function_to_array);
11186 D.setInvalidType();
11188 Diag(
D.getIdentifierLoc(), diag::err_conv_function_to_function);
11190 D.setInvalidType();
11196 if (
D.isInvalidType())
11203 ? diag::warn_cxx98_compat_explicit_conversion_functions
11204 : diag::ext_explicit_conversion_functions)
11209 assert(Conversion &&
"Expected to receive a conversion function declaration");
11232 if (ConvType == ClassType)
11237 << ClassType << ConvType;
11240 << ClassType << ConvType;
11255 return ConversionTemplate;
11273 if (!
D.isFunctionDeclarator())
11280 for (
unsigned Idx = 0; Idx < FTI.
NumParams; Idx++) {
11281 const auto &ParamInfo = FTI.
Params[Idx];
11282 if (!ParamInfo.Param)
11284 ParmVarDecl *Param = cast<ParmVarDecl>(ParamInfo.Param);
11288 ExplicitObjectParam = Param;
11292 diag::err_explicit_object_parameter_must_be_first)
11296 if (!ExplicitObjectParam)
11301 diag::err_explicit_object_default_arg)
11307 D.isStaticMember())) {
11309 diag::err_explicit_object_parameter_nonmember)
11311 D.setInvalidType();
11314 if (
D.getDeclSpec().isVirtualSpecified()) {
11316 diag::err_explicit_object_parameter_nonmember)
11318 D.setInvalidType();
11340 if (
D.getDeclSpec().isFriendSpecified() &&
11341 !isa_and_present<CXXRecordDecl>(
11344 diag::err_explicit_object_parameter_nonmember)
11346 D.setInvalidType();
11351 diag::err_explicit_object_parameter_mutable)
11359 assert(
D.isInvalidType() &&
"Explicit object parameter in non-member "
11360 "should have been diagnosed already");
11368 diag::err_explicit_object_parameter_constructor)
11371 D.setInvalidType();
11378struct BadSpecifierDiagnoser {
11381 ~BadSpecifierDiagnoser() {
11389 return check(SpecLoc,
11395 if (!Specifiers.empty()) Specifiers +=
" ";
11396 Specifiers += Spec;
11401 std::string Specifiers;
11407 TemplateName GuidedTemplate =
D.getName().TemplateName.get().get();
11409 assert(GuidedTemplateDecl &&
"missing template decl for deduction guide");
11416 Diag(
D.getIdentifierLoc(), diag::err_deduction_guide_wrong_scope)
11417 << GuidedTemplateDecl;
11421 auto &DS =
D.getMutableDeclSpec();
11423 if (DS.hasTypeSpecifier() || DS.getTypeQualifiers() ||
11424 DS.getStorageClassSpecLoc().isValid() || DS.isInlineSpecified() ||
11425 DS.isNoreturnSpecified() || DS.hasConstexprSpecifier()) {
11426 BadSpecifierDiagnoser Diagnoser(
11427 *
this,
D.getIdentifierLoc(),
11428 diag::err_deduction_guide_invalid_specifier);
11430 Diagnoser.check(DS.getStorageClassSpecLoc(), DS.getStorageClassSpec());
11431 DS.ClearStorageClassSpecs();
11435 Diagnoser.check(DS.getInlineSpecLoc(),
"inline");
11436 Diagnoser.check(DS.getNoreturnSpecLoc(),
"_Noreturn");
11437 Diagnoser.check(DS.getConstexprSpecLoc(),
"constexpr");
11438 DS.ClearConstexprSpec();
11440 Diagnoser.check(DS.getConstSpecLoc(),
"const");
11441 Diagnoser.check(DS.getRestrictSpecLoc(),
"__restrict");
11442 Diagnoser.check(DS.getVolatileSpecLoc(),
"volatile");
11443 Diagnoser.check(DS.getAtomicSpecLoc(),
"_Atomic");
11444 Diagnoser.check(DS.getUnalignedSpecLoc(),
"__unaligned");
11445 DS.ClearTypeQualifiers();
11447 Diagnoser.check(DS.getTypeSpecComplexLoc(), DS.getTypeSpecComplex());
11448 Diagnoser.check(DS.getTypeSpecSignLoc(), DS.getTypeSpecSign());
11449 Diagnoser.check(DS.getTypeSpecWidthLoc(), DS.getTypeSpecWidth());
11450 Diagnoser.check(DS.getTypeSpecTypeLoc(), DS.getTypeSpecType());
11451 DS.ClearTypeSpecType();
11454 if (
D.isInvalidType())
11458 bool FoundFunction =
false;
11464 diag::err_deduction_guide_with_complex_decl)
11468 if (!Chunk.Fun.hasTrailingReturnType())
11470 diag::err_deduction_guide_no_trailing_return_type);
11475 ParsedType TrailingReturnType = Chunk.Fun.getTrailingReturnType();
11478 assert(TSI &&
"deduction guide has valid type but invalid return type?");
11479 bool AcceptableReturnType =
false;
11480 bool MightInstantiateToSpecialization =
false;
11483 TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
11485 SpecifiedName, GuidedTemplate,
true);
11489 assert(
Qualifiers &&
"expected QualifiedTemplate");
11490 bool SimplyWritten = !
Qualifiers->hasTemplateKeyword() &&
11492 if (SimplyWritten && TemplateMatches)
11493 AcceptableReturnType =
true;
11498 MightInstantiateToSpecialization =
11499 !(TD && isa<ClassTemplateDecl>(TD) && !TemplateMatches);
11502 MightInstantiateToSpecialization =
true;
11505 if (!AcceptableReturnType)
11507 diag::err_deduction_guide_bad_trailing_return_type)
11508 << GuidedTemplate << TSI->
getType()
11509 << MightInstantiateToSpecialization
11514 FoundFunction =
true;
11517 if (
D.isFunctionDefinition())
11519 Diag(
D.getIdentifierLoc(), diag::err_deduction_guide_defines_function);
11533 assert(*IsInline != PrevNS->
isInline());
11543 S.
Diag(
Loc, diag::warn_inline_namespace_reopened_noninline)
11546 S.
Diag(
Loc, diag::err_inline_namespace_mismatch);
11564 bool IsInline = InlineLoc.
isValid();
11565 bool IsInvalid =
false;
11566 bool IsStd =
false;
11567 bool AddToKnown =
false;
11578 auto DiagnoseInlineStdNS = [&]() {
11579 assert(IsInline && II->
isStr(
"std") &&
11581 "Precondition of DiagnoseInlineStdNS not met");
11582 Diag(InlineLoc, diag::err_inline_namespace_std)
11598 RedeclarationKind::ForExternalRedeclaration);
11602 PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
11606 if (IsInline && II->
isStr(
"std") &&
11608 DiagnoseInlineStdNS();
11609 else if (IsInline != PrevNS->
isInline())
11611 &IsInline, PrevNS);
11612 }
else if (PrevDecl) {
11614 Diag(
Loc, diag::err_redefinition_different_kind)
11619 }
else if (II->
isStr(
"std") &&
11622 DiagnoseInlineStdNS();
11627 AddToKnown = !IsInline;
11630 AddToKnown = !IsInline;
11644 if (PrevNS && IsInline != PrevNS->
isInline())
11646 &IsInline, PrevNS);
11659 if (
const VisibilityAttr *
Attr = Namespc->
getAttr<VisibilityAttr>())
11665 KnownNamespaces[Namespc] =
false;
11673 TU->setAnonymousNamespace(Namespc);
11675 cast<NamespaceDecl>(
Parent)->setAnonymousNamespace(Namespc);
11724 return AD->getNamespace();
11725 return dyn_cast_or_null<NamespaceDecl>(
D);
11729 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
11730 assert(Namespc &&
"Invalid parameter, expected NamespaceDecl");
11733 if (Namespc->
hasAttr<VisibilityAttr>())
11736 if (DeferredExportedNamespaces.erase(Namespc))
11741 return cast_or_null<CXXRecordDecl>(
11750 return cast_or_null<NamespaceDecl>(
11755enum UnsupportedSTLSelect {
11762struct InvalidSTLDiagnoser {
11767 QualType operator()(UnsupportedSTLSelect Sel = USS_Other, StringRef Name =
"",
11768 const VarDecl *VD =
nullptr) {
11770 auto D = S.
Diag(
Loc, diag::err_std_compare_type_not_supported)
11771 << TyForDiags << ((
int)Sel);
11772 if (Sel == USS_InvalidMember || Sel == USS_MissingMember) {
11773 assert(!Name.empty());
11777 if (Sel == USS_InvalidMember) {
11790 "Looking for comparison category type outside of C++.");
11804 if (Info && FullyCheckedComparisonCategories[
static_cast<unsigned>(Kind)]) {
11815 std::string NameForDiags =
"std::";
11817 Diag(
Loc, diag::err_implied_comparison_category_type_not_found)
11818 << NameForDiags << (
int)Usage;
11822 assert(Info->
Kind == Kind);
11833 InvalidSTLDiagnoser UnsupportedSTLError{*
this,
Loc, TyForDiags(Info)};
11836 return UnsupportedSTLError(USS_NonTrivial);
11841 if (
Base->isEmpty())
11844 return UnsupportedSTLError();
11852 if (std::distance(FIt, FEnd) != 1 ||
11853 !FIt->getType()->isIntegralOrEnumerationType()) {
11854 return UnsupportedSTLError();
11864 return UnsupportedSTLError(USS_MissingMember, MemName);
11867 assert(VD &&
"should not be null!");
11874 return UnsupportedSTLError(USS_InvalidMember, MemName, VD);
11880 return UnsupportedSTLError();
11887 FullyCheckedComparisonCategories[
static_cast<unsigned>(Kind)] =
true;
11911 "Looking for std::initializer_list outside of C++.");
11925 dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
11934 TST = ICN->getInjectedTST();
11938 Template = dyn_cast_or_null<ClassTemplateDecl>(
11959 if (!isa<TemplateTypeParmDecl>(Params->
getParam(0)))
11971 *Element = Arguments[0].getAsType();
11978 S.
Diag(
Loc, diag::err_implied_std_initializer_list_not_found);
11985 S.
Diag(
Loc, diag::err_implied_std_initializer_list_not_found);
11990 Result.suppressDiagnostics();
11993 S.
Diag(
Found->getLocation(), diag::err_malformed_std_initializer_list);
12001 !isa<TemplateTypeParmDecl>(Params->
getParam(0))) {
12002 S.
Diag(Template->
getLocation(), diag::err_malformed_std_initializer_list);
12046 case Decl::TranslationUnit:
12048 case Decl::LinkageSpec:
12060 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
12062 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
12066 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
12067 return std::make_unique<NamespaceValidatorCCC>(*
this);
12075 auto *ND = cast<NamespaceDecl>(Corrected.
getFoundDecl());
12076 Module *M = ND->getOwningModule();
12077 assert(M &&
"hidden namespace definition not in a module?");
12081 diag::err_module_unimported_use_header)
12086 diag::err_module_unimported_use)
12096 NamespaceValidatorCCC CCC{};
12106 if (isa_and_nonnull<NamespaceDecl>(Corrected.getFoundDecl()) &&
12107 Corrected.requiresImport()) {
12110 std::string CorrectedStr(Corrected.getAsString(S.
getLangOpts()));
12111 bool DroppedSpecifier =
12112 Corrected.WillReplaceSpecifier() && Ident->
getName() == CorrectedStr;
12114 S.
PDiag(diag::err_using_directive_member_suggest)
12115 << Ident << DC << DroppedSpecifier << SS.
getRange(),
12116 S.
PDiag(diag::note_namespace_defined_here));
12119 S.
PDiag(diag::err_using_directive_suggest) << Ident,
12120 S.
PDiag(diag::note_namespace_defined_here));
12122 R.
addDecl(Corrected.getFoundDecl());
12133 assert(!SS.
isInvalid() &&
"Invalid CXXScopeSpec.");
12134 assert(NamespcName &&
"Invalid NamespcName.");
12135 assert(IdentLoc.
isValid() &&
"Invalid NamespceName location.");
12138 S = S->getDeclParent();
12156 NamespcName->
isStr(
"std")) {
12157 Diag(IdentLoc, diag::ext_using_undefined_std);
12168 assert(
NS &&
"expected namespace decl");
12187 CommonAncestor = CommonAncestor->
getParent();
12191 IdentLoc, Named, CommonAncestor);
12195 Diag(IdentLoc, diag::warn_using_directive_in_header);
12200 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.
getRange();
12233 Diag(Name.getBeginLoc(), diag::err_using_requires_qualname);
12237 switch (Name.getKind()) {
12248 Diag(Name.getBeginLoc(),
12250 ? diag::warn_cxx98_compat_using_decl_constructor
12251 : diag::err_using_decl_constructor)
12259 Diag(Name.getBeginLoc(), diag::err_using_decl_destructor) << SS.
getRange();
12263 Diag(Name.getBeginLoc(), diag::err_using_decl_template_id)
12264 <<
SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
12268 llvm_unreachable(
"cannot parse qualified deduction guide name");
12279 ? diag::err_access_decl
12280 : diag::warn_access_decl_deprecated)
12291 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
12299 SS, TargetNameInfo, EllipsisLoc, AttrList,
12313 assert(SS && !SS->
isInvalid() &&
"ScopeSpec is invalid");
12319 ? diag::err_using_enum_is_dependent
12320 : diag::err_unknown_typename)
12326 Diag(IdentLoc, diag::err_using_enum_is_dependent);
12332 Diag(IdentLoc, diag::err_using_enum_not_enum) << EnumTy;
12336 if (
auto *Def =
Enum->getDefinition())
12339 if (TSI ==
nullptr)
12362 TD2->getUnderlyingType());
12366 if (isa<UnresolvedUsingIfExistsDecl>(D1) &&
12367 isa<UnresolvedUsingIfExistsDecl>(D2))
12396 if (
auto *Using = dyn_cast<UsingDecl>(BUD)) {
12400 if (isa<EnumDecl>(OrigDC))
12408 Diag(Using->getLocation(),
12409 diag::err_using_decl_nested_name_specifier_is_current_class)
12410 << Using->getQualifierLoc().getSourceRange();
12412 Using->setInvalidDecl();
12416 Diag(Using->getQualifierLoc().getBeginLoc(),
12417 diag::err_using_decl_nested_name_specifier_is_not_base_class)
12418 << Using->getQualifier() << cast<CXXRecordDecl>(
CurContext)
12419 << Using->getQualifierLoc().getSourceRange();
12421 Using->setInvalidDecl();
12426 if (
Previous.empty())
return false;
12429 if (isa<UsingShadowDecl>(
Target))
12430 Target = cast<UsingShadowDecl>(
Target)->getTargetDecl();
12437 NamedDecl *NonTag =
nullptr, *Tag =
nullptr;
12438 bool FoundEquivalentDecl =
false;
12445 if (isa<UsingDecl>(
D) || isa<UsingPackDecl>(
D) || isa<UsingEnumDecl>(
D))
12448 if (
auto *RD = dyn_cast<CXXRecordDecl>(
D)) {
12453 !isa<IndirectFieldDecl>(
Target) &&
12454 !isa<UnresolvedUsingValueDecl>(
Target) &&
12463 PrevShadow = Shadow;
12464 FoundEquivalentDecl =
true;
12468 FoundEquivalentDecl =
true;
12472 (isa<TagDecl>(
D) ? Tag : NonTag) =
D;
12475 if (FoundEquivalentDecl)
12480 if (isa<UnresolvedUsingIfExistsDecl>(
Target) !=
12481 (isa_and_nonnull<UnresolvedUsingIfExistsDecl>(NonTag))) {
12482 if (!NonTag && !Tag)
12485 Diag(
Target->getLocation(), diag::note_using_decl_target);
12486 Diag((NonTag ? NonTag : Tag)->getLocation(),
12487 diag::note_using_decl_conflict);
12516 Diag(
Target->getLocation(), diag::note_using_decl_target);
12524 if (isa<TagDecl>(
Target)) {
12526 if (!Tag)
return false;
12529 Diag(
Target->getLocation(), diag::note_using_decl_target);
12530 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
12536 if (!NonTag)
return false;
12539 Diag(
Target->getLocation(), diag::note_using_decl_target);
12549 for (
auto &B : Derived->
bases())
12550 if (B.getType()->getAsCXXRecordDecl() ==
Base)
12551 return B.isVirtual();
12552 llvm_unreachable(
"not a direct base class");
12560 if (isa<UsingShadowDecl>(
Target)) {
12561 Target = cast<UsingShadowDecl>(
Target)->getTargetDecl();
12562 assert(!isa<UsingShadowDecl>(
Target) &&
"nested shadow declaration");
12566 if (
auto *TargetTD = dyn_cast<TemplateDecl>(
Target))
12567 NonTemplateTarget = TargetTD->getTemplatedDecl();
12570 if (NonTemplateTarget && isa<CXXConstructorDecl>(NonTemplateTarget)) {
12571 UsingDecl *Using = cast<UsingDecl>(BUD);
12572 bool IsVirtualBase =
12574 Using->getQualifier()->getAsRecordDecl());
12601 cast<CXXRecordDecl>(Shadow->
getDeclContext())->removeConversion(Shadow);
12608 S->RemoveDecl(Shadow);
12622 bool &AnyDependentBases) {
12627 CanQualType BaseType =
Base.getType()->getCanonicalTypeUnqualified();
12628 if (CanonicalDesiredBase == BaseType)
12630 if (BaseType->isDependentType())
12631 AnyDependentBases =
true;
12639 UsingValidatorCCC(
bool HasTypenameKeyword,
bool IsInstantiation,
12641 : HasTypenameKeyword(HasTypenameKeyword),
12642 IsInstantiation(IsInstantiation), OldNNS(NNS),
12643 RequireMemberOf(RequireMemberOf) {}
12645 bool ValidateCandidate(
const TypoCorrection &Candidate)
override {
12649 if (!ND || isa<NamespaceDecl>(ND))
12659 if (RequireMemberOf) {
12660 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
12661 if (FoundRecord && FoundRecord->isInjectedClassName()) {
12682 bool AnyDependentBases =
false;
12685 AnyDependentBases) &&
12686 !AnyDependentBases)
12690 if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
12696 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
12697 if (FoundRecord && FoundRecord->isInjectedClassName())
12701 if (isa<TypeDecl>(ND))
12702 return HasTypenameKeyword || !IsInstantiation;
12704 return !HasTypenameKeyword;
12707 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
12708 return std::make_unique<UsingValidatorCCC>(*
this);
12712 bool HasTypenameKeyword;
12713 bool IsInstantiation;
12742 bool IsUsingIfExists) {
12743 assert(!SS.
isInvalid() &&
"Invalid CXXScopeSpec.");
12745 assert(IdentLoc.
isValid() &&
"Invalid TargetName location.");
12754 if (
auto *RD = dyn_cast<CXXRecordDecl>(
CurContext))
12760 RedeclarationKind::ForVisibleRedeclaration);
12767 assert(IsInstantiation &&
"no scope in non-instantiation");
12795 Diag(UsingLoc, diag::err_using_if_exists_on_ctor);
12801 if (!LookupContext || EllipsisLoc.
isValid()) {
12805 SS, NameInfo, IdentLoc))
12808 if (HasTypenameKeyword) {
12811 UsingLoc, TypenameLoc,
12813 IdentLoc, NameInfo.
getName(),
12817 QualifierLoc, NameInfo, EllipsisLoc);
12825 auto Build = [&](
bool Invalid) {
12828 UsingName, HasTypenameKeyword);
12835 auto BuildInvalid = [&]{
return Build(
true); };
12836 auto BuildValid = [&]{
return Build(
false); };
12839 return BuildInvalid();
12848 if (!IsInstantiation)
12865 if (R.
empty() && IsUsingIfExists)
12882 isa<TranslationUnitDecl>(LookupContext) &&
12885 UsingValidatorCCC CCC(HasTypenameKeyword, IsInstantiation, SS.
getScopeRep(),
12893 << NameInfo.
getName() << LookupContext << 0
12898 NamedDecl *ND = Corrected.getCorrectionDecl();
12900 return BuildInvalid();
12903 auto *RD = dyn_cast<CXXRecordDecl>(ND);
12906 RD = cast<CXXRecordDecl>(RD->
getParent());
12909 if (Corrected.WillReplaceSpecifier()) {
12911 Builder.MakeTrivial(
Context, Corrected.getCorrectionSpecifier(),
12913 QualifierLoc = Builder.getWithLocInContext(
Context);
12918 auto *CurClass = cast<CXXRecordDecl>(
CurContext);
12932 Diag(IdentLoc, diag::err_no_member)
12934 return BuildInvalid();
12939 return BuildInvalid();
12941 if (HasTypenameKeyword) {
12945 Diag(IdentLoc, diag::err_using_typename_non_type);
12947 Diag((*I)->getUnderlyingDecl()->getLocation(),
12948 diag::note_using_decl_target);
12949 return BuildInvalid();
12956 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
12958 return BuildInvalid();
12965 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
12970 return BuildInvalid();
13006 RedeclarationKind::ForVisibleRedeclaration);
13012 if (UED->getEnumDecl() == ED) {
13013 Diag(UsingLoc, diag::err_using_enum_decl_redeclaration)
13039 RedeclarationKind::ForVisibleRedeclaration);
13052 assert(isa<UnresolvedUsingValueDecl>(InstantiatedFrom) ||
13053 isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) ||
13054 isa<UsingPackDecl>(InstantiatedFrom));
13058 UPD->setAccess(InstantiatedFrom->
getAccess());
13064 assert(!UD->
hasTypename() &&
"expecting a constructor name");
13067 assert(SourceType &&
13068 "Using decl naming constructor doesn't have type in scope spec.");
13072 bool AnyDependentBases =
false;
13074 AnyDependentBases);
13075 if (!
Base && !AnyDependentBases) {
13077 diag::err_using_decl_constructor_not_in_direct_base)
13079 <<
QualType(SourceType, 0) << TargetClass;
13085 Base->setInheritConstructors();
13091 bool HasTypenameKeyword,
13110 if (Qual->
isDependent() && !HasTypenameKeyword) {
13111 for (
auto *
D : Prev) {
13112 if (!isa<TypeDecl>(
D) && !isa<UsingDecl>(
D) && !isa<UsingPackDecl>(
D)) {
13113 bool OldCouldBeEnumerator =
13114 isa<UnresolvedUsingValueDecl>(
D) || isa<EnumConstantDecl>(
D);
13116 OldCouldBeEnumerator ? diag::err_redefinition
13117 : diag::err_redefinition_different_kind)
13118 << Prev.getLookupName();
13134 if (
UsingDecl *UD = dyn_cast<UsingDecl>(
D)) {
13135 DTypename = UD->hasTypename();
13136 DQual = UD->getQualifier();
13138 = dyn_cast<UnresolvedUsingValueDecl>(
D)) {
13140 DQual = UD->getQualifier();
13142 = dyn_cast<UnresolvedUsingTypenameDecl>(
D)) {
13144 DQual = UD->getQualifier();
13149 if (HasTypenameKeyword != DTypename)
continue;
13157 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.
getRange();
13171 assert(
bool(NamedContext) == (R || UD) && !(R && UD) &&
13172 "resolvable context must have exactly one set of decls");
13176 bool Cxx20Enumerator =
false;
13177 if (NamedContext) {
13186 if (
auto *ED = dyn_cast<EnumDecl>(NamedContext)) {
13190 if (EC && R && ED->isScoped())
13193 ? diag::warn_cxx17_compat_using_decl_scoped_enumerator
13194 : diag::ext_using_decl_scoped_enumerator)
13198 NamedContext = ED->getDeclContext();
13218 ? diag::warn_cxx17_compat_using_decl_class_member_enumerator
13219 : diag::err_using_decl_can_not_refer_to_class_member)
13222 if (Cxx20Enumerator)
13225 auto *RD = NamedContext
13237 Diag(SS.
getBeginLoc(), diag::note_using_decl_class_member_workaround)
13238 << diag::MemClassWorkaround::AliasDecl
13245 Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
13246 << diag::MemClassWorkaround::TypedefDecl
13261 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
13262 << diag::MemClassWorkaround::ReferenceDecl << FixIt;
13275 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
13277 ? diag::MemClassWorkaround::ConstexprVar
13278 : diag::MemClassWorkaround::ConstVar)
13287 if (!NamedContext) {
13303 ? diag::warn_cxx17_compat_using_decl_non_member_enumerator
13304 : diag::err_using_decl_nested_name_specifier_is_not_class)
13307 if (Cxx20Enumerator)
13324 cast<CXXRecordDecl>(NamedContext))) {
13326 if (Cxx20Enumerator) {
13327 Diag(NameLoc, diag::warn_cxx17_compat_using_decl_non_member_enumerator)
13334 diag::err_using_decl_nested_name_specifier_is_current_class)
13339 if (!cast<CXXRecordDecl>(NamedContext)->isInvalidDecl()) {
13341 diag::err_using_decl_nested_name_specifier_is_not_base_class)
13366 Bases.insert(
Base);
13371 if (!cast<CXXRecordDecl>(
CurContext)->forallBases(Collect))
13377 return !Bases.count(
Base);
13382 if (Bases.count(cast<CXXRecordDecl>(NamedContext)) ||
13383 !cast<CXXRecordDecl>(NamedContext)->forallBases(IsNotBase))
13387 diag::err_using_decl_nested_name_specifier_is_not_base_class)
13401 S = S->getDeclParent();
13403 if (
Type.isInvalid())
13422 TemplateParamLists.size()
13424 : RedeclarationKind::ForVisibleRedeclaration);
13429 Previous.getFoundDecl()->isTemplateParameter()) {
13435 "name in alias declaration must be an identifier");
13437 Name.StartLocation,
13438 Name.Identifier, TInfo);
13452 bool Redeclaration =
false;
13455 if (TemplateParamLists.size()) {
13459 if (TemplateParamLists.size() != 1) {
13460 Diag(UsingLoc, diag::err_alias_template_extra_headers)
13461 <<
SourceRange(TemplateParamLists[1]->getTemplateLoc(),
13462 TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
13475 Redeclaration =
true;
13479 Diag(UsingLoc, diag::err_redefinition_different_kind)
13480 << Name.Identifier;
13494 OldTemplateParams =
13522 Name.Identifier, TemplateParams,
13530 else if (OldDecl) {
13537 if (
auto *TD = dyn_cast_or_null<TagDecl>(DeclFromDeclSpec)) {
13565 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.
getRange();
13574 RedeclarationKind::ForVisibleRedeclaration);
13597 Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
13599 Diag(AD->getLocation(), diag::note_previous_namespace_alias)
13600 << AD->getNamespace();
13605 ? diag::err_redefinition
13606 : diag::err_redefinition_different_kind;
13607 Diag(AliasLoc, DiagID) << Alias;
13628struct SpecialMemberExceptionSpecInfo
13629 : SpecialMemberVisitor<SpecialMemberExceptionSpecInfo> {
13637 : SpecialMemberVisitor(S, MD, CSM, ICI),
Loc(
Loc), ExceptSpec(S) {}
13642 void visitClassSubobject(
CXXRecordDecl *Class, Subobject Subobj,
13645 void visitSubobjectCall(Subobject Subobj,
13655 auto *BaseClass = cast<CXXRecordDecl>(RT->getDecl());
13657 if (
auto *BaseCtor = SMOR.
getMethod()) {
13658 visitSubobjectCall(
Base, BaseCtor);
13662 visitClassSubobject(BaseClass,
Base, 0);
13666bool SpecialMemberExceptionSpecInfo::visitField(
FieldDecl *FD) {
13678 ExceptSpec.CalledExpr(
E);
13681 visitClassSubobject(cast<CXXRecordDecl>(RT->getDecl()), FD,
13691 bool IsMutable =
Field &&
Field->isMutable();
13692 visitSubobjectCall(Subobj, lookupIn(
Class, Quals, IsMutable));
13695void SpecialMemberExceptionSpecInfo::visitSubobjectCall(
13700 ExceptSpec.CalledDecl(getSubobjectLoc(Subobj), MD);
13729 ComputingExceptionSpec CES(S, MD,
Loc);
13736 SpecialMemberExceptionSpecInfo Info(S, MD, CSM, ICI, MD->
getLocation());
13738 return Info.ExceptSpec;
13745 diag::err_exception_spec_incomplete_type))
13746 return Info.ExceptSpec;
13763 Info.visit(Info.IsConstructor ? Info.VisitPotentiallyConstructedBases
13764 : Info.VisitAllBases);
13766 return Info.ExceptSpec;
13771struct DeclaringSpecialMember {
13775 bool WasAlreadyBeingDeclared;
13778 : S(S),
D(RD, CSM), SavedContext(S, RD) {
13780 if (WasAlreadyBeingDeclared)
13801 ~DeclaringSpecialMember() {
13802 if (!WasAlreadyBeingDeclared) {
13809 bool isAlreadyBeingDeclared()
const {
13810 return WasAlreadyBeingDeclared;
13820 RedeclarationKind::ForExternalRedeclaration);
13831void Sema::setupImplicitSpecialMemberType(
CXXMethodDecl *SpecialMem,
13849 cast<CXXRecordDecl>(SpecialMem->
getParent())->isLambda()) {
13865 "Should not build implicit default constructor!");
13867 DeclaringSpecialMember DSM(*
this, ClassDecl,
13869 if (DSM.isAlreadyBeingDeclared())
13892 setupImplicitSpecialMemberType(DefaultCon,
Context.
VoidTy, {});
13916 ClassDecl->
addDecl(DefaultCon);
13923 assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
13924 !Constructor->doesThisDeclarationHaveABody() &&
13925 !Constructor->isDeleted()) &&
13926 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
13927 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
13931 assert(ClassDecl &&
"DefineImplicitDefaultConstructor - invalid constructor");
13945 Scope.addContextNote(CurrentLocation);
13948 Constructor->setInvalidDecl();
13953 ? Constructor->getEndLoc()
13954 : Constructor->getLocation();
13956 Constructor->markUsed(
Context);
13959 L->CompletedImplicitDefinition(Constructor);
13962 DiagnoseUninitializedFields(*
this, Constructor);
13988 ->getInheritedConstructor()
13991 return cast<CXXConstructorDecl>(Ctor);
14006 false, BaseCtor, &ICI);
14023 EPI.ExceptionSpec.SourceDecl = DerivedCtor;
14029 for (
unsigned I = 0, N = FPT->
getNumParams(); I != N; ++I) {
14033 Context, DerivedCtor, UsingLoc, UsingLoc,
nullptr,
14040 ParamDecls.push_back(PD);
14045 assert(!BaseCtor->
isDeleted() &&
"should not use deleted constructor");
14048 Derived->
addDecl(DerivedCtor);
14054 return DerivedCtor;
14068 assert(Constructor->getInheritedConstructor() &&
14069 !Constructor->doesThisDeclarationHaveABody() &&
14070 !Constructor->isDeleted());
14071 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
14085 Scope.addContextNote(CurrentLocation);
14088 Constructor->getInheritedConstructor().getShadowDecl();
14090 Constructor->getInheritedConstructor().getConstructor();
14104 for (
bool VBase : {
false,
true}) {
14106 if (B.isVirtual() != VBase)
14109 auto *BaseRD = B.getType()->getAsCXXRecordDecl();
14114 if (!BaseCtor.first)
14119 InitLoc, B.getType(), BaseCtor.first, VBase, BaseCtor.second);
14123 Context, TInfo, VBase, InitLoc,
Init.get(), InitLoc,
14132 Constructor->setInvalidDecl();
14137 Constructor->markUsed(
Context);
14140 L->CompletedImplicitDefinition(Constructor);
14143 DiagnoseUninitializedFields(*
this, Constructor);
14153 DeclaringSpecialMember DSM(*
this, ClassDecl,
14155 if (DSM.isAlreadyBeingDeclared())
14216 !
Destructor->doesThisDeclarationHaveABody() &&
14218 "DefineImplicitDestructor - call it for implicit default dtor");
14223 assert(ClassDecl &&
"DefineImplicitDestructor - invalid destructor");
14234 Scope.addContextNote(CurrentLocation);
14262 "implicit complete dtors unneeded outside MS ABI");
14264 "complete dtor only exists for classes with vbases");
14269 Scope.addContextNote(CurrentLocation);
14277 if (
Record->isInvalidDecl()) {
14298 if (M->getParent()->getTemplateSpecializationKind() !=
14318 "adjusting dtor exception specs was introduced in c++11");
14328 if (DtorType->hasExceptionSpec())
14351 ExprBuilder(
const ExprBuilder&) =
delete;
14352 ExprBuilder &operator=(
const ExprBuilder&) =
delete;
14356 assert(
E &&
"Expression construction must not fail.");
14362 virtual ~ExprBuilder() {}
14367class RefBuilder:
public ExprBuilder {
14377 : Var(Var), VarType(VarType) {}
14380class ThisBuilder:
public ExprBuilder {
14387class CastBuilder:
public ExprBuilder {
14388 const ExprBuilder &Builder;
14396 CK_UncheckedDerivedToBase,
Kind,
14405class DerefBuilder:
public ExprBuilder {
14406 const ExprBuilder &Builder;
14410 return assertNotNull(
14414 DerefBuilder(
const ExprBuilder &Builder) : Builder(Builder) {}
14417class MemberBuilder:
public ExprBuilder {
14418 const ExprBuilder &Builder;
14428 nullptr, MemberLookup,
nullptr,
nullptr).get());
14431 MemberBuilder(
const ExprBuilder &Builder,
QualType Type,
bool IsArrow,
14433 : Builder(Builder),
Type(
Type), IsArrow(IsArrow),
14434 MemberLookup(MemberLookup) {}
14437class MoveCastBuilder:
public ExprBuilder {
14438 const ExprBuilder &Builder;
14445 MoveCastBuilder(
const ExprBuilder &Builder) : Builder(Builder) {}
14448class LvalueConvBuilder:
public ExprBuilder {
14449 const ExprBuilder &Builder;
14453 return assertNotNull(
14457 LvalueConvBuilder(
const ExprBuilder &Builder) : Builder(Builder) {}
14460class SubscriptBuilder:
public ExprBuilder {
14461 const ExprBuilder &
Base;
14462 const ExprBuilder &Index;
14470 SubscriptBuilder(
const ExprBuilder &
Base,
const ExprBuilder &Index)
14482 const ExprBuilder &ToB,
const ExprBuilder &FromB) {
14491 Expr *From = FromB.build(S,
Loc);
14495 Expr *To = ToB.build(S,
Loc);
14501 bool NeedsCollectableMemCpy =
14502 E->isRecordType() &&
14503 E->castAs<
RecordType>()->getDecl()->hasObjectMember();
14506 StringRef MemCpyName = NeedsCollectableMemCpy ?
14507 "__builtin_objc_memmove_collectable" :
14508 "__builtin_memcpy";
14521 assert(MemCpyRef.
isUsable() &&
"Builtin reference cannot fail");
14523 Expr *CallArgs[] = {
14529 assert(!
Call.isInvalid() &&
"Call to __builtin_memcpy cannot fail!");
14562 const ExprBuilder &To,
const ExprBuilder &From,
14563 bool CopyingBaseSubobject,
bool Copying,
14564 unsigned Depth = 0) {
14580 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
14615 if (CopyingBaseSubobject) {
14646 Expr *FromInst = From.build(S,
Loc);
14650 if (
Call.isInvalid())
14669 Loc, BO_Assign, To.build(S,
Loc), From.build(S,
Loc));
14670 if (Assignment.isInvalid())
14689 llvm::raw_svector_ostream
OS(Str);
14690 OS <<
"__i" << Depth;
14694 IterationVarName, SizeType,
14703 RefBuilder IterationVarRef(IterationVar, SizeType);
14704 LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
14710 SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
14711 MoveCastBuilder FromIndexMove(FromIndexCopy);
14712 const ExprBuilder *FromIndex;
14714 FromIndex = &FromIndexCopy;
14716 FromIndex = &FromIndexMove;
14718 SubscriptBuilder ToIndex(To, IterationVarRefRVal);
14723 ToIndex, *FromIndex, CopyingBaseSubobject,
14724 Copying, Depth + 1);
14726 if (
Copy.isInvalid() || !
Copy.get())
14733 S.
Context, IterationVarRefRVal.build(S,
Loc),
14754 const ExprBuilder &To,
const ExprBuilder &From,
14755 bool CopyingBaseSubobject,
bool Copying) {
14757 if (
T->
isArrayType() && !
T.isConstQualified() && !
T.isVolatileQualified() &&
14758 T.isTriviallyCopyableType(S.
Context))
14762 CopyingBaseSubobject,
14780 DeclaringSpecialMember DSM(*
this, ClassDecl,
14782 if (DSM.isAlreadyBeingDeclared())
14817 setupImplicitSpecialMemberType(
CopyAssignment, RetType, ArgType);
14827 ClassLoc, ClassLoc,
14869 }
else if (!isa<CXXConstructorDecl>(CopyOp) &&
14872 for (
auto *I : RD->
ctors()) {
14873 if (I->isCopyConstructor()) {
14874 UserDeclaredOperation = I;
14878 assert(UserDeclaredOperation);
14879 }
else if (isa<CXXConstructorDecl>(CopyOp) &&
14882 for (
auto *I : RD->
methods()) {
14883 if (I->isCopyAssignmentOperator()) {
14884 UserDeclaredOperation = I;
14888 assert(UserDeclaredOperation);
14891 if (UserDeclaredOperation) {
14892 bool UDOIsUserProvided = UserDeclaredOperation->
isUserProvided();
14893 bool UDOIsDestructor = isa<CXXDestructorDecl>(UserDeclaredOperation);
14894 bool IsCopyAssignment = !isa<CXXConstructorDecl>(CopyOp);
14896 (UDOIsUserProvided && UDOIsDestructor)
14897 ? diag::warn_deprecated_copy_with_user_provided_dtor
14898 : (UDOIsUserProvided && !UDOIsDestructor)
14899 ? diag::warn_deprecated_copy_with_user_provided_copy
14900 : (!UDOIsUserProvided && UDOIsDestructor)
14901 ? diag::warn_deprecated_copy_with_dtor
14902 : diag::warn_deprecated_copy;
14904 << RD << IsCopyAssignment;
14915 "DefineImplicitCopyAssignment called for wrong function");
14933 Scope.addContextNote(CurrentLocation);
14968 RefBuilder OtherRef(
Other, OtherRefType);
14971 std::optional<ThisBuilder> This;
14972 std::optional<DerefBuilder> DerefThis;
14973 std::optional<RefBuilder> ExplicitObject;
14974 bool IsArrow =
false;
14980 ExplicitObject.emplace(CopyAssignOperator->
getParamDecl(0), ObjectType);
14984 DerefThis.emplace(*This);
14987 ExprBuilder &ObjectParameter =
14988 ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
14989 :
static_cast<ExprBuilder &
>(*This);
14993 for (
auto &
Base : ClassDecl->
bases()) {
14996 QualType BaseType =
Base.getType().getUnqualifiedType();
15003 BasePath.push_back(&
Base);
15012 ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15013 :
static_cast<ExprBuilder &
>(*DerefThis),
15022 if (
Copy.isInvalid()) {
15028 Statements.push_back(
Copy.getAs<
Expr>());
15032 for (
auto *Field : ClassDecl->
fields()) {
15035 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15038 if (Field->isInvalidDecl()) {
15044 if (Field->getType()->isReferenceType()) {
15045 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15047 Diag(Field->getLocation(), diag::note_declared_at);
15055 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15057 Diag(Field->getLocation(), diag::note_declared_at);
15063 if (Field->isZeroLengthBitField())
15066 QualType FieldType = Field->getType().getNonReferenceType();
15069 "Incomplete array type is not valid");
15080 MemberBuilder From(OtherRef, OtherRefType,
false, MemberLookup);
15081 MemberBuilder To(ObjectParameter, ObjectType, IsArrow, MemberLookup);
15087 if (
Copy.isInvalid()) {
15093 Statements.push_back(
Copy.getAs<
Stmt>());
15099 (ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15100 :
LangOpts.HLSL ?
static_cast<ExprBuilder &
>(*This)
15101 :
static_cast<ExprBuilder &
>(*DerefThis))
15102 .build(*
this,
Loc);
15107 Statements.push_back(Return.
getAs<
Stmt>());
15120 assert(!Body.
isInvalid() &&
"Compound statement creation cannot fail");
15126 L->CompletedImplicitDefinition(CopyAssignOperator);
15133 DeclaringSpecialMember DSM(*
this, ClassDecl,
15135 if (DSM.isAlreadyBeingDeclared())
15169 setupImplicitSpecialMemberType(
MoveAssignment, RetType, ArgType);
15179 ClassLoc, ClassLoc,
15215 assert(!
Class->isDependentContext() &&
"should not define dependent move");
15221 if (
Class->getNumVBases() == 0 ||
Class->hasTrivialMoveAssignment() ||
15222 Class->getNumBases() < 2)
15226 typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
15229 for (
auto &BI :
Class->bases()) {
15230 Worklist.push_back(&BI);
15231 while (!Worklist.empty()) {
15237 if (!
Base->hasNonTrivialMoveAssignment())
15262 VBases.insert(std::make_pair(
Base->getCanonicalDecl(), &BI))
15264 if (Existing && Existing != &BI) {
15265 S.
Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
15268 << (
Base->getCanonicalDecl() ==
15271 S.
Diag(BI.getBeginLoc(), diag::note_vbase_moved_here)
15272 << (
Base->getCanonicalDecl() ==
15273 BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
15277 Existing =
nullptr;
15287 llvm::append_range(Worklist, llvm::make_pointer_range(
Base->bases()));
15300 "DefineImplicitMoveAssignment called for wrong function");
15330 Scope.addContextNote(CurrentLocation);
15346 RefBuilder OtherRef(
Other, OtherRefType);
15348 MoveCastBuilder MoveOther(OtherRef);
15351 std::optional<ThisBuilder> This;
15352 std::optional<DerefBuilder> DerefThis;
15353 std::optional<RefBuilder> ExplicitObject;
15355 bool IsArrow =
false;
15360 ExplicitObject.emplace(MoveAssignOperator->
getParamDecl(0), ObjectType);
15364 DerefThis.emplace(*This);
15367 ExprBuilder &ObjectParameter =
15368 ExplicitObject ? *ExplicitObject :
static_cast<ExprBuilder &
>(*This);
15372 for (
auto &
Base : ClassDecl->
bases()) {
15383 QualType BaseType =
Base.getType().getUnqualifiedType();
15390 BasePath.push_back(&
Base);
15394 CastBuilder From(OtherRef, BaseType,
VK_XValue, BasePath);
15399 ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15400 :
static_cast<ExprBuilder &
>(*DerefThis),
15409 if (Move.isInvalid()) {
15415 Statements.push_back(Move.getAs<
Expr>());
15419 for (
auto *Field : ClassDecl->
fields()) {
15422 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15425 if (Field->isInvalidDecl()) {
15431 if (Field->getType()->isReferenceType()) {
15432 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15434 Diag(Field->getLocation(), diag::note_declared_at);
15442 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15444 Diag(Field->getLocation(), diag::note_declared_at);
15450 if (Field->isZeroLengthBitField())
15453 QualType FieldType = Field->getType().getNonReferenceType();
15456 "Incomplete array type is not valid");
15465 MemberBuilder From(MoveOther, OtherRefType,
15466 false, MemberLookup);
15467 MemberBuilder To(ObjectParameter, ObjectType, IsArrow, MemberLookup);
15469 assert(!From.build(*
this,
Loc)->isLValue() &&
15470 "Member reference with rvalue base must be rvalue except for reference "
15471 "members, which aren't allowed for move assignment.");
15478 if (Move.isInvalid()) {
15484 Statements.push_back(Move.getAs<
Stmt>());
15490 (ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15491 :
LangOpts.HLSL ?
static_cast<ExprBuilder &
>(*This)
15492 :
static_cast<ExprBuilder &
>(*DerefThis))
15493 .build(*
this,
Loc);
15499 Statements.push_back(Return.
getAs<
Stmt>());
15512 assert(!Body.
isInvalid() &&
"Compound statement creation cannot fail");
15518 L->CompletedImplicitDefinition(MoveAssignOperator);
15529 DeclaringSpecialMember DSM(*
this, ClassDecl,
15531 if (DSM.isAlreadyBeingDeclared())
15598 ClassDecl->
hasAttr<TrivialABIAttr>() ||
15630 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
15635 assert(ClassDecl &&
"DefineImplicitCopyConstructor - invalid constructor");
15646 Scope.addContextNote(CurrentLocation);
15676 DeclaringSpecialMember DSM(*
this, ClassDecl,
15678 if (DSM.isAlreadyBeingDeclared())
15723 ClassLoc, ClassLoc,
15736 ClassDecl->
hasAttr<TrivialABIAttr>() ||
15768 "DefineImplicitMoveConstructor - call it for implicit move ctor");
15773 assert(ClassDecl &&
"DefineImplicitMoveConstructor - invalid constructor");
15784 Scope.addContextNote(CurrentLocation);
15830 if (CallOp != Invoker) {
15849 if (Invoker != CallOp) {
15862 assert(FunctionRef &&
"Can't refer to __invoke function?");
15870 L->CompletedImplicitDefinition(Conv);
15871 if (Invoker != CallOp)
15872 L->CompletedImplicitDefinition(Invoker);
15900 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
15909 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
15915 Stmt *ReturnS = Return.
get();
15922 L->CompletedImplicitDefinition(Conv);
15929 switch (Args.size()) {
15934 if (!Args[1]->isDefaultArgument())
15939 return !Args[0]->isDefaultArgument();
15948 bool HadMultipleCandidates,
bool IsListInitialization,
15949 bool IsStdInitListInitialization,
bool RequiresZeroInit,
15951 bool Elidable =
false;
15970 Expr *SubExpr = ExprArgs[0];
15980 FoundDecl, Constructor,
15981 Elidable, ExprArgs, HadMultipleCandidates,
15982 IsListInitialization,
15983 IsStdInitListInitialization, RequiresZeroInit,
15984 ConstructKind, ParenRange);
15990 bool HadMultipleCandidates,
bool IsListInitialization,
15991 bool IsStdInitListInitialization,
bool RequiresZeroInit,
15993 if (
auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl)) {
16003 ConstructLoc, DeclInitType, Constructor, Elidable, ExprArgs,
16004 HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
16005 RequiresZeroInit, ConstructKind, ParenRange);
16013 bool HadMultipleCandidates,
bool IsListInitialization,
16014 bool IsStdInitListInitialization,
bool RequiresZeroInit,
16017 Constructor->getParent(),
16019 "given constructor for wrong type");
16026 Context, DeclInitType, ConstructLoc, Constructor, Elidable, ExprArgs,
16027 HadMultipleCandidates, IsListInitialization,
16028 IsStdInitListInitialization, RequiresZeroInit,
16060 PDiag(diag::err_access_dtor_var)
16070 bool HasConstantInit =
false;
16077 diag::err_constexpr_var_requires_const_destruction) << VD;
16078 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
16079 Diag(Notes[I].first, Notes[I].second);
16088 if (!VD->
hasAttr<AlwaysDestroyAttr>())
16100 bool AllowExplicit,
16101 bool IsListInitialization) {
16103 unsigned NumArgs = ArgsPtr.size();
16104 Expr **Args = ArgsPtr.data();
16110 if (NumArgs < NumParams)
16111 ConvertedArgs.reserve(NumParams);
16113 ConvertedArgs.reserve(NumArgs);
16120 CallType, AllowExplicit, IsListInitialization);
16121 ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
16125 CheckConstructorCall(Constructor, DeclInitType,
16136 if (isa<NamespaceDecl>(DC)) {
16138 diag::err_operator_new_delete_declared_in_namespace)
16142 if (isa<TranslationUnitDecl>(DC) &&
16145 diag::err_operator_new_delete_declared_static)
16157 return Ctx.getPointerType(Ctx.getCanonicalType(Ctx.getQualifiedType(
16165 unsigned DependentParamTypeDiag,
16166 unsigned InvalidParamTypeDiag) {
16187 ? diag::err_operator_new_delete_dependent_result_type
16188 : diag::err_operator_new_delete_invalid_result_type)
16195 diag::err_operator_new_delete_template_too_few_parameters)
16201 diag::err_operator_new_delete_too_few_parameters)
16208 if (
const auto *PtrTy =
16213 ExpectedFirstParamType =
16219 ExpectedFirstParamType) {
16224 ? DependentParamTypeDiag
16225 : InvalidParamTypeDiag)
16226 << FnDecl->
getDeclName() << ExpectedFirstParamType;
16249 diag::err_operator_new_dependent_param_type,
16250 diag::err_operator_new_param_type))
16257 diag::err_operator_new_default_arg)
16272 auto *MD = dyn_cast<CXXMethodDecl>(FnDecl);
16288 diag::err_operator_delete_dependent_param_type,
16289 diag::err_operator_delete_param_type))
16298 diag::err_destroying_operator_delete_not_usual);
16307 "Expected an overloaded operator declaration");
16317 if (Op == OO_Delete || Op == OO_Array_Delete)
16320 if (Op == OO_New || Op == OO_Array_New)
16330 if (
CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
16331 if (MethodDecl->isStatic()) {
16332 if (Op == OO_Call || Op == OO_Subscript)
16335 ? diag::warn_cxx20_compat_operator_overload_static
16336 : diag::ext_operator_overload_static))
16339 return Diag(FnDecl->
getLocation(), diag::err_operator_overload_static)
16343 bool ClassOrEnumParam =
false;
16345 QualType ParamType = Param->getType().getNonReferenceType();
16348 ClassOrEnumParam =
true;
16353 if (!ClassOrEnumParam)
16355 diag::err_operator_overload_needs_class_or_enum)
16365 if (Op != OO_Call) {
16368 if (Param->hasDefaultArg()) {
16369 FirstDefaultedParam = Param;
16373 if (FirstDefaultedParam) {
16374 if (Op == OO_Subscript) {
16376 ? diag::ext_subscript_overload
16377 : diag::error_subscript_overload)
16382 diag::err_operator_overload_default_arg)
16390 {
false,
false,
false }
16391#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
16392 , { Unary, Binary, MemberOnly }
16393#include "clang/Basic/OperatorKinds.def"
16396 bool CanBeUnaryOperator = OperatorUses[Op][0];
16397 bool CanBeBinaryOperator = OperatorUses[Op][1];
16398 bool MustBeMemberOperator = OperatorUses[Op][2];
16405 (isa<CXXMethodDecl>(FnDecl) &&
16409 if (Op != OO_Call && Op != OO_Subscript &&
16410 ((NumParams == 1 && !CanBeUnaryOperator) ||
16411 (NumParams == 2 && !CanBeBinaryOperator) || (NumParams < 1) ||
16412 (NumParams > 2))) {
16414 unsigned ErrorKind;
16415 if (CanBeUnaryOperator && CanBeBinaryOperator) {
16417 }
else if (CanBeUnaryOperator) {
16420 assert(CanBeBinaryOperator &&
16421 "All non-call overloaded operators are unary or binary!");
16424 return Diag(FnDecl->
getLocation(), diag::err_operator_overload_must_be)
16425 << FnDecl->
getDeclName() << NumParams << ErrorKind;
16428 if (Op == OO_Subscript && NumParams != 2) {
16430 ? diag::ext_subscript_overload
16431 : diag::error_subscript_overload)
16432 << FnDecl->
getDeclName() << (NumParams == 1 ? 0 : 2);
16437 if (Op != OO_Call &&
16439 return Diag(FnDecl->
getLocation(), diag::err_operator_overload_variadic)
16444 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
16446 diag::err_operator_overload_must_be_member)
16460 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
16467 diag::err_operator_overload_post_incdec_must_be_int)
16468 << LastParam->
getType() << (Op == OO_MinusMinus);
16480 if (TemplateParams->
size() == 1) {
16482 dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->
getParam(0));
16501 }
else if (TemplateParams->
size() == 2) {
16503 dyn_cast<TemplateTypeParmDecl>(TemplateParams->
getParam(0));
16505 dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->
getParam(1));
16517 diag::ext_string_literal_operator_template);
16524 diag::err_literal_operator_template)
16530 if (isa<CXXMethodDecl>(FnDecl)) {
16531 Diag(FnDecl->
getLocation(), diag::err_literal_operator_outside_namespace)
16540 Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
16559 diag::err_literal_operator_template_with_params);
16588 diag::err_literal_operator_param)
16605 diag::err_literal_operator_invalid_param)
16615 QualType FirstParamType = (*Param)->getType().getUnqualifiedType();
16622 Diag((*Param)->getSourceRange().getBegin(),
16623 diag::err_literal_operator_param)
16624 << FirstParamType <<
"'const char *'" << (*Param)->getSourceRange();
16631 Diag((*Param)->getSourceRange().getBegin(),
16632 diag::err_literal_operator_param)
16633 << FirstParamType <<
"'const char *'" << (*Param)->getSourceRange();
16646 Diag((*Param)->getSourceRange().getBegin(),
16647 diag::err_literal_operator_param)
16648 << FirstParamType <<
"'const char *'" << (*Param)->getSourceRange();
16656 QualType SecondParamType = (*Param)->getType().getUnqualifiedType();
16658 Diag((*Param)->getSourceRange().getBegin(),
16659 diag::err_literal_operator_param)
16661 << (*Param)->getSourceRange();
16665 Diag(FnDecl->
getLocation(), diag::err_literal_operator_bad_param_count);
16674 if (Param->hasDefaultArg()) {
16675 Diag(Param->getDefaultArgRange().getBegin(),
16676 diag::err_literal_operator_default_argument)
16677 << Param->getDefaultArgRange();
16692 <<
static_cast<int>(Status)
16703 assert(Lit->
isUnevaluated() &&
"Unexpected string literal kind");
16709 else if (Lang ==
"C++")
16712 Diag(LangStr->
getExprLoc(), diag::err_language_linkage_spec_unknown)
16732 if (
getLangOpts().CPlusPlusModules && isCurrentModulePurview()) {
16733 Module *GlobalModule = PushImplicitGlobalModuleFragment(ExternLoc);
16756 PopImplicitGlobalModuleFragment();
16759 return LinkageSpec;
16792 Diag(
Loc, diag::err_catch_rvalue_ref);
16797 Diag(
Loc, diag::err_catch_variably_modified) << ExDeclType;
16803 unsigned DK = diag::err_catch_incomplete;
16807 DK = diag::err_catch_incomplete_ptr;
16810 BaseType = Ref->getPointeeType();
16812 DK = diag::err_catch_incomplete_ref;
16819 Diag(
Loc, diag::err_wasm_reftype_tc) << 1;
16824 Diag(
Loc, diag::err_catch_sizeless) << (Mode == 2 ? 1 : 0) << BaseType;
16830 diag::err_abstract_type_in_decl,
16842 Diag(
Loc, diag::err_objc_object_catch);
16847 Diag(
Loc, diag::warn_objc_pointer_cxx_catch_fragile);
16856 if (
getLangOpts().ObjCAutoRefCount &&
ObjC().inferObjCARCLifetime(ExDecl))
16881 Expr *opaqueValue =
16916 D.getIdentifierLoc());
16923 RedeclarationKind::ForVisibleRedeclaration)) {
16927 assert(!S->isDeclScope(PrevDecl));
16929 Diag(
D.getIdentifierLoc(), diag::err_redefinition)
16930 <<
D.getIdentifier();
16931 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
16933 }
else if (PrevDecl->isTemplateParameter())
16938 if (
D.getCXXScopeSpec().isSet() && !
Invalid) {
16939 Diag(
D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
16940 <<
D.getCXXScopeSpec().getRange();
16945 S, TInfo,
D.
getBeginLoc(),
D.getIdentifierLoc(),
D.getIdentifier());
16961 Expr *AssertMessageExpr,
16967 AssertMessageExpr, RParenLoc,
false);
16972 case BuiltinType::Char_S:
16973 case BuiltinType::Char_U:
16975 case BuiltinType::Char8:
16978 case BuiltinType::Char16:
16981 case BuiltinType::Char32:
16984 case BuiltinType::WChar_S:
16985 case BuiltinType::WChar_U:
16989 llvm_unreachable(
"Non-character type");
16999 char Arr[UNI_MAX_UTF8_BYTES_PER_CODE_POINT];
17002 llvm::raw_svector_ostream
OS(Str);
17006 if (K == BuiltinType::Char_S || K == BuiltinType::Char_U ||
17007 K == BuiltinType::Char8 ||
Value <= 0x7F) {
17008 StringRef Escaped = escapeCStyle<EscapeChar::Single>(
Value);
17009 if (!Escaped.empty())
17012 OS << static_cast<char>(
Value);
17017 case BuiltinType::Char16:
17018 case BuiltinType::Char32:
17019 case BuiltinType::WChar_S:
17020 case BuiltinType::WChar_U: {
17021 if (llvm::ConvertCodePointToUTF8(
Value, Ptr))
17025 << llvm::format_hex_no_prefix(
Value, TyWidth / 4,
true);
17029 llvm_unreachable(
"Non-character type is passed");
17041 switch (
V.getKind()) {
17047 int64_t BoolValue =
V.getInt().getExtValue();
17048 assert((BoolValue == 0 || BoolValue == 1) &&
17049 "Bool type, but value is not 0 or 1");
17050 llvm::raw_svector_ostream
OS(Str);
17051 OS << (BoolValue ?
"true" :
"false");
17053 llvm::raw_svector_ostream
OS(Str);
17058 switch (BTy->getKind()) {
17059 case BuiltinType::Char_S:
17060 case BuiltinType::Char_U:
17061 case BuiltinType::Char8:
17062 case BuiltinType::Char16:
17063 case BuiltinType::Char32:
17064 case BuiltinType::WChar_S:
17065 case BuiltinType::WChar_U: {
17067 assert(8 <= TyWidth && TyWidth <= 32 &&
"Unexpected integer width");
17068 uint32_t CodeUnit =
static_cast<uint32_t
>(
V.getInt().getZExtValue());
17073 << llvm::format_hex_no_prefix(CodeUnit, 2,
17075 <<
", " <<
V.getInt() <<
')';
17082 V.getInt().toString(Str);
17088 V.getFloat().toString(Str);
17092 if (
V.isNullPointer()) {
17093 llvm::raw_svector_ostream
OS(Str);
17100 llvm::raw_svector_ostream
OS(Str);
17102 V.getComplexFloatReal().toString(Str);
17104 V.getComplexFloatImag().toString(Str);
17109 llvm::raw_svector_ostream
OS(Str);
17111 V.getComplexIntReal().toString(Str);
17113 V.getComplexIntImag().toString(Str);
17136 if (isa<SubstNonTypeTemplateParmExpr>(
E))
17140 if (
const auto *UnaryOp = dyn_cast<UnaryOperator>(
E))
17144 if (
const auto *BO = dyn_cast<BinaryOperator>(
E))
17145 return (BO->isShiftOp() || BO->isAdditiveOp() || BO->isMultiplicativeOp() ||
17146 BO->isBitwiseOp());
17152 if (
const auto *Op = dyn_cast<BinaryOperator>(
E);
17153 Op && Op->getOpcode() != BO_LOr) {
17154 const Expr *LHS = Op->getLHS()->IgnoreParenImpCasts();
17155 const Expr *RHS = Op->getRHS()->IgnoreParenImpCasts();
17173 for (
unsigned I = 0; I < 2; I++) {
17174 const Expr *Side = DiagSide[I].Cond;
17178 DiagSide[I].Print =
17180 DiagSide[I].ValueString,
Context);
17182 if (DiagSide[0].Print && DiagSide[1].Print) {
17183 Diag(Op->getExprLoc(), diag::note_expr_evaluates_to)
17184 << DiagSide[0].ValueString << Op->getOpcodeStr()
17185 << DiagSide[1].ValueString << Op->getSourceRange();
17193 bool ErrorOnInvalidMessage) {
17195 assert(!Message->isTypeDependent() && !Message->isValueDependent() &&
17196 "can't evaluate a dependant static assert message");
17198 if (
const auto *SL = dyn_cast<StringLiteral>(Message)) {
17199 assert(SL->isUnevaluated() &&
"expected an unevaluated string");
17200 Result.assign(SL->getString().begin(), SL->getString().end());
17205 QualType T = Message->getType().getNonReferenceType();
17208 Diag(
Loc, diag::err_static_assert_invalid_message);
17212 auto FindMember = [&](StringRef
Member,
bool &
Empty,
17213 bool Diag =
false) -> std::optional<LookupResult> {
17220 if (MemberLookup.
empty())
17221 return std::nullopt;
17222 return std::move(MemberLookup);
17225 bool SizeNotFound, DataNotFound;
17226 std::optional<LookupResult> SizeMember = FindMember(
"size", SizeNotFound);
17227 std::optional<LookupResult> DataMember = FindMember(
"data", DataNotFound);
17228 if (SizeNotFound || DataNotFound) {
17229 Diag(
Loc, diag::err_static_assert_missing_member_function)
17230 << ((SizeNotFound && DataNotFound) ? 2
17236 if (!SizeMember || !DataMember) {
17238 FindMember(
"size", SizeNotFound,
true);
17240 FindMember(
"data", DataNotFound,
true);
17246 Message, Message->getType(), Message->getBeginLoc(),
false,
17270 Diag(
Loc, diag::err_static_assert_invalid_mem_fn_ret_ty) << 0;
17280 Diag(
Loc, diag::err_static_assert_invalid_mem_fn_ret_ty) << 1;
17284 if (!ErrorOnInvalidMessage &&
17290 Status.Diag = &Notes;
17291 if (!Message->EvaluateCharRangeAsString(
Result, EvaluatedSize.
get(),
17292 EvaluatedData.
get(), Ctx, Status) ||
17294 Diag(Message->getBeginLoc(),
17295 ErrorOnInvalidMessage ? diag::err_static_assert_message_constexpr
17296 : diag::warn_static_assert_message_constexpr);
17297 for (
const auto &
Note : Notes)
17299 return !ErrorOnInvalidMessage;
17305 Expr *AssertExpr,
Expr *AssertMessage,
17308 assert(AssertExpr !=
nullptr &&
"Expected non-null condition");
17326 AssertExpr = FullAssertExpr.
get();
17329 Expr *BaseExpr = AssertExpr;
17341 diag::err_static_assert_expression_is_not_constant,
17347 if (!Failed && AssertMessage && Cond.getBoolValue()) {
17356 bool InTemplateDefinition =
17359 if (!Failed && !Cond && !InTemplateDefinition) {
17361 llvm::raw_svector_ostream Msg(MsgBuffer);
17362 bool HasMessage = AssertMessage;
17363 if (AssertMessage) {
17367 AssertMessage, Str,
Context,
true) ||
17371 Expr *InnerCond =
nullptr;
17372 std::string InnerCondDescription;
17373 std::tie(InnerCond, InnerCondDescription) =
17375 if (InnerCond && isa<ConceptSpecializationExpr>(InnerCond)) {
17383 }
else if (InnerCond && !isa<CXXBoolLiteralExpr>(InnerCond)
17384 && !isa<IntegerLiteral>(InnerCond)) {
17386 diag::err_static_assert_requirement_failed)
17387 << InnerCondDescription << !HasMessage << Msg.str()
17404 AssertExpr = FullAssertExpr.
get();
17408 AssertExpr, AssertMessage, RParenLoc,
17422 bool IsMemberSpecialization =
false;
17427 TagLoc, NameLoc, SS,
nullptr, TempParamLists,
true,
17428 IsMemberSpecialization,
Invalid)) {
17429 if (TemplateParams->size() > 0) {
17437 FriendLoc, TempParamLists.size() - 1,
17438 TempParamLists.data())
17442 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
17444 IsMemberSpecialization =
true;
17450 bool isAllExplicitSpecializations =
true;
17451 for (
unsigned I = TempParamLists.size(); I-- > 0; ) {
17452 if (TempParamLists[I]->size()) {
17453 isAllExplicitSpecializations =
false;
17464 if (isAllExplicitSpecializations) {
17466 bool Owned =
false;
17467 bool IsDependent =
false;
17487 if (isa<DependentNameType>(
T)) {
17502 EllipsisLoc, TempParamLists);
17508 assert(SS.
isNotEmpty() &&
"valid templated tag with no SS and no direct?");
17515 unsigned FriendDeclDepth = TempParamLists.front()->getDepth();
17520 ND = cast<const TemplateTypeParmType *>(
U.first)->getDecl();
17521 Diag(
U.second, diag::friend_template_decl_malformed_pack_expansion)
17530 Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
17542 EllipsisLoc, TempParamLists);
17544 Friend->setUnsupportedFriend(
true);
17568 Diag(FriendLoc, diag::err_friend_not_first_in_declaration);
17600 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
17606 if (TempParams.size()) {
17623 ? diag::warn_cxx98_compat_unelaborated_friend_type
17624 : diag::ext_unelaborated_friend_type)
17630 ? diag::warn_cxx98_compat_nonclass_type_friend
17631 : diag::ext_nonclass_type_friend)
17648 if (!TempParams.empty())
17654 TSI, FriendLoc, EllipsisLoc);
17689 Diag(
Loc, diag::err_unexpected_friend);
17724 Scope *DCScope = S;
17726 RedeclarationKind::ForExternalRedeclaration);
17736 (FunctionContainingLocalClass =
17737 cast<CXXRecordDecl>(
CurContext)->isLocalClass())) {
17749 DCScope = S->getFnParent();
17759 DC =
Previous.getRepresentativeDecl()->getDeclContext();
17763 DC = FunctionContainingLocalClass;
17800 if (isTemplateId) {
17801 if (isa<TranslationUnitDecl>(LookupDC))
break;
17815 if (!DC)
return nullptr;
17826 diag::warn_cxx98_compat_friend_is_member :
17827 diag::err_friend_is_member);
17836 assert(isa<CXXRecordDecl>(DC) &&
"friend declaration not in class?");
17863 if (DiagArg >= 0) {
17864 Diag(
Loc, diag::err_introducing_special_friend) << DiagArg;
17875 DCScope = &FakeDCScope;
17878 bool AddToScope =
true;
17880 TemplateParams, AddToScope);
17881 if (!ND)
return nullptr;
17903 D.getIdentifierLoc(), ND,
17915 FD = FTD->getTemplatedDecl();
17917 FD = cast<FunctionDecl>(ND);
17923 if (
D.isFunctionDefinition()) {
17937 }
else if (FunctionContainingLocalClass) {
17946 }
else if (isTemplateId) {
17959 if (
D.isRedeclaration()) {
17960 Diag(FD->
getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
17962 diag::note_previous_declaration);
17963 }
else if (!
D.isFunctionDefinition())
17964 Diag(FD->
getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
17969 Diag(FD->
getLocation(), diag::warn_template_qualified_friend_unsupported)
17985 FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
17987 Diag(DelLoc, diag::err_deleted_non_function);
17992 Fn->setWillHaveBody(
false);
17994 if (
const FunctionDecl *Prev = Fn->getPreviousDecl()) {
17998 Prev->getPreviousDecl()) &&
17999 !Prev->isDefined()) {
18000 Diag(DelLoc, diag::err_deleted_decl_not_first);
18001 Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
18002 Prev->isImplicit() ? diag::note_previous_implicit_declaration
18003 : diag::note_previous_declaration);
18006 Fn->setInvalidDecl();
18014 Fn = Fn->getCanonicalDecl();
18019 Diag(Fn->getLocation(), diag::err_attribute_dll_deleted) << DLLAttr;
18020 Fn->setInvalidDecl();
18026 Diag(DelLoc, diag::err_deleted_main);
18030 Fn->setImplicitlyInline();
18031 Fn->setDeletedAsWritten(
true, Message);
18038 auto *FD = dyn_cast<FunctionDecl>(Dcl);
18040 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(Dcl)) {
18042 Diag(DefaultLoc, diag::err_defaulted_comparison_template);
18047 Diag(DefaultLoc, diag::err_default_special_members)
18058 (!FD->isDependentContext() ||
18059 (!isa<CXXConstructorDecl>(FD) &&
18061 Diag(DefaultLoc, diag::err_default_special_members)
18071 ? diag::warn_cxx17_compat_defaulted_comparison
18072 : diag::ext_defaulted_comparison);
18075 FD->setDefaulted();
18076 FD->setExplicitlyDefaulted();
18077 FD->setDefaultLoc(DefaultLoc);
18080 if (FD->isDependentContext())
18086 FD->setWillHaveBody(
false);
18099 if (isa<CXXMethodDecl>(FD)) {
18101 if (
const FunctionDecl *Pattern = FD->getTemplateInstantiationPattern())
18115 auto *MD = cast<CXXMethodDecl>(FD);
18126 for (
Stmt *SubStmt : S->children()) {
18129 if (isa<ReturnStmt>(SubStmt))
18130 Self.Diag(SubStmt->getBeginLoc(),
18131 diag::err_return_in_constructor_handler);
18132 if (!isa<Expr>(SubStmt))
18146 switch (BodyKind) {
18155 "Parsed function body should be '= delete;' or '= default;'");
18169 !NewFT->getExtParameterInfo(I).isNoEscape()) {
18171 diag::warn_overriding_method_missing_noescape);
18173 diag::note_overridden_marked_noescape);
18179 Diag(New->
getLocation(), diag::err_conflicting_overriding_attributes)
18186 const auto *OldCSA = Old->
getAttr<CodeSegAttr>();
18187 const auto *NewCSA = New->
getAttr<CodeSegAttr>();
18188 if ((NewCSA || OldCSA) &&
18189 (!OldCSA || !NewCSA || NewCSA->getName() != OldCSA->getName())) {
18200 if (OldFX != NewFXOrig) {
18204 for (
const auto &Diff : Diffs) {
18205 switch (Diff.shouldDiagnoseMethodOverride(*Old, OldFX, *New, NewFX)) {
18210 << Diff.effectName();
18215 NewFX.
insert(Diff.Old.value(), Errs);
18220 NewFT->getParamTypes(), EPI);
18235 if (NewCC == OldCC)
18246 diag::err_conflicting_overriding_cc_attributes)
18259 diag::err_explicit_object_parameter_nonmember)
18286 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
18296 diag::err_different_return_type_for_overriding_virtual_function)
18312 if (!RT->isBeingDefined() &&
18314 diag::err_covariant_return_incomplete,
18331 NewClassTy, OldClassTy,
18332 diag::err_covariant_return_inaccessible_base,
18333 diag::err_covariant_return_ambiguous_derived_to_base_conv,
18349 diag::err_covariant_return_type_different_qualifications)
18361 diag::err_covariant_return_type_class_type_not_same_or_less_qualified)
18391 else if (
auto *M = dyn_cast<CXXMethodDecl>(
D))
18429 if (
auto *VD = dyn_cast<VarDecl>(
D);
18456 "Parser allowed 'typedef' as storage class of condition decl.");
18462 if (isa<FunctionDecl>(Dcl)) {
18468 if (
auto *VD = dyn_cast<VarDecl>(Dcl))
18481 for (
unsigned I = 0, N = VTables.size(); I != N; ++I) {
18482 llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
18486 if (!Pos->second && VTables[I].DefinitionRequired)
18487 Pos->second =
true;
18491 VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
18492 NewUses.push_back(
VTableUse(VTables[I].
Record, VTables[I].Location));
18499 bool DefinitionRequired) {
18502 if (!
Class->isDynamicClass() ||
Class->isDependentContext() ||
18508 !
OpenMP().isInOpenMPDeclareTargetContext() &&
18509 !
OpenMP().isInOpenMPTargetExecutionDirective()) {
18510 if (!DefinitionRequired)
18518 std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator,
bool>
18524 if (DefinitionRequired && !Pos.first->second) {
18525 Pos.first->second =
true;
18554 if (
Class->isLocalClass())
18569 bool DefinedAnything =
false;
18570 for (
unsigned I = 0; I !=
VTableUses.size(); ++I) {
18575 Class->getTemplateSpecializationKind();
18579 bool DefineVTable =
true;
18584 if (
Class->isInCurrentModuleUnit()) {
18585 DefineVTable =
true;
18586 }
else if (KeyFunction && !KeyFunction->
hasBody()) {
18591 DefineVTable =
false;
18596 "Instantiations don't have key functions");
18598 }
else if (!KeyFunction) {
18603 bool IsExplicitInstantiationDeclaration =
18605 for (
auto *R :
Class->redecls()) {
18607 = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
18609 IsExplicitInstantiationDeclaration =
true;
18611 IsExplicitInstantiationDeclaration =
false;
18616 if (IsExplicitInstantiationDeclaration)
18617 DefineVTable =
false;
18623 if (!DefineVTable) {
18631 DefinedAnything =
true;
18644 if (!KeyFunction || (KeyFunction->
hasBody(KeyFunctionDef) &&
18651 return DefinedAnything;
18656 for (
const auto *I : RD->
methods())
18657 if (I->isVirtual() && !I->isPureVirtual())
18663 bool ConstexprOnly) {
18667 for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
18668 E = FinalOverriders.end();
18671 OE = I->second.end();
18673 assert(OI->second.size() > 0 &&
"no final overrider");
18688 for (
const auto &I : RD->
bases()) {
18691 if (
Base->getNumVBases() == 0)
18714 cast_or_null<CXXConstructorDecl>(FNTarget));
18721 if (!Current.insert(Canonical).second)
18726 Target->isInvalidDecl() || Valid.count(TCanonical)) {
18727 Valid.insert(Current.begin(), Current.end());
18730 }
else if (TCanonical == Canonical ||
Invalid.count(TCanonical) ||
18731 Current.count(TCanonical)) {
18733 if (!
Invalid.count(TCanonical)) {
18735 diag::warn_delegating_ctor_cycle)
18739 if (TCanonical != Canonical)
18740 S.
Diag(
Target->getLocation(), diag::note_it_delegates_to);
18743 while (
C->getCanonicalDecl() != Canonical) {
18745 (void)
C->getTargetConstructor()->hasBody(FNTarget);
18746 assert(FNTarget &&
"Ctor cycle through bodiless function");
18749 cast<CXXConstructorDecl>(FNTarget));
18750 S.
Diag(
C->getLocation(), diag::note_which_delegates_to);
18754 Invalid.insert(Current.begin(), Current.end());
18765 for (DelegatingCtorDeclsType::iterator
18771 for (
auto CI =
Invalid.begin(), CE =
Invalid.end(); CI != CE; ++CI)
18772 (*CI)->setInvalidDecl();
18781 explicit FindCXXThisExpr(
Sema &S) : S(S) {}
18784 S.
Diag(
E->getLocation(), diag::err_this_static_member_func)
18785 <<
E->isImplicit();
18809 FindCXXThisExpr Finder(*
this);
18822 if (!Finder.TraverseStmt(
E))
18839 FindCXXThisExpr Finder(*
this);
18861 if (!Finder.TraverseType(
E))
18871 FindCXXThisExpr Finder(*
this);
18874 for (
const auto *A : Method->
attrs()) {
18876 Expr *Arg =
nullptr;
18878 if (
const auto *G = dyn_cast<GuardedByAttr>(A))
18880 else if (
const auto *G = dyn_cast<PtGuardedByAttr>(A))
18882 else if (
const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
18884 else if (
const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
18886 else if (
const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
18887 Arg = ETLF->getSuccessValue();
18889 }
else if (
const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
18890 Arg = STLF->getSuccessValue();
18892 }
else if (
const auto *LR = dyn_cast<LockReturnedAttr>(A))
18893 Arg = LR->getArg();
18894 else if (
const auto *LE = dyn_cast<LocksExcludedAttr>(A))
18896 else if (
const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
18898 else if (
const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
18900 else if (
const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
18902 else if (
const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
18905 if (Arg && !Finder.TraverseStmt(Arg))
18908 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
18909 if (!Finder.TraverseStmt(Args[I]))
18923 Exceptions.clear();
18926 Exceptions.reserve(DynamicExceptions.size());
18927 for (
unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
18934 if (!Unexpanded.empty()) {
18945 Exceptions.push_back(ET);
18955 "Parser should have made sure that the expression is boolean");
18975 D = FTD->getTemplatedDecl();
18985 DynamicExceptionRanges, NoexceptExpr, Exceptions,
19013 Diag(DeclStart, diag::err_anonymous_property);
19025 D.setInvalidType();
19033 if (
D.getDeclSpec().isInlineSpecified())
19034 Diag(
D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
19036 if (
DeclSpec::TSCS TSCS =
D.getDeclSpec().getThreadStorageClassSpec())
19037 Diag(
D.getDeclSpec().getThreadStorageClassSpecLoc(),
19038 diag::err_invalid_thread)
19044 RedeclarationKind::ForVisibleRedeclaration);
19046 switch (
Previous.getResultKind()) {
19053 PrevDecl =
Previous.getRepresentativeDecl();
19066 PrevDecl =
nullptr;
19070 PrevDecl =
nullptr;
19081 Record->setInvalidDecl();
19083 if (
D.getDeclSpec().isModulePrivateSpecified())
19103 if (!ExplicitLists.empty()) {
19104 bool IsMemberSpecialization, IsInvalid;
19108 ExplicitLists,
false, IsMemberSpecialization, IsInvalid,
19120 if (ExplicitParams && !ExplicitParams->
empty()) {
19121 Info.AutoTemplateParameterDepth = ExplicitParams->
getDepth();
19122 llvm::append_range(Info.TemplateParams, *ExplicitParams);
19123 Info.NumExplicitTemplateParams = ExplicitParams->
size();
19125 Info.AutoTemplateParameterDepth = TemplateParameterDepth;
19126 Info.NumExplicitTemplateParams = 0;
19132 if (FSI.TemplateParams.size() > FSI.NumExplicitTemplateParams) {
19133 if (FSI.NumExplicitTemplateParams != 0) {
Defines the clang::ASTContext interface.
enum clang::sema::@1724::IndirectLocalPathEntry::EntryKind Kind
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
static bool CheckLiteralType(EvalInfo &Info, const Expr *E, const LValue *This=nullptr)
Check that this core constant expression is of literal type, and if not, produce an appropriate diagn...
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::Target Target
llvm::MachO::Record Record
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
llvm::SmallVector< std::pair< const MemRegion *, SVal >, 4 > Bindings
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 checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class, SourceLocation CurrentLocation)
Check if we're implicitly defining a move assignment operator for a class with virtual bases.
static void checkMethodTypeQualifiers(Sema &S, Declarator &D, unsigned DiagID)
static void DelegatingCycleHelper(CXXConstructorDecl *Ctor, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Valid, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Invalid, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Current, Sema &S)
static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *Body, Sema::CheckConstexprKind Kind)
Check the body for the given constexpr function declaration only contains the permitted types of stat...
llvm::SmallPtrSet< QualType, 4 > IndirectBaseSet
Use small set to collect indirect bases.
static void checkCUDADeviceBuiltinSurfaceClassTemplate(Sema &S, CXXRecordDecl *Class)
static bool checkVectorDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const VectorType *VT)
static void SearchForReturnInStmt(Sema &Self, Stmt *S)
static void extendRight(SourceRange &R, SourceRange After)
static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc, SourceLocation Loc, IdentifierInfo *II, bool *IsInline, NamespaceDecl *PrevNS)
Diagnose a mismatch in 'inline' qualifiers when a namespace is reopened.
static bool RefersToRValueRef(Expr *MemRef)
static CanQualType RemoveAddressSpaceFromPtr(Sema &SemaRef, const PointerType *PtrTy)
static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base)
Determine whether a direct base class is a virtual base class.
static IsTupleLike isTupleLike(Sema &S, SourceLocation Loc, QualType T, llvm::APSInt &Size)
#define CheckPolymorphic(Type)
static void WriteCharValueForDiagnostic(uint32_t Value, const BuiltinType *BTy, unsigned TyWidth, SmallVectorImpl< char > &Str)
Convert character's value, interpreted as a code unit, to a string.
static bool checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc, QualType SubType, bool ConstRHS, CXXSpecialMemberKind CSM, TrivialSubobjectKind Kind, Sema::TrivialABIHandling TAH, bool Diagnose)
Check whether the special member selected for a given type would be trivial.
static void CheckAbstractClassUsage(AbstractUsageInfo &Info, FunctionDecl *FD)
Check for invalid uses of an abstract type in a function declaration.
static unsigned getRecordDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for record diagnostic message.
static Expr * CastForMoving(Sema &SemaRef, Expr *E)
static void extendLeft(SourceRange &R, SourceRange Before)
static bool checkTrivialClassMembers(Sema &S, CXXRecordDecl *RD, CXXSpecialMemberKind CSM, bool ConstArg, Sema::TrivialABIHandling TAH, bool Diagnose)
Check whether the members of a class type allow a special member to be trivial.
static bool specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, unsigned Quals, bool ConstRHS, CXXConstructorDecl *InheritedCtor=nullptr, Sema::InheritedConstructorInfo *Inherited=nullptr)
Is the special member function which would be selected to perform the specified operation on the spec...
static void diagnoseInvalidDeclaratorChunks(Sema &S, Declarator &D, unsigned Kind)
static bool canPassInRegisters(Sema &S, CXXRecordDecl *D, TargetInfo::CallingConvKind CCK)
Determine whether a type is permitted to be passed or returned in registers, per C++ [class....
static void lookupOperatorsForDefaultedComparison(Sema &Self, Scope *S, UnresolvedSetImpl &Operators, OverloadedOperatorKind Op)
Perform the unqualified lookups that might be needed to form a defaulted comparison function for the ...
static void WriteCharTypePrefix(BuiltinType::Kind BTK, llvm::raw_ostream &OS)
static bool findTrivialSpecialMember(Sema &S, CXXRecordDecl *RD, CXXSpecialMemberKind CSM, unsigned Quals, bool ConstRHS, Sema::TrivialABIHandling TAH, CXXMethodDecl **Selected)
Perform lookup for a special member of the specified kind, and determine whether it is trivial.
static void diagnoseDeprecatedCopyOperation(Sema &S, CXXMethodDecl *CopyOp)
Diagnose an implicit copy operation for a class which is odr-used, but which is deprecated because th...
static void AddMostOverridenMethods(const CXXMethodDecl *MD, llvm::SmallPtrSetImpl< const CXXMethodDecl * > &Methods)
Add the most overridden methods from MD to Methods.
static bool CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl, CanQualType ExpectedResultType, CanQualType ExpectedFirstParamType, unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag)
static DeclAccessPair findDecomposableBaseClass(Sema &S, SourceLocation Loc, const CXXRecordDecl *RD, CXXCastPath &BasePath)
Find the base class to decompose in a built-in decomposition of a class type.
static const void * GetKeyForBase(ASTContext &Context, QualType BaseType)
static Sema::ImplicitExceptionSpecification ComputeDefaultedComparisonExceptionSpec(Sema &S, SourceLocation Loc, FunctionDecl *FD, Sema::DefaultedComparisonKind DCK)
static StmtResult buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &To, const ExprBuilder &From, bool CopyingBaseSubobject, bool Copying, unsigned Depth=0)
Builds a statement that copies/moves the given entity from From to To.
static void checkCUDADeviceBuiltinTextureClassTemplate(Sema &S, CXXRecordDecl *Class)
static void AddInitializerToDiag(const Sema::SemaDiagnosticBuilder &Diag, const CXXCtorInitializer *Previous, const CXXCtorInitializer *Current)
static bool BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, CXXBaseSpecifier *BaseSpec, bool IsInheritedVirtualBase, CXXCtorInitializer *&CXXBaseInit)
static bool checkTupleLikeDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, VarDecl *Src, QualType DecompType, const llvm::APSInt &TupleSize)
static void NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set, const QualType &Type)
Recursively add the bases of Type. Don't add Type itself.
static bool CheckConstexprMissingReturn(Sema &SemaRef, const FunctionDecl *Dcl)
static bool CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S, SmallVectorImpl< SourceLocation > &ReturnStmts, SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc, SourceLocation &Cxx2bLoc, Sema::CheckConstexprKind Kind)
Check the provided statement is allowed in a constexpr function definition.
static bool functionDeclHasDefaultArgument(const FunctionDecl *FD)
static bool CheckConstexprParameterTypes(Sema &SemaRef, const FunctionDecl *FD, Sema::CheckConstexprKind Kind)
Check whether a function's parameter types are all literal types.
static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext)
Determine whether a using statement is in a context where it will be apply in all contexts.
static CXXConstructorDecl * findUserDeclaredCtor(CXXRecordDecl *RD)
static bool checkMemberDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const CXXRecordDecl *OrigRD)
static void checkForMultipleExportedDefaultConstructors(Sema &S, CXXRecordDecl *Class)
static bool checkSimpleDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType, llvm::function_ref< ExprResult(SourceLocation, Expr *, unsigned)> GetInit)
static TemplateArgumentLoc getTrivialTypeTemplateArgument(Sema &S, SourceLocation Loc, QualType T)
static void findImplicitlyDeclaredEqualityComparisons(ASTContext &Ctx, CXXRecordDecl *RD, llvm::SmallVectorImpl< FunctionDecl * > &Spaceships)
Find the equality comparison functions that should be implicitly declared in a given class definition...
static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl< const void * > &IdealInits)
ImplicitInitializerKind
ImplicitInitializerKind - How an implicit base or member initializer should initialize its base or me...
static bool ConvertAPValueToString(const APValue &V, QualType T, SmallVectorImpl< char > &Str, ASTContext &Context)
Convert \V to a string we can present to the user in a diagnostic \T is the type of the expression th...
static NamespaceDecl * getNamespaceDecl(NamedDecl *D)
getNamespaceDecl - Returns the namespace a decl represents.
static bool checkArrayDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const ConstantArrayType *CAT)
static void ReferenceDllExportedMembers(Sema &S, CXXRecordDecl *Class)
static bool UsefulToPrintExpr(const Expr *E)
Some Expression types are not useful to print notes about, e.g.
static bool FindBaseInitializer(Sema &SemaRef, CXXRecordDecl *ClassDecl, QualType BaseType, const CXXBaseSpecifier *&DirectBaseSpec, const CXXBaseSpecifier *&VirtualBaseSpec)
Find the direct and/or virtual base specifiers that correspond to the given base type,...
static bool checkLiteralOperatorTemplateParameterList(Sema &SemaRef, FunctionTemplateDecl *TpDecl)
static ClassTemplateDecl * LookupStdInitializerList(Sema &S, SourceLocation Loc)
static bool CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl)
static bool ReportOverrides(Sema &S, unsigned DiagID, const CXXMethodDecl *MD, llvm::function_ref< bool(const CXXMethodDecl *)> Report)
Report an error regarding overriding, along with any relevant overridden methods.
static bool CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl)
static const void * GetKeyForMember(ASTContext &Context, CXXCtorInitializer *Member)
static std::string printTemplateArgs(const PrintingPolicy &PrintingPolicy, TemplateArgumentListInfo &Args, const TemplateParameterList *Params)
static bool CheckConstexprReturnType(Sema &SemaRef, const FunctionDecl *FD, Sema::CheckConstexprKind Kind)
Check whether a function's return type is a literal type.
static void DiagnoseBaseOrMemInitializerOrder(Sema &SemaRef, const CXXConstructorDecl *Constructor, ArrayRef< CXXCtorInitializer * > Inits)
static Sema::ImplicitExceptionSpecification computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, FunctionDecl *FD)
static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T)
Determine whether the given type is an incomplete or zero-lenfgth array type.
TrivialSubobjectKind
The kind of subobject we are checking for triviality.
@ TSK_CompleteObject
The object is actually the complete object.
@ TSK_Field
The subobject is a non-static data member.
@ TSK_BaseClass
The subobject is a base class.
static bool hasOneRealArgument(MultiExprArg Args)
Determine whether the given list arguments contains exactly one "real" (non-default) argument.
static StmtResult buildMemcpyForAssignmentOp(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &ToB, const ExprBuilder &FromB)
When generating a defaulted copy or move assignment operator, if a field should be copied with __buil...
static void DefineDefaultedFunction(Sema &S, FunctionDecl *FD, SourceLocation DefaultLoc)
static bool BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, FieldDecl *Field, IndirectFieldDecl *Indirect, CXXCtorInitializer *&CXXMemberInit)
static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info, FieldDecl *Field, IndirectFieldDecl *Indirect=nullptr)
static CXXBaseSpecifier * findDirectBaseWithType(CXXRecordDecl *Derived, QualType DesiredBase, bool &AnyDependentBases)
Find the base specifier for a base class with the given type.
static Sema::SpecialMemberOverloadResult lookupCallFromSpecialMember(Sema &S, CXXRecordDecl *Class, CXXSpecialMemberKind CSM, unsigned FieldQuals, bool ConstRHS)
Look up the special member function that would be called by a special member function for a subobject...
static bool defaultedSpecialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, bool ConstArg, CXXConstructorDecl *InheritedCtor=nullptr, Sema::InheritedConstructorInfo *Inherited=nullptr)
Determine whether the specified special member function would be constexpr if it were implicitly defi...
static bool lookupStdTypeTraitMember(Sema &S, LookupResult &TraitMemberLookup, SourceLocation Loc, StringRef Trait, TemplateArgumentListInfo &Args, unsigned DiagID)
static void DiagnoseInvisibleNamespace(const TypoCorrection &Corrected, Sema &S)
static StmtResult buildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &To, const ExprBuilder &From, bool CopyingBaseSubobject, bool Copying)
static FunctionProtoType::ExtProtoInfo getImplicitMethodEPI(Sema &S, CXXMethodDecl *MD)
static QualType getTupleLikeElementType(Sema &S, SourceLocation Loc, unsigned I, QualType T)
static Sema::ImplicitExceptionSpecification ComputeDefaultedSpecialMemberExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD, CXXSpecialMemberKind CSM, Sema::InheritedConstructorInfo *ICI)
static bool checkComplexDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const ComplexType *CT)
static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident)
static bool InitializationHasSideEffects(const FieldDecl &FD)
static bool CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef, const FunctionDecl *FnDecl)
static bool checkArrayLikeDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType)
static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl, DeclStmt *DS, SourceLocation &Cxx1yLoc, Sema::CheckConstexprKind Kind)
Check the given declaration statement is legal within a constexpr function body.
static bool IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2)
Determine whether a using declaration considers the given declarations as "equivalent",...
static TemplateArgumentLoc getTrivialIntegralTemplateArgument(Sema &S, SourceLocation Loc, QualType T, uint64_t I)
static bool CheckConstexprDestructorSubobjects(Sema &SemaRef, const CXXDestructorDecl *DD, Sema::CheckConstexprKind Kind)
Determine whether a destructor cannot be constexpr due to.
static bool CheckConstexprCtorInitializer(Sema &SemaRef, const FunctionDecl *Dcl, FieldDecl *Field, llvm::SmallSet< Decl *, 16 > &Inits, bool &Diagnosed, Sema::CheckConstexprKind Kind)
Check that the given field is initialized within a constexpr constructor.
static bool isProvablyNotDerivedFrom(Sema &SemaRef, CXXRecordDecl *Record, const BaseSet &Bases)
Determines if the given class is provably not derived from all of the prospective base classes.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
static bool isInvalid(LocType Loc, bool *Invalid)
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the clang::TypeLoc interface and its subclasses.
Allows QualTypes to be sorted and hence used in maps and sets.
const NestedNameSpecifier * Specifier
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
std::pair< CXXConstructorDecl *, bool > findConstructorForBase(CXXRecordDecl *Base, CXXConstructorDecl *Ctor) const
Find the constructor to use for inherited construction of a base class, and whether that base class c...
InheritedConstructorInfo(Sema &S, SourceLocation UseLoc, ConstructorUsingShadowDecl *Shadow)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
virtual void HandleVTable(CXXRecordDecl *RD)
Callback involved at the end of a translation unit to notify the consumer that a vtable for the given...
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
const ConstantArrayType * getAsConstantArrayType(QualType T) const
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
unsigned getIntWidth(QualType T) const
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 getRecordType(const RecordDecl *Decl) const
unsigned NumImplicitCopyAssignmentOperatorsDeclared
The number of implicitly-declared copy assignment operators for which declarations were built.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
unsigned NumImplicitDestructorsDeclared
The number of implicitly-declared destructors for which declarations were built.
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
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...
void Deallocate(void *Ptr) const
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
const LangOptions & getLangOpts() const
QualType getConstType(QualType T) const
Return the uniqued reference to the type for a const qualified type.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
ComparisonCategories CompCategories
Types and expressions required to build C++2a three-way comparisons using operator<=>,...
unsigned NumImplicitDefaultConstructorsDeclared
The number of implicitly-declared default constructors for which declarations were built.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
bool hasAnyFunctionEffects() const
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
unsigned NumImplicitMoveConstructorsDeclared
The number of implicitly-declared move constructors for which declarations were built.
unsigned NumImplicitCopyConstructorsDeclared
The number of implicitly-declared copy constructors for which declarations were built.
unsigned NumImplicitDestructors
The number of implicitly-declared destructors.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated,...
const clang::PrintingPolicy & getPrintingPolicy() const
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.
unsigned NumImplicitDefaultConstructors
The number of implicitly-declared default constructors.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
unsigned NumImplicitMoveAssignmentOperatorsDeclared
The number of implicitly-declared move assignment operators for which declarations were built.
unsigned NumImplicitMoveConstructors
The number of implicitly-declared move constructors.
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getExceptionObjectType(QualType T) const
CanQualType UnsignedLongLongTy
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
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
llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const
Make an APSInt of the appropriate width and signedness for the given Value and integer Type.
bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y, bool IgnoreDeduced=false) const
Determine whether the given template names refer to the same template.
const TargetInfo & getTargetInfo() const
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
unsigned NumImplicitCopyConstructors
The number of implicitly-declared copy constructors.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
unsigned NumImplicitCopyAssignmentOperators
The number of implicitly-declared copy assignment operators.
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
unsigned NumImplicitMoveAssignmentOperators
The number of implicitly-declared move assignment operators.
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
Represents an access specifier followed by colon ':'.
static AccessSpecDecl * Create(ASTContext &C, AccessSpecifier AS, DeclContext *DC, SourceLocation ASLoc, SourceLocation ColonLoc)
Wrapper for source info for arrays.
TypeLoc getElementLoc() 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
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
AutoTypeKeyword getKeyword() const
Represents a C++ declaration that introduces decls from somewhere else.
unsigned shadow_size() const
Return the number of shadowed declarations associated with this using declaration.
void addShadowDecl(UsingShadowDecl *S)
shadow_iterator shadow_begin() const
void removeShadowDecl(UsingShadowDecl *S)
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
A builtin binary operation expression such as "x + y" or "x <= y".
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
A binding in a decomposition declaration.
static BindingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id)
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Wrapper for source info for block pointers.
This class is used for builtin types like 'int'.
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
AccessSpecifier Access
The access along this inheritance path.
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
std::list< CXXBasePath >::iterator paths_iterator
Represents a base class of a C++ class.
SourceLocation getBeginLoc() const LLVM_READONLY
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
QualType getType() const
Retrieves the type of the base class.
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
AccessSpecifier getAccessSpecifier() const
Returns the access specifier for this base specifier.
A boolean literal, per ([C++ lex.bool] Boolean literals).
CXXCatchStmt - This represents a C++ catch block.
Represents a call to a C++ constructor.
static CXXConstructExpr * Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, CXXConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Create a C++ construction expression.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Represents a C++ constructor within a class.
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isMoveConstructor(unsigned &TypeQuals) const
Determine whether this constructor is a move constructor (C++11 [class.copy]p3), which can be used to...
ExplicitSpecifier getExplicitSpecifier()
init_iterator init_begin()
Retrieve an iterator to the first initializer.
CXXConstructorDecl * getTargetConstructor() const
When this constructor delegates to another, retrieve the target.
bool isCopyConstructor(unsigned &TypeQuals) const
Whether this constructor is a copy constructor (C++ [class.copy]p2, which can be used to copy the cla...
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
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.
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Represents a C++ base or member initializer.
bool isWritten() const
Determine whether this initializer is explicitly written in the source code.
SourceRange getSourceRange() const LLVM_READONLY
Determine the source range covering the entire initializer.
SourceLocation getSourceLocation() const
Determine the source location of the initializer.
FieldDecl * getAnyMember() const
A use of a default initializer in a constructor or in aggregate initialization.
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 call to an inherited base class constructor from an inheriting constructor.
Represents a call to a member function that may be written either with member call syntax (e....
CXXMethodDecl * getMethodDecl() const
Retrieve the declaration of the called method.
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...
bool isImplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An implicit object member function is a non-static member function without an exp...
unsigned getNumExplicitParams() const
CXXMethodDecl * getMostRecentDecl()
overridden_method_range overridden_methods() const
unsigned size_overridden_methods() const
QualType getFunctionObjectParameterReferenceType() const
Return the type of the object pointed by this.
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this method.
method_iterator begin_overridden_methods() const
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)
QualType getFunctionObjectParameterType() 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.
The null pointer literal (C++11 [lex.nullptr])
A call to an overloaded operator written using operator syntax.
Represents a C++ struct/union/class.
bool hasConstexprDefaultConstructor() const
Determine whether this class has a constexpr default constructor.
friend_range friends() const
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class....
bool isTriviallyCopyable() const
Determine whether this class is considered trivially copyable per (C++11 [class]p6).
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
bool hasUserDeclaredDestructor() const
Determine whether this class has a user-declared destructor.
bool implicitCopyConstructorHasConstParam() const
Determine whether an implicit copy constructor for this type would have a parameter with a const-qual...
bool hasInheritedAssignment() const
Determine whether this class has a using-declaration that names a base class assignment operator.
bool allowConstDefaultInit() const
Determine whether declaring a const variable with this type is ok per core issue 253.
bool hasTrivialDestructorForCall() const
bool defaultedMoveConstructorIsDeleted() const
true if a defaulted move constructor for this class would be deleted.
bool isLiteral() const
Determine whether this class is a literal type.
bool hasUserDeclaredMoveAssignment() const
Determine whether this class has had a move assignment declared by the user.
bool defaultedDestructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation.
bool isLambda() const
Determine whether this class describes a lambda function object.
bool hasTrivialMoveConstructor() const
Determine whether this class has a trivial move constructor (C++11 [class.copy]p12)
bool needsImplicitDefaultConstructor() const
Determine if we need to declare a default constructor for this class.
bool needsImplicitMoveConstructor() const
Determine whether this class should get an implicit move constructor or if any existing special membe...
bool hasUserDeclaredCopyAssignment() const
Determine whether this class has a user-declared copy assignment operator.
method_range methods() const
CXXRecordDecl * getDefinition() const
bool needsOverloadResolutionForCopyAssignment() const
Determine whether we need to eagerly declare a defaulted copy assignment operator for this class.
static AccessSpecifier MergeAccess(AccessSpecifier PathAccess, AccessSpecifier DeclAccess)
Calculates the access of a decl that is reached along a path.
bool defaultedDefaultConstructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class....
void setImplicitMoveAssignmentIsDeleted()
Set that we attempted to declare an implicit move assignment operator, but overload resolution failed...
bool hasConstexprDestructor() const
Determine whether this class has a constexpr destructor.
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
unsigned getNumBases() const
Retrieves the number of base classes of this class.
bool defaultedCopyConstructorIsDeleted() const
true if a defaulted copy constructor for this class would be deleted.
bool hasTrivialCopyConstructorForCall() const
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...
bool lambdaIsDefaultConstructibleAndAssignable() const
Determine whether this lambda should have an implicit default constructor and copy and move assignmen...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
bool hasTrivialCopyAssignment() const
Determine whether this class has a trivial copy assignment operator (C++ [class.copy]p11,...
base_class_range vbases()
base_class_iterator vbases_begin()
void setImplicitMoveConstructorIsDeleted()
Set that we attempted to declare an implicit move constructor, but overload resolution failed so we d...
bool isAbstract() const
Determine whether this class has a pure virtual function.
bool hasVariantMembers() const
Determine whether this class has any variant members.
void setImplicitCopyConstructorIsDeleted()
Set that we attempted to declare an implicit copy constructor, but overload resolution failed so we d...
bool isDynamicClass() const
bool hasInClassInitializer() const
Whether this class has any in-class initializers for non-static data members (including those in anon...
bool needsImplicitCopyConstructor() const
Determine whether this class needs an implicit copy constructor to be lazily declared.
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
bool hasDirectFields() const
Determine whether this class has direct non-static data members.
bool hasUserDeclaredCopyConstructor() const
Determine whether this class has a user-declared copy constructor.
bool hasDefinition() const
void setImplicitCopyAssignmentIsDeleted()
Set that we attempted to declare an implicit copy assignment operator, but overload resolution failed...
bool needsImplicitDestructor() const
Determine whether this class needs an implicit destructor to be lazily declared.
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
void getFinalOverriders(CXXFinalOverriderMap &FinaOverriders) const
Retrieve the final overriders for each virtual member function in the class hierarchy where this clas...
bool needsOverloadResolutionForMoveConstructor() const
Determine whether we need to eagerly declare a defaulted move constructor for this class.
bool needsOverloadResolutionForMoveAssignment() const
Determine whether we need to eagerly declare a move assignment operator for this class.
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
bool needsOverloadResolutionForDestructor() const
Determine whether we need to eagerly declare a destructor for this class.
bool hasInheritedConstructor() const
Determine whether this class has a using-declaration that names a user-declared base class constructo...
CXXMethodDecl * getLambdaStaticInvoker() const
Retrieve the lambda static invoker, the address of which is returned by the conversion operator,...
bool needsOverloadResolutionForCopyConstructor() const
Determine whether we need to eagerly declare a defaulted copy constructor for this class.
bool hasUserDeclaredMoveConstructor() const
Determine whether this class has had a move constructor declared by the user.
bool needsImplicitMoveAssignment() const
Determine whether this class should get an implicit move assignment operator or if any existing speci...
bool isInterfaceLike() const
bool needsImplicitCopyAssignment() const
Determine whether this class needs an implicit copy assignment operator to be lazily declared.
bool hasTrivialMoveConstructorForCall() const
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
bool implicitCopyAssignmentHasConstParam() const
Determine whether an implicit copy assignment operator for this type would have a parameter with a co...
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.
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.
Represents the this expression in C++.
SourceLocation getBeginLoc() const
CXXTryStmt - A C++ try block, including all handlers.
CXXCatchStmt * getHandler(unsigned i)
unsigned getNumHandlers() const
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed.
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
static CharSourceRange getTokenRange(SourceRange R)
SourceLocation getBegin() const
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Declaration of a class template.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
Represents a class template specialization, which refers to a class template with a given set of temp...
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
bool isExplicitSpecialization() const
const ComparisonCategoryInfo * lookupInfoForType(QualType Ty) const
const ComparisonCategoryInfo & getInfoForType(QualType Ty) const
Return the comparison category information as specified by getCategoryForType(Ty).
const ComparisonCategoryInfo * lookupInfo(ComparisonCategoryType Kind) const
Return the cached comparison category information for the specified 'Kind'.
static StringRef getCategoryString(ComparisonCategoryType Kind)
static StringRef getResultString(ComparisonCategoryResult Kind)
static std::vector< ComparisonCategoryResult > getPossibleResultsForType(ComparisonCategoryType Type)
Return the list of results which are valid for the specified comparison category type.
const CXXRecordDecl * Record
The declaration for the comparison category type from the standard library.
const ValueInfo * getValueInfo(ComparisonCategoryResult ValueKind) const
ComparisonCategoryType Kind
The Kind of the comparison category type.
Complex values, per C99 6.2.5p11.
QualType getElementType() const
CompoundStmt - This represents a group of statements like { stmt stmt }.
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt * > Stmts, FPOptionsOverride FPFeatures, SourceLocation LB, SourceLocation RB)
ConditionalOperator - The ?: ternary operator.
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Represents the canonical version of C arrays with a specified constant size.
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...
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
const CXXRecordDecl * getParent() const
Returns the parent of this using shadow declaration, which is the class in which this is declared.
static ConstructorUsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, UsingDecl *Using, NamedDecl *Target, bool IsVirtual)
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
NamedDecl * getDecl() const
AccessSpecifier getAccess() const
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 isDependentContext() const
Determines whether this context is dependent on a template parameter.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
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.
decl_iterator decls_end() const
bool isStdNamespace() const
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
Decl::Kind getDeclKind() const
DeclContext * getNonTransparentContext()
decl_iterator decls_begin() const
A reference to a declared variable, function, enum, etc.
SourceLocation getBeginLoc() const LLVM_READONLY
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
Captures information about "declaration specifiers".
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
Expr * getPackIndexingExpr() const
TST getTypeSpecType() const
SourceLocation getStorageClassSpecLoc() const
SCS getStorageClassSpec() const
SourceLocation getBeginLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
SourceLocation getExplicitSpecLoc() const
SourceLocation getFriendSpecLoc() const
ParsedType getRepAsType() const
bool isFriendSpecifiedFirst() const
SourceLocation getEllipsisLoc() const
SourceLocation getConstSpecLoc() const
SourceRange getExplicitSpecRange() const
Expr * getRepAsExpr() const
SourceLocation getRestrictSpecLoc() const
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
SourceLocation getAtomicSpecLoc() const
SourceLocation getConstexprSpecLoc() const
SourceLocation getTypeSpecTypeLoc() const
void forEachQualifier(llvm::function_ref< void(TQ, StringRef, SourceLocation)> Handle)
This method calls the passed in handler on each qual being set.
SourceLocation getUnalignedSpecLoc() const
SourceLocation getVolatileSpecLoc() const
FriendSpecified isFriendSpecified() const
bool hasExplicitSpecifier() const
bool hasConstexprSpecifier() const
static const TST TST_auto
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
SourceLocation getBeginLoc() const LLVM_READONLY
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
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.
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Kind
Lists the kind of concrete classes of Decl.
void clearIdentifierNamespace()
Clears the namespace of this declaration.
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
@ FOK_Undeclared
A friend of a previously-undeclared entity.
@ FOK_None
Not a friend object.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
DeclContext * getNonTransparentDeclContext()
Return the non transparent context.
bool isInvalidDecl() const
unsigned getIdentifierNamespace() const
bool isLocalExternDecl() const
Determine whether this is a block-scope declaration with linkage.
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
@ IDNS_Ordinary
Ordinary names.
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack.
void setLocalOwningModule(Module *M)
void setImplicit(bool I=true)
void setReferenced(bool R=true)
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
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
@ VisibleWhenImported
This declaration has an owning module, and is visible when that module is imported.
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
The name of a declaration.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
std::string getAsString() const
Retrieve the human-readable string for this name.
const IdentifierInfo * getCXXLiteralIdentifier() const
If this name is the name of a literal operator, retrieve the identifier associated with it.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
@ CXXConversionFunctionName
NameKind getNameKind() const
Determine what kind of name this is.
bool isIdentifier() const
Predicate functions for querying what type of name this is.
Represents a ValueDecl that came out of a declarator.
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getNumTemplateParameterLists() const
void setTypeSourceInfo(TypeSourceInfo *TI)
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
SourceLocation getIdentifierLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
ArrayRef< TemplateParameterList * > getTemplateParameterLists() const
The template parameter lists that preceded the declarator.
void setInventedTemplateParameterList(TemplateParameterList *Invented)
Sets the template parameter list generated from the explicit template parameters along with any inven...
bool isInvalidType() const
A decomposition declaration.
ArrayRef< BindingDecl * > bindings() const
A parsed C++17 decomposition declarator of the form '[' identifier-list ']'.
SourceRange getSourceRange() const
SourceLocation getLSquareLoc() const
Represents a C++17 deduced template specialization type.
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine a...
bool isLastDiagnosticIgnored() const
Determine whether the previous diagnostic was ignored.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Recursive AST visitor that supports extension via dynamic dispatch.
virtual bool TraverseConstructorInitializer(CXXCtorInitializer *Init)
Recursively visit a constructor initializer.
void setElaboratedKeywordLoc(SourceLocation Loc)
TypeLoc getNamedTypeLoc() const
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
static EmptyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
RAII object that enters a new expression evaluation context.
An instance of this object exists for each enum constant that is defined.
enumerator_range enumerators() const
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.
const Expr * getExpr() const
void setKind(ExplicitSpecKind Kind)
This represents one expression.
static bool isPotentialConstantExpr(const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExpr - Return true if this function's definition might be usable in a constant exp...
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...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
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.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
void setInClassInitializer(Expr *NewInit)
Set the C++11 in-class initializer for this member.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateInsertionFromRange(SourceLocation InsertionLoc, CharSourceRange FromRange, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code from FromRange at a specific location.
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.
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, SourceLocation EllipsisLoc={}, ArrayRef< TemplateParameterList * > FriendTypeTPLists={})
void setUnsupportedFriend(bool Unsupported)
static FriendTemplateDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc, MutableArrayRef< TemplateParameterList * > Params, FriendUnion Friend, SourceLocation FriendLoc)
static DefaultedOrDeletedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups, StringLiteral *DeletedMessage=nullptr)
Represents a function declaration or definition.
const ParmVarDecl * getParamDecl(unsigned i) const
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
ExceptionSpecificationType getExceptionSpecType() const
Gets the ExceptionSpecificationType as declared.
bool isTrivialForCall() const
ConstexprSpecKind getConstexprKind() const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
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 ...
bool isImmediateFunction() const
void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
bool hasCXXExplicitFunctionObjectParameter() const
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
SourceLocation getDefaultLoc() const
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
MutableArrayRef< ParmVarDecl * >::iterator param_iterator
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
FunctionTypeLoc getFunctionTypeLoc() const
Find the source location information for how the type of this function was written.
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.
void setBodyContainsImmediateEscalatingExpressions(bool Set)
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
FunctionEffectsRef getFunctionEffects() const
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
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 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 isImmediateEscalating() const
bool isThisDeclarationInstantiatedFromAFriendDefinition() const
Determine whether this specific declaration of the function is a friend declaration that was instanti...
void setRangeEnd(SourceLocation E)
bool isDefaulted() const
Whether this function is defaulted.
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+".
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
void setConstexprKind(ConstexprSpecKind CSK)
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
void setDefaulted(bool D=true)
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration.
QualType getDeclaredReturnType() const
Get the declared return type, which may differ from the actual return type if the return type is dedu...
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
bool hasOneParamOrDefaultArgs() const
Determine whether this function has a single parameter, or multiple parameters where all but the firs...
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
size_t param_size() const
DeclarationNameInfo getNameInfo() const
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
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.
DefaultedOrDeletedFunctionInfo * getDefalutedOrDeletedInfo() const
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
A mutable set of FunctionEffects and possibly conditions attached to them.
bool insert(const FunctionEffectWithCondition &NewEC, Conflicts &Errs)
An immutable set of FunctionEffects and possibly conditions attached to them.
Represents a prototype with parameter type info, e.g.
ExtParameterInfo getExtParameterInfo(unsigned I) const
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
unsigned getNumParams() const
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
QualType getParamType(unsigned i) const
ExtProtoInfo getExtProtoInfo() const
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
ArrayRef< QualType > getParamTypes() const
ArrayRef< QualType > exceptions() const
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type?
Declaration of a template function.
Wrapper for source info for functions.
unsigned getNumParams() const
ParmVarDecl * getParam(unsigned i) const
void setParam(unsigned i, ParmVarDecl *VD)
TypeLoc getReturnLoc() const
ExtInfo withCallingConv(CallingConv cc) const
FunctionType - C99 6.7.5.3 - Function Declarators.
CallingConv getCallConv() const
QualType getReturnType() const
One of these records is kept for each identifier that is lexed.
unsigned getLength() const
Efficiently return the length of this identifier info.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
ReservedLiteralSuffixIdStatus isReservedLiteralSuffixId() const
Determine whether this is a name reserved for future standardization or the implementation (C++ [usrl...
bool isPlaceholder() const
StringRef getName() const
Return the actual identifier string.
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
IfStmt - This represents an if/then/else.
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
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 an implicitly-generated value initialization of an object of a given type.
Represents a field injected from an anonymous union/struct into the parent scope.
void setInherited(bool I)
Description of a constructor that was inherited from a base class.
ConstructorUsingShadowDecl * getShadowDecl() const
const TypeClass * getTypePtr() const
Describes an C or C++ initializer list.
unsigned getNumInits() const
const Expr * getInit(unsigned Init) const
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 CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static InitializationKind CreateDirectList(SourceLocation InitLoc)
Describes the sequence of initializations required to initialize a given object or reference with a s...
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.
Describes an entity that is being initialized.
static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a base class subobject.
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
static InitializedEntity InitializeBinding(VarDecl *Binding)
Create the initialization entity for a structured binding.
static InitializedEntity InitializeMemberFromDefaultMemberInitializer(FieldDecl *Member)
Create the initialization entity for a default member initializer.
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
static InitializedEntity InitializeDelegation(QualType Type)
Create the initialization entity for a delegated constructor.
The injected class name of a C++ class template or class template partial specialization.
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'.
An lvalue reference type, per C++11 [dcl.ref].
Describes the capture of a variable or of this, or of a C++1y init-capture.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
bool isInitCapture(const LambdaCapture *Capture) const
Determine whether one of this lambda's captures is an init-capture.
capture_range captures() const
Retrieve this lambda's captures.
@ Ver4
Attempt to be ABI-compatible with code generated by Clang 4.0.x (SVN r291814).
@ Ver14
Attempt to be ABI-compatible with code generated by Clang 14.0.x.
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
void push_back(const T &LocalValue)
iterator begin(Source *source, bool LocalOnly=false)
static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)
Returns a string for the source that the range encompasses.
Represents a linkage specification.
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LinkageSpecLanguageIDs Lang, bool HasBraces)
void setRBraceLoc(SourceLocation L)
bool isLocalPackExpansion(const Decl *D)
Determine whether D is a pack expansion created in this scope.
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.
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
void setBaseObjectType(QualType T)
Sets the base object type for this lookup.
DeclClass * getAsSingle() const
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
void setLookupName(DeclarationName Name)
Sets the name to look up.
bool empty() const
Return true if no decls were found.
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
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.
void setHideTags(bool Hide)
Sets whether tag declarations should be hidden by non-tag declarations during resolution.
NamedDecl * getAcceptableDecl(NamedDecl *D) const
Retrieve the accepted (re)declaration of the given declaration, if there is one.
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.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
static bool isVisible(Sema &SemaRef, NamedDecl *D)
Determine whether the given declaration is visible to the program.
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
An instance of this class represents the declaration of a property member.
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
SourceLocation getExprLoc() const LLVM_READONLY
Wrapper for source info for member pointers.
A pointer to member type per C++ 8.3.3 - Pointers to members.
Describes a module or submodule.
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
bool isExplicitGlobalModule() const
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 isPlaceholderVar(const LangOptions &LangOpts) const
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined.
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Represents a C++ namespace alias.
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Represent a C++ namespace.
bool isInline() const
Returns true if this is an inline namespace declaration.
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl, bool Nested)
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace that inhabits this namespace, if any.
void setRBraceLoc(SourceLocation L)
Class that aids in the construction of nested-name-specifiers along with source-location information ...
A C++ nested-name-specifier augmented with source location information.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
@ Global
The global specifier '::'. There is no stored value.
bool containsUnexpandedParameterPack() const
Whether this nested-name-specifier contains an unexpanded parameter pack (for C++11 variadic template...
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
The basic abstraction for the target Objective-C runtime.
bool isFragile() const
The inverse of isNonFragile(): does this runtime follow the set of implied behaviors for a "fragile" ...
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
@ CSK_Normal
Normal lookup.
@ CSK_Operator
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax.
SmallVectorImpl< OverloadCandidate >::iterator iterator
MapType::iterator iterator
MapType::const_iterator const_iterator
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc)
Create a paren list.
Represents a parameter to a function.
void setDefaultArg(Expr *defarg)
SourceLocation getExplicitObjectParamThisLoc() const
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
SourceRange getDefaultArgRange() const
Retrieve the source range that covers the entire default argument.
void setUninstantiatedDefaultArg(Expr *arg)
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
bool hasUninstantiatedDefaultArg() const
bool hasInheritedDefaultArg() const
bool isExplicitObjectParameter() const
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Expr * getUninstantiatedDefaultArg()
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
void setHasInheritedDefaultArg(bool I=true)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
ParsedAttr - Represents a syntactic attribute.
IdentifierInfo * getPropertyDataSetter() const
IdentifierInfo * getPropertyDataGetter() const
static const ParsedAttributesView & none()
bool hasAttribute(ParsedAttr::Kind K) const
Wrapper for source info for pointers.
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
IdentifierTable & getIdentifierTable()
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
ArrayRef< Expr * > semantics()
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
QualType withConst() const
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
void addConst()
Add the const type qualifier to this QualType.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
bool isConstQualified() const
Determine whether this type is const-qualified.
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this 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).
bool isAtLeastAsQualifiedAs(QualType Other, const ASTContext &Ctx) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
Represents a template name as written in source code.
The collection of all-type qualifiers we support.
void addAddressSpace(LangAS space)
@ OCL_Weak
Reading or writing from this object requires a barrier call.
void removeAddressSpace()
LangAS getAddressSpace() const
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
bool hasFlexibleArrayMember() const
field_iterator field_end() const
field_range fields() const
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
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
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.
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Scope - A scope is a transient data structure that is used while parsing the program.
void setEntity(DeclContext *E)
const Scope * getParent() const
getParent - Return the scope that this is nested in.
@ 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.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
bool inferTargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, CXXMethodDecl *MemberDecl, bool ConstRHS, bool Diagnose)
Given a implicit special member, infer its CUDA target from the calls it needs to make to underlying ...
void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
A RAII object to enter scope of a compound statement.
For a defaulted function, the kind of defaulted function that it is.
DefaultedComparisonKind asComparison() const
bool isSpecialMember() const
bool isComparison() const
CXXSpecialMemberKind asSpecialMember() const
Helper class that collects exception specifications for implicitly-declared special member functions.
void CalledStmt(Stmt *S)
Integrate an invoked statement into the collected data.
void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method)
Integrate another called method into the collected data.
SpecialMemberOverloadResult - The overloading result for a special member function.
CXXMethodDecl * getMethod() const
RAII object to handle the state changes required to synthesize a function body.
Abstract base class used for diagnosing integer constant expression violations.
Sema - This implements semantic analysis and AST building for C.
void DefineImplicitLambdaToFunctionPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a function pointer.
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
CXXConstructorDecl * DeclareImplicitDefaultConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit default constructor for the given class.
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.
MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, CXXRecordDecl *ClassDecl)
void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D)
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
bool EvaluateStaticAssertMessageAsString(Expr *Message, std::string &Result, ASTContext &Ctx, bool ErrorOnInvalidMessage)
bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range)
CheckSpecifiedExceptionType - Check if the given type is valid in an exception specification.
ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation, SourceLocation ConvLocation, CXXConversionDecl *Conv, Expr *Src)
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Decl * ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS, MultiTemplateParamsArg TemplateParams, SourceLocation UsingLoc, UnqualifiedId &Name, const ParsedAttributesView &AttrList, TypeResult Type, Decl *DeclFromDeclSpec)
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.
NamedDecl * ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope)
void DiagnoseAbstractType(const CXXRecordDecl *RD)
void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow)
Hides a using shadow declaration.
bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R=nullptr, const UsingDecl *UD=nullptr)
Checks that the given nested-name qualifier used in a using decl in the current context is appropriat...
bool CheckExplicitObjectOverride(CXXMethodDecl *New, const CXXMethodDecl *Old)
llvm::SmallPtrSet< SpecialMemberDecl, 4 > SpecialMembersBeingDeclared
The C++ special members which we are currently in the process of declaring.
void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc, SourceLocation ArgLoc)
ActOnParamUnparsedDefaultArgument - We've seen a default argument for a function parameter,...
DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD)
Determine the kind of defaulting that would be done for a given function.
ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, ActOnMemberAccessExtraArgs *ExtraArgs=nullptr)
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)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath)
void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old)
Merge the exception specifications of two variable declarations.
CXXSpecialMemberKind getSpecialMember(const CXXMethodDecl *MD)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupUsingDeclName
Look up all declarations in a scope with the given name, including resolved using declarations.
@ LookupLocalFriendName
Look up a friend of a local class.
@ LookupNamespaceName
Look up a namespace name within a C++ using directive or namespace alias definition,...
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
void DiagnoseSentinelCalls(const NamedDecl *D, SourceLocation Loc, ArrayRef< Expr * > Args)
DiagnoseSentinelCalls - This routine checks whether a call or message-send is to a declaration with t...
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function.
Decl * ActOnUsingEnumDeclaration(Scope *CurScope, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceRange TyLoc, const IdentifierInfo &II, ParsedType Ty, CXXScopeSpec *SS=nullptr)
Decl * BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *AssertMessageExpr, SourceLocation RParenLoc, bool Failed)
void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD)
Evaluate the implicit exception specification for a defaulted special member function.
ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E)
ActOnExplicitBoolSpecifier - Build an ExplicitSpecifier from an expression found in an explicit(bool)...
bool DiagRedefinedPlaceholderFieldDecl(SourceLocation Loc, RecordDecl *ClassDecl, const IdentifierInfo *Name)
void ActOnFinishCXXNonNestedClass()
MemInitResult BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo, Expr *Init, CXXRecordDecl *ClassDecl, SourceLocation EllipsisLoc)
void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class)
Force the declaration of any implicitly-declared members of this class.
void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc, Expr *DefaultArg)
ActOnParamDefaultArgumentError - Parsing or semantic analysis of the default argument for the paramet...
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 DiagnoseStaticAssertDetails(const Expr *E)
Try to print more useful information about a failed static_assert with expression \E.
void DefineImplicitMoveAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared move assignment operator.
void ActOnFinishDelayedMemberInitializers(Decl *Record)
NamedDecl * ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef< BindingDecl * > Bindings={})
void CheckDelegatingCtorCycles()
SmallVector< CXXMethodDecl *, 4 > DelayedDllExportMemberFunctions
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,...
AccessResult CheckFriendAccess(NamedDecl *D)
Checks access to the target of a friend declaration.
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.
DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D)
ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a C++ if/switch/while/for statem...
void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet, OverloadedOperatorKind Op, const UnresolvedSetImpl &Fns, ArrayRef< Expr * > Args, bool RequiresADL=true)
Perform lookup for an overloaded binary operator.
DelegatingCtorDeclsType DelegatingCtorDecls
All the delegating constructors seen so far in the file, used for cycle detection at the end of the T...
bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc, SourceLocation ColonLoc, const ParsedAttributesView &Attrs)
ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
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...
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD)
Check a completed declaration of an implicit special member.
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
bool CompleteConstructorCall(CXXConstructorDecl *Constructor, QualType DeclInitType, MultiExprArg ArgsPtr, SourceLocation Loc, SmallVectorImpl< Expr * > &ConvertedArgs, bool AllowExplicit=false, bool IsListInitialization=false)
Given a constructor and the set of arguments provided for the constructor, convert the arguments and ...
@ Boolean
A boolean condition, from 'if', 'while', 'for', or 'do'.
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.
Decl * ActOnNamespaceAliasDef(Scope *CurScope, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident)
void CheckOverrideControl(NamedDecl *D)
CheckOverrideControl - Check C++11 override control semantics.
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.
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.
DeclResult ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc, unsigned TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, SourceLocation EllipsisLoc, const ParsedAttributesView &Attr, MultiTemplateParamsArg TempParamLists)
Handle a friend tag declaration where the scope specifier was templated.
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
CXXConstructorDecl * DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit move constructor for the given class.
bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl, const ParsedAttributesView &AttrList)
Annotation attributes are the only attributes allowed after an access specifier.
FunctionDecl * InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD, const TemplateArgumentList *Args, SourceLocation Loc, CodeSynthesisContext::SynthesisKind CSC=CodeSynthesisContext::ExplicitTemplateArgumentSubstitution)
Instantiate (or find existing instantiation of) a function template with a given set of template argu...
void SetFunctionBodyKind(Decl *D, SourceLocation Loc, FnBodyKind BodyKind, StringLiteral *DeletedMessage=nullptr)
void referenceDLLExportedClassMethods()
void CheckCompleteDestructorVariant(SourceLocation CurrentLocation, CXXDestructorDecl *Dtor)
Do semantic checks to allow the complete destructor variant to be emitted when the destructor is defi...
NamedDecl * ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, Expr *BitfieldWidth, const VirtSpecifiers &VS, InClassInitStyle InitStyle)
ActOnCXXMemberDeclarator - This is invoked when a C++ class member declarator is parsed.
bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member function overrides a virtual...
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 ...
bool CheckOverridingFunctionAttributes(CXXMethodDecl *New, const CXXMethodDecl *Old)
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,...
bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec)
tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.
Decl * ActOnConversionDeclarator(CXXConversionDecl *Conversion)
ActOnConversionDeclarator - Called by ActOnDeclarator to complete the declaration of the given C++ co...
@ Other
C++26 [dcl.fct.def.general]p1 function-body: ctor-initializer[opt] compound-statement function-try-bl...
@ Delete
deleted-function-body
QualType BuildStdInitializerList(QualType Element, SourceLocation Loc)
Looks for the std::initializer_list template and instantiates it with Element, or emits an error if i...
MemInitResult BuildMemberInitializer(ValueDecl *Member, Expr *Init, SourceLocation IdLoc)
StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue=true)
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.
FPOptionsOverride CurFPFeatureOverrides()
void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD)
Diagnose methods which overload virtual methods in a base class without overriding any.
UsingShadowDecl * BuildUsingShadowDecl(Scope *S, BaseUsingDecl *BUD, NamedDecl *Target, UsingShadowDecl *PrevDecl)
Builds a shadow declaration corresponding to a 'using' declaration.
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallToMemberFunction - Build a call to a member function.
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Look up a name, looking for a single declaration.
bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, DeclAccessPair Found, QualType ObjectType, SourceLocation Loc, const PartialDiagnostic &Diag)
Is the given member accessible for the purposes of deciding whether to define a special member functi...
BaseResult ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange, const ParsedAttributesView &Attrs, bool Virtual, AccessSpecifier Access, ParsedType basetype, SourceLocation BaseLoc, SourceLocation EllipsisLoc)
ActOnBaseSpecifier - Parsed a base specifier.
void ActOnFinishFunctionDeclarationDeclarator(Declarator &D)
Called after parsing a function declarator belonging to a function declaration.
void ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc, Expr *defarg)
ActOnParamDefaultArgument - Check whether the default argument provided for a function parameter is w...
void CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC)
CheckConversionDeclarator - Called by ActOnDeclarator to check the well-formednes of the conversion f...
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnFinishDelayedCXXMethodDeclaration - We have finished processing the delayed method declaration f...
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
DiagnosticsEngine & getDiagnostics() const
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
void propagateDLLAttrToBaseClassTemplate(CXXRecordDecl *Class, Attr *ClassAttr, ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc)
Perform propagation of DLL attributes from a derived class to a templated base class for MS compatibi...
NamedDecl * ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams)
void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TypedefNameDecl *NewTD)
void CheckDelayedMemberExceptionSpecs()
void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param)
This is used to implement the constant expression evaluation part of the attribute enable_if extensio...
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
ASTContext & getASTContext() const
ClassTemplateDecl * StdInitializerList
The C++ "std::initializer_list" template, which is defined in <initializer_list>.
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
void CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *MD)
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...
void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var)
Mark a variable referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
void checkExceptionSpecification(bool IsTopLevel, ExceptionSpecificationType EST, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr, SmallVectorImpl< QualType > &Exceptions, FunctionProtoType::ExceptionSpecInfo &ESI)
Check the given exception-specification and update the exception specification information with the r...
SmallVector< std::pair< FunctionDecl *, FunctionDecl * >, 2 > DelayedEquivalentExceptionSpecChecks
All the function redeclarations seen during a class definition that had their exception spec checks d...
bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method)
Check whether 'this' shows up in the type of a static member function after the (naturally empty) cv-...
void PopExpressionEvaluationContext()
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace.
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool RequiresADL=true, bool AllowRewrittenCandidates=true, FunctionDecl *DefaultedFn=nullptr)
Create a binary operation that may resolve to an overloaded operator.
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 isInitListConstructor(const FunctionDecl *Ctor)
Determine whether Ctor is an initializer-list constructor, as defined in [dcl.init....
void ActOnStartFunctionDeclarationDeclarator(Declarator &D, unsigned TemplateParameterDepth)
Called before parsing a function declarator belonging to a function declaration.
std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths)
Builds a string representing ambiguous paths from a specific derived class to different subobjects of...
DefaultedComparisonKind
Kinds of defaulted comparison operator functions.
@ Relational
This is an <, <=, >, or >= that should be implemented as a rewrite in terms of a <=> comparison.
@ NotEqual
This is an operator!= that should be implemented as a rewrite in terms of a == comparison.
@ ThreeWay
This is an operator<=> that should be implemented as a series of subobject comparisons.
@ None
This is not a defaultable comparison operator.
@ Equal
This is an operator== that should be implemented as a series of subobject comparisons.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
llvm::PointerIntPair< CXXRecordDecl *, 3, CXXSpecialMemberKind > SpecialMemberDecl
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
ValueDecl * tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl, CXXScopeSpec &SS, ParsedType TemplateTypeTy, IdentifierInfo *MemberOrBase)
NamedDecl * BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation, bool IsUsingIfExists)
Builds a using declaration.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
void DefineImplicitMoveConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitMoveConstructor - Checks for feasibility of defining this constructor as the move const...
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
EnumDecl * getStdAlignValT() const
void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record)
LangAS getDefaultCXXMethodAddrSpace() const
Returns default addr space for method qualifiers.
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
void PushFunctionScope()
Enter a new function scope.
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
void DefineImplicitCopyConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitCopyConstructor - Checks for feasibility of defining this constructor as the copy const...
FPOptions & getCurFPFeatures()
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK, bool MissingOK=false)
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
@ UPPC_UsingDeclaration
A using declaration.
@ UPPC_ExceptionType
The type of an exception.
@ UPPC_Initializer
An initializer.
@ UPPC_BaseType
The base type of a class type.
@ UPPC_FriendDeclaration
A friend declaration.
@ UPPC_DefaultArgument
A default argument.
@ UPPC_DeclarationType
The type of an arbitrary declaration.
@ UPPC_DataMemberType
The type of a data member.
@ UPPC_StaticAssertExpression
The expression in a static assertion.
Decl * ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc, SourceLocation NamespaceLoc, SourceLocation IdentLoc, IdentifierInfo *Ident, SourceLocation LBrace, const ParsedAttributesView &AttrList, UsingDirectiveDecl *&UsingDecl, bool IsNested)
ActOnStartNamespaceDef - This is called at the start of a namespace definition.
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...
QualType CheckComparisonCategoryType(ComparisonCategoryType Kind, SourceLocation Loc, ComparisonCategoryUsage Usage)
Lookup the specified comparison category types in the standard library, an check the VarDecls possibl...
void DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent)
DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was not used in the declaration of ...
SmallVector< VTableUse, 16 > VTableUses
The list of vtables that are required but have not yet been materialized.
AccessResult CheckStructuredBindingMemberAccess(SourceLocation UseLoc, CXXRecordDecl *DecomposedClass, DeclAccessPair Field)
Checks implicit access to a member in a structured binding.
void EnterTemplatedContext(Scope *S, DeclContext *DC)
Enter a template parameter scope, after it's been associated with a particular DeclContext.
void ActOnBaseSpecifiers(Decl *ClassDecl, MutableArrayRef< CXXBaseSpecifier * > Bases)
ActOnBaseSpecifiers - Attach the given base specifiers to the class, after checking whether there are...
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD, DefaultedComparisonKind DCK)
bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A, const NamedDecl *B)
Determine if A and B are equivalent internal linkage declarations from different modules,...
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)
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, const CXXBasePath &Path, unsigned DiagID, bool ForceCheck=false, bool ForceUnprivileged=false)
Checks access for a hierarchy conversion.
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument.
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)
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 AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet)
AddBuiltinOperatorCandidates - Add the appropriate built-in operator overloads to the candidate set (...
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD)
void checkClassLevelDLLAttribute(CXXRecordDecl *Class)
Check class-level dllimport/dllexport attribute.
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
const LangOptions & LangOpts
std::pair< Expr *, std::string > findFailedBooleanCondition(Expr *Cond)
Find the failed Boolean condition within a given Boolean constant expression, and describe it with a ...
void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock)
void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD, bool ConstexprOnly=false)
MarkVirtualMembersReferenced - Will mark all members of the given CXXRecordDecl referenced.
ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl)
Wrap the expression in a ConstantExpr if it is a potential immediate invocation.
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
void DefineInheritingConstructor(SourceLocation UseLoc, CXXConstructorDecl *Constructor)
Define the specified inheriting constructor.
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn)
Perform semantic checking of a new function declaration.
CXXRecordDecl * getStdBadAlloc() const
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange)
Mark the given method pure.
void SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
void NoteHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl * > &OverloadedMethods)
CXXMethodDecl * DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit move assignment operator for the given class.
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
llvm::DenseMap< CXXRecordDecl *, bool > VTablesUsed
The set of classes whose vtables have been used within this translation unit, and a bit that will be ...
void CheckCXXDefaultArguments(FunctionDecl *FD)
Helpers for dealing with blocks and functions.
@ DefaultedOperator
A defaulted 'operator<=>' needed the comparison category.
SmallVector< InventedTemplateParameterInfo, 4 > InventedParameterInfos
Stack containing information needed when in C++2a an 'auto' is encountered in a function declaration ...
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.
NamedDecl * BuildUsingEnumDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceLocation NameLoc, TypeSourceInfo *EnumType, EnumDecl *ED)
TypeLoc getReturnTypeLoc(FunctionDecl *FD) const
SmallVector< std::pair< const CXXMethodDecl *, const CXXMethodDecl * >, 2 > DelayedOverridingExceptionSpecChecks
All the overriding functions seen during a class definition that had their exception spec checks dela...
llvm::DenseMap< ParmVarDecl *, SourceLocation > UnparsedDefaultArgLocs
void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc, const CXXRecordDecl *RD)
Mark the exception specifications of all virtual member functions in the given class as needed.
ExprResult BuildConvertedConstantExpression(Expr *From, QualType T, CCEKind CCE, NamedDecl *Dest=nullptr)
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...
bool RequireCompleteEnumDecl(EnumDecl *D, SourceLocation L, CXXScopeSpec *SS=nullptr)
Require that the EnumDecl is completed with its enumerators defined or instantiated.
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...
void ExitDeclaratorContext(Scope *S)
void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir)
void CheckConstructor(CXXConstructorDecl *Constructor)
CheckConstructor - Checks a fully-formed constructor for well-formedness, issuing any diagnostics req...
void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a block pointer.
void DefineImplicitDestructor(SourceLocation CurrentLocation, CXXDestructorDecl *Destructor)
DefineImplicitDestructor - Checks for feasibility of defining this destructor as the default destruct...
void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMemberKind CSM)
Diagnose why the specified class does not have a trivial special member of the given kind.
void popCodeSynthesisContext()
CXXRecordDecl * getCurrentClass(Scope *S, const CXXScopeSpec *SS)
Get the class that is directly named by the current context.
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr)
bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method)
Check whether 'this' shows up in the attributes of the given static member function.
CXXBaseSpecifier * CheckBaseSpecifier(CXXRecordDecl *Class, SourceRange SpecifierRange, bool Virtual, AccessSpecifier Access, TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)
Check the validity of a C++ base class specifier.
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)
UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations
A mapping from parameters with unparsed default arguments to the set of instantiations of each parame...
void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitDefaultConstructor - Checks for feasibility of defining this constructor as the default...
std::pair< CXXRecordDecl *, SourceLocation > VTableUse
The list of classes whose vtables have been used within this translation unit, and the source locatio...
ExprResult DefaultLvalueConversion(Expr *E)
bool CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Target, const LookupResult &PreviousDecls, UsingShadowDecl *&PrevShadow)
Determines whether to create a using shadow decl for a particular decl, given the set of decls existi...
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.
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=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.
void DiagPlaceholderVariableDefinition(SourceLocation Loc)
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
bool DiagnoseUseOfOverloadedDecl(NamedDecl *D, SourceLocation Loc)
std::unique_ptr< RecordDeclSetTy > PureVirtualClassDiagSet
PureVirtualClassDiagSet - a set of class declarations which we have emitted a list of pure virtual fu...
void ActOnFinishInlineFunctionDef(FunctionDecl *D)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, bool Diagnose=true, bool WantSize=false, bool WantAligned=false)
VarDecl * BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id)
Perform semantic analysis for the variable declaration that occurs within a C++ catch clause,...
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.
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams, SourceLocation EllipsisLoc)
Handle a friend type declaration.
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
void DefineImplicitCopyAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared copy assignment operator.
bool SetDelegatingInitializer(CXXConstructorDecl *Constructor, CXXCtorInitializer *Initializer)
@ TAH_IgnoreTrivialABI
The triviality of a method unaffected by "trivial_abi".
@ TAH_ConsiderTrivialABI
The triviality of a method affected by "trivial_abi".
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl)
CheckLiteralOperatorDeclaration - Check whether the declaration of this literal operator function is ...
bool DefineUsedVTables()
Define all of the vtables that have been used in this translation unit and reference any virtual memb...
CXXMethodDecl * DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit copy assignment operator for the given class.
void MarkVirtualBaseDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl, llvm::SmallPtrSetImpl< const RecordType * > *DirectVirtualBases=nullptr)
Mark destructors of virtual bases of this class referenced.
void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD)
Check that the C++ class annoated with "trivial_abi" satisfies all the conditions that are needed for...
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)
unsigned ActOnReenterTemplateScope(Decl *Template, llvm::function_ref< Scope *()> EnterScope)
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl, CXXConstructorDecl *Constructor, MultiExprArg Exprs, bool HadMultipleCandidates, bool IsListInitialization, bool IsStdInitListInitialization, bool RequiresZeroInit, CXXConstructionKind ConstructKind, SourceRange ParenRange)
BuildCXXConstructExpr - Creates a complete call to a constructor, including handling of its default a...
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
FunctionDecl * SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD, FunctionDecl *Spaceship)
Substitute the name and return type of a defaulted 'operator<=>' to form an implicit 'operator=='.
NamedDecl * ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists)
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
void diagnoseFunctionEffectMergeConflicts(const FunctionEffectSet::Conflicts &Errs, SourceLocation NewLoc, SourceLocation OldLoc)
void EnterDeclaratorContext(Scope *S, DeclContext *DC)
EnterDeclaratorContext - Used when we must lookup names in the context of a declarator's nested name ...
bool CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *MD, DefaultedComparisonKind DCK)
bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method)
Whether this' shows up in the exception specification of a static member function.
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, ExprResult Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member,...
llvm::FoldingSet< SpecialMemberOverloadResultEntry > SpecialMemberCache
A cache of special member function overload resolution results for C++ records.
QualType BuildPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc, bool FullySubstituted=false, ArrayRef< QualType > Expansions={})
Decl * ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc, Expr *LangStr, SourceLocation LBraceLoc)
ActOnStartLinkageSpecification - Parsed the beginning of a C++ linkage specification,...
void FilterUsingLookup(Scope *S, LookupResult &lookup)
Remove decls we can't actually see from a lookup being used to declare shadow using decls.
Decl * ActOnExceptionDeclarator(Scope *S, Declarator &D)
ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch handler.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, SourceLocation Loc)
PushNamespaceVisibilityAttr - Note that we've entered a namespace with a visibility attribute.
void ActOnDefaultCtorInitializers(Decl *CDtorDecl)
void ActOnMemInitializers(Decl *ConstructorDecl, SourceLocation ColonLoc, ArrayRef< CXXCtorInitializer * > MemInits, bool AnyErrors)
ActOnMemInitializers - Handle the member initializers for a constructor.
bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams)
Check whether a template can be declared within this scope.
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an initializer for the declaration ...
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.
void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc, Decl *TagDecl, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
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.
Decl * ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *AssertMessageExpr, SourceLocation RParenLoc)
StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, bool AllowRecovery=false)
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
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)
ExprResult ActOnRequiresClause(ExprResult ConstraintExpr)
void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class)
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL,...
RedeclarationKind forRedeclarationInCurContext() const
LazyDeclPtr StdNamespace
The C++ "std" namespace, where the standard library resides.
bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Previous)
Checks that the given using declaration is not an invalid redeclaration.
@ CCEK_StaticAssertMessageSize
Call to size() in a static assert message.
@ CCEK_ExplicitBool
Condition in an explicit(bool) specifier.
@ CCEK_StaticAssertMessageData
Call to data() in a static assert message.
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
void ActOnFinishCXXMemberDecls()
Perform any semantic analysis which needs to be delayed until all pending class member declarations h...
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.
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Decl * ActOnFinishLinkageSpecification(Scope *S, Decl *LinkageSpec, SourceLocation RBraceLoc)
ActOnFinishLinkageSpecification - Complete the definition of the C++ linkage specification LinkageSpe...
bool CheckInheritingConstructorUsingDecl(UsingDecl *UD)
Additional checks for a using declaration referring to a constructor name.
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
QualType BuildDecltypeType(Expr *E, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
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 {'.
void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace)
ActOnFinishNamespaceDef - This callback is called after a namespace is exited.
MemInitResult BuildMemInitializer(Decl *ConstructorD, Scope *S, CXXScopeSpec &SS, IdentifierInfo *MemberOrBase, ParsedType TemplateTypeTy, const DeclSpec &DS, SourceLocation IdLoc, Expr *Init, SourceLocation EllipsisLoc)
Handle a C++ member initializer.
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
void actOnDelayedExceptionSpecification(Decl *D, ExceptionSpecificationType EST, SourceRange SpecificationRange, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr)
Add an exception-specification to the given member or friend function (or function template).
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
void CheckExplicitObjectLambda(Declarator &D)
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD)
void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc)
PopPragmaVisibility - Pop the top element of the visibility stack; used for '#pragma GCC visibility' ...
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init)
Check that the lifetime of the initializer (and its subobjects) is sufficient for initializing the en...
void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record)
Perform semantic checks on a class definition that has been completing, introducing implicitly-declar...
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)
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
SourceManager & SourceMgr
bool CheckDestructor(CXXDestructorDecl *Destructor)
CheckDestructor - Checks a fully-formed destructor definition for well-formedness,...
NamedDecl * BuildUsingPackDecl(NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl * > Expansions)
MemInitResult ActOnMemInitializer(Decl *ConstructorD, Scope *S, CXXScopeSpec &SS, IdentifierInfo *MemberOrBase, ParsedType TemplateTypeTy, const DeclSpec &DS, SourceLocation IdLoc, SourceLocation LParenLoc, ArrayRef< Expr * > Args, SourceLocation RParenLoc, SourceLocation EllipsisLoc)
Handle a C++ member initializer using parentheses syntax.
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc, StringLiteral *Message=nullptr)
void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnStartDelayedCXXMethodDeclaration - We have completed parsing a top-level (non-nested) C++ class,...
DiagnosticsEngine & Diags
FullExprArg MakeFullDiscardedValueExpr(Expr *Arg)
CXXConstructorDecl * DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit copy constructor for the given class.
NamespaceDecl * getStdNamespace() const
void DeclareImplicitEqualityComparison(CXXRecordDecl *RD, FunctionDecl *Spaceship)
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier * > Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an initializer for the declaratio...
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D, CXXSpecialMemberKind SM, bool ConstArg, bool VolatileArg, bool RValueThis, bool ConstThis, bool VolatileThis)
NamedDecl * ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *D, LookupResult &Previous, bool &Redeclaration)
ActOnTypedefNameDecl - Perform semantic checking for a declaration which declares a typedef-name,...
ExprResult ActOnIntegerConstant(SourceLocation Loc, int64_t Val)
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
Decl * ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList, SourceLocation SemiLoc)
Handle a C++11 empty-declaration and attribute-declaration.
void diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, SourceLocation FallbackLoc, SourceLocation ConstQualLoc=SourceLocation(), SourceLocation VolatileQualLoc=SourceLocation(), SourceLocation RestrictQualLoc=SourceLocation(), SourceLocation AtomicQualLoc=SourceLocation(), SourceLocation UnalignedQualLoc=SourceLocation())
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...
ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D.
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.
FunctionDecl * FindDeallocationFunctionForDestructor(SourceLocation StartLoc, CXXRecordDecl *RD)
ExprResult ConvertMemberDefaultInitExpression(FieldDecl *FD, Expr *InitExpr, SourceLocation InitLoc)
bool IsInvalidSMECallConversion(QualType FromType, QualType ToType)
void checkIncorrectVTablePointerAuthenticationAttribute(CXXRecordDecl &RD)
Check that VTable Pointer authentication is only being set on the first first instantiation of the vt...
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope.
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
bool isUsualDeallocationFunction(const CXXMethodDecl *FD)
void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD)
Produce notes explaining why a defaulted function was defined as deleted.
ExprResult BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, TypeSourceInfo *Ty, Expr *E, SourceRange AngleBrackets, SourceRange Parens)
bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionExceptionSpec - Checks whether the exception spec is a subset of base spec.
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
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...
bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionReturnType - Checks whether the return types are covariant,...
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr * > Args, SmallVectorImpl< Expr * > &AllArgs, VariadicCallType CallType=VariadicDoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
Decl * ActOnDeclarator(Scope *S, Declarator &D)
StmtResult ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)
MSPropertyDecl * HandleMSProperty(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS, const ParsedAttr &MSPropertyAttr)
HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
void ProcessAPINotes(Decl *D)
Map any API notes provided for this declaration to attributes on the declaration.
bool CheckRedeclarationInModule(NamedDecl *New, NamedDecl *Old)
A wrapper function for checking the semantic restrictions of a redeclaration within a module.
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc.
void DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, bool First=true)
Emit diagnostics explaining why a constraint expression was deemed unsatisfied.
void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc)
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
@ CheckValid
Identify whether this function satisfies the formal rules for constexpr functions in the current lanu...
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
void LoadExternalVTableUses()
Load any externally-stored vtable uses.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Decl * ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc, SourceLocation NamespcLoc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *NamespcName, const ParsedAttributesView &AttrList)
StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, ArrayRef< Stmt * > Elts, bool isStmtExpr)
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types.
void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D)
void FindHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl * > &OverloadedMethods)
Check if a method overloads virtual methods in a base class without overriding any.
IdentifierResolver IdResolver
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record)
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, TrivialABIHandling TAH=TAH_IgnoreTrivialABI, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
ExprResult ActOnCXXThis(SourceLocation Loc)
bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc, UnexpandedParameterPackContext UPPC, ArrayRef< UnexpandedParameterPack > Unexpanded)
Diagnose unexpanded parameter packs.
CXXConstructorDecl * findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor, ConstructorUsingShadowDecl *DerivedShadow)
Given a derived-class using shadow declaration for a constructor and the correspnding base class cons...
void warnOnReservedIdentifier(const NamedDecl *D)
bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, SourceLocation DefaultLoc)
bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS)
Determine whether the identifier II is a typo for the name of the class type currently being defined.
Decl * ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList)
void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param)
ActOnDelayedCXXMethodParameter - We've already started a delayed C++ method declaration.
bool isAbstractType(SourceLocation Loc, QualType T)
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr, bool SkipImmediateInvocations=true)
Instantiate or parse a C++ default argument expression as necessary.
ValueDecl * tryLookupUnambiguousFieldDecl(RecordDecl *ClassDecl, const IdentifierInfo *MemberOrBase)
ASTMutationListener * getASTMutationListener() const
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...
bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, ArrayRef< CXXCtorInitializer * > Initializers={})
void DiagnoseImmediateEscalatingReason(FunctionDecl *FD)
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
CXXDestructorDecl * DeclareImplicitDestructor(CXXRecordDecl *ClassDecl)
Declare the implicit destructor for the given class.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
A trivial tuple used to represent a source range.
void setBegin(SourceLocation b)
SourceLocation getEnd() const
SourceLocation getBegin() const
void setEnd(SourceLocation e)
static StaticAssertDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *Message, SourceLocation RParenLoc, bool Failed)
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
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
static bool isValidUDSuffix(const LangOptions &LangOpts, StringRef Suffix)
Determine whether a suffix is a valid ud-suffix.
StringLiteral - This represents a string literal expression, e.g.
bool isUnevaluated() const
StringRef getString() const
Represents the declaration of a struct/union/class/enum.
bool isBeingDefined() const
Return true if this decl is currently being defined.
StringRef getKindName() const
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
TagKind getTagKind() const
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
bool areArgsDestroyedLeftToRightInCallee() const
Are arguments to a call destroyed left to right in the callee? This is a fundamental language change,...
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
bool hasKeyFunctions() const
Does this ABI use key functions? If so, class data such as the vtable is emitted with strong linkage ...
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
virtual CallingConvKind getCallingConvKind(bool ClangABICompat4) const
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
A convenient class for passing around template argument information.
void addArgument(const TemplateArgumentLoc &Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Location wrapper for a TemplateArgument.
const TemplateArgument & getArgument() const
TypeSourceInfo * getTypeSourceInfo() const
Represents a template argument.
@ Type
The template argument is a type.
ArgKind getKind() const
Return the kind of stored template argument.
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(bool IgnoreDeduced=false) const
Retrieve the underlying template declaration that this template name refers to, if known.
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
SourceRange getSourceRange() const LLVM_READONLY
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
static bool shouldIncludeTypeForArgument(const PrintingPolicy &Policy, const TemplateParameterList *TPL, unsigned Idx)
SourceLocation getTemplateLoc() const
unsigned getNumArgs() const
TemplateArgumentLoc getArgLoc(unsigned i) const
Represents a type template specialization; the template must be a class template, a type alias templa...
ArrayRef< TemplateArgument > template_arguments() const
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Declaration of a template type parameter.
unsigned getIndex() const
Retrieve the index of the template parameter.
unsigned getDepth() const
Retrieve the depth of the template parameter.
unsigned getIndex() const
unsigned getDepth() const
The top declaration context.
Represents the declaration of a typedef-name via a C++11 alias-declaration.
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Declaration of an alias template.
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Represents a declaration of a type.
const Type * getTypeForDecl() const
Base wrapper for a particular "section" of type source info.
QualType getType() const
Get the type for which this source info wrapper provides information.
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
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.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceRange getLocalSourceRange() const
Get the local source range.
TypeLocClass getTypeLocClass() const
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.
A reasonable base class for TypeLocs that correspond to types that are written as a type-specifier.
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
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.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBooleanType() const
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
bool isIncompleteArrayType() const
bool isUndeducedAutoType() const
bool isRValueReferenceType() const
bool isPointerType() const
CanQualType getCanonicalTypeUnqualified() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isElaboratedTypeSpecifier() const
Determine wither this type is a C++ elaborated-type-specifier.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isLValueReferenceType() const
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
QualType getCanonicalTypeInternal() const
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 isFunctionProtoType() const
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isStructureOrClassType() const
bool isRealFloatingType() const
Floating point categories.
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Base class for declarations which introduce a typedef-name.
QualType getUnderlyingType() const
Simple class containing the result of Sema::CorrectTypo.
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
SourceRange getCorrectionRange() const
void WillReplaceSpecifier(bool ForceReplacement)
DeclClass * getCorrectionDeclAs() const
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
static UnaryOperator * Create(const ASTContext &C, Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow, FPOptionsOverride FPFeatures)
Represents a C++ unqualified-id that has been parsed.
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent)
A set of unresolved declarations.
ArrayRef< DeclAccessPair > pairs() const
The iterator over UnresolvedSets.
A set of unresolved declarations.
This node is generated when a using-declaration that was annotated with attribute((using_if_exists)) ...
static UnresolvedUsingIfExistsDecl * Create(ASTContext &Ctx, DeclContext *DC, SourceLocation Loc, DeclarationName Name)
Represents a dependent using declaration which was marked with typename.
static UnresolvedUsingTypenameDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation TypenameLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TargetNameLoc, DeclarationName TargetName, SourceLocation EllipsisLoc)
Represents a dependent using declaration which was not marked with typename.
static UnresolvedUsingValueDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, SourceLocation EllipsisLoc)
Represents a C++ using-declaration.
bool hasTypename() const
Return true if the using declaration has 'typename'.
DeclarationNameInfo getNameInfo() const
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name.
SourceLocation getUsingLoc() const
Return the source location of the 'using' keyword.
Represents C++ using-directive.
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Represents a C++ using-enum-declaration.
static UsingEnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, SourceLocation EnumL, SourceLocation NameL, TypeSourceInfo *EnumType)
static UsingPackDecl * Create(ASTContext &C, DeclContext *DC, NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl * > UsingDecls)
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
static UsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, DeclarationName Name, BaseUsingDecl *Introducer, NamedDecl *Target)
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)
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)
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isNoDestroy(const ASTContext &) const
Is destruction of this variable entirely suppressed? If so, the variable need not have a usable destr...
bool isInlineSpecified() const
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
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.
bool hasConstantInitialization() const
Determine whether this variable has constant initialization.
bool evaluateDestruction(SmallVectorImpl< PartialDiagnosticAt > &Notes) const
Evaluate the destruction of this variable to determine if it constitutes constant destruction.
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
ThreadStorageClassSpecifier getTSCSpec() const
const Expr * getInit() const
@ TLS_Dynamic
TLS with a dynamic initializer.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
void setExceptionVariable(bool EV)
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
Declaration of a variable template.
Represents a GCC generic vector type.
unsigned getNumElements() const
QualType getElementType() const
Represents a C++11 virt-specifier-seq.
SourceLocation getOverrideLoc() const
SourceLocation getLastLocation() const
bool isOverrideSpecified() const
SourceLocation getFinalLoc() const
bool isFinalSpecified() const
bool isFinalSpelledSealed() const
Retains information about a function, method, or block that is currently being parsed.
bool FoundImmediateEscalatingExpression
Whether we found an immediate-escalating expression.
Defines the clang::TargetInfo interface.
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
bool Inc(InterpState &S, CodePtr OpPC)
1) Pops a pointer from the stack 2) Load the value from the pointer 3) Writes the value increased by ...
bool Zero(InterpState &S, CodePtr OpPC)
bool Comp(InterpState &S, CodePtr OpPC)
1) Pops the value from the stack.
The JSON file list parser is used to communicate input to InstallAPI.
bool FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI)
TypeSpecifierType
Specifies the kind of type.
@ TST_typename_pack_indexing
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
@ NUM_OVERLOADED_OPERATORS
bool isa(CodeGen::Address addr)
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
@ 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.
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
LinkageSpecLanguageIDs
Represents the language in a linkage specification.
InClassInitStyle
In-class initialization styles for non-static data members.
@ ICIS_ListInit
Direct list-initialization.
@ ICIS_NoInit
No in-class initializer.
@ RQ_None
No ref-qualifier was provided.
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
@ OK_Ordinary
An ordinary object is located at an address in memory.
@ If
'if' clause, allowed on all the Compute Constructs, Data Constructs, Executable Constructs,...
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
@ 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.
std::optional< ComparisonCategoryType > getComparisonCategoryForBuiltinCmp(QualType T)
Get the comparison category that should be used when comparing values of type T.
StorageClass
Storage classes.
ThreadStorageClassSpecifier
Thread storage-class-specifier.
ComparisonCategoryType commonComparisonType(ComparisonCategoryType A, ComparisonCategoryType B)
Determine the common comparison type, as defined in C++2a [class.spaceship]p4.
ComparisonCategoryResult
An enumeration representing the possible results of a three-way comparison.
Language
The language for the input, used to select and validate the language standard and possible actions.
@ Result
The result type of a method or function.
std::pair< unsigned, unsigned > getDepthAndIndex(const NamedDecl *ND)
Retrieve the depth and index of a template parameter.
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
void EscapeStringForDiagnostic(StringRef Str, SmallVectorImpl< char > &OutStr)
EscapeStringForDiagnostic - Append Str to the diagnostic buffer, escaping non-printable characters an...
ReservedLiteralSuffixIdStatus
ActionResult< Expr * > ExprResult
TagTypeKind
The kind of a tag type.
@ Interface
The "__interface" keyword.
@ Struct
The "struct" keyword.
@ Class
The "class" keyword.
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ CanPassInRegs
The argument of this type can be passed directly in registers.
@ CanNeverPassInRegs
The argument of this type cannot be passed directly in registers.
@ CannotPassInRegs
The argument of this type cannot be passed directly in registers.
@ TU_Prefix
The translation unit is a prefix to a translation unit, and is not complete.
ComparisonCategoryType
An enumeration representing the different comparison categories types.
ActionResult< Stmt * > StmtResult
CXXSpecialMemberKind
Kinds of C++ special members.
OverloadedOperatorKind getRewrittenOverloadedOperator(OverloadedOperatorKind Kind)
Get the other overloaded operator that the given operator can be rewritten into, if any such operator...
@ TNK_Concept_template
The name refers to a concept.
ActionResult< ParsedType > TypeResult
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
const FunctionProtoType * T
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
std::pair< llvm::PointerUnion< const TemplateTypeParmType *, NamedDecl * >, SourceLocation > UnexpandedParameterPack
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
@ Incomplete
Template argument deduction did not deduce a value for every template parameter.
@ Inconsistent
Template argument deduction produced inconsistent deduced values for the given template parameter.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ 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.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ 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.
bool isExternallyVisible(Linkage L)
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
@ EST_DependentNoexcept
noexcept(expression), value-dependent
@ EST_Uninstantiated
not instantiated yet
@ EST_Unparsed
not parsed yet
@ EST_NoThrow
Microsoft __declspec(nothrow) extension.
@ EST_None
no exception specification
@ EST_MSAny
Microsoft throw(...) extension.
@ EST_BasicNoexcept
noexcept
@ EST_NoexceptFalse
noexcept(expression), evals to 'false'
@ EST_Unevaluated
not evaluated yet, for special member function
@ EST_NoexceptTrue
noexcept(expression), evals to 'true'
@ EST_Dynamic
throw(T1, T2)
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
MutableArrayRef< Expr * > MultiExprArg
@ NOUR_Unevaluated
This name appears in an unevaluated operand.
bool hasValidIntValue() const
True iff we've successfully evaluated the variable as a constant expression and extracted its integer...
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 setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
SourceRange getSourceRange() const LLVM_READONLY
getSourceRange - The range of the declaration name.
SourceLocation getEndLoc() const LLVM_READONLY
bool containsUnexpandedParameterPack() const
Determine whether this name contains an unexpanded parameter pack.
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with ',...)',...
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
DeclSpec * MethodQualifiers
DeclSpec for the function with the qualifier related info.
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
bool hasMutableQualifier() const
Determine whether this lambda-declarator contains a 'mutable' qualifier.
bool hasMethodTypeQualifiers() const
Determine whether this method has qualifiers.
void freeParams()
Reset the parameter list to having zero parameters.
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
std::unique_ptr< CachedTokens > DefaultArgTokens
DefaultArgTokens - When the parameter's default argument cannot be parsed immediately (because it occ...
One instance of this struct is used for each type in a declarator that is parsed.
SourceRange getSourceRange() const
enum clang::DeclaratorChunk::@225 Kind
EvalResult is a struct with detailed info about an evaluated expression.
Holds information about the various types of exception specification.
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
ExceptionSpecificationType Type
The kind of exception specification this is.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
FunctionEffectsRef FunctionEffects
RefQualifierKind RefQualifier
FunctionType::ExtInfo ExtInfo
T * get(ExternalASTSource *Source) const
Retrieve the pointer to the AST node that this lazy pointer points to.
Information about operator rewrites to consider when adding operator functions to a candidate set.
Describes how types, statements, expressions, and declarations should be printed.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
@ MarkingClassDllexported
We are marking a class as __dllexport.
@ InitializingStructuredBinding
We are initializing a structured binding.
@ ExceptionSpecEvaluation
We are computing the exception specification for a defaulted special member function.
@ DeclaringSpecialMember
We are declaring an implicit special member function.
@ DeclaringImplicitEqualityComparison
We are declaring an implicit 'operator==' for a defaulted 'operator<=>'.
Decl * Entity
The entity that is being synthesized.
CXXSpecialMemberKind SpecialMember
The special member being declared or defined.
Abstract class used to diagnose incomplete types.
virtual void diagnose(Sema &S, SourceLocation Loc, QualType T)=0
Information about a template-id annotation token.
TemplateNameKind Kind
The kind of template that Template refers to.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.