48#include "llvm/ADT/APInt.h"
49#include "llvm/ADT/STLExtras.h"
50#include "llvm/ADT/StringExtras.h"
51#include "llvm/Support/ErrorHandling.h"
52#include "llvm/Support/TypeSize.h"
62 if ([[maybe_unused]]
const auto *DNT = dyn_cast<DependentNameType>(
Type))
63 assert(DNT->getIdentifier() == &Name &&
"not a constructor name");
76 "not a constructor name");
98 auto *RD = dyn_cast<CXXRecordDecl>(ND);
99 if (RD && RD->isInjectedClassName()) {
100 InjectedClassName = RD;
104 if (!InjectedClassName) {
109 diag::err_incomplete_nested_name_spec) << CurClass << SS.
getRange();
115 InjectedClassName,
false);
122 bool EnteringContext) {
168 auto IsAcceptableResult = [&](
NamedDecl *D) ->
bool {
169 auto *
Type = dyn_cast<TypeDecl>(D->getUnderlyingDecl());
177 return Context.hasSameUnqualifiedType(
T, SearchType);
180 unsigned NumAcceptableResults = 0;
182 if (IsAcceptableResult(D))
183 ++NumAcceptableResults;
188 if (
auto *RD = dyn_cast<CXXRecordDecl>(D))
189 if (RD->isInjectedClassName())
192 if (FoundDeclSet.insert(D).second)
193 FoundDecls.push_back(D);
201 if (
Found.isAmbiguous() && NumAcceptableResults == 1) {
202 Diag(NameLoc, diag::ext_dtor_name_ambiguous);
213 if (!IsAcceptableResult(D))
219 if (
Found.isAmbiguous())
223 if (IsAcceptableResult(
Type)) {
228 Context.getTrivialTypeSourceInfo(
T, NameLoc));
235 bool IsDependent =
false;
237 auto LookupInObjectType = [&]() ->
ParsedType {
238 if (Failed || SearchType.
isNull())
248 return CheckLookupResult(
Found);
266 return CheckLookupResult(
Found);
275 return CheckLookupResult(
Found);
318 return TL.getPrefix();
329 PrefixSS.
Adopt(Prefix);
330 if (
ParsedType T = LookupInNestedNameSpec(PrefixSS))
364 unsigned NumNonExtensionDecls = FoundDecls.size();
388 Diag(SS.
getEndLoc(), diag::ext_qualified_dtor_named_in_lexical_scope)
390 Diag(FoundDecls.back()->getLocation(), diag::note_destructor_type_here)
401 FoundDecls.resize(NumNonExtensionDecls);
410 auto MakeFixItHint = [&]{
416 Destroyed = dyn_cast_or_null<CXXRecordDecl>(S->
getEntity());
423 if (FoundDecls.empty()) {
425 Diag(NameLoc, diag::err_undeclared_destructor_name)
426 << &II << MakeFixItHint();
427 }
else if (!SearchType.
isNull() && FoundDecls.size() == 1) {
428 if (
auto *TD = dyn_cast<TypeDecl>(FoundDecls[0]->getUnderlyingDecl())) {
429 assert(!SearchType.
isNull() &&
430 "should only reject a type result if we have a search type");
431 Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
434 << SearchType << MakeFixItHint();
436 Diag(NameLoc, diag::err_destructor_expr_nontype)
437 << &II << MakeFixItHint();
440 Diag(NameLoc, SearchType.
isNull() ? diag::err_destructor_name_nontype
441 : diag::err_destructor_expr_mismatch)
442 << &II << SearchType << MakeFixItHint();
446 if (
auto *TD = dyn_cast<TypeDecl>(FoundD->getUnderlyingDecl()))
447 Diag(FoundD->getLocation(), diag::note_destructor_type_here)
451 Diag(FoundD->getLocation(), diag::note_destructor_nontype_here)
469 "unexpected type in getDestructorType");
476 !
Context.hasSameUnqualifiedType(
T, SearchType)) {
499 (StringRef(
"operator\"\"") + II->
getName()).str());
508 Diag(Loc, diag::warn_deprecated_literal_operator_id) << II << Hint;
511 Diag(Loc, diag::warn_reserved_extern_symbol)
512 << II << static_cast<int>(Status) << Hint;
521 Diag(Name.
getBeginLoc(), diag::err_literal_operator_id_outside_namespace)
532 llvm_unreachable(
"unknown nested name specifier kind");
546 =
Context.getUnqualifiedArrayType(Operand->getType().getNonReferenceType(),
548 if (
T->isRecordType() &&
552 if (
T->isVariablyModifiedType())
553 return ExprError(
Diag(TypeidLoc, diag::err_variably_modified_typeid) <<
T);
566 bool WasEvaluated =
false;
575 if (
auto *RecordD =
T->getAsCXXRecordDecl()) {
586 if (RecordD->isPolymorphic() && E->
isGLValue()) {
614 if (!
Context.hasSameType(
T, UnqualT)) {
621 return ExprError(
Diag(TypeidLoc, diag::err_variably_modified_typeid)
628 ? diag::warn_side_effects_typeid
629 : diag::warn_side_effects_unevaluated_context);
642 return ExprError(
Diag(OpLoc, diag::err_openclcxx_not_supported)
648 return ExprError(
Diag(OpLoc, diag::err_need_header_before_typeid));
662 return ExprError(
Diag(OpLoc, diag::err_need_header_before_typeid));
666 return ExprError(
Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));
680 TInfo =
Context.getTrivialTypeSourceInfo(
T, OpLoc);
690 if (
auto *CTE = dyn_cast<CXXTypeidExpr>(
Result.get()))
691 if (CTE->isPotentiallyEvaluated() && !CTE->isMostDerived(
Context))
692 Diag(OpLoc, diag::warn_no_typeid_with_rtti_disabled)
714 if (
const auto *Uuid = TD->getMostRecentDecl()->getAttr<UuidAttr>()) {
715 UuidAttrs.insert(Uuid);
720 if (
const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
723 const UuidAttr *UuidForTA =
nullptr;
730 UuidAttrs.insert(UuidForTA);
740 if (!Operand->getType()->isDependentType()) {
743 if (UuidAttrs.empty())
744 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_without_guid));
745 if (UuidAttrs.size() > 1)
746 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
747 Guid = UuidAttrs.back()->getGuidDecl();
764 if (UuidAttrs.empty())
765 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_without_guid));
766 if (UuidAttrs.size() > 1)
767 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
768 Guid = UuidAttrs.back()->getGuidDecl();
792 TInfo =
Context.getTrivialTypeSourceInfo(
T, OpLoc);
803 assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
804 "Unknown C++ Boolean value!");
816 bool IsThrownVarInScope =
false;
829 if (
const auto *DRE = dyn_cast<DeclRefExpr>(Ex->
IgnoreParens()))
830 if (
const auto *Var = dyn_cast<VarDecl>(DRE->getDecl());
831 Var && Var->hasLocalStorage() &&
832 !Var->getType().isVolatileQualified()) {
835 IsThrownVarInScope =
true;
852 bool IsThrownVarInScope) {
853 const llvm::Triple &
T =
Context.getTargetInfo().getTriple();
854 const bool IsOpenMPGPUTarget =
855 getLangOpts().OpenMPIsTargetDevice && (
T.isNVPTX() ||
T.isAMDGCN());
860 if (IsOpenMPGPUTarget)
861 targetDiag(OpLoc, diag::warn_throw_not_valid_on_target) <<
T.str();
869 Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) <<
"throw";
874 Diag(OpLoc, diag::err_acc_branch_in_out_compute_construct)
909 if (Ex &&
Context.getTargetInfo().getTriple().isPPC64())
918 llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,
919 llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,
920 llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,
921 bool ParentIsPublic) {
923 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
928 NewSubobject = VBases.insert(BaseDecl).second;
933 ++SubobjectsSeen[BaseDecl];
936 bool PublicPath = ParentIsPublic && BS.getAccessSpecifier() ==
AS_public;
938 PublicSubobjectsSeen.insert(BaseDecl);
948 llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;
950 llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;
951 SubobjectsSeen[RD] = 1;
952 PublicSubobjectsSeen.insert(RD);
956 for (
CXXRecordDecl *PublicSubobject : PublicSubobjectsSeen) {
958 if (SubobjectsSeen[PublicSubobject] > 1)
961 Objects.push_back(PublicSubobject);
970 bool isPointer =
false;
990 isPointer ? diag::err_throw_incomplete_ptr
991 : diag::err_throw_incomplete,
1001 diag::err_throw_abstract_type, E))
1023 PDiag(diag::err_access_dtor_exception) << Ty);
1032 if (
Context.getTargetInfo().getCXXABI().isMicrosoft()) {
1039 for (
CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {
1062 Context.addCopyConstructorForExceptionObject(Subobject, CD);
1066 for (
unsigned I = 1, E = CD->
getNumParams(); I != E; ++I) {
1077 if (
Context.getTargetInfo().getCXXABI().isItaniumFamily()) {
1080 if (ExnObjAlign < TypeAlign) {
1081 Diag(ThrowLoc, diag::warn_throw_underaligned_obj);
1082 Diag(ThrowLoc, diag::note_throw_underaligned_obj)
1087 if (!isPointer &&
getLangOpts().AssumeNothrowExceptionDtor) {
1089 auto Ty = Dtor->getType();
1093 Diag(ThrowLoc, diag::err_throw_object_throwing_dtor) << RD;
1145 for (
int I = FunctionScopes.size();
1157 if (
C.isCopyCapture()) {
1169 "While computing 'this' capture-type for a generic lambda, when we "
1170 "run out of enclosing LSI's, yet the enclosing DC is a "
1171 "lambda-call-operator we must be (i.e. Current LSI) in a generic "
1172 "lambda call oeprator");
1175 auto IsThisCaptured =
1180 if (
C.capturesThis()) {
1191 bool IsByCopyCapture =
false;
1192 bool IsConstCapture =
false;
1195 IsThisCaptured(Closure, IsByCopyCapture, IsConstCapture)) {
1196 if (IsByCopyCapture) {
1214 if (method && method->isImplicitObjectMemberFunction())
1215 ThisTy = method->getThisType().getNonReferenceType();
1227 ThisTy =
Context.getPointerType(ClassTy);
1245 if (!Enabled || !ContextDecl)
1259 T = S.getASTContext().getQualifiedType(
T, CXXThisTypeQuals);
1261 S.CXXThisTypeOverride =
1262 S.Context.getLangOpts().HLSL ?
T : S.Context.getPointerType(
T);
1264 this->Enabled =
true;
1270 S.CXXThisTypeOverride = OldCXXThisTypeOverride;
1281 Sema.
Diag(DiagLoc, diag::note_lambda_this_capture_fixit)
1287 bool BuildAndDiagnose,
const unsigned *
const FunctionScopeIndexToStopAt,
1288 const bool ByCopy) {
1293 assert((!ByCopy ||
Explicit) &&
"cannot implicitly capture *this by value");
1295 const int MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
1296 ? *FunctionScopeIndexToStopAt
1322 unsigned NumCapturingClosures = 0;
1323 for (
int idx = MaxFunctionScopesIndex; idx >= 0; idx--) {
1326 if (CSI->CXXThisCaptureIndex != 0) {
1328 CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed(BuildAndDiagnose);
1334 if (BuildAndDiagnose) {
1336 Diag(Loc, diag::err_this_capture)
1337 << (
Explicit && idx == MaxFunctionScopesIndex);
1347 (
Explicit && idx == MaxFunctionScopesIndex)) {
1353 NumCapturingClosures++;
1357 if (BuildAndDiagnose) {
1359 Diag(Loc, diag::err_this_capture)
1360 << (
Explicit && idx == MaxFunctionScopesIndex);
1368 if (!BuildAndDiagnose)
return false;
1381 "Only a lambda can capture the enclosing object (referred to by "
1384 for (
int idx = MaxFunctionScopesIndex; NumCapturingClosures;
1385 --idx, --NumCapturingClosures) {
1392 bool isNested = NumCapturingClosures > 1;
1426 const auto *
Method = dyn_cast<CXXMethodDecl>(DC);
1427 if (
Method &&
Method->isExplicitObjectMemberFunction()) {
1428 Diag(Loc, diag::err_invalid_this_use) << 1;
1430 Diag(Loc, diag::err_invalid_this_use) << 1;
1432 Diag(Loc, diag::err_invalid_this_use) << 0;
1446 if (
This->isTypeDependent())
1451 auto IsDependent = [&]() {
1453 auto *LSI = dyn_cast<sema::LambdaScopeInfo>(
Scope);
1457 if (LSI->Lambda && !LSI->Lambda->Encloses(
CurContext) &&
1458 LSI->AfterParameterList)
1465 if (LSI->isCXXThisCaptured()) {
1466 if (!LSI->getCXXThisCapture().isCopyCapture())
1469 const auto *MD = LSI->CallOperator;
1470 if (MD->getType().isNull())
1474 return Ty && MD->isExplicitObjectMemberFunction() &&
1481 This->setCapturedByCopyInLambdaWithExplicitObjectParameter(IsDependent);
1501 bool ListInitialization) {
1511 RParenOrBraceLoc, ListInitialization);
1514 RParenOrBraceLoc, exprs, Ty);
1523 bool ListInitialization) {
1532 ? ListInitialization
1534 TyBeginLoc, LParenOrBraceLoc, RParenOrBraceLoc)
1547 if (Deduced && !Deduced->isDeduced() &&
1554 }
else if (Deduced && !Deduced->isDeduced()) {
1556 if (ListInitialization) {
1558 Inits =
MultiExprArg(ILE->getInits(), ILE->getNumInits());
1562 return ExprError(
Diag(TyBeginLoc, diag::err_auto_expr_init_no_expression)
1563 << Ty << FullRange);
1564 if (Inits.size() > 1) {
1565 Expr *FirstBad = Inits[1];
1567 diag::err_auto_expr_init_multiple_expressions)
1568 << Ty << FullRange);
1571 if (Ty->
getAs<AutoType>())
1572 Diag(TyBeginLoc, diag::warn_cxx20_compat_auto_expr) << FullRange;
1574 Expr *Deduce = Inits[0];
1578 << ListInitialization << Ty << FullRange);
1585 return ExprError(
Diag(TyBeginLoc, diag::err_auto_expr_deduction_failure)
1586 << Ty << Deduce->
getType() << FullRange
1588 if (DeducedType.
isNull()) {
1600 RParenOrBraceLoc, ListInitialization);
1606 if (Exprs.size() == 1 && !ListInitialization &&
1608 Expr *Arg = Exprs[0];
1616 if (!ListInitialization)
1617 return ExprError(
Diag(TyBeginLoc, diag::err_value_init_for_array_type)
1619 ElemTy =
Context.getBaseElementType(Ty);
1627 return ExprError(
Diag(TyBeginLoc, diag::err_init_for_function_type)
1628 << Ty << FullRange);
1637 if (ListInitialization &&
1642 Exprs[0]->getBeginLoc(), Exprs[0]->getEndLoc());
1645 diag::err_invalid_incomplete_type_use,
1659 Inner = BTE->getSubExpr();
1660 if (
auto *CE = dyn_cast<ConstantExpr>(Inner);
1661 CE && CE->isImmediateInvocation())
1662 Inner = CE->getSubExpr();
1676 :
SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
1697 Method->getDeclContext()->lookup(
Method->getDeclName());
1698 for (
const auto *D : R) {
1699 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
1709 bool Result =
Method->isUsualDeallocationFunction(PreventedBy);
1716 return llvm::none_of(PreventedBy, [&](
const FunctionDecl *FD) {
1718 "Only single-operand functions should be in PreventedBy");
1736 unsigned UsualParams = 1;
1737 if (S.
getLangOpts().SizedDeallocation && UsualParams < FD->getNumParams() &&
1743 if (S.
getLangOpts().AlignedAllocation && UsualParams < FD->getNumParams() &&
1753 struct UsualDeallocFnInfo {
1754 UsualDeallocFnInfo()
1757 UsualDeallocFnInfo(Sema &S, DeclAccessPair
Found, QualType AllocType,
1759 :
Found(
Found), FD(dyn_cast<FunctionDecl>(
Found->getUnderlyingDecl())),
1761 IDP({AllocType, TypeAwareAllocationMode::No,
1762 AlignedAllocationMode::No, SizedDeallocationMode::No}),
1767 if (AllocType.isNull())
1769 auto *FTD = dyn_cast<FunctionTemplateDecl>(
Found->getUnderlyingDecl());
1772 FunctionDecl *InstantiatedDecl =
1773 S.BuildTypeAwareUsualDelete(FTD, AllocType, Loc);
1774 if (!InstantiatedDecl)
1776 FD = InstantiatedDecl;
1778 unsigned NumBaseParams = 1;
1779 if (FD->isTypeAwareOperatorNewOrDelete()) {
1785 if (AllocType.isNull()) {
1789 QualType TypeIdentityTag = FD->getParamDecl(0)->getType();
1790 QualType ExpectedTypeIdentityTag =
1791 S.tryBuildStdTypeIdentity(AllocType, Loc);
1792 if (ExpectedTypeIdentityTag.
isNull()) {
1796 if (!S.Context.hasSameType(TypeIdentityTag, ExpectedTypeIdentityTag)) {
1800 IDP.PassTypeIdentity = TypeAwareAllocationMode::Yes;
1804 if (FD->isDestroyingOperatorDelete()) {
1809 if (NumBaseParams < FD->getNumParams() &&
1810 S.Context.hasSameUnqualifiedType(
1811 FD->getParamDecl(NumBaseParams)->getType(),
1812 S.Context.getSizeType())) {
1814 IDP.PassSize = SizedDeallocationMode::Yes;
1817 if (NumBaseParams < FD->getNumParams() &&
1818 FD->getParamDecl(NumBaseParams)->getType()->isAlignValT()) {
1820 IDP.PassAlignment = AlignedAllocationMode::Yes;
1824 if (S.getLangOpts().CUDA)
1825 CUDAPref = S.CUDA().IdentifyPreference(
1826 S.getCurFunctionDecl(
true), FD);
1829 explicit operator bool()
const {
return FD; }
1832 ImplicitDeallocationParameters TargetIDP)
const {
1839 if (Destroying !=
Other.Destroying)
1840 return Destroying ? 1 : -1;
1842 const ImplicitDeallocationParameters &OtherIDP =
Other.IDP;
1852 return IDP.PassAlignment == TargetIDP.
PassAlignment ? 1 : -1;
1854 if (IDP.PassSize != OtherIDP.
PassSize)
1855 return IDP.PassSize == TargetIDP.
PassSize ? 1 : -1;
1860 FunctionTemplateDecl *PrimaryTemplate = FD->getPrimaryTemplate();
1861 FunctionTemplateDecl *OtherPrimaryTemplate =
1862 Other.FD->getPrimaryTemplate();
1863 if ((!PrimaryTemplate) != (!OtherPrimaryTemplate))
1864 return OtherPrimaryTemplate ? 1 : -1;
1866 if (PrimaryTemplate && OtherPrimaryTemplate) {
1867 const auto *DC = dyn_cast<CXXRecordDecl>(
Found->getDeclContext());
1868 const auto *OtherDC =
1869 dyn_cast<CXXRecordDecl>(
Other.Found->getDeclContext());
1870 unsigned ImplicitArgCount = Destroying + IDP.getNumImplicitArgs();
1872 PrimaryTemplate, OtherPrimaryTemplate, SourceLocation(),
1877 return Best == PrimaryTemplate ? 1 : -1;
1883 if (CUDAPref >
Other.CUDAPref)
1885 if (CUDAPref ==
Other.CUDAPref)
1890 DeclAccessPair
Found;
1893 ImplicitDeallocationParameters IDP;
1913 QualType SelectedTypeIdentityParameter =
1916 diag::err_incomplete_type))
1924 S.
Diag(StartLoc, diag::err_deleted_function_use)
1925 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef());
1942 UsualDeallocFnInfo Best;
1943 for (
auto I = R.
begin(), E = R.
end(); I != E; ++I) {
1944 UsualDeallocFnInfo Info(S, I.getPair(), IDP.
Type, Loc);
1955 BestFns->push_back(Info);
1958 int ComparisonResult = Best.Compare(S, Info, IDP);
1959 if (ComparisonResult > 0)
1964 if (BestFns && ComparisonResult < 0)
1969 BestFns->push_back(Info);
1982 const auto *record =
1984 if (!record)
return false;
1997 if (ops.
empty())
return false;
2007 allocType, PassType,
2019 std::optional<Expr *> ArraySize;
2045 if (
Expr *NumElts = Array.NumElts) {
2046 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {
2060 NumElts,
nullptr, diag::err_new_array_nonconst,
2078 DirectInitRange = List->getSourceRange();
2081 PlacementLParen, PlacementArgs, PlacementRParen,
2082 TypeIdParens, AllocType, TInfo, ArraySize, DirectInitRange,
2091 return IsCPlusPlus20 || PLE->getNumExprs() == 0;
2095 return !CCE->isListInitialization() &&
2096 CCE->getConstructor()->isDefaultConstructor();
2099 "Shouldn't create list CXXConstructExprs for arrays.");
2124 StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling(
2129 Diag(Loc, diag::err_aligned_allocation_unavailable)
2131 << OSVersion.getAsString() << OSVersion.empty();
2132 Diag(Loc, diag::note_silence_aligned_allocation_unavailable);
2142 std::optional<Expr *> ArraySize,
2148 if (DirectInitRange.
isValid()) {
2149 assert(
Initializer &&
"Have parens but no initializer.");
2151 }
else if (isa_and_nonnull<InitListExpr>(
Initializer))
2156 "Initializer expression that cannot have been implicitly created.");
2163 "paren init for non-call init");
2164 Exprs =
MultiExprArg(List->getExprs(), List->getNumExprs());
2165 }
else if (
auto *List = dyn_cast_or_null<CXXParenListInitExpr>(
Initializer)) {
2167 "paren init for non-call init");
2168 Exprs = List->getInitExprs();
2175 switch (InitStyle) {
2186 DirectInitRange.
getEnd());
2192 llvm_unreachable(
"Unknown initialization kind");
2197 if (Deduced && !Deduced->isDeduced() &&
2201 Diag(*ArraySize ? (*ArraySize)->getExprLoc() : TypeRange.
getBegin(),
2202 diag::err_deduced_class_template_compound_type)
2204 << (*ArraySize ? (*ArraySize)->getSourceRange() : TypeRange));
2209 AllocTypeInfo, Entity, Kind, Exprs);
2212 }
else if (Deduced && !Deduced->isDeduced()) {
2217 Inits =
MultiExprArg(ILE->getInits(), ILE->getNumInits());
2221 return ExprError(
Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
2222 << AllocType << TypeRange);
2223 if (Inits.size() > 1) {
2224 Expr *FirstBad = Inits[1];
2226 diag::err_auto_new_ctor_multiple_expressions)
2227 << AllocType << TypeRange);
2231 << AllocType << TypeRange;
2232 Expr *Deduce = Inits[0];
2236 << Braced << AllocType << TypeRange);
2243 return ExprError(
Diag(StartLoc, diag::err_auto_new_deduction_failure)
2244 << AllocType << Deduce->
getType() << TypeRange
2246 if (DeducedType.
isNull()) {
2250 AllocType = DeducedType;
2258 =
Context.getAsConstantArrayType(AllocType)) {
2262 AllocType = Array->getElementType();
2276 AllocType =
Context.getLifetimeQualifiedType(AllocType,
2282 if (ArraySize && *ArraySize &&
2283 (*ArraySize)->getType()->isNonOverloadPlaceholderType()) {
2286 ArraySize = result.
get();
2295 std::optional<uint64_t> KnownArraySize;
2296 if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {
2299 assert(
Context.getTargetInfo().getIntWidth() &&
"Builtin type of size 0?");
2304 if (!ConvertedSize.
isInvalid() && (*ArraySize)->getType()->isRecordType())
2306 Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion)
2307 << (*ArraySize)->getType() << 0 <<
"'size_t'";
2314 SizeConvertDiagnoser(
Expr *ArraySize)
2316 ArraySize(ArraySize) {}
2320 return S.
Diag(Loc, diag::err_array_size_not_integral)
2326 return S.
Diag(Loc, diag::err_array_size_incomplete_type)
2332 return S.
Diag(Loc, diag::err_array_size_explicit_conversion) <<
T << ConvTy;
2343 return S.
Diag(Loc, diag::err_array_size_ambiguous_conversion) <<
T;
2357 ? diag::warn_cxx98_compat_array_size_conversion
2358 : diag::ext_array_size_conversion)
2361 } SizeDiagnoser(*ArraySize);
2369 ArraySize = ConvertedSize.
get();
2370 QualType SizeType = (*ArraySize)->getType();
2372 if (!SizeType->isIntegralOrUnscopedEnumerationType())
2388 if (std::optional<llvm::APSInt>
Value =
2389 (*ArraySize)->getIntegerConstantExpr(
Context)) {
2390 if (
Value->isSigned() &&
Value->isNegative()) {
2392 diag::err_typecheck_negative_array_size)
2393 << (*ArraySize)->getSourceRange());
2397 unsigned ActiveSizeBits =
2401 Diag((*ArraySize)->getBeginLoc(), diag::err_array_too_large)
2405 << (*ArraySize)->getSourceRange());
2408 KnownArraySize =
Value->getZExtValue();
2409 }
else if (TypeIdParens.
isValid()) {
2411 Diag((*ArraySize)->getBeginLoc(), diag::ext_new_paren_array_nonconst)
2412 << (*ArraySize)->getSourceRange()
2425 unsigned Alignment =
2427 unsigned NewAlignment =
Context.getTargetInfo().getNewAlign();
2431 Alignment > NewAlignment)};
2440 AllocationParameterRange =
SourceRange(PlacementLParen, PlacementRParen);
2444 AllocType, ArraySize.has_value(), IAP,
2445 PlacementArgs, OperatorNew, OperatorDelete))
2450 bool UsualArrayDeleteWantsSize =
false;
2466 unsigned NumImplicitArgs = 1;
2468 assert(OperatorNew->isTypeAwareOperatorNewOrDelete());
2474 Proto, NumImplicitArgs, PlacementArgs,
2475 AllPlaceArgs, CallType))
2478 if (!AllPlaceArgs.empty())
2479 PlacementArgs = AllPlaceArgs;
2487 unsigned SizeTyWidth =
Context.getTypeSize(SizeTy);
2489 llvm::APInt SingleEltSize(
2490 SizeTyWidth,
Context.getTypeSizeInChars(AllocType).getQuantity());
2493 std::optional<llvm::APInt> AllocationSize;
2496 AllocationSize = SingleEltSize;
2500 AllocationSize = llvm::APInt(SizeTyWidth, *KnownArraySize)
2501 .umul_ov(SingleEltSize, Overflow);
2505 "Expected that all the overflows would have been handled already.");
2509 Context, AllocationSize.value_or(llvm::APInt::getZero(SizeTyWidth)),
2524 llvm::APInt(
Context.getTypeSize(SizeTy),
2525 Alignment /
Context.getCharWidth()),
2528 CK_IntegralCast, &AlignmentLiteral,
2533 CallArgs.reserve(NumImplicitArgs + PlacementArgs.size());
2534 CallArgs.emplace_back(AllocationSize
2535 ?
static_cast<Expr *
>(&AllocationSizeLiteral)
2536 : &OpaqueAllocationSize);
2538 CallArgs.emplace_back(&DesiredAlignment);
2539 llvm::append_range(CallArgs, PlacementArgs);
2543 checkCall(OperatorNew, Proto,
nullptr, CallArgs,
2544 false, StartLoc, Range, CallType);
2549 (OperatorNew->isImplicit() ||
2550 (OperatorNew->getBeginLoc().isValid() &&
2552 if (Alignment > NewAlignment)
2553 Diag(StartLoc, diag::warn_overaligned_type)
2565 SourceRange InitRange(Exprs.front()->getBeginLoc(),
2566 Exprs.back()->getEndLoc());
2567 Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
2578 InitType =
Context.getConstantArrayType(
2584 InitType =
Context.getIncompleteArrayType(AllocType,
2587 InitType = AllocType;
2600 dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.
get()))
2601 FullInit = Binder->getSubExpr();
2608 if (ArraySize && !*ArraySize) {
2616 Diag(TypeRange.
getEnd(), diag::err_new_array_size_unknown_from_init)
2628 if (OperatorDelete) {
2635 IAP, UsualArrayDeleteWantsSize, PlacementArgs,
2637 ResultType, AllocTypeInfo, Range, DirectInitRange);
2645 return Diag(Loc, diag::err_bad_new_type)
2646 << AllocType << 0 << R;
2648 return Diag(Loc, diag::err_bad_new_type)
2649 << AllocType << 1 << R;
2652 Loc, AllocType, diag::err_new_incomplete_or_sizeless_type, R))
2655 diag::err_allocation_of_abstract_type))
2658 return Diag(Loc, diag::err_variably_modified_new_type)
2662 return Diag(Loc, diag::err_address_space_qualified_new)
2670 return Diag(Loc, diag::err_arc_new_array_without_ownership)
2684 unsigned NonTypeArgumentOffset = 0;
2686 ++NonTypeArgumentOffset;
2692 Alloc != AllocEnd; ++Alloc) {
2734 AlignArg = Args[NonTypeArgumentOffset + 1];
2735 Args.erase(Args.begin() + NonTypeArgumentOffset + 1);
2737 PassAlignment, Operator,
2754 PassAlignment, Operator,
2769 (Args[1]->getType()->isObjectPointerType() ||
2770 Args[1]->getType()->isArrayType())) {
2771 const QualType Arg1Type = Args[1]->getType();
2776 S.
Diag(Args[1]->getExprLoc(),
2777 diag::err_placement_new_into_const_qualified_storage)
2778 << Arg1Type << Args[1]->getSourceRange();
2781 S.
Diag(R.
getNameLoc(), diag::err_need_header_before_placement_new)
2796 if (AlignedCandidates) {
2798 auto AlignArgOffset = NonTypeArgumentOffset + 1;
2799 return C.Function->getNumParams() > AlignArgOffset &&
2800 C.Function->getParamDecl(AlignArgOffset)
2806 AlignedArgs.reserve(Args.size() + NonTypeArgumentOffset + 1);
2807 for (
unsigned Idx = 0; Idx < NonTypeArgumentOffset + 1; ++Idx)
2808 AlignedArgs.push_back(Args[Idx]);
2809 AlignedArgs.push_back(AlignArg);
2810 AlignedArgs.append(Args.begin() + NonTypeArgumentOffset + 1,
2824 if (AlignedCandidates)
2825 AlignedCandidates->
NoteCandidates(S, AlignedArgs, AlignedCands,
"",
2835 S.
PDiag(diag::err_ovl_ambiguous_call)
2844 Candidates, Best->Function, Args);
2848 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
2862 while (Filter.hasNext()) {
2863 FunctionDecl *FD = Filter.next()->getUnderlyingDecl()->getAsFunction();
2883 UntypedParameters.reserve(Args.size() - 1);
2884 UntypedParameters.push_back(Args[1]);
2889 UntypedParameters.push_back(Args[2]);
2890 UntypedParameters.append(Args.begin() + 3, Args.end());
2896 AlignedCandidates, AlignArg,
Diagnose))
2906 Args = std::move(UntypedParameters);
2911 AlignedCandidates, AlignArg,
Diagnose);
2942 IsArray ? OO_Array_New : OO_New);
2957 if (!SpecializedTypeIdentity.
isNull()) {
2958 TypeIdentity = SpecializedTypeIdentity;
2960 diag::err_incomplete_type))
2969 AllocArgs.push_back(&TypeIdentityParam);
2972 unsigned SizeTyWidth =
Context.getTypeSize(SizeTy);
2975 AllocArgs.push_back(&Size);
2980 if (IncludeAlignParam) {
2985 if (IncludeAlignParam)
2986 AllocArgs.push_back(&Align);
2988 llvm::append_range(AllocArgs, PlaceArgs);
3019 if (PlaceArgs.empty()) {
3020 Diag(StartLoc, diag::err_openclcxx_not_supported) <<
"default new";
3022 Diag(StartLoc, diag::err_openclcxx_placement_new);
3027 assert(!R.
empty() &&
"implicitly declared allocation functions not found");
3028 assert(!R.
isAmbiguous() &&
"global allocation functions are ambiguous");
3041 OperatorDelete =
nullptr;
3048 OperatorNew->getDeclName().getCXXOverloadedOperator() == OO_Array_New
3076 while (Filter.hasNext()) {
3077 auto *FD = dyn_cast<FunctionDecl>(Filter.next()->getUnderlyingDecl());
3078 if (FD && FD->isDestroyingOperatorDelete())
3084 auto GetRedeclContext = [](
Decl *D) {
3085 return D->getDeclContext()->getRedeclContext();
3088 DeclContext *OperatorNewContext = GetRedeclContext(OperatorNew);
3090 bool FoundGlobalDelete = FoundDelete.
empty();
3091 bool IsClassScopedTypeAwareNew =
3094 auto DiagnoseMissingTypeAwareCleanupOperator = [&](
bool IsPlacementOperator) {
3097 Diag(StartLoc, diag::err_mismatching_type_aware_cleanup_deallocator)
3098 << OperatorNew->getDeclName() << IsPlacementOperator << DeleteName;
3099 Diag(OperatorNew->getLocation(), diag::note_type_aware_operator_declared)
3100 << OperatorNew->isTypeAwareOperatorNewOrDelete()
3101 << OperatorNew->getDeclName() << OperatorNewContext;
3104 if (IsClassScopedTypeAwareNew && FoundDelete.
empty()) {
3105 DiagnoseMissingTypeAwareCleanupOperator(
false);
3108 if (FoundDelete.
empty()) {
3140 unsigned NonPlacementNewArgCount = 1;
3142 NonPlacementNewArgCount =
3144 bool isPlacementNew = !PlaceArgs.empty() ||
3145 OperatorNew->param_size() != NonPlacementNewArgCount ||
3146 OperatorNew->isVariadic();
3148 if (isPlacementNew) {
3164 int InitialParamOffset = 0;
3166 ArgTypes.push_back(TypeIdentity);
3167 InitialParamOffset = 1;
3169 ArgTypes.push_back(
Context.VoidPtrTy);
3170 for (
unsigned I = ArgTypes.size() - InitialParamOffset,
3171 N = Proto->getNumParams();
3173 ArgTypes.push_back(Proto->getParamType(I));
3177 EPI.
Variadic = Proto->isVariadic();
3179 ExpectedFunctionType
3184 DEnd = FoundDelete.
end();
3188 dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
3199 ExpectedFunctionType,
3201 ExpectedFunctionType))
3202 Matches.push_back(std::make_pair(D.getPair(), Fn));
3209 DiagnoseMissingTypeAwareCleanupOperator(isPlacementNew);
3222 AllocElemType, OriginalTypeAwareState,
3227 *
this, FoundDelete, IDP, StartLoc, &BestDeallocFns);
3228 if (Selected && BestDeallocFns.empty())
3229 Matches.push_back(std::make_pair(Selected.Found, Selected.FD));
3233 for (
auto Fn : BestDeallocFns)
3234 Matches.push_back(std::make_pair(Fn.Found, Fn.FD));
3242 if (Matches.size() == 1) {
3243 OperatorDelete = Matches[0].second;
3244 DeclContext *OperatorDeleteContext = GetRedeclContext(OperatorDelete);
3245 bool FoundTypeAwareOperator =
3246 OperatorDelete->isTypeAwareOperatorNewOrDelete() ||
3247 OperatorNew->isTypeAwareOperatorNewOrDelete();
3248 if (
Diagnose && FoundTypeAwareOperator) {
3249 bool MismatchedTypeAwareness =
3250 OperatorDelete->isTypeAwareOperatorNewOrDelete() !=
3251 OperatorNew->isTypeAwareOperatorNewOrDelete();
3252 bool MismatchedContext = OperatorDeleteContext != OperatorNewContext;
3253 if (MismatchedTypeAwareness || MismatchedContext) {
3254 FunctionDecl *Operators[] = {OperatorDelete, OperatorNew};
3255 bool TypeAwareOperatorIndex =
3257 Diag(StartLoc, diag::err_mismatching_type_aware_cleanup_deallocator)
3258 << Operators[TypeAwareOperatorIndex]->
getDeclName()
3260 << Operators[!TypeAwareOperatorIndex]->
getDeclName()
3261 << GetRedeclContext(Operators[TypeAwareOperatorIndex]);
3262 Diag(OperatorNew->getLocation(),
3263 diag::note_type_aware_operator_declared)
3264 << OperatorNew->isTypeAwareOperatorNewOrDelete()
3265 << OperatorNew->getDeclName() << OperatorNewContext;
3266 Diag(OperatorDelete->getLocation(),
3267 diag::note_type_aware_operator_declared)
3268 << OperatorDelete->isTypeAwareOperatorNewOrDelete()
3269 << OperatorDelete->getDeclName() << OperatorDeleteContext;
3281 UsualDeallocFnInfo Info(*
this,
3283 AllocElemType, StartLoc);
3289 if (IsSizedDelete && !FoundGlobalDelete) {
3294 *
this, FoundDelete, SizeTestingIDP, StartLoc);
3295 if (NonSizedDelete &&
3298 IsSizedDelete =
false;
3305 PlaceArgs.back()->getEndLoc());
3306 Diag(StartLoc, diag::err_placement_new_non_placement_delete) << R;
3307 if (!OperatorDelete->isImplicit())
3308 Diag(OperatorDelete->getLocation(), diag::note_previous_decl)
3317 }
else if (!Matches.empty()) {
3321 Diag(StartLoc, diag::warn_ambiguous_suitable_delete_function_found)
3322 << DeleteName << AllocElemType;
3324 for (
auto &
Match : Matches)
3326 diag::note_member_declared_here) << DeleteName;
3385 &
PP.getIdentifierTable().get(
"bad_alloc"),
nullptr);
3390 if (TheGlobalModuleFragment) {
3401 &
PP.getIdentifierTable().get(
"align_val_t"),
nullptr,
true,
true,
true);
3405 if (TheGlobalModuleFragment) {
3406 AlignValT->setModuleOwnershipKind(
3408 AlignValT->setLocalOwningModule(TheGlobalModuleFragment);
3411 AlignValT->setIntegerType(
Context.getSizeType());
3412 AlignValT->setPromotionType(
Context.getSizeType());
3413 AlignValT->setImplicit(
true);
3426 Params.push_back(Param);
3429 bool HasSizedVariant =
getLangOpts().SizedDeallocation &&
3430 (Kind == OO_Delete || Kind == OO_Array_Delete);
3431 bool HasAlignedVariant =
getLangOpts().AlignedAllocation;
3433 int NumSizeVariants = (HasSizedVariant ? 2 : 1);
3434 int NumAlignVariants = (HasAlignedVariant ? 2 : 1);
3435 for (
int Sized = 0; Sized < NumSizeVariants; ++Sized) {
3437 Params.push_back(
SizeT);
3439 for (
int Aligned = 0; Aligned < NumAlignVariants; ++Aligned) {
3444 Context.DeclarationNames.getCXXOperatorName(Kind), Return, Params);
3452 DeclareGlobalAllocationFunctions(OO_New, VoidPtr,
SizeT);
3453 DeclareGlobalAllocationFunctions(OO_Array_New, VoidPtr,
SizeT);
3454 DeclareGlobalAllocationFunctions(OO_Delete,
Context.VoidTy, VoidPtr);
3455 DeclareGlobalAllocationFunctions(OO_Array_Delete,
Context.VoidTy, VoidPtr);
3458 PopGlobalModuleFragment();
3471 Alloc != AllocEnd; ++Alloc) {
3475 if (
Func->getNumParams() == Params.size()) {
3476 if (std::equal(
Func->param_begin(),
Func->param_end(), Params.begin(),
3478 return Context.hasSameUnqualifiedType(D->getType(),
3484 Func->setVisibleDespiteOwningModule();
3492 Context.getTargetInfo().getDefaultCallingConv());
3496 if (HasBadAllocExceptionSpec) {
3499 assert(
StdBadAlloc &&
"Must have std::bad_alloc declared");
3511 auto CreateAllocationFunctionDecl = [&](
Attr *ExtraAttr) {
3519 Context.getTargetInfo().getTriple().isSPIRV()) {
3520 if (
auto *ATI =
Context.getAuxTargetInfo())
3530 Alloc->setImplicit();
3532 Alloc->setVisibleDespiteOwningModule();
3534 if (HasBadAllocExceptionSpec &&
getLangOpts().NewInfallible &&
3537 ReturnsNonNullAttr::CreateImplicit(
Context, Alloc->getLocation()));
3549 if (TheGlobalModuleFragment) {
3550 Alloc->setModuleOwnershipKind(
3552 Alloc->setLocalOwningModule(TheGlobalModuleFragment);
3555 if (
LangOpts.hasGlobalAllocationFunctionVisibility())
3556 Alloc->addAttr(VisibilityAttr::CreateImplicit(
3558 ? VisibilityAttr::Hidden
3559 :
LangOpts.hasProtectedGlobalAllocationFunctionVisibility()
3560 ? VisibilityAttr::Protected
3561 : VisibilityAttr::Default));
3568 ParamDecls.back()->setImplicit();
3570 Alloc->setParams(ParamDecls);
3572 Alloc->addAttr(ExtraAttr);
3574 Context.getTranslationUnitDecl()->addDecl(Alloc);
3579 CreateAllocationFunctionDecl(
nullptr);
3583 CreateAllocationFunctionDecl(CUDAHostAttr::CreateImplicit(
Context));
3584 CreateAllocationFunctionDecl(CUDADeviceAttr::CreateImplicit(
Context));
3611 assert(
Result.FD &&
"operator delete missing from global scope?");
3618 bool LookForGlobal) {
3627 if (!LookForGlobal) {
3632 return OperatorDelete;
3652 if (
Found.isAmbiguous())
3655 Found.suppressDiagnostics();
3668 if (Matches.size() == 1) {
3671 Found.getNamingClass(), Matches[0].Found,
3678 if (!Matches.empty()) {
3680 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
3682 for (
auto &
Match : Matches)
3683 Diag(
Match.FD->getLocation(), diag::note_member_declared_here) << Name;
3690 if (!
Found.empty()) {
3692 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
3696 Diag(D->getUnderlyingDecl()->getLocation(),
3697 diag::note_member_declared_here) << Name;
3709class MismatchingNewDeleteDetector {
3711 enum MismatchResult {
3717 MemberInitMismatches,
3726 explicit MismatchingNewDeleteDetector(
bool EndOfTU)
3727 : Field(
nullptr), IsArrayForm(
false), EndOfTU(EndOfTU),
3728 HasUndefinedConstructors(
false) {}
3740 MismatchResult analyzeDeleteExpr(
const CXXDeleteExpr *DE);
3745 MismatchResult analyzeField(FieldDecl *Field,
bool DeleteWasArrayForm);
3748 llvm::SmallVector<const CXXNewExpr *, 4> NewExprs;
3755 bool HasUndefinedConstructors;
3759 const CXXNewExpr *getNewExprFromInitListOrExpr(
const Expr *E);
3767 MismatchResult analyzeMemberExpr(
const MemberExpr *ME);
3775 bool hasMatchingVarInit(
const DeclRefExpr *D);
3784 bool hasMatchingNewInCtor(
const CXXConstructorDecl *CD);
3787 bool hasMatchingNewInCtorInit(
const CXXCtorInitializer *CI);
3790 MismatchResult analyzeInClassInitializer();
3794MismatchingNewDeleteDetector::MismatchResult
3795MismatchingNewDeleteDetector::analyzeDeleteExpr(
const CXXDeleteExpr *DE) {
3797 assert(DE &&
"Expected delete-expression");
3800 if (
const MemberExpr *ME = dyn_cast<const MemberExpr>(E)) {
3801 return analyzeMemberExpr(ME);
3802 }
else if (
const DeclRefExpr *D = dyn_cast<const DeclRefExpr>(E)) {
3803 if (!hasMatchingVarInit(D))
3804 return VarInitMismatches;
3810MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(
const Expr *E) {
3811 assert(E !=
nullptr &&
"Expected a valid initializer expression");
3813 if (
const InitListExpr *ILE = dyn_cast<const InitListExpr>(E)) {
3814 if (ILE->getNumInits() == 1)
3815 E = dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts());
3818 return dyn_cast_or_null<const CXXNewExpr>(E);
3821bool MismatchingNewDeleteDetector::hasMatchingNewInCtorInit(
3822 const CXXCtorInitializer *CI) {
3823 const CXXNewExpr *
NE =
nullptr;
3825 (NE = getNewExprFromInitListOrExpr(CI->
getInit()))) {
3826 if (
NE->isArray() == IsArrayForm)
3829 NewExprs.push_back(NE);
3834bool MismatchingNewDeleteDetector::hasMatchingNewInCtor(
3835 const CXXConstructorDecl *CD) {
3840 HasUndefinedConstructors =
true;
3844 if (hasMatchingNewInCtorInit(CI))
3850MismatchingNewDeleteDetector::MismatchResult
3851MismatchingNewDeleteDetector::analyzeInClassInitializer() {
3852 assert(Field !=
nullptr &&
"This should be called only for members");
3853 const Expr *InitExpr =
Field->getInClassInitializer();
3855 return EndOfTU ? NoMismatch : AnalyzeLater;
3856 if (
const CXXNewExpr *NE = getNewExprFromInitListOrExpr(InitExpr)) {
3857 if (
NE->isArray() != IsArrayForm) {
3858 NewExprs.push_back(NE);
3859 return MemberInitMismatches;
3865MismatchingNewDeleteDetector::MismatchResult
3866MismatchingNewDeleteDetector::analyzeField(FieldDecl *Field,
3867 bool DeleteWasArrayForm) {
3868 assert(Field !=
nullptr &&
"Analysis requires a valid class member.");
3870 IsArrayForm = DeleteWasArrayForm;
3872 for (
const auto *CD : RD->
ctors()) {
3873 if (hasMatchingNewInCtor(CD))
3876 if (HasUndefinedConstructors)
3877 return EndOfTU ? NoMismatch : AnalyzeLater;
3878 if (!NewExprs.empty())
3879 return MemberInitMismatches;
3880 return Field->hasInClassInitializer() ? analyzeInClassInitializer()
3884MismatchingNewDeleteDetector::MismatchResult
3885MismatchingNewDeleteDetector::analyzeMemberExpr(
const MemberExpr *ME) {
3886 assert(ME !=
nullptr &&
"Expected a member expression");
3887 if (FieldDecl *F = dyn_cast<FieldDecl>(ME->
getMemberDecl()))
3888 return analyzeField(F, IsArrayForm);
3892bool MismatchingNewDeleteDetector::hasMatchingVarInit(
const DeclRefExpr *D) {
3893 const CXXNewExpr *
NE =
nullptr;
3894 if (
const VarDecl *VD = dyn_cast<const VarDecl>(D->
getDecl())) {
3895 if (VD->hasInit() && (NE = getNewExprFromInitListOrExpr(VD->getInit())) &&
3896 NE->isArray() != IsArrayForm) {
3897 NewExprs.push_back(NE);
3900 return NewExprs.empty();
3905 const MismatchingNewDeleteDetector &Detector) {
3908 if (!Detector.IsArrayForm)
3917 SemaRef.
Diag(DeleteLoc, diag::warn_mismatched_delete_new)
3918 << Detector.IsArrayForm << H;
3920 for (
const auto *NE : Detector.NewExprs)
3921 SemaRef.
Diag(NE->getExprLoc(), diag::note_allocated_here)
3922 << Detector.IsArrayForm;
3925void Sema::AnalyzeDeleteExprMismatch(
const CXXDeleteExpr *DE) {
3926 if (
Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation()))
3928 MismatchingNewDeleteDetector Detector(
false);
3929 switch (Detector.analyzeDeleteExpr(DE)) {
3930 case MismatchingNewDeleteDetector::VarInitMismatches:
3931 case MismatchingNewDeleteDetector::MemberInitMismatches: {
3935 case MismatchingNewDeleteDetector::AnalyzeLater: {
3940 case MismatchingNewDeleteDetector::NoMismatch:
3945void Sema::AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,
3946 bool DeleteWasArrayForm) {
3947 MismatchingNewDeleteDetector Detector(
true);
3948 switch (Detector.analyzeField(Field, DeleteWasArrayForm)) {
3949 case MismatchingNewDeleteDetector::VarInitMismatches:
3950 llvm_unreachable(
"This analysis should have been done for class members.");
3951 case MismatchingNewDeleteDetector::AnalyzeLater:
3952 llvm_unreachable(
"Analysis cannot be postponed any point beyond end of "
3953 "translation unit.");
3954 case MismatchingNewDeleteDetector::MemberInitMismatches:
3957 case MismatchingNewDeleteDetector::NoMismatch:
3964 bool ArrayForm,
Expr *ExE) {
3974 bool ArrayFormAsWritten = ArrayForm;
3975 bool UsualArrayDeleteWantsSize =
false;
3993 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
4000 return S.
Diag(Loc, diag::err_delete_operand) <<
T;
4005 return S.
Diag(Loc, diag::err_delete_incomplete_class_type) <<
T;
4011 return S.
Diag(Loc, diag::err_delete_explicit_conversion) <<
T << ConvTy;
4022 return S.
Diag(Loc, diag::err_ambiguous_delete_operand) <<
T;
4034 llvm_unreachable(
"conversion functions are permitted");
4042 if (!Converter.match(
Type))
4053 diag::err_address_space_qualified_delete)
4063 Diag(StartLoc,
LangOpts.CPlusPlus26 ? diag::err_delete_incomplete
4064 : diag::ext_delete_void_ptr_operand)
4077 ? diag::err_delete_incomplete
4078 : diag::warn_delete_incomplete,
4085 Diag(StartLoc, diag::warn_delete_array_type)
4092 ArrayForm ? OO_Array_Delete : OO_Delete);
4100 OperatorDelete, IDP))
4114 else if (isa_and_nonnull<CXXMethodDecl>(OperatorDelete)) {
4115 UsualDeallocFnInfo UDFI(
4124 if (Dtor->isCalledByDelete(OperatorDelete)) {
4138 if (!OperatorDelete) {
4140 Diag(StartLoc, diag::err_openclcxx_not_supported) <<
"default delete";
4145 bool CanProvideSize =
4146 IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||
4156 if (!OperatorDelete)
4160 if (OperatorDelete->isInvalidDecl())
4167 bool IsVirtualDelete =
false;
4170 if (Dtor->isCalledByDelete(OperatorDelete))
4172 PDiag(diag::err_access_dtor) << PointeeElem);
4173 IsVirtualDelete = Dtor->isVirtual();
4179 unsigned AddressParamIdx = 0;
4180 if (OperatorDelete->isTypeAwareOperatorNewOrDelete()) {
4181 QualType TypeIdentity = OperatorDelete->getParamDecl(0)->getType();
4183 diag::err_incomplete_type))
4185 AddressParamIdx = 1;
4193 OperatorDelete->getParamDecl(AddressParamIdx)->getType();
4212 Context.VoidTy, UseGlobal, ArrayForm, ArrayFormAsWritten,
4213 UsualArrayDeleteWantsSize, OperatorDelete, Ex.
get(), StartLoc);
4214 AnalyzeDeleteExprMismatch(
Result);
4223 IsDelete ? OO_Delete : OO_New);
4227 assert(!R.
empty() &&
"implicitly declared allocation functions not found");
4228 assert(!R.
isAmbiguous() &&
"global allocation functions are ambiguous");
4237 FnOvl != FnOvlEnd; ++FnOvl) {
4240 NamedDecl *D = (*FnOvl)->getUnderlyingDecl();
4264 "class members should not be considered");
4267 S.
Diag(R.
getNameLoc(), diag::err_builtin_operator_new_delete_not_usual)
4268 << (IsDelete ? 1 : 0) << Range;
4269 S.
Diag(FnDecl->
getLocation(), diag::note_non_usual_function_declared_here)
4281 S.
PDiag(diag::err_ovl_no_viable_function_in_call)
4289 S.
PDiag(diag::err_ovl_ambiguous_call)
4296 Candidates, Best->Function, Args);
4299 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
4307 << (IsDelete ?
"__builtin_operator_delete" :
"__builtin_operator_new")
4315 FunctionDecl *OperatorNewOrDelete =
nullptr;
4317 OperatorNewOrDelete))
4319 assert(OperatorNewOrDelete &&
"should be found");
4325 for (
unsigned i = 0; i != TheCall->
getNumArgs(); ++i) {
4327 InitializedEntity Entity =
4336 assert(Callee &&
Callee->getCastKind() == CK_BuiltinFnToFnPtr &&
4337 "Callee expected to be implicit cast to a builtin function pointer");
4340 return TheCallResult;
4344 bool IsDelete,
bool CallCanBeVirtual,
4345 bool WarnOnNonAbstractTypes,
4372 Diag(Loc, diag::warn_delete_abstract_non_virtual_dtor) << (IsDelete ? 0 : 1)
4374 }
else if (WarnOnNonAbstractTypes) {
4377 Diag(Loc, diag::warn_delete_non_virtual_dtor) << (IsDelete ? 0 : 1)
4381 std::string TypeStr;
4383 Diag(DtorLoc, diag::note_delete_non_virtual)
4410 if (
T->isFunctionType())
4412 diag::err_invalid_use_of_function_type)
4414 else if (
T->isArrayType())
4416 diag::err_invalid_use_of_array_type)
4434 llvm_unreachable(
"unexpected condition kind");
4466 diag::err_constexpr_if_condition_expression_is_not_constant);
4474 From = Cast->getSubExpr();
4486 if (!ToPtrType->getPointeeType().hasQualifiers()) {
4487 switch (StrLit->getKind()) {
4495 return (ToPointeeType->getKind() == BuiltinType::Char_U ||
4496 ToPointeeType->getKind() == BuiltinType::Char_S);
4501 assert(
false &&
"Unevaluated string literal in expression");
4516 bool HadMultipleCandidates,
4519 default: llvm_unreachable(
"Unhandled cast kind!");
4520 case CK_ConstructorConversion: {
4525 diag::err_allocation_of_abstract_type))
4539 ConstructorArgs, HadMultipleCandidates,
4540 false,
false,
false,
4542 if (Result.isInvalid())
4548 case CK_UserDefinedConversion: {
4558 HadMultipleCandidates);
4559 if (Result.isInvalid())
4563 CK_UserDefinedConversion, Result.get(),
4564 nullptr, Result.get()->getValueKind(),
4597 assert(FD &&
"no conversion function for user-defined conversion seq");
4599 CastKind = CK_UserDefinedConversion;
4604 BeforeToType =
Context.getCanonicalTagType(Conv->getParent());
4607 CastKind = CK_ConstructorConversion;
4634 From = CastArg.
get();
4648 PDiag(diag::err_typecheck_ambiguous_condition)
4654 llvm_unreachable(
"bad conversion");
4664 assert(Diagnosed &&
"failed to diagnose bad conversion"); (void)Diagnosed;
4678 ElType = ToVec->getElementType();
4685 return Context.getExtVectorType(ElType, FromVec->getNumElements());
4715 false,
false,
false,
4722 false,
false,
false,
4755 ToAtomicType = ToType;
4756 ToType = ToAtomic->getValueType();
4759 QualType InitialFromType = FromType;
4761 switch (SCS.
First) {
4764 FromType = FromAtomic->getValueType().getUnqualifiedType();
4777 From = FromRes.
get();
4783 FromType =
Context.getArrayDecayedType(FromType);
4791 FromType =
Context.getArrayParameterType(FromType);
4802 FromType =
Context.getPointerType(FromType);
4809 llvm_unreachable(
"Improper first standard conversion");
4850 "only enums with fixed underlying type can promote to bool");
4880 CK = CK_FloatingComplexCast;
4882 CK = CK_FloatingComplexToIntegralComplex;
4884 CK = CK_IntegralComplexToFloatingComplex;
4886 CK = CK_IntegralComplexCast;
4912 "Attempting implicit fixed point conversion without a fixed "
4917 nullptr, CCK).
get();
4921 nullptr, CCK).
get();
4925 nullptr, CCK).
get();
4929 nullptr, CCK).
get();
4933 nullptr, CCK).
get();
4937 nullptr, CCK).
get();
4942 nullptr, CCK).
get();
4952 diag::ext_typecheck_convert_incompatible_pointer)
4957 diag::ext_typecheck_convert_incompatible_pointer)
4964 }
else if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
4965 !
ObjC().CheckObjCARCUnavailableWeakConversion(ToType,
4970 Diag(From->
getBeginLoc(), diag::err_arc_convesion_of_weak_unavailable)
4981 NewToType =
Context.removeAddrSpaceQualType(ToPteeType);
4982 NewToType =
Context.getAddrSpaceQualType(NewToType,
4985 NewToType =
Context.getObjCObjectPointerType(NewToType);
4987 NewToType =
Context.getBlockPointerType(NewToType);
4989 NewToType =
Context.getPointerType(NewToType);
4999 if (Kind == CK_BlockPointerToObjCPointerCast) {
5004 if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers())
5019 assert((Kind != CK_NullToMemberPointer ||
5022 "Expr must be null pointer constant!");
5027 llvm_unreachable(
"unexpected result");
5029 llvm_unreachable(
"Should not have been called if derivation isn't OK.");
5072 &BasePath, CCK).
get();
5101 QualType ElType = ToComplex->getElementType();
5109 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).
get();
5113 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).
get();
5117 isFloatingComplex ? CK_FloatingRealToComplex
5118 : CK_IntegralRealToComplex).
get();
5123 QualType ElType = FromComplex->getElementType();
5128 isFloatingComplex ? CK_FloatingComplexToReal
5129 : CK_IntegralComplexToReal,
5134 if (
Context.hasSameUnqualifiedType(ElType, ToType)) {
5138 isFloatingComplex ? CK_FloatingCast
5139 : CK_IntegralToFloating,
5145 isFloatingComplex ? CK_FloatingToIntegral
5162 AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
5175 From = FromRes.
get();
5177 "Improper transparent union conversion");
5185 CK_ZeroToOCLOpaqueType,
5200 llvm_unreachable(
"Improper second standard conversion");
5209 "Dimension conversion for matrix types is not implemented yet.");
5211 "Dimension conversion output must be vector or scalar type.");
5228 QualType TruncTy = FromVec->getElementType();
5230 TruncTy =
Context.getExtVectorType(TruncTy, ToVec->getNumElements());
5239 llvm_unreachable(
"Improper element standard conversion");
5243 switch (SCS.
Third) {
5266 CK = CK_AddressSpaceConversion;
5271 CK = CK_AddressSpaceConversion;
5277 << InitialFromType << ToType;
5288 ? diag::ext_deprecated_string_literal_conversion
5289 : diag::warn_deprecated_string_literal_conversion)
5297 llvm_unreachable(
"Improper third standard conversion");
5302 if (!ToAtomicType.
isNull()) {
5334 "placeholders should have been weeded out by now");
5349 const char *OpSpelling = isIndirect ?
"->*" :
".*";
5357 Diag(Loc, diag::err_bad_memptr_rhs)
5379 Diag(Loc, diag::err_bad_memptr_lhs)
5380 << OpSpelling << 1 << LHSType
5390 OpSpelling, (
int)isIndirect)) {
5395 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
5404 LHSType, RHSClassType, Loc,
5413 UseType =
Context.getPointerType(UseType);
5422 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
5441 switch (Proto->getRefQualifier()) {
5450 if (Proto->isConst() && !Proto->isVolatile())
5452 ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue
5453 : diag::ext_pointer_to_const_ref_member_on_rvalue);
5455 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5462 Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
5475 if (
Result->isFunctionType()) {
5478 }
else if (isIndirect) {
5496 bool &HaveConversion,
5498 HaveConversion =
false;
5521 HaveConversion =
true;
5536 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
5537 Self.IsDerivedFrom(QuestionLoc, FTy, TTy);
5538 if (FRec && TRec && (FRec == TRec || FDerivedFromT ||
5539 Self.IsDerivedFrom(QuestionLoc, TTy, FTy))) {
5543 if (FRec == TRec || FDerivedFromT) {
5548 HaveConversion =
true;
5571 HaveConversion = !InitSeq.
Failed();
5589 Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args,
5597 LHS.
get(), Best->BuiltinParamTypes[0], Best->Conversions[0],
5604 RHS.
get(), Best->BuiltinParamTypes[1], Best->Conversions[1],
5610 Self.MarkFunctionReferenced(QuestionLoc, Best->Function);
5619 if (
Self.DiagnoseConditionalForNull(LHS.
get(), RHS.
get(), QuestionLoc))
5622 Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
5628 Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
5636 llvm_unreachable(
"Conditional operator has only built-in overloads");
5650 if (Result.isInvalid())
5665 assert(!EltTy->
isEnumeralType() &&
"Vectors cant be enum types");
5675 assert(!EltTy->
isEnumeralType() &&
"Vectors cant be enum types");
5687 QualType CondElementTy = CondVT->getElementType();
5688 unsigned CondElementCount = CondVT->getNumElements();
5697 if (LHSVT && RHSVT) {
5699 Diag(QuestionLoc, diag::err_conditional_vector_cond_result_mismatch)
5705 if (!
Context.hasSameType(LHSType, RHSType)) {
5706 Diag(QuestionLoc, diag::err_conditional_vector_mismatched)
5707 << LHSType << RHSType;
5710 ResultType =
Context.getCommonSugaredType(LHSType, RHSType);
5711 }
else if (LHSVT || RHSVT) {
5713 LHS, RHS, QuestionLoc,
false,
true,
5717 if (ResultType.isNull())
5724 Context.hasSameType(LHSType, RHSType)
5725 ?
Context.getCommonSugaredType(LHSType, RHSType)
5730 Diag(QuestionLoc, diag::err_conditional_vector_operand_type)
5736 Context.getExtVectorType(ResultElementTy, CondVT->getNumElements());
5738 ResultType =
Context.getVectorType(
5745 assert(!ResultType.isNull() && ResultType->isVectorType() &&
5747 "Result should have been a vector type");
5748 auto *ResultVectorTy = ResultType->castAs<
VectorType>();
5749 QualType ResultElementTy = ResultVectorTy->getElementType();
5750 unsigned ResultElementCount = ResultVectorTy->getNumElements();
5752 if (ResultElementCount != CondElementCount) {
5753 Diag(QuestionLoc, diag::err_conditional_vector_size) << CondType
5759 if (
Context.getTypeSize(ResultElementTy) !=
5760 Context.getTypeSize(CondElementTy) &&
5761 (!CondElementTy->isBooleanType() ||
LangOpts.OpenCL)) {
5762 Diag(QuestionLoc, diag::err_conditional_vector_element_size)
5763 << CondType << ResultType;
5780 llvm::ElementCount CondElementCount =
5781 Context.getBuiltinVectorTypeInfo(CondBT).EC;
5792 if (LHSBT && RHSBT) {
5794 if (!
Context.hasSameType(LHSType, RHSType)) {
5795 Diag(QuestionLoc, diag::err_conditional_vector_mismatched)
5796 << LHSType << RHSType;
5799 ResultType = LHSType;
5800 }
else if (LHSBT || RHSBT) {
5812 if (
Context.hasSameType(LHSType, RHSType))
5813 ResultElementTy = LHSType;
5819 Diag(QuestionLoc, diag::err_conditional_vector_operand_type)
5824 ResultType =
Context.getScalableVectorType(
5825 ResultElementTy, CondElementCount.getKnownMinValue());
5832 "Result should have been a vector type");
5835 llvm::ElementCount ResultElementCount =
5836 Context.getBuiltinVectorTypeInfo(ResultBuiltinTy).EC;
5838 if (ResultElementCount != CondElementCount) {
5839 Diag(QuestionLoc, diag::err_conditional_vector_size)
5840 << CondType << ResultType;
5844 if (
Context.getTypeSize(ResultElementTy) !=
5845 Context.getTypeSize(CondElementTy)) {
5846 Diag(QuestionLoc, diag::err_conditional_vector_element_size)
5847 << CondType << ResultType;
5864 bool IsVectorConditional =
5867 bool IsSizelessVectorConditional =
5869 Cond.get()->getType());
5873 if (!
Cond.get()->isTypeDependent()) {
5874 ExprResult CondRes = IsVectorConditional || IsSizelessVectorConditional
5900 if (LVoid || RVoid) {
5909 if (IsVectorConditional) {
5912 bool IsThrow = LVoid ? LThrow : RThrow;
5913 Diag(DiagLoc.
getBegin(), diag::err_conditional_vector_has_void)
5914 << DiagLoc << IsThrow;
5918 if (LThrow != RThrow) {
5919 Expr *NonThrow = LThrow ? RHS.
get() : LHS.
get();
5930 return Context.getCommonSugaredType(LTy, RTy);
5933 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
5934 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
5940 if (IsVectorConditional)
5943 if (IsSizelessVectorConditional)
5948 Diag(QuestionLoc, diag::err_wasm_table_conditional_expression)
5957 if (!
Context.hasSameType(LTy, RTy) &&
5961 bool HaveL2R, HaveR2L;
5968 if (HaveL2R && HaveR2L) {
5969 Diag(QuestionLoc, diag::err_conditional_ambiguous)
5981 }
else if (HaveR2L) {
6005 ReferenceConversions::Qualification |
6006 ReferenceConversions::NestedQualification |
6007 ReferenceConversions::Function;
6012 !(RefConv & ~AllowedConversions) &&
6020 !(RefConv & ~AllowedConversions) &&
6035 bool Same =
Context.hasSameType(LTy, RTy);
6036 if (Same && LVK == RVK && LVK !=
VK_PRValue &&
6043 return Context.getCommonSugaredType(LTy, RTy);
6073 if (
Context.hasSameType(LTy, RTy)) {
6089 return Context.getCommonSugaredType(LTy, RTy);
6110 diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
6148 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
6168 bool T2IsPointerLike = T2->isAnyPointerType() || T2->isMemberPointerType() ||
6169 T2->isNullPtrType();
6170 if (!T1IsPointerLike && !T2IsPointerLike)
6178 if (T1IsPointerLike &&
6182 ? CK_NullToMemberPointer
6183 : CK_NullToPointer).
get();
6186 if (T2IsPointerLike &&
6190 ? CK_NullToMemberPointer
6191 : CK_NullToPointer).
get();
6196 if (!T1IsPointerLike || !T2IsPointerLike)
6199 "nullptr_t should be a null pointer constant");
6202 enum Kind {
Pointer, ObjCPointer, MemberPointer, Array } K;
6208 const Type *ClassOrBound;
6210 Step(Kind K,
const Type *ClassOrBound =
nullptr)
6211 : K(K), ClassOrBound(ClassOrBound) {}
6223 if (
auto *CAT = cast_or_null<ConstantArrayType>(ClassOrBound))
6229 llvm_unreachable(
"unknown step kind");
6251 unsigned NeedConstBefore = 0;
6256 Composite1 =
Context.getUnqualifiedArrayType(Composite1, Q1);
6257 Composite2 =
Context.getUnqualifiedArrayType(Composite2, Q2);
6260 if (!Steps.empty()) {
6270 }
else if (Steps.size() == 1) {
6273 if (MaybeQ1 == MaybeQ2) {
6292 assert(Steps.size() == 1);
6300 assert(Steps.size() == 1);
6309 Steps.back().Quals = Quals;
6310 if (Q1 != Quals || Q2 != Quals)
6311 NeedConstBefore = Steps.size() - 1;
6317 if ((Arr1 =
Context.getAsArrayType(Composite1)) &&
6318 (Arr2 =
Context.getAsArrayType(Composite2))) {
6319 auto *CAT1 = dyn_cast<ConstantArrayType>(Arr1);
6320 auto *CAT2 = dyn_cast<ConstantArrayType>(Arr2);
6321 if (CAT1 && CAT2 && CAT1->getSize() == CAT2->getSize()) {
6324 Steps.emplace_back(Step::Array, CAT1);
6329 if ((IAT1 && IAT2) ||
6331 ((
bool)CAT1 != (
bool)CAT2) &&
6332 (Steps.empty() || Steps.back().K != Step::Array))) {
6338 Steps.emplace_back(Step::Array);
6340 NeedConstBefore = Steps.size();
6350 Steps.emplace_back(Step::Pointer);
6359 Steps.emplace_back(Step::ObjCPointer);
6383 else if (Steps.empty())
6390 Steps.emplace_back(Step::MemberPointer,
6391 Context.getCanonicalTagType(Cls).getTypePtr());
6403 Steps.emplace_back(Step::Pointer);
6441 if (Steps.size() == 1) {
6453 bool CFIUncheckedCallee =
6464 Composite1 =
Context.getFunctionType(FPT1->getReturnType(),
6465 FPT1->getParamTypes(), EPI1);
6466 Composite2 =
Context.getFunctionType(FPT2->getReturnType(),
6467 FPT2->getParamTypes(), EPI2);
6473 if (Steps.size() == 1 && Steps.front().K == Step::Pointer &&
6474 !
Context.hasSameType(Composite1, Composite2)) {
6479 Composite2 = Composite1;
6481 Composite1 = Composite2;
6490 Composite1 = Composite2;
6492 Composite2 = Composite1;
6497 if (!
Context.hasSameType(Composite1, Composite2))
6502 for (
unsigned I = 0; I != NeedConstBefore; ++I)
6503 Steps[I].Quals.addConst();
6506 QualType Composite =
Context.getCommonSugaredType(Composite1, Composite2);
6507 for (
auto &S : llvm::reverse(Steps))
6508 Composite = S.rebuild(
Context, Composite);
6529 E1 = E1Result.
get();
6534 E2 = E2Result.
get();
6555 bool ReturnsRetained;
6560 Expr *Callee =
Call->getCallee()->IgnoreParens();
6566 T = BinOp->getRHS()->getType();
6567 else if (
MemberExpr *Mem = dyn_cast<MemberExpr>(Callee))
6568 T = Mem->getMemberDecl()->getType();
6572 T = Ptr->getPointeeType();
6574 T = Ptr->getPointeeType();
6576 T = MemPtr->getPointeeType();
6579 ReturnsRetained = FTy->getExtInfo().getProducesResult();
6584 ReturnsRetained =
true;
6598 D = Send->getMethodDecl();
6599 }
else if (
ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(E)) {
6600 D = BoxedExpr->getBoxingMethod();
6604 if (ArrayLit->getNumElements() == 0 &&
6605 Context.getLangOpts().ObjCRuntime.hasEmptyCollections())
6608 D = ArrayLit->getArrayWithObjectsMethod();
6610 = dyn_cast<ObjCDictionaryLiteral>(E)) {
6613 if (DictLit->getNumElements() == 0 &&
6614 Context.getLangOpts().ObjCRuntime.hasEmptyCollections())
6617 D = DictLit->getDictWithObjectsMethod();
6620 ReturnsRetained = (D && D->
hasAttr<NSReturnsRetainedAttr>());
6625 if (!ReturnsRetained &&
6634 Cleanup.setExprNeedsCleanups(
true);
6636 CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
6637 : CK_ARCReclaimReturnedObject);
6643 Cleanup.setExprNeedsCleanups(
true);
6651 const RecordType *RT =
nullptr;
6653 switch (
T->getTypeClass()) {
6657 case Type::ConstantArray:
6658 case Type::IncompleteArray:
6659 case Type::VariableArray:
6660 case Type::DependentSizedArray:
6682 PDiag(diag::err_access_dtor_temp)
6692 Cleanup.setExprNeedsCleanups(
true);
6713 assert(SubExpr &&
"subexpression can't be null!");
6719 assert(
Cleanup.exprNeedsCleanups() ||
6721 if (!
Cleanup.exprNeedsCleanups())
6735 assert(SubStmt &&
"sub-statement can't be null!");
6739 if (!
Cleanup.exprNeedsCleanups())
6758 "not in a decltype expression");
6775 if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
6779 if (SubExpr.
get() == PE->getSubExpr())
6784 if (BO->getOpcode() == BO_Comma) {
6788 if (RHS.
get() == BO->getRHS())
6791 BO->
getType(), BO->getValueKind(),
6792 BO->getObjectKind(), BO->getOperatorLoc(),
6793 BO->getFPFeatures());
6820 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeCalls.size();
6823 if (
Call == TopCall)
6833 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeBinds.size();
6837 if (
Bind == TopBind)
6843 Bind->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
6849 PDiag(diag::err_access_dtor_temp)
6850 <<
Bind->getType());
6855 Cleanup.setExprNeedsCleanups(
true);
6865 unsigned SkipStart = OperatorArrows.size(), SkipCount = 0;
6868 if (OperatorArrows.size() > Limit) {
6870 SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2;
6871 SkipCount = OperatorArrows.size() - (Limit - 1);
6874 for (
unsigned I = 0; I < OperatorArrows.size(); ) {
6875 if (I == SkipStart) {
6876 S.
Diag(OperatorArrows[I]->getLocation(),
6877 diag::note_operator_arrows_suppressed)
6881 S.
Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here)
6882 << OperatorArrows[I]->getCallResultType();
6892 bool &MayBePseudoDestructor) {
6903 MayBePseudoDestructor =
false;
6904 if (BaseType->isDependentType()) {
6908 if (OpKind == tok::arrow)
6910 BaseType = Ptr->getPointeeType();
6913 MayBePseudoDestructor =
true;
6920 if (OpKind == tok::arrow) {
6922 bool NoArrowOperatorFound =
false;
6923 bool FirstIteration =
true;
6928 CTypes.insert(
Context.getCanonicalType(BaseType));
6930 while (BaseType->isRecordType()) {
6931 if (OperatorArrows.size() >=
getLangOpts().ArrowDepth) {
6932 Diag(OpLoc, diag::err_operator_arrow_depth_exceeded)
6933 << StartingType <<
getLangOpts().ArrowDepth <<
Base->getSourceRange();
6935 Diag(OpLoc, diag::note_operator_arrow_depth)
6948 : &NoArrowOperatorFound);
6949 if (
Result.isInvalid()) {
6950 if (NoArrowOperatorFound) {
6951 if (FirstIteration) {
6952 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
6953 << BaseType << 1 <<
Base->getSourceRange()
6955 OpKind = tok::period;
6958 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
6959 << BaseType <<
Base->getSourceRange();
6963 diag::note_member_reference_arrow_from_operator_arrow);
6970 OperatorArrows.push_back(OpCall->getDirectCallee());
6971 BaseType =
Base->getType();
6973 if (!CTypes.insert(CBaseType).second) {
6974 Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType;
6978 FirstIteration =
false;
6981 if (OpKind == tok::arrow) {
6982 if (BaseType->isPointerType())
6983 BaseType = BaseType->getPointeeType();
6984 else if (
auto *AT =
Context.getAsArrayType(BaseType))
6985 BaseType = AT->getElementType();
6991 if (BaseType->isObjCObjectPointerType())
6992 BaseType = BaseType->getPointeeType();
7005 if (!BaseType->isRecordType()) {
7007 MayBePseudoDestructor =
true;
7016 if (!BaseType->isDependentType() &&
7019 diag::err_incomplete_member_access)) {
7034 if (
Base->hasPlaceholderType()) {
7039 ObjectType =
Base->getType();
7047 if (OpKind == tok::arrow) {
7057 ObjectType =
Base->getType();
7062 }
else if (!
Base->isTypeDependent()) {
7064 S.
Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
7065 << ObjectType <<
true
7070 OpKind = tok::period;
7112 Diag(OpLoc, diag::ext_pseudo_dtor_on_void) <<
Base->getSourceRange();
7114 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
7115 << ObjectType <<
Base->getSourceRange();
7123 if (DestructedTypeInfo) {
7128 if (!
Context.hasSameUnqualifiedType(DestructedType, ObjectType)) {
7133 Context.hasSameUnqualifiedType(DestructedType,
7136 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
7137 << ObjectType << 0 <<
Base->getSourceRange();
7141 *
this, DestructedType))
7146 ObjectType = DestructedType;
7147 OpKind = tok::arrow;
7149 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
7150 << ObjectType << DestructedType <<
Base->getSourceRange()
7154 DestructedType = ObjectType;
7155 DestructedTypeInfo =
7156 Context.getTrivialTypeSourceInfo(ObjectType, DestructedTypeStart);
7166 Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)
7167 << ObjectType << DestructedType <<
Base->getSourceRange()
7172 DestructedType = ObjectType;
7173 DestructedTypeInfo =
Context.getTrivialTypeSourceInfo(ObjectType,
7174 DestructedTypeStart);
7187 if (ScopeTypeInfo) {
7189 if (!ScopeType->isDependentType() && !ObjectType->
isDependentType() &&
7190 !
Context.hasSameUnqualifiedType(ScopeType, ObjectType)) {
7193 diag::err_pseudo_dtor_type_mismatch)
7194 << ObjectType << ScopeType <<
Base->getSourceRange()
7198 ScopeTypeInfo =
nullptr;
7204 OpKind == tok::arrow, OpLoc,
7224 "Invalid first type name in pseudo-destructor");
7227 "Invalid second type name in pseudo-destructor");
7251 S, &SS,
true,
false, ObjectTypePtrForLookup,
7264 diag::err_pseudo_dtor_destructor_non_type)
7270 DestructedType = ObjectType;
7285 if (
T.isInvalid() || !
T.get()) {
7287 DestructedType = ObjectType;
7294 if (!DestructedType.
isNull()) {
7295 if (!DestructedTypeInfo)
7296 DestructedTypeInfo =
Context.getTrivialTypeSourceInfo(DestructedType,
7309 S, &SS,
true,
false, ObjectTypePtrForLookup,
7313 diag::err_pseudo_dtor_destructor_non_type)
7335 if (
T.isInvalid() || !
T.get()) {
7343 if (!ScopeType.isNull() && !ScopeTypeInfo)
7344 ScopeTypeInfo =
Context.getTrivialTypeSourceInfo(ScopeType,
7349 ScopeTypeInfo, CCLoc, TildeLoc,
7388 llvm_unreachable(
"Unsupported type in pseudo destructor");
7414 Operand->HasSideEffects(
Context,
false)) {
7417 Diag(Operand->getExprLoc(), diag::warn_side_effects_unevaluated_context);
7433 bool IsCompoundAssign =
false;
7434 bool isIncrementDecrementUnaryOp =
false;
7436 if (BO->getLHS()->getType()->isDependentType() ||
7437 BO->getRHS()->getType()->isDependentType()) {
7438 if (BO->getOpcode() != BO_Assign)
7440 }
else if (!BO->isAssignmentOp())
7443 IsCompoundAssign = BO->isCompoundAssignmentOp();
7444 LHS = dyn_cast<DeclRefExpr>(BO->getLHS());
7446 if (COCE->getOperator() != OO_Equal)
7448 LHS = dyn_cast<DeclRefExpr>(COCE->getArg(0));
7449 }
else if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
7450 if (!UO->isIncrementDecrementOp())
7452 isIncrementDecrementUnaryOp =
true;
7453 LHS = dyn_cast<DeclRefExpr>(UO->getSubExpr());
7463 if ((IsCompoundAssign || isIncrementDecrementUnaryOp) &&
7469 iter->getSecond()--;
7546 diag::err_incomplete_type);
7573 const VarDecl *DefVD =
nullptr;
7607 while (isa_and_nonnull<CapturedDecl>(DC))
7611 "The current call operator must be synchronized with Sema's CurContext");
7632 !IsFullExprInstantiationDependent)
7645 const bool IsVarNeverAConstantExpression =
7647 if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {
7659 DeclRefType,
nullptr)) {
7665 DeclRefType,
nullptr);
7677 const unsigned FunctionScopeIndexOfCapturableLambda = *Index;
7680 &FunctionScopeIndexOfCapturableLambda);
7689 bool DiscardedValue,
bool IsConstexpr,
7690 bool IsTemplateArgument) {
7699 if (DiscardedValue) {
7722 CheckCompletedExpr(
FullExpr.get(), CC, IsConstexpr);
7771 while (isa_and_nonnull<CapturedDecl>(DC))
7774 if (IsInLambdaDeclContext && CurrentLSI &&
7818 llvm_unreachable(
"Invalid LookupResult Kind!");
7847 "Exactly one of TypeName and TemplateId must be specified.");
7894 auto &II =
Context.Idents.get(
"expr-type");
7915 E,
false, NoexceptLoc,
7947 assert(TC &&
"Type Constraint cannot be null here");
7949 assert(IDC &&
"ImmediatelyDeclaredConstraint can't be null here.");
7953 SubstitutedConstraintExpr =
7961 [&](llvm::raw_ostream &
OS) {
7962 IDC->printPretty(OS, nullptr,
7963 getPrintingPolicy());
7965 IsSimple, NoexceptLoc, ReturnTypeRequirement);
7971 ReturnTypeRequirement, Status,
7972 SubstitutedConstraintExpr);
7981 IsSimple, NoexceptLoc,
7982 ReturnTypeRequirement);
8016 InvalidConstraintEntity,
8032 if (Param->getType()->isVoidType()) {
8033 if (LocalParameters.size() > 1) {
8034 Diag(Param->getBeginLoc(), diag::err_void_only_param);
8035 Param->setType(
Context.IntTy);
8036 }
else if (Param->getIdentifier()) {
8037 Diag(Param->getBeginLoc(), diag::err_param_with_void_type);
8038 Param->setType(
Context.IntTy);
8039 }
else if (Param->getType().hasQualifiers()) {
8040 Diag(Param->getBeginLoc(), diag::err_void_param_qualified);
8042 }
else if (Param->hasDefaultArg()) {
8046 Diag(Param->getDefaultArgRange().getBegin(),
8047 diag::err_requires_expr_local_parameter_default_argument);
8049 }
else if (Param->isExplicitObjectParameter()) {
8060 Diag(Param->getExplicitObjectParamThisLoc(),
8061 diag::err_requires_expr_explicit_object_parameter);
8065 Param->setDeclContext(Body);
8067 if (Param->getIdentifier()) {
8076 assert(
CurContext &&
"DeclContext imbalance!");
8078 assert(
CurContext &&
"Popped translation unit!");
8087 LocalParameters, RParenLoc, Requirements,
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines a function that returns the minimum OS versions supporting C++17's aligned allocation functio...
static bool CanThrow(Expr *E, ASTContext &Ctx)
static const char * getPlatformName(Darwin::DarwinPlatformKind Platform, Darwin::DarwinEnvironmentKind Environment)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
This file defines the classes used to store parsed information about declaration-specifiers and decla...
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines Expressions and AST nodes for C++2a concepts.
llvm::MachO::Record Record
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
@ NotForRedeclaration
The lookup is a reference to this name that is not for the purpose of redeclaring the name.
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 bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc, TypeAwareAllocationMode PassType, QualType allocType)
Determine whether a given type is a class for which 'delete[]' would call a member 'operator delete[]...
static void collectPublicBases(CXXRecordDecl *RD, llvm::DenseMap< CXXRecordDecl *, unsigned > &SubobjectsSeen, llvm::SmallPtrSetImpl< CXXRecordDecl * > &VBases, llvm::SetVector< CXXRecordDecl * > &PublicSubobjectsSeen, bool ParentIsPublic)
static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T)
Perform an "extended" implicit conversion as returned by TryClassUnification.
static void MaybeDecrementCount(Expr *E, llvm::DenseMap< const VarDecl *, int > &RefsMinusAssignments)
static bool CheckDeleteOperator(Sema &S, SourceLocation StartLoc, SourceRange Range, bool Diagnose, CXXRecordDecl *NamingClass, DeclAccessPair Decl, FunctionDecl *Operator)
static void DiagnoseMismatchedNewDelete(Sema &SemaRef, SourceLocation DeleteLoc, const MismatchingNewDeleteDetector &Detector)
static void getUnambiguousPublicSubobjects(CXXRecordDecl *RD, llvm::SmallVectorImpl< CXXRecordDecl * > &Objects)
static bool isLegalArrayNewInitializer(CXXNewInitializationStyle Style, Expr *Init, bool IsCPlusPlus20)
static QualType adjustVectorType(ASTContext &Context, QualType FromTy, QualType ToType, QualType *ElTy=nullptr)
static void CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(Expr *const FE, LambdaScopeInfo *const CurrentLSI, Sema &S)
Check if the current lambda has any potential captures that must be captured by any of its enclosing ...
static void getUuidAttrOfType(Sema &SemaRef, QualType QT, llvm::SmallSetVector< const UuidAttr *, 1 > &UuidAttrs)
Grabs __declspec(uuid()) off a type, or returns 0 if we cannot resolve to a single GUID.
static QualType adjustCVQualifiersForCXXThisWithinLambda(ArrayRef< FunctionScopeInfo * > FunctionScopes, QualType ThisTy, DeclContext *CurSemaContext, ASTContext &ASTCtx)
static bool resolveAllocationOverloadInterior(Sema &S, LookupResult &R, SourceRange Range, ResolveMode Mode, SmallVectorImpl< Expr * > &Args, AlignedAllocationMode &PassAlignment, FunctionDecl *&Operator, OverloadCandidateSet *AlignedCandidates, Expr *AlignArg, bool Diagnose)
static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Try to find a common type for two according to C++0x 5.16p5.
static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, SourceLocation QuestionLoc, bool &HaveConversion, QualType &ToType)
Try to convert a type to another according to C++11 5.16p3.
static bool resolveAllocationOverload(Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl< Expr * > &Args, ImplicitAllocationParameters &IAP, FunctionDecl *&Operator, OverloadCandidateSet *AlignedCandidates, Expr *AlignArg, bool Diagnose)
static UsualDeallocFnInfo resolveDeallocationOverload(Sema &S, LookupResult &R, const ImplicitDeallocationParameters &IDP, SourceLocation Loc, llvm::SmallVectorImpl< UsualDeallocFnInfo > *BestFns=nullptr)
Select the correct "usual" deallocation function to use from a selection of deallocation functions (e...
static bool hasNewExtendedAlignment(Sema &S, QualType AllocType)
Determine whether a type has new-extended alignment.
static ExprResult BuildCXXCastArgument(Sema &S, SourceLocation CastLoc, QualType Ty, CastKind Kind, CXXMethodDecl *Method, DeclAccessPair FoundDecl, bool HadMultipleCandidates, Expr *From)
static bool VariableCanNeverBeAConstantExpression(VarDecl *Var, ASTContext &Context)
static bool canRecoverDotPseudoDestructorCallsOnPointerObjects(Sema &SemaRef, QualType DestructedType)
Check if it's ok to try and recover dot pseudo destructor calls on pointer objects.
static bool CheckArrow(Sema &S, QualType &ObjectType, Expr *&Base, tok::TokenKind &OpKind, SourceLocation OpLoc)
static bool resolveBuiltinNewDeleteOverload(Sema &S, CallExpr *TheCall, bool IsDelete, FunctionDecl *&Operator)
static bool isValidVectorForConditionalCondition(ASTContext &Ctx, QualType CondTy)
static void LookupGlobalDeallocationFunctions(Sema &S, SourceLocation Loc, LookupResult &FoundDelete, DeallocLookupMode Mode, DeclarationName Name)
static void noteOperatorArrows(Sema &S, ArrayRef< FunctionDecl * > OperatorArrows)
Note a set of 'operator->' functions that were used for a member access.
static bool isValidSizelessVectorForConditionalCondition(ASTContext &Ctx, QualType CondTy)
static void buildLambdaThisCaptureFixit(Sema &Sema, LambdaScopeInfo *LSI)
static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD)
Determine whether the given function is a non-placement deallocation function.
This file declares semantic analysis for HLSL constructs.
This file provides some common utility functions for processing Lambdas.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis functions specific to PowerPC.
static QualType getPointeeType(const MemRegion *R)
Defines the clang::TokenKind enum and support functions.
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
a trap message and trap category.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
DeclarationNameTable DeclarationNames
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
unsigned getTypeAlignIfKnown(QualType T, bool NeedsPreferredAlignment=false) const
Return the alignment of a type, in bits, or 0 if the type is incomplete and we cannot determine the a...
QualType getMemberPointerType(QualType T, NestedNameSpecifier Qualifier, const CXXRecordDecl *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
const TargetInfo & getTargetInfo() const
CanQualType getCanonicalTagType(const TagDecl *TD) const
QualType getIncompleteArrayType(QualType EltTy, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type.
Represents a constant array type that does not decay to a pointer when used as a function parameter.
QualType getConstantArrayType(const ASTContext &Ctx) const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Attr - This represents one attribute.
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)
This class is used for builtin types like 'int'.
Represents a base class of a C++ class.
Represents binding an expression to a temporary.
static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)
const Expr * getSubExpr() const
A boolean literal, per ([C++ lex.bool] Boolean literals).
Represents a call to a C++ constructor.
Represents a C++ constructor within a class.
Represents a C++ conversion function within a class.
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
Expr * getInit() const
Get the initializer.
Represents a delete expression for memory deallocation and destructor calls, e.g.
SourceLocation getBeginLoc() const
Represents a C++ destructor within a class.
static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, FPOptionsOverride FPO, SourceLocation LPLoc, SourceLocation RPLoc)
Represents a static or instance method of a struct/union/class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
QualType getFunctionObjectParameterType() const
static CXXNewExpr * Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete, const ImplicitAllocationParameters &IAP, bool UsualArrayDeleteWantsSize, ArrayRef< Expr * > PlacementArgs, SourceRange TypeIdParens, std::optional< Expr * > ArraySize, CXXNewInitializationStyle InitializationStyle, Expr *Initializer, QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, SourceRange DirectInitRange)
Create a c++ new expression.
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
The null pointer literal (C++11 [lex.nullptr])
A call to an overloaded operator written using operator syntax.
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Represents a C++ struct/union/class.
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr)
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
capture_const_range captures() const
bool isAbstract() const
Determine whether this class has a pure virtual function.
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
bool hasDefinition() const
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
An expression "T()" which creates an rvalue of a non-class type T.
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.
SourceLocation getLastQualifierNameLoc() const
Retrieve the location of the name in the last qualifier in this nested name specifier.
SourceLocation getEndLoc() const
SourceRange getRange() const
bool isSet() const
Deprecated.
NestedNameSpecifier getScopeRep() const
Retrieve the representation of the nested-name-specifier.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Represents a C++ temporary.
void setDestructor(const CXXDestructorDecl *Dtor)
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Represents the this expression in C++.
static CXXThisExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType Ty, bool IsImplicit)
A C++ throw-expression (C++ [except.throw]).
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
static CXXUnresolvedConstructExpr * Create(const ASTContext &Context, QualType T, TypeSourceInfo *TSI, SourceLocation LParenLoc, ArrayRef< Expr * > Args, SourceLocation RParenLoc, bool IsListInit)
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
SourceLocation getBeginLoc() const
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Declaration of a class template.
Complex values, per C99 6.2.5p11.
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)
Represents the specialization of a concept - evaluates to a prvalue of type bool.
bool isSatisfied() const
Whether or not the concept with the given arguments was satisfied when the expression was created.
const ASTConstraintSatisfaction & getSatisfaction() const
Get elaborated satisfaction info about the template arguments' satisfaction of the named concept.
Represents the canonical version of C arrays with a specified constant size.
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
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.
lookup_result::iterator lookup_iterator
DeclContextLookupResult lookup_result
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
A reference to a declared variable, function, enum, etc.
Captures information about "declaration specifiers".
bool hasAutoTypeSpec() const
Expr * getPackIndexingExpr() const
TST getTypeSpecType() const
SourceLocation getBeginLoc() const LLVM_READONLY
static const TST TST_typename_pack_indexing
ParsedType getRepAsType() const
SourceLocation getEllipsisLoc() const
Expr * getRepAsExpr() const
static const TST TST_decltype
SourceLocation getTypeSpecTypeLoc() const
static const TST TST_decltype_auto
static const TST TST_error
SourceRange getTypeofParensRange() const
Decl - This represents one declaration (or definition), e.g.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
bool isInvalidDecl() const
SourceLocation getLocation() const
void setLocalOwningModule(Module *M)
void setImplicit(bool I=true)
DeclContext * getDeclContext()
@ ReachableWhenImported
This declaration has an owning module, and is visible to lookups that occurs within that module.
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
The name of a declaration.
bool isDependentName() const
Determines whether the name itself is dependent, e.g., because it involves a C++ type that is itself ...
bool isAnyOperatorDelete() const
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
bool isAnyOperatorNew() const
SourceLocation getBeginLoc() const LLVM_READONLY
Information about one declarator, including the parsed type information and the identifier.
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.
SourceLocation getEndLoc() const LLVM_READONLY
void DropFirstTypeObject()
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
bool isInvalidType() const
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
void setRParenLoc(SourceLocation Loc)
void setDecltypeLoc(SourceLocation Loc)
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine a...
DiagnosticOptions & getDiagnosticOptions() const
Retrieve the diagnostic options.
bool isComplete() const
Returns true if this can be considered a complete type.
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
This represents one expression.
bool isReadIfDiscardedInCPlusPlus11() const
Determine whether an lvalue-to-rvalue conversion should implicitly be applied to this expression if i...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool refersToVectorElement() const
Returns whether this expression refers to a vector element.
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 * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
@ NPC_ValueDependentIsNull
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
bool isOrdinaryOrBitFieldObject() const
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
Represents difference between two FPOptions values.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
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.
FullExpr - Represents a "full-expression" node.
Represents a function declaration or definition.
static constexpr unsigned RequiredTypeAwareDeleteParameterCount
Count of mandatory parameters for type aware operator delete.
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, const AssociatedConstraint &TrailingRequiresClause={})
const ParmVarDecl * getParamDecl(unsigned i) const
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
StringLiteral * getDeletedMessage() const
Get the message that indicates why this function was deleted.
QualType getReturnType() const
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
bool isReplaceableGlobalAllocationFunction(UnsignedOrNone *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
bool isDeleted() const
Whether this function has been deleted.
bool isTypeAwareOperatorNewOrDelete() const
Determine whether this is a type aware operator new or delete.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
Represents a prototype with parameter type info, e.g.
QualType getParamType(unsigned i) const
Declaration of a template function.
ExtInfo withCallingConv(CallingConv cc) const
ExtInfo withNoReturn(bool noReturn) const
FunctionType - C99 6.7.5.3 - Function Declarators.
One of these records is kept for each identifier that is lexed.
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const
Determine whether this is a name reserved for the implementation (C99 7.1.3, C++ [lib....
ReservedLiteralSuffixIdStatus isReservedLiteralSuffixId() const
Determine whether this is a name reserved for future standardization or the implementation (C++ [usrl...
StringRef getName() const
Return the actual identifier string.
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)
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
@ StaticObjectArgumentConversion
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence.
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
void DiagnoseAmbiguousConversion(Sema &S, SourceLocation CaretLoc, const PartialDiagnostic &PDiag) const
Diagnoses an ambiguous conversion.
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)
static InitializationKind CreateValue(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool isImplicit=false)
Create a value initialization.
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.
bool isAmbiguous() const
Determine whether this initialization failed due to an ambiguity.
bool Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr * > Args)
Diagnose an potentially-invalid initialization sequence.
bool Failed() const
Determine whether the initialization sequence is invalid.
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init....
Describes an entity that is being initialized.
static InitializedEntity InitializeException(SourceLocation ThrowLoc, QualType Type)
Create the initialization entity for an exception object.
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
static InitializedEntity InitializeNew(SourceLocation NewLoc, QualType Type)
Create the initialization entity for an object allocated via new.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
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'.
static SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)
Checks that the given token is the first token that occurs after the given location (this excludes co...
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.
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
DeclClass * getAsSingle() const
void setLookupName(DeclarationName Name)
Sets the name to look up.
bool empty() const
Return true if no decls were found.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Filter makeFilter()
Create a filter for this result set.
CXXRecordDecl * getNamingClass() const
Returns the 'naming class' for this lookup, i.e.
UnresolvedSetImpl::iterator iterator
bool isClassLookup() const
Returns whether these results arose from performing a lookup into a class.
LookupResultKind getResultKind() const
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
A pointer to member type per C++ 8.3.3 - Pointers to members.
CXXRecordDecl * getMostRecentCXXRecordDecl() const
Note: this can trigger extra deserialization when external AST sources are used.
QualType getPointeeType() const
Data structure that captures multiple levels of template argument lists for use in template instantia...
void addOuterRetainedLevels(unsigned Num)
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.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
A C++ nested-name-specifier augmented with source location information.
NamespaceAndPrefixLoc getAsNamespaceAndPrefix() const
TypeLoc getAsTypeLoc() const
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
const Type * getAsType() const
@ MicrosoftSuper
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Global
The global specifier '::'. There is no stored value.
@ Type
A type, stored as a Type*.
@ Namespace
A namespace-like entity, stored as a NamespaceBaseDecl*.
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
ObjCBoxedExpr - used for generalized expression boxing.
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
An expression that sends a message to the given Objective-C object or class.
ObjCMethodDecl - Represents an instance or class method declaration.
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
Represents a pointer to an Objective C object.
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
static OpaquePtr getFromOpaquePtr(void *P)
static OpaquePtr make(QualType P)
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
void NoteCandidates(PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
When overload resolution fails, prints diagnostic messages containing the candidates in the candidate...
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
SmallVector< OverloadCandidate *, 32 > CompleteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, SourceLocation OpLoc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
void setEllipsisLoc(SourceLocation Loc)
ParenExpr - This represents a parenthesized expression, e.g.
Represents a parameter to a function.
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
bool isEquivalent(PointerAuthQualifier Other) const
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
Stores the type being destroyed by a pseudo-destructor expression.
TypeSourceInfo * getTypeSourceInfo() const
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
QualType withConst() const
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.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
bool isConstQualified() const
Determine whether this type is const-qualified.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
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 isAtLeastAsQualifiedAs(QualType Other, const ASTContext &Ctx) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
The collection of all-type qualifiers we support.
void removeCVRQualifiers(unsigned mask)
@ OCL_None
There is no lifetime qualification on this type.
bool hasCVRQualifiers() const
bool hasUnaligned() const
unsigned getAddressSpaceAttributePrintValue() const
Get the address space attribute value to be printed by diagnostics.
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B, const ASTContext &Ctx)
Returns true if address space A is equal to or a superset of B.
void setAddressSpace(LangAS space)
unsigned getCVRUQualifiers() const
PointerAuthQualifier getPointerAuth() const
void setObjCGCAttr(GC type)
ObjCLifetime getObjCLifetime() const
static Qualifiers fromCVRUMask(unsigned CVRU)
LangAS getAddressSpace() const
void setPointerAuth(PointerAuthQualifier Q)
void setObjCLifetime(ObjCLifetime type)
Represents a struct/union/class.
Represents the body of a requires-expression.
static RequiresExprBodyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc)
static RequiresExpr * Create(ASTContext &C, SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body, SourceLocation LParenLoc, ArrayRef< ParmVarDecl * > LocalParameters, SourceLocation RParenLoc, ArrayRef< concepts::Requirement * > Requirements, SourceLocation RBraceLoc)
Scope - A scope is a transient data structure that is used while parsing the program.
unsigned getFlags() const
getFlags - Return the flags for this scope.
bool isDeclScope(const Decl *D) const
isDeclScope - Return true if this is the scope that the specified decl is declared in.
DeclContext * getEntity() const
Get the entity corresponding to this scope.
const Scope * getParent() const
getParent - Return the scope that this is nested in.
@ BlockScope
This is a scope that corresponds to a block/closure object.
@ ClassScope
The scope of a struct/union/class definition.
@ TryScope
This is the scope of a C++ try statement.
@ FnScope
This indicates that the scope corresponds to a function, which means that labels are set here.
@ ObjCMethodScope
This scope corresponds to an Objective-C method body.
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
CUDAFunctionTarget CurrentTarget()
Gets the CUDA target for the current context.
SemaDiagnosticBuilder DiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...
void EraseUnwantedMatches(const FunctionDecl *Caller, llvm::SmallVectorImpl< std::pair< DeclAccessPair, FunctionDecl * > > &Matches)
Finds a function in Matches with highest calling priority from Caller context and erases all function...
CUDAFunctionPreference IdentifyPreference(const FunctionDecl *Caller, const FunctionDecl *Callee)
Identifies relative preference of a given Caller/Callee combination, based on their host/device attri...
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
FindCompositeObjCPointerType - Helper method to find composite type of two objective-c pointer types ...
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type,...
CastKind PrepareCastToObjCObjectPointer(ExprResult &E)
Prepare a conversion of the given expression to an ObjC object pointer type.
ARCConversionResult CheckObjCConversion(SourceRange castRange, QualType castType, Expr *&op, CheckedConversionKind CCK, bool Diagnose=true, bool DiagnoseCFAudited=false, BinaryOperatorKind Opc=BO_PtrMemD, bool IsReinterpretCast=false)
Checks for invalid conversions and casts between retainable pointers and other pointer kinds for ARC ...
bool CheckPPCMMAType(QualType Type, SourceLocation TypeLoc)
CXXThisScopeRAII(Sema &S, Decl *ContextDecl, Qualifiers CXXThisTypeQuals, bool Enabled=true)
Introduce a new scope where 'this' may be allowed (when enabled), using the given declaration (which ...
Abstract base class used to perform a contextual implicit conversion from an expression to any type p...
Sema - This implements semantic analysis and AST building for C.
void DeclareGlobalNewDelete()
DeclareGlobalNewDelete - Declare the global forms of operator new and delete.
IfExistsResult CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS, const DeclarationNameInfo &TargetNameInfo)
QualType CheckSizelessVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
FunctionDecl * FindUsualDeallocationFunction(SourceLocation StartLoc, ImplicitDeallocationParameters, DeclarationName Name, bool Diagnose=true)
ExprResult ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXTypeid - Parse typeid( something ).
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
ExprResult ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXUuidof - Parse __uuidof( something ).
Scope * getCurScope() const
Retrieve the parser's current scope.
QualType CheckVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
bool checkArrayElementAlignment(QualType EltTy, SourceLocation Loc)
ExprResult IgnoredValueConversions(Expr *E)
IgnoredValueConversions - Given that an expression's result is syntactically ignored,...
bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &...Args)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupDestructorName
Look up a name following ~ in a destructor name.
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
@ LookupAnyName
Look up any declaration with any name.
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...
ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen, Expr *Operand, SourceLocation RParen)
bool BuildTypeConstraint(const CXXScopeSpec &SS, TemplateIdAnnotation *TypeConstraint, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc, bool AllowUnexpandedPack)
bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, ImplicitDeallocationParameters, bool Diagnose=true)
bool CheckCXXThisType(SourceLocation Loc, QualType Type)
Check whether the type of 'this' is valid in the current context.
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, ArithConvKind ACK)
UsualArithmeticConversions - Performs various conversions that are common to binary operators (C99 6....
QualType tryBuildStdTypeIdentity(QualType Type, SourceLocation Loc)
Looks for the std::type_identity template and instantiates it with Type, or returns a null type if ty...
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 ...
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
@ Boolean
A boolean condition, from 'if', 'while', 'for', or 'do'.
@ Switch
An integral condition for a 'switch' statement.
@ ConstexprIf
A constant boolean condition from 'if constexpr'.
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr * > Args, SmallVectorImpl< Expr * > &AllArgs, VariadicCallType CallType=VariadicCallType::DoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
@ Ref_Compatible
Ref_Compatible - The two types are reference-compatible.
ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type, SourceLocation LParenLoc, Expr *CastExpr, SourceLocation RParenLoc)
bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit=false, bool BuildAndDiagnose=true, const unsigned *const FunctionScopeIndexToStopAt=nullptr, bool ByCopy=false)
Make sure the value of 'this' is actually available in the current context, if it is a potentially ev...
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor,...
void MarkCaptureUsedInEnclosingContext(ValueDecl *Capture, SourceLocation Loc, unsigned CapturingScopeIndex)
ExprResult ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, ParsedType &ObjectType, bool &MayBePseudoDestructor)
QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool AllowBothBool, bool AllowBoolConversion, bool AllowBoolOperation, bool ReportInvalid)
type checking for vector binary operators.
concepts::Requirement * ActOnSimpleRequirement(Expr *E)
FPOptionsOverride CurFPFeatureOverrides()
concepts::Requirement * ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc)
ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool *NoArrowOperatorFound=nullptr)
BuildOverloadedArrowExpr - Build a call to an overloaded operator-> (if one exists),...
concepts::Requirement::SubstitutionDiagnostic * createSubstDiagAt(SourceLocation Location, EntityPrinter Printer)
create a Requirement::SubstitutionDiagnostic with only a SubstitutedEntity and DiagLoc using ASTConte...
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
ExprResult CheckUnevaluatedOperand(Expr *E)
ExprResult ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *Operand)
ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
void DiagnoseExceptionUse(SourceLocation Loc, bool IsTry)
ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond)
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we're implicitly casting from a _Nullable pointer type to a _Nonnull one.
ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc)
ActOnCXXNullPtrLiteral - Parse 'nullptr'.
ExprResult BuildCXXTypeId(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a C++ typeid expression with a type operand.
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
DiagnosticsEngine & getDiagnostics() const
ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME)
This is not an AltiVec-style cast or or C++ direct-initialization, so turn the ParenListExpr into a s...
concepts::TypeRequirement * BuildTypeRequirement(TypeSourceInfo *Type)
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
bool isStdTypeIdentity(QualType Ty, QualType *TypeArgument, const Decl **MalformedDecl=nullptr)
Tests whether Ty is an instance of std::type_identity and, if it is and TypeArgument is not NULL,...
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over....
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
ParsedType getDestructorName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, ParsedType ObjectType, bool EnteringContext)
void CleanupVarDeclMarking()
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
ASTContext & getASTContext() const
void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return, ArrayRef< QualType > Params)
DeclareGlobalAllocationFunction - Declares a single implicit global allocation function if it doesn't...
bool DiagnoseUnexpandedParameterPackInRequiresExpr(RequiresExpr *RE)
If the given requirees-expression contains an unexpanded reference to one of its own parameter packs,...
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
bool tryCaptureVariable(ValueDecl *Var, SourceLocation Loc, TryCaptureKind Kind, SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt)
Try to capture the given variable.
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace.
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.
ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, UnqualifiedId &FirstTypeName, SourceLocation CCLoc, SourceLocation TildeLoc, UnqualifiedId &SecondTypeName)
bool CheckArgsForPlaceholders(MultiExprArg args)
Check an argument list for placeholders that we won't try to handle later.
AccessResult CheckAllocationAccess(SourceLocation OperatorLoc, SourceRange PlacementRange, CXXRecordDecl *NamingClass, DeclAccessPair FoundDecl, bool Diagnose=true)
Checks access to an overloaded operator new or delete.
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, const SourceRange &, DeclAccessPair FoundDecl)
void ActOnFinishRequiresExpr()
ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional< Expr * > ArraySize, SourceRange DirectInitRange, Expr *Initializer)
void DiagnoseUseOfDeletedFunction(SourceLocation Loc, SourceRange Range, DeclarationName Name, OverloadCandidateSet &CandidateSet, FunctionDecl *Fn, MultiExprArg Args, bool IsMember=false)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr)
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 CheckConstraintSatisfaction(ConstrainedDeclOrNestedRequirement Entity, ArrayRef< AssociatedConstraint > AssociatedConstraints, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction, const ConceptReference *TopLevelConceptId=nullptr, Expr **ConvertedExpr=nullptr)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
EnumDecl * getStdAlignValT() const
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
NamedReturnInfo getNamedReturnInfo(Expr *&E, SimplerImplicitMoveMode Mode=SimplerImplicitMoveMode::Normal)
Determine whether the given expression might be move-eligible or copy-elidable in either a (co_)retur...
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id, bool IsUDSuffix)
void DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID)
DiagnoseUnusedExprResult - If the statement passed in is an expression whose result is unused,...
FPOptions & getCurFPFeatures()
Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, TranslationUnitKind TUKind=TU_Complete, CodeCompleteConsumer *CompletionConsumer=nullptr)
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
@ UPPC_IfExists
Microsoft __if_exists.
@ UPPC_IfNotExists
Microsoft __if_not_exists.
const LangOptions & getLangOpts() const
StmtResult ActOnFinishFullStmt(Stmt *Stmt)
CastKind PrepareScalarCast(ExprResult &src, QualType destType)
Prepares for a scalar cast, performing all the necessary stages except the final cast and returning t...
void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, SourceLocation Loc)
Produce diagnostics if FD is an aligned allocation or deallocation function that is unavailable.
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, QualType ObjectType, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
bool 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)
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type, SourceLocation LParenLoc, MultiExprArg Exprs, SourceLocation RParenLoc, bool ListInitialization)
AssignConvertType CheckAssignmentConstraints(SourceLocation Loc, QualType LHSType, QualType RHSType)
CheckAssignmentConstraints - Perform type checking for assignment, argument passing,...
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions={}, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false, bool StrictPackMatch=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
const LangOptions & LangOpts
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, CXXConversionDecl *Method, bool HadMultipleCandidates)
ExprResult CheckConditionVariable(VarDecl *ConditionVar, SourceLocation StmtLoc, ConditionKind CK)
Check the use of the given variable as a C++ condition in an if, while, do-while, or switch statement...
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
CXXRecordDecl * getStdBadAlloc() const
ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep, SourceLocation LParenOrBraceLoc, MultiExprArg Exprs, SourceLocation RParenOrBraceLoc, bool ListInitialization)
ActOnCXXTypeConstructExpr - Parse construction of a specified type.
void CheckUnusedVolatileAssignment(Expr *E)
Check whether E, which is either a discarded-value expression or an unevaluated operand,...
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
ConditionResult ActOnConditionVariable(Decl *ConditionVar, SourceLocation StmtLoc, ConditionKind CK)
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
bool CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R)
Checks that a type is suitable as the allocated type in a new-expression.
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
ExprResult ActOnRequiresExpr(SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body, SourceLocation LParenLoc, ArrayRef< ParmVarDecl * > LocalParameters, SourceLocation RParenLoc, ArrayRef< concepts::Requirement * > Requirements, SourceLocation ClosingBraceLoc)
QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2, bool ConvertArgs=true)
Find a merged pointer type and convert the two expressions to it.
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
ReferenceConversionsScope::ReferenceConversions ReferenceConversions
CXXRecordDecl * getCurrentClass(Scope *S, const CXXScopeSpec *SS)
Get the class that is directly named by the current context.
ExprResult BuildCXXUuidof(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a Microsoft __uuidof expression with a type operand.
MemberPointerConversionResult CheckMemberPointerConversion(QualType FromType, const MemberPointerType *ToPtrType, CastKind &Kind, CXXCastPath &BasePath, SourceLocation CheckLoc, SourceRange OpRange, bool IgnoreBaseAccess, MemberPointerConversionDirection Direction)
CheckMemberPointerConversion - Check the member pointer conversion from the expression From to the ty...
Expr * BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit)
Build a CXXThisExpr and mark it referenced in the current context.
QualType CheckSizelessVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, ArithConvKind OperationKind)
llvm::DenseMap< const VarDecl *, int > RefsMinusAssignments
Increment when we find a reference; decrement when we find an ignored assignment.
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
void MarkThisReferenced(CXXThisExpr *This)
ExprResult DefaultLvalueConversion(Expr *E)
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
bool isInLifetimeExtendingContext() const
Module * getCurrentModule() const
Get the module unit whose scope we are currently within.
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
static bool isCast(CheckedConversionKind CCK)
FunctionDecl * FindDeallocationFunctionForDestructor(SourceLocation StartLoc, CXXRecordDecl *RD, bool Diagnose, bool LookForGlobal)
ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr)
Prepare SplattedExpr for a vector splat operation, adding implicit casts if necessary.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, AllocationFunctionScope NewScope, AllocationFunctionScope DeleteScope, QualType AllocType, bool IsArray, ImplicitAllocationParameters &IAP, MultiExprArg PlaceArgs, FunctionDecl *&OperatorNew, FunctionDecl *&OperatorDelete, bool Diagnose=true)
Finds the overloads of operator new and delete that are appropriate for the allocation.
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+...
AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, DeclAccessPair FoundDecl, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp=false)
Checks access to a constructor.
bool DiagnoseConditionalForNull(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation QuestionLoc)
Emit a specialized diagnostic when one expression is a null pointer constant and the other is not a p...
ParsedType getDestructorTypeForDecltype(const DeclSpec &DS, ParsedType ObjectType)
bool IsDerivedFrom(SourceLocation Loc, CXXRecordDecl *Derived, CXXRecordDecl *Base, CXXBasePaths &Paths)
Determine whether the type Derived is a C++ class that is derived from the type Base.
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
DeclContext * getFunctionLevelDeclContext(bool AllowLambda=false) const
If AllowLambda is true, treat lambda as function.
Stmt * MaybeCreateStmtWithCleanups(Stmt *SubStmt)
ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, Declarator &D, Expr *Initializer)
Parsed a C++ 'new' expression (C++ 5.3.4).
ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand, SourceLocation RParen)
bool GlobalNewDeleteDeclared
A flag to remember whether the implicit forms of operator new and delete have been declared.
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
ExprResult TransformToPotentiallyEvaluated(Expr *E)
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
QualType CXXThisTypeOverride
When non-NULL, the C++ 'this' expression is allowed despite the current context not being a non-stati...
ExprResult FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity, const NamedReturnInfo &NRInfo, Expr *Value, bool SupressSimplerImplicitMoves=false)
Perform the initialization of a potentially-movable value, which is the result of return value.
ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr=false)
CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
CanThrowResult canThrow(const Stmt *E)
bool isThisOutsideMemberFunctionBody(QualType BaseType)
Determine whether the given type is the type of *this that is used outside of the body of a member fu...
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
QualType CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, SourceLocation OpLoc, bool isIndirect)
concepts::ExprRequirement * BuildExprRequirement(Expr *E, bool IsSatisfied, SourceLocation NoexceptLoc, concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement)
QualType CXXCheckConditionalOperands(ExprResult &cond, ExprResult &lhs, ExprResult &rhs, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc)
Check the operands of ?
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 ...
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.
concepts::Requirement * ActOnTypeRequirement(SourceLocation TypenameKWLoc, CXXScopeSpec &SS, SourceLocation NameLoc, const IdentifierInfo *TypeName, TemplateIdAnnotation *TemplateId)
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
ParsedType getInheritingConstructorName(CXXScopeSpec &SS, SourceLocation NameLoc, const IdentifierInfo &Name)
Handle the result of the special case name lookup for inheriting constructor declarations.
TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc, ImplicitTypenameContext IsImplicitTypename=ImplicitTypenameContext::No)
Called when the parser has parsed a C++ typename specifier, e.g., "typename T::type".
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
ExprResult BuildPseudoDestructorExpr(Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, const CXXScopeSpec &SS, TypeSourceInfo *ScopeType, SourceLocation CCLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
RecordDecl * CXXTypeInfoDecl
The C++ "type_info" declaration, which is defined in <typeinfo>.
CXXConstructorDecl * LookupCopyingConstructor(CXXRecordDecl *Class, unsigned Quals)
Look up the copying constructor for the given class.
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=AllowFoldKind::No)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
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.
RequiresExprBodyDecl * ActOnStartRequiresExpr(SourceLocation RequiresKWLoc, ArrayRef< ParmVarDecl * > LocalParameters, Scope *BodyScope)
bool CheckPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess, bool Diagnose=true)
CheckPointerConversion - Check the pointer conversion from the expression From to the type ToType.
SmallVector< ExprWithCleanups::CleanupObject, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(FunctionDecl *FD)
If this function is a C++ replaceable global allocation function (C++2a [basic.stc....
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.
bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, CallExpr *CE, FunctionDecl *FD)
CheckCallReturnType - Checks that a call expression's return type is complete.
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, ReferenceConversions *Conv=nullptr)
CompareReferenceRelationship - Compare the two types T1 and T2 to determine whether they are referenc...
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
Delete-expressions to be analyzed at the end of translation unit.
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
void DiscardCleanupsInEvaluationContext()
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const
Determine whether FD is an aligned allocation or deallocation function that is unavailable.
DiagnosticsEngine & Diags
TypeAwareAllocationMode ShouldUseTypeAwareOperatorNewOrDelete() const
NamespaceDecl * getStdNamespace() const
ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex, bool IsThrownVarInScope)
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc)
friend class InitializationSequence
concepts::NestedRequirement * BuildNestedRequirement(Expr *E)
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, ArrayRef< TemplateArgument > TemplateArgs, sema::TemplateDeductionInfo &Info)
QualType ActOnPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc)
bool isUsualDeallocationFunction(const CXXMethodDecl *FD)
TypeResult ActOnTemplateIdType(Scope *S, ElaboratedTypeKeyword ElaboratedKeyword, SourceLocation ElaboratedKeywordLoc, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, const IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false, bool IsClassName=false, ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No)
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
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,...
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD=nullptr)
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
ParsedType getConstructorName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, bool EnteringContext)
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E)
CheckCXXThrowOperand - Validate the operand of a throw.
TemplateDeductionResult DeduceAutoType(TypeLoc AutoTypeLoc, Expr *Initializer, QualType &Result, sema::TemplateDeductionInfo &Info, bool DependentDeduction=false, bool IgnoreConstraints=false, TemplateSpecCandidateSet *FailedTSC=nullptr)
Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
concepts::Requirement * ActOnNestedRequirement(Expr *Constraint)
QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, bool AdjustExceptionSpec=false)
Adjust the type ArgFunctionType to match the calling convention, noreturn, and optionally the excepti...
bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType)
Helper function to determine whether this is the (deprecated) C++ conversion from a string literal to...
bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType)
static ConditionResult ConditionError()
IdentifierResolver IdResolver
FunctionTemplateDecl * getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, QualType RawObj1Ty={}, QualType RawObj2Ty={}, bool Reversed=false, bool PartialOverloading=false)
Returns the more specialized function template according to the rules of function template partial or...
ExprResult ActOnCXXThis(SourceLocation Loc)
ExprResult ActOnDecltypeExpression(Expr *E)
Process the expression contained within a decltype.
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr, bool SkipImmediateInvocations=true)
Instantiate or parse a C++ default argument expression as necessary.
void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc, bool IsDelete, bool CallCanBeVirtual, bool WarnOnNonAbstractTypes, SourceLocation DtorLoc)
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, const Expr *ThisArg, ArrayRef< const Expr * > Args, bool IsMemberFunction, SourceLocation Loc, SourceRange Range, VariadicCallType CallType)
Handles the checks for format strings, non-POD arguments to vararg functions, NULL arguments passed t...
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3....
DeclAccessPair FoundCopyConstructor
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion,...
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion,...
unsigned DeprecatedStringLiteralToCharPtr
Whether this is the deprecated conversion of a string literal to a pointer to non-const character dat...
CXXConstructorDecl * CopyConstructor
CopyConstructor - The copy constructor that is used to perform this conversion, when the conversion i...
unsigned IncompatibleObjC
IncompatibleObjC - Whether this is an Objective-C conversion that we should warn about (if we actuall...
ImplicitConversionKind Third
Third - The third conversion can be a qualification conversion or a function conversion.
ImplicitConversionKind Dimension
Dimension - Between the second and third conversion a vector or matrix dimension conversion may occur...
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
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
StringLiteral - This represents a string literal expression, e.g.
StringRef getString() const
unsigned getNewAlign() const
Return the largest alignment for which a suitably-sized allocation with 'operator new(size_t)' is gua...
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
A template argument list.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Represents a template argument.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Type
The template argument is a type.
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, UnsignedOrNone NumExpanded=std::nullopt)
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
Expr * getImmediatelyDeclaredConstraint() const
Get the immediately-declared constraint expression introduced by this type-constraint,...
Represents a declaration of a type.
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
void pushTrivial(ASTContext &Context, QualType T, SourceLocation Loc)
Pushes 'T' with all locations pointing to 'Loc'.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
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.
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.
bool isBlockPointerType() const
bool isBooleanType() const
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isVoidPointerType() const
CXXRecordDecl * castAsCXXRecordDecl() const
bool isArithmeticType() const
bool isPointerType() const
bool isArrayParameterType() 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 isScalarType() const
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isExtVectorType() const
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isMemberPointerType() const
bool isMatrixType() const
EnumDecl * castAsEnumDecl() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isObjectType() const
Determine whether this type is an object type.
EnumDecl * getAsEnumDecl() const
Retrieves the EnumDecl this type refers to.
bool isPointerOrReferenceType() const
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isVectorType() const
bool isRealFloatingType() const
Floating point categories.
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
bool isFloatingType() const
bool isAnyPointerType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
bool isNullPtrType() const
bool isRecordType() const
bool isObjCRetainableType() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represents a C++ unqualified-id that has been parsed.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
const IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId,...
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 ...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr.
VarDecl * getPotentiallyDecomposedVarDecl()
Represents a variable declaration or definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
Represents a GCC generic vector type.
bool isTypeConstraint() const
TemplateParameterList * getTypeConstraintTemplateParameterList() const
bool isSubstitutionFailure() const
A requires-expression requirement which queries the validity and properties of an expression ('simple...
@ SS_ConstraintsNotSatisfied
@ SS_TypeRequirementSubstitutionFailure
A requires-expression requirement which is satisfied when a general constraint expression is satisfie...
A static requirement that can be used in a requires-expression to check properties of types and expre...
A requires-expression requirement which queries the existence of a type name or type template special...
ImplicitCaptureStyle ImpCaptureStyle
Capture & getCXXThisCapture()
Retrieve the capture of C++ 'this', if it has been captured.
bool isCXXThisCaptured() const
Determine whether the C++ 'this' is captured.
void addThisCapture(bool isNested, SourceLocation Loc, QualType CaptureType, bool ByCopy)
SourceLocation PotentialThisCaptureLocation
bool hasPotentialThisCapture() const
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
bool lambdaCaptureShouldBeConst() const
void clearPotentialCaptures()
bool hasPotentialCaptures() const
bool isVariableExprMarkedAsNonODRUsed(Expr *CapturingVarExpr) const
CXXRecordDecl * Lambda
The class that describes the lambda.
void visitPotentialCaptures(llvm::function_ref< void(ValueDecl *, Expr *)> Callback) const
unsigned NumExplicitCaptures
The number of captures in the Captures list that are explicit captures.
bool AfterParameterList
Indicate that we parsed the parameter list at which point the mutability of the lambda is known.
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
Provides information about an attempted template argument deduction, whose success or failure was des...
Defines the clang::TargetInfo interface.
SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)
Returns the results of matching Matcher on Node.
bool NE(InterpState &S, CodePtr OpPC)
ComparisonCategoryResult Compare(const T &X, const T &Y)
Helper to compare two comparable types.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
The JSON file list parser is used to communicate input to InstallAPI.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
bool isLambdaCallWithImplicitObjectParameter(const DeclContext *DC)
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ Match
This is not an overload because the signature exactly matches an existing declaration.
bool isa(CodeGen::Address addr)
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.
CanThrowResult
Possible results from evaluation of a noexcept expression.
AllocationFunctionScope
The scope in which to find allocation functions.
@ Both
Look for allocation functions in both the global scope and in the scope of the allocated class.
@ Global
Only look for allocation functions in the global scope.
@ Class
Only look for allocation functions in the scope of the allocated class.
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
bool isReservedInAllContexts(ReservedIdentifierStatus Status)
Determine whether an identifier is reserved in all contexts.
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
@ 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.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ Found
Name lookup found a single declaration that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
AlignedAllocationMode alignedAllocationModeFromBool(bool IsAligned)
@ Conditional
A conditional (?:) operator.
@ RQ_None
No ref-qualifier was provided.
@ RQ_LValue
An lvalue 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.
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
@ OK_ObjCProperty
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
@ OK_Ordinary
An ordinary object is located at an address in memory.
@ OK_BitField
A bitfield object is a bitfield on a C or C++ record.
UnsignedOrNone getStackIndexOfNearestEnclosingCaptureCapableLambda(ArrayRef< const sema::FunctionScopeInfo * > FunctionScopes, ValueDecl *VarToCapture, Sema &S)
Examines the FunctionScopeInfo stack to determine the nearest enclosing lambda (to the current lambda...
@ LCK_StarThis
Capturing the *this object by copy.
@ Bind
'bind' clause, allowed on routine constructs.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
bool isLambdaCallWithExplicitObjectParameter(const DeclContext *DC)
bool isAlignedAllocation(AlignedAllocationMode Mode)
MutableArrayRef< Expr * > MultiExprArg
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
ActionResult< ParsedType > TypeResult
const FunctionProtoType * T
@ ICK_Complex_Conversion
Complex conversions (C99 6.3.1.6)
@ ICK_Floating_Promotion
Floating point promotions (C++ [conv.fpprom])
@ ICK_Boolean_Conversion
Boolean conversions (C++ [conv.bool])
@ ICK_Integral_Conversion
Integral conversions (C++ [conv.integral])
@ ICK_Fixed_Point_Conversion
Fixed point type conversions according to N1169.
@ ICK_Vector_Conversion
Vector conversions.
@ ICK_Block_Pointer_Conversion
Block Pointer conversions.
@ ICK_Pointer_Member
Pointer-to-member conversions (C++ [conv.mem])
@ ICK_Floating_Integral
Floating-integral conversions (C++ [conv.fpint])
@ ICK_HLSL_Array_RValue
HLSL non-decaying array rvalue cast.
@ ICK_SVE_Vector_Conversion
Arm SVE Vector conversions.
@ ICK_HLSL_Vector_Truncation
HLSL vector truncation.
@ ICK_Incompatible_Pointer_Conversion
C-only conversion between pointers with incompatible types.
@ ICK_Array_To_Pointer
Array-to-pointer conversion (C++ [conv.array])
@ ICK_RVV_Vector_Conversion
RISC-V RVV Vector conversions.
@ ICK_Complex_Promotion
Complex promotions (Clang extension)
@ ICK_Num_Conversion_Kinds
The number of conversion kinds.
@ ICK_Function_Conversion
Function pointer conversion (C++17 [conv.fctptr])
@ ICK_Vector_Splat
A vector splat from an arithmetic type.
@ ICK_Zero_Queue_Conversion
Zero constant to queue.
@ ICK_Identity
Identity conversion (no conversion)
@ ICK_Derived_To_Base
Derived-to-base (C++ [over.best.ics])
@ ICK_Lvalue_To_Rvalue
Lvalue-to-rvalue conversion (C++ [conv.lval])
@ ICK_Qualification
Qualification conversions (C++ [conv.qual])
@ ICK_Pointer_Conversion
Pointer conversions (C++ [conv.ptr])
@ ICK_TransparentUnionConversion
Transparent Union Conversions.
@ ICK_Integral_Promotion
Integral promotions (C++ [conv.prom])
@ ICK_Floating_Conversion
Floating point conversions (C++ [conv.double].
@ ICK_Compatible_Conversion
Conversions between compatible types in C99.
@ ICK_C_Only_Conversion
Conversions allowed in C, but not C++.
@ ICK_Writeback_Conversion
Objective-C ARC writeback conversion.
@ ICK_Zero_Event_Conversion
Zero constant to event (OpenCL1.2 6.12.10)
@ ICK_Complex_Real
Complex-real conversions (C99 6.3.1.7)
@ ICK_Function_To_Pointer
Function-to-pointer (C++ [conv.array])
@ Template
We are parsing a template declaration.
ActionResult< CXXBaseSpecifier * > BaseResult
llvm::VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS)
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
@ Incompatible
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST.
@ Compatible
Compatible - the types are compatible according to the standard.
@ NotStartsWithUnderscore
@ Class
The "class" keyword.
@ Type
The name was classified as a type.
bool isTypeAwareAllocation(TypeAwareAllocationMode Mode)
LangAS
Defines the address space values used by the address space qualifier of QualType.
CastKind
CastKind - The kind of operation required for a conversion.
MutableArrayRef< ParsedTemplateArgument > ASTTemplateArgsPtr
SizedDeallocationMode sizedDeallocationModeFromBool(bool IsSized)
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
bool isPtrSizeAddressSpace(LangAS AS)
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_LValue
An l-value expression is a reference to an object with independent storage.
SmallVector< CXXBaseSpecifier *, 4 > CXXCastPath
A simple array of base specifiers.
bool isSizedDeallocation(SizedDeallocationMode Mode)
IfExistsResult
Describes the result of an "if-exists" condition check.
@ Dependent
The name is a dependent name, so the results will differ from one instantiation to the next.
@ Exists
The symbol exists.
@ Error
An error occurred.
@ DoesNotExist
The symbol does not exist.
@ TPOC_Call
Partial ordering of function templates for a function call.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
TemplateDeductionResult
Describes the result of template argument deduction.
@ Success
Template argument deduction was successful.
@ AlreadyDiagnosed
Some error which was already diagnosed.
@ Generic
not a target-specific vector type
U cast(CodeGen::Address addr)
@ ArrayBound
Array bound in array declarator or new-expression.
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
@ None
No keyword precedes the qualified type name.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
ActionResult< Expr * > ExprResult
@ Other
Other implicit parameter.
CXXNewInitializationStyle
@ Parens
New-expression has a C++98 paren-delimited initializer.
@ None
New-expression has no initializer as written.
@ Braces
New-expression has a C++11 list-initializer.
@ EST_BasicNoexcept
noexcept
@ EST_Dynamic
throw(T1, T2)
CheckedConversionKind
The kind of conversion being performed.
@ CStyleCast
A C-style cast.
@ ForBuiltinOverloadedOp
A conversion for an operand of a builtin overloaded operator.
@ FunctionalCast
A functional-style cast.
ActionResult< Stmt * > StmtResult
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
static ASTConstraintSatisfaction * Rebuild(const ASTContext &C, const ASTConstraintSatisfaction &Satisfaction)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
DeclarationName getName() const
getName - Returns the embedded declaration name.
unsigned hasStatic
True if this dimension included the 'static' keyword.
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
One instance of this struct is used for each type in a declarator that is parsed.
SourceLocation Loc
Loc - The place where this type was defined.
enum clang::DeclaratorChunk::@340323374315200305336204205154073066142310370142 Kind
ExceptionSpecificationType Type
The kind of exception specification this is.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
unsigned CFIUncheckedCallee
FunctionType::ExtInfo ExtInfo
AlignedAllocationMode PassAlignment
TypeAwareAllocationMode PassTypeIdentity
unsigned getNumImplicitArgs() const
TypeAwareAllocationMode PassTypeIdentity
SizedDeallocationMode PassSize
AlignedAllocationMode PassAlignment
NestedNameSpecifierLoc Prefix
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
Information about a template-id annotation token.
const IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
unsigned NumArgs
NumArgs - The number of template arguments.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
SourceLocation TemplateKWLoc
TemplateKWLoc - The location of the template keyword.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
StandardConversionSequence Before
Represents the standard conversion that occurs before the actual user-defined conversion.
FunctionDecl * ConversionFunction
ConversionFunction - The function that will perform the user-defined conversion.
bool HadMultipleCandidates
HadMultipleCandidates - When this is true, it means that the conversion function was resolved from an...
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion.
bool EllipsisConversion
EllipsisConversion - When this is true, it means user-defined conversion sequence starts with a ....
DeclAccessPair FoundConversionFunction
The declaration that we found via name lookup, which might be the same as ConversionFunction or it mi...