49#include "llvm/ADT/ArrayRef.h"
50#include "llvm/ADT/STLExtras.h"
51#include "llvm/ADT/STLForwardCompat.h"
52#include "llvm/ADT/ScopeExit.h"
53#include "llvm/ADT/SmallString.h"
54#include "llvm/ADT/StringExtras.h"
55#include "llvm/Support/ConvertUTF.h"
56#include "llvm/Support/SaveAndRestore.h"
73class CheckDefaultArgumentVisitor
76 const Expr *DefaultArg;
79 CheckDefaultArgumentVisitor(
Sema &S,
const Expr *DefaultArg)
80 : S(S), DefaultArg(DefaultArg) {}
85 bool VisitLambdaExpr(
const LambdaExpr *Lambda);
90bool CheckDefaultArgumentVisitor::VisitExpr(
const Expr *
Node) {
91 bool IsInvalid =
false;
92 for (
const Stmt *SubStmt :
Node->children())
94 IsInvalid |= Visit(SubStmt);
101bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(
const DeclRefExpr *DRE) {
104 if (!isa<VarDecl, BindingDecl>(
Decl))
107 if (
const auto *Param = dyn_cast<ParmVarDecl>(
Decl)) {
118 diag::err_param_default_argument_references_param)
119 << Param->getDeclName() << DefaultArg->getSourceRange();
120 }
else if (
auto *VD =
Decl->getPotentiallyDecomposedVarDecl()) {
135 diag::err_param_default_argument_references_local)
142bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(
const CXXThisExpr *ThisE) {
147 diag::err_param_default_argument_references_this)
151bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(
156 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E)) {
157 E = OVE->getSourceExpr();
158 assert(E &&
"pseudo-object binding without source expression?");
166bool CheckDefaultArgumentVisitor::VisitLambdaExpr(
const LambdaExpr *Lambda) {
175 return S.
Diag(LC.getLocation(), diag::err_lambda_capture_default_arg);
177 auto *D = cast<VarDecl>(LC.getCapturedVar());
178 Invalid |= Visit(D->getInit());
210 llvm_unreachable(
"should not see unresolved exception specs here");
239 "should not generate implicit declarations for dependent cases");
243 assert(EST ==
EST_Dynamic &&
"EST case not considered earlier.");
245 "Shouldn't collect exceptions when throw-all is guaranteed.");
250 Exceptions.push_back(E);
278 if (
Self->canThrow(S))
285 diag::err_typecheck_decl_incomplete_type))
304 CheckCompletedExpr(Arg, EqualLoc);
317 UnparsedDefaultArgInstantiationsMap::iterator InstPos
320 for (
unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
321 InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
334 if (!param || !DefaultArg)
342 Diag(EqualLoc, diag::err_param_default_argument)
355 Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
369 CheckDefaultArgumentVisitor DefaultArgChecker(*
this, DefaultArg);
370 if (DefaultArgChecker.Visit(DefaultArg))
407 Param->
getType().getNonReferenceType());
429 if (MightBeFunction) {
433 MightBeFunction =
false;
436 for (
unsigned argIdx = 0, e = chunk.
Fun.
NumParams; argIdx != e;
440 std::unique_ptr<CachedTokens> Toks =
443 if (Toks->size() > 1)
445 Toks->back().getLocation());
457 MightBeFunction =
false;
464 return P->hasDefaultArg() && !P->hasInheritedDefaultArg();
485 for (; PrevForDefaultArgs;
533 for (
unsigned p = 0, NumParams = PrevForDefaultArgs
536 p < NumParams; ++p) {
540 bool OldParamHasDfl = OldParam ? OldParam->
hasDefaultArg() :
false;
543 if (OldParamHasDfl && NewParamHasDfl) {
544 unsigned DiagDefaultParamID =
545 diag::err_param_default_argument_redefinition;
560 DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
578 for (
auto Older = PrevForDefaultArgs;
580 Older = Older->getPreviousDecl();
581 OldParam = Older->getParamDecl(p);
586 }
else if (OldParamHasDfl) {
604 }
else if (NewParamHasDfl) {
608 diag::err_param_default_argument_template_redecl)
611 diag::note_template_prev_declaration)
642 if (
Record->getDescribedClassTemplate())
644 else if (isa<ClassTemplatePartialSpecializationDecl>(
Record))
651 diag::err_param_default_argument_member_template_redecl)
661 if (isa<CXXConstructorDecl>(New) &&
665 if (NewSM != OldSM) {
668 Diag(NewParam->
getLocation(), diag::err_default_arg_makes_ctor_special)
703 if (isa<CXXDeductionGuideDecl>(New) &&
715 Diag(New->
getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
736 ? diag::warn_cxx23_placeholder_var_definition
737 : diag::ext_placeholder_var_definition);
755 if (!TemplateParamLists.empty()) {
758 Diag(TemplateParamLists.front()->getTemplateLoc(),
759 diag::err_decomp_decl_template);
765 ? diag::ext_decomp_decl
767 ? diag::ext_decomp_decl_cond
768 : diag::warn_cxx14_compat_decomp_decl)
791 if (
auto SCS = DS.getStorageClassSpec()) {
794 CPlusPlus20SpecifierLocs.push_back(DS.getStorageClassSpecLoc());
797 BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
800 if (
auto TSCS = DS.getThreadStorageClassSpec()) {
802 CPlusPlus20SpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
804 if (DS.hasConstexprSpecifier()) {
805 BadSpecifiers.push_back(
807 BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());
809 if (DS.isInlineSpecified()) {
810 BadSpecifiers.push_back(
"inline");
811 BadSpecifierLocs.push_back(DS.getInlineSpecLoc());
814 if (!BadSpecifiers.empty()) {
815 auto &&Err =
Diag(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);
816 Err << (
int)BadSpecifiers.size()
817 << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(),
" ");
820 for (
auto Loc : BadSpecifierLocs)
822 }
else if (!CPlusPlus20Specifiers.empty()) {
823 auto &&Warn =
Diag(CPlusPlus20SpecifierLocs.front(),
825 ? diag::warn_cxx17_compat_decomp_decl_spec
826 : diag::ext_decomp_decl_spec);
827 Warn << (
int)CPlusPlus20Specifiers.size()
828 << llvm::join(CPlusPlus20Specifiers.begin(),
829 CPlusPlus20Specifiers.end(),
" ");
830 for (
auto Loc : CPlusPlus20SpecifierLocs)
842 Diag(DS.getVolatileSpecLoc(),
843 diag::warn_deprecated_volatile_structured_binding);
863 ? diag::err_decomp_decl_parens
864 : diag::err_decomp_decl_type)
875 if (DS.isConstrainedAuto()) {
878 "No other template kind should be possible for a constrained auto");
896 assert(VarName &&
"Cannot have an unnamed binding declaration");
899 RedeclarationKind::ForVisibleRedeclaration);
905 Previous.getFoundDecl()->isTemplateParameter()) {
937 auto *Old =
Previous.getRepresentativeDecl();
938 Diag(B.NameLoc, diag::err_redefinition) << B.Name;
939 Diag(Old->getLocation(), diag::note_previous_definition);
954 RedeclarationKind::ForVisibleRedeclaration);
957 bool AddToScope =
true;
966 if (
OpenMP().isInOpenMPDeclareTargetContext())
976 if ((int64_t)
Bindings.size() != NumElems) {
977 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
990 E = GetInit(Loc, E.
get(), I++);
993 B->setBinding(ElemType, E.
get());
1002 const llvm::APSInt &NumElems,
1005 S,
Bindings, Src, DecompType, NumElems, ElemType,
1036 S,
Bindings, Src, DecompType, llvm::APSInt::get(2),
1040 return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
1048 llvm::raw_svector_ostream
OS(SS);
1060 return std::string(
OS.str());
1067 auto DiagnoseMissing = [&] {
1077 return DiagnoseMissing();
1087 return DiagnoseMissing();
1088 if (
Result.isAmbiguous())
1093 Result.suppressDiagnostics();
1095 S.
Diag(Loc, diag::err_std_type_trait_not_class_template) << Trait;
1107 Loc, TraitTy, DiagID,
1114 assert(RD &&
"specialization of class template is not a class?");
1133namespace {
enum class IsTupleLike { TupleLike, NotTupleLike,
Error }; }
1136 llvm::APSInt &Size) {
1151 return IsTupleLike::NotTupleLike;
1160 : R(R), Args(Args) {}
1163 return S.
Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
1167 } Diagnoser(R, Args);
1172 return IsTupleLike::Error;
1176 return IsTupleLike::Error;
1178 return IsTupleLike::TupleLike;
1193 S, R, Loc,
"tuple_element", Args,
1194 diag::err_decomp_decl_std_tuple_element_not_specialized))
1200 S.
Diag(Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
1212struct InitializingBinding {
1221 ~InitializingBinding() {
1230 const llvm::APSInt &TupleSize) {
1231 if ((int64_t)
Bindings.size() != TupleSize) {
1232 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1248 bool UseMemberGet =
false;
1258 dyn_cast<FunctionTemplateDecl>(D->getUnderlyingDecl())) {
1260 if (TPL->
size() != 0 &&
1261 isa<NonTypeTemplateParmDecl>(TPL->
getParam(0))) {
1263 UseMemberGet =
true;
1272 InitializingBinding InitContext(S, B);
1295 MemberGet, &Args,
nullptr);
1330 B->getDeclName().getAsIdentifierInfo(), RefType,
1334 RefVD->setImplicit();
1336 RefVD->setInlineSpecified();
1337 RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);
1342 E =
Seq.Perform(S, Entity, Kind,
Init);
1348 RefVD->setInit(E.
get());
1357 B->setBinding(
T, E.
get());
1372 return Specifier->getType()->getAsCXXRecordDecl()->hasDirectFields();
1381 ClassWithFields = RD;
1393 for (
auto &
P : Paths) {
1397 BestPath->back().Base->getType())) {
1399 S.
Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1400 <<
false << RD << BestPath->back().Base->getType()
1401 <<
P.back().Base->getType();
1403 }
else if (
P.Access < BestPath->
Access) {
1409 QualType BaseType = BestPath->back().Base->getType();
1411 S.
Diag(Loc, diag::err_decomp_decl_ambiguous_base)
1418 *BestPath, diag::err_decomp_decl_inaccessible_base);
1429 S.
Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1430 << (ClassWithFields == RD) << RD << ClassWithFields
1431 << Paths.front().back().Base->getType();
1442 diag::err_incomplete_type))
1454 auto DiagnoseBadNumberOfBindings = [&]() ->
bool {
1455 unsigned NumFields = llvm::count_if(
1456 RD->
fields(), [](
FieldDecl *FD) { return !FD->isUnnamedBitField(); });
1457 assert(
Bindings.size() != NumFields);
1458 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1468 for (
auto *FD : RD->
fields()) {
1469 if (FD->isUnnamedBitField())
1474 if (!FD->getDeclName()) {
1481 if (FD->isAnonymousStructOrUnion()) {
1484 S.
Diag(FD->getLocation(), diag::note_declared_at);
1493 return DiagnoseBadNumberOfBindings();
1504 BasePair.
getAccess(), FD->getAccess())));
1527 if (FD->isMutable())
1533 return DiagnoseBadNumberOfBindings();
1575 llvm::APSInt TupleSize(32);
1577 case IsTupleLike::Error:
1581 case IsTupleLike::TupleLike:
1586 case IsTupleLike::NotTupleLike:
1595 << DD << !RD << DecompType;
1618 "Should only be called if types are otherwise the same.");
1629 NewType =
P->getPointeeType();
1662 if (FTD->isMemberSpecialization())
1686 diag::err_param_default_argument_missing_name)
1690 diag::err_param_default_argument_missing);
1698template <
typename... Ts>
1708 std::forward<Ts>(DiagArgs)...);
1714 llvm_unreachable(
"unknown CheckConstexprKind");
1722 "this check is obsolete for C++23");
1733 SemaRef.
Diag(Loc, diag::note_constexpr_dtor_subobject)
1741 if (!Check(B.getBaseTypeLoc(), B.getType(),
nullptr))
1744 if (!Check(FD->getLocation(), FD->getType(), FD))
1755 "this check is obsolete for C++23");
1756 unsigned ArgIndex = 0;
1759 e = FT->param_type_end();
1760 i != e; ++i, ++ArgIndex) {
1762 assert(PD &&
"null in a parameter list");
1765 diag::err_constexpr_non_literal_param, ArgIndex + 1,
1778 "this check is obsolete for C++23");
1780 diag::err_constexpr_non_literal_return,
1799 default: llvm_unreachable(
"Invalid tag kind for record diagnostic!");
1830 << isa<CXXConstructorDecl>(NewFD)
1832 for (
const auto &I : RD->
vbases())
1833 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
1834 << I.getSourceRange();
1839 if (!isa<CXXConstructorDecl>(NewFD)) {
1844 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
1848 Diag(Method->
getLocation(), diag::warn_cxx17_compat_constexpr_virtual);
1861 if (WrittenVirtual != Method)
1863 diag::note_overridden_virtual_function);
1874 if (
auto *Dtor = dyn_cast<CXXDestructorDecl>(NewFD)) {
1879 !Dtor->getParent()->defaultedDestructorIsConstexpr()) {
1894 "CheckConstexprFunctionDefinition called on function with no body");
1909 for (
const auto *DclIt : DS->
decls()) {
1910 switch (DclIt->getKind()) {
1911 case Decl::StaticAssert:
1913 case Decl::UsingShadow:
1914 case Decl::UsingDirective:
1915 case Decl::UnresolvedUsingTypename:
1916 case Decl::UnresolvedUsingValue:
1917 case Decl::UsingEnum:
1925 case Decl::TypeAlias: {
1928 const auto *TN = cast<TypedefNameDecl>(DclIt);
1929 if (TN->getUnderlyingType()->isVariablyModifiedType()) {
1932 TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
1935 << isa<CXXConstructorDecl>(Dcl);
1943 case Decl::CXXRecord:
1945 if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) {
1949 ? diag::warn_cxx11_compat_constexpr_type_definition
1950 : diag::ext_constexpr_type_definition)
1951 << isa<CXXConstructorDecl>(Dcl);
1958 case Decl::EnumConstant:
1959 case Decl::IndirectField:
1966 case Decl::Decomposition: {
1971 const auto *VD = cast<VarDecl>(DclIt);
1972 if (VD->isThisDeclarationADefinition()) {
1973 if (VD->isStaticLocal()) {
1977 ? diag::warn_cxx20_compat_constexpr_var
1978 : diag::ext_constexpr_static_var)
1979 << isa<CXXConstructorDecl>(Dcl)
1987 diag::warn_cxx20_compat_constexpr_var,
1988 isa<CXXConstructorDecl>(Dcl),
1991 SemaRef, Kind, VD->getLocation(), VD->getType(),
1992 diag::err_constexpr_local_var_non_literal_type,
1993 isa<CXXConstructorDecl>(Dcl))) {
1996 if (!VD->getType()->isDependentType() &&
1997 !VD->hasInit() && !VD->isCXXForRangeDecl()) {
2002 ? diag::warn_cxx17_compat_constexpr_local_var_no_init
2003 : diag::ext_constexpr_local_var_no_init)
2004 << isa<CXXConstructorDecl>(Dcl);
2014 ? diag::warn_cxx11_compat_constexpr_local_var
2015 : diag::ext_constexpr_local_var)
2016 << isa<CXXConstructorDecl>(Dcl);
2023 case Decl::NamespaceAlias:
2024 case Decl::Function:
2034 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval();
2059 llvm::SmallSet<Decl*, 16> &Inits,
2067 if (Field->isInvalidDecl())
2070 if (Field->isUnnamedBitField())
2076 if (Field->isAnonymousStructOrUnion() &&
2077 (Field->getType()->isUnionType()
2078 ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
2079 : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
2082 if (!Inits.count(Field)) {
2087 ? diag::warn_cxx17_compat_constexpr_ctor_missing_init
2088 : diag::ext_constexpr_ctor_missing_init);
2092 diag::note_constexpr_ctor_missing_init);
2096 }
else if (Field->isAnonymousStructOrUnion()) {
2098 for (
auto *I : RD->
fields())
2101 if (!RD->
isUnion() || Inits.count(I))
2118 switch (S->getStmtClass()) {
2119 case Stmt::NullStmtClass:
2123 case Stmt::DeclStmtClass:
2133 case Stmt::ReturnStmtClass:
2135 if (isa<CXXConstructorDecl>(Dcl)) {
2138 Cxx1yLoc = S->getBeginLoc();
2142 ReturnStmts.push_back(S->getBeginLoc());
2145 case Stmt::AttributedStmtClass:
2149 SemaRef, Dcl, cast<AttributedStmt>(S)->getSubStmt(), ReturnStmts,
2150 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind);
2152 case Stmt::CompoundStmtClass: {
2155 Cxx1yLoc = S->getBeginLoc();
2158 for (
auto *BodyIt : CompStmt->
body()) {
2160 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2166 case Stmt::IfStmtClass: {
2169 Cxx1yLoc = S->getBeginLoc();
2173 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2175 if (
If->getElse() &&
2177 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2182 case Stmt::WhileStmtClass:
2183 case Stmt::DoStmtClass:
2184 case Stmt::ForStmtClass:
2185 case Stmt::CXXForRangeStmtClass:
2186 case Stmt::ContinueStmtClass:
2192 Cxx1yLoc = S->getBeginLoc();
2193 for (
Stmt *SubStmt : S->children()) {
2196 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2201 case Stmt::SwitchStmtClass:
2202 case Stmt::CaseStmtClass:
2203 case Stmt::DefaultStmtClass:
2204 case Stmt::BreakStmtClass:
2208 Cxx1yLoc = S->getBeginLoc();
2209 for (
Stmt *SubStmt : S->children()) {
2212 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2217 case Stmt::LabelStmtClass:
2218 case Stmt::GotoStmtClass:
2220 Cxx2bLoc = S->getBeginLoc();
2221 for (
Stmt *SubStmt : S->children()) {
2224 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2229 case Stmt::GCCAsmStmtClass:
2230 case Stmt::MSAsmStmtClass:
2232 case Stmt::CXXTryStmtClass:
2234 Cxx2aLoc = S->getBeginLoc();
2235 for (
Stmt *SubStmt : S->children()) {
2238 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2243 case Stmt::CXXCatchStmtClass:
2247 SemaRef, Dcl, cast<CXXCatchStmt>(S)->getHandlerBlock(), ReturnStmts,
2248 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2258 Cxx1yLoc = S->getBeginLoc();
2263 SemaRef.
Diag(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
2264 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval();
2279 if (isa<CXXTryStmt>(Body)) {
2301 ? diag::ext_constexpr_function_try_block_cxx20
2302 : diag::warn_cxx17_compat_constexpr_function_try_block)
2303 << isa<CXXConstructorDecl>(Dcl);
2317 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2328 }
else if (Cxx2bLoc.
isValid()) {
2331 ? diag::warn_cxx20_compat_constexpr_body_invalid_stmt
2332 : diag::ext_constexpr_body_invalid_stmt_cxx23)
2333 << isa<CXXConstructorDecl>(Dcl);
2334 }
else if (Cxx2aLoc.
isValid()) {
2337 ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
2338 : diag::ext_constexpr_body_invalid_stmt_cxx20)
2339 << isa<CXXConstructorDecl>(Dcl);
2340 }
else if (Cxx1yLoc.
isValid()) {
2343 ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
2344 : diag::ext_constexpr_body_invalid_stmt)
2345 << isa<CXXConstructorDecl>(Dcl);
2349 = dyn_cast<CXXConstructorDecl>(Dcl)) {
2358 if (Constructor->getNumCtorInitializers() == 0 &&
2364 ? diag::warn_cxx17_compat_constexpr_union_ctor_no_init
2365 : diag::ext_constexpr_union_ctor_no_init);
2370 }
else if (!Constructor->isDependentContext() &&
2371 !Constructor->isDelegatingConstructor()) {
2372 assert(RD->
getNumVBases() == 0 &&
"constexpr ctor with virtual bases");
2376 bool AnyAnonStructUnionMembers =
false;
2377 unsigned Fields = 0;
2379 E = RD->
field_end(); I != E; ++I, ++Fields) {
2380 if (I->isAnonymousStructOrUnion()) {
2381 AnyAnonStructUnionMembers =
true;
2389 if (AnyAnonStructUnionMembers ||
2390 Constructor->getNumCtorInitializers() != RD->
getNumBases() + Fields) {
2394 llvm::SmallSet<Decl*, 16> Inits;
2395 for (
const auto *I: Constructor->inits()) {
2399 Inits.insert(ID->chain_begin(), ID->chain_end());
2402 bool Diagnosed =
false;
2403 for (
auto *I : RD->
fields())
2410 if (ReturnStmts.empty()) {
2421 OK ? diag::warn_cxx11_compat_constexpr_body_no_return
2422 : diag::err_constexpr_body_no_return)
2436 }
else if (ReturnStmts.size() > 1) {
2442 ? diag::warn_cxx11_compat_constexpr_body_multiple_return
2443 : diag::ext_constexpr_body_multiple_return);
2444 for (
unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
2446 diag::note_constexpr_body_previous_return);
2475 diag::ext_constexpr_function_never_constant_expr)
2476 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval()
2478 for (
size_t I = 0, N =
Diags.size(); I != N; ++I)
2496 Diag(it->second, diag::err_immediate_function_used_before_definition)
2509 "expected an immediate function");
2510 assert(FD->
hasBody() &&
"expected the function to have a body");
2511 struct ImmediateEscalatingExpressionsVisitor
2518 bool ImmediateFnIsConstructor;
2523 : SemaRef(SemaRef), ImmediateFn(FD),
2524 ImmediateFnIsConstructor(isa<CXXConstructorDecl>(FD)) {}
2526 bool shouldVisitImplicitCode()
const {
return true; }
2527 bool shouldVisitLambdaBody()
const {
return false; }
2532 if (CurrentConstructor && CurrentInit) {
2540 SemaRef.
Diag(Loc, diag::note_immediate_function_reason)
2541 << ImmediateFn << Fn << Fn->
isConsteval() << IsCall
2542 << isa<CXXConstructorDecl>(Fn) << ImmediateFnIsConstructor
2543 << (InitializedField !=
nullptr)
2544 << (CurrentInit && !CurrentInit->
isWritten())
2545 << InitializedField << Range;
2547 bool TraverseCallExpr(
CallExpr *E) {
2548 if (
const auto *DR =
2550 DR && DR->isImmediateEscalating()) {
2556 if (!getDerived().TraverseStmt(A))
2563 if (
const auto *ReferencedFn = dyn_cast<FunctionDecl>(E->
getDecl());
2565 Diag(E, ReferencedFn,
false);
2583 return Base::TraverseConstructorInitializer(
Init);
2588 return Base::TraverseCXXConstructorDecl(Ctr);
2591 bool TraverseType(
QualType T) {
return true; }
2592 bool VisitBlockExpr(
BlockExpr *
T) {
return true; }
2594 } Visitor(*
this, FD);
2595 Visitor.TraverseDecl(FD);
2614 return dyn_cast_or_null<CXXRecordDecl>(DC);
2617 return dyn_cast_or_null<CXXRecordDecl>(
CurContext);
2642 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
2644 CurDecl = dyn_cast_or_null<CXXRecordDecl>(
CurContext);
2664 for (
const auto &I : Current->bases()) {
2676 Queue.push_back(
Base);
2682 Current = Queue.pop_back_val();
2710 if (
Class->isUnion()) {
2711 Diag(
Class->getLocation(), diag::err_base_clause_on_union)
2718 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
2730 if (BaseDecl->getCanonicalDecl() ==
Class->getCanonicalDecl() ||
2731 ((BaseDecl = BaseDecl->getDefinition()) &&
2733 Diag(BaseLoc, diag::err_circular_inheritance)
2736 if (BaseDecl->getCanonicalDecl() !=
Class->getCanonicalDecl())
2737 Diag(BaseDecl->getLocation(), diag::note_previous_decl)
2750 if (!
Class->getTypeForDecl()->isDependentType())
2751 Class->setInvalidDecl();
2754 Access, TInfo, EllipsisLoc);
2759 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
2766 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
2774 if (
auto *BaseTemplate = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
2786 diag::err_incomplete_base_class, SpecifierRange)) {
2787 Class->setInvalidDecl();
2793 assert(BaseDecl &&
"Record type has no declaration");
2795 assert(BaseDecl &&
"Base type is not incomplete, but has no definition");
2797 assert(CXXBaseDecl &&
"Base type is not a C++ type");
2802 const auto *BaseCSA = CXXBaseDecl->
getAttr<CodeSegAttr>();
2803 const auto *DerivedCSA =
Class->getAttr<CodeSegAttr>();
2804 if ((DerivedCSA || BaseCSA) &&
2805 (!BaseCSA || !DerivedCSA || BaseCSA->getName() != DerivedCSA->getName())) {
2806 Diag(
Class->getLocation(), diag::err_mismatched_code_seg_base);
2807 Diag(CXXBaseDecl->
getLocation(), diag::note_base_class_specified_here)
2819 Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
2827 if (FinalAttr *FA = CXXBaseDecl->
getAttr<FinalAttr>()) {
2828 Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
2830 << FA->isSpelledAsSealed();
2837 Class->setInvalidDecl();
2842 Access, TInfo, EllipsisLoc);
2864 Class->setIsParsingBaseSpecifiers();
2872 Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
2873 << AL << AL.getRange();
2875 Diag(AL.getLoc(), diag::err_base_specifier_attribute)
2876 << AL << AL.isRegularKeywordAttribute() << AL.getRange();
2892 Class->setInvalidDecl();
2909 auto Decl = Rec->getAsCXXRecordDecl();
2912 for (
const auto &BaseSpec :
Decl->bases()) {
2933 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
2940 unsigned NumGoodBases = 0;
2942 for (
unsigned idx = 0; idx < Bases.size(); ++idx) {
2952 Diag(Bases[idx]->getBeginLoc(), diag::err_duplicate_base_class)
2953 << KnownBase->
getType() << Bases[idx]->getSourceRange();
2962 KnownBase = Bases[idx];
2963 Bases[NumGoodBases++] = Bases[idx];
2968 if (Bases.size() > 1)
2973 if (
Class->isInterface() &&
2990 Class->setBases(Bases.data(), NumGoodBases);
2993 for (
unsigned idx = 0; idx < NumGoodBases; ++idx) {
2995 QualType BaseType = Bases[idx]->getType();
3005 if (IndirectBaseTypes.count(CanonicalBase)) {
3009 =
Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
3013 if (Paths.isAmbiguous(CanonicalBase))
3014 Diag(Bases[idx]->getBeginLoc(), diag::warn_inaccessible_base_class)
3016 << Bases[idx]->getSourceRange();
3018 assert(Bases[idx]->isVirtual());
3034 if (!ClassDecl || Bases.empty())
3095 for (
unsigned I = Path.size(); I != 0; --I) {
3096 if (Path[I - 1].
Base->isVirtual()) {
3103 for (
unsigned I = Start, E = Path.size(); I != E; ++I)
3110 assert(BasePathArray.empty() &&
"Base path array must be empty!");
3111 assert(Paths.isRecordingPaths() &&
"Must record paths!");
3112 return ::BuildBasePathArray(Paths.front(), BasePathArray);
3128 unsigned InaccessibleBaseID,
3129 unsigned AmbiguousBaseConvID,
3133 bool IgnoreAccess) {
3141 if (!DerivationOkay)
3146 Path = &Paths.front();
3153 if (PossiblePath.size() == 1) {
3154 Path = &PossiblePath;
3155 if (AmbiguousBaseConvID)
3156 Diag(Loc, diag::ext_ms_ambiguous_direct_base)
3157 <<
Base << Derived << Range;
3164 if (!IgnoreAccess) {
3183 if (AmbiguousBaseConvID) {
3191 Paths.setRecordingPaths(
true);
3193 assert(StillOkay &&
"Can only be used with a derived-to-base conversion");
3202 Diag(Loc, AmbiguousBaseConvID)
3203 << Derived <<
Base << PathDisplayStr << Range << Name;
3212 bool IgnoreAccess) {
3214 Derived,
Base, diag::err_upcast_to_inaccessible_base,
3215 diag::err_ambiguous_derived_to_base_conv, Loc, Range,
DeclarationName(),
3216 BasePath, IgnoreAccess);
3233 std::string PathDisplayStr;
3234 std::set<unsigned> DisplayedPaths;
3236 Path != Paths.end(); ++Path) {
3237 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
3240 PathDisplayStr +=
"\n ";
3242 for (CXXBasePath::const_iterator Element = Path->begin();
3243 Element != Path->end(); ++Element)
3244 PathDisplayStr +=
" -> " + Element->Base->getType().getAsString();
3248 return PathDisplayStr;
3259 assert(Access !=
AS_none &&
"Invalid kind for syntactic access specifier!");
3289 if (!OverloadedMethods.empty()) {
3290 if (OverrideAttr *OA = D->
getAttr<OverrideAttr>()) {
3291 Diag(OA->getLocation(),
3292 diag::override_keyword_hides_virtual_member_function)
3293 <<
"override" << (OverloadedMethods.size() > 1);
3294 }
else if (FinalAttr *FA = D->
getAttr<FinalAttr>()) {
3295 Diag(FA->getLocation(),
3296 diag::override_keyword_hides_virtual_member_function)
3297 << (FA->isSpelledAsSealed() ?
"sealed" :
"final")
3298 << (OverloadedMethods.size() > 1);
3309 if (OverrideAttr *OA = D->
getAttr<OverrideAttr>()) {
3310 Diag(OA->getLocation(),
3311 diag::override_keyword_only_allowed_on_virtual_member_functions)
3315 if (FinalAttr *FA = D->
getAttr<FinalAttr>()) {
3316 Diag(FA->getLocation(),
3317 diag::override_keyword_only_allowed_on_virtual_member_functions)
3318 << (FA->isSpelledAsSealed() ?
"sealed" :
"final")
3330 if (MD->
hasAttr<OverrideAttr>() && !HasOverriddenMethods)
3331 Diag(MD->
getLocation(), diag::err_function_marked_override_not_overriding)
3351 auto EmitDiag = [&](
unsigned DiagInconsistent,
unsigned DiagSuggest) {
3360 if (isa<CXXDestructorDecl>(MD))
3362 diag::warn_inconsistent_destructor_marked_not_override_overriding,
3363 diag::warn_suggest_destructor_marked_not_override_overriding);
3365 EmitDiag(diag::warn_inconsistent_function_marked_not_override_overriding,
3366 diag::warn_suggest_function_marked_not_override_overriding);
3375 FinalAttr *FA = Old->
getAttr<FinalAttr>();
3381 << FA->isSpelledAsSealed();
3390 return !RD->isCompleteDefinition() ||
3391 !RD->hasTrivialDefaultConstructor() ||
3392 !RD->hasTrivialDestructor();
3405 std::map<CXXRecordDecl*, NamedDecl*> Bases;
3408 const auto Base =
Specifier->getType()->getAsCXXRecordDecl();
3410 if (Bases.find(
Base) != Bases.end())
3412 for (
const auto Field :
Base->lookup(FieldName)) {
3413 if ((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&
3416 assert(Bases.find(
Base) == Bases.end());
3429 for (
const auto &
P : Paths) {
3430 auto Base =
P.back().Base->getType()->getAsCXXRecordDecl();
3431 auto It = Bases.find(
Base);
3433 if (It == Bases.end())
3435 auto BaseField = It->second;
3436 assert(BaseField->getAccess() !=
AS_private);
3439 Diag(Loc, diag::warn_shadow_field)
3440 << FieldName << RD <<
Base << DeclIsField;
3441 Diag(BaseField->getLocation(), diag::note_shadow_field);
3466 Expr *BitWidth =
static_cast<Expr*
>(BW);
3475 if (cast<CXXRecordDecl>(
CurContext)->isInterface()) {
3479 unsigned InvalidDecl;
3480 bool ShowDeclName =
true;
3490 else switch (Name.getNameKind()) {
3493 ShowDeclName =
false;
3498 ShowDeclName =
false;
3513 Diag(Loc, diag::err_invalid_member_in_interface)
3514 << (InvalidDecl-1) << Name;
3516 Diag(Loc, diag::err_invalid_member_in_interface)
3517 << (InvalidDecl-1) <<
"";
3543 diag::err_storageclass_invalid_for_member);
3563 const char *PrevSpec;
3568 assert(!Failed &&
"Making a constexpr member const shouldn't fail");
3572 const char *PrevSpec;
3578 "This is the only DeclSpec that should fail to be applied");
3582 isInstField =
false;
3592 if (!Name.isIdentifier()) {
3593 Diag(Loc, diag::err_bad_variable_name)
3602 if (TemplateParameterLists.size()) {
3604 if (TemplateParams->
size()) {
3613 diag::err_template_member_noparams)
3652 if (MSPropertyAttr) {
3654 BitWidth, InitStyle, AS, *MSPropertyAttr);
3657 isInstField =
false;
3660 BitWidth, InitStyle, AS);
3665 CheckShadowInheritedFields(Loc, Name, cast<CXXRecordDecl>(
CurContext));
3673 if (
Member->isInvalidDecl()) {
3675 }
else if (isa<VarDecl>(
Member) || isa<VarTemplateDecl>(
Member)) {
3678 Diag(Loc, diag::err_static_not_bitfield)
3680 }
else if (isa<TypedefDecl>(
Member)) {
3682 Diag(Loc, diag::err_typedef_not_bitfield)
3687 Diag(Loc, diag::err_not_integral_type_bitfield)
3688 << Name << cast<ValueDecl>(
Member)->getType()
3693 Member->setInvalidDecl();
3698 NonTemplateMember = FunTmpl->getTemplatedDecl();
3700 NonTemplateMember = VarTmpl->getTemplatedDecl();
3706 if (NonTemplateMember !=
Member)
3712 if (
auto *DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {
3713 auto *TD = DG->getDeducedTemplate();
3716 if (AS != TD->getAccess() &&
3717 TD->getDeclContext()->getRedeclContext()->Equals(
3718 DG->getDeclContext()->getRedeclContext())) {
3719 Diag(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);
3720 Diag(TD->getBeginLoc(), diag::note_deduction_guide_template_access)
3723 for (
const auto *D : cast<CXXRecordDecl>(
CurContext)->decls()) {
3724 if (
const auto *AccessSpec = dyn_cast<AccessSpecDecl>(D))
3725 LastAccessSpec = AccessSpec;
3727 assert(LastAccessSpec &&
"differing access with no access specifier");
3728 Diag(LastAccessSpec->
getBeginLoc(), diag::note_deduction_guide_access)
3739 ? FinalAttr::Keyword_sealed
3740 : FinalAttr::Keyword_final));
3750 assert((Name || isInstField) &&
"No identifier for non-field ?");
3760 auto DeclHasUnusedAttr = [](
const QualType &
T) {
3762 return TD->hasAttr<UnusedAttr>();
3764 return TDT->getDecl()->hasAttr<UnusedAttr>();
3772 !DeclHasUnusedAttr(FD->
getType()) &&
3782 class UninitializedFieldVisitor
3787 llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
3790 llvm::SmallPtrSetImpl<QualType> &BaseClasses;
3805 UninitializedFieldVisitor(
Sema &S,
3806 llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
3807 llvm::SmallPtrSetImpl<QualType> &BaseClasses)
3808 : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
3809 Constructor(nullptr), InitList(
false), InitListFieldDecl(nullptr) {}
3812 bool IsInitListMemberExprInitialized(
MemberExpr *ME,
3813 bool CheckReferenceOnly) {
3815 bool ReferenceField =
false;
3820 Fields.push_back(FD);
3822 ReferenceField =
true;
3828 if (CheckReferenceOnly && !ReferenceField)
3834 for (
const FieldDecl *FD : llvm::drop_begin(llvm::reverse(Fields)))
3837 for (
auto UsedIter = UsedFieldIndex.begin(),
3838 UsedEnd = UsedFieldIndex.end(),
3839 OrigIter = InitFieldIndex.begin(),
3840 OrigEnd = InitFieldIndex.end();
3841 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
3842 if (*UsedIter < *OrigIter)
3844 if (*UsedIter > *OrigIter)
3851 void HandleMemberExpr(
MemberExpr *ME,
bool CheckReferenceOnly,
3864 dyn_cast<MemberExpr>(
Base->IgnoreParenImpCasts())) {
3866 if (isa<VarDecl>(SubME->getMemberDecl()))
3869 if (
FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
3874 AllPODFields =
false;
3876 Base = SubME->getBase();
3879 if (!isa<CXXThisExpr>(
Base->IgnoreParenImpCasts())) {
3884 if (AddressOf && AllPODFields)
3890 while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
3891 BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
3894 if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
3904 if (!Decls.count(FoundVD))
3909 if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
3911 if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
3916 if (CheckReferenceOnly && !IsReference)
3920 unsigned diag = IsReference
3921 ? diag::warn_reference_field_is_uninit
3922 : diag::warn_field_is_uninit;
3926 diag::note_uninit_in_this_constructor)
3931 void HandleValue(
Expr *E,
bool AddressOf) {
3934 if (
MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3935 HandleMemberExpr(ME,
false ,
3941 Visit(CO->getCond());
3942 HandleValue(CO->getTrueExpr(), AddressOf);
3943 HandleValue(CO->getFalseExpr(), AddressOf);
3948 dyn_cast<BinaryConditionalOperator>(E)) {
3949 Visit(BCO->getCond());
3950 HandleValue(BCO->getFalseExpr(), AddressOf);
3955 HandleValue(OVE->getSourceExpr(), AddressOf);
3960 switch (BO->getOpcode()) {
3965 HandleValue(BO->getLHS(), AddressOf);
3966 Visit(BO->getRHS());
3969 Visit(BO->getLHS());
3970 HandleValue(BO->getRHS(), AddressOf);
3979 InitFieldIndex.push_back(0);
3980 for (
auto *Child : ILE->
children()) {
3981 if (
InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
3982 CheckInitListExpr(SubList);
3986 ++InitFieldIndex.back();
3988 InitFieldIndex.pop_back();
3997 DeclsToRemove.clear();
4004 InitListFieldDecl =
Field;
4005 InitFieldIndex.clear();
4006 CheckInitListExpr(ILE);
4020 HandleMemberExpr(ME,
true ,
false );
4029 Inherited::VisitImplicitCastExpr(E);
4035 if (
InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
4039 if (ICE->getCastKind() == CK_NoOp)
4040 ArgExpr = ICE->getSubExpr();
4041 HandleValue(ArgExpr,
false );
4044 Inherited::VisitCXXConstructExpr(E);
4049 if (isa<MemberExpr>(Callee)) {
4050 HandleValue(Callee,
false );
4056 Inherited::VisitCXXMemberCallExpr(E);
4062 HandleValue(E->
getArg(0),
false);
4066 Inherited::VisitCallExpr(E);
4072 if (isa<UnresolvedLookupExpr>(Callee))
4073 return Inherited::VisitCXXOperatorCallExpr(E);
4077 HandleValue(Arg->IgnoreParenImpCasts(),
false );
4087 DeclsToRemove.push_back(FD);
4090 HandleValue(E->
getLHS(),
false );
4095 Inherited::VisitBinaryOperator(E);
4105 HandleValue(ME->
getBase(),
true );
4110 Inherited::VisitUnaryOperator(E);
4120 static void DiagnoseUninitializedFields(
4140 for (
auto *I : RD->
decls()) {
4141 if (
auto *FD = dyn_cast<FieldDecl>(I)) {
4142 UninitializedFields.insert(FD);
4143 }
else if (
auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
4144 UninitializedFields.insert(IFD->getAnonField());
4149 for (
const auto &I : RD->
bases())
4150 UninitializedBaseClasses.insert(I.getType().getCanonicalType());
4152 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
4155 UninitializedFieldVisitor UninitializedChecker(
SemaRef,
4156 UninitializedFields,
4157 UninitializedBaseClasses);
4159 for (
const auto *FieldInit :
Constructor->inits()) {
4160 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
4163 Expr *InitExpr = FieldInit->getInit();
4168 dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
4169 InitExpr =
Default->getExpr();
4173 UninitializedChecker.CheckInitializer(InitExpr, Constructor,
4174 FieldInit->getAnyMember(),
4175 FieldInit->getBaseClass());
4177 UninitializedChecker.CheckInitializer(InitExpr,
nullptr,
4178 FieldInit->getAnyMember(),
4179 FieldInit->getBaseClass());
4202 auto *ParamDecl = cast<NamedDecl>(Param.Param);
4203 if (ParamDecl->getDeclName())
4224 return ConstraintExpr;
4239 return Seq.Perform(*
this, Entity, Kind, InitExpr);
4253 "must set init style when field is created");
4270 assert(
Init.isUsable() &&
"Init should at least have a RecoveryExpr");
4276 if (!
Init.isInvalid())
4278 if (
Init.isInvalid()) {
4296 DirectBaseSpec =
nullptr;
4297 for (
const auto &
Base : ClassDecl->
bases()) {
4301 DirectBaseSpec = &
Base;
4309 VirtualBaseSpec =
nullptr;
4310 if (!DirectBaseSpec || !DirectBaseSpec->
isVirtual()) {
4319 Path != Paths.end(); ++Path) {
4320 if (Path->back().Base->isVirtual()) {
4321 VirtualBaseSpec = Path->back().Base;
4328 return DirectBaseSpec || VirtualBaseSpec;
4343 DS, IdLoc, InitList,
4362 DS, IdLoc, List, EllipsisLoc);
4371 explicit MemInitializerValidatorCCC(
CXXRecordDecl *ClassDecl)
4372 : ClassDecl(ClassDecl) {}
4374 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
4377 return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
4378 return isa<TypeDecl>(ND);
4383 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
4384 return std::make_unique<MemInitializerValidatorCCC>(*
this);
4399 return isa<FieldDecl, IndirectFieldDecl>(Elem) &&
4403 if (Found ==
Result.end())
4405 Diag(Loc, diag::err_using_placeholder_variable) << Name;
4410 if (isa<FieldDecl, IndirectFieldDecl>(ND) &&
4421 for (
auto *D : ClassDecl->
lookup(MemberOrBase)) {
4422 if (isa<FieldDecl, IndirectFieldDecl>(D)) {
4425 if (IsPlaceholder && D->getDeclContext() == ND->
getDeclContext())
4430 return cast<ValueDecl>(D);
4431 ND = cast<ValueDecl>(D);
4469 = dyn_cast<CXXConstructorDecl>(ConstructorD);
4493 ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {
4495 Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
4505 if (TemplateTypeTy) {
4530 bool NotUnknownSpecialization =
false;
4533 NotUnknownSpecialization = !
Record->hasAnyDependentBases();
4535 if (!NotUnknownSpecialization) {
4560 auto *TempSpec = cast<TemplateSpecializationType>(
4561 UnqualifiedBase->getInjectedClassNameSpecialization());
4563 for (
auto const &
Base : ClassDecl->
bases()) {
4567 BaseTemplate->getTemplateName(), TN)) {
4568 Diag(IdLoc, diag::ext_unqualified_base_class)
4570 BaseType =
Base.getType();
4579 MemInitializerValidatorCCC CCC(ClassDecl);
4588 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4589 << MemberOrBase <<
true);
4596 DirectBaseSpec, VirtualBaseSpec)) {
4601 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4602 << MemberOrBase <<
false,
4615 if (!TyD && BaseType.
isNull()) {
4616 Diag(IdLoc, diag::err_mem_init_not_member_or_class)
4617 << MemberOrBase <<
SourceRange(IdLoc,
Init->getSourceRange().getEnd());
4645 assert((DirectMember || IndirectMember) &&
4646 "Member must be a FieldDecl or IndirectFieldDecl");
4651 if (
Member->isInvalidDecl())
4656 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4658 Args =
MultiExprArg(InitList->getInits(), InitList->getNumInits());
4666 if (
Member->getType()->isDependentType() ||
Init->isTypeDependent()) {
4671 bool InitList =
false;
4672 if (isa<InitListExpr>(
Init)) {
4684 IdLoc,
Init->getBeginLoc(),
Init->getEndLoc())
4728 return Diag(NameLoc, diag::err_delegating_ctor)
4730 Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
4732 bool InitList =
true;
4736 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4745 NameLoc,
Init->getBeginLoc(),
Init->getEndLoc())
4753 cast<CXXConstructExpr>(DelegationInit.
get())->getConstructor()) &&
4754 "Delegating constructor with no target?");
4760 DelegationInit.
get(), InitRange.
getBegin(),
false);
4778 DelegationInit =
Init;
4793 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
4813 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
4842 if (!DirectBaseSpec && !VirtualBaseSpec) {
4851 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
4863 InitRange.
getEnd(), EllipsisLoc);
4870 if (DirectBaseSpec && VirtualBaseSpec)
4871 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
4876 BaseSpec = VirtualBaseSpec;
4879 bool InitList =
true;
4883 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4923 InitRange.
getEnd(), EllipsisLoc);
4933 TargetType, ExprLoc);
4953 bool IsInheritedVirtualBase,
4957 IsInheritedVirtualBase);
4961 switch (ImplicitInitKind) {
4967 BaseInit = InitSeq.
Perform(
SemaRef, InitEntity, InitKind, std::nullopt);
4973 bool Moving = ImplicitInitKind ==
IIK_Move;
4974 ParmVarDecl *Param = Constructor->getParamDecl(0);
4980 Constructor->getLocation(), ParamType,
4995 BasePath.push_back(BaseSpec);
4997 CK_UncheckedDerivedToBase,
5005 BaseInit = InitSeq.
Perform(
SemaRef, InitEntity, InitKind, CopyCtorArg);
5028 ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
5037 if (Field->isInvalidDecl())
5043 bool Moving = ImplicitInitKind ==
IIK_Move;
5044 ParmVarDecl *Param = Constructor->getParamDecl(0);
5051 Expr *MemberExprBase =
5066 MemberLookup.
addDecl(Indirect ? cast<ValueDecl>(Indirect)
5117 "Unhandled implicit init kind!");
5153 if (!Field->getParent()->isUnion()) {
5156 diag::err_uninitialized_member_in_ctor)
5157 << (
int)Constructor->isImplicit()
5159 << 0 << Field->getDeclName();
5160 SemaRef.
Diag(Field->getLocation(), diag::note_declared_at);
5166 diag::err_uninitialized_member_in_ctor)
5167 << (
int)Constructor->isImplicit()
5169 << 1 << Field->getDeclName();
5170 SemaRef.
Diag(Field->getLocation(), diag::note_declared_at);
5187 CXXMemberInit =
nullptr;
5192struct BaseAndFieldInfo {
5195 bool AnyErrorsInInits;
5197 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
5199 llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
5202 : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
5214 bool isImplicitCopyOrMove()
const {
5225 llvm_unreachable(
"Invalid ImplicitInitializerKind!");
5229 AllToInit.push_back(
Init);
5238 bool isInactiveUnionMember(
FieldDecl *Field) {
5244 ActiveUnionMember.lookup(
Record->getCanonicalDecl()))
5245 return Active !=
Field->getCanonicalDecl();
5248 if (isImplicitCopyOrMove())
5253 if (
Field->hasInClassInitializer())
5257 if (!
Field->isAnonymousStructOrUnion())
5266 bool isWithinInactiveUnionMember(
FieldDecl *Field,
5269 return isInactiveUnionMember(Field);
5271 for (
auto *
C : Indirect->
chain()) {
5273 if (Field && isInactiveUnionMember(Field))
5288 if (ArrayT->isZeroSize())
5291 T = ArrayT->getElementType();
5300 if (Field->isInvalidDecl())
5305 Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
5306 return Info.addFieldInitializer(
Init);
5320 if (Info.isWithinInactiveUnionMember(Field, Indirect))
5323 if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
5341 return Info.addFieldInitializer(
Init);
5351 if (Info.AnyErrorsInInits)
5362 return Info.addFieldInitializer(
Init);
5369 Constructor->setNumCtorInitializers(1);
5373 Constructor->setCtorInitializers(initializer);
5382 DiagnoseUninitializedFields(*
this, Constructor);
5389 if (Constructor->isDependentContext()) {
5392 if (!Initializers.empty()) {
5393 Constructor->setNumCtorInitializers(Initializers.size());
5396 memcpy(baseOrMemberInitializers, Initializers.data(),
5398 Constructor->setCtorInitializers(baseOrMemberInitializers);
5403 Constructor->setInvalidDecl();
5408 BaseAndFieldInfo Info(*
this, Constructor, AnyErrors);
5412 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
5416 bool HadError =
false;
5418 for (
unsigned i = 0; i < Initializers.size(); i++) {
5421 if (
Member->isBaseInitializer())
5424 Info.AllBaseFields[
Member->getAnyMember()->getCanonicalDecl()] =
Member;
5427 for (
auto *
C : F->chain()) {
5430 Info.ActiveUnionMember.insert(std::make_pair(
5435 Info.ActiveUnionMember.insert(std::make_pair(
5443 for (
auto &I : ClassDecl->
bases()) {
5445 DirectVBases.insert(&I);
5449 for (
auto &VBase : ClassDecl->
vbases()) {
5451 = Info.AllBaseFields.lookup(VBase.getType()->getAs<
RecordType>())) {
5459 Diag(
Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
5460 << VBase.getType() << ClassDecl;
5464 Info.AllToInit.push_back(
Value);
5465 }
else if (!AnyErrors && !ClassDecl->
isAbstract()) {
5470 bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
5473 &VBase, IsInheritedVirtualBase,
5479 Info.AllToInit.push_back(CXXBaseInit);
5486 if (
Base.isVirtual())
5490 = Info.AllBaseFields.lookup(
Base.getType()->getAs<
RecordType>())) {
5491 Info.AllToInit.push_back(
Value);
5492 }
else if (!AnyErrors) {
5501 Info.AllToInit.push_back(CXXBaseInit);
5506 for (
auto *Mem : ClassDecl->
decls()) {
5507 if (
auto *F = dyn_cast<FieldDecl>(Mem)) {
5512 if (F->isUnnamedBitField())
5518 if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
5527 if (Info.isImplicitCopyOrMove())
5530 if (
auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
5531 if (F->getType()->isIncompleteArrayType()) {
5533 "Incomplete array type is not valid");
5545 unsigned NumInitializers = Info.AllToInit.size();
5546 if (NumInitializers > 0) {
5547 Constructor->setNumCtorInitializers(NumInitializers);
5550 memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
5552 Constructor->setCtorInitializers(baseOrMemberInitializers);
5557 Constructor->getParent());
5567 for (
auto *Field : RD->
fields())
5572 IdealInits.push_back(Field->getCanonicalDecl());
5581 if (!
Member->isAnyMemberInitializer())
5584 return Member->getAnyMember()->getCanonicalDecl();
5590 if (
Previous->isAnyMemberInitializer())
5595 if (Current->isAnyMemberInitializer())
5596 Diag << 0 << Current->getAnyMember();
5598 Diag << 1 << Current->getTypeSourceInfo()->getType();
5604 if (Constructor->getDeclContext()->isDependentContext())
5609 bool ShouldCheckOrder =
false;
5610 for (
unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5613 Init->getSourceLocation())) {
5614 ShouldCheckOrder =
true;
5618 if (!ShouldCheckOrder)
5629 for (
const auto &VBase : ClassDecl->
vbases())
5633 for (
const auto &
Base : ClassDecl->
bases()) {
5634 if (
Base.isVirtual())
5640 for (
auto *Field : ClassDecl->
fields()) {
5641 if (Field->isUnnamedBitField())
5647 unsigned NumIdealInits = IdealInitKeys.size();
5648 unsigned IdealIndex = 0;
5657 for (
unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5662 for (; IdealIndex != NumIdealInits; ++IdealIndex)
5663 if (InitKey == IdealInitKeys[IdealIndex])
5669 if (IdealIndex == NumIdealInits && InitIndex) {
5670 WarnIndexes.push_back(InitIndex);
5673 for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
5674 if (InitKey == IdealInitKeys[IdealIndex])
5677 assert(IdealIndex < NumIdealInits &&
5678 "initializer not found in initializer list");
5680 CorrelatedInitOrder.emplace_back(IdealIndex, InitIndex);
5683 if (WarnIndexes.empty())
5687 llvm::sort(CorrelatedInitOrder, llvm::less_first());
5693 Inits[WarnIndexes.front() - 1]->getSourceLocation(),
5694 WarnIndexes.size() == 1 ? diag::warn_initializer_out_of_order
5695 : diag::warn_some_initializers_out_of_order);
5697 for (
unsigned I = 0; I < CorrelatedInitOrder.size(); ++I) {
5698 if (CorrelatedInitOrder[I].second == I)
5704 Inits[I]->getSourceRange(),
5707 Inits[CorrelatedInitOrder[I].second]->getSourceRange()),
5713 if (WarnIndexes.size() == 1) {
5715 Inits[WarnIndexes.front()]);
5721 for (
unsigned WarnIndex : WarnIndexes) {
5724 diag::note_initializer_out_of_order);
5731bool CheckRedundantInit(
Sema &S,
5741 diag::err_multiple_mem_initialization)
5742 <<
Field->getDeclName()
5743 <<
Init->getSourceRange();
5745 const Type *BaseClass =
Init->getBaseClass();
5746 assert(BaseClass &&
"neither field nor base");
5748 diag::err_multiple_base_initialization)
5750 <<
Init->getSourceRange();
5758typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
5759typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
5761bool CheckRedundantUnionInit(
Sema &S,
5763 RedundantUnionMap &Unions) {
5768 while (
Parent->isAnonymousStructOrUnion() ||
Parent->isUnion()) {
5770 UnionEntry &En = Unions[
Parent];
5771 if (En.first && En.first != Child) {
5773 diag::err_multiple_mem_union_initialization)
5774 <<
Field->getDeclName()
5775 <<
Init->getSourceRange();
5776 S.
Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
5777 << 0 << En.second->getSourceRange();
5784 if (!
Parent->isAnonymousStructOrUnion())
5801 if (!ConstructorDecl)
5807 = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
5810 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
5817 llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
5820 RedundantUnionMap MemberUnions;
5822 bool HadError =
false;
5823 for (
unsigned i = 0; i < MemInits.size(); i++) {
5827 Init->setSourceOrder(i);
5829 if (
Init->isAnyMemberInitializer()) {
5831 if (CheckRedundantInit(*
this,
Init, Members[Key]) ||
5832 CheckRedundantUnionInit(*
this,
Init, MemberUnions))
5834 }
else if (
Init->isBaseInitializer()) {
5836 if (CheckRedundantInit(*
this,
Init, Members[Key]))
5839 assert(
Init->isDelegatingInitializer());
5841 if (MemInits.size() != 1) {
5843 diag::err_delegating_initializer_alone)
5844 <<
Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
5860 DiagnoseUninitializedFields(*
this, Constructor);
5877 for (
auto *Field : ClassDecl->
fields()) {
5878 if (Field->isInvalidDecl())
5905 PDiag(diag::err_access_dtor_field)
5906 << Field->getDeclName()
5915 bool VisitVirtualBases = !ClassDecl->
isAbstract();
5922 if (Dtor && Dtor->
isUsed())
5923 VisitVirtualBases =
false;
5929 for (
const auto &
Base : ClassDecl->
bases()) {
5935 if (
Base.isVirtual()) {
5936 if (!VisitVirtualBases)
5938 DirectVirtualBases.insert(RT);
5955 PDiag(diag::err_access_dtor_base)
5956 <<
Base.getType() <<
Base.getSourceRange(),
5963 if (VisitVirtualBases)
5965 &DirectVirtualBases);
5970 llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases) {
5972 for (
const auto &VBase : ClassDecl->
vbases()) {
5977 if (DirectVirtualBases && DirectVirtualBases->count(RT))
5993 PDiag(diag::err_access_dtor_vbase)
5999 diag::err_access_dtor_vbase, 0, ClassDecl->
getLocation(),
6013 = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
6019 DiagnoseUninitializedFields(*
this, Constructor);
6074 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
6075 MEnd = FinalOverriders.end();
6079 SOEnd = M->second.end();
6080 SO != SOEnd; ++SO) {
6087 if (SO->second.size() != 1)
6090 if (!SO->second.front().Method->isPureVirtual())
6093 if (!SeenPureMethods.insert(SO->second.front().Method).second)
6096 Diag(SO->second.front().Method->getLocation(),
6097 diag::note_pure_virtual_function)
6098 << SO->second.front().Method->getDeclName() << RD->
getDeclName();
6108struct AbstractUsageInfo {
6116 AbstractType(S.Context.getCanonicalType(
6117 S.Context.getTypeDeclType(
Record))),
6120 void DiagnoseAbstractType() {
6129struct CheckAbstractUsage {
6130 AbstractUsageInfo &Info;
6133 CheckAbstractUsage(AbstractUsageInfo &Info,
const NamedDecl *Ctx)
6134 : Info(Info), Ctx(Ctx) {}
6138#define ABSTRACT_TYPELOC(CLASS, PARENT)
6139#define TYPELOC(CLASS, PARENT) \
6140 case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
6141#include "clang/AST/TypeLocNodes.def"
6147 for (
unsigned I = 0, E = TL.
getNumParams(); I != E; ++I) {
6162 for (
unsigned I = 0, E = TL.
getNumArgs(); I != E; ++I) {
6172#define CheckPolymorphic(Type) \
6173 void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
6174 Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
6189 return Visit(Next, Sel);
6199 T = Info.S.Context.getBaseElementType(
T);
6202 if (CT != Info.AbstractType)
return;
6207 Info.S.Diag(Ctx->
getLocation(), diag::err_array_of_abstract_type)
6210 Info.S.Diag(Ctx->
getLocation(), diag::err_abstract_type_in_decl)
6213 Info.DiagnoseAbstractType();
6219 CheckAbstractUsage(*
this, D).Visit(TL, Sel);
6254 for (
auto *D : RD->
decls()) {
6255 if (D->isImplicit())
continue;
6258 if (
auto *FD = dyn_cast<FriendDecl>(D)) {
6259 D = FD->getFriendDecl();
6264 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
6266 }
else if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(D)) {
6270 }
else if (
auto *FD = dyn_cast<FieldDecl>(D)) {
6273 }
else if (
auto *VD = dyn_cast<VarDecl>(D)) {
6275 }
else if (
auto *VTD = dyn_cast<VarTemplateDecl>(D)) {
6279 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
6281 }
else if (
auto *CTD = dyn_cast<ClassTemplateDecl>(D)) {
6292 assert(ClassAttr->
getKind() == attr::DLLExport);
6302 struct MarkingClassDllexported {
6313 ~MarkingClassDllexported() {
6323 if (!
Member->hasAttr<DLLExportAttr>())
6328 auto *VD = dyn_cast<VarDecl>(
Member);
6329 if (VD && VD->getStorageClass() ==
SC_Static &&
6333 auto *MD = dyn_cast<CXXMethodDecl>(
Member);
6337 if (MD->isUserProvided()) {
6347 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
6357 }
else if (MD->isExplicitlyDefaulted()) {
6366 }
else if (!MD->isTrivial() ||
6367 MD->isCopyAssignmentOperator() ||
6368 MD->isMoveAssignmentOperator()) {
6392 auto *CD = dyn_cast<CXXConstructorDecl>(
Member);
6393 if (!CD || !CD->isDefaultConstructor())
6395 auto *
Attr = CD->getAttr<DLLExportAttr>();
6401 if (!
Class->isDependentContext()) {
6408 if (LastExportedDefaultCtor) {
6410 diag::err_attribute_dll_ambiguous_default_ctor)
6412 S.
Diag(CD->getLocation(), diag::note_entity_declared_at)
6413 << CD->getDeclName();
6416 LastExportedDefaultCtor = CD;
6422 bool ErrorReported =
false;
6423 auto reportIllegalClassTemplate = [&ErrorReported](
Sema &S,
6427 S.
Diag(TD->getLocation(),
6428 diag::err_cuda_device_builtin_surftex_cls_template)
6430 ErrorReported =
true;
6435 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(
Class);
6438 diag::err_cuda_device_builtin_surftex_ref_decl)
6441 diag::note_cuda_device_builtin_surftex_should_be_template_class)
6445 TD = SD->getSpecializedTemplate();
6449 unsigned N = Params->
size();
6452 reportIllegalClassTemplate(S, TD);
6454 diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6457 if (N > 0 && !isa<TemplateTypeParmDecl>(Params->
getParam(0))) {
6458 reportIllegalClassTemplate(S, TD);
6460 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6464 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(1));
6465 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6466 reportIllegalClassTemplate(S, TD);
6468 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6476 bool ErrorReported =
false;
6477 auto reportIllegalClassTemplate = [&ErrorReported](
Sema &S,
6481 S.
Diag(TD->getLocation(),
6482 diag::err_cuda_device_builtin_surftex_cls_template)
6484 ErrorReported =
true;
6489 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(
Class);
6492 diag::err_cuda_device_builtin_surftex_ref_decl)
6495 diag::note_cuda_device_builtin_surftex_should_be_template_class)
6499 TD = SD->getSpecializedTemplate();
6503 unsigned N = Params->
size();
6506 reportIllegalClassTemplate(S, TD);
6508 diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6511 if (N > 0 && !isa<TemplateTypeParmDecl>(Params->
getParam(0))) {
6512 reportIllegalClassTemplate(S, TD);
6514 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6518 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(1));
6519 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6520 reportIllegalClassTemplate(S, TD);
6522 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6527 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(2));
6528 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6529 reportIllegalClassTemplate(S, TD);
6531 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6539 for (
auto *Method :
Class->methods()) {
6540 if (Method->isUserProvided())
6553 if (
auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(
Class)) {
6554 if (
Attr *TemplateAttr =
6555 getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
6556 auto *A = cast<InheritableAttr>(TemplateAttr->clone(
getASTContext()));
6557 A->setInherited(
true);
6572 (!
Class->isExternallyVisible() &&
Class->hasExternalFormalLinkage())) {
6573 Class->dropAttrs<DLLExportAttr, DLLImportAttr>();
6577 if (!
Class->isExternallyVisible()) {
6578 Diag(
Class->getLocation(), diag::err_attribute_dll_not_extern)
6579 <<
Class << ClassAttr;
6587 if (!isa<VarDecl>(
Member) && !isa<CXXMethodDecl>(
Member))
6594 diag::err_attribute_dll_member_of_dll_class)
6595 << MemberAttr << ClassAttr;
6596 Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
6597 Member->setInvalidDecl();
6601 if (
Class->getDescribedClassTemplate())
6606 const bool ClassExported = ClassAttr->
getKind() == attr::DLLExport;
6611 const bool PropagatedImport =
6613 cast<DLLImportAttr>(ClassAttr)->wasPropagatedToBaseTemplate();
6622 Class->dropAttr<DLLExportAttr>();
6656 auto *Ctor = dyn_cast<CXXConstructorDecl>(MD);
6665 (Ctor || isa<CXXDestructorDecl>(MD)) && MD->
isTrivial())
6672 if (VD && PropagatedImport)
6686 if (ClassExported) {
6698 Member->addAttr(NewAttr);
6708 "friend re-decl should not already have a DLLAttr");
6740 NewAttr->setInherited(
true);
6741 BaseTemplateSpec->
addAttr(NewAttr);
6745 if (
auto *ImportAttr = dyn_cast<DLLImportAttr>(NewAttr))
6746 ImportAttr->setPropagatedToBaseTemplate();
6767 Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
6772 diag::note_template_class_explicit_specialization_was_here)
6773 << BaseTemplateSpec;
6776 diag::note_template_class_instantiation_was_here)
6777 << BaseTemplateSpec;
6790 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
6802 if (MD->isCopyAssignmentOperator())
6805 if (MD->isMoveAssignmentOperator())
6808 if (isa<CXXDestructorDecl>(FD))
6816 case OO_ExclaimEqual:
6828 case OO_GreaterEqual:
6851 cast<CXXConstructorDecl>(FD));
6869 llvm_unreachable(
"Invalid special member.");
6887 bool CopyCtorIsTrivial =
false, CopyCtorIsTrivialForCall =
false;
6888 bool DtorIsTrivialForCall =
false;
6899 CopyCtorIsTrivial =
true;
6901 CopyCtorIsTrivialForCall =
true;
6905 if (CD->isCopyConstructor() && !CD->isDeleted() &&
6906 !CD->isIneligibleOrNotSelected()) {
6907 if (CD->isTrivial())
6908 CopyCtorIsTrivial =
true;
6909 if (CD->isTrivialForCall())
6910 CopyCtorIsTrivialForCall =
true;
6918 DtorIsTrivialForCall =
true;
6920 if (!DD->isDeleted() && DD->isTrivialForCall())
6921 DtorIsTrivialForCall =
true;
6925 if (CopyCtorIsTrivialForCall && DtorIsTrivialForCall)
6939 uint64_t TypeSize = isAArch64 ? 128 : 64;
6941 if (CopyCtorIsTrivial &&
6951 bool HasNonDeletedCopyOrMove =
false;
6957 HasNonDeletedCopyOrMove =
true;
6964 HasNonDeletedCopyOrMove =
true;
6972 if (MD->isDeleted() || MD->isIneligibleOrNotSelected())
6975 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
6976 if (CD && CD->isCopyOrMoveConstructor())
6977 HasNonDeletedCopyOrMove =
true;
6978 else if (!isa<CXXDestructorDecl>(MD))
6981 if (!MD->isTrivialForCall())
6985 return HasNonDeletedCopyOrMove;
6996 bool IssuedDiagnostic =
false;
6999 if (!IssuedDiagnostic) {
7001 IssuedDiagnostic =
true;
7003 S.
Diag(O->getLocation(), diag::note_overridden_virtual_function);
7006 return IssuedDiagnostic;
7020 if (
Record->isAbstract() && !
Record->isInvalidDecl()) {
7021 AbstractUsageInfo Info(*
this,
Record);
7028 if (!
Record->isInvalidDecl() && !
Record->isDependentType() &&
7029 !
Record->isAggregate() && !
Record->hasUserDeclaredConstructor() &&
7031 bool Complained =
false;
7032 for (
const auto *F :
Record->fields()) {
7033 if (F->hasInClassInitializer() || F->isUnnamedBitField())
7036 if (F->getType()->isReferenceType() ||
7037 (F->getType().isConstQualified() && F->getType()->isScalarType())) {
7039 Diag(
Record->getLocation(), diag::warn_no_constructor_for_refconst)
7040 << llvm::to_underlying(
Record->getTagKind()) <<
Record;
7044 Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
7045 << F->getType()->isReferenceType()
7046 << F->getDeclName();
7051 if (
Record->getIdentifier()) {
7064 if (((isa<FieldDecl>(D) || isa<UnresolvedUsingValueDecl>(D)) &&
7065 Record->hasUserDeclaredConstructor()) ||
7066 isa<IndirectFieldDecl>(D)) {
7067 Diag((*I)->getLocation(), diag::err_member_name_of_class)
7075 if (
Record->isPolymorphic() && !
Record->isDependentType()) {
7078 !
Record->hasAttr<FinalAttr>())
7083 if (
Record->isAbstract()) {
7084 if (FinalAttr *FA =
Record->getAttr<FinalAttr>()) {
7085 Diag(
Record->getLocation(), diag::warn_abstract_final_class)
7086 << FA->isSpelledAsSealed();
7092 if (!
Record->hasAttr<FinalAttr>()) {
7094 if (
const FinalAttr *FA = dtor->getAttr<FinalAttr>()) {
7095 Diag(FA->getLocation(), diag::warn_final_dtor_non_final_class)
7096 << FA->isSpelledAsSealed()
7099 (FA->isSpelledAsSealed() ?
" sealed" :
" final"));
7101 diag::note_final_dtor_non_final_class_silence)
7108 if (
Record->hasAttr<TrivialABIAttr>())
7113 bool HasTrivialABI =
Record->hasAttr<TrivialABIAttr>();
7116 Record->setHasTrivialSpecialMemberForCall();
7126 auto CheckCompletedMemberFunction = [&](
CXXMethodDecl *MD) {
7137 MD->
isDeleted() ? diag::err_deleted_override
7138 : diag::err_non_deleted_override,
7142 if (MD->isDefaulted() && MD->isDeleted())
7151 MD->isConsteval() ? diag::err_consteval_override
7152 : diag::err_non_consteval_override,
7154 return MD->isConsteval() !=
V->isConsteval();
7156 if (MD->isDefaulted() && MD->isDeleted())
7163 auto CheckForDefaultedFunction = [&](
FunctionDecl *FD) ->
bool {
7164 if (!FD || FD->
isInvalidDecl() || !FD->isExplicitlyDefaulted())
7170 DefaultedSecondaryComparisons.push_back(FD);
7180 bool Incomplete = CheckForDefaultedFunction(M);
7183 if (
Record->isDependentType())
7189 if (!M->isImplicit() && !M->isUserProvided()) {
7193 Record->finishedDefaultedOrDeletedMember(M);
7194 M->setTrivialForCall(
7197 Record->setTrivialForCallFlags(M);
7206 M->isUserProvided()) {
7207 M->setTrivialForCall(HasTrivialABI);
7208 Record->setTrivialForCallFlags(M);
7211 if (!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&
7212 M->hasAttr<DLLExportAttr>()) {
7218 M->dropAttr<DLLExportAttr>();
7220 if (M->hasAttr<DLLExportAttr>()) {
7230 M->isDefaulted() && M->isConstexpr() && M->size_overridden_methods())
7234 CheckCompletedMemberFunction(M);
7243 CompleteMemberFunction(Dtor);
7245 bool HasMethodWithOverrideControl =
false,
7246 HasOverridingMethodWithoutOverrideControl =
false;
7247 for (
auto *D :
Record->decls()) {
7248 if (
auto *M = dyn_cast<CXXMethodDecl>(D)) {
7251 if (!
Record->isDependentType()) {
7256 if (M->hasAttr<OverrideAttr>())
7257 HasMethodWithOverrideControl =
true;
7258 else if (M->size_overridden_methods() > 0)
7259 HasOverridingMethodWithoutOverrideControl =
true;
7262 if (!isa<CXXDestructorDecl>(M))
7263 CompleteMemberFunction(M);
7264 }
else if (
auto *F = dyn_cast<FriendDecl>(D)) {
7265 CheckForDefaultedFunction(
7266 dyn_cast_or_null<FunctionDecl>(F->getFriendDecl()));
7270 if (HasOverridingMethodWithoutOverrideControl) {
7271 bool HasInconsistentOverrideControl = HasMethodWithOverrideControl;
7272 for (
auto *M :
Record->methods())
7277 for (
FunctionDecl *FD : DefaultedSecondaryComparisons) {
7281 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD))
7282 CheckCompletedMemberFunction(MD);
7300 Diag(
Record->getLocation(), diag::warn_cxx_ms_struct);
7306 bool ClangABICompat4 =
7314 if (
Record->getArgPassingRestrictions() !=
7316 Record->setArgPassingRestrictions(
7325 Record->setParamDestroyedInCallee(
true);
7326 else if (
Record->hasNonTrivialDestructor())
7327 Record->setParamDestroyedInCallee(CanPass);
7336 if (
Record->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>())
7338 else if (
Record->hasAttr<CUDADeviceBuiltinTextureTypeAttr>())
7356 unsigned LHSQuals = 0;
7359 LHSQuals = FieldQuals;
7361 unsigned RHSQuals = FieldQuals;
7383 llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
7389 : S(S), UseLoc(UseLoc) {
7390 bool DiagnosedMultipleConstructedBases =
false;
7396 for (
auto *D : Shadow->
redecls()) {
7397 auto *DShadow = cast<ConstructorUsingShadowDecl>(D);
7398 auto *DNominatedBase = DShadow->getNominatedBaseClass();
7399 auto *DConstructedBase = DShadow->getConstructedBaseClass();
7401 InheritedFromBases.insert(
7402 std::make_pair(DNominatedBase->getCanonicalDecl(),
7403 DShadow->getNominatedBaseClassShadowDecl()));
7404 if (DShadow->constructsVirtualBase())
7405 InheritedFromBases.insert(
7406 std::make_pair(DConstructedBase->getCanonicalDecl(),
7407 DShadow->getConstructedBaseClassShadowDecl()));
7409 assert(DNominatedBase == DConstructedBase);
7414 if (!ConstructedBase) {
7415 ConstructedBase = DConstructedBase;
7416 ConstructedBaseIntroducer = D->getIntroducer();
7417 }
else if (ConstructedBase != DConstructedBase &&
7419 if (!DiagnosedMultipleConstructedBases) {
7420 S.
Diag(UseLoc, diag::err_ambiguous_inherited_constructor)
7423 diag::note_ambiguous_inherited_constructor_using)
7425 DiagnosedMultipleConstructedBases =
true;
7427 S.
Diag(D->getIntroducer()->getLocation(),
7428 diag::note_ambiguous_inherited_constructor_using)
7429 << DConstructedBase;
7433 if (DiagnosedMultipleConstructedBases)
7440 std::pair<CXXConstructorDecl *, bool>
7442 auto It = InheritedFromBases.find(
Base->getCanonicalDecl());
7443 if (It == InheritedFromBases.end())
7444 return std::make_pair(
nullptr,
false);
7448 return std::make_pair(
7450 It->second->constructsVirtualBase());
7453 return std::make_pair(Ctor,
false);
7470 if (InheritedCtor) {
7473 Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;
7475 return BaseCtor->isConstexpr();
7543 if (Ctor && ClassDecl->
isUnion())
7563 for (
const auto &B : ClassDecl->
bases()) {
7569 InheritedCtor, Inherited))
7582 for (
const auto *F : ClassDecl->
fields()) {
7583 if (F->isInvalidDecl())
7586 F->hasInClassInitializer())
7590 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
7593 ConstArg && !F->isMutable()))
7608struct ComputingExceptionSpec {
7619 ~ComputingExceptionSpec() {
7639 if (DFK.isSpecialMember())
7641 S, Loc, cast<CXXMethodDecl>(FD), DFK.asSpecialMember(),
nullptr);
7642 if (DFK.isComparison())
7644 DFK.asComparison());
7646 auto *CD = cast<CXXConstructorDecl>(FD);
7647 assert(CD->getInheritedConstructor() &&
7648 "only defaulted functions and inherited constructors have implicit "
7651 S, Loc, CD->getInheritedConstructor().getShadowDecl());
7678 auto ESI = IES.getExceptionSpec();
7710 "not an explicitly-defaulted special member");
7720 bool HadError =
false;
7733 bool ShouldDeleteForTypeMismatch =
false;
7734 unsigned ExpectedParams = 1;
7746 if (DeleteOnTypeMismatch)
7747 ShouldDeleteForTypeMismatch =
true;
7757 bool CanHaveConstParam =
false;
7767 ReturnType =
Type->getReturnType();
7778 Diag(MD->
getLocation(), diag::err_defaulted_special_member_return_type)
7780 << ExpectedReturnType;
7786 if (DeleteOnTypeMismatch)
7787 ShouldDeleteForTypeMismatch =
true;
7804 if (DeleteOnTypeMismatch)
7805 ShouldDeleteForTypeMismatch =
true;
7808 diag::err_defaulted_special_member_explicit_object_mismatch)
7821 bool HasConstParam =
false;
7828 if (DeleteOnTypeMismatch)
7829 ShouldDeleteForTypeMismatch =
true;
7832 diag::err_defaulted_special_member_volatile_param)
7833 << llvm::to_underlying(CSM);
7838 if (HasConstParam && !CanHaveConstParam) {
7839 if (DeleteOnTypeMismatch)
7840 ShouldDeleteForTypeMismatch =
true;
7844 diag::err_defaulted_special_member_copy_const_param)
7850 diag::err_defaulted_special_member_move_const_param)
7855 }
else if (ExpectedParams) {
7859 "unexpected non-ref argument");
7888 : isa<CXXConstructorDecl>(MD))) &&
7893 diag::err_incorrect_defaulted_constexpr_with_vb)
7894 << llvm::to_underlying(CSM);
7895 for (
const auto &I : RD->
vbases())
7896 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here);
7915 if (!
Type->hasExceptionSpec()) {
7933 << llvm::to_underlying(CSM);
7934 if (ShouldDeleteForTypeMismatch) {
7936 << llvm::to_underlying(CSM);
7940 Diag(DefaultLoc, diag::note_replace_equals_default_to_delete)
7944 if (ShouldDeleteForTypeMismatch && !HadError) {
7946 diag::warn_cxx17_compat_defaulted_method_type_mismatch)
7947 << llvm::to_underlying(CSM);
7954 << llvm::to_underlying(CSM);
7955 assert(!ShouldDeleteForTypeMismatch &&
"deleted non-first decl");
7977template<
typename Derived,
typename ResultList,
typename Result,
7979class DefaultedComparisonVisitor {
7984 DefaultedComparisonKind DCK)
7985 : S(S), RD(RD), FD(FD), DCK(DCK) {
7989 Fns.assign(Info->getUnqualifiedLookups().begin(),
7990 Info->getUnqualifiedLookups().end());
7994 ResultList visit() {
8002 case DefaultedComparisonKind::None:
8003 llvm_unreachable(
"not a defaulted comparison");
8005 case DefaultedComparisonKind::Equal:
8006 case DefaultedComparisonKind::ThreeWay:
8007 getDerived().visitSubobjects(Results, RD, ParamLvalType.
getQualifiers());
8010 case DefaultedComparisonKind::NotEqual:
8011 case DefaultedComparisonKind::Relational:
8012 Results.add(getDerived().visitExpandedSubobject(
8013 ParamLvalType, getDerived().getCompleteObject()));
8016 llvm_unreachable(
"");
8020 Derived &getDerived() {
return static_cast<Derived&
>(*this); }
8031 if (Results.add(getDerived().visitSubobject(
8033 getDerived().getBase(&
Base))))
8040 if (
Field->isUnnamedBitField())
8043 if (
Field->isAnonymousStructOrUnion()) {
8044 if (visitSubobjects(Results,
Field->getType()->getAsCXXRecordDecl(),
8052 if (
Field->isMutable())
8057 if (Results.add(getDerived().visitSubobject(
8058 FieldType, getDerived().getField(Field))))
8066 Result visitSubobject(
QualType Type, Subobject Subobj) {
8069 if (
auto *CAT = dyn_cast_or_null<ConstantArrayType>(AT))
8070 return getDerived().visitSubobjectArray(CAT->getElementType(),
8071 CAT->getSize(), Subobj);
8072 return getDerived().visitExpandedSubobject(
Type, Subobj);
8075 Result visitSubobjectArray(
QualType Type,
const llvm::APInt &Size,
8077 return getDerived().visitSubobject(
Type, Subobj);
8084 DefaultedComparisonKind DCK;
8090struct DefaultedComparisonInfo {
8095 static DefaultedComparisonInfo deleted() {
8096 DefaultedComparisonInfo
Deleted;
8101 bool add(
const DefaultedComparisonInfo &R) {
8111struct DefaultedComparisonSubobject {
8119class DefaultedComparisonAnalyzer
8120 :
public DefaultedComparisonVisitor<DefaultedComparisonAnalyzer,
8121 DefaultedComparisonInfo,
8122 DefaultedComparisonInfo,
8123 DefaultedComparisonSubobject> {
8125 enum DiagnosticKind { NoDiagnostics, ExplainDeleted, ExplainConstexpr };
8128 DiagnosticKind Diagnose;
8131 using Base = DefaultedComparisonVisitor;
8132 using Result = DefaultedComparisonInfo;
8133 using Subobject = DefaultedComparisonSubobject;
8138 DefaultedComparisonKind DCK,
8139 DiagnosticKind Diagnose = NoDiagnostics)
8140 :
Base(S, RD, FD, DCK), Diagnose(Diagnose) {}
8143 if ((DCK == DefaultedComparisonKind::Equal ||
8144 DCK == DefaultedComparisonKind::ThreeWay) &&
8149 if (Diagnose == ExplainDeleted) {
8153 return Result::deleted();
8156 return Base::visit();
8160 Subobject getCompleteObject() {
8161 return Subobject{Subobject::CompleteObject, RD, FD->
getLocation()};
8165 return Subobject{Subobject::Base,
Base->getType()->getAsCXXRecordDecl(),
8166 Base->getBaseTypeLoc()};
8170 return Subobject{Subobject::Member,
Field,
Field->getLocation()};
8173 Result visitExpandedSubobject(
QualType Type, Subobject Subobj) {
8178 if (Diagnose == ExplainDeleted) {
8179 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_reference_member)
8182 return Result::deleted();
8187 Expr *Args[] = {&Xi, &Xi};
8191 assert(OO !=
OO_None &&
"not an overloaded operator!");
8192 return visitBinaryOperator(OO, Args, Subobj);
8206 !SpaceshipCandidates));
8211 CandidateSet.exclude(FD);
8213 if (Args[0]->getType()->isOverloadableType())
8224 switch (CandidateSet.BestViableFunction(S, FD->
getLocation(), Best)) {
8230 if ((DCK == DefaultedComparisonKind::NotEqual ||
8231 DCK == DefaultedComparisonKind::Relational) &&
8232 !Best->RewriteKind) {
8233 if (Diagnose == ExplainDeleted) {
8234 if (Best->Function) {
8235 S.
Diag(Best->Function->getLocation(),
8236 diag::note_defaulted_comparison_not_rewritten_callee)
8239 assert(Best->Conversions.size() == 2 &&
8240 Best->Conversions[0].isUserDefined() &&
8241 "non-user-defined conversion from class to built-in "
8243 S.
Diag(Best->Conversions[0]
8244 .UserDefined.FoundConversionFunction.getDecl()
8246 diag::note_defaulted_comparison_not_rewritten_conversion)
8250 return Result::deleted();
8260 CXXRecordDecl *ArgClass = Args[0]->getType()->getAsCXXRecordDecl();
8261 if (ArgClass && Best->FoundDecl.getDecl() &&
8262 Best->FoundDecl.getDecl()->isCXXClassMember()) {
8263 QualType ObjectType = Subobj.Kind == Subobject::Member
8264 ? Args[0]->getType()
8267 ArgClass, Best->FoundDecl, ObjectType, Subobj.Loc,
8268 Diagnose == ExplainDeleted
8269 ? S.
PDiag(diag::note_defaulted_comparison_inaccessible)
8270 << FD << Subobj.Kind << Subobj.Decl
8272 return Result::deleted();
8275 bool NeedsDeducing =
8283 assert(!BestFD->isDeleted() &&
"wrong overload resolution result");
8285 if (Diagnose == ExplainConstexpr && !BestFD->isConstexpr()) {
8286 if (Subobj.Kind != Subobject::CompleteObject)
8287 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_not_constexpr)
8288 << Subobj.
Kind << Subobj.Decl;
8289 S.
Diag(BestFD->getLocation(),
8290 diag::note_defaulted_comparison_not_constexpr_here);
8292 return Result::deleted();
8294 R.Constexpr &= BestFD->isConstexpr();
8296 if (NeedsDeducing) {
8301 if (BestFD->getReturnType()->isUndeducedType() &&
8307 if (Diagnose == NoDiagnostics) {
8310 diag::err_defaulted_comparison_cannot_deduce_undeduced_auto)
8311 << Subobj.
Kind << Subobj.Decl;
8314 diag::note_defaulted_comparison_cannot_deduce_undeduced_auto)
8315 << Subobj.
Kind << Subobj.Decl;
8316 S.
Diag(BestFD->getLocation(),
8317 diag::note_defaulted_comparison_cannot_deduce_callee)
8318 << Subobj.
Kind << Subobj.Decl;
8320 return Result::deleted();
8323 BestFD->getCallResultType());
8325 if (Diagnose == ExplainDeleted) {
8326 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_cannot_deduce)
8327 << Subobj.
Kind << Subobj.Decl
8328 << BestFD->getCallResultType().withoutLocalFastQualifiers();
8329 S.
Diag(BestFD->getLocation(),
8330 diag::note_defaulted_comparison_cannot_deduce_callee)
8331 << Subobj.
Kind << Subobj.Decl;
8333 return Result::deleted();
8335 R.Category = Info->Kind;
8338 QualType T = Best->BuiltinParamTypes[0];
8339 assert(
T == Best->BuiltinParamTypes[1] &&
8340 "builtin comparison for different types?");
8341 assert(Best->BuiltinParamTypes[2].isNull() &&
8342 "invalid builtin comparison");
8344 if (NeedsDeducing) {
8345 std::optional<ComparisonCategoryType> Cat =
8347 assert(Cat &&
"no category for builtin comparison?");
8358 if (Diagnose == ExplainDeleted) {
8361 Kind = OO == OO_EqualEqual ? 1 : 2;
8362 CandidateSet.NoteCandidates(
8364 Subobj.Loc, S.
PDiag(diag::note_defaulted_comparison_ambiguous)
8365 << FD << Kind << Subobj.Kind << Subobj.Decl),
8368 R = Result::deleted();
8372 if (Diagnose == ExplainDeleted) {
8373 if ((DCK == DefaultedComparisonKind::NotEqual ||
8374 DCK == DefaultedComparisonKind::Relational) &&
8375 !Best->RewriteKind) {
8376 S.
Diag(Best->Function->getLocation(),
8377 diag::note_defaulted_comparison_not_rewritten_callee)
8381 diag::note_defaulted_comparison_calls_deleted)
8382 << FD << Subobj.
Kind << Subobj.Decl;
8386 R = Result::deleted();
8392 if (OO == OO_Spaceship &&
8396 if (!R.add(visitBinaryOperator(OO_EqualEqual, Args, Subobj,
8398 R.add(visitBinaryOperator(OO_Less, Args, Subobj, &CandidateSet));
8402 if (Diagnose == ExplainDeleted) {
8403 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_no_viable_function)
8404 << FD << (OO == OO_EqualEqual || OO == OO_ExclaimEqual)
8405 << Subobj.
Kind << Subobj.Decl;
8409 if (SpaceshipCandidates) {
8410 SpaceshipCandidates->NoteCandidates(
8415 diag::note_defaulted_comparison_no_viable_function_synthesized)
8416 << (OO == OO_EqualEqual ? 0 : 1);
8419 CandidateSet.NoteCandidates(
8424 R = Result::deleted();
8433struct StmtListResult {
8434 bool IsInvalid =
false;
8438 IsInvalid |= S.isInvalid();
8441 Stmts.push_back(S.get());
8448class DefaultedComparisonSynthesizer
8449 :
public DefaultedComparisonVisitor<DefaultedComparisonSynthesizer,
8450 StmtListResult, StmtResult,
8451 std::pair<ExprResult, ExprResult>> {
8453 unsigned ArrayDepth = 0;
8456 using Base = DefaultedComparisonVisitor;
8457 using ExprPair = std::pair<ExprResult, ExprResult>;
8462 DefaultedComparisonKind DCK,
8464 :
Base(S, RD, FD, DCK), Loc(BodyLoc) {}
8470 StmtListResult Stmts = visit();
8471 if (Stmts.IsInvalid)
8476 case DefaultedComparisonKind::None:
8477 llvm_unreachable(
"not a defaulted comparison");
8479 case DefaultedComparisonKind::Equal: {
8488 auto OldStmts = std::move(Stmts.Stmts);
8489 Stmts.Stmts.clear();
8492 auto FinishCmp = [&] {
8493 if (
Expr *Prior = CmpSoFar.
get()) {
8495 if (RetVal.
isUnset() && Stmts.Stmts.empty())
8498 else if (Stmts.add(buildIfNotCondReturnFalse(Prior)))
8504 for (
Stmt *EAsStmt : llvm::reverse(OldStmts)) {
8505 Expr *E = dyn_cast<Expr>(EAsStmt);
8508 if (FinishCmp() || Stmts.add(EAsStmt))
8523 std::reverse(Stmts.Stmts.begin(), Stmts.Stmts.end());
8530 case DefaultedComparisonKind::ThreeWay: {
8534 ComparisonCategoryType::StrongOrdering, Loc,
8535 Sema::ComparisonCategoryUsage::DefaultedOperator);
8541 RetVal = getDecl(EqualVD);
8544 RetVal = buildStaticCastToR(RetVal.
get());
8548 case DefaultedComparisonKind::NotEqual:
8549 case DefaultedComparisonKind::Relational:
8550 RetVal = cast<Expr>(Stmts.Stmts.pop_back_val());
8576 ExprPair getCompleteObject() {
8579 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD);
8586 LHS = getParam(Param++);
8594 ExprPair Obj = getCompleteObject();
8595 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8605 ExprPair Obj = getCompleteObject();
8606 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8629 assert(!False.
isInvalid() &&
"should never fail");
8634 return S.
ActOnIfStmt(Loc, IfStatementKind::Ordinary, Loc,
nullptr,
8636 Sema::ConditionKind::Boolean),
8649 llvm::raw_svector_ostream OS(Str);
8650 OS <<
"i" << ArrayDepth;
8661 auto IterRef = [&] {
8665 assert(!Ref.
isInvalid() &&
"can't reference our own variable?");
8671 Loc, BO_NE, IterRef(),
8673 assert(!Cond.
isInvalid() &&
"should never fail");
8677 assert(!
Inc.isInvalid() &&
"should never fail");
8685 Subobj.first = Index(Subobj.first);
8686 Subobj.second = Index(Subobj.second);
8699 if (
Expr *ElemCmp = dyn_cast<Expr>(Substmt.
get())) {
8700 assert(DCK == DefaultedComparisonKind::Equal &&
8701 "should have non-expression statement");
8702 Substmt = buildIfNotCondReturnFalse(ElemCmp);
8710 Sema::ConditionKind::Boolean),
8716 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8724 Obj.second.get(),
true,
8732 case DefaultedComparisonKind::None:
8733 llvm_unreachable(
"not a defaulted comparison");
8735 case DefaultedComparisonKind::Equal:
8743 case DefaultedComparisonKind::ThreeWay: {
8748 Op = buildStaticCastToR(Op.
get());
8773 if (
Comp.isInvalid())
8776 nullptr, Loc,
Comp.get(), Sema::ConditionKind::Boolean);
8781 VDRef = getDecl(VD);
8789 return S.
ActOnIfStmt(Loc, IfStatementKind::Ordinary, Loc, InitStmt, Cond,
8794 case DefaultedComparisonKind::NotEqual:
8795 case DefaultedComparisonKind::Relational:
8800 llvm_unreachable(
"");
8806 assert(!R->
isUndeducedType() &&
"type should have been deduced already");
8824 Self.LookupOverloadedOperatorName(OO, S, Operators);
8837 if (Op == OO_Spaceship) {
8838 Lookup(OO_ExclaimEqual);
8840 Lookup(OO_EqualEqual);
8868 bool IsMethod = isa<CXXMethodDecl>(FD);
8870 auto *MD = cast<CXXMethodDecl>(FD);
8871 assert(!MD->
isStatic() &&
"comparison function cannot be a static member");
8881 FPT->getParamTypes(), EPI));
8888 if (!
T.isConstQualified()) {
8897 InsertLoc = Loc.getRParenLoc();
8902 Diag(Loc, diag::err_defaulted_comparison_non_const)
8911 FPT->getParamTypes(), EPI));
8922 FPT->getParamTypes(), EPI));
8928 (IsMethod ? 1 : 2)) {
8932 <<
int(IsMethod) <<
int(DCK);
8938 if (Param->isExplicitObjectParameter())
8940 QualType ParmTy = Param->getType();
8945 bool Ok = !IsMethod;
8950 CTy = Ref->getPointeeType();
8961 }
else if (
auto *CRD = CTy->getAsRecordDecl()) {
8962 RD = cast<CXXRecordDecl>(CRD);
8978 <<
int(DCK) << ParmTy << RefTy <<
int(!IsMethod) << PlainTy
8979 << Param->getSourceRange();
8981 assert(!IsMethod &&
"should know expected type for method");
8983 diag::err_defaulted_comparison_param_unknown)
8984 <<
int(DCK) << ParmTy << Param->getSourceRange();
8990 Diag(FD->
getLocation(), diag::err_defaulted_comparison_param_mismatch)
8992 << ParmTy << Param->getSourceRange();
8997 assert(RD &&
"must have determined class");
9006 diag::err_defaulted_comparison_not_friend,
int(DCK),
9011 return FD->getCanonicalDecl() ==
9012 F->getFriendDecl()->getCanonicalDecl();
9015 <<
int(DCK) <<
int(0) << RD;
9027 Diag(FD->
getLocation(), diag::err_defaulted_comparison_return_type_not_bool)
9037 RT->getContainedDeducedType() &&
9039 RT->getContainedAutoType()->isConstrained())) {
9041 diag::err_defaulted_comparison_deduced_return_type_not_auto)
9053 DefaultedComparisonInfo Info =
9054 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK).visit();
9068 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK,
9069 DefaultedComparisonAnalyzer::ExplainDeleted)
9080 diag::note_previous_declaration);
9092 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK,
9093 DefaultedComparisonAnalyzer::ExplainDeleted)
9143 Diag(FD->
getBeginLoc(), diag::err_defaulted_comparison_constexpr_mismatch)
9145 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK,
9146 DefaultedComparisonAnalyzer::ExplainConstexpr)
9167 EPI.ExceptionSpec.SourceDecl = FD;
9169 FPT->getParamTypes(), EPI));
9184 EqualEqual->setImplicit();
9199 Scope.addContextNote(UseLoc);
9206 CXXRecordDecl *RD = PT.getNonReferenceType()->getAsCXXRecordDecl();
9210 DefaultedComparisonSynthesizer(*
this, RD, FD, DCK, BodyLoc).build();
9224 L->CompletedImplicitDefinition(FD);
9231 ComputingExceptionSpec CES(S, FD, Loc);
9258 DefaultedComparisonSynthesizer(S, RD, FD, DCK, BodyLoc).build();
9280 for (
auto &Check : Overriding)
9292template<
typename Derived>
9293struct SpecialMemberVisitor {
9300 bool IsConstructor =
false, IsAssignment =
false, ConstArg =
false;
9304 : S(S), MD(MD), CSM(CSM), ICI(ICI) {
9306 case CXXSpecialMemberKind::DefaultConstructor:
9307 case CXXSpecialMemberKind::CopyConstructor:
9308 case CXXSpecialMemberKind::MoveConstructor:
9309 IsConstructor =
true;
9311 case CXXSpecialMemberKind::CopyAssignment:
9312 case CXXSpecialMemberKind::MoveAssignment:
9313 IsAssignment =
true;
9315 case CXXSpecialMemberKind::Destructor:
9317 case CXXSpecialMemberKind::Invalid:
9318 llvm_unreachable(
"invalid special member kind");
9324 ConstArg = RT->getPointeeType().isConstQualified();
9328 Derived &getDerived() {
return static_cast<Derived&
>(*this); }
9331 bool isMove()
const {
9332 return CSM == CXXSpecialMemberKind::MoveConstructor ||
9333 CSM == CXXSpecialMemberKind::MoveAssignment;
9338 unsigned Quals,
bool IsMutable) {
9340 ConstArg && !IsMutable);
9348 assert(CSM == CXXSpecialMemberKind::DefaultConstructor);
9350 cast<CXXConstructorDecl>(MD)->getInheritedConstructor().getConstructor();
9357 typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
9364 return B->getBaseTypeLoc();
9366 return Subobj.get<
FieldDecl*>()->getLocation();
9371 VisitNonVirtualBases,
9376 VisitPotentiallyConstructedBases,
9382 bool visit(BasesToVisit Bases) {
9385 if (Bases == VisitPotentiallyConstructedBases)
9386 Bases = RD->
isAbstract() ? VisitNonVirtualBases : VisitAllBases;
9388 for (
auto &B : RD->
bases())
9389 if ((Bases == VisitDirectBases || !B.isVirtual()) &&
9390 getDerived().visitBase(&B))
9393 if (Bases == VisitAllBases)
9394 for (
auto &B : RD->
vbases())
9395 if (getDerived().visitBase(&B))
9398 for (
auto *F : RD->
fields())
9399 if (!F->isInvalidDecl() && !F->isUnnamedBitField() &&
9400 getDerived().visitField(F))
9409struct SpecialMemberDeletionInfo
9410 : SpecialMemberVisitor<SpecialMemberDeletionInfo> {
9415 bool AllFieldsAreConst;
9420 : SpecialMemberVisitor(S, MD, CSM, ICI), Diagnose(Diagnose),
9421 Loc(MD->getLocation()), AllFieldsAreConst(
true) {}
9426 return ICI ? CXXSpecialMemberKind::Invalid : CSM;
9432 bool visitField(
FieldDecl *Field) {
return shouldDeleteForField(Field); }
9435 bool shouldDeleteForField(
FieldDecl *FD);
9436 bool shouldDeleteForAllConstMembers();
9438 bool shouldDeleteForClassSubobject(
CXXRecordDecl *Class, Subobject Subobj,
9440 bool shouldDeleteForSubobjectCall(Subobject Subobj,
9442 bool IsDtorCallInCtor);
9450bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
9471bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
9473 bool IsDtorCallInCtor) {
9480 DiagKind = !
Decl ? 0 : 1;
9483 else if (!isAccessible(Subobj,
Decl))
9485 else if (!IsDtorCallInCtor && Field &&
Field->getParent()->isUnion() &&
9486 !
Decl->isTrivial()) {
9498 const auto *RD = cast<CXXRecordDecl>(
Field->getParent());
9512 diag::note_deleted_special_member_class_subobject)
9513 << llvm::to_underlying(getEffectiveCSM()) << MD->
getParent()
9514 <<
true <<
Field << DiagKind << IsDtorCallInCtor
9519 diag::note_deleted_special_member_class_subobject)
9520 << llvm::to_underlying(getEffectiveCSM()) << MD->
getParent()
9521 <<
false <<
Base->getType() << DiagKind
9522 << IsDtorCallInCtor <<
false;
9535bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
9538 bool IsMutable =
Field &&
Field->isMutable();
9555 Field->hasInClassInitializer()) &&
9556 shouldDeleteForSubobjectCall(Subobj, lookupIn(
Class, Quals, IsMutable),
9563 if (IsConstructor) {
9566 false,
false,
false,
false);
9567 if (shouldDeleteForSubobjectCall(Subobj, SMOR,
true))
9574bool SpecialMemberDeletionInfo::shouldDeleteForVariantObjCPtrMember(
9589 auto *ParentClass = cast<CXXRecordDecl>(FD->
getParent());
9590 S.
Diag(FD->
getLocation(), diag::note_deleted_special_member_class_subobject)
9591 << llvm::to_underlying(getEffectiveCSM()) << ParentClass
9592 <<
true << FD << 4 <<
false
9610 if (
auto *BaseCtor = SMOR.
getMethod()) {
9615 if (BaseCtor->isDeleted() &&
Diagnose) {
9617 diag::note_deleted_special_member_class_subobject)
9618 << llvm::to_underlying(getEffectiveCSM()) << MD->
getParent()
9619 <<
false <<
Base->getType() << 1
9623 return BaseCtor->isDeleted();
9625 return shouldDeleteForClassSubobject(BaseClass,
Base, 0);
9630bool SpecialMemberDeletionInfo::shouldDeleteForField(
FieldDecl *FD) {
9634 if (inUnion() && shouldDeleteForVariantObjCPtrMember(FD, FieldType))
9642 S.
Diag(FD->
getLocation(), diag::note_deleted_default_ctor_uninit_field)
9643 << !!ICI << MD->
getParent() << FD << FieldType << 0;
9653 S.
Diag(FD->
getLocation(), diag::note_deleted_default_ctor_uninit_field)
9659 AllFieldsAreConst =
false;
9665 S.
Diag(FD->
getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
9669 }
else if (IsAssignment) {
9674 << isMove() << MD->
getParent() << FD << FieldType << 0;
9689 if (!inUnion() && FieldRecord->
isUnion() &&
9691 bool AllVariantFieldsAreConst =
true;
9694 for (
auto *UI : FieldRecord->
fields()) {
9697 if (shouldDeleteForVariantObjCPtrMember(&*UI, UnionFieldType))
9701 AllVariantFieldsAreConst =
false;
9704 if (UnionFieldRecord &&
9705 shouldDeleteForClassSubobject(UnionFieldRecord, UI,
9712 AllVariantFieldsAreConst && !FieldRecord->
field_empty()) {
9715 diag::note_deleted_default_ctor_all_const)
9726 if (shouldDeleteForClassSubobject(FieldRecord, FD,
9737bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
9741 AllFieldsAreConst) {
9742 bool AnyFields =
false;
9744 if ((AnyFields = !F->isUnnamedBitField()))
9750 diag::note_deleted_default_ctor_all_const)
9803 bool DeletesOnlyMatchingCopy =
9808 (!DeletesOnlyMatchingCopy ||
9813 for (
auto *I : RD->
ctors()) {
9814 if (I->isMoveConstructor()) {
9815 UserDeclaredMove = I;
9819 assert(UserDeclaredMove);
9821 (!DeletesOnlyMatchingCopy ||
9826 for (
auto *I : RD->
methods()) {
9827 if (I->isMoveAssignmentOperator()) {
9828 UserDeclaredMove = I;
9832 assert(UserDeclaredMove);
9835 if (UserDeclaredMove) {
9837 diag::note_deleted_copy_user_declared_move)
9855 OperatorDelete,
false)) {
9862 SpecialMemberDeletionInfo SMI(*
this, MD, CSM, ICI,
Diagnose);
9870 if (SMI.visit(SMI.IsAssignment ? SMI.VisitDirectBases
9871 : SMI.VisitPotentiallyConstructedBases))
9874 if (SMI.shouldDeleteForAllConstMembers())
9898 assert(DFK &&
"not a defaultable function");
9905 DefaultedComparisonAnalyzer(
9907 DFK.
asComparison(), DefaultedComparisonAnalyzer::ExplainDeleted)
9929 *Selected =
nullptr;
9933 llvm_unreachable(
"not a special member");
9951 for (
auto *CI : RD->
ctors()) {
9952 if (!CI->isDefaultConstructor())
9959 *Selected = DefCtor;
9992 }
else if (!Selected) {
10000 goto NeedOverloadResolution;
10010 }
else if (!Selected) {
10015 goto NeedOverloadResolution;
10019 NeedOverloadResolution:
10048 llvm_unreachable(
"unknown special method kind");
10052 for (
auto *CI : RD->
ctors())
10053 if (!CI->isImplicit())
10060 dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
10091 ConstRHS, TAH,
Diagnose ? &Selected :
nullptr))
10099 S.
Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
10102 S.
Diag(CD->getLocation(), diag::note_user_declared_ctor);
10103 }
else if (!Selected)
10104 S.
Diag(SubobjLoc, diag::note_nontrivial_no_copy)
10112 S.
Diag(SubobjLoc, diag::note_nontrivial_user_provided)
10118 S.
Diag(SubobjLoc, diag::note_nontrivial_subobject)
10136 for (
const auto *FI : RD->
fields()) {
10137 if (FI->isInvalidDecl() || FI->isUnnamedBitField())
10143 if (FI->isAnonymousStructOrUnion()) {
10155 FI->hasInClassInitializer()) {
10157 S.
Diag(FI->getLocation(), diag::note_nontrivial_default_member_init)
10168 S.
Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
10173 bool ConstRHS = ConstArg && !FI->isMutable();
10201 "not special enough");
10205 bool ConstArg =
false;
10233 ClangABICompat14)) {
10263 llvm_unreachable(
"not a special member");
10269 diag::note_nontrivial_default_arg)
10288 for (
const auto &BI : RD->
bases())
10330 Diag(BS.
getBeginLoc(), diag::note_nontrivial_has_virtual) << RD << 1;
10335 for (
const auto *MI : RD->
methods()) {
10336 if (MI->isVirtual()) {
10338 Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
10343 llvm_unreachable(
"dynamic class with no vbases and no virtual functions");
10351struct FindHiddenVirtualMethod {
10359 static bool CheckMostOverridenMethods(
10361 const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
10365 if (CheckMostOverridenMethods(O, Methods))
10381 bool foundSameNameMethod =
false;
10388 foundSameNameMethod =
true;
10405 if (!CheckMostOverridenMethods(MD, OverridenAndUsingBaseMethods))
10406 overloadedMethods.push_back(MD);
10410 if (foundSameNameMethod)
10411 OverloadedMethods.append(overloadedMethods.begin(),
10412 overloadedMethods.end());
10413 return foundSameNameMethod;
10420 llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
10438 FindHiddenVirtualMethod FHVM;
10449 ND = shad->getTargetDecl();
10455 OverloadedMethods = FHVM.OverloadedMethods;
10460 for (
unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
10463 diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
10480 if (!OverloadedMethods.empty()) {
10482 << MD << (OverloadedMethods.size() > 1);
10489 auto PrintDiagAndRemoveAttr = [&](
unsigned N) {
10492 Diag(RD.
getAttr<TrivialABIAttr>()->getLocation(),
10493 diag::ext_cannot_use_trivial_abi) << &RD;
10494 Diag(RD.
getAttr<TrivialABIAttr>()->getLocation(),
10495 diag::note_cannot_use_trivial_abi_reason) << &RD << N;
10501 auto HasNonDeletedCopyOrMoveConstructor = [&]() {
10513 if (CD->isCopyOrMoveConstructor() && !CD->isDeleted())
10518 if (!HasNonDeletedCopyOrMoveConstructor()) {
10519 PrintDiagAndRemoveAttr(0);
10525 PrintDiagAndRemoveAttr(1);
10529 for (
const auto &B : RD.
bases()) {
10532 if (!B.getType()->isDependentType() &&
10533 !B.getType()->getAsCXXRecordDecl()->canPassInRegisters()) {
10534 PrintDiagAndRemoveAttr(2);
10538 if (B.isVirtual()) {
10539 PrintDiagAndRemoveAttr(3);
10544 for (
const auto *FD : RD.
fields()) {
10549 PrintDiagAndRemoveAttr(4);
10554 if (!RT->isDependentType() &&
10555 !cast<CXXRecordDecl>(RT->getDecl())->canPassInRegisters()) {
10556 PrintDiagAndRemoveAttr(5);
10571 if (AL.getKind() != ParsedAttr::AT_Visibility)
10574 Diag(AL.getLoc(), diag::warn_attribute_after_definition_ignored) << AL;
10582 LBrac, RBrac, AttrList);
10599 FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Friend->getFriendDecl());
10604 Spaceships.clear();
10610 Spaceships.push_back(FD);
10619 if (
auto *FD = dyn_cast<FunctionDecl>(ND))
10620 if (FD->isExplicitlyDefaulted())
10621 Spaceships.push_back(FD);
10721 DefaultedSpaceships);
10722 for (
auto *FD : DefaultedSpaceships)
10729 llvm::function_ref<
Scope *()> EnterScope) {
10737 DeclContext *LookupDC = dyn_cast<DeclContext>(D);
10740 for (
unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
10741 ParameterLists.push_back(DD->getTemplateParameterList(i));
10745 ParameterLists.push_back(FTD->getTemplateParameters());
10746 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
10750 ParameterLists.push_back(VTD->getTemplateParameters());
10751 else if (
auto *PSD = dyn_cast<VarTemplatePartialSpecializationDecl>(D))
10752 ParameterLists.push_back(PSD->getTemplateParameters());
10754 }
else if (
TagDecl *TD = dyn_cast<TagDecl>(D)) {
10755 for (
unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
10756 ParameterLists.push_back(TD->getTemplateParameterList(i));
10760 ParameterLists.push_back(CTD->getTemplateParameters());
10761 else if (
auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
10762 ParameterLists.push_back(PSD->getTemplateParameters());
10767 unsigned Count = 0;
10768 Scope *InnermostTemplateScope =
nullptr;
10772 if (Params->size() == 0)
10775 InnermostTemplateScope = EnterScope();
10777 if (Param->getDeclName()) {
10778 InnermostTemplateScope->
AddDecl(Param);
10786 if (InnermostTemplateScope) {
10787 assert(LookupDC &&
"no enclosing DeclContext for template lookup");
10795 if (!RecordD)
return;
10802 if (!RecordD)
return;
10876 bool DiagOccured =
false;
10878 [DiagID, &S, &DiagOccured](
DeclSpec::TQ, StringRef QualName,
10885 DiagOccured =
true;
10963 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
10965 return Constructor->setInvalidDecl();
10972 if (!Constructor->isInvalidDecl() &&
10973 Constructor->hasOneParamOrDefaultArgs() &&
10974 Constructor->getTemplateSpecializationKind() !=
10976 QualType ParamType = Constructor->getParamDecl(0)->getType();
10979 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
10980 const char *ConstRef
10981 = Constructor->getParamDecl(0)->getIdentifier() ?
"const &"
10983 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
10988 Constructor->setInvalidDecl();
11010 Expr *ThisArg =
nullptr;
11015 if (OperatorDelete->isDestroyingOperatorDelete()) {
11016 QualType ParamType = OperatorDelete->getParamDecl(0)->getType();
11023 ActOnCXXThis(OperatorDelete->getParamDecl(0)->getLocation());
11024 assert(!This.isInvalid() &&
"couldn't form 'this' expr in dtor?");
11026 if (This.isInvalid()) {
11029 Diag(Loc, diag::note_implicit_delete_this_in_destructor_here);
11032 ThisArg = This.get();
11038 Destructor->setOperatorDelete(OperatorDelete, ThisArg);
11061 << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
11064 if (TST->isTypeAlias())
11066 << DeclaratorType << 1;
11160 if (After.isInvalid())
11164 R.
setEnd(After.getEnd());
11219 unsigned NumParam = Proto->getNumParams();
11223 if (NumParam == 1) {
11225 if (
const auto *
First =
11226 dyn_cast_if_present<ParmVarDecl>(FTI.
Params[0].
Param);
11227 First &&
First->isExplicitObjectParameter())
11231 if (NumParam != 0) {
11236 }
else if (Proto->isVariadic()) {
11243 if (Proto->getReturnType() != ConvType) {
11244 bool NeedsTypedef =
false;
11248 bool PastFunctionChunk =
false;
11250 switch (Chunk.Kind) {
11252 if (!PastFunctionChunk) {
11253 if (Chunk.Fun.HasTrailingReturnType) {
11258 PastFunctionChunk =
true;
11263 NeedsTypedef =
true;
11283 After.isValid() ? After.getBegin() :
11285 auto &&DB =
Diag(Loc, diag::err_conv_function_with_complex_decl);
11286 DB << Before << After;
11288 if (!NeedsTypedef) {
11292 if (After.isInvalid() && ConvTSI) {
11300 }
else if (!Proto->getReturnType()->isDependentType()) {
11301 DB << 1 << Proto->getReturnType();
11303 DB << 2 << Proto->getReturnType();
11314 ConvType = Proto->getReturnType();
11335 Proto->getExtProtoInfo());
11341 ? diag::warn_cxx98_compat_explicit_conversion_functions
11342 : diag::ext_explicit_conversion_functions)
11351 assert(Conversion &&
"Expected to receive a conversion function declaration");
11374 if (ConvType == ClassType)
11379 << ClassType << ConvType;
11382 << ClassType << ConvType;
11397 return ConversionTemplate;
11422 for (
unsigned Idx = 0; Idx < FTI.
NumParams; Idx++) {
11423 const auto &ParamInfo = FTI.
Params[Idx];
11424 if (!ParamInfo.Param)
11426 ParmVarDecl *Param = cast<ParmVarDecl>(ParamInfo.Param);
11430 ExplicitObjectParam = Param;
11434 diag::err_explicit_object_parameter_must_be_first)
11438 if (!ExplicitObjectParam)
11443 diag::err_explicit_object_default_arg)
11451 diag::err_explicit_object_parameter_nonmember)
11458 diag::err_explicit_object_parameter_nonmember)
11465 diag::err_explicit_object_parameter_mutable)
11474 diag::err_explicit_object_parameter_nonmember)
11484 diag::err_explicit_object_parameter_constructor)
11494struct BadSpecifierDiagnoser {
11497 ~BadSpecifierDiagnoser() {
11505 return check(SpecLoc,
11511 if (!Specifiers.empty()) Specifiers +=
" ";
11512 Specifiers += Spec;
11517 std::string Specifiers;
11529 assert(GuidedTemplateDecl &&
"missing template decl for deduction guide");
11537 << GuidedTemplateDecl;
11543 if (DS.hasTypeSpecifier() || DS.getTypeQualifiers() ||
11544 DS.getStorageClassSpecLoc().isValid() || DS.isInlineSpecified() ||
11545 DS.isNoreturnSpecified() || DS.hasConstexprSpecifier()) {
11546 BadSpecifierDiagnoser Diagnoser(
11548 diag::err_deduction_guide_invalid_specifier);
11550 Diagnoser.check(DS.getStorageClassSpecLoc(), DS.getStorageClassSpec());
11551 DS.ClearStorageClassSpecs();
11555 Diagnoser.check(DS.getInlineSpecLoc(),
"inline");
11556 Diagnoser.check(DS.getNoreturnSpecLoc(),
"_Noreturn");
11557 Diagnoser.check(DS.getConstexprSpecLoc(),
"constexpr");
11558 DS.ClearConstexprSpec();
11560 Diagnoser.check(DS.getConstSpecLoc(),
"const");
11561 Diagnoser.check(DS.getRestrictSpecLoc(),
"__restrict");
11562 Diagnoser.check(DS.getVolatileSpecLoc(),
"volatile");
11563 Diagnoser.check(DS.getAtomicSpecLoc(),
"_Atomic");
11564 Diagnoser.check(DS.getUnalignedSpecLoc(),
"__unaligned");
11565 DS.ClearTypeQualifiers();
11567 Diagnoser.check(DS.getTypeSpecComplexLoc(), DS.getTypeSpecComplex());
11568 Diagnoser.check(DS.getTypeSpecSignLoc(), DS.getTypeSpecSign());
11569 Diagnoser.check(DS.getTypeSpecWidthLoc(), DS.getTypeSpecWidth());
11570 Diagnoser.check(DS.getTypeSpecTypeLoc(), DS.getTypeSpecType());
11571 DS.ClearTypeSpecType();
11578 bool FoundFunction =
false;
11584 diag::err_deduction_guide_with_complex_decl)
11588 if (!Chunk.Fun.hasTrailingReturnType())
11590 diag::err_deduction_guide_no_trailing_return_type);
11595 ParsedType TrailingReturnType = Chunk.Fun.getTrailingReturnType();
11598 assert(TSI &&
"deduction guide has valid type but invalid return type?");
11599 bool AcceptableReturnType =
false;
11600 bool MightInstantiateToSpecialization =
false;
11603 TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
11604 bool TemplateMatches =
11606 auto TKind = SpecifiedName.
getKind();
11612 if (SimplyWritten && TemplateMatches)
11613 AcceptableReturnType =
true;
11618 MightInstantiateToSpecialization = !(TD && isa<ClassTemplateDecl>(TD) &&
11622 MightInstantiateToSpecialization =
true;
11625 if (!AcceptableReturnType)
11627 diag::err_deduction_guide_bad_trailing_return_type)
11628 << GuidedTemplate << TSI->
getType()
11629 << MightInstantiateToSpecialization
11634 FoundFunction =
true;
11653 assert(*IsInline != PrevNS->
isInline());
11663 S.
Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
11666 S.
Diag(Loc, diag::err_inline_namespace_mismatch);
11684 bool IsInline = InlineLoc.
isValid();
11685 bool IsInvalid =
false;
11686 bool IsStd =
false;
11687 bool AddToKnown =
false;
11698 auto DiagnoseInlineStdNS = [&]() {
11699 assert(IsInline && II->
isStr(
"std") &&
11701 "Precondition of DiagnoseInlineStdNS not met");
11702 Diag(InlineLoc, diag::err_inline_namespace_std)
11718 RedeclarationKind::ForExternalRedeclaration);
11722 PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
11726 if (IsInline && II->
isStr(
"std") &&
11728 DiagnoseInlineStdNS();
11729 else if (IsInline != PrevNS->
isInline())
11731 &IsInline, PrevNS);
11732 }
else if (PrevDecl) {
11734 Diag(Loc, diag::err_redefinition_different_kind)
11739 }
else if (II->
isStr(
"std") &&
11742 DiagnoseInlineStdNS();
11747 AddToKnown = !IsInline;
11750 AddToKnown = !IsInline;
11764 if (PrevNS && IsInline != PrevNS->
isInline())
11766 &IsInline, PrevNS);
11779 if (
const VisibilityAttr *
Attr = Namespc->
getAttr<VisibilityAttr>())
11785 KnownNamespaces[Namespc] =
false;
11793 TU->setAnonymousNamespace(Namespc);
11795 cast<NamespaceDecl>(
Parent)->setAnonymousNamespace(Namespc);
11844 return AD->getNamespace();
11845 return dyn_cast_or_null<NamespaceDecl>(D);
11851 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
11852 assert(Namespc &&
"Invalid parameter, expected NamespaceDecl");
11855 if (Namespc->
hasAttr<VisibilityAttr>())
11858 if (DeferredExportedNamespaces.erase(Namespc))
11863 return cast_or_null<CXXRecordDecl>(
11872 return cast_or_null<NamespaceDecl>(
11877enum UnsupportedSTLSelect {
11884struct InvalidSTLDiagnoser {
11889 QualType operator()(UnsupportedSTLSelect Sel = USS_Other, StringRef Name =
"",
11890 const VarDecl *VD =
nullptr) {
11892 auto D = S.
Diag(Loc, diag::err_std_compare_type_not_supported)
11893 << TyForDiags << ((
int)Sel);
11894 if (Sel == USS_InvalidMember || Sel == USS_MissingMember) {
11895 assert(!Name.empty());
11899 if (Sel == USS_InvalidMember) {
11912 "Looking for comparison category type outside of C++.");
11926 if (Info && FullyCheckedComparisonCategories[
static_cast<unsigned>(Kind)]) {
11937 std::string NameForDiags =
"std::";
11939 Diag(Loc, diag::err_implied_comparison_category_type_not_found)
11940 << NameForDiags << (
int)Usage;
11944 assert(Info->
Kind == Kind);
11955 InvalidSTLDiagnoser UnsupportedSTLError{*
this, Loc, TyForDiags(Info)};
11958 return UnsupportedSTLError(USS_NonTrivial);
11963 if (
Base->isEmpty())
11966 return UnsupportedSTLError();
11974 if (std::distance(FIt, FEnd) != 1 ||
11975 !FIt->getType()->isIntegralOrEnumerationType()) {
11976 return UnsupportedSTLError();
11986 return UnsupportedSTLError(USS_MissingMember, MemName);
11989 assert(VD &&
"should not be null!");
11996 return UnsupportedSTLError(USS_InvalidMember, MemName, VD);
12002 return UnsupportedSTLError();
12009 FullyCheckedComparisonCategories[
static_cast<unsigned>(Kind)] =
true;
12035 "Looking for std::initializer_list outside of C++.");
12049 dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
12057 Template = dyn_cast_or_null<ClassTemplateDecl>(
12058 TST->getTemplateName().getAsTemplateDecl());
12059 Arguments = TST->template_arguments().begin();
12077 if (!isa<TemplateTypeParmDecl>(Params->
getParam(0)))
12089 *Element = Arguments[0].getAsType();
12096 S.
Diag(Loc, diag::err_implied_std_initializer_list_not_found);
12103 S.
Diag(Loc, diag::err_implied_std_initializer_list_not_found);
12108 Result.suppressDiagnostics();
12111 S.
Diag(Found->
getLocation(), diag::err_malformed_std_initializer_list);
12119 !isa<TemplateTypeParmDecl>(Params->
getParam(0))) {
12120 S.
Diag(Template->
getLocation(), diag::err_malformed_std_initializer_list);
12164 case Decl::TranslationUnit:
12166 case Decl::LinkageSpec:
12178 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
12180 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
12184 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
12185 return std::make_unique<NamespaceValidatorCCC>(*
this);
12193 auto *ND = cast<NamespaceDecl>(Corrected.
getFoundDecl());
12194 Module *M = ND->getOwningModule();
12195 assert(M &&
"hidden namespace definition not in a module?");
12199 diag::err_module_unimported_use_header)
12204 diag::err_module_unimported_use)
12214 NamespaceValidatorCCC CCC{};
12224 if (isa_and_nonnull<NamespaceDecl>(Corrected.getFoundDecl()) &&
12225 Corrected.requiresImport()) {
12228 std::string CorrectedStr(Corrected.getAsString(S.
getLangOpts()));
12229 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
12230 Ident->
getName().equals(CorrectedStr);
12232 S.
PDiag(diag::err_using_directive_member_suggest)
12233 << Ident << DC << DroppedSpecifier << SS.
getRange(),
12234 S.
PDiag(diag::note_namespace_defined_here));
12237 S.
PDiag(diag::err_using_directive_suggest) << Ident,
12238 S.
PDiag(diag::note_namespace_defined_here));
12240 R.
addDecl(Corrected.getFoundDecl());
12251 assert(!SS.
isInvalid() &&
"Invalid CXXScopeSpec.");
12252 assert(NamespcName &&
"Invalid NamespcName.");
12253 assert(IdentLoc.
isValid() &&
"Invalid NamespceName location.");
12256 S = S->getDeclParent();
12274 NamespcName->
isStr(
"std")) {
12275 Diag(IdentLoc, diag::ext_using_undefined_std);
12286 assert(
NS &&
"expected namespace decl");
12305 CommonAncestor = CommonAncestor->
getParent();
12309 IdentLoc, Named, CommonAncestor);
12313 Diag(IdentLoc, diag::warn_using_directive_in_header);
12318 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.
getRange();
12351 Diag(Name.getBeginLoc(), diag::err_using_requires_qualname);
12355 switch (Name.getKind()) {
12366 Diag(Name.getBeginLoc(),
12368 ? diag::warn_cxx98_compat_using_decl_constructor
12369 : diag::err_using_decl_constructor)
12377 Diag(Name.getBeginLoc(), diag::err_using_decl_destructor) << SS.
getRange();
12381 Diag(Name.getBeginLoc(), diag::err_using_decl_template_id)
12382 <<
SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
12386 llvm_unreachable(
"cannot parse qualified deduction guide name");
12397 ? diag::err_access_decl
12398 : diag::warn_access_decl_deprecated)
12409 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
12417 SS, TargetNameInfo, EllipsisLoc, AttrList,
12431 assert(!SS->
isInvalid() &&
"ScopeSpec is invalid");
12441 ? diag::err_using_enum_is_dependent
12442 : diag::err_unknown_typename)
12450 Diag(IdentLoc, diag::err_using_enum_not_enum) << EnumTy;
12454 if (
auto *Def =
Enum->getDefinition())
12457 if (TSI ==
nullptr)
12480 TD2->getUnderlyingType());
12484 if (isa<UnresolvedUsingIfExistsDecl>(D1) &&
12485 isa<UnresolvedUsingIfExistsDecl>(D2))
12517 if (
auto *Using = dyn_cast<UsingDecl>(BUD)) {
12521 if (isa<EnumDecl>(OrigDC))
12529 Diag(Using->getLocation(),
12530 diag::err_using_decl_nested_name_specifier_is_current_class)
12531 << Using->getQualifierLoc().getSourceRange();
12533 Using->setInvalidDecl();
12537 Diag(Using->getQualifierLoc().getBeginLoc(),
12538 diag::err_using_decl_nested_name_specifier_is_not_base_class)
12539 << Using->getQualifier() << cast<CXXRecordDecl>(
CurContext)
12540 << Using->getQualifierLoc().getSourceRange();
12542 Using->setInvalidDecl();
12547 if (
Previous.empty())
return false;
12550 if (isa<UsingShadowDecl>(
Target))
12551 Target = cast<UsingShadowDecl>(
Target)->getTargetDecl();
12558 NamedDecl *NonTag =
nullptr, *Tag =
nullptr;
12559 bool FoundEquivalentDecl =
false;
12562 NamedDecl *D = (*I)->getUnderlyingDecl();
12566 if (isa<UsingDecl>(D) || isa<UsingPackDecl>(D) || isa<UsingEnumDecl>(D))
12569 if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
12574 !isa<IndirectFieldDecl>(
Target) &&
12575 !isa<UnresolvedUsingValueDecl>(
Target) &&
12584 PrevShadow = Shadow;
12585 FoundEquivalentDecl =
true;
12589 FoundEquivalentDecl =
true;
12593 (isa<TagDecl>(D) ? Tag : NonTag) = D;
12596 if (FoundEquivalentDecl)
12601 if (isa<UnresolvedUsingIfExistsDecl>(
Target) !=
12602 (isa_and_nonnull<UnresolvedUsingIfExistsDecl>(NonTag))) {
12603 if (!NonTag && !Tag)
12606 Diag(
Target->getLocation(), diag::note_using_decl_target);
12607 Diag((NonTag ? NonTag : Tag)->getLocation(),
12608 diag::note_using_decl_conflict);
12637 Diag(
Target->getLocation(), diag::note_using_decl_target);
12645 if (isa<TagDecl>(
Target)) {
12647 if (!Tag)
return false;
12650 Diag(
Target->getLocation(), diag::note_using_decl_target);
12651 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
12657 if (!NonTag)
return false;
12660 Diag(
Target->getLocation(), diag::note_using_decl_target);
12670 for (
auto &B : Derived->
bases())
12671 if (B.getType()->getAsCXXRecordDecl() ==
Base)
12672 return B.isVirtual();
12673 llvm_unreachable(
"not a direct base class");
12682 if (isa<UsingShadowDecl>(
Target)) {
12683 Target = cast<UsingShadowDecl>(
Target)->getTargetDecl();
12684 assert(!isa<UsingShadowDecl>(
Target) &&
"nested shadow declaration");
12688 if (
auto *TargetTD = dyn_cast<TemplateDecl>(
Target))
12689 NonTemplateTarget = TargetTD->getTemplatedDecl();
12692 if (NonTemplateTarget && isa<CXXConstructorDecl>(NonTemplateTarget)) {
12693 UsingDecl *Using = cast<UsingDecl>(BUD);
12694 bool IsVirtualBase =
12696 Using->getQualifier()->getAsRecordDecl());
12750 cast<CXXRecordDecl>(Shadow->
getDeclContext())->removeConversion(Shadow);
12757 S->RemoveDecl(Shadow);
12771 bool &AnyDependentBases) {
12776 CanQualType BaseType =
Base.getType()->getCanonicalTypeUnqualified();
12777 if (CanonicalDesiredBase == BaseType)
12779 if (BaseType->isDependentType())
12780 AnyDependentBases =
true;
12788 UsingValidatorCCC(
bool HasTypenameKeyword,
bool IsInstantiation,
12790 : HasTypenameKeyword(HasTypenameKeyword),
12791 IsInstantiation(IsInstantiation), OldNNS(NNS),
12792 RequireMemberOf(RequireMemberOf) {}
12794 bool ValidateCandidate(
const TypoCorrection &Candidate)
override {
12798 if (!ND || isa<NamespaceDecl>(ND))
12808 if (RequireMemberOf) {
12809 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
12810 if (FoundRecord && FoundRecord->isInjectedClassName()) {
12831 bool AnyDependentBases =
false;
12834 AnyDependentBases) &&
12835 !AnyDependentBases)
12839 if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
12845 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
12846 if (FoundRecord && FoundRecord->isInjectedClassName())
12850 if (isa<TypeDecl>(ND))
12851 return HasTypenameKeyword || !IsInstantiation;
12853 return !HasTypenameKeyword;
12856 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
12857 return std::make_unique<UsingValidatorCCC>(*
this);
12861 bool HasTypenameKeyword;
12862 bool IsInstantiation;
12901 bool IsUsingIfExists) {
12902 assert(!SS.
isInvalid() &&
"Invalid CXXScopeSpec.");
12904 assert(IdentLoc.
isValid() &&
"Invalid TargetName location.");
12913 if (
auto *RD = dyn_cast<CXXRecordDecl>(
CurContext))
12919 RedeclarationKind::ForVisibleRedeclaration);
12926 assert(IsInstantiation &&
"no scope in non-instantiation");
12954 Diag(UsingLoc, diag::err_using_if_exists_on_ctor);
12960 if (!LookupContext || EllipsisLoc.
isValid()) {
12964 SS, NameInfo, IdentLoc))
12967 if (HasTypenameKeyword) {
12970 UsingLoc, TypenameLoc,
12972 IdentLoc, NameInfo.
getName(),
12976 QualifierLoc, NameInfo, EllipsisLoc);
12984 auto Build = [&](
bool Invalid) {
12987 UsingName, HasTypenameKeyword);
12994 auto BuildInvalid = [&]{
return Build(
true); };
12995 auto BuildValid = [&]{
return Build(
false); };
12998 return BuildInvalid();
13007 if (!IsInstantiation)
13024 if (R.
empty() && IsUsingIfExists)
13041 isa<TranslationUnitDecl>(LookupContext) &&
13044 UsingValidatorCCC CCC(HasTypenameKeyword, IsInstantiation, SS.
getScopeRep(),
13052 << NameInfo.
getName() << LookupContext << 0
13057 NamedDecl *ND = Corrected.getCorrectionDecl();
13059 return BuildInvalid();
13062 auto *RD = dyn_cast<CXXRecordDecl>(ND);
13065 RD = cast<CXXRecordDecl>(RD->
getParent());
13068 if (Corrected.WillReplaceSpecifier()) {
13070 Builder.MakeTrivial(
Context, Corrected.getCorrectionSpecifier(),
13072 QualifierLoc = Builder.getWithLocInContext(
Context);
13077 auto *CurClass = cast<CXXRecordDecl>(
CurContext);
13091 Diag(IdentLoc, diag::err_no_member)
13093 return BuildInvalid();
13098 return BuildInvalid();
13100 if (HasTypenameKeyword) {
13104 Diag(IdentLoc, diag::err_using_typename_non_type);
13106 Diag((*I)->getUnderlyingDecl()->getLocation(),
13107 diag::note_using_decl_target);
13108 return BuildInvalid();
13115 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
13117 return BuildInvalid();
13124 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
13126 return BuildInvalid();
13162 RedeclarationKind::ForVisibleRedeclaration);
13168 if (UED->getEnumDecl() == ED) {
13169 Diag(UsingLoc, diag::err_using_enum_decl_redeclaration)
13195 RedeclarationKind::ForVisibleRedeclaration);
13208 assert(isa<UnresolvedUsingValueDecl>(InstantiatedFrom) ||
13209 isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) ||
13210 isa<UsingPackDecl>(InstantiatedFrom));
13214 UPD->setAccess(InstantiatedFrom->
getAccess());
13221 assert(!UD->
hasTypename() &&
"expecting a constructor name");
13224 assert(SourceType &&
13225 "Using decl naming constructor doesn't have type in scope spec.");
13229 bool AnyDependentBases =
false;
13231 AnyDependentBases);
13232 if (!
Base && !AnyDependentBases) {
13234 diag::err_using_decl_constructor_not_in_direct_base)
13236 <<
QualType(SourceType, 0) << TargetClass;
13242 Base->setInheritConstructors();
13251 bool HasTypenameKeyword,
13270 if (Qual->
isDependent() && !HasTypenameKeyword) {
13271 for (
auto *D : Prev) {
13272 if (!isa<TypeDecl>(D) && !isa<UsingDecl>(D) && !isa<UsingPackDecl>(D)) {
13273 bool OldCouldBeEnumerator =
13274 isa<UnresolvedUsingValueDecl>(D) || isa<EnumConstantDecl>(D);
13276 OldCouldBeEnumerator ? diag::err_redefinition
13277 : diag::err_redefinition_different_kind)
13278 << Prev.getLookupName();
13294 if (
UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
13295 DTypename = UD->hasTypename();
13296 DQual = UD->getQualifier();
13298 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
13300 DQual = UD->getQualifier();
13302 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
13304 DQual = UD->getQualifier();
13309 if (HasTypenameKeyword != DTypename)
continue;
13317 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.
getRange();
13338 assert(
bool(NamedContext) == (R || UD) && !(R && UD) &&
13339 "resolvable context must have exactly one set of decls");
13343 bool Cxx20Enumerator =
false;
13344 if (NamedContext) {
13353 if (
auto *ED = dyn_cast<EnumDecl>(NamedContext)) {
13357 if (EC && R && ED->isScoped())
13360 ? diag::warn_cxx17_compat_using_decl_scoped_enumerator
13361 : diag::ext_using_decl_scoped_enumerator)
13365 NamedContext = ED->getDeclContext();
13385 ? diag::warn_cxx17_compat_using_decl_class_member_enumerator
13386 : diag::err_using_decl_can_not_refer_to_class_member)
13389 if (Cxx20Enumerator)
13392 auto *RD = NamedContext
13404 Diag(SS.
getBeginLoc(), diag::note_using_decl_class_member_workaround)
13412 Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
13428 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
13443 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
13453 if (!NamedContext) {
13469 ? diag::warn_cxx17_compat_using_decl_non_member_enumerator
13470 : diag::err_using_decl_nested_name_specifier_is_not_class)
13473 if (Cxx20Enumerator)
13490 cast<CXXRecordDecl>(NamedContext))) {
13492 if (Cxx20Enumerator) {
13493 Diag(NameLoc, diag::warn_cxx17_compat_using_decl_non_member_enumerator)
13500 diag::err_using_decl_nested_name_specifier_is_current_class)
13505 if (!cast<CXXRecordDecl>(NamedContext)->isInvalidDecl()) {
13507 diag::err_using_decl_nested_name_specifier_is_not_base_class)
13532 Bases.insert(
Base);
13537 if (!cast<CXXRecordDecl>(
CurContext)->forallBases(Collect))
13543 return !Bases.count(
Base);
13548 if (Bases.count(cast<CXXRecordDecl>(NamedContext)) ||
13549 !cast<CXXRecordDecl>(NamedContext)->forallBases(IsNotBase))
13553 diag::err_using_decl_nested_name_specifier_is_not_base_class)
13567 S = S->getDeclParent();
13569 if (
Type.isInvalid())
13588 TemplateParamLists.size()
13590 : RedeclarationKind::ForVisibleRedeclaration);
13595 Previous.getFoundDecl()->isTemplateParameter()) {
13601 "name in alias declaration must be an identifier");
13603 Name.StartLocation,
13604 Name.Identifier, TInfo);
13618 bool Redeclaration =
false;
13621 if (TemplateParamLists.size()) {
13625 if (TemplateParamLists.size() != 1) {
13626 Diag(UsingLoc, diag::err_alias_template_extra_headers)
13627 <<
SourceRange(TemplateParamLists[1]->getTemplateLoc(),
13628 TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
13641 Redeclaration =
true;
13645 Diag(UsingLoc, diag::err_redefinition_different_kind)
13646 << Name.Identifier;
13660 OldTemplateParams =
13688 Name.Identifier, TemplateParams,
13696 else if (OldDecl) {
13703 if (
auto *TD = dyn_cast_or_null<TagDecl>(DeclFromDeclSpec)) {
13731 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.
getRange();
13740 RedeclarationKind::ForVisibleRedeclaration);
13763 Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
13765 Diag(AD->getLocation(), diag::note_previous_namespace_alias)
13766 << AD->getNamespace();
13771 ? diag::err_redefinition
13772 : diag::err_redefinition_different_kind;
13773 Diag(AliasLoc, DiagID) << Alias;
13794struct SpecialMemberExceptionSpecInfo
13795 : SpecialMemberVisitor<SpecialMemberExceptionSpecInfo> {
13803 : SpecialMemberVisitor(S, MD, CSM, ICI), Loc(Loc), ExceptSpec(S) {}
13808 void visitClassSubobject(
CXXRecordDecl *Class, Subobject Subobj,
13811 void visitSubobjectCall(Subobject Subobj,
13821 auto *BaseClass = cast<CXXRecordDecl>(RT->getDecl());
13823 if (
auto *BaseCtor = SMOR.
getMethod()) {
13824 visitSubobjectCall(
Base, BaseCtor);
13828 visitClassSubobject(BaseClass,
Base, 0);
13832bool SpecialMemberExceptionSpecInfo::visitField(
FieldDecl *FD) {
13844 ExceptSpec.CalledExpr(E);
13847 visitClassSubobject(cast<CXXRecordDecl>(RT->getDecl()), FD,
13857 bool IsMutable =
Field &&
Field->isMutable();
13858 visitSubobjectCall(Subobj, lookupIn(
Class, Quals, IsMutable));
13861void SpecialMemberExceptionSpecInfo::visitSubobjectCall(
13866 ExceptSpec.CalledDecl(getSubobjectLoc(Subobj), MD);
13895 ComputingExceptionSpec CES(S, MD, Loc);
13902 SpecialMemberExceptionSpecInfo Info(S, MD, CSM, ICI, MD->
getLocation());
13904 return Info.ExceptSpec;
13911 diag::err_exception_spec_incomplete_type))
13912 return Info.ExceptSpec;
13929 Info.visit(Info.IsConstructor ? Info.VisitPotentiallyConstructedBases
13930 : Info.VisitAllBases);
13932 return Info.ExceptSpec;
13937struct DeclaringSpecialMember {
13941 bool WasAlreadyBeingDeclared;
13944 : S(S), D(RD, CSM), SavedContext(S, RD) {
13946 if (WasAlreadyBeingDeclared)
13967 ~DeclaringSpecialMember() {
13968 if (!WasAlreadyBeingDeclared) {
13975 bool isAlreadyBeingDeclared()
const {
13976 return WasAlreadyBeingDeclared;
13986 RedeclarationKind::ForExternalRedeclaration);
13997void Sema::setupImplicitSpecialMemberType(
CXXMethodDecl *SpecialMem,
14015 cast<CXXRecordDecl>(SpecialMem->
getParent())->isLambda()) {
14031 "Should not build implicit default constructor!");
14033 DeclaringSpecialMember DSM(*
this, ClassDecl,
14035 if (DSM.isAlreadyBeingDeclared())
14058 setupImplicitSpecialMemberType(DefaultCon,
Context.
VoidTy, std::nullopt);
14082 ClassDecl->
addDecl(DefaultCon);
14089 assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
14090 !Constructor->doesThisDeclarationHaveABody() &&
14091 !Constructor->isDeleted()) &&
14092 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
14093 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
14097 assert(ClassDecl &&
"DefineImplicitDefaultConstructor - invalid constructor");
14111 Scope.addContextNote(CurrentLocation);
14114 Constructor->setInvalidDecl();
14119 ? Constructor->getEndLoc()
14120 : Constructor->getLocation();
14122 Constructor->markUsed(
Context);
14125 L->CompletedImplicitDefinition(Constructor);
14128 DiagnoseUninitializedFields(*
this, Constructor);
14154 ->getInheritedConstructor()
14157 return cast<CXXConstructorDecl>(Ctor);
14172 false, BaseCtor, &ICI);
14189 EPI.ExceptionSpec.SourceDecl = DerivedCtor;
14195 for (
unsigned I = 0, N = FPT->
getNumParams(); I != N; ++I) {
14199 Context, DerivedCtor, UsingLoc, UsingLoc,
nullptr,
14206 ParamDecls.push_back(PD);
14211 assert(!BaseCtor->
isDeleted() &&
"should not use deleted constructor");
14214 Derived->
addDecl(DerivedCtor);
14220 return DerivedCtor;
14234 assert(Constructor->getInheritedConstructor() &&
14235 !Constructor->doesThisDeclarationHaveABody() &&
14236 !Constructor->isDeleted());
14237 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
14251 Scope.addContextNote(CurrentLocation);
14254 Constructor->getInheritedConstructor().getShadowDecl();
14256 Constructor->getInheritedConstructor().getConstructor();
14270 for (
bool VBase : {
false,
true}) {
14272 if (B.isVirtual() != VBase)
14275 auto *BaseRD = B.getType()->getAsCXXRecordDecl();
14280 if (!BaseCtor.first)
14285 InitLoc, B.getType(), BaseCtor.first, VBase, BaseCtor.second);
14289 Context, TInfo, VBase, InitLoc,
Init.get(), InitLoc,
14298 Constructor->setInvalidDecl();
14303 Constructor->markUsed(
Context);
14306 L->CompletedImplicitDefinition(Constructor);
14309 DiagnoseUninitializedFields(*
this, Constructor);
14319 DeclaringSpecialMember DSM(*
this, ClassDecl,
14321 if (DSM.isAlreadyBeingDeclared())
14382 !
Destructor->doesThisDeclarationHaveABody() &&
14384 "DefineImplicitDestructor - call it for implicit default dtor");
14389 assert(ClassDecl &&
"DefineImplicitDestructor - invalid destructor");
14400 Scope.addContextNote(CurrentLocation);
14428 "implicit complete dtors unneeded outside MS ABI");
14430 "complete dtor only exists for classes with vbases");
14435 Scope.addContextNote(CurrentLocation);
14445 if (
Record->isInvalidDecl()) {
14466 if (M->getParent()->getTemplateSpecializationKind() !=
14486 "adjusting dtor exception specs was introduced in c++11");
14496 if (DtorType->hasExceptionSpec())
14520 ExprBuilder(
const ExprBuilder&) =
delete;
14521 ExprBuilder &operator=(
const ExprBuilder&) =
delete;
14524 static Expr *assertNotNull(
Expr *E) {
14525 assert(E &&
"Expression construction must not fail.");
14531 virtual ~ExprBuilder() {}
14536class RefBuilder:
public ExprBuilder {
14546 : Var(Var), VarType(VarType) {}
14549class ThisBuilder:
public ExprBuilder {
14556class CastBuilder:
public ExprBuilder {
14557 const ExprBuilder &Builder;
14565 CK_UncheckedDerivedToBase, Kind,
14574class DerefBuilder:
public ExprBuilder {
14575 const ExprBuilder &Builder;
14579 return assertNotNull(
14583 DerefBuilder(
const ExprBuilder &Builder) : Builder(Builder) {}
14586class MemberBuilder:
public ExprBuilder {
14587 const ExprBuilder &Builder;
14597 nullptr, MemberLookup,
nullptr,
nullptr).get());
14600 MemberBuilder(
const ExprBuilder &Builder,
QualType Type,
bool IsArrow,
14602 : Builder(Builder),
Type(
Type), IsArrow(IsArrow),
14603 MemberLookup(MemberLookup) {}
14606class MoveCastBuilder:
public ExprBuilder {
14607 const ExprBuilder &Builder;
14611 return assertNotNull(
CastForMoving(S, Builder.build(S, Loc)));
14614 MoveCastBuilder(
const ExprBuilder &Builder) : Builder(Builder) {}
14617class LvalueConvBuilder:
public ExprBuilder {
14618 const ExprBuilder &Builder;
14622 return assertNotNull(
14626 LvalueConvBuilder(
const ExprBuilder &Builder) : Builder(Builder) {}
14629class SubscriptBuilder:
public ExprBuilder {
14630 const ExprBuilder &
Base;
14631 const ExprBuilder &Index;
14636 Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).
get());
14639 SubscriptBuilder(
const ExprBuilder &
Base,
const ExprBuilder &Index)
14651 const ExprBuilder &ToB,
const ExprBuilder &FromB) {
14660 Expr *From = FromB.build(S, Loc);
14664 Expr *To = ToB.build(S, Loc);
14670 bool NeedsCollectableMemCpy =
14675 StringRef MemCpyName = NeedsCollectableMemCpy ?
14676 "__builtin_objc_memmove_collectable" :
14677 "__builtin_memcpy";
14690 assert(MemCpyRef.
isUsable() &&
"Builtin reference cannot fail");
14692 Expr *CallArgs[] = {
14696 Loc, CallArgs, Loc);
14698 assert(!
Call.isInvalid() &&
"Call to __builtin_memcpy cannot fail!");
14731 const ExprBuilder &To,
const ExprBuilder &From,
14732 bool CopyingBaseSubobject,
bool Copying,
14733 unsigned Depth = 0) {
14749 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
14784 if (CopyingBaseSubobject) {
14815 Expr *FromInst = From.build(S, Loc);
14818 Loc, FromInst, Loc);
14819 if (
Call.isInvalid())
14838 Loc, BO_Assign, To.build(S, Loc), From.build(S, Loc));
14839 if (Assignment.isInvalid())
14858 llvm::raw_svector_ostream
OS(Str);
14859 OS <<
"__i" << Depth;
14863 IterationVarName, SizeType,
14872 RefBuilder IterationVarRef(IterationVar, SizeType);
14873 LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
14879 SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
14880 MoveCastBuilder FromIndexMove(FromIndexCopy);
14881 const ExprBuilder *FromIndex;
14883 FromIndex = &FromIndexCopy;
14885 FromIndex = &FromIndexMove;
14887 SubscriptBuilder ToIndex(To, IterationVarRefRVal);
14892 ToIndex, *FromIndex, CopyingBaseSubobject,
14893 Copying, Depth + 1);
14895 if (
Copy.isInvalid() || !
Copy.get())
14902 S.
Context, IterationVarRefRVal.build(S, Loc),
14916 Loc, Loc, InitStmt,
14923 const ExprBuilder &To,
const ExprBuilder &From,
14924 bool CopyingBaseSubobject,
bool Copying) {
14926 if (
T->
isArrayType() && !
T.isConstQualified() && !
T.isVolatileQualified() &&
14927 T.isTriviallyCopyableType(S.
Context))
14931 CopyingBaseSubobject,
14949 DeclaringSpecialMember DSM(*
this, ClassDecl,
14951 if (DSM.isAlreadyBeingDeclared())
14986 setupImplicitSpecialMemberType(
CopyAssignment, RetType, ArgType);
14996 ClassLoc, ClassLoc,
15038 }
else if (!isa<CXXConstructorDecl>(CopyOp) &&
15041 for (
auto *I : RD->
ctors()) {
15042 if (I->isCopyConstructor()) {
15043 UserDeclaredOperation = I;
15047 assert(UserDeclaredOperation);
15048 }
else if (isa<CXXConstructorDecl>(CopyOp) &&
15051 for (
auto *I : RD->
methods()) {
15052 if (I->isCopyAssignmentOperator()) {
15053 UserDeclaredOperation = I;
15057 assert(UserDeclaredOperation);
15060 if (UserDeclaredOperation) {
15061 bool UDOIsUserProvided = UserDeclaredOperation->
isUserProvided();
15062 bool UDOIsDestructor = isa<CXXDestructorDecl>(UserDeclaredOperation);
15063 bool IsCopyAssignment = !isa<CXXConstructorDecl>(CopyOp);
15065 (UDOIsUserProvided && UDOIsDestructor)
15066 ? diag::warn_deprecated_copy_with_user_provided_dtor
15067 : (UDOIsUserProvided && !UDOIsDestructor)
15068 ? diag::warn_deprecated_copy_with_user_provided_copy
15069 : (!UDOIsUserProvided && UDOIsDestructor)
15070 ? diag::warn_deprecated_copy_with_dtor
15071 : diag::warn_deprecated_copy;
15073 << RD << IsCopyAssignment;
15084 "DefineImplicitCopyAssignment called for wrong function");
15102 Scope.addContextNote(CurrentLocation);
15137 RefBuilder OtherRef(
Other, OtherRefType);
15140 std::optional<ThisBuilder> This;
15141 std::optional<DerefBuilder> DerefThis;
15142 std::optional<RefBuilder> ExplicitObject;
15143 bool IsArrow =
false;
15149 ExplicitObject.emplace(CopyAssignOperator->
getParamDecl(0), ObjectType);
15153 DerefThis.emplace(*This);
15156 ExprBuilder &ObjectParameter =
15157 ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15158 :
static_cast<ExprBuilder &
>(*This);
15162 for (
auto &
Base : ClassDecl->
bases()) {
15165 QualType BaseType =
Base.getType().getUnqualifiedType();
15172 BasePath.push_back(&
Base);
15181 ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15182 :
static_cast<ExprBuilder &
>(*DerefThis),
15191 if (
Copy.isInvalid()) {
15197 Statements.push_back(
Copy.getAs<
Expr>());
15201 for (
auto *Field : ClassDecl->
fields()) {
15204 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15207 if (Field->isInvalidDecl()) {
15213 if (Field->getType()->isReferenceType()) {
15214 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15216 Diag(Field->getLocation(), diag::note_declared_at);
15224 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15226 Diag(Field->getLocation(), diag::note_declared_at);
15232 if (Field->isZeroLengthBitField(
Context))
15235 QualType FieldType = Field->getType().getNonReferenceType();
15238 "Incomplete array type is not valid");
15244 LookupResult MemberLookup(*
this, Field->getDeclName(), Loc,
15249 MemberBuilder From(OtherRef, OtherRefType,
false, MemberLookup);
15250 MemberBuilder To(ObjectParameter, ObjectType, IsArrow, MemberLookup);
15256 if (
Copy.isInvalid()) {
15262 Statements.push_back(
Copy.getAs<
Stmt>());
15268 (ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15269 :
LangOpts.HLSL ?
static_cast<ExprBuilder &
>(*This)
15270 :
static_cast<ExprBuilder &
>(*DerefThis))
15271 .build(*
this, Loc);
15276 Statements.push_back(Return.
getAs<
Stmt>());
15289 assert(!Body.
isInvalid() &&
"Compound statement creation cannot fail");
15295 L->CompletedImplicitDefinition(CopyAssignOperator);
15302 DeclaringSpecialMember DSM(*
this, ClassDecl,
15304 if (DSM.isAlreadyBeingDeclared())
15338 setupImplicitSpecialMemberType(
MoveAssignment, RetType, ArgType);
15348 ClassLoc, ClassLoc,
15384 assert(!
Class->isDependentContext() &&
"should not define dependent move");
15390 if (
Class->getNumVBases() == 0 ||
Class->hasTrivialMoveAssignment() ||
15391 Class->getNumBases() < 2)
15395 typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
15398 for (
auto &BI :
Class->bases()) {
15399 Worklist.push_back(&BI);
15400 while (!Worklist.empty()) {
15406 if (!
Base->hasNonTrivialMoveAssignment())
15431 VBases.insert(std::make_pair(
Base->getCanonicalDecl(), &BI))
15433 if (Existing && Existing != &BI) {
15434 S.
Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
15437 << (
Base->getCanonicalDecl() ==
15440 S.
Diag(BI.getBeginLoc(), diag::note_vbase_moved_here)
15441 << (
Base->getCanonicalDecl() ==
15442 BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
15446 Existing =
nullptr;
15456 llvm::append_range(Worklist, llvm::make_pointer_range(
Base->bases()));
15469 "DefineImplicitMoveAssignment called for wrong function");
15499 Scope.addContextNote(CurrentLocation);
15515 RefBuilder OtherRef(
Other, OtherRefType);
15517 MoveCastBuilder MoveOther(OtherRef);
15520 std::optional<ThisBuilder> This;
15521 std::optional<DerefBuilder> DerefThis;
15522 std::optional<RefBuilder> ExplicitObject;
15528 ExplicitObject.emplace(MoveAssignOperator->
getParamDecl(0), ObjectType);
15532 DerefThis.emplace(*This);
15534 ExprBuilder &ObjectParameter =
15535 ExplicitObject ? *ExplicitObject :
static_cast<ExprBuilder &
>(*This);
15539 for (
auto &
Base : ClassDecl->
bases()) {
15550 QualType BaseType =
Base.getType().getUnqualifiedType();
15557 BasePath.push_back(&
Base);
15561 CastBuilder From(OtherRef, BaseType,
VK_XValue, BasePath);
15566 ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15567 :
static_cast<ExprBuilder &
>(*DerefThis),
15576 if (Move.isInvalid()) {
15582 Statements.push_back(Move.getAs<
Expr>());
15586 for (
auto *Field : ClassDecl->
fields()) {
15589 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15592 if (Field->isInvalidDecl()) {
15598 if (Field->getType()->isReferenceType()) {
15599 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15601 Diag(Field->getLocation(), diag::note_declared_at);
15609 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15611 Diag(Field->getLocation(), diag::note_declared_at);
15617 if (Field->isZeroLengthBitField(
Context))
15620 QualType FieldType = Field->getType().getNonReferenceType();
15623 "Incomplete array type is not valid");
15628 LookupResult MemberLookup(*
this, Field->getDeclName(), Loc,
15632 MemberBuilder From(MoveOther, OtherRefType,
15633 false, MemberLookup);
15634 MemberBuilder To(ObjectParameter, ObjectType, !ExplicitObject,
15637 assert(!From.build(*
this, Loc)->isLValue() &&
15638 "Member reference with rvalue base must be rvalue except for reference "
15639 "members, which aren't allowed for move assignment.");
15646 if (Move.isInvalid()) {
15652 Statements.push_back(Move.getAs<
Stmt>());
15658 (ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15659 :
static_cast<ExprBuilder &
>(*DerefThis))
15660 .build(*
this, Loc);
15666 Statements.push_back(Return.
getAs<
Stmt>());
15679 assert(!Body.
isInvalid() &&
"Compound statement creation cannot fail");
15685 L->CompletedImplicitDefinition(MoveAssignOperator);
15696 DeclaringSpecialMember DSM(*
this, ClassDecl,
15698 if (DSM.isAlreadyBeingDeclared())
15765 ClassDecl->
hasAttr<TrivialABIAttr>() ||
15797 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
15802 assert(ClassDecl &&
"DefineImplicitCopyConstructor - invalid constructor");
15813 Scope.addContextNote(CurrentLocation);
15844 DeclaringSpecialMember DSM(*
this, ClassDecl,
15846 if (DSM.isAlreadyBeingDeclared())
15891 ClassLoc, ClassLoc,
15904 ClassDecl->
hasAttr<TrivialABIAttr>() ||
15936 "DefineImplicitMoveConstructor - call it for implicit move ctor");
15941 assert(ClassDecl &&
"DefineImplicitMoveConstructor - invalid constructor");
15952 Scope.addContextNote(CurrentLocation);
15999 if (CallOp != Invoker) {
16018 if (Invoker != CallOp) {
16031 assert(FunctionRef &&
"Can't refer to __invoke function?");
16039 L->CompletedImplicitDefinition(Conv);
16040 if (Invoker != CallOp)
16041 L->CompletedImplicitDefinition(Invoker);
16069 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
16078 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
16084 Stmt *ReturnS = Return.
get();
16091 L->CompletedImplicitDefinition(Conv);
16098 switch (Args.size()) {
16103 if (!Args[1]->isDefaultArgument())
16108 return !Args[0]->isDefaultArgument();
16117 bool HadMultipleCandidates,
bool IsListInitialization,
16118 bool IsStdInitListInitialization,
bool RequiresZeroInit,
16120 bool Elidable =
false;
16139 Expr *SubExpr = ExprArgs[0];
16149 FoundDecl, Constructor,
16150 Elidable, ExprArgs, HadMultipleCandidates,
16151 IsListInitialization,
16152 IsStdInitListInitialization, RequiresZeroInit,
16153 ConstructKind, ParenRange);
16159 bool HadMultipleCandidates,
bool IsListInitialization,
16160 bool IsStdInitListInitialization,
bool RequiresZeroInit,
16162 if (
auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl)) {
16172 ConstructLoc, DeclInitType, Constructor, Elidable, ExprArgs,
16173 HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
16174 RequiresZeroInit, ConstructKind, ParenRange);
16182 bool HadMultipleCandidates,
bool IsListInitialization,
16183 bool IsStdInitListInitialization,
bool RequiresZeroInit,
16186 Constructor->getParent(),
16188 "given constructor for wrong type");
16195 Context, DeclInitType, ConstructLoc, Constructor, Elidable, ExprArgs,
16196 HadMultipleCandidates, IsListInitialization,
16197 IsStdInitListInitialization, RequiresZeroInit,
16229 PDiag(diag::err_access_dtor_var)
16239 bool HasConstantInit =
false;
16246 diag::err_constexpr_var_requires_const_destruction) << VD;
16247 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
16248 Diag(Notes[I].first, Notes[I].second);
16257 if (!VD->
hasAttr<AlwaysDestroyAttr>())
16274 bool AllowExplicit,
16275 bool IsListInitialization) {
16277 unsigned NumArgs = ArgsPtr.size();
16278 Expr **Args = ArgsPtr.data();
16284 if (NumArgs < NumParams)
16285 ConvertedArgs.reserve(NumParams);
16287 ConvertedArgs.reserve(NumArgs);
16293 Loc, Constructor, Proto, 0,
llvm::ArrayRef(Args, NumArgs), AllArgs,
16294 CallType, AllowExplicit, IsListInitialization);
16295 ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
16299 CheckConstructorCall(Constructor, DeclInitType,
16310 if (isa<NamespaceDecl>(DC)) {
16312 diag::err_operator_new_delete_declared_in_namespace)
16316 if (isa<TranslationUnitDecl>(DC) &&
16319 diag::err_operator_new_delete_declared_static)
16331 return Ctx.getPointerType(Ctx.getCanonicalType(Ctx.getQualifiedType(
16339 unsigned DependentParamTypeDiag,
16340 unsigned InvalidParamTypeDiag) {
16361 ? diag::err_operator_new_delete_dependent_result_type
16362 : diag::err_operator_new_delete_invalid_result_type)
16369 diag::err_operator_new_delete_template_too_few_parameters)
16375 diag::err_operator_new_delete_too_few_parameters)
16382 if (
const auto *PtrTy =
16387 ExpectedFirstParamType =
16393 ExpectedFirstParamType) {
16398 ? DependentParamTypeDiag
16399 : InvalidParamTypeDiag)
16400 << FnDecl->
getDeclName() << ExpectedFirstParamType;
16423 diag::err_operator_new_dependent_param_type,
16424 diag::err_operator_new_param_type))
16431 diag::err_operator_new_default_arg)
16446 auto *MD = dyn_cast<CXXMethodDecl>(FnDecl);
16462 diag::err_operator_delete_dependent_param_type,
16463 diag::err_operator_delete_param_type))
16472 diag::err_destroying_operator_delete_not_usual);
16484 "Expected an overloaded operator declaration");
16494 if (Op == OO_Delete || Op == OO_Array_Delete)
16497 if (Op == OO_New || Op == OO_Array_New)
16507 if (
CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
16508 if (MethodDecl->isStatic()) {
16509 if (Op == OO_Call || Op == OO_Subscript)
16512 ? diag::warn_cxx20_compat_operator_overload_static
16513 : diag::ext_operator_overload_static))
16516 return Diag(FnDecl->
getLocation(), diag::err_operator_overload_static)
16520 bool ClassOrEnumParam =
false;
16522 QualType ParamType = Param->getType().getNonReferenceType();
16525 ClassOrEnumParam =
true;
16530 if (!ClassOrEnumParam)
16532 diag::err_operator_overload_needs_class_or_enum)
16542 if (Op != OO_Call) {
16545 if (Param->hasDefaultArg()) {
16546 FirstDefaultedParam = Param;
16550 if (FirstDefaultedParam) {
16551 if (Op == OO_Subscript) {
16553 ? diag::ext_subscript_overload
16554 : diag::error_subscript_overload)
16559 diag::err_operator_overload_default_arg)
16567 {
false,
false,
false }
16568#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
16569 , { Unary, Binary, MemberOnly }
16570#include "clang/Basic/OperatorKinds.def"
16573 bool CanBeUnaryOperator = OperatorUses[Op][0];
16574 bool CanBeBinaryOperator = OperatorUses[Op][1];
16575 bool MustBeMemberOperator = OperatorUses[Op][2];
16582 (isa<CXXMethodDecl>(FnDecl) &&
16586 if (Op != OO_Call && Op != OO_Subscript &&
16587 ((NumParams == 1 && !CanBeUnaryOperator) ||
16588 (NumParams == 2 && !CanBeBinaryOperator) || (NumParams < 1) ||
16589 (NumParams > 2))) {
16591 unsigned ErrorKind;
16592 if (CanBeUnaryOperator && CanBeBinaryOperator) {
16594 }
else if (CanBeUnaryOperator) {
16597 assert(CanBeBinaryOperator &&
16598 "All non-call overloaded operators are unary or binary!");
16601 return Diag(FnDecl->
getLocation(), diag::err_operator_overload_must_be)
16602 << FnDecl->
getDeclName() << NumParams << ErrorKind;
16605 if (Op == OO_Subscript && NumParams != 2) {
16607 ? diag::ext_subscript_overload
16608 : diag::error_subscript_overload)
16609 << FnDecl->
getDeclName() << (NumParams == 1 ? 0 : 2);
16614 if (Op != OO_Call &&
16616 return Diag(FnDecl->
getLocation(), diag::err_operator_overload_variadic)
16621 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
16623 diag::err_operator_overload_must_be_member)
16637 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
16644 diag::err_operator_overload_post_incdec_must_be_int)
16645 << LastParam->
getType() << (Op == OO_MinusMinus);
16657 if (TemplateParams->
size() == 1) {
16659 dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->
getParam(0));
16678 }
else if (TemplateParams->
size() == 2) {
16680 dyn_cast<TemplateTypeParmDecl>(TemplateParams->
getParam(0));
16682 dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->
getParam(1));
16694 diag::ext_string_literal_operator_template);
16701 diag::err_literal_operator_template)
16710 if (isa<CXXMethodDecl>(FnDecl)) {
16711 Diag(FnDecl->
getLocation(), diag::err_literal_operator_outside_namespace)
16720 Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
16739 diag::err_literal_operator_template_with_params);
16768 diag::err_literal_operator_param)
16785 diag::err_literal_operator_invalid_param)
16795 QualType FirstParamType = (*Param)->getType().getUnqualifiedType();
16802 Diag((*Param)->getSourceRange().getBegin(),
16803 diag::err_literal_operator_param)
16804 << FirstParamType <<
"'const char *'" << (*Param)->getSourceRange();
16811 Diag((*Param)->getSourceRange().getBegin(),
16812 diag::err_literal_operator_param)
16813 << FirstParamType <<
"'const char *'" << (*Param)->getSourceRange();
16826 Diag((*Param)->getSourceRange().getBegin(),
16827 diag::err_literal_operator_param)
16828 << FirstParamType <<
"'const char *'" << (*Param)->getSourceRange();
16836 QualType SecondParamType = (*Param)->getType().getUnqualifiedType();
16838 Diag((*Param)->getSourceRange().getBegin(),
16839 diag::err_literal_operator_param)
16841 << (*Param)->getSourceRange();
16845 Diag(FnDecl->
getLocation(), diag::err_literal_operator_bad_param_count);
16854 if (Param->hasDefaultArg()) {
16855 Diag(Param->getDefaultArgRange().getBegin(),
16856 diag::err_literal_operator_default_argument)
16857 << Param->getDefaultArgRange();
16872 <<
static_cast<int>(Status)
16889 assert(Lit->
isUnevaluated() &&
"Unexpected string literal kind");
16895 else if (Lang ==
"C++")
16898 Diag(LangStr->
getExprLoc(), diag::err_language_linkage_spec_unknown)
16918 if (
getLangOpts().CPlusPlusModules && isCurrentModulePurview()) {
16919 Module *GlobalModule = PushImplicitGlobalModuleFragment(ExternLoc);
16946 PopImplicitGlobalModuleFragment();
16949 return LinkageSpec;
16985 Diag(Loc, diag::err_catch_rvalue_ref);
16990 Diag(Loc, diag::err_catch_variably_modified) << ExDeclType;
16996 unsigned DK = diag::err_catch_incomplete;
17000 DK = diag::err_catch_incomplete_ptr;
17003 BaseType = Ref->getPointeeType();
17005 DK = diag::err_catch_incomplete_ref;
17012 Diag(Loc, diag::err_wasm_reftype_tc) << 1;
17017 Diag(Loc, diag::err_catch_sizeless) << (Mode == 2 ? 1 : 0) << BaseType;
17023 diag::err_abstract_type_in_decl,
17035 Diag(Loc, diag::err_objc_object_catch);
17040 Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
17074 Expr *opaqueValue =
17118 RedeclarationKind::ForVisibleRedeclaration)) {
17122 assert(!S->isDeclScope(PrevDecl));
17126 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
17128 }
else if (PrevDecl->isTemplateParameter())
17156 Expr *AssertMessageExpr,
17162 AssertMessageExpr, RParenLoc,
false);
17167 case BuiltinType::Char_S:
17168 case BuiltinType::Char_U:
17170 case BuiltinType::Char8:
17173 case BuiltinType::Char16:
17176 case BuiltinType::Char32:
17179 case BuiltinType::WChar_S:
17180 case BuiltinType::WChar_U:
17184 llvm_unreachable(
"Non-character type");
17194 char Arr[UNI_MAX_UTF8_BYTES_PER_CODE_POINT];
17197 llvm::raw_svector_ostream
OS(Str);
17201 if (K == BuiltinType::Char_S || K == BuiltinType::Char_U ||
17202 K == BuiltinType::Char8 ||
Value <= 0x7F) {
17203 StringRef Escaped = escapeCStyle<EscapeChar::Single>(
Value);
17204 if (!Escaped.empty())
17207 OS << static_cast<char>(
Value);
17212 case BuiltinType::Char16:
17213 case BuiltinType::Char32:
17214 case BuiltinType::WChar_S:
17215 case BuiltinType::WChar_U: {
17216 if (llvm::ConvertCodePointToUTF8(
Value, Ptr))
17220 << llvm::format_hex_no_prefix(
Value, TyWidth / 4,
true);
17224 llvm_unreachable(
"Non-character type is passed");
17236 switch (
V.getKind()) {
17242 int64_t BoolValue =
V.getInt().getExtValue();
17243 assert((BoolValue == 0 || BoolValue == 1) &&
17244 "Bool type, but value is not 0 or 1");
17245 llvm::raw_svector_ostream
OS(Str);
17246 OS << (BoolValue ?
"true" :
"false");
17248 llvm::raw_svector_ostream
OS(Str);
17253 switch (BTy->getKind()) {
17254 case BuiltinType::Char_S:
17255 case BuiltinType::Char_U:
17256 case BuiltinType::Char8:
17257 case BuiltinType::Char16:
17258 case BuiltinType::Char32:
17259 case BuiltinType::WChar_S:
17260 case BuiltinType::WChar_U: {
17262 assert(8 <= TyWidth && TyWidth <= 32 &&
"Unexpected integer width");
17263 uint32_t CodeUnit =
static_cast<uint32_t
>(
V.getInt().getZExtValue());
17268 << llvm::format_hex_no_prefix(CodeUnit, 2,
17270 <<
", " <<
V.getInt() <<
')';
17277 V.getInt().toString(Str);
17283 V.getFloat().toString(Str);
17287 if (
V.isNullPointer()) {
17288 llvm::raw_svector_ostream
OS(Str);
17295 llvm::raw_svector_ostream
OS(Str);
17297 V.getComplexFloatReal().toString(Str);
17299 V.getComplexFloatImag().toString(Str);
17304 llvm::raw_svector_ostream
OS(Str);
17306 V.getComplexIntReal().toString(Str);
17308 V.getComplexIntImag().toString(Str);
17331 if (isa<SubstNonTypeTemplateParmExpr>(E))
17335 if (
const auto *UnaryOp = dyn_cast<UnaryOperator>(E))
17339 if (
const auto *BO = dyn_cast<BinaryOperator>(E))
17340 return (BO->isShiftOp() || BO->isAdditiveOp() || BO->isMultiplicativeOp() ||
17341 BO->isBitwiseOp());
17349 if (
const auto *Op = dyn_cast<BinaryOperator>(E);
17350 Op && Op->getOpcode() != BO_LOr) {
17351 const Expr *LHS = Op->getLHS()->IgnoreParenImpCasts();
17352 const Expr *RHS = Op->getRHS()->IgnoreParenImpCasts();
17370 for (
unsigned I = 0; I < 2; I++) {
17371 const Expr *Side = DiagSide[I].Cond;
17375 DiagSide[I].Print =
17377 DiagSide[I].ValueString,
Context);
17379 if (DiagSide[0].Print && DiagSide[1].Print) {
17380 Diag(Op->getExprLoc(), diag::note_expr_evaluates_to)
17381 << DiagSide[0].ValueString << Op->getOpcodeStr()
17382 << DiagSide[1].ValueString << Op->getSourceRange();
17390 bool ErrorOnInvalidMessage) {
17392 assert(!Message->isTypeDependent() && !Message->isValueDependent() &&
17393 "can't evaluate a dependant static assert message");
17395 if (
const auto *SL = dyn_cast<StringLiteral>(Message)) {
17396 assert(SL->isUnevaluated() &&
"expected an unevaluated string");
17397 Result.assign(SL->getString().begin(), SL->getString().end());
17402 QualType T = Message->getType().getNonReferenceType();
17405 Diag(Loc, diag::err_static_assert_invalid_message);
17409 auto FindMember = [&](StringRef
Member,
bool &Empty,
17410 bool Diag =
false) -> std::optional<LookupResult> {
17414 Empty = MemberLookup.
empty();
17417 if (MemberLookup.
empty())
17418 return std::nullopt;
17419 return std::move(MemberLookup);
17422 bool SizeNotFound, DataNotFound;
17423 std::optional<LookupResult> SizeMember = FindMember(
"size", SizeNotFound);
17424 std::optional<LookupResult> DataMember = FindMember(
"data", DataNotFound);
17425 if (SizeNotFound || DataNotFound) {
17426 Diag(Loc, diag::err_static_assert_missing_member_function)
17427 << ((SizeNotFound && DataNotFound) ? 2
17433 if (!SizeMember || !DataMember) {
17435 FindMember(
"size", SizeNotFound,
true);
17437 FindMember(
"data", DataNotFound,
true);
17443 Message, Message->getType(), Message->getBeginLoc(),
false,
17468 Diag(Loc, diag::err_static_assert_invalid_mem_fn_ret_ty) << 0;
17478 Diag(Loc, diag::err_static_assert_invalid_mem_fn_ret_ty) << 1;
17482 if (!ErrorOnInvalidMessage &&
17483 Diags.
isIgnored(diag::warn_static_assert_message_constexpr, Loc))
17488 Status.Diag = &Notes;
17489 if (!Message->EvaluateCharRangeAsString(
Result, EvaluatedSize.
get(),
17490 EvaluatedData.
get(), Ctx, Status) ||
17492 Diag(Message->getBeginLoc(),
17493 ErrorOnInvalidMessage ? diag::err_static_assert_message_constexpr
17494 : diag::warn_static_assert_message_constexpr);
17495 for (
const auto &
Note : Notes)
17497 return !ErrorOnInvalidMessage;
17503 Expr *AssertExpr,
Expr *AssertMessage,
17506 assert(AssertExpr !=
nullptr &&
"Expected non-null condition");
17524 AssertExpr = FullAssertExpr.
get();
17527 Expr *BaseExpr = AssertExpr;
17539 diag::err_static_assert_expression_is_not_constant,
17545 if (!Failed && AssertMessage && Cond.getBoolValue()) {
17554 bool InTemplateDefinition =
17557 if (!Failed && !Cond && !InTemplateDefinition) {
17559 llvm::raw_svector_ostream Msg(MsgBuffer);
17560 bool HasMessage = AssertMessage;
17561 if (AssertMessage) {
17565 AssertMessage, Str,
Context,
true) ||
17569 Expr *InnerCond =
nullptr;
17570 std::string InnerCondDescription;
17571 std::tie(InnerCond, InnerCondDescription) =
17573 if (InnerCond && isa<ConceptSpecializationExpr>(InnerCond)) {
17581 }
else if (InnerCond && !isa<CXXBoolLiteralExpr>(InnerCond)
17582 && !isa<IntegerLiteral>(InnerCond)) {
17584 diag::err_static_assert_requirement_failed)
17585 << InnerCondDescription << !HasMessage << Msg.str()
17602 AssertExpr = FullAssertExpr.
get();
17606 AssertExpr, AssertMessage, RParenLoc,
17621 bool IsMemberSpecialization =
false;
17626 TagLoc, NameLoc, SS,
nullptr, TempParamLists,
true,
17627 IsMemberSpecialization,
Invalid)) {
17628 if (TemplateParams->size() > 0) {
17636 FriendLoc, TempParamLists.size() - 1,
17637 TempParamLists.data()).
get();
17640 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
17642 IsMemberSpecialization =
true;
17648 bool isAllExplicitSpecializations =
true;
17649 for (
unsigned I = TempParamLists.size(); I-- > 0; ) {
17650 if (TempParamLists[I]->size()) {
17651 isAllExplicitSpecializations =
false;
17661 if (isAllExplicitSpecializations) {
17663 bool Owned =
false;
17664 bool IsDependent =
false;
17685 if (isa<DependentNameType>(
T)) {
17699 TSI, FriendLoc, TempParamLists);
17705 assert(SS.
isNotEmpty() &&
"valid templated tag with no SS and no direct?");
17712 Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
17723 TSI, FriendLoc, TempParamLists);
17765 Diag(FriendLoc, diag::err_friend_not_first_in_declaration);
17793 if (TempParams.size()) {
17810 ? diag::warn_cxx98_compat_unelaborated_friend_type
17811 : diag::ext_unelaborated_friend_type)
17817 ? diag::warn_cxx98_compat_nonclass_type_friend
17818 : diag::ext_nonclass_type_friend)
17835 if (!TempParams.empty())
17872 Diag(Loc, diag::err_unexpected_friend);
17907 Scope *DCScope = S;
17909 RedeclarationKind::ForExternalRedeclaration);
17919 (FunctionContainingLocalClass =
17920 cast<CXXRecordDecl>(
CurContext)->isLocalClass())) {
17932 DCScope = S->getFnParent();
17942 DC =
Previous.getRepresentativeDecl()->getDeclContext();
17946 DC = FunctionContainingLocalClass;
17983 if (isTemplateId) {
17984 if (isa<TranslationUnitDecl>(LookupDC))
break;
17998 if (!DC)
return nullptr;
18009 diag::warn_cxx98_compat_friend_is_member :
18010 diag::err_friend_is_member);
18019 assert(isa<CXXRecordDecl>(DC) &&
"friend declaration not in class?");
18046 if (DiagArg >= 0) {
18047 Diag(Loc, diag::err_introducing_special_friend) << DiagArg;
18058 DCScope = &FakeDCScope;
18061 bool AddToScope =
true;
18063 TemplateParams, AddToScope);
18064 if (!ND)
return nullptr;
18098 FD = FTD->getTemplatedDecl();
18100 FD = cast<FunctionDecl>(ND);
18120 }
else if (FunctionContainingLocalClass) {
18129 }
else if (isTemplateId) {
18143 Diag(FD->
getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
18145 diag::note_previous_declaration);
18147 Diag(FD->
getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
18152 Diag(FD->
getLocation(), diag::warn_template_qualified_friend_unsupported)
18168 FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
18170 Diag(DelLoc, diag::err_deleted_non_function);
18181 Prev->getPreviousDecl()) &&
18182 !Prev->isDefined()) {
18183 Diag(DelLoc, diag::err_deleted_decl_not_first);
18184 Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
18185 Prev->isImplicit() ? diag::note_previous_implicit_declaration
18186 : diag::note_previous_declaration);
18209 Diag(DelLoc, diag::err_deleted_main);
18221 auto *FD = dyn_cast<FunctionDecl>(Dcl);
18223 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(Dcl)) {
18225 Diag(DefaultLoc, diag::err_defaulted_comparison_template);
18230 Diag(DefaultLoc, diag::err_default_special_members)
18241 (!FD->isDependentContext() ||
18242 (!isa<CXXConstructorDecl>(FD) &&
18244 Diag(DefaultLoc, diag::err_default_special_members)
18254 ? diag::warn_cxx17_compat_defaulted_comparison
18255 : diag::ext_defaulted_comparison);
18258 FD->setDefaulted();
18259 FD->setExplicitlyDefaulted();
18260 FD->setDefaultLoc(DefaultLoc);
18263 if (FD->isDependentContext())
18269 FD->setWillHaveBody(
false);
18282 if (isa<CXXMethodDecl>(FD)) {
18284 if (
const FunctionDecl *Pattern = FD->getTemplateInstantiationPattern())
18298 auto *MD = cast<CXXMethodDecl>(FD);
18309 for (
Stmt *SubStmt : S->children()) {
18312 if (isa<ReturnStmt>(SubStmt))
18313 Self.Diag(SubStmt->getBeginLoc(),
18314 diag::err_return_in_constructor_handler);
18315 if (!isa<Expr>(SubStmt))
18321 for (
unsigned I = 0, E = TryBlock->
getNumHandlers(); I != E; ++I) {
18329 switch (BodyKind) {
18338 "Parsed function body should be '= delete;' or '= default;'");
18348 for (
unsigned I = 0, E = OldFT->
getNumParams(); I != E; ++I)
18352 !NewFT->getExtParameterInfo(I).isNoEscape()) {
18354 diag::warn_overriding_method_missing_noescape);
18356 diag::note_overridden_marked_noescape);
18362 Diag(New->
getLocation(), diag::err_conflicting_overriding_attributes)
18369 const auto *OldCSA = Old->
getAttr<CodeSegAttr>();
18370 const auto *NewCSA = New->
getAttr<CodeSegAttr>();
18371 if ((NewCSA || OldCSA) &&
18372 (!OldCSA || !NewCSA || NewCSA->getName() != OldCSA->getName())) {
18381 if (NewCC == OldCC)
18392 diag::err_conflicting_overriding_cc_attributes)
18405 diag::err_explicit_object_parameter_nonmember)
18432 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
18440 if (NewClassTy.
isNull()) {
18442 diag::err_different_return_type_for_overriding_virtual_function)
18458 if (!RT->isBeingDefined() &&
18460 diag::err_covariant_return_incomplete,
18477 NewClassTy, OldClassTy,
18478 diag::err_covariant_return_inaccessible_base,
18479 diag::err_covariant_return_ambiguous_derived_to_base_conv,
18495 diag::err_covariant_return_type_different_qualifications)
18507 diag::err_covariant_return_type_class_type_more_qualified)
18542 else if (
auto *M = dyn_cast<CXXMethodDecl>(D))
18551 if (
const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
18552 return Var->hasGlobalStorage();
18606 "Parser allowed 'typedef' as storage class of condition decl.");
18612 if (isa<FunctionDecl>(Dcl)) {
18618 if (
auto *VD = dyn_cast<VarDecl>(Dcl))
18631 for (
unsigned I = 0, N = VTables.size(); I != N; ++I) {
18632 llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
18636 if (!Pos->second && VTables[I].DefinitionRequired)
18637 Pos->second =
true;
18641 VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
18642 NewUses.push_back(
VTableUse(VTables[I].
Record, VTables[I].Location));
18649 bool DefinitionRequired) {
18652 if (!
Class->isDynamicClass() ||
Class->isDependentContext() ||
18658 !
OpenMP().isInOpenMPDeclareTargetContext() &&
18659 !
OpenMP().isInOpenMPTargetExecutionDirective()) {
18660 if (!DefinitionRequired)
18668 std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator,
bool>
18674 if (DefinitionRequired && !Pos.first->second) {
18675 Pos.first->second =
true;
18704 if (
Class->isLocalClass())
18719 bool DefinedAnything =
false;
18720 for (
unsigned I = 0; I !=
VTableUses.size(); ++I) {
18725 Class->getTemplateSpecializationKind();
18729 bool DefineVTable =
true;
18735 if (KeyFunction && !KeyFunction->
hasBody()) {
18737 DefineVTable =
false;
18742 "Instantiations don't have key functions");
18744 }
else if (!KeyFunction) {
18749 bool IsExplicitInstantiationDeclaration =
18751 for (
auto *R :
Class->redecls()) {
18753 = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
18755 IsExplicitInstantiationDeclaration =
true;
18757 IsExplicitInstantiationDeclaration =
false;
18762 if (IsExplicitInstantiationDeclaration)
18763 DefineVTable =
false;
18769 if (!DefineVTable) {
18777 DefinedAnything =
true;
18790 if (!KeyFunction || (KeyFunction->
hasBody(KeyFunctionDef) &&
18797 return DefinedAnything;
18802 for (
const auto *I : RD->
methods())
18803 if (I->isVirtual() && !I->isPureVirtual())
18809 bool ConstexprOnly) {
18813 for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
18814 E = FinalOverriders.end();
18817 OE = I->second.end();
18819 assert(OI->second.size() > 0 &&
"no final overrider");
18834 for (
const auto &I : RD->
bases()) {
18837 if (
Base->getNumVBases() == 0)
18854 for (
unsigned i = 0; i < ivars.size(); i++) {
18856 if (Field->isInvalidDecl())
18866 InitSeq.
Perform(*
this, InitEntity, InitKind, std::nullopt);
18878 AllToInit.push_back(
Member);
18883 ->getAs<RecordType>()) {
18884 CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
18888 PDiag(diag::err_access_dtor_ivar)
18894 AllToInit.data(), AllToInit.size());
18915 cast_or_null<CXXConstructorDecl>(FNTarget));
18922 if (!Current.insert(Canonical).second)
18927 Target->isInvalidDecl() || Valid.count(TCanonical)) {
18928 Valid.insert(Current.begin(), Current.end());
18931 }
else if (TCanonical == Canonical ||
Invalid.count(TCanonical) ||
18932 Current.count(TCanonical)) {
18934 if (!
Invalid.count(TCanonical)) {
18936 diag::warn_delegating_ctor_cycle)
18940 if (TCanonical != Canonical)
18941 S.
Diag(
Target->getLocation(), diag::note_it_delegates_to);
18944 while (
C->getCanonicalDecl() != Canonical) {
18946 (void)
C->getTargetConstructor()->hasBody(FNTarget);
18947 assert(FNTarget &&
"Ctor cycle through bodiless function");
18950 cast<CXXConstructorDecl>(FNTarget));
18951 S.
Diag(
C->getLocation(), diag::note_which_delegates_to);
18955 Invalid.insert(Current.begin(), Current.end());
18966 for (DelegatingCtorDeclsType::iterator
18972 for (
auto CI =
Invalid.begin(), CE =
Invalid.end(); CI != CE; ++CI)
18973 (*CI)->setInvalidDecl();
18982 explicit FindCXXThisExpr(
Sema &S) : S(S) { }
19010 FindCXXThisExpr Finder(*
this);
19023 if (!Finder.TraverseStmt(E))
19040 FindCXXThisExpr Finder(*
this);
19062 if (!Finder.TraverseType(E))
19072 FindCXXThisExpr Finder(*
this);
19075 for (
const auto *A : Method->
attrs()) {
19077 Expr *Arg =
nullptr;
19079 if (
const auto *G = dyn_cast<GuardedByAttr>(A))
19081 else if (
const auto *G = dyn_cast<PtGuardedByAttr>(A))
19083 else if (
const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
19085 else if (
const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
19087 else if (
const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
19088 Arg = ETLF->getSuccessValue();
19090 }
else if (
const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
19091 Arg = STLF->getSuccessValue();
19093 }
else if (
const auto *LR = dyn_cast<LockReturnedAttr>(A))
19094 Arg = LR->getArg();
19095 else if (
const auto *LE = dyn_cast<LocksExcludedAttr>(A))
19097 else if (
const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
19099 else if (
const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
19101 else if (
const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
19103 else if (
const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
19106 if (Arg && !Finder.TraverseStmt(Arg))
19109 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
19110 if (!Finder.TraverseStmt(Args[I]))
19124 Exceptions.clear();
19127 Exceptions.reserve(DynamicExceptions.size());
19128 for (
unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
19135 if (!Unexpanded.empty()) {
19146 Exceptions.push_back(ET);
19156 "Parser should have made sure that the expression is boolean");
19172 Expr *NoexceptExpr) {
19178 MethodD = FunTmpl->getTemplatedDecl();
19188 DynamicExceptionRanges, NoexceptExpr, Exceptions,
19214 Diag(DeclStart, diag::err_anonymous_property);
19239 diag::err_invalid_thread)
19245 RedeclarationKind::ForVisibleRedeclaration);
19247 switch (
Previous.getResultKind()) {
19254 PrevDecl =
Previous.getRepresentativeDecl();
19267 PrevDecl =
nullptr;
19271 PrevDecl =
nullptr;
19282 Record->setInvalidDecl();
19304 if (!ExplicitLists.empty()) {
19305 bool IsMemberSpecialization, IsInvalid;
19309 ExplicitLists,
false, IsMemberSpecialization, IsInvalid,
19321 if (ExplicitParams && !ExplicitParams->
empty()) {
19322 Info.AutoTemplateParameterDepth = ExplicitParams->
getDepth();
19323 llvm::append_range(Info.TemplateParams, *ExplicitParams);
19324 Info.NumExplicitTemplateParams = ExplicitParams->
size();
19326 Info.AutoTemplateParameterDepth = TemplateParameterDepth;
19327 Info.NumExplicitTemplateParams = 0;
19333 if (FSI.TemplateParams.size() > FSI.NumExplicitTemplateParams) {
19334 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 bool findCircularInheritance(const CXXRecordDecl *Class, const CXXRecordDecl *Current)
Determine whether the given class is a base class of the given class, including looking at dependent ...
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 isNonlocalVariable(const Decl *D)
Determine whether the given declaration is a global variable or static data member.
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 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.
ArrayRef< NamedDecl * > chain() const
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.
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.
const ObjCInterfaceDecl * getClassInterface() const
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
void setIvarInitializers(ASTContext &C, CXXCtorInitializer **initializers, unsigned numInitializers)
Represents an ObjC class declaration.
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.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
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.
void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI, SmallVectorImpl< ObjCIvarDecl * > &Ivars)
CollectIvarsToConstructOrDestruct - Collect those ivars which require initialization.
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)
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.
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 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
void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation)
SetIvarInitializers - This routine builds initialization ASTs for the Objective-C implementation whos...
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)
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, 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...
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.
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.
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.
void actOnDelayedExceptionSpecification(Decl *Method, ExceptionSpecificationType EST, SourceRange SpecificationRange, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr)
Add an exception-specification to the given member function (or member function template).
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.
bool inferObjCARCLifetime(ValueDecl *decl)
@ 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.
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()
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...
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 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