50#include "llvm/ADT/ArrayRef.h"
51#include "llvm/ADT/STLExtras.h"
52#include "llvm/ADT/STLForwardCompat.h"
53#include "llvm/ADT/ScopeExit.h"
54#include "llvm/ADT/SmallString.h"
55#include "llvm/ADT/StringExtras.h"
56#include "llvm/Support/ConvertUTF.h"
57#include "llvm/Support/SaveAndRestore.h"
74class CheckDefaultArgumentVisitor
77 const Expr *DefaultArg;
80 CheckDefaultArgumentVisitor(
Sema &S,
const Expr *DefaultArg)
81 : S(S), DefaultArg(DefaultArg) {}
86 bool VisitLambdaExpr(
const LambdaExpr *Lambda);
91bool CheckDefaultArgumentVisitor::VisitExpr(
const Expr *
Node) {
92 bool IsInvalid =
false;
93 for (
const Stmt *SubStmt :
Node->children())
95 IsInvalid |= Visit(SubStmt);
102bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(
const DeclRefExpr *DRE) {
105 if (!isa<VarDecl, BindingDecl>(
Decl))
108 if (
const auto *Param = dyn_cast<ParmVarDecl>(
Decl)) {
119 diag::err_param_default_argument_references_param)
120 << Param->getDeclName() << DefaultArg->getSourceRange();
121 }
else if (
auto *VD =
Decl->getPotentiallyDecomposedVarDecl()) {
136 diag::err_param_default_argument_references_local)
143bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(
const CXXThisExpr *ThisE) {
148 diag::err_param_default_argument_references_this)
152bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(
157 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E)) {
158 E = OVE->getSourceExpr();
159 assert(E &&
"pseudo-object binding without source expression?");
167bool CheckDefaultArgumentVisitor::VisitLambdaExpr(
const LambdaExpr *Lambda) {
176 return S.
Diag(LC.getLocation(), diag::err_lambda_capture_default_arg);
178 auto *D = cast<VarDecl>(LC.getCapturedVar());
179 Invalid |= Visit(D->getInit());
211 llvm_unreachable(
"should not see unresolved exception specs here");
240 "should not generate implicit declarations for dependent cases");
244 assert(EST ==
EST_Dynamic &&
"EST case not considered earlier.");
246 "Shouldn't collect exceptions when throw-all is guaranteed.");
251 Exceptions.push_back(E);
279 if (
Self->canThrow(S))
286 diag::err_typecheck_decl_incomplete_type))
305 CheckCompletedExpr(Arg, EqualLoc);
318 UnparsedDefaultArgInstantiationsMap::iterator InstPos
321 for (
unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
322 InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
335 if (!param || !DefaultArg)
343 Diag(EqualLoc, diag::err_param_default_argument)
356 Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
370 CheckDefaultArgumentVisitor DefaultArgChecker(*
this, DefaultArg);
371 if (DefaultArgChecker.Visit(DefaultArg))
408 Param->
getType().getNonReferenceType());
430 if (MightBeFunction) {
434 MightBeFunction =
false;
437 for (
unsigned argIdx = 0, e = chunk.
Fun.
NumParams; argIdx != e;
441 std::unique_ptr<CachedTokens> Toks =
444 if (Toks->size() > 1)
446 Toks->back().getLocation());
458 MightBeFunction =
false;
465 return P->hasDefaultArg() && !P->hasInheritedDefaultArg();
486 for (; PrevForDefaultArgs;
534 for (
unsigned p = 0, NumParams = PrevForDefaultArgs
537 p < NumParams; ++p) {
541 bool OldParamHasDfl = OldParam ? OldParam->
hasDefaultArg() :
false;
544 if (OldParamHasDfl && NewParamHasDfl) {
545 unsigned DiagDefaultParamID =
546 diag::err_param_default_argument_redefinition;
561 DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
579 for (
auto Older = PrevForDefaultArgs;
581 Older = Older->getPreviousDecl();
582 OldParam = Older->getParamDecl(p);
587 }
else if (OldParamHasDfl) {
605 }
else if (NewParamHasDfl) {
609 diag::err_param_default_argument_template_redecl)
612 diag::note_template_prev_declaration)
643 if (
Record->getDescribedClassTemplate())
645 else if (isa<ClassTemplatePartialSpecializationDecl>(
Record))
652 diag::err_param_default_argument_member_template_redecl)
662 if (isa<CXXConstructorDecl>(New) &&
666 if (NewSM != OldSM) {
669 Diag(NewParam->
getLocation(), diag::err_default_arg_makes_ctor_special)
704 if (isa<CXXDeductionGuideDecl>(New) &&
716 Diag(New->
getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
737 ? diag::warn_cxx23_placeholder_var_definition
738 : diag::ext_placeholder_var_definition);
756 if (!TemplateParamLists.empty()) {
759 Diag(TemplateParamLists.front()->getTemplateLoc(),
760 diag::err_decomp_decl_template);
766 ? diag::ext_decomp_decl
768 ? diag::ext_decomp_decl_cond
769 : diag::warn_cxx14_compat_decomp_decl)
792 if (
auto SCS = DS.getStorageClassSpec()) {
795 CPlusPlus20SpecifierLocs.push_back(DS.getStorageClassSpecLoc());
798 BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
801 if (
auto TSCS = DS.getThreadStorageClassSpec()) {
803 CPlusPlus20SpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
805 if (DS.hasConstexprSpecifier()) {
806 BadSpecifiers.push_back(
808 BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());
810 if (DS.isInlineSpecified()) {
811 BadSpecifiers.push_back(
"inline");
812 BadSpecifierLocs.push_back(DS.getInlineSpecLoc());
815 if (!BadSpecifiers.empty()) {
816 auto &&Err =
Diag(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);
817 Err << (
int)BadSpecifiers.size()
818 << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(),
" ");
821 for (
auto Loc : BadSpecifierLocs)
823 }
else if (!CPlusPlus20Specifiers.empty()) {
824 auto &&Warn =
Diag(CPlusPlus20SpecifierLocs.front(),
826 ? diag::warn_cxx17_compat_decomp_decl_spec
827 : diag::ext_decomp_decl_spec);
828 Warn << (
int)CPlusPlus20Specifiers.size()
829 << llvm::join(CPlusPlus20Specifiers.begin(),
830 CPlusPlus20Specifiers.end(),
" ");
831 for (
auto Loc : CPlusPlus20SpecifierLocs)
843 Diag(DS.getVolatileSpecLoc(),
844 diag::warn_deprecated_volatile_structured_binding);
864 ? diag::err_decomp_decl_parens
865 : diag::err_decomp_decl_type)
876 if (DS.isConstrainedAuto()) {
879 "No other template kind should be possible for a constrained auto");
897 assert(VarName &&
"Cannot have an unnamed binding declaration");
900 RedeclarationKind::ForVisibleRedeclaration);
906 Previous.getFoundDecl()->isTemplateParameter()) {
940 auto *Old =
Previous.getRepresentativeDecl();
941 Diag(B.NameLoc, diag::err_redefinition) << B.Name;
942 Diag(Old->getLocation(), diag::note_previous_definition);
957 RedeclarationKind::ForVisibleRedeclaration);
960 bool AddToScope =
true;
969 if (
OpenMP().isInOpenMPDeclareTargetContext())
979 if ((int64_t)
Bindings.size() != NumElems) {
980 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
993 E = GetInit(
Loc, E.
get(), I++);
996 B->setBinding(ElemType, E.
get());
1005 const llvm::APSInt &NumElems,
1008 S,
Bindings, Src, DecompType, NumElems, ElemType,
1039 S,
Bindings, Src, DecompType, llvm::APSInt::get(2),
1043 return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
1051 llvm::raw_svector_ostream
OS(SS);
1063 return std::string(
OS.str());
1070 auto DiagnoseMissing = [&] {
1080 return DiagnoseMissing();
1090 return DiagnoseMissing();
1091 if (
Result.isAmbiguous())
1096 Result.suppressDiagnostics();
1098 S.
Diag(
Loc, diag::err_std_type_trait_not_class_template) << Trait;
1110 Loc, TraitTy, DiagID,
1117 assert(RD &&
"specialization of class template is not a class?");
1136namespace {
enum class IsTupleLike { TupleLike, NotTupleLike,
Error }; }
1139 llvm::APSInt &Size) {
1154 return IsTupleLike::NotTupleLike;
1163 : R(R), Args(Args) {}
1166 return S.
Diag(
Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
1170 } Diagnoser(R, Args);
1175 return IsTupleLike::Error;
1179 return IsTupleLike::Error;
1181 return IsTupleLike::TupleLike;
1196 S, R,
Loc,
"tuple_element", Args,
1197 diag::err_decomp_decl_std_tuple_element_not_specialized))
1203 S.
Diag(
Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
1215struct InitializingBinding {
1224 ~InitializingBinding() {
1233 const llvm::APSInt &TupleSize) {
1234 if ((int64_t)
Bindings.size() != TupleSize) {
1235 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1251 bool UseMemberGet =
false;
1261 dyn_cast<FunctionTemplateDecl>(D->getUnderlyingDecl())) {
1263 if (TPL->
size() != 0 &&
1264 isa<NonTypeTemplateParmDecl>(TPL->
getParam(0))) {
1266 UseMemberGet =
true;
1275 InitializingBinding InitContext(S, B);
1298 MemberGet, &Args,
nullptr);
1333 B->getDeclName().getAsIdentifierInfo(), RefType,
1337 RefVD->setImplicit();
1339 RefVD->setInlineSpecified();
1340 RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);
1345 E =
Seq.Perform(S, Entity, Kind,
Init);
1351 RefVD->setInit(E.
get());
1360 B->setBinding(
T, E.
get());
1375 return Specifier->getType()->getAsCXXRecordDecl()->hasDirectFields();
1384 ClassWithFields = RD;
1396 for (
auto &
P : Paths) {
1400 BestPath->back().Base->getType())) {
1402 S.
Diag(
Loc, diag::err_decomp_decl_multiple_bases_with_members)
1403 <<
false << RD << BestPath->back().Base->getType()
1404 <<
P.back().Base->getType();
1406 }
else if (
P.Access < BestPath->
Access) {
1412 QualType BaseType = BestPath->back().Base->getType();
1414 S.
Diag(
Loc, diag::err_decomp_decl_ambiguous_base)
1421 *BestPath, diag::err_decomp_decl_inaccessible_base);
1432 S.
Diag(
Loc, diag::err_decomp_decl_multiple_bases_with_members)
1433 << (ClassWithFields == RD) << RD << ClassWithFields
1434 << Paths.front().back().Base->getType();
1445 diag::err_incomplete_type))
1457 auto DiagnoseBadNumberOfBindings = [&]() ->
bool {
1458 unsigned NumFields = llvm::count_if(
1459 RD->
fields(), [](
FieldDecl *FD) { return !FD->isUnnamedBitField(); });
1460 assert(
Bindings.size() != NumFields);
1461 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1471 for (
auto *FD : RD->
fields()) {
1472 if (FD->isUnnamedBitField())
1477 if (!FD->getDeclName()) {
1484 if (FD->isAnonymousStructOrUnion()) {
1487 S.
Diag(FD->getLocation(), diag::note_declared_at);
1496 return DiagnoseBadNumberOfBindings();
1507 BasePair.
getAccess(), FD->getAccess())));
1530 if (FD->isMutable())
1536 return DiagnoseBadNumberOfBindings();
1578 llvm::APSInt TupleSize(32);
1580 case IsTupleLike::Error:
1584 case IsTupleLike::TupleLike:
1589 case IsTupleLike::NotTupleLike:
1598 << DD << !RD << DecompType;
1621 "Should only be called if types are otherwise the same.");
1632 NewType =
P->getPointeeType();
1665 if (FTD->isMemberSpecialization())
1689 diag::err_param_default_argument_missing_name)
1693 diag::err_param_default_argument_missing);
1701template <
typename... Ts>
1711 std::forward<Ts>(DiagArgs)...);
1717 llvm_unreachable(
"unknown CheckConstexprKind");
1725 "this check is obsolete for C++23");
1744 if (!Check(B.getBaseTypeLoc(), B.getType(),
nullptr))
1747 if (!Check(FD->getLocation(), FD->getType(), FD))
1758 "this check is obsolete for C++23");
1759 unsigned ArgIndex = 0;
1762 e = FT->param_type_end();
1763 i != e; ++i, ++ArgIndex) {
1765 assert(PD &&
"null in a parameter list");
1768 diag::err_constexpr_non_literal_param, ArgIndex + 1,
1781 "this check is obsolete for C++23");
1783 diag::err_constexpr_non_literal_return,
1802 default: llvm_unreachable(
"Invalid tag kind for record diagnostic!");
1833 << isa<CXXConstructorDecl>(NewFD)
1835 for (
const auto &I : RD->
vbases())
1836 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
1837 << I.getSourceRange();
1842 if (!isa<CXXConstructorDecl>(NewFD)) {
1847 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
1851 Diag(Method->
getLocation(), diag::warn_cxx17_compat_constexpr_virtual);
1864 if (WrittenVirtual != Method)
1866 diag::note_overridden_virtual_function);
1877 if (
auto *Dtor = dyn_cast<CXXDestructorDecl>(NewFD)) {
1882 !Dtor->getParent()->defaultedDestructorIsConstexpr()) {
1897 "CheckConstexprFunctionDefinition called on function with no body");
1912 for (
const auto *DclIt : DS->
decls()) {
1913 switch (DclIt->getKind()) {
1914 case Decl::StaticAssert:
1916 case Decl::UsingShadow:
1917 case Decl::UsingDirective:
1918 case Decl::UnresolvedUsingTypename:
1919 case Decl::UnresolvedUsingValue:
1920 case Decl::UsingEnum:
1928 case Decl::TypeAlias: {
1931 const auto *TN = cast<TypedefNameDecl>(DclIt);
1932 if (TN->getUnderlyingType()->isVariablyModifiedType()) {
1935 TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
1938 << isa<CXXConstructorDecl>(Dcl);
1946 case Decl::CXXRecord:
1948 if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) {
1952 ? diag::warn_cxx11_compat_constexpr_type_definition
1953 : diag::ext_constexpr_type_definition)
1954 << isa<CXXConstructorDecl>(Dcl);
1961 case Decl::EnumConstant:
1962 case Decl::IndirectField:
1969 case Decl::Decomposition: {
1974 const auto *VD = cast<VarDecl>(DclIt);
1975 if (VD->isThisDeclarationADefinition()) {
1976 if (VD->isStaticLocal()) {
1980 ? diag::warn_cxx20_compat_constexpr_var
1981 : diag::ext_constexpr_static_var)
1982 << isa<CXXConstructorDecl>(Dcl)
1990 diag::warn_cxx20_compat_constexpr_var,
1991 isa<CXXConstructorDecl>(Dcl),
1994 SemaRef, Kind, VD->getLocation(), VD->getType(),
1995 diag::err_constexpr_local_var_non_literal_type,
1996 isa<CXXConstructorDecl>(Dcl))) {
1999 if (!VD->getType()->isDependentType() &&
2000 !VD->hasInit() && !VD->isCXXForRangeDecl()) {
2005 ? diag::warn_cxx17_compat_constexpr_local_var_no_init
2006 : diag::ext_constexpr_local_var_no_init)
2007 << isa<CXXConstructorDecl>(Dcl);
2017 ? diag::warn_cxx11_compat_constexpr_local_var
2018 : diag::ext_constexpr_local_var)
2019 << isa<CXXConstructorDecl>(Dcl);
2026 case Decl::NamespaceAlias:
2027 case Decl::Function:
2037 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval();
2062 llvm::SmallSet<Decl*, 16> &Inits,
2070 if (Field->isInvalidDecl())
2073 if (Field->isUnnamedBitField())
2079 if (Field->isAnonymousStructOrUnion() &&
2080 (Field->getType()->isUnionType()
2081 ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
2082 : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
2085 if (!Inits.count(Field)) {
2090 ? diag::warn_cxx17_compat_constexpr_ctor_missing_init
2091 : diag::ext_constexpr_ctor_missing_init);
2095 diag::note_constexpr_ctor_missing_init);
2099 }
else if (Field->isAnonymousStructOrUnion()) {
2101 for (
auto *I : RD->
fields())
2104 if (!RD->
isUnion() || Inits.count(I))
2121 switch (S->getStmtClass()) {
2122 case Stmt::NullStmtClass:
2126 case Stmt::DeclStmtClass:
2136 case Stmt::ReturnStmtClass:
2138 if (isa<CXXConstructorDecl>(Dcl)) {
2141 Cxx1yLoc = S->getBeginLoc();
2145 ReturnStmts.push_back(S->getBeginLoc());
2148 case Stmt::AttributedStmtClass:
2152 SemaRef, Dcl, cast<AttributedStmt>(S)->getSubStmt(), ReturnStmts,
2153 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind);
2155 case Stmt::CompoundStmtClass: {
2158 Cxx1yLoc = S->getBeginLoc();
2161 for (
auto *BodyIt : CompStmt->
body()) {
2163 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2169 case Stmt::IfStmtClass: {
2172 Cxx1yLoc = S->getBeginLoc();
2176 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2178 if (
If->getElse() &&
2180 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2185 case Stmt::WhileStmtClass:
2186 case Stmt::DoStmtClass:
2187 case Stmt::ForStmtClass:
2188 case Stmt::CXXForRangeStmtClass:
2189 case Stmt::ContinueStmtClass:
2195 Cxx1yLoc = S->getBeginLoc();
2196 for (
Stmt *SubStmt : S->children()) {
2199 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2204 case Stmt::SwitchStmtClass:
2205 case Stmt::CaseStmtClass:
2206 case Stmt::DefaultStmtClass:
2207 case Stmt::BreakStmtClass:
2211 Cxx1yLoc = S->getBeginLoc();
2212 for (
Stmt *SubStmt : S->children()) {
2215 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2220 case Stmt::LabelStmtClass:
2221 case Stmt::GotoStmtClass:
2223 Cxx2bLoc = S->getBeginLoc();
2224 for (
Stmt *SubStmt : S->children()) {
2227 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2232 case Stmt::GCCAsmStmtClass:
2233 case Stmt::MSAsmStmtClass:
2235 case Stmt::CXXTryStmtClass:
2237 Cxx2aLoc = S->getBeginLoc();
2238 for (
Stmt *SubStmt : S->children()) {
2241 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2246 case Stmt::CXXCatchStmtClass:
2250 SemaRef, Dcl, cast<CXXCatchStmt>(S)->getHandlerBlock(), ReturnStmts,
2251 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2261 Cxx1yLoc = S->getBeginLoc();
2266 SemaRef.
Diag(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
2267 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval();
2282 if (isa<CXXTryStmt>(Body)) {
2304 ? diag::ext_constexpr_function_try_block_cxx20
2305 : diag::warn_cxx17_compat_constexpr_function_try_block)
2306 << isa<CXXConstructorDecl>(Dcl);
2320 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2331 }
else if (Cxx2bLoc.
isValid()) {
2334 ? diag::warn_cxx20_compat_constexpr_body_invalid_stmt
2335 : diag::ext_constexpr_body_invalid_stmt_cxx23)
2336 << isa<CXXConstructorDecl>(Dcl);
2337 }
else if (Cxx2aLoc.
isValid()) {
2340 ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
2341 : diag::ext_constexpr_body_invalid_stmt_cxx20)
2342 << isa<CXXConstructorDecl>(Dcl);
2343 }
else if (Cxx1yLoc.
isValid()) {
2346 ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
2347 : diag::ext_constexpr_body_invalid_stmt)
2348 << isa<CXXConstructorDecl>(Dcl);
2352 = dyn_cast<CXXConstructorDecl>(Dcl)) {
2361 if (Constructor->getNumCtorInitializers() == 0 &&
2367 ? diag::warn_cxx17_compat_constexpr_union_ctor_no_init
2368 : diag::ext_constexpr_union_ctor_no_init);
2373 }
else if (!Constructor->isDependentContext() &&
2374 !Constructor->isDelegatingConstructor()) {
2375 assert(RD->
getNumVBases() == 0 &&
"constexpr ctor with virtual bases");
2379 bool AnyAnonStructUnionMembers =
false;
2380 unsigned Fields = 0;
2382 E = RD->
field_end(); I != E; ++I, ++Fields) {
2383 if (I->isAnonymousStructOrUnion()) {
2384 AnyAnonStructUnionMembers =
true;
2392 if (AnyAnonStructUnionMembers ||
2393 Constructor->getNumCtorInitializers() != RD->
getNumBases() + Fields) {
2397 llvm::SmallSet<Decl*, 16> Inits;
2398 for (
const auto *I: Constructor->inits()) {
2402 Inits.insert(ID->chain_begin(), ID->chain_end());
2405 bool Diagnosed =
false;
2406 for (
auto *I : RD->
fields())
2413 if (ReturnStmts.empty()) {
2424 OK ? diag::warn_cxx11_compat_constexpr_body_no_return
2425 : diag::err_constexpr_body_no_return)
2439 }
else if (ReturnStmts.size() > 1) {
2445 ? diag::warn_cxx11_compat_constexpr_body_multiple_return
2446 : diag::ext_constexpr_body_multiple_return);
2447 for (
unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
2449 diag::note_constexpr_body_previous_return);
2478 diag::ext_constexpr_function_never_constant_expr)
2479 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval()
2481 for (
size_t I = 0, N =
Diags.size(); I != N; ++I)
2499 Diag(it->second, diag::err_immediate_function_used_before_definition)
2512 "expected an immediate function");
2513 assert(FD->
hasBody() &&
"expected the function to have a body");
2514 struct ImmediateEscalatingExpressionsVisitor
2521 bool ImmediateFnIsConstructor;
2526 : SemaRef(SemaRef), ImmediateFn(FD),
2527 ImmediateFnIsConstructor(isa<CXXConstructorDecl>(FD)) {}
2529 bool shouldVisitImplicitCode()
const {
return true; }
2530 bool shouldVisitLambdaBody()
const {
return false; }
2535 if (CurrentConstructor && CurrentInit) {
2543 SemaRef.
Diag(
Loc, diag::note_immediate_function_reason)
2544 << ImmediateFn << Fn << Fn->
isConsteval() << IsCall
2545 << isa<CXXConstructorDecl>(Fn) << ImmediateFnIsConstructor
2546 << (InitializedField !=
nullptr)
2547 << (CurrentInit && !CurrentInit->
isWritten())
2548 << InitializedField <<
Range;
2550 bool TraverseCallExpr(
CallExpr *E) {
2551 if (
const auto *DR =
2553 DR && DR->isImmediateEscalating()) {
2559 if (!getDerived().TraverseStmt(A))
2566 if (
const auto *ReferencedFn = dyn_cast<FunctionDecl>(E->
getDecl());
2568 Diag(E, ReferencedFn,
false);
2586 return Base::TraverseConstructorInitializer(
Init);
2591 return Base::TraverseCXXConstructorDecl(Ctr);
2594 bool TraverseType(
QualType T) {
return true; }
2595 bool VisitBlockExpr(
BlockExpr *
T) {
return true; }
2597 } Visitor(*
this, FD);
2598 Visitor.TraverseDecl(FD);
2617 return dyn_cast_or_null<CXXRecordDecl>(DC);
2620 return dyn_cast_or_null<CXXRecordDecl>(
CurContext);
2645 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
2647 CurDecl = dyn_cast_or_null<CXXRecordDecl>(
CurContext);
2676 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
2690 if (BaseDecl->isUnion()) {
2691 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
2699 if (
auto *BaseSpec =
2700 dyn_cast<ClassTemplateSpecializationDecl>(BaseDecl)) {
2709 Class->setInvalidDecl();
2713 BaseDecl = BaseDecl->getDefinition();
2714 assert(BaseDecl &&
"Base type is not incomplete, but has no definition");
2719 const auto *BaseCSA = BaseDecl->getAttr<CodeSegAttr>();
2720 const auto *DerivedCSA =
Class->getAttr<CodeSegAttr>();
2721 if ((DerivedCSA || BaseCSA) &&
2722 (!BaseCSA || !DerivedCSA ||
2723 BaseCSA->getName() != DerivedCSA->getName())) {
2724 Diag(
Class->getLocation(), diag::err_mismatched_code_seg_base);
2725 Diag(BaseDecl->getLocation(), diag::note_base_class_specified_here)
2736 if (BaseDecl->hasFlexibleArrayMember()) {
2737 Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
2738 << BaseDecl->getDeclName();
2745 if (FinalAttr *FA = BaseDecl->getAttr<FinalAttr>()) {
2746 Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
2747 << BaseDecl->getDeclName() << FA->isSpelledAsSealed();
2748 Diag(BaseDecl->getLocation(), diag::note_entity_declared_at)
2749 << BaseDecl->getDeclName() << FA->getRange();
2754 if (BaseDecl->isInvalidDecl())
2755 Class->setInvalidDecl();
2763 if (!
Class->isDependentContext())
2764 Class->setInvalidDecl();
2767 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
2779 Access, TInfo, EllipsisLoc);
2801 Class->setIsParsingBaseSpecifiers();
2809 Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
2810 << AL << AL.getRange();
2812 Diag(AL.getLoc(), diag::err_base_specifier_attribute)
2813 << AL << AL.isRegularKeywordAttribute() << AL.getRange();
2826 if (
Class->isUnion()) {
2827 Diag(
Class->getLocation(), diag::err_base_clause_on_union)
2837 Class->setInvalidDecl();
2853 auto Decl = Rec->getAsCXXRecordDecl();
2856 for (
const auto &BaseSpec :
Decl->bases()) {
2877 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
2884 unsigned NumGoodBases = 0;
2886 for (
unsigned idx = 0; idx < Bases.size(); ++idx) {
2896 Diag(Bases[idx]->getBeginLoc(), diag::err_duplicate_base_class)
2897 << KnownBase->
getType() << Bases[idx]->getSourceRange();
2906 KnownBase = Bases[idx];
2907 Bases[NumGoodBases++] = Bases[idx];
2912 if (Bases.size() > 1)
2917 if (
Class->isInterface() &&
2934 Class->setBases(Bases.data(), NumGoodBases);
2937 for (
unsigned idx = 0; idx < NumGoodBases; ++idx) {
2939 QualType BaseType = Bases[idx]->getType();
2949 if (IndirectBaseTypes.count(CanonicalBase)) {
2953 =
Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
2957 if (Paths.isAmbiguous(CanonicalBase))
2958 Diag(Bases[idx]->getBeginLoc(), diag::warn_inaccessible_base_class)
2960 << Bases[idx]->getSourceRange();
2962 assert(Bases[idx]->isVirtual());
2978 if (!ClassDecl || Bases.empty())
3039 for (
unsigned I = Path.size(); I != 0; --I) {
3040 if (Path[I - 1].
Base->isVirtual()) {
3047 for (
unsigned I = Start, E = Path.size(); I != E; ++I)
3054 assert(BasePathArray.empty() &&
"Base path array must be empty!");
3055 assert(Paths.isRecordingPaths() &&
"Must record paths!");
3056 return ::BuildBasePathArray(Paths.front(), BasePathArray);
3072 unsigned InaccessibleBaseID,
3073 unsigned AmbiguousBaseConvID,
3077 bool IgnoreAccess) {
3085 if (!DerivationOkay)
3090 Path = &Paths.front();
3097 if (PossiblePath.size() == 1) {
3098 Path = &PossiblePath;
3099 if (AmbiguousBaseConvID)
3100 Diag(
Loc, diag::ext_ms_ambiguous_direct_base)
3108 if (!IgnoreAccess) {
3127 if (AmbiguousBaseConvID) {
3135 Paths.setRecordingPaths(
true);
3137 assert(StillOkay &&
"Can only be used with a derived-to-base conversion");
3146 Diag(
Loc, AmbiguousBaseConvID)
3147 << Derived <<
Base << PathDisplayStr <<
Range << Name;
3156 bool IgnoreAccess) {
3158 Derived,
Base, diag::err_upcast_to_inaccessible_base,
3160 BasePath, IgnoreAccess);
3177 std::string PathDisplayStr;
3178 std::set<unsigned> DisplayedPaths;
3180 Path != Paths.end(); ++Path) {
3181 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
3184 PathDisplayStr +=
"\n ";
3186 for (CXXBasePath::const_iterator Element = Path->begin();
3187 Element != Path->end(); ++Element)
3188 PathDisplayStr +=
" -> " + Element->Base->getType().getAsString();
3192 return PathDisplayStr;
3203 assert(Access !=
AS_none &&
"Invalid kind for syntactic access specifier!");
3233 if (!OverloadedMethods.empty()) {
3234 if (OverrideAttr *OA = D->
getAttr<OverrideAttr>()) {
3235 Diag(OA->getLocation(),
3236 diag::override_keyword_hides_virtual_member_function)
3237 <<
"override" << (OverloadedMethods.size() > 1);
3238 }
else if (FinalAttr *FA = D->
getAttr<FinalAttr>()) {
3239 Diag(FA->getLocation(),
3240 diag::override_keyword_hides_virtual_member_function)
3241 << (FA->isSpelledAsSealed() ?
"sealed" :
"final")
3242 << (OverloadedMethods.size() > 1);
3253 if (OverrideAttr *OA = D->
getAttr<OverrideAttr>()) {
3254 Diag(OA->getLocation(),
3255 diag::override_keyword_only_allowed_on_virtual_member_functions)
3259 if (FinalAttr *FA = D->
getAttr<FinalAttr>()) {
3260 Diag(FA->getLocation(),
3261 diag::override_keyword_only_allowed_on_virtual_member_functions)
3262 << (FA->isSpelledAsSealed() ?
"sealed" :
"final")
3274 if (MD->
hasAttr<OverrideAttr>() && !HasOverriddenMethods)
3275 Diag(MD->
getLocation(), diag::err_function_marked_override_not_overriding)
3295 auto EmitDiag = [&](
unsigned DiagInconsistent,
unsigned DiagSuggest) {
3304 if (isa<CXXDestructorDecl>(MD))
3306 diag::warn_inconsistent_destructor_marked_not_override_overriding,
3307 diag::warn_suggest_destructor_marked_not_override_overriding);
3309 EmitDiag(diag::warn_inconsistent_function_marked_not_override_overriding,
3310 diag::warn_suggest_function_marked_not_override_overriding);
3319 FinalAttr *FA = Old->
getAttr<FinalAttr>();
3325 << FA->isSpelledAsSealed();
3334 return !RD->isCompleteDefinition() ||
3335 !RD->hasTrivialDefaultConstructor() ||
3336 !RD->hasTrivialDestructor();
3349 std::map<CXXRecordDecl*, NamedDecl*> Bases;
3352 const auto Base =
Specifier->getType()->getAsCXXRecordDecl();
3354 if (Bases.find(
Base) != Bases.end())
3356 for (
const auto Field :
Base->lookup(FieldName)) {
3357 if ((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&
3360 assert(Bases.find(
Base) == Bases.end());
3373 for (
const auto &
P : Paths) {
3374 auto Base =
P.back().Base->getType()->getAsCXXRecordDecl();
3375 auto It = Bases.find(
Base);
3377 if (It == Bases.end())
3379 auto BaseField = It->second;
3380 assert(BaseField->getAccess() !=
AS_private);
3383 Diag(
Loc, diag::warn_shadow_field)
3384 << FieldName << RD <<
Base << DeclIsField;
3385 Diag(BaseField->getLocation(), diag::note_shadow_field);
3410 Expr *BitWidth =
static_cast<Expr*
>(BW);
3419 if (cast<CXXRecordDecl>(
CurContext)->isInterface()) {
3423 unsigned InvalidDecl;
3424 bool ShowDeclName =
true;
3434 else switch (Name.getNameKind()) {
3437 ShowDeclName =
false;
3442 ShowDeclName =
false;
3457 Diag(
Loc, diag::err_invalid_member_in_interface)
3458 << (InvalidDecl-1) << Name;
3460 Diag(
Loc, diag::err_invalid_member_in_interface)
3461 << (InvalidDecl-1) <<
"";
3487 diag::err_storageclass_invalid_for_member);
3507 const char *PrevSpec;
3512 assert(!Failed &&
"Making a constexpr member const shouldn't fail");
3516 const char *PrevSpec;
3522 "This is the only DeclSpec that should fail to be applied");
3526 isInstField =
false;
3536 if (!Name.isIdentifier()) {
3537 Diag(
Loc, diag::err_bad_variable_name)
3546 if (TemplateParameterLists.size()) {
3548 if (TemplateParams->
size()) {
3557 diag::err_template_member_noparams)
3596 if (MSPropertyAttr) {
3598 BitWidth, InitStyle, AS, *MSPropertyAttr);
3601 isInstField =
false;
3604 BitWidth, InitStyle, AS);
3609 CheckShadowInheritedFields(
Loc, Name, cast<CXXRecordDecl>(
CurContext));
3617 if (
Member->isInvalidDecl()) {
3619 }
else if (isa<VarDecl>(
Member) || isa<VarTemplateDecl>(
Member)) {
3622 Diag(
Loc, diag::err_static_not_bitfield)
3624 }
else if (isa<TypedefDecl>(
Member)) {
3626 Diag(
Loc, diag::err_typedef_not_bitfield)
3631 Diag(
Loc, diag::err_not_integral_type_bitfield)
3632 << Name << cast<ValueDecl>(
Member)->getType()
3637 Member->setInvalidDecl();
3642 NonTemplateMember = FunTmpl->getTemplatedDecl();
3644 NonTemplateMember = VarTmpl->getTemplatedDecl();
3650 if (NonTemplateMember !=
Member)
3656 if (
auto *DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {
3657 auto *TD = DG->getDeducedTemplate();
3660 if (AS != TD->getAccess() &&
3661 TD->getDeclContext()->getRedeclContext()->Equals(
3662 DG->getDeclContext()->getRedeclContext())) {
3663 Diag(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);
3664 Diag(TD->getBeginLoc(), diag::note_deduction_guide_template_access)
3667 for (
const auto *D : cast<CXXRecordDecl>(
CurContext)->decls()) {
3668 if (
const auto *AccessSpec = dyn_cast<AccessSpecDecl>(D))
3669 LastAccessSpec = AccessSpec;
3671 assert(LastAccessSpec &&
"differing access with no access specifier");
3672 Diag(LastAccessSpec->
getBeginLoc(), diag::note_deduction_guide_access)
3683 ? FinalAttr::Keyword_sealed
3684 : FinalAttr::Keyword_final));
3694 assert((Name || isInstField) &&
"No identifier for non-field ?");
3704 auto DeclHasUnusedAttr = [](
const QualType &
T) {
3706 return TD->hasAttr<UnusedAttr>();
3708 return TDT->getDecl()->hasAttr<UnusedAttr>();
3716 !DeclHasUnusedAttr(FD->
getType()) &&
3726 class UninitializedFieldVisitor
3731 llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
3734 llvm::SmallPtrSetImpl<QualType> &BaseClasses;
3749 UninitializedFieldVisitor(
Sema &S,
3750 llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
3751 llvm::SmallPtrSetImpl<QualType> &BaseClasses)
3752 : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
3753 Constructor(nullptr), InitList(
false), InitListFieldDecl(nullptr) {}
3756 bool IsInitListMemberExprInitialized(
MemberExpr *ME,
3757 bool CheckReferenceOnly) {
3759 bool ReferenceField =
false;
3764 Fields.push_back(FD);
3766 ReferenceField =
true;
3772 if (CheckReferenceOnly && !ReferenceField)
3778 for (
const FieldDecl *FD : llvm::drop_begin(llvm::reverse(Fields)))
3781 for (
auto UsedIter = UsedFieldIndex.begin(),
3782 UsedEnd = UsedFieldIndex.end(),
3783 OrigIter = InitFieldIndex.begin(),
3784 OrigEnd = InitFieldIndex.end();
3785 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
3786 if (*UsedIter < *OrigIter)
3788 if (*UsedIter > *OrigIter)
3795 void HandleMemberExpr(
MemberExpr *ME,
bool CheckReferenceOnly,
3808 dyn_cast<MemberExpr>(
Base->IgnoreParenImpCasts())) {
3810 if (isa<VarDecl>(SubME->getMemberDecl()))
3813 if (
FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
3818 AllPODFields =
false;
3820 Base = SubME->getBase();
3823 if (!isa<CXXThisExpr>(
Base->IgnoreParenImpCasts())) {
3828 if (AddressOf && AllPODFields)
3834 while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
3835 BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
3838 if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
3848 if (!Decls.count(FoundVD))
3853 if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
3855 if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
3860 if (CheckReferenceOnly && !IsReference)
3864 unsigned diag = IsReference
3865 ? diag::warn_reference_field_is_uninit
3866 : diag::warn_field_is_uninit;
3870 diag::note_uninit_in_this_constructor)
3875 void HandleValue(
Expr *E,
bool AddressOf) {
3878 if (
MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3879 HandleMemberExpr(ME,
false ,
3885 Visit(CO->getCond());
3886 HandleValue(CO->getTrueExpr(), AddressOf);
3887 HandleValue(CO->getFalseExpr(), AddressOf);
3892 dyn_cast<BinaryConditionalOperator>(E)) {
3893 Visit(BCO->getCond());
3894 HandleValue(BCO->getFalseExpr(), AddressOf);
3899 HandleValue(OVE->getSourceExpr(), AddressOf);
3904 switch (BO->getOpcode()) {
3909 HandleValue(BO->getLHS(), AddressOf);
3910 Visit(BO->getRHS());
3913 Visit(BO->getLHS());
3914 HandleValue(BO->getRHS(), AddressOf);
3923 InitFieldIndex.push_back(0);
3924 for (
auto *Child : ILE->
children()) {
3925 if (
InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
3926 CheckInitListExpr(SubList);
3930 ++InitFieldIndex.back();
3932 InitFieldIndex.pop_back();
3941 DeclsToRemove.clear();
3948 InitListFieldDecl =
Field;
3949 InitFieldIndex.clear();
3950 CheckInitListExpr(ILE);
3964 HandleMemberExpr(ME,
true ,
false );
3973 Inherited::VisitImplicitCastExpr(E);
3979 if (
InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
3983 if (ICE->getCastKind() == CK_NoOp)
3984 ArgExpr = ICE->getSubExpr();
3985 HandleValue(ArgExpr,
false );
3988 Inherited::VisitCXXConstructExpr(E);
3993 if (isa<MemberExpr>(Callee)) {
3994 HandleValue(Callee,
false );
4000 Inherited::VisitCXXMemberCallExpr(E);
4006 HandleValue(E->
getArg(0),
false);
4010 Inherited::VisitCallExpr(E);
4016 if (isa<UnresolvedLookupExpr>(Callee))
4017 return Inherited::VisitCXXOperatorCallExpr(E);
4021 HandleValue(Arg->IgnoreParenImpCasts(),
false );
4031 DeclsToRemove.push_back(FD);
4034 HandleValue(E->
getLHS(),
false );
4039 Inherited::VisitBinaryOperator(E);
4049 HandleValue(ME->
getBase(),
true );
4054 Inherited::VisitUnaryOperator(E);
4064 static void DiagnoseUninitializedFields(
4084 for (
auto *I : RD->
decls()) {
4085 if (
auto *FD = dyn_cast<FieldDecl>(I)) {
4086 UninitializedFields.insert(FD);
4087 }
else if (
auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
4088 UninitializedFields.insert(IFD->getAnonField());
4093 for (
const auto &I : RD->
bases())
4094 UninitializedBaseClasses.insert(I.getType().getCanonicalType());
4096 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
4099 UninitializedFieldVisitor UninitializedChecker(
SemaRef,
4100 UninitializedFields,
4101 UninitializedBaseClasses);
4103 for (
const auto *FieldInit :
Constructor->inits()) {
4104 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
4107 Expr *InitExpr = FieldInit->getInit();
4112 dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
4113 InitExpr =
Default->getExpr();
4117 UninitializedChecker.CheckInitializer(InitExpr, Constructor,
4118 FieldInit->getAnyMember(),
4119 FieldInit->getBaseClass());
4121 UninitializedChecker.CheckInitializer(InitExpr,
nullptr,
4122 FieldInit->getAnyMember(),
4123 FieldInit->getBaseClass());
4146 auto *ParamDecl = cast<NamedDecl>(Param.Param);
4147 if (ParamDecl->getDeclName())
4168 return ConstraintExpr;
4183 return Seq.Perform(*
this, Entity, Kind, InitExpr);
4197 "must set init style when field is created");
4214 assert(
Init.isUsable() &&
"Init should at least have a RecoveryExpr");
4220 if (!
Init.isInvalid())
4222 if (
Init.isInvalid()) {
4240 DirectBaseSpec =
nullptr;
4241 for (
const auto &
Base : ClassDecl->
bases()) {
4245 DirectBaseSpec = &
Base;
4253 VirtualBaseSpec =
nullptr;
4254 if (!DirectBaseSpec || !DirectBaseSpec->
isVirtual()) {
4263 Path != Paths.end(); ++Path) {
4264 if (Path->back().Base->isVirtual()) {
4265 VirtualBaseSpec = Path->back().Base;
4272 return DirectBaseSpec || VirtualBaseSpec;
4287 DS, IdLoc, InitList,
4306 DS, IdLoc, List, EllipsisLoc);
4315 explicit MemInitializerValidatorCCC(
CXXRecordDecl *ClassDecl)
4316 : ClassDecl(ClassDecl) {}
4318 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
4321 return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
4322 return isa<TypeDecl>(ND);
4327 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
4328 return std::make_unique<MemInitializerValidatorCCC>(*
this);
4343 return isa<FieldDecl, IndirectFieldDecl>(Elem) &&
4347 if (Found ==
Result.end())
4349 Diag(
Loc, diag::err_using_placeholder_variable) << Name;
4354 if (isa<FieldDecl, IndirectFieldDecl>(ND) &&
4365 for (
auto *D : ClassDecl->
lookup(MemberOrBase)) {
4366 if (isa<FieldDecl, IndirectFieldDecl>(D)) {
4369 if (IsPlaceholder && D->getDeclContext() == ND->
getDeclContext())
4374 return cast<ValueDecl>(D);
4375 ND = cast<ValueDecl>(D);
4413 = dyn_cast<CXXConstructorDecl>(ConstructorD);
4437 ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {
4439 Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
4449 if (TemplateTypeTy) {
4474 bool NotUnknownSpecialization =
false;
4477 NotUnknownSpecialization = !
Record->hasAnyDependentBases();
4479 if (!NotUnknownSpecialization) {
4504 auto *TempSpec = cast<TemplateSpecializationType>(
4505 UnqualifiedBase->getInjectedClassNameSpecialization());
4507 for (
auto const &
Base : ClassDecl->
bases()) {
4511 BaseTemplate->getTemplateName(), TN)) {
4512 Diag(IdLoc, diag::ext_unqualified_base_class)
4514 BaseType =
Base.getType();
4523 MemInitializerValidatorCCC CCC(ClassDecl);
4532 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4533 << MemberOrBase <<
true);
4540 DirectBaseSpec, VirtualBaseSpec)) {
4545 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4546 << MemberOrBase <<
false,
4559 if (!TyD && BaseType.
isNull()) {
4560 Diag(IdLoc, diag::err_mem_init_not_member_or_class)
4561 << MemberOrBase <<
SourceRange(IdLoc,
Init->getSourceRange().getEnd());
4589 assert((DirectMember || IndirectMember) &&
4590 "Member must be a FieldDecl or IndirectFieldDecl");
4595 if (
Member->isInvalidDecl())
4600 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4602 Args =
MultiExprArg(InitList->getInits(), InitList->getNumInits());
4610 if (
Member->getType()->isDependentType() ||
Init->isTypeDependent()) {
4615 bool InitList =
false;
4616 if (isa<InitListExpr>(
Init)) {
4628 IdLoc,
Init->getBeginLoc(),
Init->getEndLoc())
4672 return Diag(NameLoc, diag::err_delegating_ctor)
4674 Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
4676 bool InitList =
true;
4680 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4689 NameLoc,
Init->getBeginLoc(),
Init->getEndLoc())
4697 cast<CXXConstructExpr>(DelegationInit.
get())->getConstructor()) &&
4698 "Delegating constructor with no target?");
4704 DelegationInit.
get(), InitRange.
getBegin(),
false);
4722 DelegationInit =
Init;
4737 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
4757 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
4786 if (!DirectBaseSpec && !VirtualBaseSpec) {
4795 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
4807 InitRange.
getEnd(), EllipsisLoc);
4814 if (DirectBaseSpec && VirtualBaseSpec)
4815 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
4820 BaseSpec = VirtualBaseSpec;
4823 bool InitList =
true;
4827 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4867 InitRange.
getEnd(), EllipsisLoc);
4877 TargetType, ExprLoc);
4897 bool IsInheritedVirtualBase,
4901 IsInheritedVirtualBase);
4905 switch (ImplicitInitKind) {
4911 BaseInit = InitSeq.
Perform(
SemaRef, InitEntity, InitKind, std::nullopt);
4917 bool Moving = ImplicitInitKind ==
IIK_Move;
4918 ParmVarDecl *Param = Constructor->getParamDecl(0);
4924 Constructor->getLocation(), ParamType,
4939 BasePath.push_back(BaseSpec);
4941 CK_UncheckedDerivedToBase,
4949 BaseInit = InitSeq.
Perform(
SemaRef, InitEntity, InitKind, CopyCtorArg);
4972 ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
4981 if (Field->isInvalidDecl())
4987 bool Moving = ImplicitInitKind ==
IIK_Move;
4988 ParmVarDecl *Param = Constructor->getParamDecl(0);
4995 Expr *MemberExprBase =
5061 "Unhandled implicit init kind!");
5097 if (!Field->getParent()->isUnion()) {
5100 diag::err_uninitialized_member_in_ctor)
5101 << (
int)Constructor->isImplicit()
5103 << 0 << Field->getDeclName();
5104 SemaRef.
Diag(Field->getLocation(), diag::note_declared_at);
5110 diag::err_uninitialized_member_in_ctor)
5111 << (
int)Constructor->isImplicit()
5113 << 1 << Field->getDeclName();
5114 SemaRef.
Diag(Field->getLocation(), diag::note_declared_at);
5131 CXXMemberInit =
nullptr;
5136struct BaseAndFieldInfo {
5139 bool AnyErrorsInInits;
5141 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
5143 llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
5146 : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
5158 bool isImplicitCopyOrMove()
const {
5169 llvm_unreachable(
"Invalid ImplicitInitializerKind!");
5173 AllToInit.push_back(
Init);
5182 bool isInactiveUnionMember(
FieldDecl *Field) {
5188 ActiveUnionMember.lookup(
Record->getCanonicalDecl()))
5189 return Active !=
Field->getCanonicalDecl();
5192 if (isImplicitCopyOrMove())
5197 if (
Field->hasInClassInitializer())
5201 if (!
Field->isAnonymousStructOrUnion())
5210 bool isWithinInactiveUnionMember(
FieldDecl *Field,
5213 return isInactiveUnionMember(Field);
5217 if (Field && isInactiveUnionMember(Field))
5232 if (ArrayT->isZeroSize())
5235 T = ArrayT->getElementType();
5244 if (Field->isInvalidDecl())
5249 Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
5250 return Info.addFieldInitializer(
Init);
5264 if (Info.isWithinInactiveUnionMember(Field,
Indirect))
5267 if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
5285 return Info.addFieldInitializer(
Init);
5295 if (Info.AnyErrorsInInits)
5306 return Info.addFieldInitializer(
Init);
5313 Constructor->setNumCtorInitializers(1);
5317 Constructor->setCtorInitializers(initializer);
5326 DiagnoseUninitializedFields(*
this, Constructor);
5333 if (Constructor->isDependentContext()) {
5336 if (!Initializers.empty()) {
5337 Constructor->setNumCtorInitializers(Initializers.size());
5340 memcpy(baseOrMemberInitializers, Initializers.data(),
5342 Constructor->setCtorInitializers(baseOrMemberInitializers);
5347 Constructor->setInvalidDecl();
5352 BaseAndFieldInfo Info(*
this, Constructor, AnyErrors);
5356 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
5360 bool HadError =
false;
5362 for (
unsigned i = 0; i < Initializers.size(); i++) {
5365 if (
Member->isBaseInitializer())
5368 Info.AllBaseFields[
Member->getAnyMember()->getCanonicalDecl()] =
Member;
5371 for (
auto *
C : F->chain()) {
5374 Info.ActiveUnionMember.insert(std::make_pair(
5379 Info.ActiveUnionMember.insert(std::make_pair(
5387 for (
auto &I : ClassDecl->
bases()) {
5389 DirectVBases.insert(&I);
5393 for (
auto &VBase : ClassDecl->
vbases()) {
5395 = Info.AllBaseFields.lookup(VBase.getType()->getAs<
RecordType>())) {
5403 Diag(
Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
5404 << VBase.getType() << ClassDecl;
5408 Info.AllToInit.push_back(
Value);
5409 }
else if (!AnyErrors && !ClassDecl->
isAbstract()) {
5414 bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
5417 &VBase, IsInheritedVirtualBase,
5423 Info.AllToInit.push_back(CXXBaseInit);
5430 if (
Base.isVirtual())
5434 = Info.AllBaseFields.lookup(
Base.getType()->getAs<
RecordType>())) {
5435 Info.AllToInit.push_back(
Value);
5436 }
else if (!AnyErrors) {
5445 Info.AllToInit.push_back(CXXBaseInit);
5450 for (
auto *Mem : ClassDecl->
decls()) {
5451 if (
auto *F = dyn_cast<FieldDecl>(Mem)) {
5456 if (F->isUnnamedBitField())
5462 if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
5471 if (Info.isImplicitCopyOrMove())
5474 if (
auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
5475 if (F->getType()->isIncompleteArrayType()) {
5477 "Incomplete array type is not valid");
5489 unsigned NumInitializers = Info.AllToInit.size();
5490 if (NumInitializers > 0) {
5491 Constructor->setNumCtorInitializers(NumInitializers);
5494 memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
5496 Constructor->setCtorInitializers(baseOrMemberInitializers);
5501 Constructor->getParent());
5511 for (
auto *Field : RD->
fields())
5516 IdealInits.push_back(Field->getCanonicalDecl());
5525 if (!
Member->isAnyMemberInitializer())
5528 return Member->getAnyMember()->getCanonicalDecl();
5534 if (
Previous->isAnyMemberInitializer())
5539 if (Current->isAnyMemberInitializer())
5540 Diag << 0 << Current->getAnyMember();
5542 Diag << 1 << Current->getTypeSourceInfo()->getType();
5548 if (Constructor->getDeclContext()->isDependentContext())
5553 bool ShouldCheckOrder =
false;
5554 for (
unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5557 Init->getSourceLocation())) {
5558 ShouldCheckOrder =
true;
5562 if (!ShouldCheckOrder)
5573 for (
const auto &VBase : ClassDecl->
vbases())
5577 for (
const auto &
Base : ClassDecl->
bases()) {
5578 if (
Base.isVirtual())
5584 for (
auto *Field : ClassDecl->
fields()) {
5585 if (Field->isUnnamedBitField())
5591 unsigned NumIdealInits = IdealInitKeys.size();
5592 unsigned IdealIndex = 0;
5601 for (
unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5606 for (; IdealIndex != NumIdealInits; ++IdealIndex)
5607 if (InitKey == IdealInitKeys[IdealIndex])
5613 if (IdealIndex == NumIdealInits && InitIndex) {
5614 WarnIndexes.push_back(InitIndex);
5617 for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
5618 if (InitKey == IdealInitKeys[IdealIndex])
5621 assert(IdealIndex < NumIdealInits &&
5622 "initializer not found in initializer list");
5624 CorrelatedInitOrder.emplace_back(IdealIndex, InitIndex);
5627 if (WarnIndexes.empty())
5631 llvm::sort(CorrelatedInitOrder, llvm::less_first());
5637 Inits[WarnIndexes.front() - 1]->getSourceLocation(),
5638 WarnIndexes.size() == 1 ? diag::warn_initializer_out_of_order
5639 : diag::warn_some_initializers_out_of_order);
5641 for (
unsigned I = 0; I < CorrelatedInitOrder.size(); ++I) {
5642 if (CorrelatedInitOrder[I].second == I)
5648 Inits[I]->getSourceRange(),
5651 Inits[CorrelatedInitOrder[I].second]->getSourceRange()),
5657 if (WarnIndexes.size() == 1) {
5659 Inits[WarnIndexes.front()]);
5665 for (
unsigned WarnIndex : WarnIndexes) {
5668 diag::note_initializer_out_of_order);
5675bool CheckRedundantInit(
Sema &S,
5685 diag::err_multiple_mem_initialization)
5686 <<
Field->getDeclName()
5687 <<
Init->getSourceRange();
5689 const Type *BaseClass =
Init->getBaseClass();
5690 assert(BaseClass &&
"neither field nor base");
5692 diag::err_multiple_base_initialization)
5694 <<
Init->getSourceRange();
5702typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
5703typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
5705bool CheckRedundantUnionInit(
Sema &S,
5707 RedundantUnionMap &Unions) {
5712 while (
Parent->isAnonymousStructOrUnion() ||
Parent->isUnion()) {
5714 UnionEntry &En = Unions[
Parent];
5715 if (En.first && En.first != Child) {
5717 diag::err_multiple_mem_union_initialization)
5718 <<
Field->getDeclName()
5719 <<
Init->getSourceRange();
5720 S.
Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
5721 << 0 << En.second->getSourceRange();
5728 if (!
Parent->isAnonymousStructOrUnion())
5745 if (!ConstructorDecl)
5751 = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
5754 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
5761 llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
5764 RedundantUnionMap MemberUnions;
5766 bool HadError =
false;
5767 for (
unsigned i = 0; i < MemInits.size(); i++) {
5771 Init->setSourceOrder(i);
5773 if (
Init->isAnyMemberInitializer()) {
5775 if (CheckRedundantInit(*
this,
Init, Members[Key]) ||
5776 CheckRedundantUnionInit(*
this,
Init, MemberUnions))
5778 }
else if (
Init->isBaseInitializer()) {
5780 if (CheckRedundantInit(*
this,
Init, Members[Key]))
5783 assert(
Init->isDelegatingInitializer());
5785 if (MemInits.size() != 1) {
5787 diag::err_delegating_initializer_alone)
5788 <<
Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
5804 DiagnoseUninitializedFields(*
this, Constructor);
5821 for (
auto *Field : ClassDecl->
fields()) {
5822 if (Field->isInvalidDecl())
5849 PDiag(diag::err_access_dtor_field)
5850 << Field->getDeclName()
5859 bool VisitVirtualBases = !ClassDecl->
isAbstract();
5866 if (Dtor && Dtor->
isUsed())
5867 VisitVirtualBases =
false;
5873 for (
const auto &
Base : ClassDecl->
bases()) {
5879 if (
Base.isVirtual()) {
5880 if (!VisitVirtualBases)
5882 DirectVirtualBases.insert(RT);
5899 PDiag(diag::err_access_dtor_base)
5900 <<
Base.getType() <<
Base.getSourceRange(),
5907 if (VisitVirtualBases)
5909 &DirectVirtualBases);
5914 llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases) {
5916 for (
const auto &VBase : ClassDecl->
vbases()) {
5921 if (DirectVirtualBases && DirectVirtualBases->count(RT))
5937 PDiag(diag::err_access_dtor_vbase)
5943 diag::err_access_dtor_vbase, 0, ClassDecl->
getLocation(),
5957 = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
5959 !ClassDecl || ClassDecl->isInvalidDecl()) {
5963 DiagnoseUninitializedFields(*
this, Constructor);
6018 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
6019 MEnd = FinalOverriders.end();
6023 SOEnd = M->second.end();
6024 SO != SOEnd; ++SO) {
6031 if (SO->second.size() != 1)
6034 if (!SO->second.front().Method->isPureVirtual())
6037 if (!SeenPureMethods.insert(SO->second.front().Method).second)
6040 Diag(SO->second.front().Method->getLocation(),
6041 diag::note_pure_virtual_function)
6042 << SO->second.front().Method->getDeclName() << RD->
getDeclName();
6052struct AbstractUsageInfo {
6060 AbstractType(S.Context.getCanonicalType(
6061 S.Context.getTypeDeclType(
Record))),
6064 void DiagnoseAbstractType() {
6073struct CheckAbstractUsage {
6074 AbstractUsageInfo &Info;
6077 CheckAbstractUsage(AbstractUsageInfo &Info,
const NamedDecl *Ctx)
6078 : Info(Info), Ctx(Ctx) {}
6082#define ABSTRACT_TYPELOC(CLASS, PARENT)
6083#define TYPELOC(CLASS, PARENT) \
6084 case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
6085#include "clang/AST/TypeLocNodes.def"
6091 for (
unsigned I = 0, E = TL.
getNumParams(); I != E; ++I) {
6106 for (
unsigned I = 0, E = TL.
getNumArgs(); I != E; ++I) {
6116#define CheckPolymorphic(Type) \
6117 void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
6118 Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
6133 return Visit(Next, Sel);
6143 T = Info.S.Context.getBaseElementType(
T);
6146 if (CT != Info.AbstractType)
return;
6151 Info.S.Diag(Ctx->
getLocation(), diag::err_array_of_abstract_type)
6154 Info.S.Diag(Ctx->
getLocation(), diag::err_abstract_type_in_decl)
6157 Info.DiagnoseAbstractType();
6163 CheckAbstractUsage(*
this, D).Visit(TL, Sel);
6198 for (
auto *D : RD->
decls()) {
6199 if (D->isImplicit())
continue;
6202 if (
auto *FD = dyn_cast<FriendDecl>(D)) {
6203 D = FD->getFriendDecl();
6208 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
6210 }
else if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(D)) {
6214 }
else if (
auto *FD = dyn_cast<FieldDecl>(D)) {
6217 }
else if (
auto *VD = dyn_cast<VarDecl>(D)) {
6219 }
else if (
auto *VTD = dyn_cast<VarTemplateDecl>(D)) {
6223 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
6225 }
else if (
auto *CTD = dyn_cast<ClassTemplateDecl>(D)) {
6236 assert(ClassAttr->
getKind() == attr::DLLExport);
6246 struct MarkingClassDllexported {
6257 ~MarkingClassDllexported() {
6267 if (!
Member->hasAttr<DLLExportAttr>())
6272 auto *VD = dyn_cast<VarDecl>(
Member);
6273 if (VD && VD->getStorageClass() ==
SC_Static &&
6277 auto *MD = dyn_cast<CXXMethodDecl>(
Member);
6281 if (MD->isUserProvided()) {
6291 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
6301 }
else if (MD->isExplicitlyDefaulted()) {
6310 }
else if (!MD->isTrivial() ||
6311 MD->isCopyAssignmentOperator() ||
6312 MD->isMoveAssignmentOperator()) {
6336 auto *CD = dyn_cast<CXXConstructorDecl>(
Member);
6337 if (!CD || !CD->isDefaultConstructor())
6339 auto *
Attr = CD->getAttr<DLLExportAttr>();
6345 if (!
Class->isDependentContext()) {
6352 if (LastExportedDefaultCtor) {
6354 diag::err_attribute_dll_ambiguous_default_ctor)
6356 S.
Diag(CD->getLocation(), diag::note_entity_declared_at)
6357 << CD->getDeclName();
6360 LastExportedDefaultCtor = CD;
6366 bool ErrorReported =
false;
6367 auto reportIllegalClassTemplate = [&ErrorReported](
Sema &S,
6371 S.
Diag(TD->getLocation(),
6372 diag::err_cuda_device_builtin_surftex_cls_template)
6374 ErrorReported =
true;
6379 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(
Class);
6382 diag::err_cuda_device_builtin_surftex_ref_decl)
6385 diag::note_cuda_device_builtin_surftex_should_be_template_class)
6389 TD = SD->getSpecializedTemplate();
6393 unsigned N = Params->
size();
6396 reportIllegalClassTemplate(S, TD);
6398 diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6401 if (N > 0 && !isa<TemplateTypeParmDecl>(Params->
getParam(0))) {
6402 reportIllegalClassTemplate(S, TD);
6404 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6408 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(1));
6409 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6410 reportIllegalClassTemplate(S, TD);
6412 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6420 bool ErrorReported =
false;
6421 auto reportIllegalClassTemplate = [&ErrorReported](
Sema &S,
6425 S.
Diag(TD->getLocation(),
6426 diag::err_cuda_device_builtin_surftex_cls_template)
6428 ErrorReported =
true;
6433 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(
Class);
6436 diag::err_cuda_device_builtin_surftex_ref_decl)
6439 diag::note_cuda_device_builtin_surftex_should_be_template_class)
6443 TD = SD->getSpecializedTemplate();
6447 unsigned N = Params->
size();
6450 reportIllegalClassTemplate(S, TD);
6452 diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6455 if (N > 0 && !isa<TemplateTypeParmDecl>(Params->
getParam(0))) {
6456 reportIllegalClassTemplate(S, TD);
6458 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6462 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(1));
6463 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6464 reportIllegalClassTemplate(S, TD);
6466 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6471 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(2));
6472 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6473 reportIllegalClassTemplate(S, TD);
6475 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6483 for (
auto *Method :
Class->methods()) {
6484 if (Method->isUserProvided())
6497 if (
auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(
Class)) {
6498 if (
Attr *TemplateAttr =
6499 getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
6500 auto *A = cast<InheritableAttr>(TemplateAttr->clone(
getASTContext()));
6501 A->setInherited(
true);
6516 (!
Class->isExternallyVisible() &&
Class->hasExternalFormalLinkage())) {
6517 Class->dropAttrs<DLLExportAttr, DLLImportAttr>();
6521 if (!
Class->isExternallyVisible()) {
6522 Diag(
Class->getLocation(), diag::err_attribute_dll_not_extern)
6523 <<
Class << ClassAttr;
6531 if (!isa<VarDecl>(
Member) && !isa<CXXMethodDecl>(
Member))
6538 diag::err_attribute_dll_member_of_dll_class)
6539 << MemberAttr << ClassAttr;
6540 Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
6541 Member->setInvalidDecl();
6545 if (
Class->getDescribedClassTemplate())
6550 const bool ClassExported = ClassAttr->
getKind() == attr::DLLExport;
6555 const bool PropagatedImport =
6557 cast<DLLImportAttr>(ClassAttr)->wasPropagatedToBaseTemplate();
6566 Class->dropAttr<DLLExportAttr>();
6600 auto *Ctor = dyn_cast<CXXConstructorDecl>(MD);
6609 (Ctor || isa<CXXDestructorDecl>(MD)) && MD->
isTrivial())
6616 if (VD && PropagatedImport)
6630 if (ClassExported) {
6642 Member->addAttr(NewAttr);
6652 "friend re-decl should not already have a DLLAttr");
6684 NewAttr->setInherited(
true);
6685 BaseTemplateSpec->
addAttr(NewAttr);
6689 if (
auto *ImportAttr = dyn_cast<DLLImportAttr>(NewAttr))
6690 ImportAttr->setPropagatedToBaseTemplate();
6711 Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
6716 diag::note_template_class_explicit_specialization_was_here)
6717 << BaseTemplateSpec;
6720 diag::note_template_class_instantiation_was_here)
6721 << BaseTemplateSpec;
6734 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
6746 if (MD->isCopyAssignmentOperator())
6749 if (MD->isMoveAssignmentOperator())
6752 if (isa<CXXDestructorDecl>(FD))
6760 case OO_ExclaimEqual:
6772 case OO_GreaterEqual:
6795 cast<CXXConstructorDecl>(FD));
6813 llvm_unreachable(
"Invalid special member.");
6831 bool CopyCtorIsTrivial =
false, CopyCtorIsTrivialForCall =
false;
6832 bool DtorIsTrivialForCall =
false;
6843 CopyCtorIsTrivial =
true;
6845 CopyCtorIsTrivialForCall =
true;
6849 if (CD->isCopyConstructor() && !CD->isDeleted() &&
6850 !CD->isIneligibleOrNotSelected()) {
6851 if (CD->isTrivial())
6852 CopyCtorIsTrivial =
true;
6853 if (CD->isTrivialForCall())
6854 CopyCtorIsTrivialForCall =
true;
6862 DtorIsTrivialForCall =
true;
6864 if (!DD->isDeleted() && DD->isTrivialForCall())
6865 DtorIsTrivialForCall =
true;
6869 if (CopyCtorIsTrivialForCall && DtorIsTrivialForCall)
6883 uint64_t TypeSize = isAArch64 ? 128 : 64;
6885 if (CopyCtorIsTrivial &&
6895 bool HasNonDeletedCopyOrMove =
false;
6901 HasNonDeletedCopyOrMove =
true;
6908 HasNonDeletedCopyOrMove =
true;
6916 if (MD->isDeleted() || MD->isIneligibleOrNotSelected())
6919 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
6920 if (CD && CD->isCopyOrMoveConstructor())
6921 HasNonDeletedCopyOrMove =
true;
6922 else if (!isa<CXXDestructorDecl>(MD))
6925 if (!MD->isTrivialForCall())
6929 return HasNonDeletedCopyOrMove;
6940 bool IssuedDiagnostic =
false;
6943 if (!IssuedDiagnostic) {
6945 IssuedDiagnostic =
true;
6947 S.
Diag(O->getLocation(), diag::note_overridden_virtual_function);
6950 return IssuedDiagnostic;
6964 if (
Record->isAbstract() && !
Record->isInvalidDecl()) {
6965 AbstractUsageInfo Info(*
this,
Record);
6972 if (!
Record->isInvalidDecl() && !
Record->isDependentType() &&
6973 !
Record->isAggregate() && !
Record->hasUserDeclaredConstructor() &&
6975 bool Complained =
false;
6976 for (
const auto *F :
Record->fields()) {
6977 if (F->hasInClassInitializer() || F->isUnnamedBitField())
6980 if (F->getType()->isReferenceType() ||
6981 (F->getType().isConstQualified() && F->getType()->isScalarType())) {
6983 Diag(
Record->getLocation(), diag::warn_no_constructor_for_refconst)
6984 << llvm::to_underlying(
Record->getTagKind()) <<
Record;
6988 Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
6989 << F->getType()->isReferenceType()
6990 << F->getDeclName();
6995 if (
Record->getIdentifier()) {
7008 if (((isa<FieldDecl>(D) || isa<UnresolvedUsingValueDecl>(D)) &&
7009 Record->hasUserDeclaredConstructor()) ||
7010 isa<IndirectFieldDecl>(D)) {
7011 Diag((*I)->getLocation(), diag::err_member_name_of_class)
7019 if (
Record->isPolymorphic() && !
Record->isDependentType()) {
7022 !
Record->hasAttr<FinalAttr>())
7027 if (
Record->isAbstract()) {
7028 if (FinalAttr *FA =
Record->getAttr<FinalAttr>()) {
7029 Diag(
Record->getLocation(), diag::warn_abstract_final_class)
7030 << FA->isSpelledAsSealed();
7036 if (!
Record->hasAttr<FinalAttr>()) {
7038 if (
const FinalAttr *FA = dtor->getAttr<FinalAttr>()) {
7039 Diag(FA->getLocation(), diag::warn_final_dtor_non_final_class)
7040 << FA->isSpelledAsSealed()
7043 (FA->isSpelledAsSealed() ?
" sealed" :
" final"));
7045 diag::note_final_dtor_non_final_class_silence)
7052 if (
Record->hasAttr<TrivialABIAttr>())
7057 bool HasTrivialABI =
Record->hasAttr<TrivialABIAttr>();
7060 Record->setHasTrivialSpecialMemberForCall();
7070 auto CheckCompletedMemberFunction = [&](
CXXMethodDecl *MD) {
7081 MD->
isDeleted() ? diag::err_deleted_override
7082 : diag::err_non_deleted_override,
7086 if (MD->isDefaulted() && MD->isDeleted())
7095 MD->isConsteval() ? diag::err_consteval_override
7096 : diag::err_non_consteval_override,
7098 return MD->isConsteval() !=
V->isConsteval();
7100 if (MD->isDefaulted() && MD->isDeleted())
7107 auto CheckForDefaultedFunction = [&](
FunctionDecl *FD) ->
bool {
7108 if (!FD || FD->
isInvalidDecl() || !FD->isExplicitlyDefaulted())
7114 DefaultedSecondaryComparisons.push_back(FD);
7124 bool Incomplete = CheckForDefaultedFunction(M);
7127 if (
Record->isDependentType())
7133 if (!M->isImplicit() && !M->isUserProvided()) {
7137 Record->finishedDefaultedOrDeletedMember(M);
7138 M->setTrivialForCall(
7141 Record->setTrivialForCallFlags(M);
7150 M->isUserProvided()) {
7151 M->setTrivialForCall(HasTrivialABI);
7152 Record->setTrivialForCallFlags(M);
7155 if (!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&
7156 M->hasAttr<DLLExportAttr>()) {
7162 M->dropAttr<DLLExportAttr>();
7164 if (M->hasAttr<DLLExportAttr>()) {
7174 M->isDefaulted() && M->isConstexpr() && M->size_overridden_methods())
7178 CheckCompletedMemberFunction(M);
7187 CompleteMemberFunction(Dtor);
7189 bool HasMethodWithOverrideControl =
false,
7190 HasOverridingMethodWithoutOverrideControl =
false;
7191 for (
auto *D :
Record->decls()) {
7192 if (
auto *M = dyn_cast<CXXMethodDecl>(D)) {
7195 if (!
Record->isDependentType()) {
7200 if (M->hasAttr<OverrideAttr>())
7201 HasMethodWithOverrideControl =
true;
7202 else if (M->size_overridden_methods() > 0)
7203 HasOverridingMethodWithoutOverrideControl =
true;
7206 if (!isa<CXXDestructorDecl>(M))
7207 CompleteMemberFunction(M);
7208 }
else if (
auto *F = dyn_cast<FriendDecl>(D)) {
7209 CheckForDefaultedFunction(
7210 dyn_cast_or_null<FunctionDecl>(F->getFriendDecl()));
7214 if (HasOverridingMethodWithoutOverrideControl) {
7215 bool HasInconsistentOverrideControl = HasMethodWithOverrideControl;
7216 for (
auto *M :
Record->methods())
7221 for (
FunctionDecl *FD : DefaultedSecondaryComparisons) {
7225 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD))
7226 CheckCompletedMemberFunction(MD);
7244 Diag(
Record->getLocation(), diag::warn_cxx_ms_struct);
7250 bool ClangABICompat4 =
7258 if (
Record->getArgPassingRestrictions() !=
7260 Record->setArgPassingRestrictions(
7269 Record->setParamDestroyedInCallee(
true);
7270 else if (
Record->hasNonTrivialDestructor())
7271 Record->setParamDestroyedInCallee(CanPass);
7280 if (
Record->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>())
7282 else if (
Record->hasAttr<CUDADeviceBuiltinTextureTypeAttr>())
7300 unsigned LHSQuals = 0;
7303 LHSQuals = FieldQuals;
7305 unsigned RHSQuals = FieldQuals;
7327 llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
7333 : S(S), UseLoc(UseLoc) {
7334 bool DiagnosedMultipleConstructedBases =
false;
7340 for (
auto *D : Shadow->
redecls()) {
7341 auto *DShadow = cast<ConstructorUsingShadowDecl>(D);
7342 auto *DNominatedBase = DShadow->getNominatedBaseClass();
7343 auto *DConstructedBase = DShadow->getConstructedBaseClass();
7345 InheritedFromBases.insert(
7346 std::make_pair(DNominatedBase->getCanonicalDecl(),
7347 DShadow->getNominatedBaseClassShadowDecl()));
7348 if (DShadow->constructsVirtualBase())
7349 InheritedFromBases.insert(
7350 std::make_pair(DConstructedBase->getCanonicalDecl(),
7351 DShadow->getConstructedBaseClassShadowDecl()));
7353 assert(DNominatedBase == DConstructedBase);
7358 if (!ConstructedBase) {
7359 ConstructedBase = DConstructedBase;
7360 ConstructedBaseIntroducer = D->getIntroducer();
7361 }
else if (ConstructedBase != DConstructedBase &&
7363 if (!DiagnosedMultipleConstructedBases) {
7364 S.
Diag(UseLoc, diag::err_ambiguous_inherited_constructor)
7367 diag::note_ambiguous_inherited_constructor_using)
7369 DiagnosedMultipleConstructedBases =
true;
7371 S.
Diag(D->getIntroducer()->getLocation(),
7372 diag::note_ambiguous_inherited_constructor_using)
7373 << DConstructedBase;
7377 if (DiagnosedMultipleConstructedBases)
7384 std::pair<CXXConstructorDecl *, bool>
7386 auto It = InheritedFromBases.find(
Base->getCanonicalDecl());
7387 if (It == InheritedFromBases.end())
7388 return std::make_pair(
nullptr,
false);
7392 return std::make_pair(
7394 It->second->constructsVirtualBase());
7397 return std::make_pair(Ctor,
false);
7414 if (InheritedCtor) {
7417 Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;
7419 return BaseCtor->isConstexpr();
7487 if (Ctor && ClassDecl->
isUnion())
7507 for (
const auto &B : ClassDecl->
bases()) {
7513 InheritedCtor, Inherited))
7526 for (
const auto *F : ClassDecl->
fields()) {
7527 if (F->isInvalidDecl())
7530 F->hasInClassInitializer())
7534 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
7537 ConstArg && !F->isMutable()))
7552struct ComputingExceptionSpec {
7563 ~ComputingExceptionSpec() {
7583 if (DFK.isSpecialMember())
7585 S,
Loc, cast<CXXMethodDecl>(FD), DFK.asSpecialMember(),
nullptr);
7586 if (DFK.isComparison())
7588 DFK.asComparison());
7590 auto *CD = cast<CXXConstructorDecl>(FD);
7591 assert(CD->getInheritedConstructor() &&
7592 "only defaulted functions and inherited constructors have implicit "
7595 S,
Loc, CD->getInheritedConstructor().getShadowDecl());
7622 auto ESI = IES.getExceptionSpec();
7654 "not an explicitly-defaulted special member");
7664 bool HadError =
false;
7677 bool ShouldDeleteForTypeMismatch =
false;
7678 unsigned ExpectedParams = 1;
7690 if (DeleteOnTypeMismatch)
7691 ShouldDeleteForTypeMismatch =
true;
7701 bool CanHaveConstParam =
false;
7711 ReturnType =
Type->getReturnType();
7722 Diag(MD->
getLocation(), diag::err_defaulted_special_member_return_type)
7724 << ExpectedReturnType;
7730 if (DeleteOnTypeMismatch)
7731 ShouldDeleteForTypeMismatch =
true;
7748 if (DeleteOnTypeMismatch)
7749 ShouldDeleteForTypeMismatch =
true;
7752 diag::err_defaulted_special_member_explicit_object_mismatch)
7765 bool HasConstParam =
false;
7772 if (DeleteOnTypeMismatch)
7773 ShouldDeleteForTypeMismatch =
true;
7776 diag::err_defaulted_special_member_volatile_param)
7777 << llvm::to_underlying(CSM);
7782 if (HasConstParam && !CanHaveConstParam) {
7783 if (DeleteOnTypeMismatch)
7784 ShouldDeleteForTypeMismatch =
true;
7788 diag::err_defaulted_special_member_copy_const_param)
7794 diag::err_defaulted_special_member_move_const_param)
7799 }
else if (ExpectedParams) {
7803 "unexpected non-ref argument");
7832 : isa<CXXConstructorDecl>(MD))) &&
7837 diag::err_incorrect_defaulted_constexpr_with_vb)
7838 << llvm::to_underlying(CSM);
7839 for (
const auto &I : RD->
vbases())
7840 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here);
7859 if (!
Type->hasExceptionSpec()) {
7877 << llvm::to_underlying(CSM);
7878 if (ShouldDeleteForTypeMismatch) {
7880 << llvm::to_underlying(CSM);
7884 Diag(DefaultLoc, diag::note_replace_equals_default_to_delete)
7888 if (ShouldDeleteForTypeMismatch && !HadError) {
7890 diag::warn_cxx17_compat_defaulted_method_type_mismatch)
7891 << llvm::to_underlying(CSM);
7898 << llvm::to_underlying(CSM);
7899 assert(!ShouldDeleteForTypeMismatch &&
"deleted non-first decl");
7921template<
typename Derived,
typename ResultList,
typename Result,
7923class DefaultedComparisonVisitor {
7928 DefaultedComparisonKind DCK)
7929 : S(S), RD(RD), FD(FD), DCK(DCK) {
7933 Fns.assign(Info->getUnqualifiedLookups().begin(),
7934 Info->getUnqualifiedLookups().end());
7938 ResultList visit() {
7946 case DefaultedComparisonKind::None:
7947 llvm_unreachable(
"not a defaulted comparison");
7949 case DefaultedComparisonKind::Equal:
7950 case DefaultedComparisonKind::ThreeWay:
7951 getDerived().visitSubobjects(Results, RD, ParamLvalType.
getQualifiers());
7954 case DefaultedComparisonKind::NotEqual:
7955 case DefaultedComparisonKind::Relational:
7956 Results.add(getDerived().visitExpandedSubobject(
7957 ParamLvalType, getDerived().getCompleteObject()));
7960 llvm_unreachable(
"");
7964 Derived &getDerived() {
return static_cast<Derived&
>(*this); }
7975 if (Results.add(getDerived().visitSubobject(
7977 getDerived().getBase(&
Base))))
7984 if (
Field->isUnnamedBitField())
7987 if (
Field->isAnonymousStructOrUnion()) {
7988 if (visitSubobjects(Results,
Field->getType()->getAsCXXRecordDecl(),
7996 if (
Field->isMutable())
8001 if (Results.add(getDerived().visitSubobject(
8002 FieldType, getDerived().getField(Field))))
8010 Result visitSubobject(
QualType Type, Subobject Subobj) {
8013 if (
auto *CAT = dyn_cast_or_null<ConstantArrayType>(AT))
8014 return getDerived().visitSubobjectArray(CAT->getElementType(),
8015 CAT->getSize(), Subobj);
8016 return getDerived().visitExpandedSubobject(
Type, Subobj);
8019 Result visitSubobjectArray(
QualType Type,
const llvm::APInt &Size,
8021 return getDerived().visitSubobject(
Type, Subobj);
8028 DefaultedComparisonKind DCK;
8034struct DefaultedComparisonInfo {
8039 static DefaultedComparisonInfo deleted() {
8040 DefaultedComparisonInfo
Deleted;
8045 bool add(
const DefaultedComparisonInfo &R) {
8055struct DefaultedComparisonSubobject {
8063class DefaultedComparisonAnalyzer
8064 :
public DefaultedComparisonVisitor<DefaultedComparisonAnalyzer,
8065 DefaultedComparisonInfo,
8066 DefaultedComparisonInfo,
8067 DefaultedComparisonSubobject> {
8069 enum DiagnosticKind { NoDiagnostics, ExplainDeleted, ExplainConstexpr };
8072 DiagnosticKind Diagnose;
8075 using Base = DefaultedComparisonVisitor;
8076 using Result = DefaultedComparisonInfo;
8077 using Subobject = DefaultedComparisonSubobject;
8082 DefaultedComparisonKind DCK,
8083 DiagnosticKind Diagnose = NoDiagnostics)
8084 :
Base(S, RD, FD, DCK), Diagnose(Diagnose) {}
8087 if ((DCK == DefaultedComparisonKind::Equal ||
8088 DCK == DefaultedComparisonKind::ThreeWay) &&
8093 if (Diagnose == ExplainDeleted) {
8097 return Result::deleted();
8100 return Base::visit();
8104 Subobject getCompleteObject() {
8105 return Subobject{Subobject::CompleteObject, RD, FD->
getLocation()};
8109 return Subobject{Subobject::Base,
Base->getType()->getAsCXXRecordDecl(),
8110 Base->getBaseTypeLoc()};
8114 return Subobject{Subobject::Member,
Field,
Field->getLocation()};
8117 Result visitExpandedSubobject(
QualType Type, Subobject Subobj) {
8122 if (Diagnose == ExplainDeleted) {
8123 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_reference_member)
8126 return Result::deleted();
8131 Expr *Args[] = {&Xi, &Xi};
8135 assert(OO !=
OO_None &&
"not an overloaded operator!");
8136 return visitBinaryOperator(OO, Args, Subobj);
8150 !SpaceshipCandidates));
8155 CandidateSet.exclude(FD);
8157 if (Args[0]->getType()->isOverloadableType())
8168 switch (CandidateSet.BestViableFunction(S, FD->
getLocation(), Best)) {
8174 if ((DCK == DefaultedComparisonKind::NotEqual ||
8175 DCK == DefaultedComparisonKind::Relational) &&
8176 !Best->RewriteKind) {
8177 if (Diagnose == ExplainDeleted) {
8178 if (Best->Function) {
8179 S.
Diag(Best->Function->getLocation(),
8180 diag::note_defaulted_comparison_not_rewritten_callee)
8183 assert(Best->Conversions.size() == 2 &&
8184 Best->Conversions[0].isUserDefined() &&
8185 "non-user-defined conversion from class to built-in "
8187 S.
Diag(Best->Conversions[0]
8188 .UserDefined.FoundConversionFunction.getDecl()
8190 diag::note_defaulted_comparison_not_rewritten_conversion)
8194 return Result::deleted();
8204 CXXRecordDecl *ArgClass = Args[0]->getType()->getAsCXXRecordDecl();
8205 if (ArgClass && Best->FoundDecl.getDecl() &&
8206 Best->FoundDecl.getDecl()->isCXXClassMember()) {
8207 QualType ObjectType = Subobj.Kind == Subobject::Member
8208 ? Args[0]->getType()
8211 ArgClass, Best->FoundDecl, ObjectType, Subobj.Loc,
8212 Diagnose == ExplainDeleted
8213 ? S.
PDiag(diag::note_defaulted_comparison_inaccessible)
8214 << FD << Subobj.Kind << Subobj.Decl
8216 return Result::deleted();
8219 bool NeedsDeducing =
8227 assert(!BestFD->isDeleted() &&
"wrong overload resolution result");
8229 if (Diagnose == ExplainConstexpr && !BestFD->isConstexpr()) {
8230 if (Subobj.Kind != Subobject::CompleteObject)
8231 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_not_constexpr)
8232 << Subobj.
Kind << Subobj.Decl;
8233 S.
Diag(BestFD->getLocation(),
8234 diag::note_defaulted_comparison_not_constexpr_here);
8236 return Result::deleted();
8238 R.Constexpr &= BestFD->isConstexpr();
8240 if (NeedsDeducing) {
8245 if (BestFD->getReturnType()->isUndeducedType() &&
8251 if (Diagnose == NoDiagnostics) {
8254 diag::err_defaulted_comparison_cannot_deduce_undeduced_auto)
8255 << Subobj.
Kind << Subobj.Decl;
8258 diag::note_defaulted_comparison_cannot_deduce_undeduced_auto)
8259 << Subobj.
Kind << Subobj.Decl;
8260 S.
Diag(BestFD->getLocation(),
8261 diag::note_defaulted_comparison_cannot_deduce_callee)
8262 << Subobj.
Kind << Subobj.Decl;
8264 return Result::deleted();
8267 BestFD->getCallResultType());
8269 if (Diagnose == ExplainDeleted) {
8270 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_cannot_deduce)
8271 << Subobj.
Kind << Subobj.Decl
8272 << BestFD->getCallResultType().withoutLocalFastQualifiers();
8273 S.
Diag(BestFD->getLocation(),
8274 diag::note_defaulted_comparison_cannot_deduce_callee)
8275 << Subobj.
Kind << Subobj.Decl;
8277 return Result::deleted();
8279 R.Category = Info->Kind;
8282 QualType T = Best->BuiltinParamTypes[0];
8283 assert(
T == Best->BuiltinParamTypes[1] &&
8284 "builtin comparison for different types?");
8285 assert(Best->BuiltinParamTypes[2].isNull() &&
8286 "invalid builtin comparison");
8288 if (NeedsDeducing) {
8289 std::optional<ComparisonCategoryType> Cat =
8291 assert(Cat &&
"no category for builtin comparison?");
8302 if (Diagnose == ExplainDeleted) {
8305 Kind = OO == OO_EqualEqual ? 1 : 2;
8306 CandidateSet.NoteCandidates(
8308 Subobj.Loc, S.
PDiag(diag::note_defaulted_comparison_ambiguous)
8309 << FD << Kind << Subobj.Kind << Subobj.Decl),
8312 R = Result::deleted();
8316 if (Diagnose == ExplainDeleted) {
8317 if ((DCK == DefaultedComparisonKind::NotEqual ||
8318 DCK == DefaultedComparisonKind::Relational) &&
8319 !Best->RewriteKind) {
8320 S.
Diag(Best->Function->getLocation(),
8321 diag::note_defaulted_comparison_not_rewritten_callee)
8325 diag::note_defaulted_comparison_calls_deleted)
8326 << FD << Subobj.
Kind << Subobj.Decl;
8330 R = Result::deleted();
8336 if (OO == OO_Spaceship &&
8340 if (!R.add(visitBinaryOperator(OO_EqualEqual, Args, Subobj,
8342 R.add(visitBinaryOperator(OO_Less, Args, Subobj, &CandidateSet));
8346 if (Diagnose == ExplainDeleted) {
8347 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_no_viable_function)
8348 << FD << (OO == OO_EqualEqual || OO == OO_ExclaimEqual)
8349 << Subobj.
Kind << Subobj.Decl;
8353 if (SpaceshipCandidates) {
8354 SpaceshipCandidates->NoteCandidates(
8359 diag::note_defaulted_comparison_no_viable_function_synthesized)
8360 << (OO == OO_EqualEqual ? 0 : 1);
8363 CandidateSet.NoteCandidates(
8368 R = Result::deleted();
8377struct StmtListResult {
8378 bool IsInvalid =
false;
8382 IsInvalid |= S.isInvalid();
8385 Stmts.push_back(S.get());
8392class DefaultedComparisonSynthesizer
8393 :
public DefaultedComparisonVisitor<DefaultedComparisonSynthesizer,
8394 StmtListResult, StmtResult,
8395 std::pair<ExprResult, ExprResult>> {
8397 unsigned ArrayDepth = 0;
8400 using Base = DefaultedComparisonVisitor;
8401 using ExprPair = std::pair<ExprResult, ExprResult>;
8406 DefaultedComparisonKind DCK,
8408 :
Base(S, RD, FD, DCK),
Loc(BodyLoc) {}
8414 StmtListResult Stmts = visit();
8415 if (Stmts.IsInvalid)
8420 case DefaultedComparisonKind::None:
8421 llvm_unreachable(
"not a defaulted comparison");
8423 case DefaultedComparisonKind::Equal: {
8432 auto OldStmts = std::move(Stmts.Stmts);
8433 Stmts.Stmts.clear();
8436 auto FinishCmp = [&] {
8437 if (
Expr *Prior = CmpSoFar.
get()) {
8439 if (RetVal.
isUnset() && Stmts.Stmts.empty())
8442 else if (Stmts.add(buildIfNotCondReturnFalse(Prior)))
8448 for (
Stmt *EAsStmt : llvm::reverse(OldStmts)) {
8449 Expr *E = dyn_cast<Expr>(EAsStmt);
8452 if (FinishCmp() || Stmts.add(EAsStmt))
8467 std::reverse(Stmts.Stmts.begin(), Stmts.Stmts.end());
8474 case DefaultedComparisonKind::ThreeWay: {
8478 ComparisonCategoryType::StrongOrdering,
Loc,
8479 Sema::ComparisonCategoryUsage::DefaultedOperator);
8485 RetVal = getDecl(EqualVD);
8488 RetVal = buildStaticCastToR(RetVal.
get());
8492 case DefaultedComparisonKind::NotEqual:
8493 case DefaultedComparisonKind::Relational:
8494 RetVal = cast<Expr>(Stmts.Stmts.pop_back_val());
8520 ExprPair getCompleteObject() {
8523 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD);
8530 LHS = getParam(Param++);
8538 ExprPair Obj = getCompleteObject();
8539 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8549 ExprPair Obj = getCompleteObject();
8550 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8573 assert(!False.
isInvalid() &&
"should never fail");
8580 Sema::ConditionKind::Boolean),
8593 llvm::raw_svector_ostream OS(Str);
8594 OS <<
"i" << ArrayDepth;
8605 auto IterRef = [&] {
8609 assert(!Ref.
isInvalid() &&
"can't reference our own variable?");
8615 Loc, BO_NE, IterRef(),
8617 assert(!Cond.
isInvalid() &&
"should never fail");
8621 assert(!
Inc.isInvalid() &&
"should never fail");
8629 Subobj.first = Index(Subobj.first);
8630 Subobj.second = Index(Subobj.second);
8643 if (
Expr *ElemCmp = dyn_cast<Expr>(Substmt.
get())) {
8644 assert(DCK == DefaultedComparisonKind::Equal &&
8645 "should have non-expression statement");
8646 Substmt = buildIfNotCondReturnFalse(ElemCmp);
8654 Sema::ConditionKind::Boolean),
8660 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8668 Obj.second.get(),
true,
8676 case DefaultedComparisonKind::None:
8677 llvm_unreachable(
"not a defaulted comparison");
8679 case DefaultedComparisonKind::Equal:
8687 case DefaultedComparisonKind::ThreeWay: {
8692 Op = buildStaticCastToR(Op.
get());
8717 if (
Comp.isInvalid())
8720 nullptr,
Loc,
Comp.get(), Sema::ConditionKind::Boolean);
8725 VDRef = getDecl(VD);
8738 case DefaultedComparisonKind::NotEqual:
8739 case DefaultedComparisonKind::Relational:
8744 llvm_unreachable(
"");
8750 assert(!R->
isUndeducedType() &&
"type should have been deduced already");
8768 Self.LookupOverloadedOperatorName(OO, S, Operators);
8781 if (Op == OO_Spaceship) {
8782 Lookup(OO_ExclaimEqual);
8784 Lookup(OO_EqualEqual);
8812 bool IsMethod = isa<CXXMethodDecl>(FD);
8814 auto *MD = cast<CXXMethodDecl>(FD);
8815 assert(!MD->
isStatic() &&
"comparison function cannot be a static member");
8825 FPT->getParamTypes(), EPI));
8832 if (!
T.isConstQualified()) {
8841 InsertLoc =
Loc.getRParenLoc();
8846 Diag(
Loc, diag::err_defaulted_comparison_non_const)
8855 FPT->getParamTypes(), EPI));
8866 FPT->getParamTypes(), EPI));
8872 (IsMethod ? 1 : 2)) {
8876 <<
int(IsMethod) <<
int(DCK);
8882 if (Param->isExplicitObjectParameter())
8884 QualType ParmTy = Param->getType();
8889 bool Ok = !IsMethod;
8894 CTy = Ref->getPointeeType();
8905 }
else if (
auto *CRD = CTy->getAsRecordDecl()) {
8906 RD = cast<CXXRecordDecl>(CRD);
8922 <<
int(DCK) << ParmTy << RefTy <<
int(!IsMethod) << PlainTy
8923 << Param->getSourceRange();
8925 assert(!IsMethod &&
"should know expected type for method");
8927 diag::err_defaulted_comparison_param_unknown)
8928 <<
int(DCK) << ParmTy << Param->getSourceRange();
8934 Diag(FD->
getLocation(), diag::err_defaulted_comparison_param_mismatch)
8936 << ParmTy << Param->getSourceRange();
8941 assert(RD &&
"must have determined class");
8950 diag::err_defaulted_comparison_not_friend,
int(DCK),
8955 return FD->getCanonicalDecl() ==
8956 F->getFriendDecl()->getCanonicalDecl();
8959 <<
int(DCK) <<
int(0) << RD;
8971 Diag(FD->
getLocation(), diag::err_defaulted_comparison_return_type_not_bool)
8981 RT->getContainedDeducedType() &&
8983 RT->getContainedAutoType()->isConstrained())) {
8985 diag::err_defaulted_comparison_deduced_return_type_not_auto)
8997 DefaultedComparisonInfo Info =
8998 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK).visit();
9012 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK,
9013 DefaultedComparisonAnalyzer::ExplainDeleted)
9024 diag::note_previous_declaration);
9036 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK,
9037 DefaultedComparisonAnalyzer::ExplainDeleted)
9087 Diag(FD->
getBeginLoc(), diag::err_defaulted_comparison_constexpr_mismatch)
9089 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK,
9090 DefaultedComparisonAnalyzer::ExplainConstexpr)
9111 EPI.ExceptionSpec.SourceDecl = FD;
9113 FPT->getParamTypes(), EPI));
9128 EqualEqual->setImplicit();
9143 Scope.addContextNote(UseLoc);
9150 CXXRecordDecl *RD = PT.getNonReferenceType()->getAsCXXRecordDecl();
9154 DefaultedComparisonSynthesizer(*
this, RD, FD, DCK, BodyLoc).build();
9168 L->CompletedImplicitDefinition(FD);
9175 ComputingExceptionSpec CES(S, FD,
Loc);
9202 DefaultedComparisonSynthesizer(S, RD, FD, DCK, BodyLoc).build();
9224 for (
auto &Check : Overriding)
9236template<
typename Derived>
9237struct SpecialMemberVisitor {
9244 bool IsConstructor =
false, IsAssignment =
false, ConstArg =
false;
9248 : S(S), MD(MD), CSM(CSM), ICI(ICI) {
9250 case CXXSpecialMemberKind::DefaultConstructor:
9251 case CXXSpecialMemberKind::CopyConstructor:
9252 case CXXSpecialMemberKind::MoveConstructor:
9253 IsConstructor =
true;
9255 case CXXSpecialMemberKind::CopyAssignment:
9256 case CXXSpecialMemberKind::MoveAssignment:
9257 IsAssignment =
true;
9259 case CXXSpecialMemberKind::Destructor:
9261 case CXXSpecialMemberKind::Invalid:
9262 llvm_unreachable(
"invalid special member kind");
9268 ConstArg = RT->getPointeeType().isConstQualified();
9272 Derived &getDerived() {
return static_cast<Derived&
>(*this); }
9275 bool isMove()
const {
9276 return CSM == CXXSpecialMemberKind::MoveConstructor ||
9277 CSM == CXXSpecialMemberKind::MoveAssignment;
9282 unsigned Quals,
bool IsMutable) {
9284 ConstArg && !IsMutable);
9292 assert(CSM == CXXSpecialMemberKind::DefaultConstructor);
9294 cast<CXXConstructorDecl>(MD)->getInheritedConstructor().getConstructor();
9301 typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
9308 return B->getBaseTypeLoc();
9310 return Subobj.get<
FieldDecl*>()->getLocation();
9315 VisitNonVirtualBases,
9320 VisitPotentiallyConstructedBases,
9326 bool visit(BasesToVisit Bases) {
9329 if (Bases == VisitPotentiallyConstructedBases)
9330 Bases = RD->
isAbstract() ? VisitNonVirtualBases : VisitAllBases;
9332 for (
auto &B : RD->
bases())
9333 if ((Bases == VisitDirectBases || !B.isVirtual()) &&
9334 getDerived().visitBase(&B))
9337 if (Bases == VisitAllBases)
9338 for (
auto &B : RD->
vbases())
9339 if (getDerived().visitBase(&B))
9342 for (
auto *F : RD->
fields())
9343 if (!F->isInvalidDecl() && !F->isUnnamedBitField() &&
9344 getDerived().visitField(F))
9353struct SpecialMemberDeletionInfo
9354 : SpecialMemberVisitor<SpecialMemberDeletionInfo> {
9359 bool AllFieldsAreConst;
9364 : SpecialMemberVisitor(S, MD, CSM, ICI), Diagnose(Diagnose),
9365 Loc(MD->getLocation()), AllFieldsAreConst(
true) {}
9370 return ICI ? CXXSpecialMemberKind::Invalid : CSM;
9376 bool visitField(
FieldDecl *Field) {
return shouldDeleteForField(Field); }
9379 bool shouldDeleteForField(
FieldDecl *FD);
9380 bool shouldDeleteForAllConstMembers();
9382 bool shouldDeleteForClassSubobject(
CXXRecordDecl *Class, Subobject Subobj,
9384 bool shouldDeleteForSubobjectCall(Subobject Subobj,
9386 bool IsDtorCallInCtor);
9394bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
9415bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
9417 bool IsDtorCallInCtor) {
9424 DiagKind = !
Decl ? 0 : 1;
9427 else if (!isAccessible(Subobj,
Decl))
9429 else if (!IsDtorCallInCtor && Field &&
Field->getParent()->isUnion() &&
9430 !
Decl->isTrivial()) {
9442 const auto *RD = cast<CXXRecordDecl>(
Field->getParent());
9456 diag::note_deleted_special_member_class_subobject)
9457 << llvm::to_underlying(getEffectiveCSM()) << MD->
getParent()
9458 <<
true <<
Field << DiagKind << IsDtorCallInCtor
9463 diag::note_deleted_special_member_class_subobject)
9464 << llvm::to_underlying(getEffectiveCSM()) << MD->
getParent()
9465 <<
false <<
Base->getType() << DiagKind
9466 << IsDtorCallInCtor <<
false;
9479bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
9482 bool IsMutable =
Field &&
Field->isMutable();
9499 Field->hasInClassInitializer()) &&
9500 shouldDeleteForSubobjectCall(Subobj, lookupIn(
Class, Quals, IsMutable),
9507 if (IsConstructor) {
9510 false,
false,
false,
false);
9511 if (shouldDeleteForSubobjectCall(Subobj, SMOR,
true))
9518bool SpecialMemberDeletionInfo::shouldDeleteForVariantObjCPtrMember(
9533 auto *ParentClass = cast<CXXRecordDecl>(FD->
getParent());
9534 S.
Diag(FD->
getLocation(), diag::note_deleted_special_member_class_subobject)
9535 << llvm::to_underlying(getEffectiveCSM()) << ParentClass
9536 <<
true << FD << 4 <<
false
9554 if (
auto *BaseCtor = SMOR.
getMethod()) {
9559 if (BaseCtor->isDeleted() &&
Diagnose) {
9561 diag::note_deleted_special_member_class_subobject)
9562 << llvm::to_underlying(getEffectiveCSM()) << MD->
getParent()
9563 <<
false <<
Base->getType() << 1
9567 return BaseCtor->isDeleted();
9569 return shouldDeleteForClassSubobject(BaseClass,
Base, 0);
9574bool SpecialMemberDeletionInfo::shouldDeleteForField(
FieldDecl *FD) {
9578 if (inUnion() && shouldDeleteForVariantObjCPtrMember(FD, FieldType))
9586 S.
Diag(FD->
getLocation(), diag::note_deleted_default_ctor_uninit_field)
9587 << !!ICI << MD->
getParent() << FD << FieldType << 0;
9597 S.
Diag(FD->
getLocation(), diag::note_deleted_default_ctor_uninit_field)
9603 AllFieldsAreConst =
false;
9609 S.
Diag(FD->
getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
9613 }
else if (IsAssignment) {
9618 << isMove() << MD->
getParent() << FD << FieldType << 0;
9633 if (!inUnion() && FieldRecord->
isUnion() &&
9635 bool AllVariantFieldsAreConst =
true;
9638 for (
auto *UI : FieldRecord->
fields()) {
9641 if (shouldDeleteForVariantObjCPtrMember(&*UI, UnionFieldType))
9645 AllVariantFieldsAreConst =
false;
9648 if (UnionFieldRecord &&
9649 shouldDeleteForClassSubobject(UnionFieldRecord, UI,
9656 AllVariantFieldsAreConst && !FieldRecord->
field_empty()) {
9659 diag::note_deleted_default_ctor_all_const)
9670 if (shouldDeleteForClassSubobject(FieldRecord, FD,
9681bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
9685 AllFieldsAreConst) {
9686 bool AnyFields =
false;
9688 if ((AnyFields = !F->isUnnamedBitField()))
9694 diag::note_deleted_default_ctor_all_const)
9747 bool DeletesOnlyMatchingCopy =
9752 (!DeletesOnlyMatchingCopy ||
9757 for (
auto *I : RD->
ctors()) {
9758 if (I->isMoveConstructor()) {
9759 UserDeclaredMove = I;
9763 assert(UserDeclaredMove);
9765 (!DeletesOnlyMatchingCopy ||
9770 for (
auto *I : RD->
methods()) {
9771 if (I->isMoveAssignmentOperator()) {
9772 UserDeclaredMove = I;
9776 assert(UserDeclaredMove);
9779 if (UserDeclaredMove) {
9781 diag::note_deleted_copy_user_declared_move)
9799 OperatorDelete,
false)) {
9806 SpecialMemberDeletionInfo SMI(*
this, MD, CSM, ICI,
Diagnose);
9814 if (SMI.visit(SMI.IsAssignment ? SMI.VisitDirectBases
9815 : SMI.VisitPotentiallyConstructedBases))
9818 if (SMI.shouldDeleteForAllConstMembers())
9842 assert(DFK &&
"not a defaultable function");
9849 DefaultedComparisonAnalyzer(
9851 DFK.
asComparison(), DefaultedComparisonAnalyzer::ExplainDeleted)
9873 *Selected =
nullptr;
9877 llvm_unreachable(
"not a special member");
9895 for (
auto *CI : RD->
ctors()) {
9896 if (!CI->isDefaultConstructor())
9903 *Selected = DefCtor;
9936 }
else if (!Selected) {
9944 goto NeedOverloadResolution;
9954 }
else if (!Selected) {
9959 goto NeedOverloadResolution;
9963 NeedOverloadResolution:
9992 llvm_unreachable(
"unknown special method kind");
9996 for (
auto *CI : RD->
ctors())
9997 if (!CI->isImplicit())
10004 dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
10035 ConstRHS, TAH,
Diagnose ? &Selected :
nullptr))
10043 S.
Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
10046 S.
Diag(CD->getLocation(), diag::note_user_declared_ctor);
10047 }
else if (!Selected)
10048 S.
Diag(SubobjLoc, diag::note_nontrivial_no_copy)
10056 S.
Diag(SubobjLoc, diag::note_nontrivial_user_provided)
10062 S.
Diag(SubobjLoc, diag::note_nontrivial_subobject)
10080 for (
const auto *FI : RD->
fields()) {
10081 if (FI->isInvalidDecl() || FI->isUnnamedBitField())
10087 if (FI->isAnonymousStructOrUnion()) {
10099 FI->hasInClassInitializer()) {
10101 S.
Diag(FI->getLocation(), diag::note_nontrivial_default_member_init)
10112 S.
Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
10117 bool ConstRHS = ConstArg && !FI->isMutable();
10145 "not special enough");
10149 bool ConstArg =
false;
10177 ClangABICompat14)) {
10207 llvm_unreachable(
"not a special member");
10213 diag::note_nontrivial_default_arg)
10232 for (
const auto &BI : RD->
bases())
10274 Diag(BS.
getBeginLoc(), diag::note_nontrivial_has_virtual) << RD << 1;
10279 for (
const auto *MI : RD->
methods()) {
10280 if (MI->isVirtual()) {
10282 Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
10287 llvm_unreachable(
"dynamic class with no vbases and no virtual functions");
10295struct FindHiddenVirtualMethod {
10303 static bool CheckMostOverridenMethods(
10305 const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
10309 if (CheckMostOverridenMethods(O, Methods))
10325 bool foundSameNameMethod =
false;
10332 foundSameNameMethod =
true;
10349 if (!CheckMostOverridenMethods(MD, OverridenAndUsingBaseMethods))
10350 overloadedMethods.push_back(MD);
10354 if (foundSameNameMethod)
10355 OverloadedMethods.append(overloadedMethods.begin(),
10356 overloadedMethods.end());
10357 return foundSameNameMethod;
10364 llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
10382 FindHiddenVirtualMethod FHVM;
10393 ND = shad->getTargetDecl();
10399 OverloadedMethods = FHVM.OverloadedMethods;
10404 for (
unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
10407 diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
10424 if (!OverloadedMethods.empty()) {
10426 << MD << (OverloadedMethods.size() > 1);
10433 auto PrintDiagAndRemoveAttr = [&](
unsigned N) {
10436 Diag(RD.
getAttr<TrivialABIAttr>()->getLocation(),
10437 diag::ext_cannot_use_trivial_abi) << &RD;
10438 Diag(RD.
getAttr<TrivialABIAttr>()->getLocation(),
10439 diag::note_cannot_use_trivial_abi_reason) << &RD << N;
10445 auto HasNonDeletedCopyOrMoveConstructor = [&]() {
10457 if (CD->isCopyOrMoveConstructor() && !CD->isDeleted())
10462 if (!HasNonDeletedCopyOrMoveConstructor()) {
10463 PrintDiagAndRemoveAttr(0);
10469 PrintDiagAndRemoveAttr(1);
10473 for (
const auto &B : RD.
bases()) {
10476 if (!B.getType()->isDependentType() &&
10477 !B.getType()->getAsCXXRecordDecl()->canPassInRegisters()) {
10478 PrintDiagAndRemoveAttr(2);
10482 if (B.isVirtual()) {
10483 PrintDiagAndRemoveAttr(3);
10488 for (
const auto *FD : RD.
fields()) {
10493 PrintDiagAndRemoveAttr(4);
10498 if (!RT->isDependentType() &&
10499 !cast<CXXRecordDecl>(RT->getDecl())->canPassInRegisters()) {
10500 PrintDiagAndRemoveAttr(5);
10515 if (AL.getKind() != ParsedAttr::AT_Visibility)
10518 Diag(AL.getLoc(), diag::warn_attribute_after_definition_ignored) << AL;
10526 LBrac, RBrac, AttrList);
10543 FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Friend->getFriendDecl());
10548 Spaceships.clear();
10554 Spaceships.push_back(FD);
10563 if (
auto *FD = dyn_cast<FunctionDecl>(ND))
10564 if (FD->isExplicitlyDefaulted())
10565 Spaceships.push_back(FD);
10665 DefaultedSpaceships);
10666 for (
auto *FD : DefaultedSpaceships)
10673 llvm::function_ref<
Scope *()> EnterScope) {
10681 DeclContext *LookupDC = dyn_cast<DeclContext>(D);
10684 for (
unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
10685 ParameterLists.push_back(DD->getTemplateParameterList(i));
10689 ParameterLists.push_back(FTD->getTemplateParameters());
10690 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
10694 ParameterLists.push_back(VTD->getTemplateParameters());
10695 else if (
auto *PSD = dyn_cast<VarTemplatePartialSpecializationDecl>(D))
10696 ParameterLists.push_back(PSD->getTemplateParameters());
10698 }
else if (
TagDecl *TD = dyn_cast<TagDecl>(D)) {
10699 for (
unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
10700 ParameterLists.push_back(TD->getTemplateParameterList(i));
10704 ParameterLists.push_back(CTD->getTemplateParameters());
10705 else if (
auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
10706 ParameterLists.push_back(PSD->getTemplateParameters());
10711 unsigned Count = 0;
10712 Scope *InnermostTemplateScope =
nullptr;
10716 if (Params->size() == 0)
10719 InnermostTemplateScope = EnterScope();
10721 if (Param->getDeclName()) {
10722 InnermostTemplateScope->
AddDecl(Param);
10730 if (InnermostTemplateScope) {
10731 assert(LookupDC &&
"no enclosing DeclContext for template lookup");
10739 if (!RecordD)
return;
10746 if (!RecordD)
return;
10820 bool DiagOccured =
false;
10822 [DiagID, &S, &DiagOccured](
DeclSpec::TQ, StringRef QualName,
10829 DiagOccured =
true;
10907 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
10909 return Constructor->setInvalidDecl();
10916 if (!Constructor->isInvalidDecl() &&
10917 Constructor->hasOneParamOrDefaultArgs() &&
10918 Constructor->getTemplateSpecializationKind() !=
10920 QualType ParamType = Constructor->getParamDecl(0)->getType();
10923 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
10924 const char *ConstRef
10925 = Constructor->getParamDecl(0)->getIdentifier() ?
"const &"
10927 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
10932 Constructor->setInvalidDecl();
10954 Expr *ThisArg =
nullptr;
10959 if (OperatorDelete->isDestroyingOperatorDelete()) {
10960 QualType ParamType = OperatorDelete->getParamDecl(0)->getType();
10967 ActOnCXXThis(OperatorDelete->getParamDecl(0)->getLocation());
10968 assert(!This.isInvalid() &&
"couldn't form 'this' expr in dtor?");
10970 if (This.isInvalid()) {
10973 Diag(
Loc, diag::note_implicit_delete_this_in_destructor_here);
10976 ThisArg = This.get();
10982 Destructor->setOperatorDelete(OperatorDelete, ThisArg);
11005 << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
11008 if (TST->isTypeAlias())
11010 << DeclaratorType << 1;
11104 if (After.isInvalid())
11108 R.
setEnd(After.getEnd());
11163 unsigned NumParam = Proto->getNumParams();
11167 if (NumParam == 1) {
11169 if (
const auto *
First =
11170 dyn_cast_if_present<ParmVarDecl>(FTI.
Params[0].
Param);
11171 First &&
First->isExplicitObjectParameter())
11175 if (NumParam != 0) {
11180 }
else if (Proto->isVariadic()) {
11187 if (Proto->getReturnType() != ConvType) {
11188 bool NeedsTypedef =
false;
11192 bool PastFunctionChunk =
false;
11194 switch (Chunk.Kind) {
11196 if (!PastFunctionChunk) {
11197 if (Chunk.Fun.HasTrailingReturnType) {
11202 PastFunctionChunk =
true;
11207 NeedsTypedef =
true;
11227 After.isValid() ? After.getBegin() :
11229 auto &&DB =
Diag(
Loc, diag::err_conv_function_with_complex_decl);
11230 DB << Before << After;
11232 if (!NeedsTypedef) {
11236 if (After.isInvalid() && ConvTSI) {
11244 }
else if (!Proto->getReturnType()->isDependentType()) {
11245 DB << 1 << Proto->getReturnType();
11247 DB << 2 << Proto->getReturnType();
11258 ConvType = Proto->getReturnType();
11279 Proto->getExtProtoInfo());
11285 ? diag::warn_cxx98_compat_explicit_conversion_functions
11286 : diag::ext_explicit_conversion_functions)
11295 assert(Conversion &&
"Expected to receive a conversion function declaration");
11318 if (ConvType == ClassType)
11323 << ClassType << ConvType;
11326 << ClassType << ConvType;
11341 return ConversionTemplate;
11366 for (
unsigned Idx = 0; Idx < FTI.
NumParams; Idx++) {
11367 const auto &ParamInfo = FTI.
Params[Idx];
11368 if (!ParamInfo.Param)
11370 ParmVarDecl *Param = cast<ParmVarDecl>(ParamInfo.Param);
11374 ExplicitObjectParam = Param;
11378 diag::err_explicit_object_parameter_must_be_first)
11382 if (!ExplicitObjectParam)
11387 diag::err_explicit_object_default_arg)
11395 diag::err_explicit_object_parameter_nonmember)
11402 diag::err_explicit_object_parameter_nonmember)
11409 diag::err_explicit_object_parameter_mutable)
11418 diag::err_explicit_object_parameter_nonmember)
11428 diag::err_explicit_object_parameter_constructor)
11438struct BadSpecifierDiagnoser {
11441 ~BadSpecifierDiagnoser() {
11449 return check(SpecLoc,
11455 if (!Specifiers.empty()) Specifiers +=
" ";
11456 Specifiers += Spec;
11461 std::string Specifiers;
11473 assert(GuidedTemplateDecl &&
"missing template decl for deduction guide");
11481 << GuidedTemplateDecl;
11487 if (DS.hasTypeSpecifier() || DS.getTypeQualifiers() ||
11488 DS.getStorageClassSpecLoc().isValid() || DS.isInlineSpecified() ||
11489 DS.isNoreturnSpecified() || DS.hasConstexprSpecifier()) {
11490 BadSpecifierDiagnoser Diagnoser(
11492 diag::err_deduction_guide_invalid_specifier);
11494 Diagnoser.check(DS.getStorageClassSpecLoc(), DS.getStorageClassSpec());
11495 DS.ClearStorageClassSpecs();
11499 Diagnoser.check(DS.getInlineSpecLoc(),
"inline");
11500 Diagnoser.check(DS.getNoreturnSpecLoc(),
"_Noreturn");
11501 Diagnoser.check(DS.getConstexprSpecLoc(),
"constexpr");
11502 DS.ClearConstexprSpec();
11504 Diagnoser.check(DS.getConstSpecLoc(),
"const");
11505 Diagnoser.check(DS.getRestrictSpecLoc(),
"__restrict");
11506 Diagnoser.check(DS.getVolatileSpecLoc(),
"volatile");
11507 Diagnoser.check(DS.getAtomicSpecLoc(),
"_Atomic");
11508 Diagnoser.check(DS.getUnalignedSpecLoc(),
"__unaligned");
11509 DS.ClearTypeQualifiers();
11511 Diagnoser.check(DS.getTypeSpecComplexLoc(), DS.getTypeSpecComplex());
11512 Diagnoser.check(DS.getTypeSpecSignLoc(), DS.getTypeSpecSign());
11513 Diagnoser.check(DS.getTypeSpecWidthLoc(), DS.getTypeSpecWidth());
11514 Diagnoser.check(DS.getTypeSpecTypeLoc(), DS.getTypeSpecType());
11515 DS.ClearTypeSpecType();
11522 bool FoundFunction =
false;
11528 diag::err_deduction_guide_with_complex_decl)
11532 if (!Chunk.Fun.hasTrailingReturnType())
11534 diag::err_deduction_guide_no_trailing_return_type);
11539 ParsedType TrailingReturnType = Chunk.Fun.getTrailingReturnType();
11542 assert(TSI &&
"deduction guide has valid type but invalid return type?");
11543 bool AcceptableReturnType =
false;
11544 bool MightInstantiateToSpecialization =
false;
11547 TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
11548 bool TemplateMatches =
11550 auto TKind = SpecifiedName.
getKind();
11556 if (SimplyWritten && TemplateMatches)
11557 AcceptableReturnType =
true;
11562 MightInstantiateToSpecialization = !(TD && isa<ClassTemplateDecl>(TD) &&
11566 MightInstantiateToSpecialization =
true;
11569 if (!AcceptableReturnType)
11571 diag::err_deduction_guide_bad_trailing_return_type)
11572 << GuidedTemplate << TSI->
getType()
11573 << MightInstantiateToSpecialization
11578 FoundFunction =
true;
11597 assert(*IsInline != PrevNS->
isInline());
11607 S.
Diag(
Loc, diag::warn_inline_namespace_reopened_noninline)
11610 S.
Diag(
Loc, diag::err_inline_namespace_mismatch);
11628 bool IsInline = InlineLoc.
isValid();
11629 bool IsInvalid =
false;
11630 bool IsStd =
false;
11631 bool AddToKnown =
false;
11642 auto DiagnoseInlineStdNS = [&]() {
11643 assert(IsInline && II->
isStr(
"std") &&
11645 "Precondition of DiagnoseInlineStdNS not met");
11646 Diag(InlineLoc, diag::err_inline_namespace_std)
11662 RedeclarationKind::ForExternalRedeclaration);
11666 PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
11670 if (IsInline && II->
isStr(
"std") &&
11672 DiagnoseInlineStdNS();
11673 else if (IsInline != PrevNS->
isInline())
11675 &IsInline, PrevNS);
11676 }
else if (PrevDecl) {
11678 Diag(
Loc, diag::err_redefinition_different_kind)
11683 }
else if (II->
isStr(
"std") &&
11686 DiagnoseInlineStdNS();
11691 AddToKnown = !IsInline;
11694 AddToKnown = !IsInline;
11708 if (PrevNS && IsInline != PrevNS->
isInline())
11710 &IsInline, PrevNS);
11723 if (
const VisibilityAttr *
Attr = Namespc->
getAttr<VisibilityAttr>())
11729 KnownNamespaces[Namespc] =
false;
11737 TU->setAnonymousNamespace(Namespc);
11739 cast<NamespaceDecl>(
Parent)->setAnonymousNamespace(Namespc);
11788 return AD->getNamespace();
11789 return dyn_cast_or_null<NamespaceDecl>(D);
11795 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
11796 assert(Namespc &&
"Invalid parameter, expected NamespaceDecl");
11799 if (Namespc->
hasAttr<VisibilityAttr>())
11802 if (DeferredExportedNamespaces.erase(Namespc))
11807 return cast_or_null<CXXRecordDecl>(
11816 return cast_or_null<NamespaceDecl>(
11821enum UnsupportedSTLSelect {
11828struct InvalidSTLDiagnoser {
11833 QualType operator()(UnsupportedSTLSelect Sel = USS_Other, StringRef Name =
"",
11834 const VarDecl *VD =
nullptr) {
11836 auto D = S.
Diag(
Loc, diag::err_std_compare_type_not_supported)
11837 << TyForDiags << ((
int)Sel);
11838 if (Sel == USS_InvalidMember || Sel == USS_MissingMember) {
11839 assert(!Name.empty());
11843 if (Sel == USS_InvalidMember) {
11856 "Looking for comparison category type outside of C++.");
11870 if (Info && FullyCheckedComparisonCategories[
static_cast<unsigned>(Kind)]) {
11881 std::string NameForDiags =
"std::";
11883 Diag(
Loc, diag::err_implied_comparison_category_type_not_found)
11884 << NameForDiags << (
int)Usage;
11888 assert(Info->
Kind == Kind);
11899 InvalidSTLDiagnoser UnsupportedSTLError{*
this,
Loc, TyForDiags(Info)};
11902 return UnsupportedSTLError(USS_NonTrivial);
11907 if (
Base->isEmpty())
11910 return UnsupportedSTLError();
11918 if (std::distance(FIt, FEnd) != 1 ||
11919 !FIt->getType()->isIntegralOrEnumerationType()) {
11920 return UnsupportedSTLError();
11930 return UnsupportedSTLError(USS_MissingMember, MemName);
11933 assert(VD &&
"should not be null!");
11940 return UnsupportedSTLError(USS_InvalidMember, MemName, VD);
11946 return UnsupportedSTLError();
11953 FullyCheckedComparisonCategories[
static_cast<unsigned>(Kind)] =
true;
11979 "Looking for std::initializer_list outside of C++.");
11993 dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
12002 TST = ICN->getInjectedTST();
12006 Template = dyn_cast_or_null<ClassTemplateDecl>(
12027 if (!isa<TemplateTypeParmDecl>(Params->
getParam(0)))
12039 *Element = Arguments[0].getAsType();
12046 S.
Diag(
Loc, diag::err_implied_std_initializer_list_not_found);
12053 S.
Diag(
Loc, diag::err_implied_std_initializer_list_not_found);
12058 Result.suppressDiagnostics();
12061 S.
Diag(Found->
getLocation(), diag::err_malformed_std_initializer_list);
12069 !isa<TemplateTypeParmDecl>(Params->
getParam(0))) {
12070 S.
Diag(Template->
getLocation(), diag::err_malformed_std_initializer_list);
12114 case Decl::TranslationUnit:
12116 case Decl::LinkageSpec:
12128 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
12130 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
12134 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
12135 return std::make_unique<NamespaceValidatorCCC>(*
this);
12143 auto *ND = cast<NamespaceDecl>(Corrected.
getFoundDecl());
12144 Module *M = ND->getOwningModule();
12145 assert(M &&
"hidden namespace definition not in a module?");
12149 diag::err_module_unimported_use_header)
12154 diag::err_module_unimported_use)
12164 NamespaceValidatorCCC CCC{};
12174 if (isa_and_nonnull<NamespaceDecl>(Corrected.getFoundDecl()) &&
12175 Corrected.requiresImport()) {
12178 std::string CorrectedStr(Corrected.getAsString(S.
getLangOpts()));
12179 bool DroppedSpecifier =
12180 Corrected.WillReplaceSpecifier() && Ident->
getName() == CorrectedStr;
12182 S.
PDiag(diag::err_using_directive_member_suggest)
12183 << Ident << DC << DroppedSpecifier << SS.
getRange(),
12184 S.
PDiag(diag::note_namespace_defined_here));
12187 S.
PDiag(diag::err_using_directive_suggest) << Ident,
12188 S.
PDiag(diag::note_namespace_defined_here));
12190 R.
addDecl(Corrected.getFoundDecl());
12201 assert(!SS.
isInvalid() &&
"Invalid CXXScopeSpec.");
12202 assert(NamespcName &&
"Invalid NamespcName.");
12203 assert(IdentLoc.
isValid() &&
"Invalid NamespceName location.");
12206 S = S->getDeclParent();
12224 NamespcName->
isStr(
"std")) {
12225 Diag(IdentLoc, diag::ext_using_undefined_std);
12236 assert(
NS &&
"expected namespace decl");
12255 CommonAncestor = CommonAncestor->
getParent();
12259 IdentLoc, Named, CommonAncestor);
12263 Diag(IdentLoc, diag::warn_using_directive_in_header);
12268 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.
getRange();
12301 Diag(Name.getBeginLoc(), diag::err_using_requires_qualname);
12305 switch (Name.getKind()) {
12316 Diag(Name.getBeginLoc(),
12318 ? diag::warn_cxx98_compat_using_decl_constructor
12319 : diag::err_using_decl_constructor)
12327 Diag(Name.getBeginLoc(), diag::err_using_decl_destructor) << SS.
getRange();
12331 Diag(Name.getBeginLoc(), diag::err_using_decl_template_id)
12332 <<
SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
12336 llvm_unreachable(
"cannot parse qualified deduction guide name");
12347 ? diag::err_access_decl
12348 : diag::warn_access_decl_deprecated)
12359 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
12367 SS, TargetNameInfo, EllipsisLoc, AttrList,
12381 assert(!SS->
isInvalid() &&
"ScopeSpec is invalid");
12391 ? diag::err_using_enum_is_dependent
12392 : diag::err_unknown_typename)
12400 Diag(IdentLoc, diag::err_using_enum_not_enum) << EnumTy;
12404 if (
auto *Def =
Enum->getDefinition())
12407 if (TSI ==
nullptr)
12430 TD2->getUnderlyingType());
12434 if (isa<UnresolvedUsingIfExistsDecl>(D1) &&
12435 isa<UnresolvedUsingIfExistsDecl>(D2))
12467 if (
auto *Using = dyn_cast<UsingDecl>(BUD)) {
12471 if (isa<EnumDecl>(OrigDC))
12479 Diag(Using->getLocation(),
12480 diag::err_using_decl_nested_name_specifier_is_current_class)
12481 << Using->getQualifierLoc().getSourceRange();
12483 Using->setInvalidDecl();
12487 Diag(Using->getQualifierLoc().getBeginLoc(),
12488 diag::err_using_decl_nested_name_specifier_is_not_base_class)
12489 << Using->getQualifier() << cast<CXXRecordDecl>(
CurContext)
12490 << Using->getQualifierLoc().getSourceRange();
12492 Using->setInvalidDecl();
12497 if (
Previous.empty())
return false;
12500 if (isa<UsingShadowDecl>(
Target))
12501 Target = cast<UsingShadowDecl>(
Target)->getTargetDecl();
12508 NamedDecl *NonTag =
nullptr, *Tag =
nullptr;
12509 bool FoundEquivalentDecl =
false;
12512 NamedDecl *D = (*I)->getUnderlyingDecl();
12516 if (isa<UsingDecl>(D) || isa<UsingPackDecl>(D) || isa<UsingEnumDecl>(D))
12519 if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
12524 !isa<IndirectFieldDecl>(
Target) &&
12525 !isa<UnresolvedUsingValueDecl>(
Target) &&
12534 PrevShadow = Shadow;
12535 FoundEquivalentDecl =
true;
12539 FoundEquivalentDecl =
true;
12543 (isa<TagDecl>(D) ? Tag : NonTag) = D;
12546 if (FoundEquivalentDecl)
12551 if (isa<UnresolvedUsingIfExistsDecl>(
Target) !=
12552 (isa_and_nonnull<UnresolvedUsingIfExistsDecl>(NonTag))) {
12553 if (!NonTag && !Tag)
12556 Diag(
Target->getLocation(), diag::note_using_decl_target);
12557 Diag((NonTag ? NonTag : Tag)->getLocation(),
12558 diag::note_using_decl_conflict);
12587 Diag(
Target->getLocation(), diag::note_using_decl_target);
12595 if (isa<TagDecl>(
Target)) {
12597 if (!Tag)
return false;
12600 Diag(
Target->getLocation(), diag::note_using_decl_target);
12601 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
12607 if (!NonTag)
return false;
12610 Diag(
Target->getLocation(), diag::note_using_decl_target);
12620 for (
auto &B : Derived->
bases())
12621 if (B.getType()->getAsCXXRecordDecl() ==
Base)
12622 return B.isVirtual();
12623 llvm_unreachable(
"not a direct base class");
12632 if (isa<UsingShadowDecl>(
Target)) {
12633 Target = cast<UsingShadowDecl>(
Target)->getTargetDecl();
12634 assert(!isa<UsingShadowDecl>(
Target) &&
"nested shadow declaration");
12638 if (
auto *TargetTD = dyn_cast<TemplateDecl>(
Target))
12639 NonTemplateTarget = TargetTD->getTemplatedDecl();
12642 if (NonTemplateTarget && isa<CXXConstructorDecl>(NonTemplateTarget)) {
12643 UsingDecl *Using = cast<UsingDecl>(BUD);
12644 bool IsVirtualBase =
12646 Using->getQualifier()->getAsRecordDecl());
12700 cast<CXXRecordDecl>(Shadow->
getDeclContext())->removeConversion(Shadow);
12707 S->RemoveDecl(Shadow);
12721 bool &AnyDependentBases) {
12726 CanQualType BaseType =
Base.getType()->getCanonicalTypeUnqualified();
12727 if (CanonicalDesiredBase == BaseType)
12729 if (BaseType->isDependentType())
12730 AnyDependentBases =
true;
12738 UsingValidatorCCC(
bool HasTypenameKeyword,
bool IsInstantiation,
12740 : HasTypenameKeyword(HasTypenameKeyword),
12741 IsInstantiation(IsInstantiation), OldNNS(NNS),
12742 RequireMemberOf(RequireMemberOf) {}
12744 bool ValidateCandidate(
const TypoCorrection &Candidate)
override {
12748 if (!ND || isa<NamespaceDecl>(ND))
12758 if (RequireMemberOf) {
12759 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
12760 if (FoundRecord && FoundRecord->isInjectedClassName()) {
12781 bool AnyDependentBases =
false;
12784 AnyDependentBases) &&
12785 !AnyDependentBases)
12789 if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
12795 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
12796 if (FoundRecord && FoundRecord->isInjectedClassName())
12800 if (isa<TypeDecl>(ND))
12801 return HasTypenameKeyword || !IsInstantiation;
12803 return !HasTypenameKeyword;
12806 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
12807 return std::make_unique<UsingValidatorCCC>(*
this);
12811 bool HasTypenameKeyword;
12812 bool IsInstantiation;
12851 bool IsUsingIfExists) {
12852 assert(!SS.
isInvalid() &&
"Invalid CXXScopeSpec.");
12854 assert(IdentLoc.
isValid() &&
"Invalid TargetName location.");
12863 if (
auto *RD = dyn_cast<CXXRecordDecl>(
CurContext))
12869 RedeclarationKind::ForVisibleRedeclaration);
12876 assert(IsInstantiation &&
"no scope in non-instantiation");
12904 Diag(UsingLoc, diag::err_using_if_exists_on_ctor);
12910 if (!LookupContext || EllipsisLoc.
isValid()) {
12914 SS, NameInfo, IdentLoc))
12917 if (HasTypenameKeyword) {
12920 UsingLoc, TypenameLoc,
12922 IdentLoc, NameInfo.
getName(),
12926 QualifierLoc, NameInfo, EllipsisLoc);
12934 auto Build = [&](
bool Invalid) {
12937 UsingName, HasTypenameKeyword);
12944 auto BuildInvalid = [&]{
return Build(
true); };
12945 auto BuildValid = [&]{
return Build(
false); };
12948 return BuildInvalid();
12957 if (!IsInstantiation)
12974 if (R.
empty() && IsUsingIfExists)
12991 isa<TranslationUnitDecl>(LookupContext) &&
12994 UsingValidatorCCC CCC(HasTypenameKeyword, IsInstantiation, SS.
getScopeRep(),
13002 << NameInfo.
getName() << LookupContext << 0
13007 NamedDecl *ND = Corrected.getCorrectionDecl();
13009 return BuildInvalid();
13012 auto *RD = dyn_cast<CXXRecordDecl>(ND);
13015 RD = cast<CXXRecordDecl>(RD->
getParent());
13018 if (Corrected.WillReplaceSpecifier()) {
13020 Builder.MakeTrivial(
Context, Corrected.getCorrectionSpecifier(),
13022 QualifierLoc = Builder.getWithLocInContext(
Context);
13027 auto *CurClass = cast<CXXRecordDecl>(
CurContext);
13041 Diag(IdentLoc, diag::err_no_member)
13043 return BuildInvalid();
13048 return BuildInvalid();
13050 if (HasTypenameKeyword) {
13054 Diag(IdentLoc, diag::err_using_typename_non_type);
13056 Diag((*I)->getUnderlyingDecl()->getLocation(),
13057 diag::note_using_decl_target);
13058 return BuildInvalid();
13065 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
13067 return BuildInvalid();
13074 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
13076 return BuildInvalid();
13112 RedeclarationKind::ForVisibleRedeclaration);
13118 if (UED->getEnumDecl() == ED) {
13119 Diag(UsingLoc, diag::err_using_enum_decl_redeclaration)
13145 RedeclarationKind::ForVisibleRedeclaration);
13158 assert(isa<UnresolvedUsingValueDecl>(InstantiatedFrom) ||
13159 isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) ||
13160 isa<UsingPackDecl>(InstantiatedFrom));
13164 UPD->setAccess(InstantiatedFrom->
getAccess());
13171 assert(!UD->
hasTypename() &&
"expecting a constructor name");
13174 assert(SourceType &&
13175 "Using decl naming constructor doesn't have type in scope spec.");
13179 bool AnyDependentBases =
false;
13181 AnyDependentBases);
13182 if (!
Base && !AnyDependentBases) {
13184 diag::err_using_decl_constructor_not_in_direct_base)
13186 <<
QualType(SourceType, 0) << TargetClass;
13192 Base->setInheritConstructors();
13201 bool HasTypenameKeyword,
13220 if (Qual->
isDependent() && !HasTypenameKeyword) {
13221 for (
auto *D : Prev) {
13222 if (!isa<TypeDecl>(D) && !isa<UsingDecl>(D) && !isa<UsingPackDecl>(D)) {
13223 bool OldCouldBeEnumerator =
13224 isa<UnresolvedUsingValueDecl>(D) || isa<EnumConstantDecl>(D);
13226 OldCouldBeEnumerator ? diag::err_redefinition
13227 : diag::err_redefinition_different_kind)
13228 << Prev.getLookupName();
13244 if (
UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
13245 DTypename = UD->hasTypename();
13246 DQual = UD->getQualifier();
13248 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
13250 DQual = UD->getQualifier();
13252 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
13254 DQual = UD->getQualifier();
13259 if (HasTypenameKeyword != DTypename)
continue;
13267 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.
getRange();
13288 assert(
bool(NamedContext) == (R || UD) && !(R && UD) &&
13289 "resolvable context must have exactly one set of decls");
13293 bool Cxx20Enumerator =
false;
13294 if (NamedContext) {
13303 if (
auto *ED = dyn_cast<EnumDecl>(NamedContext)) {
13307 if (EC && R && ED->isScoped())
13310 ? diag::warn_cxx17_compat_using_decl_scoped_enumerator
13311 : diag::ext_using_decl_scoped_enumerator)
13315 NamedContext = ED->getDeclContext();
13335 ? diag::warn_cxx17_compat_using_decl_class_member_enumerator
13336 : diag::err_using_decl_can_not_refer_to_class_member)
13339 if (Cxx20Enumerator)
13342 auto *RD = NamedContext
13354 Diag(SS.
getBeginLoc(), diag::note_using_decl_class_member_workaround)
13362 Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
13378 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
13393 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
13403 if (!NamedContext) {
13419 ? diag::warn_cxx17_compat_using_decl_non_member_enumerator
13420 : diag::err_using_decl_nested_name_specifier_is_not_class)
13423 if (Cxx20Enumerator)
13440 cast<CXXRecordDecl>(NamedContext))) {
13442 if (Cxx20Enumerator) {
13443 Diag(NameLoc, diag::warn_cxx17_compat_using_decl_non_member_enumerator)
13450 diag::err_using_decl_nested_name_specifier_is_current_class)
13455 if (!cast<CXXRecordDecl>(NamedContext)->isInvalidDecl()) {
13457 diag::err_using_decl_nested_name_specifier_is_not_base_class)
13482 Bases.insert(
Base);
13487 if (!cast<CXXRecordDecl>(
CurContext)->forallBases(Collect))
13493 return !Bases.count(
Base);
13498 if (Bases.count(cast<CXXRecordDecl>(NamedContext)) ||
13499 !cast<CXXRecordDecl>(NamedContext)->forallBases(IsNotBase))
13503 diag::err_using_decl_nested_name_specifier_is_not_base_class)
13517 S = S->getDeclParent();
13519 if (
Type.isInvalid())
13538 TemplateParamLists.size()
13540 : RedeclarationKind::ForVisibleRedeclaration);
13545 Previous.getFoundDecl()->isTemplateParameter()) {
13551 "name in alias declaration must be an identifier");
13553 Name.StartLocation,
13554 Name.Identifier, TInfo);
13568 bool Redeclaration =
false;
13571 if (TemplateParamLists.size()) {
13575 if (TemplateParamLists.size() != 1) {
13576 Diag(UsingLoc, diag::err_alias_template_extra_headers)
13577 <<
SourceRange(TemplateParamLists[1]->getTemplateLoc(),
13578 TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
13591 Redeclaration =
true;
13595 Diag(UsingLoc, diag::err_redefinition_different_kind)
13596 << Name.Identifier;
13610 OldTemplateParams =
13638 Name.Identifier, TemplateParams,
13646 else if (OldDecl) {
13653 if (
auto *TD = dyn_cast_or_null<TagDecl>(DeclFromDeclSpec)) {
13681 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.
getRange();
13690 RedeclarationKind::ForVisibleRedeclaration);
13713 Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
13715 Diag(AD->getLocation(), diag::note_previous_namespace_alias)
13716 << AD->getNamespace();
13721 ? diag::err_redefinition
13722 : diag::err_redefinition_different_kind;
13723 Diag(AliasLoc, DiagID) << Alias;
13744struct SpecialMemberExceptionSpecInfo
13745 : SpecialMemberVisitor<SpecialMemberExceptionSpecInfo> {
13753 : SpecialMemberVisitor(S, MD, CSM, ICI),
Loc(
Loc), ExceptSpec(S) {}
13758 void visitClassSubobject(
CXXRecordDecl *Class, Subobject Subobj,
13761 void visitSubobjectCall(Subobject Subobj,
13771 auto *BaseClass = cast<CXXRecordDecl>(RT->getDecl());
13773 if (
auto *BaseCtor = SMOR.
getMethod()) {
13774 visitSubobjectCall(
Base, BaseCtor);
13778 visitClassSubobject(BaseClass,
Base, 0);
13782bool SpecialMemberExceptionSpecInfo::visitField(
FieldDecl *FD) {
13794 ExceptSpec.CalledExpr(E);
13797 visitClassSubobject(cast<CXXRecordDecl>(RT->getDecl()), FD,
13807 bool IsMutable =
Field &&
Field->isMutable();
13808 visitSubobjectCall(Subobj, lookupIn(
Class, Quals, IsMutable));
13811void SpecialMemberExceptionSpecInfo::visitSubobjectCall(
13816 ExceptSpec.CalledDecl(getSubobjectLoc(Subobj), MD);
13845 ComputingExceptionSpec CES(S, MD,
Loc);
13852 SpecialMemberExceptionSpecInfo Info(S, MD, CSM, ICI, MD->
getLocation());
13854 return Info.ExceptSpec;
13861 diag::err_exception_spec_incomplete_type))
13862 return Info.ExceptSpec;
13879 Info.visit(Info.IsConstructor ? Info.VisitPotentiallyConstructedBases
13880 : Info.VisitAllBases);
13882 return Info.ExceptSpec;
13887struct DeclaringSpecialMember {
13891 bool WasAlreadyBeingDeclared;
13894 : S(S), D(RD, CSM), SavedContext(S, RD) {
13896 if (WasAlreadyBeingDeclared)
13917 ~DeclaringSpecialMember() {
13918 if (!WasAlreadyBeingDeclared) {
13925 bool isAlreadyBeingDeclared()
const {
13926 return WasAlreadyBeingDeclared;
13936 RedeclarationKind::ForExternalRedeclaration);
13947void Sema::setupImplicitSpecialMemberType(
CXXMethodDecl *SpecialMem,
13965 cast<CXXRecordDecl>(SpecialMem->
getParent())->isLambda()) {
13981 "Should not build implicit default constructor!");
13983 DeclaringSpecialMember DSM(*
this, ClassDecl,
13985 if (DSM.isAlreadyBeingDeclared())
14008 setupImplicitSpecialMemberType(DefaultCon,
Context.
VoidTy, std::nullopt);
14032 ClassDecl->
addDecl(DefaultCon);
14039 assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
14040 !Constructor->doesThisDeclarationHaveABody() &&
14041 !Constructor->isDeleted()) &&
14042 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
14043 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
14047 assert(ClassDecl &&
"DefineImplicitDefaultConstructor - invalid constructor");
14061 Scope.addContextNote(CurrentLocation);
14064 Constructor->setInvalidDecl();
14069 ? Constructor->getEndLoc()
14070 : Constructor->getLocation();
14072 Constructor->markUsed(
Context);
14075 L->CompletedImplicitDefinition(Constructor);
14078 DiagnoseUninitializedFields(*
this, Constructor);
14104 ->getInheritedConstructor()
14107 return cast<CXXConstructorDecl>(Ctor);
14122 false, BaseCtor, &ICI);
14139 EPI.ExceptionSpec.SourceDecl = DerivedCtor;
14145 for (
unsigned I = 0, N = FPT->
getNumParams(); I != N; ++I) {
14149 Context, DerivedCtor, UsingLoc, UsingLoc,
nullptr,
14156 ParamDecls.push_back(PD);
14161 assert(!BaseCtor->
isDeleted() &&
"should not use deleted constructor");
14164 Derived->
addDecl(DerivedCtor);
14170 return DerivedCtor;
14184 assert(Constructor->getInheritedConstructor() &&
14185 !Constructor->doesThisDeclarationHaveABody() &&
14186 !Constructor->isDeleted());
14187 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
14201 Scope.addContextNote(CurrentLocation);
14204 Constructor->getInheritedConstructor().getShadowDecl();
14206 Constructor->getInheritedConstructor().getConstructor();
14220 for (
bool VBase : {
false,
true}) {
14222 if (B.isVirtual() != VBase)
14225 auto *BaseRD = B.getType()->getAsCXXRecordDecl();
14230 if (!BaseCtor.first)
14235 InitLoc, B.getType(), BaseCtor.first, VBase, BaseCtor.second);
14239 Context, TInfo, VBase, InitLoc,
Init.get(), InitLoc,
14248 Constructor->setInvalidDecl();
14253 Constructor->markUsed(
Context);
14256 L->CompletedImplicitDefinition(Constructor);
14259 DiagnoseUninitializedFields(*
this, Constructor);
14269 DeclaringSpecialMember DSM(*
this, ClassDecl,
14271 if (DSM.isAlreadyBeingDeclared())
14332 !
Destructor->doesThisDeclarationHaveABody() &&
14334 "DefineImplicitDestructor - call it for implicit default dtor");
14339 assert(ClassDecl &&
"DefineImplicitDestructor - invalid destructor");
14350 Scope.addContextNote(CurrentLocation);
14378 "implicit complete dtors unneeded outside MS ABI");
14380 "complete dtor only exists for classes with vbases");
14385 Scope.addContextNote(CurrentLocation);
14395 if (
Record->isInvalidDecl()) {
14416 if (M->getParent()->getTemplateSpecializationKind() !=
14436 "adjusting dtor exception specs was introduced in c++11");
14446 if (DtorType->hasExceptionSpec())
14470 ExprBuilder(
const ExprBuilder&) =
delete;
14471 ExprBuilder &operator=(
const ExprBuilder&) =
delete;
14474 static Expr *assertNotNull(
Expr *E) {
14475 assert(E &&
"Expression construction must not fail.");
14481 virtual ~ExprBuilder() {}
14486class RefBuilder:
public ExprBuilder {
14496 : Var(Var), VarType(VarType) {}
14499class ThisBuilder:
public ExprBuilder {
14506class CastBuilder:
public ExprBuilder {
14507 const ExprBuilder &Builder;
14515 CK_UncheckedDerivedToBase, Kind,
14524class DerefBuilder:
public ExprBuilder {
14525 const ExprBuilder &Builder;
14529 return assertNotNull(
14533 DerefBuilder(
const ExprBuilder &Builder) : Builder(Builder) {}
14536class MemberBuilder:
public ExprBuilder {
14537 const ExprBuilder &Builder;
14547 nullptr, MemberLookup,
nullptr,
nullptr).get());
14550 MemberBuilder(
const ExprBuilder &Builder,
QualType Type,
bool IsArrow,
14552 : Builder(Builder),
Type(
Type), IsArrow(IsArrow),
14553 MemberLookup(MemberLookup) {}
14556class MoveCastBuilder:
public ExprBuilder {
14557 const ExprBuilder &Builder;
14564 MoveCastBuilder(
const ExprBuilder &Builder) : Builder(Builder) {}
14567class LvalueConvBuilder:
public ExprBuilder {
14568 const ExprBuilder &Builder;
14572 return assertNotNull(
14576 LvalueConvBuilder(
const ExprBuilder &Builder) : Builder(Builder) {}
14579class SubscriptBuilder:
public ExprBuilder {
14580 const ExprBuilder &
Base;
14581 const ExprBuilder &Index;
14589 SubscriptBuilder(
const ExprBuilder &
Base,
const ExprBuilder &Index)
14601 const ExprBuilder &ToB,
const ExprBuilder &FromB) {
14610 Expr *From = FromB.build(S,
Loc);
14614 Expr *To = ToB.build(S,
Loc);
14620 bool NeedsCollectableMemCpy =
14625 StringRef MemCpyName = NeedsCollectableMemCpy ?
14626 "__builtin_objc_memmove_collectable" :
14627 "__builtin_memcpy";
14640 assert(MemCpyRef.
isUsable() &&
"Builtin reference cannot fail");
14642 Expr *CallArgs[] = {
14648 assert(!
Call.isInvalid() &&
"Call to __builtin_memcpy cannot fail!");
14681 const ExprBuilder &To,
const ExprBuilder &From,
14682 bool CopyingBaseSubobject,
bool Copying,
14683 unsigned Depth = 0) {
14699 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
14734 if (CopyingBaseSubobject) {
14765 Expr *FromInst = From.build(S,
Loc);
14769 if (
Call.isInvalid())
14788 Loc, BO_Assign, To.build(S,
Loc), From.build(S,
Loc));
14789 if (Assignment.isInvalid())
14808 llvm::raw_svector_ostream
OS(Str);
14809 OS <<
"__i" << Depth;
14813 IterationVarName, SizeType,
14822 RefBuilder IterationVarRef(IterationVar, SizeType);
14823 LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
14829 SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
14830 MoveCastBuilder FromIndexMove(FromIndexCopy);
14831 const ExprBuilder *FromIndex;
14833 FromIndex = &FromIndexCopy;
14835 FromIndex = &FromIndexMove;
14837 SubscriptBuilder ToIndex(To, IterationVarRefRVal);
14842 ToIndex, *FromIndex, CopyingBaseSubobject,
14843 Copying, Depth + 1);
14845 if (
Copy.isInvalid() || !
Copy.get())
14852 S.
Context, IterationVarRefRVal.build(S,
Loc),
14873 const ExprBuilder &To,
const ExprBuilder &From,
14874 bool CopyingBaseSubobject,
bool Copying) {
14876 if (
T->
isArrayType() && !
T.isConstQualified() && !
T.isVolatileQualified() &&
14877 T.isTriviallyCopyableType(S.
Context))
14881 CopyingBaseSubobject,
14899 DeclaringSpecialMember DSM(*
this, ClassDecl,
14901 if (DSM.isAlreadyBeingDeclared())
14936 setupImplicitSpecialMemberType(
CopyAssignment, RetType, ArgType);
14946 ClassLoc, ClassLoc,
14988 }
else if (!isa<CXXConstructorDecl>(CopyOp) &&
14991 for (
auto *I : RD->
ctors()) {
14992 if (I->isCopyConstructor()) {
14993 UserDeclaredOperation = I;
14997 assert(UserDeclaredOperation);
14998 }
else if (isa<CXXConstructorDecl>(CopyOp) &&
15001 for (
auto *I : RD->
methods()) {
15002 if (I->isCopyAssignmentOperator()) {
15003 UserDeclaredOperation = I;
15007 assert(UserDeclaredOperation);
15010 if (UserDeclaredOperation) {
15011 bool UDOIsUserProvided = UserDeclaredOperation->
isUserProvided();
15012 bool UDOIsDestructor = isa<CXXDestructorDecl>(UserDeclaredOperation);
15013 bool IsCopyAssignment = !isa<CXXConstructorDecl>(CopyOp);
15015 (UDOIsUserProvided && UDOIsDestructor)
15016 ? diag::warn_deprecated_copy_with_user_provided_dtor
15017 : (UDOIsUserProvided && !UDOIsDestructor)
15018 ? diag::warn_deprecated_copy_with_user_provided_copy
15019 : (!UDOIsUserProvided && UDOIsDestructor)
15020 ? diag::warn_deprecated_copy_with_dtor
15021 : diag::warn_deprecated_copy;
15023 << RD << IsCopyAssignment;
15034 "DefineImplicitCopyAssignment called for wrong function");
15052 Scope.addContextNote(CurrentLocation);
15087 RefBuilder OtherRef(
Other, OtherRefType);
15090 std::optional<ThisBuilder> This;
15091 std::optional<DerefBuilder> DerefThis;
15092 std::optional<RefBuilder> ExplicitObject;
15093 bool IsArrow =
false;
15099 ExplicitObject.emplace(CopyAssignOperator->
getParamDecl(0), ObjectType);
15103 DerefThis.emplace(*This);
15106 ExprBuilder &ObjectParameter =
15107 ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15108 :
static_cast<ExprBuilder &
>(*This);
15112 for (
auto &
Base : ClassDecl->
bases()) {
15115 QualType BaseType =
Base.getType().getUnqualifiedType();
15122 BasePath.push_back(&
Base);
15131 ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15132 :
static_cast<ExprBuilder &
>(*DerefThis),
15141 if (
Copy.isInvalid()) {
15147 Statements.push_back(
Copy.getAs<
Expr>());
15151 for (
auto *Field : ClassDecl->
fields()) {
15154 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15157 if (Field->isInvalidDecl()) {
15163 if (Field->getType()->isReferenceType()) {
15164 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15166 Diag(Field->getLocation(), diag::note_declared_at);
15174 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15176 Diag(Field->getLocation(), diag::note_declared_at);
15182 if (Field->isZeroLengthBitField(
Context))
15185 QualType FieldType = Field->getType().getNonReferenceType();
15188 "Incomplete array type is not valid");
15199 MemberBuilder From(OtherRef, OtherRefType,
false, MemberLookup);
15200 MemberBuilder To(ObjectParameter, ObjectType, IsArrow, MemberLookup);
15206 if (
Copy.isInvalid()) {
15212 Statements.push_back(
Copy.getAs<
Stmt>());
15218 (ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15219 :
LangOpts.HLSL ?
static_cast<ExprBuilder &
>(*This)
15220 :
static_cast<ExprBuilder &
>(*DerefThis))
15221 .build(*
this,
Loc);
15226 Statements.push_back(Return.
getAs<
Stmt>());
15239 assert(!Body.
isInvalid() &&
"Compound statement creation cannot fail");
15245 L->CompletedImplicitDefinition(CopyAssignOperator);
15252 DeclaringSpecialMember DSM(*
this, ClassDecl,
15254 if (DSM.isAlreadyBeingDeclared())
15288 setupImplicitSpecialMemberType(
MoveAssignment, RetType, ArgType);
15298 ClassLoc, ClassLoc,
15334 assert(!
Class->isDependentContext() &&
"should not define dependent move");
15340 if (
Class->getNumVBases() == 0 ||
Class->hasTrivialMoveAssignment() ||
15341 Class->getNumBases() < 2)
15345 typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
15348 for (
auto &BI :
Class->bases()) {
15349 Worklist.push_back(&BI);
15350 while (!Worklist.empty()) {
15356 if (!
Base->hasNonTrivialMoveAssignment())
15381 VBases.insert(std::make_pair(
Base->getCanonicalDecl(), &BI))
15383 if (Existing && Existing != &BI) {
15384 S.
Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
15387 << (
Base->getCanonicalDecl() ==
15390 S.
Diag(BI.getBeginLoc(), diag::note_vbase_moved_here)
15391 << (
Base->getCanonicalDecl() ==
15392 BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
15396 Existing =
nullptr;
15406 llvm::append_range(Worklist, llvm::make_pointer_range(
Base->bases()));
15419 "DefineImplicitMoveAssignment called for wrong function");
15449 Scope.addContextNote(CurrentLocation);
15465 RefBuilder OtherRef(
Other, OtherRefType);
15467 MoveCastBuilder MoveOther(OtherRef);
15470 std::optional<ThisBuilder> This;
15471 std::optional<DerefBuilder> DerefThis;
15472 std::optional<RefBuilder> ExplicitObject;
15478 ExplicitObject.emplace(MoveAssignOperator->
getParamDecl(0), ObjectType);
15482 DerefThis.emplace(*This);
15484 ExprBuilder &ObjectParameter =
15485 ExplicitObject ? *ExplicitObject :
static_cast<ExprBuilder &
>(*This);
15489 for (
auto &
Base : ClassDecl->
bases()) {
15500 QualType BaseType =
Base.getType().getUnqualifiedType();
15507 BasePath.push_back(&
Base);
15511 CastBuilder From(OtherRef, BaseType,
VK_XValue, BasePath);
15516 ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15517 :
static_cast<ExprBuilder &
>(*DerefThis),
15526 if (Move.isInvalid()) {
15532 Statements.push_back(Move.getAs<
Expr>());
15536 for (
auto *Field : ClassDecl->
fields()) {
15539 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15542 if (Field->isInvalidDecl()) {
15548 if (Field->getType()->isReferenceType()) {
15549 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15551 Diag(Field->getLocation(), diag::note_declared_at);
15559 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15561 Diag(Field->getLocation(), diag::note_declared_at);
15567 if (Field->isZeroLengthBitField(
Context))
15570 QualType FieldType = Field->getType().getNonReferenceType();
15573 "Incomplete array type is not valid");
15582 MemberBuilder From(MoveOther, OtherRefType,
15583 false, MemberLookup);
15584 MemberBuilder To(ObjectParameter, ObjectType, !ExplicitObject,
15587 assert(!From.build(*
this,
Loc)->isLValue() &&
15588 "Member reference with rvalue base must be rvalue except for reference "
15589 "members, which aren't allowed for move assignment.");
15596 if (Move.isInvalid()) {
15602 Statements.push_back(Move.getAs<
Stmt>());
15608 (ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15609 :
static_cast<ExprBuilder &
>(*DerefThis))
15610 .build(*
this,
Loc);
15616 Statements.push_back(Return.
getAs<
Stmt>());
15629 assert(!Body.
isInvalid() &&
"Compound statement creation cannot fail");
15635 L->CompletedImplicitDefinition(MoveAssignOperator);
15646 DeclaringSpecialMember DSM(*
this, ClassDecl,
15648 if (DSM.isAlreadyBeingDeclared())
15715 ClassDecl->
hasAttr<TrivialABIAttr>() ||
15747 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
15752 assert(ClassDecl &&
"DefineImplicitCopyConstructor - invalid constructor");
15763 Scope.addContextNote(CurrentLocation);
15794 DeclaringSpecialMember DSM(*
this, ClassDecl,
15796 if (DSM.isAlreadyBeingDeclared())
15841 ClassLoc, ClassLoc,
15854 ClassDecl->
hasAttr<TrivialABIAttr>() ||
15886 "DefineImplicitMoveConstructor - call it for implicit move ctor");
15891 assert(ClassDecl &&
"DefineImplicitMoveConstructor - invalid constructor");
15902 Scope.addContextNote(CurrentLocation);
15949 if (CallOp != Invoker) {
15968 if (Invoker != CallOp) {
15981 assert(FunctionRef &&
"Can't refer to __invoke function?");
15989 L->CompletedImplicitDefinition(Conv);
15990 if (Invoker != CallOp)
15991 L->CompletedImplicitDefinition(Invoker);
16019 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
16028 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
16034 Stmt *ReturnS = Return.
get();
16041 L->CompletedImplicitDefinition(Conv);
16048 switch (Args.size()) {
16053 if (!Args[1]->isDefaultArgument())
16058 return !Args[0]->isDefaultArgument();
16067 bool HadMultipleCandidates,
bool IsListInitialization,
16068 bool IsStdInitListInitialization,
bool RequiresZeroInit,
16070 bool Elidable =
false;
16089 Expr *SubExpr = ExprArgs[0];
16099 FoundDecl, Constructor,
16100 Elidable, ExprArgs, HadMultipleCandidates,
16101 IsListInitialization,
16102 IsStdInitListInitialization, RequiresZeroInit,
16103 ConstructKind, ParenRange);
16109 bool HadMultipleCandidates,
bool IsListInitialization,
16110 bool IsStdInitListInitialization,
bool RequiresZeroInit,
16112 if (
auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl)) {
16122 ConstructLoc, DeclInitType, Constructor, Elidable, ExprArgs,
16123 HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
16124 RequiresZeroInit, ConstructKind, ParenRange);
16132 bool HadMultipleCandidates,
bool IsListInitialization,
16133 bool IsStdInitListInitialization,
bool RequiresZeroInit,
16136 Constructor->getParent(),
16138 "given constructor for wrong type");
16145 Context, DeclInitType, ConstructLoc, Constructor, Elidable, ExprArgs,
16146 HadMultipleCandidates, IsListInitialization,
16147 IsStdInitListInitialization, RequiresZeroInit,
16179 PDiag(diag::err_access_dtor_var)
16189 bool HasConstantInit =
false;
16196 diag::err_constexpr_var_requires_const_destruction) << VD;
16197 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
16198 Diag(Notes[I].first, Notes[I].second);
16207 if (!VD->
hasAttr<AlwaysDestroyAttr>())
16224 bool AllowExplicit,
16225 bool IsListInitialization) {
16227 unsigned NumArgs = ArgsPtr.size();
16228 Expr **Args = ArgsPtr.data();
16234 if (NumArgs < NumParams)
16235 ConvertedArgs.reserve(NumParams);
16237 ConvertedArgs.reserve(NumArgs);
16244 CallType, AllowExplicit, IsListInitialization);
16245 ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
16249 CheckConstructorCall(Constructor, DeclInitType,
16260 if (isa<NamespaceDecl>(DC)) {
16262 diag::err_operator_new_delete_declared_in_namespace)
16266 if (isa<TranslationUnitDecl>(DC) &&
16269 diag::err_operator_new_delete_declared_static)
16281 return Ctx.getPointerType(Ctx.getCanonicalType(Ctx.getQualifiedType(
16289 unsigned DependentParamTypeDiag,
16290 unsigned InvalidParamTypeDiag) {
16311 ? diag::err_operator_new_delete_dependent_result_type
16312 : diag::err_operator_new_delete_invalid_result_type)
16319 diag::err_operator_new_delete_template_too_few_parameters)
16325 diag::err_operator_new_delete_too_few_parameters)
16332 if (
const auto *PtrTy =
16337 ExpectedFirstParamType =
16343 ExpectedFirstParamType) {
16348 ? DependentParamTypeDiag
16349 : InvalidParamTypeDiag)
16350 << FnDecl->
getDeclName() << ExpectedFirstParamType;
16373 diag::err_operator_new_dependent_param_type,
16374 diag::err_operator_new_param_type))
16381 diag::err_operator_new_default_arg)
16396 auto *MD = dyn_cast<CXXMethodDecl>(FnDecl);
16412 diag::err_operator_delete_dependent_param_type,
16413 diag::err_operator_delete_param_type))
16422 diag::err_destroying_operator_delete_not_usual);
16434 "Expected an overloaded operator declaration");
16444 if (Op == OO_Delete || Op == OO_Array_Delete)
16447 if (Op == OO_New || Op == OO_Array_New)
16457 if (
CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
16458 if (MethodDecl->isStatic()) {
16459 if (Op == OO_Call || Op == OO_Subscript)
16462 ? diag::warn_cxx20_compat_operator_overload_static
16463 : diag::ext_operator_overload_static))
16466 return Diag(FnDecl->
getLocation(), diag::err_operator_overload_static)
16470 bool ClassOrEnumParam =
false;
16472 QualType ParamType = Param->getType().getNonReferenceType();
16475 ClassOrEnumParam =
true;
16480 if (!ClassOrEnumParam)
16482 diag::err_operator_overload_needs_class_or_enum)
16492 if (Op != OO_Call) {
16495 if (Param->hasDefaultArg()) {
16496 FirstDefaultedParam = Param;
16500 if (FirstDefaultedParam) {
16501 if (Op == OO_Subscript) {
16503 ? diag::ext_subscript_overload
16504 : diag::error_subscript_overload)
16509 diag::err_operator_overload_default_arg)
16517 {
false,
false,
false }
16518#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
16519 , { Unary, Binary, MemberOnly }
16520#include "clang/Basic/OperatorKinds.def"
16523 bool CanBeUnaryOperator = OperatorUses[Op][0];
16524 bool CanBeBinaryOperator = OperatorUses[Op][1];
16525 bool MustBeMemberOperator = OperatorUses[Op][2];
16532 (isa<CXXMethodDecl>(FnDecl) &&
16536 if (Op != OO_Call && Op != OO_Subscript &&
16537 ((NumParams == 1 && !CanBeUnaryOperator) ||
16538 (NumParams == 2 && !CanBeBinaryOperator) || (NumParams < 1) ||
16539 (NumParams > 2))) {
16541 unsigned ErrorKind;
16542 if (CanBeUnaryOperator && CanBeBinaryOperator) {
16544 }
else if (CanBeUnaryOperator) {
16547 assert(CanBeBinaryOperator &&
16548 "All non-call overloaded operators are unary or binary!");
16551 return Diag(FnDecl->
getLocation(), diag::err_operator_overload_must_be)
16552 << FnDecl->
getDeclName() << NumParams << ErrorKind;
16555 if (Op == OO_Subscript && NumParams != 2) {
16557 ? diag::ext_subscript_overload
16558 : diag::error_subscript_overload)
16559 << FnDecl->
getDeclName() << (NumParams == 1 ? 0 : 2);
16564 if (Op != OO_Call &&
16566 return Diag(FnDecl->
getLocation(), diag::err_operator_overload_variadic)
16571 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
16573 diag::err_operator_overload_must_be_member)
16587 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
16594 diag::err_operator_overload_post_incdec_must_be_int)
16595 << LastParam->
getType() << (Op == OO_MinusMinus);
16607 if (TemplateParams->
size() == 1) {
16609 dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->
getParam(0));
16628 }
else if (TemplateParams->
size() == 2) {
16630 dyn_cast<TemplateTypeParmDecl>(TemplateParams->
getParam(0));
16632 dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->
getParam(1));
16644 diag::ext_string_literal_operator_template);
16651 diag::err_literal_operator_template)
16660 if (isa<CXXMethodDecl>(FnDecl)) {
16661 Diag(FnDecl->
getLocation(), diag::err_literal_operator_outside_namespace)
16670 Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
16689 diag::err_literal_operator_template_with_params);
16718 diag::err_literal_operator_param)
16735 diag::err_literal_operator_invalid_param)
16745 QualType FirstParamType = (*Param)->getType().getUnqualifiedType();
16752 Diag((*Param)->getSourceRange().getBegin(),
16753 diag::err_literal_operator_param)
16754 << FirstParamType <<
"'const char *'" << (*Param)->getSourceRange();
16761 Diag((*Param)->getSourceRange().getBegin(),
16762 diag::err_literal_operator_param)
16763 << FirstParamType <<
"'const char *'" << (*Param)->getSourceRange();
16776 Diag((*Param)->getSourceRange().getBegin(),
16777 diag::err_literal_operator_param)
16778 << FirstParamType <<
"'const char *'" << (*Param)->getSourceRange();
16786 QualType SecondParamType = (*Param)->getType().getUnqualifiedType();
16788 Diag((*Param)->getSourceRange().getBegin(),
16789 diag::err_literal_operator_param)
16791 << (*Param)->getSourceRange();
16795 Diag(FnDecl->
getLocation(), diag::err_literal_operator_bad_param_count);
16804 if (Param->hasDefaultArg()) {
16805 Diag(Param->getDefaultArgRange().getBegin(),
16806 diag::err_literal_operator_default_argument)
16807 << Param->getDefaultArgRange();
16822 <<
static_cast<int>(Status)
16839 assert(Lit->
isUnevaluated() &&
"Unexpected string literal kind");
16845 else if (Lang ==
"C++")
16848 Diag(LangStr->
getExprLoc(), diag::err_language_linkage_spec_unknown)
16868 if (
getLangOpts().CPlusPlusModules && isCurrentModulePurview()) {
16869 Module *GlobalModule = PushImplicitGlobalModuleFragment(ExternLoc);
16896 PopImplicitGlobalModuleFragment();
16899 return LinkageSpec;
16935 Diag(
Loc, diag::err_catch_rvalue_ref);
16940 Diag(
Loc, diag::err_catch_variably_modified) << ExDeclType;
16946 unsigned DK = diag::err_catch_incomplete;
16950 DK = diag::err_catch_incomplete_ptr;
16953 BaseType = Ref->getPointeeType();
16955 DK = diag::err_catch_incomplete_ref;
16962 Diag(
Loc, diag::err_wasm_reftype_tc) << 1;
16967 Diag(
Loc, diag::err_catch_sizeless) << (Mode == 2 ? 1 : 0) << BaseType;
16973 diag::err_abstract_type_in_decl,
16985 Diag(
Loc, diag::err_objc_object_catch);
16990 Diag(
Loc, diag::warn_objc_pointer_cxx_catch_fragile);
16999 if (
getLangOpts().ObjCAutoRefCount &&
ObjC().inferObjCARCLifetime(ExDecl))
17024 Expr *opaqueValue =
17068 RedeclarationKind::ForVisibleRedeclaration)) {
17072 assert(!S->isDeclScope(PrevDecl));
17076 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
17078 }
else if (PrevDecl->isTemplateParameter())
17106 Expr *AssertMessageExpr,
17112 AssertMessageExpr, RParenLoc,
false);
17117 case BuiltinType::Char_S:
17118 case BuiltinType::Char_U:
17120 case BuiltinType::Char8:
17123 case BuiltinType::Char16:
17126 case BuiltinType::Char32:
17129 case BuiltinType::WChar_S:
17130 case BuiltinType::WChar_U:
17134 llvm_unreachable(
"Non-character type");
17144 char Arr[UNI_MAX_UTF8_BYTES_PER_CODE_POINT];
17147 llvm::raw_svector_ostream
OS(Str);
17151 if (K == BuiltinType::Char_S || K == BuiltinType::Char_U ||
17152 K == BuiltinType::Char8 ||
Value <= 0x7F) {
17153 StringRef Escaped = escapeCStyle<EscapeChar::Single>(
Value);
17154 if (!Escaped.empty())
17157 OS << static_cast<char>(
Value);
17162 case BuiltinType::Char16:
17163 case BuiltinType::Char32:
17164 case BuiltinType::WChar_S:
17165 case BuiltinType::WChar_U: {
17166 if (llvm::ConvertCodePointToUTF8(
Value, Ptr))
17170 << llvm::format_hex_no_prefix(
Value, TyWidth / 4,
true);
17174 llvm_unreachable(
"Non-character type is passed");
17186 switch (
V.getKind()) {
17192 int64_t BoolValue =
V.getInt().getExtValue();
17193 assert((BoolValue == 0 || BoolValue == 1) &&
17194 "Bool type, but value is not 0 or 1");
17195 llvm::raw_svector_ostream
OS(Str);
17196 OS << (BoolValue ?
"true" :
"false");
17198 llvm::raw_svector_ostream
OS(Str);
17203 switch (BTy->getKind()) {
17204 case BuiltinType::Char_S:
17205 case BuiltinType::Char_U:
17206 case BuiltinType::Char8:
17207 case BuiltinType::Char16:
17208 case BuiltinType::Char32:
17209 case BuiltinType::WChar_S:
17210 case BuiltinType::WChar_U: {
17212 assert(8 <= TyWidth && TyWidth <= 32 &&
"Unexpected integer width");
17213 uint32_t CodeUnit =
static_cast<uint32_t
>(
V.getInt().getZExtValue());
17218 << llvm::format_hex_no_prefix(CodeUnit, 2,
17220 <<
", " <<
V.getInt() <<
')';
17227 V.getInt().toString(Str);
17233 V.getFloat().toString(Str);
17237 if (
V.isNullPointer()) {
17238 llvm::raw_svector_ostream
OS(Str);
17245 llvm::raw_svector_ostream
OS(Str);
17247 V.getComplexFloatReal().toString(Str);
17249 V.getComplexFloatImag().toString(Str);
17254 llvm::raw_svector_ostream
OS(Str);
17256 V.getComplexIntReal().toString(Str);
17258 V.getComplexIntImag().toString(Str);
17281 if (isa<SubstNonTypeTemplateParmExpr>(E))
17285 if (
const auto *UnaryOp = dyn_cast<UnaryOperator>(E))
17289 if (
const auto *BO = dyn_cast<BinaryOperator>(E))
17290 return (BO->isShiftOp() || BO->isAdditiveOp() || BO->isMultiplicativeOp() ||
17291 BO->isBitwiseOp());
17299 if (
const auto *Op = dyn_cast<BinaryOperator>(E);
17300 Op && Op->getOpcode() != BO_LOr) {
17301 const Expr *LHS = Op->getLHS()->IgnoreParenImpCasts();
17302 const Expr *RHS = Op->getRHS()->IgnoreParenImpCasts();
17320 for (
unsigned I = 0; I < 2; I++) {
17321 const Expr *Side = DiagSide[I].Cond;
17325 DiagSide[I].Print =
17327 DiagSide[I].ValueString,
Context);
17329 if (DiagSide[0].Print && DiagSide[1].Print) {
17330 Diag(Op->getExprLoc(), diag::note_expr_evaluates_to)
17331 << DiagSide[0].ValueString << Op->getOpcodeStr()
17332 << DiagSide[1].ValueString << Op->getSourceRange();
17340 bool ErrorOnInvalidMessage) {
17342 assert(!Message->isTypeDependent() && !Message->isValueDependent() &&
17343 "can't evaluate a dependant static assert message");
17345 if (
const auto *SL = dyn_cast<StringLiteral>(Message)) {
17346 assert(SL->isUnevaluated() &&
"expected an unevaluated string");
17347 Result.assign(SL->getString().begin(), SL->getString().end());
17352 QualType T = Message->getType().getNonReferenceType();
17355 Diag(
Loc, diag::err_static_assert_invalid_message);
17359 auto FindMember = [&](StringRef
Member,
bool &Empty,
17360 bool Diag =
false) -> std::optional<LookupResult> {
17364 Empty = MemberLookup.
empty();
17367 if (MemberLookup.
empty())
17368 return std::nullopt;
17369 return std::move(MemberLookup);
17372 bool SizeNotFound, DataNotFound;
17373 std::optional<LookupResult> SizeMember = FindMember(
"size", SizeNotFound);
17374 std::optional<LookupResult> DataMember = FindMember(
"data", DataNotFound);
17375 if (SizeNotFound || DataNotFound) {
17376 Diag(
Loc, diag::err_static_assert_missing_member_function)
17377 << ((SizeNotFound && DataNotFound) ? 2
17383 if (!SizeMember || !DataMember) {
17385 FindMember(
"size", SizeNotFound,
true);
17387 FindMember(
"data", DataNotFound,
true);
17393 Message, Message->getType(), Message->getBeginLoc(),
false,
17418 Diag(
Loc, diag::err_static_assert_invalid_mem_fn_ret_ty) << 0;
17428 Diag(
Loc, diag::err_static_assert_invalid_mem_fn_ret_ty) << 1;
17432 if (!ErrorOnInvalidMessage &&
17438 Status.Diag = &Notes;
17439 if (!Message->EvaluateCharRangeAsString(
Result, EvaluatedSize.
get(),
17440 EvaluatedData.
get(), Ctx, Status) ||
17442 Diag(Message->getBeginLoc(),
17443 ErrorOnInvalidMessage ? diag::err_static_assert_message_constexpr
17444 : diag::warn_static_assert_message_constexpr);
17445 for (
const auto &
Note : Notes)
17447 return !ErrorOnInvalidMessage;
17453 Expr *AssertExpr,
Expr *AssertMessage,
17456 assert(AssertExpr !=
nullptr &&
"Expected non-null condition");
17474 AssertExpr = FullAssertExpr.
get();
17477 Expr *BaseExpr = AssertExpr;
17489 diag::err_static_assert_expression_is_not_constant,
17495 if (!Failed && AssertMessage && Cond.getBoolValue()) {
17504 bool InTemplateDefinition =
17507 if (!Failed && !Cond && !InTemplateDefinition) {
17509 llvm::raw_svector_ostream Msg(MsgBuffer);
17510 bool HasMessage = AssertMessage;
17511 if (AssertMessage) {
17515 AssertMessage, Str,
Context,
true) ||
17519 Expr *InnerCond =
nullptr;
17520 std::string InnerCondDescription;
17521 std::tie(InnerCond, InnerCondDescription) =
17523 if (InnerCond && isa<ConceptSpecializationExpr>(InnerCond)) {
17531 }
else if (InnerCond && !isa<CXXBoolLiteralExpr>(InnerCond)
17532 && !isa<IntegerLiteral>(InnerCond)) {
17534 diag::err_static_assert_requirement_failed)
17535 << InnerCondDescription << !HasMessage << Msg.str()
17552 AssertExpr = FullAssertExpr.
get();
17556 AssertExpr, AssertMessage, RParenLoc,
17571 bool IsMemberSpecialization =
false;
17576 TagLoc, NameLoc, SS,
nullptr, TempParamLists,
true,
17577 IsMemberSpecialization,
Invalid)) {
17578 if (TemplateParams->size() > 0) {
17586 FriendLoc, TempParamLists.size() - 1,
17587 TempParamLists.data()).
get();
17590 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
17592 IsMemberSpecialization =
true;
17598 bool isAllExplicitSpecializations =
true;
17599 for (
unsigned I = TempParamLists.size(); I-- > 0; ) {
17600 if (TempParamLists[I]->size()) {
17601 isAllExplicitSpecializations =
false;
17611 if (isAllExplicitSpecializations) {
17613 bool Owned =
false;
17614 bool IsDependent =
false;
17635 if (isa<DependentNameType>(
T)) {
17649 TSI, FriendLoc, TempParamLists);
17655 assert(SS.
isNotEmpty() &&
"valid templated tag with no SS and no direct?");
17662 Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
17673 TSI, FriendLoc, TempParamLists);
17715 Diag(FriendLoc, diag::err_friend_not_first_in_declaration);
17743 if (TempParams.size()) {
17760 ? diag::warn_cxx98_compat_unelaborated_friend_type
17761 : diag::ext_unelaborated_friend_type)
17767 ? diag::warn_cxx98_compat_nonclass_type_friend
17768 : diag::ext_nonclass_type_friend)
17785 if (!TempParams.empty())
17822 Diag(
Loc, diag::err_unexpected_friend);
17857 Scope *DCScope = S;
17859 RedeclarationKind::ForExternalRedeclaration);
17869 (FunctionContainingLocalClass =
17870 cast<CXXRecordDecl>(
CurContext)->isLocalClass())) {
17882 DCScope = S->getFnParent();
17892 DC =
Previous.getRepresentativeDecl()->getDeclContext();
17896 DC = FunctionContainingLocalClass;
17933 if (isTemplateId) {
17934 if (isa<TranslationUnitDecl>(LookupDC))
break;
17948 if (!DC)
return nullptr;
17959 diag::warn_cxx98_compat_friend_is_member :
17960 diag::err_friend_is_member);
17969 assert(isa<CXXRecordDecl>(DC) &&
"friend declaration not in class?");
17996 if (DiagArg >= 0) {
17997 Diag(
Loc, diag::err_introducing_special_friend) << DiagArg;
18008 DCScope = &FakeDCScope;
18011 bool AddToScope =
true;
18013 TemplateParams, AddToScope);
18014 if (!ND)
return nullptr;
18048 FD = FTD->getTemplatedDecl();
18050 FD = cast<FunctionDecl>(ND);
18070 }
else if (FunctionContainingLocalClass) {
18079 }
else if (isTemplateId) {
18093 Diag(FD->
getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
18095 diag::note_previous_declaration);
18097 Diag(FD->
getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
18102 Diag(FD->
getLocation(), diag::warn_template_qualified_friend_unsupported)
18118 FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
18120 Diag(DelLoc, diag::err_deleted_non_function);
18131 Prev->getPreviousDecl()) &&
18132 !Prev->isDefined()) {
18133 Diag(DelLoc, diag::err_deleted_decl_not_first);
18134 Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
18135 Prev->isImplicit() ? diag::note_previous_implicit_declaration
18136 : diag::note_previous_declaration);
18159 Diag(DelLoc, diag::err_deleted_main);
18171 auto *FD = dyn_cast<FunctionDecl>(Dcl);
18173 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(Dcl)) {
18175 Diag(DefaultLoc, diag::err_defaulted_comparison_template);
18180 Diag(DefaultLoc, diag::err_default_special_members)
18191 (!FD->isDependentContext() ||
18192 (!isa<CXXConstructorDecl>(FD) &&
18194 Diag(DefaultLoc, diag::err_default_special_members)
18204 ? diag::warn_cxx17_compat_defaulted_comparison
18205 : diag::ext_defaulted_comparison);
18208 FD->setDefaulted();
18209 FD->setExplicitlyDefaulted();
18210 FD->setDefaultLoc(DefaultLoc);
18213 if (FD->isDependentContext())
18219 FD->setWillHaveBody(
false);
18232 if (isa<CXXMethodDecl>(FD)) {
18234 if (
const FunctionDecl *Pattern = FD->getTemplateInstantiationPattern())
18248 auto *MD = cast<CXXMethodDecl>(FD);
18259 for (
Stmt *SubStmt : S->children()) {
18262 if (isa<ReturnStmt>(SubStmt))
18263 Self.Diag(SubStmt->getBeginLoc(),
18264 diag::err_return_in_constructor_handler);
18265 if (!isa<Expr>(SubStmt))
18271 for (
unsigned I = 0, E = TryBlock->
getNumHandlers(); I != E; ++I) {
18279 switch (BodyKind) {
18288 "Parsed function body should be '= delete;' or '= default;'");
18298 for (
unsigned I = 0, E = OldFT->
getNumParams(); I != E; ++I)
18302 !NewFT->getExtParameterInfo(I).isNoEscape()) {
18304 diag::warn_overriding_method_missing_noescape);
18306 diag::note_overridden_marked_noescape);
18312 Diag(New->
getLocation(), diag::err_conflicting_overriding_attributes)
18319 const auto *OldCSA = Old->
getAttr<CodeSegAttr>();
18320 const auto *NewCSA = New->
getAttr<CodeSegAttr>();
18321 if ((NewCSA || OldCSA) &&
18322 (!OldCSA || !NewCSA || NewCSA->getName() != OldCSA->getName())) {
18331 if (NewCC == OldCC)
18342 diag::err_conflicting_overriding_cc_attributes)
18355 diag::err_explicit_object_parameter_nonmember)
18382 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
18390 if (NewClassTy.
isNull()) {
18392 diag::err_different_return_type_for_overriding_virtual_function)
18408 if (!RT->isBeingDefined() &&
18410 diag::err_covariant_return_incomplete,
18427 NewClassTy, OldClassTy,
18428 diag::err_covariant_return_inaccessible_base,
18429 diag::err_covariant_return_ambiguous_derived_to_base_conv,
18445 diag::err_covariant_return_type_different_qualifications)
18457 diag::err_covariant_return_type_class_type_more_qualified)
18492 else if (
auto *M = dyn_cast<CXXMethodDecl>(D))
18531 if (
auto *VD = dyn_cast<VarDecl>(D);
18561 "Parser allowed 'typedef' as storage class of condition decl.");
18567 if (isa<FunctionDecl>(Dcl)) {
18573 if (
auto *VD = dyn_cast<VarDecl>(Dcl))
18586 for (
unsigned I = 0, N = VTables.size(); I != N; ++I) {
18587 llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
18591 if (!Pos->second && VTables[I].DefinitionRequired)
18592 Pos->second =
true;
18596 VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
18597 NewUses.push_back(
VTableUse(VTables[I].
Record, VTables[I].Location));
18604 bool DefinitionRequired) {
18607 if (!
Class->isDynamicClass() ||
Class->isDependentContext() ||
18613 !
OpenMP().isInOpenMPDeclareTargetContext() &&
18614 !
OpenMP().isInOpenMPTargetExecutionDirective()) {
18615 if (!DefinitionRequired)
18623 std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator,
bool>
18629 if (DefinitionRequired && !Pos.first->second) {
18630 Pos.first->second =
true;
18659 if (
Class->isLocalClass())
18674 bool DefinedAnything =
false;
18675 for (
unsigned I = 0; I !=
VTableUses.size(); ++I) {
18680 Class->getTemplateSpecializationKind();
18684 bool DefineVTable =
true;
18690 if (KeyFunction && !KeyFunction->
hasBody()) {
18692 DefineVTable =
false;
18697 "Instantiations don't have key functions");
18699 }
else if (!KeyFunction) {
18704 bool IsExplicitInstantiationDeclaration =
18706 for (
auto *R :
Class->redecls()) {
18708 = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
18710 IsExplicitInstantiationDeclaration =
true;
18712 IsExplicitInstantiationDeclaration =
false;
18717 if (IsExplicitInstantiationDeclaration)
18718 DefineVTable =
false;
18724 if (!DefineVTable) {
18732 DefinedAnything =
true;
18745 if (!KeyFunction || (KeyFunction->
hasBody(KeyFunctionDef) &&
18752 return DefinedAnything;
18757 for (
const auto *I : RD->
methods())
18758 if (I->isVirtual() && !I->isPureVirtual())
18764 bool ConstexprOnly) {
18768 for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
18769 E = FinalOverriders.end();
18772 OE = I->second.end();
18774 assert(OI->second.size() > 0 &&
"no final overrider");
18789 for (
const auto &I : RD->
bases()) {
18792 if (
Base->getNumVBases() == 0)
18815 cast_or_null<CXXConstructorDecl>(FNTarget));
18822 if (!Current.insert(Canonical).second)
18827 Target->isInvalidDecl() || Valid.count(TCanonical)) {
18828 Valid.insert(Current.begin(), Current.end());
18831 }
else if (TCanonical == Canonical ||
Invalid.count(TCanonical) ||
18832 Current.count(TCanonical)) {
18834 if (!
Invalid.count(TCanonical)) {
18836 diag::warn_delegating_ctor_cycle)
18840 if (TCanonical != Canonical)
18841 S.
Diag(
Target->getLocation(), diag::note_it_delegates_to);
18844 while (
C->getCanonicalDecl() != Canonical) {
18846 (void)
C->getTargetConstructor()->hasBody(FNTarget);
18847 assert(FNTarget &&
"Ctor cycle through bodiless function");
18850 cast<CXXConstructorDecl>(FNTarget));
18851 S.
Diag(
C->getLocation(), diag::note_which_delegates_to);
18855 Invalid.insert(Current.begin(), Current.end());
18866 for (DelegatingCtorDeclsType::iterator
18872 for (
auto CI =
Invalid.begin(), CE =
Invalid.end(); CI != CE; ++CI)
18873 (*CI)->setInvalidDecl();
18882 explicit FindCXXThisExpr(
Sema &S) : S(S) { }
18910 FindCXXThisExpr Finder(*
this);
18923 if (!Finder.TraverseStmt(E))
18940 FindCXXThisExpr Finder(*
this);
18962 if (!Finder.TraverseType(E))
18972 FindCXXThisExpr Finder(*
this);
18975 for (
const auto *A : Method->
attrs()) {
18977 Expr *Arg =
nullptr;
18979 if (
const auto *G = dyn_cast<GuardedByAttr>(A))
18981 else if (
const auto *G = dyn_cast<PtGuardedByAttr>(A))
18983 else if (
const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
18985 else if (
const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
18987 else if (
const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
18988 Arg = ETLF->getSuccessValue();
18990 }
else if (
const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
18991 Arg = STLF->getSuccessValue();
18993 }
else if (
const auto *LR = dyn_cast<LockReturnedAttr>(A))
18994 Arg = LR->getArg();
18995 else if (
const auto *LE = dyn_cast<LocksExcludedAttr>(A))
18997 else if (
const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
18999 else if (
const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
19001 else if (
const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
19003 else if (
const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
19006 if (Arg && !Finder.TraverseStmt(Arg))
19009 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
19010 if (!Finder.TraverseStmt(Args[I]))
19024 Exceptions.clear();
19027 Exceptions.reserve(DynamicExceptions.size());
19028 for (
unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
19035 if (!Unexpanded.empty()) {
19046 Exceptions.push_back(ET);
19056 "Parser should have made sure that the expression is boolean");
19076 D = FTD->getTemplatedDecl();
19086 DynamicExceptionRanges, NoexceptExpr, Exceptions,
19114 Diag(DeclStart, diag::err_anonymous_property);
19139 diag::err_invalid_thread)
19145 RedeclarationKind::ForVisibleRedeclaration);
19147 switch (
Previous.getResultKind()) {
19154 PrevDecl =
Previous.getRepresentativeDecl();
19167 PrevDecl =
nullptr;
19171 PrevDecl =
nullptr;
19182 Record->setInvalidDecl();
19204 if (!ExplicitLists.empty()) {
19205 bool IsMemberSpecialization, IsInvalid;
19209 ExplicitLists,
false, IsMemberSpecialization, IsInvalid,
19221 if (ExplicitParams && !ExplicitParams->
empty()) {
19222 Info.AutoTemplateParameterDepth = ExplicitParams->
getDepth();
19223 llvm::append_range(Info.TemplateParams, *ExplicitParams);
19224 Info.NumExplicitTemplateParams = ExplicitParams->
size();
19226 Info.AutoTemplateParameterDepth = TemplateParameterDepth;
19227 Info.NumExplicitTemplateParams = 0;
19233 if (FSI.TemplateParams.size() > FSI.NumExplicitTemplateParams) {
19234 if (FSI.NumExplicitTemplateParams != 0) {
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
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 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 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.
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.
bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y) const
Determine whether the given template names refer to the same template.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
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.
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 bool isCompoundAssignmentOp(Opcode Opc)
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...
DeclContext::lookup_iterator Decls
The declarations found inside this base class subobject.
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.
Expr * getArg(unsigned Arg)
Return the specified argument.
bool isImmediateEscalating() const
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
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 defaultedDestructorIsDeleted() const
true if a defaulted destructor for this class would be deleted.
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 hasNonTrivialCopyConstructorForCall() const
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 hasNonTrivialDestructorForCall() const
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
SourceLocation getLocation() 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]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
bool isCallToStdMove() const
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.
CastKind getCastKind() const
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.
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
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?
bool isImmediateEscalating() const
Captures information about "declaration specifiers".
bool isVirtualSpecified() const
bool isModulePrivateSpecified() const
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec and return false if there was no error.
Expr * getPackIndexingExpr() const
void ClearStorageClassSpecs()
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
TSCS getThreadStorageClassSpec() const
bool isFriendSpecifiedFirst() const
ParsedAttributes & getAttributes()
SourceLocation getEllipsisLoc() const
SourceLocation getConstSpecLoc() const
SourceRange getExplicitSpecRange() const
Expr * getRepAsExpr() const
bool isInlineSpecified() const
SourceLocation getRestrictSpecLoc() const
bool SetTypeQual(TQ T, SourceLocation Loc)
void ClearConstexprSpec()
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
SourceLocation getThreadStorageClassSpecLoc() const
SourceLocation getAtomicSpecLoc() const
SourceLocation getVirtualSpecLoc() 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 getInlineSpecLoc() const
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.
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.
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
bool isDeclarationOfFunction() const
Determine whether the declaration that will be produced from this declaration will be a function.
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
bool isFunctionDeclarationContext() const
Return true if this declaration appears in a context where a function declarator would be a function ...
SourceLocation getIdentifierLoc() const
void SetIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Set the name of this declarator to be the given identifier.
type_object_range type_objects() const
Returns the range of type objects, from the identifier outwards.
bool hasGroupingParens() const
void setInvalidType(bool Val=true)
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
bool isRedeclaration() const
DeclaratorContext getContext() const
const DecompositionDeclarator & getDecompositionDeclarator() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isFunctionDefinition() const
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
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 mayHaveDecompositionDeclarator() const
Return true if the context permits a C++17 decomposition declarator.
bool isInvalidType() const
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
bool isDecompositionDeclarator() const
Return whether this declarator is a decomposition declarator.
bool isStaticMember()
Returns true if this declares a static member.
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
const IdentifierInfo * getIdentifier() const
A decomposition declaration.
ArrayRef< BindingDecl * > bindings() const
A parsed C++17 decomposition declarator of the form '[' identifier-list ']'.
ArrayRef< Binding > bindings() const
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) ...
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.
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.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
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 removeInClassInitializer()
Remove the C++11 in-class initializer from this member.
void setInClassInitializer(Expr *NewInit)
Set the C++11 in-class initializer for this member.
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, ArrayRef< TemplateParameterList * > FriendTypeTPLists=std::nullopt)
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
void setWillHaveBody(bool V=true)
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...
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 isMain() const
Determines whether this function is "main", which is the entry point into an executable program.
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
bool 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...
void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)
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.
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'.
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 nested inside 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()
const ParsedAttr * getMSPropertyAttr() const
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 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 isMoreQualifiedThan(QualType Other) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
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).
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
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
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.
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)
bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, const CXXMethodDecl *Old)
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 ActOnIntegerConstant(SourceLocation Loc, uint64_t Val)
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 * 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)
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.
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)
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)
CheckForFunctionMarkedFinal - Checks whether a virtual member function overrides a virtual member fun...
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
TemplateParameterList * MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, ArrayRef< TemplateParameterList * > ParamLists, bool IsFriend, bool &IsMemberSpecialization, bool &Invalid, bool SuppressDiagnostic=false)
Match the given template parameter lists to the given scope specifier, returning the template paramet...
void handleTagNumbering(const TagDecl *Tag, Scope *TagScope)
void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl)
AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared special functions,...
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())
Decl * ActOnUsingEnumDeclaration(Scope *CurScope, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceLocation IdentLoc, IdentifierInfo &II, CXXScopeSpec *SS=nullptr)
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)
bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, ArrayRef< CXXCtorInitializer * > Initializers=std::nullopt)
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)
ActOnBaseSpecifier - Parsed a base 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.
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)
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams)
Handle a friend type declaration.
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
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.
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.
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, Expr *Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member,...
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.
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type.
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...
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
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 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)
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)
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
DeclResult ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc, unsigned TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, MultiTemplateParamsArg TempParamLists)
Handle a friend tag declaration where the scope specifier was templated.
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.
NamedDecl * ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef< BindingDecl * > Bindings=std::nullopt)
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...
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.
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() const
Retrieve the underlying template declaration that this template name refers to, if known.
@ UsingTemplate
A template name that refers to a template declaration found through a specific using shadow declarati...
@ Template
A single template declaration.
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 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),...
Expr * getSubExpr() const
static bool isIncrementDecrementOp(Opcode Op)
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.
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
UnionParsedType DestructorName
When Kind == IK_DestructorName, the type referred to by the class-name.
UnionParsedTemplateTy TemplateName
When Kind == IK_DeductionGuideName, the parsed template-name.
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent)
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.
@ 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.
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.
@ 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.
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< 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.
enum clang::DeclaratorChunk::@221 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
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.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
OpaquePtr< T > get() const