47 #include "llvm/ADT/APInt.h"
48 #include "llvm/ADT/STLExtras.h"
49 #include "llvm/ADT/STLForwardCompat.h"
50 #include "llvm/ADT/StringExtras.h"
51 #include "llvm/Support/ErrorHandling.h"
52 #include "llvm/Support/TypeSize.h"
54 using namespace clang;
86 llvm_unreachable(
"Nested name specifier is not a type for inheriting ctor");
91 return CreateParsedType(
Type,
100 "not a constructor name");
111 if (SS.
isNotEmpty() && RequireCompleteDeclContext(SS, CurClass))
122 auto *RD = dyn_cast<CXXRecordDecl>(ND);
123 if (RD && RD->isInjectedClassName()) {
124 InjectedClassName = RD;
128 if (!InjectedClassName) {
133 diag::err_incomplete_nested_name_spec) << CurClass << SS.
getRange();
139 DiagnoseUseOfDecl(InjectedClassName, NameLoc);
140 MarkAnyDeclReferenced(NameLoc, InjectedClassName,
false);
148 bool EnteringContext) {
191 ObjectTypePtr ? GetTypeFromParser(ObjectTypePtr) :
QualType();
194 auto IsAcceptableResult = [&](
NamedDecl *D) ->
bool {
195 auto *
Type = dyn_cast<TypeDecl>(D->getUnderlyingDecl());
206 unsigned NumAcceptableResults = 0;
208 if (IsAcceptableResult(D))
209 ++NumAcceptableResults;
214 if (
auto *RD = dyn_cast<CXXRecordDecl>(D))
215 if (RD->isInjectedClassName())
216 D = cast<NamedDecl>(RD->getParent());
218 if (FoundDeclSet.insert(D).second)
219 FoundDecls.push_back(D);
227 if (Found.isAmbiguous() && NumAcceptableResults == 1) {
228 Diag(NameLoc, diag::ext_dtor_name_ambiguous);
238 if (!IsAcceptableResult(D))
244 if (Found.isAmbiguous())
248 if (IsAcceptableResult(
Type)) {
250 MarkAnyDeclReferenced(
Type->getLocation(),
Type,
false);
251 return CreateParsedType(
260 bool IsDependent =
false;
262 auto LookupInObjectType = [&]() ->
ParsedType {
263 if (Failed || SearchType.
isNull())
268 LookupResult Found(*
this, &II, NameLoc, LookupDestructorName);
269 DeclContext *LookupCtx = computeDeclContext(SearchType);
272 LookupQualifiedName(Found, LookupCtx);
273 return CheckLookupResult(Found);
280 IsDependent |= isDependentScopeSpecifier(LookupSS);
281 DeclContext *LookupCtx = computeDeclContext(LookupSS, EnteringContext);
285 LookupResult Found(*
this, &II, NameLoc, LookupDestructorName);
286 if (RequireCompleteDeclContext(LookupSS, LookupCtx)) {
290 LookupQualifiedName(Found, LookupCtx);
291 return CheckLookupResult(Found);
298 LookupResult Found(*
this, &II, NameLoc, LookupDestructorName);
299 LookupName(Found, S);
300 return CheckLookupResult(Found);
347 if (
ParsedType T = LookupInNestedNameSpec(PrefixSS))
377 unsigned NumNonExtensionDecls = FoundDecls.size();
401 Diag(SS.
getEndLoc(), diag::ext_qualified_dtor_named_in_lexical_scope)
403 Diag(FoundDecls.back()->getLocation(), diag::note_destructor_type_here)
404 << GetTypeFromParser(
T);
414 FoundDecls.resize(NumNonExtensionDecls);
417 std::stable_sort(FoundDecls.begin(), FoundDecls.end(),
419 return isa<TypeDecl>(A->getUnderlyingDecl()) >
420 isa<TypeDecl>(B->getUnderlyingDecl());
424 auto MakeFixItHint = [&]{
430 Destroyed = dyn_cast_or_null<CXXRecordDecl>(S->getEntity());
437 if (FoundDecls.empty()) {
439 Diag(NameLoc, diag::err_undeclared_destructor_name)
440 << &II << MakeFixItHint();
441 }
else if (!SearchType.
isNull() && FoundDecls.size() == 1) {
442 if (
auto *TD = dyn_cast<TypeDecl>(FoundDecls[0]->getUnderlyingDecl())) {
443 assert(!SearchType.
isNull() &&
444 "should only reject a type result if we have a search type");
446 Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
447 <<
T << SearchType << MakeFixItHint();
449 Diag(NameLoc, diag::err_destructor_expr_nontype)
450 << &II << MakeFixItHint();
453 Diag(NameLoc, SearchType.
isNull() ? diag::err_destructor_name_nontype
454 : diag::err_destructor_expr_mismatch)
455 << &II << SearchType << MakeFixItHint();
459 if (
auto *TD = dyn_cast<TypeDecl>(FoundD->getUnderlyingDecl()))
460 Diag(FoundD->getLocation(), diag::note_destructor_type_here)
463 Diag(FoundD->getLocation(), diag::note_destructor_nontype_here)
481 "unexpected type in getDestructorType");
486 QualType SearchType = GetTypeFromParser(ObjectType);
508 if (!PP.getSourceManager().isInSystemHeader(
Loc)) {
510 Name.getSourceRange(),
511 (StringRef(
"operator\"\"") + II->
getName()).str());
513 Diag(
Loc, diag::warn_reserved_extern_symbol)
514 << II << static_cast<int>(Status) << Hint;
516 Diag(
Loc, diag::warn_deprecated_literal_operator_id) << II << Hint;
532 Diag(Name.getBeginLoc(), diag::err_literal_operator_id_outside_namespace)
543 llvm_unreachable(
"unknown nested name specifier kind");
561 RequireCompleteType(TypeidLoc,
T, diag::err_incomplete_typeid))
565 return ExprError(
Diag(TypeidLoc, diag::err_variably_modified_typeid) <<
T);
567 if (CheckQualifiedFunctionForTypeId(
T, TypeidLoc))
579 bool WasEvaluated =
false;
589 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
593 if (RequireCompleteType(TypeidLoc,
T, diag::err_incomplete_typeid))
601 if (isUnevaluatedContext()) {
604 ExprResult Result = TransformToPotentiallyEvaluated(E);
605 if (Result.isInvalid())
611 MarkVTableUsed(TypeidLoc, RecordD);
616 ExprResult Result = CheckUnevaluatedOperand(E);
617 if (Result.isInvalid())
630 E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->
getValueKind()).get();
635 return ExprError(
Diag(TypeidLoc, diag::err_variably_modified_typeid)
637 else if (!inTemplateInstantiation() &&
642 ? diag::warn_side_effects_typeid
643 : diag::warn_side_effects_unevaluated_context);
655 if (getLangOpts().OpenCLCPlusPlus) {
656 return ExprError(
Diag(OpLoc, diag::err_openclcxx_not_supported)
661 if (!getStdNamespace())
662 return ExprError(
Diag(OpLoc, diag::err_need_header_before_typeid));
664 if (!CXXTypeInfoDecl) {
665 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get(
"type_info");
667 LookupQualifiedName(R, getStdNamespace());
671 if (!CXXTypeInfoDecl && LangOpts.MSVCCompat) {
675 if (!CXXTypeInfoDecl)
676 return ExprError(
Diag(OpLoc, diag::err_need_header_before_typeid));
679 if (!getLangOpts().RTTI) {
680 return ExprError(
Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));
696 return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);
701 BuildCXXTypeId(TypeInfoType, OpLoc, (
Expr *)TyOrExpr, RParenLoc);
703 if (!getLangOpts().RTTIData && !Result.isInvalid())
704 if (
auto *CTE = dyn_cast<CXXTypeidExpr>(Result.get()))
705 if (CTE->isPotentiallyEvaluated() && !CTE->isMostDerived(Context))
706 Diag(OpLoc, diag::warn_no_typeid_with_rtti_disabled)
707 << (getDiagnostics().getDiagnosticOptions().getFormat() ==
728 if (
const auto *Uuid = TD->getMostRecentDecl()->getAttr<UuidAttr>()) {
729 UuidAttrs.insert(Uuid);
734 if (
const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
737 const UuidAttr *UuidForTA =
nullptr;
744 UuidAttrs.insert(UuidForTA);
755 if (!Operand->getType()->isDependentType()) {
758 if (UuidAttrs.empty())
759 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_without_guid));
760 if (UuidAttrs.size() > 1)
761 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
762 Guid = UuidAttrs.back()->getGuidDecl();
780 if (UuidAttrs.empty())
781 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_without_guid));
782 if (UuidAttrs.size() > 1)
783 return ExprError(
Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
784 Guid = UuidAttrs.back()->getGuidDecl();
810 return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc);
814 return BuildCXXUuidof(GuidType, OpLoc, (
Expr*)TyOrExpr, RParenLoc);
820 assert((
Kind == tok::kw_true ||
Kind == tok::kw_false) &&
821 "Unknown C++ Boolean value!");
835 bool IsThrownVarInScope =
false;
848 if (
const auto *DRE = dyn_cast<DeclRefExpr>(Ex->
IgnoreParens()))
849 if (
const auto *Var = dyn_cast<VarDecl>(DRE->getDecl());
850 Var && Var->hasLocalStorage() &&
851 !Var->getType().isVolatileQualified()) {
852 for (; S; S = S->getParent()) {
853 if (S->isDeclScope(Var)) {
854 IsThrownVarInScope =
true;
867 return BuildCXXThrow(OpLoc, Ex, IsThrownVarInScope);
871 bool IsThrownVarInScope) {
873 const bool IsOpenMPGPUTarget =
874 getLangOpts().OpenMPIsTargetDevice && (
T.isNVPTX() ||
T.isAMDGCN());
877 if (!IsOpenMPGPUTarget && !getLangOpts().CXXExceptions &&
878 !getSourceManager().isInSystemHeader(OpLoc) && !getLangOpts().CUDA) {
880 targetDiag(OpLoc, diag::err_exceptions_disabled) <<
"throw";
884 if (IsOpenMPGPUTarget)
885 targetDiag(OpLoc, diag::warn_throw_not_valid_on_target) <<
T.str();
888 if (getLangOpts().
CUDA)
889 CUDA().DiagIfDeviceCode(OpLoc, diag::err_cuda_device_exceptions)
890 <<
"throw" << llvm::to_underlying(
CUDA().CurrentTarget());
893 if (getLangOpts().SYCLIsDevice)
894 SYCL().DiagIfDeviceCode(OpLoc, diag::err_sycl_restrict)
897 if (getCurScope() && getCurScope()->isOpenMPSimdDirectiveScope())
898 Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) <<
"throw";
901 if (getLangOpts().OpenACC && getCurScope() &&
903 Diag(OpLoc, diag::err_acc_branch_in_out_compute_construct)
926 if (CheckCXXThrowOperand(OpLoc, ExceptionObjectTy, Ex))
931 ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRInfo, Ex);
947 llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,
948 llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,
949 llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,
950 bool ParentIsPublic) {
952 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
957 NewSubobject = VBases.insert(BaseDecl).second;
962 ++SubobjectsSeen[BaseDecl];
965 bool PublicPath = ParentIsPublic && BS.getAccessSpecifier() ==
AS_public;
967 PublicSubobjectsSeen.insert(BaseDecl);
977 llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;
978 llvm::SmallSet<CXXRecordDecl *, 2> VBases;
979 llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;
980 SubobjectsSeen[RD] = 1;
981 PublicSubobjectsSeen.insert(RD);
985 for (
CXXRecordDecl *PublicSubobject : PublicSubobjectsSeen) {
987 if (SubobjectsSeen[PublicSubobject] > 1)
990 Objects.push_back(PublicSubobject);
1000 bool isPointer =
false;
1019 if (RequireCompleteType(ThrowLoc, Ty,
1020 isPointer ? diag::err_throw_incomplete_ptr
1021 : diag::err_throw_incomplete,
1030 if (RequireNonAbstractType(ThrowLoc, ExceptionObjectTy,
1031 diag::err_throw_abstract_type, E))
1042 MarkVTableUsed(ThrowLoc, RD);
1051 MarkFunctionReferenced(E->
getExprLoc(), Destructor);
1052 CheckDestructorAccess(E->
getExprLoc(), Destructor,
1053 PDiag(diag::err_access_dtor_exception) << Ty);
1054 if (DiagnoseUseOfDecl(Destructor, E->
getExprLoc()))
1069 for (
CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {
1096 for (
unsigned I = 1, E = CD->
getNumParams(); I != E; ++I) {
1097 if (CheckCXXDefaultArgExpr(ThrowLoc, CD, CD->
getParamDecl(I)))
1110 if (ExnObjAlign < TypeAlign) {
1111 Diag(ThrowLoc, diag::warn_throw_underaligned_obj);
1112 Diag(ThrowLoc, diag::note_throw_underaligned_obj)
1117 if (!isPointer && getLangOpts().AssumeNothrowExceptionDtor) {
1119 auto Ty = Dtor->getType();
1123 Diag(ThrowLoc, diag::err_throw_object_throwing_dtor) << RD;
1175 for (
int I = FunctionScopes.size();
1176 I-- && isa<LambdaScopeInfo>(FunctionScopes[I]) &&
1178 cast<LambdaScopeInfo>(FunctionScopes[I])->CallOperator);
1180 CurLSI = cast<LambdaScopeInfo>(FunctionScopes[I]);
1187 if (C.isCopyCapture()) {
1199 "While computing 'this' capture-type for a generic lambda, when we "
1200 "run out of enclosing LSI's, yet the enclosing DC is a "
1201 "lambda-call-operator we must be (i.e. Current LSI) in a generic "
1202 "lambda call oeprator");
1205 auto IsThisCaptured =
1209 for (
auto &&C : Closure->
captures()) {
1210 if (C.capturesThis()) {
1221 bool IsByCopyCapture =
false;
1222 bool IsConstCapture =
false;
1225 IsThisCaptured(Closure, IsByCopyCapture, IsConstCapture)) {
1226 if (IsByCopyCapture) {
1241 QualType ThisTy = CXXThisTypeOverride;
1244 if (method && method->isImplicitObjectMemberFunction())
1245 ThisTy = method->getThisType().getNonReferenceType();
1249 inTemplateInstantiation() && isa<CXXRecordDecl>(DC)) {
1265 CurContext, Context);
1273 : S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(
false)
1275 if (!Enabled || !ContextDecl)
1280 Record = Template->getTemplatedDecl();
1282 Record = cast<CXXRecordDecl>(ContextDecl);
1290 this->Enabled =
true;
1307 Sema.
Diag(DiagLoc, diag::note_lambda_this_capture_fixit)
1313 bool BuildAndDiagnose,
const unsigned *
const FunctionScopeIndexToStopAt,
1314 const bool ByCopy) {
1319 assert((!ByCopy || Explicit) &&
"cannot implicitly capture *this by value");
1321 const int MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
1322 ? *FunctionScopeIndexToStopAt
1348 unsigned NumCapturingClosures = 0;
1349 for (
int idx = MaxFunctionScopesIndex; idx >= 0; idx--) {
1352 if (CSI->CXXThisCaptureIndex != 0) {
1354 CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed(BuildAndDiagnose);
1360 if (BuildAndDiagnose) {
1362 Diag(
Loc, diag::err_this_capture)
1363 << (Explicit && idx == MaxFunctionScopesIndex);
1373 (Explicit && idx == MaxFunctionScopesIndex)) {
1379 NumCapturingClosures++;
1383 if (BuildAndDiagnose) {
1385 Diag(
Loc, diag::err_this_capture)
1386 << (Explicit && idx == MaxFunctionScopesIndex);
1394 if (!BuildAndDiagnose)
return false;
1407 "Only a lambda can capture the enclosing object (referred to by "
1410 for (
int idx = MaxFunctionScopesIndex; NumCapturingClosures;
1411 --idx, --NumCapturingClosures) {
1418 bool isNested = NumCapturingClosures > 1;
1452 const auto *Method = dyn_cast<CXXMethodDecl>(DC);
1453 if (Method && Method->isExplicitObjectMemberFunction()) {
1454 Diag(
Loc, diag::err_invalid_this_use) << 1;
1456 Diag(
Loc, diag::err_invalid_this_use) << 1;
1458 Diag(
Loc, diag::err_invalid_this_use) << 0;
1472 if (
This->isTypeDependent())
1477 auto IsDependent = [&]() {
1479 auto *LSI = dyn_cast<sema::LambdaScopeInfo>(
Scope);
1483 if (LSI->Lambda && !LSI->Lambda->Encloses(
CurContext) &&
1484 LSI->AfterParameterList)
1491 if (LSI->isCXXThisCaptured()) {
1492 if (!LSI->getCXXThisCapture().isCopyCapture())
1495 const auto *MD = LSI->CallOperator;
1496 if (MD->getType().isNull())
1500 return Ty && MD->isExplicitObjectMemberFunction() &&
1507 This->setCapturedByCopyInLambdaWithExplicitObjectParameter(IsDependent);
1531 bool ListInitialization) {
1541 RParenOrBraceLoc, ListInitialization);
1545 if (!Result.isInvalid() && Result.get()->isInstantiationDependent() &&
1546 !Result.get()->isTypeDependent())
1548 else if (Result.isInvalid())
1550 RParenOrBraceLoc, exprs, Ty);
1559 bool ListInitialization) {
1568 ? ListInitialization
1570 TyBeginLoc, LParenOrBraceLoc, RParenOrBraceLoc)
1584 isa<DeducedTemplateSpecializationType>(Deduced)) {
1590 }
else if (Deduced && !Deduced->
isDeduced()) {
1592 if (ListInitialization) {
1593 auto *ILE = cast<InitListExpr>(Exprs[0]);
1594 Inits =
MultiExprArg(ILE->getInits(), ILE->getNumInits());
1598 return ExprError(
Diag(TyBeginLoc, diag::err_auto_expr_init_no_expression)
1599 << Ty << FullRange);
1600 if (Inits.size() > 1) {
1601 Expr *FirstBad = Inits[1];
1603 diag::err_auto_expr_init_multiple_expressions)
1604 << Ty << FullRange);
1608 Diag(TyBeginLoc, diag::warn_cxx20_compat_auto_expr) << FullRange;
1610 Expr *Deduce = Inits[0];
1611 if (isa<InitListExpr>(Deduce))
1614 << ListInitialization << Ty << FullRange);
1621 return ExprError(
Diag(TyBeginLoc, diag::err_auto_expr_deduction_failure)
1622 << Ty << Deduce->
getType() << FullRange
1636 RParenOrBraceLoc, ListInitialization);
1642 if (Exprs.size() == 1 && !ListInitialization &&
1643 !isa<InitListExpr>(Exprs[0])) {
1644 Expr *Arg = Exprs[0];
1652 if (!ListInitialization)
1653 return ExprError(
Diag(TyBeginLoc, diag::err_value_init_for_array_type)
1663 return ExprError(
Diag(TyBeginLoc, diag::err_init_for_function_type)
1664 << Ty << FullRange);
1671 diag::err_invalid_incomplete_type_use, FullRange))
1679 if (Result.isInvalid())
1682 Expr *Inner = Result.get();
1684 Inner = BTE->getSubExpr();
1685 if (
auto *CE = dyn_cast<ConstantExpr>(Inner);
1686 CE && CE->isImmediateInvocation())
1687 Inner = CE->getSubExpr();
1688 if (!isa<CXXTemporaryObjectExpr>(Inner) &&
1689 !isa<CXXScalarValueInitExpr>(Inner)) {
1698 QualType ResultType = Result.get()->getType();
1701 :
SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
1723 for (
const auto *D : R) {
1724 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
1741 return llvm::none_of(PreventedBy, [&](
const FunctionDecl *FD) {
1743 "Only single-operand functions should be in PreventedBy");
1758 unsigned UsualParams = 1;
1760 if (S.
getLangOpts().SizedDeallocation && UsualParams < FD->getNumParams() &&
1766 if (S.
getLangOpts().AlignedAllocation && UsualParams < FD->getNumParams() &&
1776 struct UsualDeallocFnInfo {
1777 UsualDeallocFnInfo() : Found(), FD(nullptr) {}
1779 : Found(Found), FD(dyn_cast<
FunctionDecl>(Found->getUnderlyingDecl())),
1785 unsigned NumBaseParams = 1;
1786 if (FD->isDestroyingOperatorDelete()) {
1791 if (NumBaseParams < FD->getNumParams() &&
1793 FD->getParamDecl(NumBaseParams)->getType(),
1799 if (NumBaseParams < FD->getNumParams() &&
1800 FD->getParamDecl(NumBaseParams)->getType()->isAlignValT()) {
1802 HasAlignValT =
true;
1811 explicit operator bool()
const {
return FD; }
1813 bool isBetterThan(
const UsualDeallocFnInfo &Other,
bool WantSize,
1814 bool WantAlign)
const {
1818 if (Destroying !=
Other.Destroying)
1825 if (HasAlignValT !=
Other.HasAlignValT)
1826 return HasAlignValT == WantAlign;
1828 if (HasSizeT !=
Other.HasSizeT)
1829 return HasSizeT == WantSize;
1832 return CUDAPref >
Other.CUDAPref;
1837 bool Destroying, HasSizeT, HasAlignValT;
1857 UsualDeallocFnInfo Best;
1859 for (
auto I = R.
begin(), E = R.
end(); I != E; ++I) {
1860 UsualDeallocFnInfo Info(S, I.getPair());
1868 BestFns->push_back(Info);
1872 if (Best.isBetterThan(Info, WantSize, WantAlign))
1877 if (BestFns && Info.isBetterThan(Best, WantSize, WantAlign))
1882 BestFns->push_back(Info);
1896 if (!record)
return false;
1909 if (ops.
empty())
return false;
1921 return Best && Best.HasSizeT;
1945 std::optional<Expr *> ArraySize;
1972 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {
1987 NumElts,
nullptr, diag::err_new_array_nonconst,
AllowFold)
2004 DirectInitRange = List->getSourceRange();
2007 PlacementLParen, PlacementArgs, PlacementRParen,
2008 TypeIdParens, AllocType, TInfo, ArraySize, DirectInitRange,
2013 Expr *Init,
bool IsCPlusPlus20) {
2017 return IsCPlusPlus20 || PLE->getNumExprs() == 0;
2018 if (isa<ImplicitValueInitExpr>(Init))
2021 return !CCE->isListInitialization() &&
2022 CCE->getConstructor()->isDefaultConstructor();
2024 assert(isa<InitListExpr>(Init) &&
2025 "Shouldn't create list CXXConstructExprs for arrays.");
2037 std::optional<unsigned> AlignmentParam;
2050 StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling(
2055 bool IsDelete =
Kind == OO_Delete ||
Kind == OO_Array_Delete;
2056 Diag(
Loc, diag::err_aligned_allocation_unavailable)
2058 << OSVersion.getAsString() << OSVersion.empty();
2059 Diag(
Loc, diag::note_silence_aligned_allocation_unavailable);
2069 std::optional<Expr *> ArraySize,
2075 if (DirectInitRange.
isValid()) {
2076 assert(
Initializer &&
"Have parens but no initializer.");
2083 "Initializer expression that cannot have been implicitly created.");
2090 "paren init for non-call init");
2091 Exprs =
MultiExprArg(List->getExprs(), List->getNumExprs());
2098 switch (InitStyle) {
2109 DirectInitRange.
getEnd());
2115 llvm_unreachable(
"Unknown initialization kind");
2120 if (Deduced && !Deduced->isDeduced() &&
2121 isa<DeducedTemplateSpecializationType>(Deduced)) {
2124 Diag(*ArraySize ? (*ArraySize)->getExprLoc() : TypeRange.
getBegin(),
2125 diag::err_deduced_class_template_compound_type)
2127 << (*ArraySize ? (*ArraySize)->getSourceRange() : TypeRange));
2132 AllocTypeInfo, Entity,
Kind, Exprs);
2135 }
else if (Deduced && !Deduced->isDeduced()) {
2139 auto *ILE = cast<InitListExpr>(Exprs[0]);
2140 Inits =
MultiExprArg(ILE->getInits(), ILE->getNumInits());
2144 return ExprError(
Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
2145 << AllocType << TypeRange);
2146 if (Inits.size() > 1) {
2147 Expr *FirstBad = Inits[1];
2149 diag::err_auto_new_ctor_multiple_expressions)
2150 << AllocType << TypeRange);
2154 << AllocType << TypeRange;
2155 Expr *Deduce = Inits[0];
2156 if (isa<InitListExpr>(Deduce))
2159 << Braced << AllocType << TypeRange);
2166 return ExprError(
Diag(StartLoc, diag::err_auto_new_deduction_failure)
2167 << AllocType << Deduce->
getType() << TypeRange
2184 AllocType =
Array->getElementType();
2204 if (ArraySize && *ArraySize &&
2205 (*ArraySize)->getType()->isNonOverloadPlaceholderType()) {
2208 ArraySize = result.
get();
2217 std::optional<uint64_t> KnownArraySize;
2218 if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {
2227 (*ArraySize)->getType()->getAs<
RecordType>())
2229 Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion)
2230 << (*ArraySize)->getType() << 0 <<
"'size_t'";
2237 SizeConvertDiagnoser(
Expr *ArraySize)
2239 ArraySize(ArraySize) {}
2243 return S.
Diag(
Loc, diag::err_array_size_not_integral)
2249 return S.
Diag(
Loc, diag::err_array_size_incomplete_type)
2255 return S.
Diag(
Loc, diag::err_array_size_explicit_conversion) <<
T << ConvTy;
2266 return S.
Diag(
Loc, diag::err_array_size_ambiguous_conversion) <<
T;
2280 ? diag::warn_cxx98_compat_array_size_conversion
2281 : diag::ext_array_size_conversion)
2284 } SizeDiagnoser(*ArraySize);
2292 ArraySize = ConvertedSize.
get();
2293 QualType SizeType = (*ArraySize)->getType();
2311 if (std::optional<llvm::APSInt>
Value =
2312 (*ArraySize)->getIntegerConstantExpr(
Context)) {
2313 if (
Value->isSigned() &&
Value->isNegative()) {
2315 diag::err_typecheck_negative_array_size)
2316 << (*ArraySize)->getSourceRange());
2320 unsigned ActiveSizeBits =
2324 Diag((*ArraySize)->getBeginLoc(), diag::err_array_too_large)
2328 KnownArraySize =
Value->getZExtValue();
2329 }
else if (TypeIdParens.
isValid()) {
2331 Diag((*ArraySize)->getBeginLoc(), diag::ext_new_paren_array_nonconst)
2332 << (*ArraySize)->getSourceRange()
2345 unsigned Alignment =
2348 bool PassAlignment =
getLangOpts().AlignedAllocation &&
2349 Alignment > NewAlignment;
2359 AllocType, ArraySize.has_value(), PassAlignment, PlacementArgs,
2360 OperatorNew, OperatorDelete))
2365 bool UsualArrayDeleteWantsSize =
false;
2367 UsualArrayDeleteWantsSize =
2380 unsigned NumImplicitArgs = PassAlignment ? 2 : 1;
2382 NumImplicitArgs, PlacementArgs, AllPlaceArgs,
2386 if (!AllPlaceArgs.empty())
2387 PlacementArgs = AllPlaceArgs;
2401 std::optional<llvm::APInt> AllocationSize;
2404 AllocationSize = SingleEltSize;
2408 AllocationSize =
llvm::APInt(SizeTyWidth, *KnownArraySize)
2409 .umul_ov(SingleEltSize, Overflow);
2413 "Expected that all the overflows would have been handled already.");
2417 Context, AllocationSize.value_or(llvm::APInt::getZero(SizeTyWidth)),
2436 CK_IntegralCast, &AlignmentLiteral,
2441 CallArgs.reserve(NumImplicitArgs + PlacementArgs.size());
2442 CallArgs.emplace_back(AllocationSize
2443 ?
static_cast<Expr *
>(&AllocationSizeLiteral)
2444 : &OpaqueAllocationSize);
2446 CallArgs.emplace_back(&DesiredAlignment);
2447 CallArgs.insert(CallArgs.end(), PlacementArgs.begin(), PlacementArgs.end());
2451 checkCall(OperatorNew, Proto,
nullptr, CallArgs,
2452 false, StartLoc,
Range, CallType);
2456 if (PlacementArgs.empty() && !PassAlignment &&
2460 if (Alignment > NewAlignment)
2461 Diag(StartLoc, diag::warn_overaligned_type)
2473 SourceRange InitRange(Exprs.front()->getBeginLoc(),
2474 Exprs.back()->getEndLoc());
2475 Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
2495 InitType = AllocType;
2508 dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.
get()))
2509 FullInit = Binder->getSubExpr();
2516 if (ArraySize && !*ArraySize) {
2524 Diag(TypeRange.
getEnd(), diag::err_new_array_size_unknown_from_init)
2540 if (OperatorDelete) {
2547 PassAlignment, UsualArrayDeleteWantsSize,
2548 PlacementArgs, TypeIdParens, ArraySize, InitStyle,
2560 return Diag(
Loc, diag::err_bad_new_type)
2561 << AllocType << 0 << R;
2563 return Diag(
Loc, diag::err_bad_new_type)
2564 << AllocType << 1 << R;
2567 Loc, AllocType, diag::err_new_incomplete_or_sizeless_type, R))
2570 diag::err_allocation_of_abstract_type))
2573 return Diag(
Loc, diag::err_variably_modified_new_type)
2577 return Diag(
Loc, diag::err_address_space_qualified_new)
2585 return Diag(
Loc, diag::err_arc_new_array_without_ownership)
2600 Alloc != AllocEnd; ++Alloc) {
2637 if (PassAlignment) {
2638 PassAlignment =
false;
2640 Args.erase(Args.begin() + 1);
2642 Operator, &Candidates, AlignArg,
2668 (Args[1]->getType()->isObjectPointerType() ||
2669 Args[1]->getType()->isArrayType())) {
2670 S.
Diag(R.
getNameLoc(), diag::err_need_header_before_placement_new)
2685 if (AlignedCandidates) {
2687 return C.Function->getNumParams() > 1 &&
2688 C.Function->getParamDecl(1)->getType()->isAlignValT();
2692 AlignedArgs.reserve(Args.size() + 1);
2693 AlignedArgs.push_back(Args[0]);
2694 AlignedArgs.push_back(AlignArg);
2695 AlignedArgs.append(Args.begin() + 1, Args.end());
2708 if (AlignedCandidates)
2709 AlignedCandidates->
NoteCandidates(S, AlignedArgs, AlignedCands,
"",
2719 S.
PDiag(diag::err_ovl_ambiguous_call)
2728 Candidates, Best->Function, Args);
2732 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
2754 AllocArgs.reserve((PassAlignment ? 2 : 1) + PlaceArgs.size());
2764 AllocArgs.push_back(&Size);
2767 if (PassAlignment) {
2773 AllocArgs.push_back(&Align);
2775 AllocArgs.insert(AllocArgs.end(), PlaceArgs.begin(), PlaceArgs.end());
2784 IsArray ? OO_Array_New : OO_New);
2816 if (PlaceArgs.empty()) {
2817 Diag(StartLoc, diag::err_openclcxx_not_supported) <<
"default new";
2819 Diag(StartLoc, diag::err_openclcxx_placement_new);
2824 assert(!R.
empty() &&
"implicitly declared allocation functions not found");
2825 assert(!R.
isAmbiguous() &&
"global allocation functions are ambiguous");
2831 OperatorNew,
nullptr,
2838 OperatorDelete =
nullptr;
2873 while (
Filter.hasNext()) {
2874 auto *FD = dyn_cast<FunctionDecl>(
Filter.next()->getUnderlyingDecl());
2875 if (FD && FD->isDestroyingOperatorDelete())
2881 bool FoundGlobalDelete = FoundDelete.
empty();
2882 if (FoundDelete.
empty()) {
2909 bool isPlacementNew = !PlaceArgs.empty() || OperatorNew->
param_size() != 1 ||
2912 if (isPlacementNew) {
2929 for (
unsigned I = 1, N = Proto->getNumParams(); I < N; ++I)
2930 ArgTypes.push_back(Proto->getParamType(I));
2934 EPI.
Variadic = Proto->isVariadic();
2936 ExpectedFunctionType
2941 DEnd = FoundDelete.
end();
2945 dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
2953 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
2956 ExpectedFunctionType,
2958 ExpectedFunctionType))
2959 Matches.push_back(std::make_pair(D.getPair(), Fn));
2975 *
this, FoundDelete, FoundGlobalDelete,
2979 Matches.push_back(std::make_pair(Selected.Found, Selected.FD));
2983 for (
auto Fn : BestDeallocFns)
2984 Matches.push_back(std::make_pair(Fn.Found, Fn.FD));
2992 if (Matches.size() == 1) {
2993 OperatorDelete = Matches[0].second;
3003 UsualDeallocFnInfo Info(*
this,
3009 bool IsSizedDelete = Info.HasSizeT;
3010 if (IsSizedDelete && !FoundGlobalDelete) {
3011 auto NonSizedDelete =
3014 if (NonSizedDelete && !NonSizedDelete.HasSizeT &&
3015 NonSizedDelete.HasAlignValT == Info.HasAlignValT)
3016 IsSizedDelete =
false;
3019 if (IsSizedDelete) {
3023 PlaceArgs.back()->getEndLoc());
3024 Diag(StartLoc, diag::err_placement_new_non_placement_delete) << R;
3033 }
else if (!Matches.empty()) {
3037 Diag(StartLoc, diag::warn_ambiguous_suitable_delete_function_found)
3038 << DeleteName << AllocElemType;
3040 for (
auto &Match : Matches)
3041 Diag(Match.second->getLocation(),
3042 diag::note_member_declared_here) << DeleteName;
3129 if (TheGlobalModuleFragment) {
3144 if (TheGlobalModuleFragment) {
3145 AlignValT->setModuleOwnershipKind(
3147 AlignValT->setLocalOwningModule(TheGlobalModuleFragment);
3152 AlignValT->setImplicit(
true);
3165 Params.push_back(Param);
3168 bool HasSizedVariant =
getLangOpts().SizedDeallocation &&
3169 (
Kind == OO_Delete ||
Kind == OO_Array_Delete);
3170 bool HasAlignedVariant =
getLangOpts().AlignedAllocation;
3172 int NumSizeVariants = (HasSizedVariant ? 2 : 1);
3173 int NumAlignVariants = (HasAlignedVariant ? 2 : 1);
3174 for (
int Sized = 0; Sized < NumSizeVariants; ++Sized) {
3176 Params.push_back(SizeT);
3178 for (
int Aligned = 0; Aligned < NumAlignVariants; ++Aligned) {
3191 DeclareGlobalAllocationFunctions(OO_New, VoidPtr, SizeT);
3192 DeclareGlobalAllocationFunctions(OO_Array_New, VoidPtr, SizeT);
3193 DeclareGlobalAllocationFunctions(OO_Delete,
Context.
VoidTy, VoidPtr);
3194 DeclareGlobalAllocationFunctions(OO_Array_Delete,
Context.
VoidTy, VoidPtr);
3197 PopGlobalModuleFragment();
3210 Alloc != AllocEnd; ++Alloc) {
3214 if (
Func->getNumParams() == Params.size()) {
3216 for (
auto *
P :
Func->parameters())
3217 FuncParams.push_back(
3223 Func->setVisibleDespiteOwningModule();
3231 false,
false,
true));
3234 bool HasBadAllocExceptionSpec
3235 = (Name.getCXXOverloadedOperator() == OO_New ||
3236 Name.getCXXOverloadedOperator() == OO_Array_New);
3237 if (HasBadAllocExceptionSpec) {
3240 assert(
StdBadAlloc &&
"Must have std::bad_alloc declared");
3252 auto CreateAllocationFunctionDecl = [&](
Attr *ExtraAttr) {
3262 if (HasBadAllocExceptionSpec &&
getLangOpts().NewInfallible &&
3277 if (TheGlobalModuleFragment) {
3284 Alloc->
addAttr(VisibilityAttr::CreateImplicit(
3286 ? VisibilityAttr::Hidden
3288 ? VisibilityAttr::Protected
3289 : VisibilityAttr::Default));
3296 ParamDecls.back()->setImplicit();
3298 Alloc->setParams(ParamDecls);
3307 CreateAllocationFunctionDecl(
nullptr);
3311 CreateAllocationFunctionDecl(CUDAHostAttr::CreateImplicit(
Context));
3312 CreateAllocationFunctionDecl(CUDADeviceAttr::CreateImplicit(
Context));
3317 bool CanProvideSize,
3331 assert(Result.FD &&
"operator delete missing from global scope?");
3343 return OperatorDelete;
3355 bool WantSize,
bool WantAligned) {
3373 Overaligned, &Matches);
3376 if (Matches.size() == 1) {
3377 Operator = cast<CXXMethodDecl>(Matches[0].FD);
3383 Diag(StartLoc, diag::err_deleted_function_use)
3384 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef());
3400 if (!Matches.empty()) {
3402 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)
3404 for (
auto &Match : Matches)
3405 Diag(Match.FD->getLocation(), diag::note_member_declared_here) << Name;
3412 if (!Found.
empty()) {
3414 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
3418 Diag(D->getUnderlyingDecl()->getLocation(),
3419 diag::note_member_declared_here) << Name;
3431 class MismatchingNewDeleteDetector {
3433 enum MismatchResult {
3439 MemberInitMismatches,
3448 explicit MismatchingNewDeleteDetector(
bool EndOfTU)
3449 : Field(nullptr), IsArrayForm(
false), EndOfTU(EndOfTU),
3450 HasUndefinedConstructors(
false) {}
3467 MismatchResult analyzeField(
FieldDecl *Field,
bool DeleteWasArrayForm);
3477 bool HasUndefinedConstructors;
3489 MismatchResult analyzeMemberExpr(
const MemberExpr *ME);
3512 MismatchResult analyzeInClassInitializer();
3516 MismatchingNewDeleteDetector::MismatchResult
3517 MismatchingNewDeleteDetector::analyzeDeleteExpr(
const CXXDeleteExpr *DE) {
3519 assert(DE &&
"Expected delete-expression");
3522 if (
const MemberExpr *ME = dyn_cast<const MemberExpr>(E)) {
3523 return analyzeMemberExpr(ME);
3524 }
else if (
const DeclRefExpr *D = dyn_cast<const DeclRefExpr>(E)) {
3525 if (!hasMatchingVarInit(D))
3526 return VarInitMismatches;
3532 MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(
const Expr *E) {
3533 assert(E !=
nullptr &&
"Expected a valid initializer expression");
3535 if (
const InitListExpr *ILE = dyn_cast<const InitListExpr>(E)) {
3536 if (ILE->getNumInits() == 1)
3537 E = dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts());
3540 return dyn_cast_or_null<const CXXNewExpr>(E);
3543 bool MismatchingNewDeleteDetector::hasMatchingNewInCtorInit(
3547 (
NE = getNewExprFromInitListOrExpr(CI->
getInit()))) {
3548 if (
NE->isArray() == IsArrayForm)
3551 NewExprs.push_back(
NE);
3556 bool MismatchingNewDeleteDetector::hasMatchingNewInCtor(
3562 HasUndefinedConstructors =
true;
3565 for (
const auto *CI : cast<const CXXConstructorDecl>(Definition)->inits()) {
3566 if (hasMatchingNewInCtorInit(CI))
3572 MismatchingNewDeleteDetector::MismatchResult
3573 MismatchingNewDeleteDetector::analyzeInClassInitializer() {
3574 assert(Field !=
nullptr &&
"This should be called only for members");
3575 const Expr *InitExpr =
Field->getInClassInitializer();
3577 return EndOfTU ? NoMismatch : AnalyzeLater;
3578 if (
const CXXNewExpr *
NE = getNewExprFromInitListOrExpr(InitExpr)) {
3579 if (
NE->isArray() != IsArrayForm) {
3580 NewExprs.push_back(
NE);
3581 return MemberInitMismatches;
3587 MismatchingNewDeleteDetector::MismatchResult
3588 MismatchingNewDeleteDetector::analyzeField(
FieldDecl *Field,
3589 bool DeleteWasArrayForm) {
3590 assert(Field !=
nullptr &&
"Analysis requires a valid class member.");
3591 this->Field =
Field;
3592 IsArrayForm = DeleteWasArrayForm;
3594 for (
const auto *CD : RD->
ctors()) {
3595 if (hasMatchingNewInCtor(CD))
3598 if (HasUndefinedConstructors)
3599 return EndOfTU ? NoMismatch : AnalyzeLater;
3600 if (!NewExprs.empty())
3601 return MemberInitMismatches;
3602 return Field->hasInClassInitializer() ? analyzeInClassInitializer()
3606 MismatchingNewDeleteDetector::MismatchResult
3607 MismatchingNewDeleteDetector::analyzeMemberExpr(
const MemberExpr *ME) {
3608 assert(ME !=
nullptr &&
"Expected a member expression");
3610 return analyzeField(F, IsArrayForm);
3614 bool MismatchingNewDeleteDetector::hasMatchingVarInit(
const DeclRefExpr *D) {
3617 if (VD->hasInit() && (
NE = getNewExprFromInitListOrExpr(VD->getInit())) &&
3618 NE->isArray() != IsArrayForm) {
3619 NewExprs.push_back(
NE);
3622 return NewExprs.empty();
3627 const MismatchingNewDeleteDetector &Detector) {
3630 if (!Detector.IsArrayForm)
3639 SemaRef.
Diag(DeleteLoc, diag::warn_mismatched_delete_new)
3640 << Detector.IsArrayForm << H;
3642 for (
const auto *
NE : Detector.NewExprs)
3644 << Detector.IsArrayForm;
3647 void Sema::AnalyzeDeleteExprMismatch(
const CXXDeleteExpr *DE) {
3650 MismatchingNewDeleteDetector Detector(
false);
3651 switch (Detector.analyzeDeleteExpr(DE)) {
3652 case MismatchingNewDeleteDetector::VarInitMismatches:
3653 case MismatchingNewDeleteDetector::MemberInitMismatches: {
3657 case MismatchingNewDeleteDetector::AnalyzeLater: {
3662 case MismatchingNewDeleteDetector::NoMismatch:
3668 bool DeleteWasArrayForm) {
3669 MismatchingNewDeleteDetector Detector(
true);
3670 switch (Detector.analyzeField(Field, DeleteWasArrayForm)) {
3671 case MismatchingNewDeleteDetector::VarInitMismatches:
3672 llvm_unreachable(
"This analysis should have been done for class members.");
3673 case MismatchingNewDeleteDetector::AnalyzeLater:
3674 llvm_unreachable(
"Analysis cannot be postponed any point beyond end of "
3675 "translation unit.");
3676 case MismatchingNewDeleteDetector::MemberInitMismatches:
3679 case MismatchingNewDeleteDetector::NoMismatch:
3690 bool ArrayForm,
Expr *ExE) {
3700 bool ArrayFormAsWritten = ArrayForm;
3701 bool UsualArrayDeleteWantsSize =
false;
3719 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType())
3726 return S.
Diag(
Loc, diag::err_delete_operand) <<
T;
3731 return S.
Diag(
Loc, diag::err_delete_incomplete_class_type) <<
T;
3737 return S.
Diag(
Loc, diag::err_delete_explicit_conversion) <<
T << ConvTy;
3748 return S.
Diag(
Loc, diag::err_ambiguous_delete_operand) <<
T;
3760 llvm_unreachable(
"conversion functions are permitted");
3768 if (!Converter.match(
Type))
3779 diag::err_address_space_qualified_delete)
3788 Diag(StartLoc, diag::ext_delete_void_ptr_operand)
3798 diag::warn_delete_incomplete, Ex.
get())) {
3800 PointeeRD = cast<CXXRecordDecl>(RT->getDecl());
3805 Diag(StartLoc, diag::warn_delete_array_type)
3812 ArrayForm ? OO_Array_Delete : OO_Delete);
3826 UsualArrayDeleteWantsSize =
3831 else if (OperatorDelete && isa<CXXMethodDecl>(OperatorDelete))
3832 UsualArrayDeleteWantsSize =
3833 UsualDeallocFnInfo(*
this,
3852 if (!OperatorDelete) {
3854 Diag(StartLoc, diag::err_openclcxx_not_supported) <<
"default delete";
3859 bool CanProvideSize =
3860 IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||
3866 Overaligned, DeleteName);
3873 bool IsVirtualDelete =
false;
3877 PDiag(diag::err_access_dtor) << PointeeElem);
3878 IsVirtualDelete = Dtor->isVirtual();
3907 UsualArrayDeleteWantsSize, OperatorDelete, Ex.
get(), StartLoc);
3908 AnalyzeDeleteExprMismatch(Result);
3917 IsDelete ? OO_Delete : OO_New);
3921 assert(!R.
empty() &&
"implicitly declared allocation functions not found");
3922 assert(!R.
isAmbiguous() &&
"global allocation functions are ambiguous");
3931 FnOvl != FnOvlEnd; ++FnOvl) {
3934 NamedDecl *D = (*FnOvl)->getUnderlyingDecl();
3958 "class members should not be considered");
3961 S.
Diag(R.
getNameLoc(), diag::err_builtin_operator_new_delete_not_usual)
3962 << (IsDelete ? 1 : 0) <<
Range;
3963 S.
Diag(FnDecl->
getLocation(), diag::note_non_usual_function_declared_here)
3975 S.
PDiag(diag::err_ovl_no_viable_function_in_call)
3983 S.
PDiag(diag::err_ovl_ambiguous_call)
3990 Candidates, Best->Function, Args);
3993 llvm_unreachable(
"Unreachable, bad result from BestViableFunction");
3998 CallExpr *TheCall = cast<CallExpr>(TheCallResult.
get());
4001 << (IsDelete ?
"__builtin_operator_delete" :
"__builtin_operator_new")
4011 OperatorNewOrDelete))
4013 assert(OperatorNewOrDelete &&
"should be found");
4019 for (
unsigned i = 0; i != TheCall->
getNumArgs(); ++i) {
4030 assert(Callee &&
Callee->getCastKind() == CK_BuiltinFnToFnPtr &&
4031 "Callee expected to be implicit cast to a builtin function pointer");
4034 return TheCallResult;
4038 bool IsDelete,
bool CallCanBeVirtual,
4039 bool WarnOnNonAbstractTypes,
4066 Diag(
Loc, diag::warn_delete_abstract_non_virtual_dtor) << (IsDelete ? 0 : 1)
4068 }
else if (WarnOnNonAbstractTypes) {
4071 Diag(
Loc, diag::warn_delete_non_virtual_dtor) << (IsDelete ? 0 : 1)
4075 std::string TypeStr;
4077 Diag(DtorLoc, diag::note_delete_non_virtual)
4107 diag::err_invalid_use_of_function_type)
4111 diag::err_invalid_use_of_array_type)
4129 llvm_unreachable(
"unexpected condition kind");
4156 diag::err_constexpr_if_condition_expression_is_not_constant);
4168 From =
Cast->getSubExpr();
4180 if (!ToPtrType->getPointeeType().hasQualifiers()) {
4181 switch (StrLit->getKind()) {
4188 return (ToPointeeType->getKind() == BuiltinType::Char_U ||
4189 ToPointeeType->getKind() == BuiltinType::Char_S);
4194 assert(
false &&
"Unevaluated string literal in expression");
4209 bool HadMultipleCandidates,
4212 default: llvm_unreachable(
"Unhandled cast kind!");
4213 case CK_ConstructorConversion: {
4218 diag::err_allocation_of_abstract_type))
4231 CastLoc, Ty, FoundDecl, cast<CXXConstructorDecl>(Method),
4232 ConstructorArgs, HadMultipleCandidates,
4233 false,
false,
false,
4235 if (Result.isInvalid())
4241 case CK_UserDefinedConversion: {
4251 HadMultipleCandidates);
4252 if (Result.isInvalid())
4256 CK_UserDefinedConversion, Result.get(),
4257 nullptr, Result.get()->getValueKind(),
4295 assert(FD &&
"no conversion function for user-defined conversion seq");
4297 CastKind = CK_UserDefinedConversion;
4305 CastKind = CK_ConstructorConversion;
4333 From = CastArg.
get();
4347 PDiag(diag::err_typecheck_ambiguous_condition)
4353 llvm_unreachable(
"bad conversion");
4360 ToType, From->
getType(), From, Action);
4361 assert(Diagnosed &&
"failed to diagnose bad conversion"); (void)Diagnosed;
4401 false,
false,
false,
4408 false,
false,
false,
4441 ToAtomicType = ToType;
4442 ToType = ToAtomic->getValueType();
4445 QualType InitialFromType = FromType;
4447 switch (SCS.
First) {
4450 FromType = FromAtomic->getValueType().getUnqualifiedType();
4463 From = FromRes.
get();
4490 llvm_unreachable(
"Improper first standard conversion");
4527 "only enums with fixed underlying type can promote to bool");
4552 CK = CK_FloatingComplexCast;
4554 CK = CK_FloatingComplexToIntegralComplex;
4556 CK = CK_IntegralComplexToFloatingComplex;
4558 CK = CK_IntegralComplexCast;
4579 "Attempting implicit fixed point conversion without a fixed "
4584 nullptr, CCK).
get();
4588 nullptr, CCK).
get();
4592 nullptr, CCK).
get();
4596 nullptr, CCK).
get();
4600 nullptr, CCK).
get();
4604 nullptr, CCK).
get();
4609 nullptr, CCK).
get();
4618 diag::ext_typecheck_convert_incompatible_pointer)
4623 diag::ext_typecheck_convert_incompatible_pointer)
4630 }
else if (
getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
4631 !
ObjC().CheckObjCARCUnavailableWeakConversion(ToType,
4636 Diag(From->
getBeginLoc(), diag::err_arc_convesion_of_weak_unavailable)
4665 if (
Kind == CK_BlockPointerToObjCPointerCast) {
4719 &BasePath, CCK).
get();
4748 QualType ElType = ToComplex->getElementType();
4756 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).
get();
4760 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).
get();
4764 isFloatingComplex ? CK_FloatingRealToComplex
4765 : CK_IntegralRealToComplex).
get();
4770 QualType ElType = FromComplex->getElementType();
4775 isFloatingComplex ? CK_FloatingComplexToReal
4776 : CK_IntegralComplexToReal,
4785 isFloatingComplex ? CK_FloatingCast
4786 : CK_IntegralToFloating,
4792 isFloatingComplex ? CK_FloatingToIntegral
4808 AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
4821 From = FromRes.
get();
4823 "Improper transparent union conversion");
4831 CK_ZeroToOCLOpaqueType,
4839 "HLSL vector truncation should only apply to ExtVectors");
4842 QualType ElType = FromVec->getElementType();
4860 llvm_unreachable(
"Improper second standard conversion");
4869 "Element conversion for matrix types is not implemented yet.");
4871 "Element conversion is only supported for vector types.");
4874 "Element conversion is only supported for vectors with the same "
4884 FromType = FPExtType;
4898 "only enums with fixed underlying type can promote to bool");
4929 llvm_unreachable(
"Improper element standard conversion");
4933 switch (SCS.
Third) {
4956 CK = CK_AddressSpaceConversion;
4961 CK = CK_AddressSpaceConversion;
4967 << InitialFromType << ToType;
4978 ? diag::ext_deprecated_string_literal_conversion
4979 : diag::warn_deprecated_string_literal_conversion)
4987 llvm_unreachable(
"Improper third standard conversion");
4992 if (!ToAtomicType.
isNull()) {
5028 S.
Diag(
T->getTypeLoc().getBeginLoc(), diag::err_vla_unsupported)
5029 << 1 << TypeTraitID;
5052 default: llvm_unreachable(
"not a UTT");
5054 case UTT_IsCompleteType:
5062 case UTT_IsIntegral:
5063 case UTT_IsFloatingPoint:
5065 case UTT_IsBoundedArray:
5067 case UTT_IsNullPointer:
5068 case UTT_IsReferenceable:
5069 case UTT_IsLvalueReference:
5070 case UTT_IsRvalueReference:
5071 case UTT_IsMemberFunctionPointer:
5072 case UTT_IsMemberObjectPointer:
5074 case UTT_IsScopedEnum:
5077 case UTT_IsFunction:
5078 case UTT_IsReference:
5079 case UTT_IsArithmetic:
5080 case UTT_IsFundamental:
5083 case UTT_IsCompound:
5084 case UTT_IsMemberPointer:
5093 case UTT_IsVolatile:
5095 case UTT_IsUnboundedArray:
5096 case UTT_IsUnsigned:
5099 case UTT_IsInterfaceClass:
5105 case UTT_IsPolymorphic:
5106 case UTT_IsAbstract:
5110 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
5119 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
5123 case UTT_IsAggregate:
5128 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
5133 case UTT_IsTriviallyCopyable:
5134 case UTT_IsStandardLayout:
5139 case UTT_IsTriviallyRelocatable:
5140 case UTT_IsTriviallyEqualityComparable:
5141 case UTT_CanPassInRegs:
5145 case UTT_HasNothrowAssign:
5146 case UTT_HasNothrowMoveAssign:
5147 case UTT_HasNothrowConstructor:
5148 case UTT_HasNothrowCopy:
5149 case UTT_HasTrivialAssign:
5150 case UTT_HasTrivialMoveAssign:
5151 case UTT_HasTrivialDefaultConstructor:
5152 case UTT_HasTrivialMoveConstructor:
5153 case UTT_HasTrivialCopy:
5154 case UTT_HasTrivialDestructor:
5155 case UTT_HasVirtualDestructor:
5161 case UTT_IsDestructible:
5162 case UTT_IsNothrowDestructible:
5163 case UTT_IsTriviallyDestructible:
5164 case UTT_HasUniqueObjectRepresentations:
5169 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
5180 if ((RD->*HasTrivial)() && !(RD->*HasNonTrivial)())
5186 if (Self.LookupQualifiedName(Res, RD)) {
5187 bool FoundOperator =
false;
5190 Op != OpEnd; ++Op) {
5191 if (isa<FunctionTemplateDecl>(*Op))
5195 if((Operator->*IsDesiredOp)()) {
5196 FoundOperator =
true;
5198 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
5203 return FoundOperator;
5212 assert(!
T->
isDependentType() &&
"Cannot evaluate traits of dependent type");
5216 default: llvm_unreachable(
"not a UTT");
5221 case UTT_IsIntegral:
5223 case UTT_IsFloatingPoint:
5228 if (
const auto *CAT = C.getAsConstantArrayType(
T))
5229 return CAT->getSize() != 0;
5231 case UTT_IsBoundedArray:
5236 if (
const auto *CAT = C.getAsConstantArrayType(
T))
5237 return CAT->getSize() != 0;
5239 case UTT_IsUnboundedArray:
5245 case UTT_IsNullPointer:
5247 case UTT_IsLvalueReference:
5249 case UTT_IsRvalueReference:
5251 case UTT_IsMemberFunctionPointer:
5253 case UTT_IsMemberObjectPointer:
5257 case UTT_IsScopedEnum:
5263 case UTT_IsFunction:
5268 case UTT_IsReference:
5270 case UTT_IsArithmetic:
5272 case UTT_IsFundamental:
5282 switch (
T.getObjCLifetime()) {
5295 case UTT_IsCompound:
5297 case UTT_IsMemberPointer:
5303 return T.isConstQualified();
5304 case UTT_IsVolatile:
5305 return T.isVolatileQualified();
5307 return T.isTrivialType(C);
5308 case UTT_IsTriviallyCopyable:
5309 return T.isTriviallyCopyableType(C);
5310 case UTT_IsStandardLayout:
5313 return T.isPODType(C);
5320 case UTT_IsPolymorphic:
5324 case UTT_IsAbstract:
5328 case UTT_IsAggregate:
5337 case UTT_IsInterfaceClass:
5342 return RD->
hasAttr<FinalAttr>();
5349 case UTT_IsUnsigned:
5368 case UTT_HasTrivialDefaultConstructor:
5375 if (
CXXRecordDecl *RD = C.getBaseElementType(
T)->getAsCXXRecordDecl())
5379 case UTT_HasTrivialMoveConstructor:
5385 if (
CXXRecordDecl *RD = C.getBaseElementType(
T)->getAsCXXRecordDecl())
5388 case UTT_HasTrivialCopy:
5400 case UTT_HasTrivialMoveAssign:
5406 if (
CXXRecordDecl *RD = C.getBaseElementType(
T)->getAsCXXRecordDecl())
5409 case UTT_HasTrivialAssign:
5422 if (
T.isConstQualified())
5430 case UTT_IsDestructible:
5431 case UTT_IsTriviallyDestructible:
5432 case UTT_IsNothrowDestructible:
5451 if (UTT == UTT_IsTriviallyDestructible &&
T.isDestructedType())
5458 if (
auto *RD = C.getBaseElementType(
T)->getAsCXXRecordDecl()) {
5465 if (Destructor->isDeleted())
5467 if (C.getLangOpts().AccessControl && Destructor->getAccess() !=
AS_public)
5469 if (UTT == UTT_IsNothrowDestructible) {
5471 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
5478 case UTT_HasTrivialDestructor:
5493 if (
CXXRecordDecl *RD = C.getBaseElementType(
T)->getAsCXXRecordDecl())
5497 case UTT_HasNothrowAssign:
5505 if (C.getBaseElementType(
T).isConstQualified())
5518 case UTT_HasNothrowMoveAssign:
5531 case UTT_HasNothrowCopy:
5544 bool FoundConstructor =
false;
5546 for (
const auto *ND : Self.LookupConstructors(RD)) {
5550 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
5553 if (isa<UsingDecl>(ND))
5555 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
5556 if (Constructor->isCopyConstructor(FoundTQs)) {
5557 FoundConstructor =
true;
5559 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
5569 return FoundConstructor;
5572 case UTT_HasNothrowConstructor:
5580 if (
CXXRecordDecl *RD = C.getBaseElementType(
T)->getAsCXXRecordDecl()) {
5585 bool FoundConstructor =
false;
5586 for (
const auto *ND : Self.LookupConstructors(RD)) {
5588 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))
5591 if (isa<UsingDecl>(ND))
5593 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());
5594 if (Constructor->isDefaultConstructor()) {
5595 FoundConstructor =
true;
5597 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT);
5606 return FoundConstructor;
5609 case UTT_HasVirtualDestructor:
5615 return Destructor->isVirtual();
5621 case UTT_IsCompleteType:
5626 case UTT_HasUniqueObjectRepresentations:
5627 return C.hasUniqueObjectRepresentations(
T);
5628 case UTT_IsTriviallyRelocatable:
5629 return T.isTriviallyRelocatableType(C);
5630 case UTT_IsReferenceable:
5631 return T.isReferenceable();
5632 case UTT_CanPassInRegs:
5635 Self.Diag(KeyLoc, diag::err_builtin_pass_in_regs_non_class) <<
T;
5637 case UTT_IsTriviallyEqualityComparable:
5638 return T.isTriviallyEqualityComparableType(C);
5647 SourceLocation KeyLoc, llvm::BumpPtrAllocator &OpaqueExprAllocator) {
5688 LhsT = Self.Context.getRValueReferenceType(LhsT);
5729 Kind != BTT_ReferenceConstructsFromTemporary &&
5730 Kind != BTT_ReferenceConvertsFromTemporary)
5732 Args[1], RParenLoc);
5735 case clang::BTT_ReferenceBindsToTemporary:
5736 case clang::BTT_ReferenceConstructsFromTemporary:
5737 case clang::BTT_ReferenceConvertsFromTemporary:
5738 case clang::TT_IsConstructible:
5739 case clang::TT_IsNothrowConstructible:
5740 case clang::TT_IsTriviallyConstructible: {
5754 assert(!Args.empty());
5759 for (
const auto *TSI : Args) {
5765 diag::err_incomplete_type_used_in_type_trait_expr))
5779 llvm::BumpPtrAllocator OpaqueExprAllocator;
5781 ArgExprs.reserve(Args.size() - 1);
5782 for (
unsigned I = 1, N = Args.size(); I != N; ++I) {
5783 QualType ArgTy = Args[I]->getType();
5802 Kind == clang::BTT_ReferenceConvertsFromTemporary
5809 ExprResult Result = Init.Perform(S, To, InitKind, ArgExprs);
5813 if (
Kind == clang::TT_IsConstructible)
5816 if (
Kind == clang::BTT_ReferenceBindsToTemporary ||
5817 Kind == clang::BTT_ReferenceConstructsFromTemporary ||
5818 Kind == clang::BTT_ReferenceConvertsFromTemporary) {
5822 if (!Init.isDirectReferenceBinding())
5825 if (
Kind == clang::BTT_ReferenceBindsToTemporary)
5829 if (
U->isReferenceType())
5837 OpaqueExprAllocator)
5841 if (
Kind == clang::TT_IsNothrowConstructible)
5844 if (
Kind == clang::TT_IsTriviallyConstructible) {
5847 if (
T.getNonReferenceType().hasNonTrivialObjCLifetime())
5852 return !Result.get()->hasNonTrivialCall(S.
Context);
5855 llvm_unreachable(
"unhandled type trait");
5858 default: llvm_unreachable(
"not a TT");
5869 case UTT_HasNothrowAssign:
5870 case UTT_HasNothrowMoveAssign:
5871 Replacement = BTT_IsNothrowAssignable;
5873 case UTT_HasNothrowCopy:
5874 case UTT_HasNothrowConstructor:
5875 Replacement = TT_IsNothrowConstructible;
5877 case UTT_HasTrivialAssign:
5878 case UTT_HasTrivialMoveAssign:
5879 Replacement = BTT_IsTriviallyAssignable;
5881 case UTT_HasTrivialCopy:
5882 Replacement = UTT_IsTriviallyCopyable;
5884 case UTT_HasTrivialDefaultConstructor:
5885 case UTT_HasTrivialMoveConstructor:
5886 Replacement = TT_IsTriviallyConstructible;
5888 case UTT_HasTrivialDestructor:
5889 Replacement = UTT_IsTriviallyDestructible;
5894 S.
Diag(KWLoc, diag::warn_deprecated_builtin)
5900 if (Arity && N != Arity) {
5901 Diag(
Loc, diag::err_type_trait_arity)
5906 if (!Arity && N == 0) {
5907 Diag(
Loc, diag::err_type_trait_arity)
5929 *
this,
Kind, KWLoc, Args[0]->getType()))
5932 DiagnoseBuiltinDeprecation(*
this,
Kind, KWLoc);
5934 bool Dependent =
false;
5935 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
5936 if (Args[I]->getType()->isDependentType()) {
5947 KWLoc,
Kind, Args, RParenLoc, Result);
5950 llvm_unreachable(
"unhandled type trait return type");
5957 ConvertedArgs.reserve(Args.size());
5959 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
5965 ConvertedArgs.push_back(TInfo);
5977 "Cannot evaluate traits of dependent types");
5980 case BTT_IsBaseOf: {
5988 if (!rhsRecord || !lhsRecord) {
5991 if (!LHSObjTy || !RHSObjTy)
5996 if (!BaseInterface || !DerivedInterface)
5999 if (Self.RequireCompleteType(
6001 diag::err_incomplete_type_used_in_type_trait_expr))
6007 assert(Self.Context.hasSameUnqualifiedType(LhsT, RhsT)
6008 == (lhsRecord == rhsRecord));
6014 if (rhsRecord && rhsRecord->getDecl()->isUnion())
6017 if (lhsRecord == rhsRecord)
6024 if (Self.RequireCompleteType(
6026 diag::err_incomplete_type_used_in_type_trait_expr))
6029 return cast<CXXRecordDecl>(rhsRecord->getDecl())
6030 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->
getDecl()));
6033 return Self.Context.hasSameType(LhsT, RhsT);
6034 case BTT_TypeCompatible: {
6037 QualType Lhs = Self.getASTContext().getUnqualifiedArrayType(LhsT, LhsQuals);
6038 QualType Rhs = Self.getASTContext().getUnqualifiedArrayType(RhsT, RhsQuals);
6039 return Self.Context.typesAreCompatible(Lhs, Rhs);
6041 case BTT_IsConvertible:
6042 case BTT_IsConvertibleTo:
6043 case BTT_IsNothrowConvertible: {
6046 llvm::BumpPtrAllocator OpaqueExprAllocator;
6048 OpaqueExprAllocator);
6049 if (Result.isInvalid())
6052 if (BTT != BTT_IsNothrowConvertible)
6055 return Self.canThrow(Result.get()) ==
CT_Cannot;
6058 case BTT_IsAssignable:
6059 case BTT_IsNothrowAssignable:
6060 case BTT_IsTriviallyAssignable: {
6073 Self.RequireCompleteType(
6075 diag::err_incomplete_type_used_in_type_trait_expr))
6078 Self.RequireCompleteType(
6080 diag::err_incomplete_type_used_in_type_trait_expr))
6090 LhsT = Self.Context.getRValueReferenceType(LhsT);
6092 RhsT = Self.Context.getRValueReferenceType(RhsT);
6104 ExprResult Result = Self.BuildBinOp(
nullptr, KeyLoc, BO_Assign, &Lhs,
6106 if (Result.isInvalid())
6110 Self.CheckUnusedVolatileAssignment(Result.get());
6115 if (BTT == BTT_IsAssignable)
6118 if (BTT == BTT_IsNothrowAssignable)
6119 return Self.canThrow(Result.get()) ==
CT_Cannot;
6121 if (BTT == BTT_IsTriviallyAssignable) {
6127 return !Result.get()->hasNonTrivialCall(Self.Context);
6130 llvm_unreachable(
"unhandled type trait");
6133 case BTT_IsLayoutCompatible: {
6136 diag::err_incomplete_type);
6139 diag::err_incomplete_type);
6144 return Self.IsLayoutCompatible(LhsT, RhsT);
6146 case BTT_IsPointerInterconvertibleBaseOf: {
6148 !Self.getASTContext().hasSameUnqualifiedType(LhsT, RhsT)) {
6150 diag::err_incomplete_type);
6154 tok::kw___is_pointer_interconvertible_base_of);
6156 tok::kw___is_pointer_interconvertible_base_of);
6158 return Self.IsPointerInterconvertibleBaseOf(Lhs, Rhs);
6160 case BTT_IsDeducible: {
6161 const auto *TSTToBeDeduced = cast<DeducedTemplateSpecializationType>(LhsT);
6163 return Self.DeduceTemplateArgumentsFromType(
6164 TSTToBeDeduced->getTemplateName().getAsTemplateDecl(), RhsT,
6168 llvm_unreachable(
"not a BTT");
6170 llvm_unreachable(
"Unknown type trait or not implemented");
6189 assert(!
T->
isDependentType() &&
"Cannot evaluate traits of dependent type");
6195 while (
const ArrayType *AT = Self.Context.getAsArrayType(
T)) {
6197 T = AT->getElementType();
6203 case ATT_ArrayExtent: {
6206 if (Self.VerifyIntegerConstantExpression(
6207 DimExpr, &
Value, diag::err_dimension_expr_not_constant_integer)
6210 if (
Value.isSigned() &&
Value.isNegative()) {
6211 Self.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer)
6215 Dim =
Value.getLimitedValue();
6219 bool Matched =
false;
6220 while (
const ArrayType *AT = Self.Context.getAsArrayType(
T)) {
6226 T = AT->getElementType();
6231 return CAT->getLimitedSize();
6237 llvm_unreachable(
"Unknown type trait or not implemented");
6277 case ET_IsLValueExpr:
return E->
isLValue();
6278 case ET_IsRValueExpr:
6281 llvm_unreachable(
"Expression trait not covered by switch");
6307 "placeholders should have been weeded out by now");
6322 const char *OpSpelling = isIndirect ?
"->*" :
".*";
6330 Diag(
Loc, diag::err_bad_memptr_rhs)
6352 Diag(
Loc, diag::err_bad_memptr_lhs)
6353 << OpSpelling << 1 << LHSType
6362 OpSpelling, (
int)isIndirect)) {
6367 Diag(
Loc, diag::err_bad_memptr_lhs) << OpSpelling
6391 Diag(
Loc, diag::err_pointer_to_member_type) << isIndirect;
6410 switch (Proto->getRefQualifier()) {
6419 if (Proto->isConst() && !Proto->isVolatile())
6421 ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue
6422 : diag::ext_pointer_to_const_ref_member_on_rvalue);
6424 Diag(
Loc, diag::err_pointer_to_member_oper_value_classify)
6431 Diag(
Loc, diag::err_pointer_to_member_oper_value_classify)
6444 if (Result->isFunctionType()) {
6447 }
else if (isIndirect) {
6465 bool &HaveConversion,
6467 HaveConversion =
false;
6484 QualType T = Self.Context.getReferenceQualifiedType(To);
6490 HaveConversion =
true;
6505 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
6506 Self.IsDerivedFrom(QuestionLoc, FTy, TTy);
6507 if (FRec && TRec && (FRec == TRec || FDerivedFromT ||
6508 Self.IsDerivedFrom(QuestionLoc, TTy, FTy))) {
6512 if (FRec == TRec || FDerivedFromT) {
6517 HaveConversion =
true;
6540 HaveConversion = !InitSeq.
Failed();
6558 Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args,
6565 ExprResult LHSRes = Self.PerformImplicitConversion(
6566 LHS.
get(), Best->BuiltinParamTypes[0], Best->Conversions[0],
6572 ExprResult RHSRes = Self.PerformImplicitConversion(
6573 RHS.
get(), Best->BuiltinParamTypes[1], Best->Conversions[1],
6579 Self.MarkFunctionReferenced(QuestionLoc, Best->Function);
6588 if (Self.DiagnoseConditionalForNull(LHS.
get(), RHS.
get(), QuestionLoc))
6591 Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
6597 Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)
6605 llvm_unreachable(
"Conditional operator has only built-in overloads");
6619 if (Result.isInvalid())
6634 assert(!EltTy->
isEnumeralType() &&
"Vectors cant be enum types");
6644 assert(!EltTy->
isEnumeralType() &&
"Vectors cant be enum types");
6656 QualType CondElementTy = CondVT->getElementType();
6657 unsigned CondElementCount = CondVT->getNumElements();
6666 if (LHSVT && RHSVT) {
6667 if (isa<ExtVectorType>(CondVT) != isa<ExtVectorType>(LHSVT)) {
6668 Diag(QuestionLoc, diag::err_conditional_vector_cond_result_mismatch)
6669 << isa<ExtVectorType>(CondVT);
6675 Diag(QuestionLoc, diag::err_conditional_vector_mismatched)
6676 << LHSType << RHSType;
6680 }
else if (LHSVT || RHSVT) {
6682 LHS, RHS, QuestionLoc,
false,
true,
6686 if (ResultType.isNull())
6699 Diag(QuestionLoc, diag::err_conditional_vector_operand_type)
6714 assert(!ResultType.isNull() && ResultType->isVectorType() &&
6716 "Result should have been a vector type");
6717 auto *ResultVectorTy = ResultType->castAs<
VectorType>();
6718 QualType ResultElementTy = ResultVectorTy->getElementType();
6719 unsigned ResultElementCount = ResultVectorTy->getNumElements();
6721 if (ResultElementCount != CondElementCount) {
6722 Diag(QuestionLoc, diag::err_conditional_vector_size) << CondType
6729 Diag(QuestionLoc, diag::err_conditional_vector_element_size) << CondType
6747 llvm::ElementCount CondElementCount =
6759 if (LHSBT && RHSBT) {
6762 Diag(QuestionLoc, diag::err_conditional_vector_mismatched)
6763 << LHSType << RHSType;
6766 ResultType = LHSType;
6767 }
else if (LHSBT || RHSBT) {
6770 if (ResultType.isNull())
6779 ResultElementTy = LHSType;
6785 Diag(QuestionLoc, diag::err_conditional_vector_operand_type)
6791 ResultElementTy, CondElementCount.getKnownMinValue());
6797 assert(!ResultType.isNull() && ResultType->isSveVLSBuiltinType() &&
6798 "Result should have been a vector type");
6799 auto *ResultBuiltinTy = ResultType->castAs<
BuiltinType>();
6801 llvm::ElementCount ResultElementCount =
6804 if (ResultElementCount != CondElementCount) {
6805 Diag(QuestionLoc, diag::err_conditional_vector_size)
6806 << CondType << ResultType;
6812 Diag(QuestionLoc, diag::err_conditional_vector_element_size)
6813 << CondType << ResultType;
6850 bool IsVectorConditional =
6853 bool IsSizelessVectorConditional =
6860 ExprResult CondRes = IsVectorConditional || IsSizelessVectorConditional
6886 if (LVoid || RVoid) {
6895 if (IsVectorConditional) {
6898 bool IsThrow = LVoid ? LThrow : RThrow;
6899 Diag(DiagLoc.
getBegin(), diag::err_conditional_vector_has_void)
6900 << DiagLoc << IsThrow;
6904 if (LThrow != RThrow) {
6905 Expr *NonThrow = LThrow ? RHS.
get() : LHS.
get();
6919 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
6920 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
6926 if (IsVectorConditional)
6929 if (IsSizelessVectorConditional)
6934 Diag(QuestionLoc, diag::err_wasm_table_conditional_expression)
6947 bool HaveL2R, HaveR2L;
6954 if (HaveL2R && HaveR2L) {
6955 Diag(QuestionLoc, diag::err_conditional_ambiguous)
6967 }
else if (HaveR2L) {
6991 ReferenceConversions::Qualification |
6992 ReferenceConversions::NestedQualification |
6993 ReferenceConversions::Function;
6998 !(RefConv & ~AllowedConversions) &&
7006 !(RefConv & ~AllowedConversions) &&
7022 if (Same && LVK == RVK && LVK !=
VK_PRValue &&
7096 diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
7134 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
7165 bool T2IsPointerLike = T2->isAnyPointerType() || T2->isMemberPointerType() ||
7166 T2->isNullPtrType();
7167 if (!T1IsPointerLike && !T2IsPointerLike)
7175 if (T1IsPointerLike &&
7179 ? CK_NullToMemberPointer
7180 : CK_NullToPointer).
get();
7183 if (T2IsPointerLike &&
7187 ? CK_NullToMemberPointer
7188 : CK_NullToPointer).
get();
7193 if (!T1IsPointerLike || !T2IsPointerLike)
7196 "nullptr_t should be a null pointer constant");
7199 enum Kind { Pointer, ObjCPointer, MemberPointer,
Array } K;
7204 const Type *ClassOrBound;
7206 Step(
Kind K,
const Type *ClassOrBound =
nullptr)
7207 : K(K), ClassOrBound(ClassOrBound) {}
7218 if (
auto *CAT = cast_or_null<ConstantArrayType>(ClassOrBound))
7224 llvm_unreachable(
"unknown step kind");
7246 unsigned NeedConstBefore = 0;
7255 if (!Steps.empty()) {
7265 }
else if (Steps.size() == 1) {
7268 if (MaybeQ1 == MaybeQ2) {
7287 assert(Steps.size() == 1);
7295 assert(Steps.size() == 1);
7299 Steps.back().Quals = Quals;
7300 if (Q1 != Quals || Q2 != Quals)
7301 NeedConstBefore = Steps.size() - 1;
7309 auto *CAT1 = dyn_cast<ConstantArrayType>(Arr1);
7310 auto *CAT2 = dyn_cast<ConstantArrayType>(Arr2);
7311 if (CAT1 && CAT2 && CAT1->getSize() == CAT2->getSize()) {
7314 Steps.emplace_back(Step::Array, CAT1);
7317 bool IAT1 = isa<IncompleteArrayType>(Arr1);
7318 bool IAT2 = isa<IncompleteArrayType>(Arr2);
7319 if ((IAT1 && IAT2) ||
7321 ((
bool)CAT1 != (
bool)CAT2) &&
7322 (Steps.empty() || Steps.back().K != Step::Array))) {
7328 Steps.emplace_back(Step::Array);
7330 NeedConstBefore = Steps.size();
7340 Steps.emplace_back(Step::Pointer);
7349 Steps.emplace_back(Step::ObjCPointer);
7373 else if (Steps.empty())
7379 Steps.emplace_back(Step::MemberPointer,
Class);
7391 Steps.emplace_back(Step::Pointer);
7429 if (Steps.size() == 1) {
7448 FPT1->getParamTypes(), EPI1);
7450 FPT2->getParamTypes(), EPI2);
7456 if (Steps.size() == 1 && Steps.front().K == Step::Pointer &&
7462 Composite2 = Composite1;
7464 Composite1 = Composite2;
7473 Composite1 = Composite2;
7475 Composite2 = Composite1;
7485 for (
unsigned I = 0; I != NeedConstBefore; ++I)
7486 Steps[I].Quals.addConst();
7490 for (
auto &S : llvm::reverse(Steps))
7491 Composite = S.rebuild(
Context, Composite);
7512 E1 = E1Result.
get();
7517 E2 = E2Result.
get();
7527 assert(!isa<CXXBindTemporaryExpr>(E) &&
"Double-bound temporary?");
7538 bool ReturnsRetained;
7542 if (
CallExpr *Call = dyn_cast<CallExpr>(E)) {
7543 Expr *Callee = Call->getCallee()->IgnoreParens();
7549 T = BinOp->getRHS()->getType();
7550 else if (
MemberExpr *Mem = dyn_cast<MemberExpr>(Callee))
7551 T = Mem->getMemberDecl()->getType();
7566 }
else if (isa<StmtExpr>(E)) {
7567 ReturnsRetained =
true;
7571 }
else if (isa<CastExpr>(E) &&
7572 isa<BlockExpr>(cast<CastExpr>(E)->getSubExpr())) {
7581 D = Send->getMethodDecl();
7582 }
else if (
ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(E)) {
7583 D = BoxedExpr->getBoxingMethod();
7587 if (ArrayLit->getNumElements() == 0 &&
7591 D = ArrayLit->getArrayWithObjectsMethod();
7593 = dyn_cast<ObjCDictionaryLiteral>(E)) {
7596 if (DictLit->getNumElements() == 0 &&
7600 D = DictLit->getDictWithObjectsMethod();
7603 ReturnsRetained = (D && D->
hasAttr<NSReturnsRetainedAttr>());
7608 if (!ReturnsRetained &&
7619 CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
7620 : CK_ARCReclaimReturnedObject);
7638 RT = cast<RecordType>(
T);
7640 case Type::ConstantArray:
7641 case Type::IncompleteArray:
7642 case Type::VariableArray:
7643 case Type::DependentSizedArray:
7644 T = cast<ArrayType>(
T)->getElementType().getTypePtr();
7664 PDiag(diag::err_access_dtor_temp)
7670 if (Destructor->isTrivial())
7695 assert(SubExpr &&
"subexpression can't be null!");
7717 assert(SubStmt &&
"sub-statement can't be null!");
7744 "not in a decltype expression");
7747 if (Result.isInvalid())
7761 if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
7765 if (SubExpr.
get() == PE->getSubExpr())
7770 if (BO->getOpcode() == BO_Comma) {
7774 if (RHS.
get() == BO->getRHS())
7777 BO->
getType(), BO->getValueKind(),
7778 BO->getObjectKind(), BO->getOperatorLoc(),
7779 BO->getFPFeatures());
7796 if (Result.isInvalid())
7806 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeCalls.size();
7809 if (Call == TopCall)
7813 Call->getBeginLoc(), Call, Call->getDirectCallee()))
7819 for (
unsigned I = 0, N =
ExprEvalContexts.back().DelayedDecltypeBinds.size();
7823 if (Bind == TopBind)
7829 Bind->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
7835 PDiag(diag::err_access_dtor_temp)
7836 << Bind->getType());
7851 unsigned SkipStart = OperatorArrows.size(), SkipCount = 0;
7854 if (OperatorArrows.size() > Limit) {
7856 SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2;
7857 SkipCount = OperatorArrows.size() - (Limit - 1);
7860 for (
unsigned I = 0; I < OperatorArrows.size(); ) {
7861 if (I == SkipStart) {
7862 S.
Diag(OperatorArrows[I]->getLocation(),
7863 diag::note_operator_arrows_suppressed)
7867 S.
Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here)
7868 << OperatorArrows[I]->getCallResultType();
7878 bool &MayBePseudoDestructor) {
7881 if (Result.isInvalid())
return ExprError();
7882 Base = Result.get();
7885 if (Result.isInvalid())
return ExprError();
7886 Base = Result.get();
7889 MayBePseudoDestructor =
false;
7894 if (OpKind == tok::arrow)
7899 MayBePseudoDestructor =
true;
7906 if (OpKind == tok::arrow) {
7908 bool NoArrowOperatorFound =
false;
7909 bool FirstIteration =
true;
7917 if (OperatorArrows.size() >=
getLangOpts().ArrowDepth) {
7918 Diag(OpLoc, diag::err_operator_arrow_depth_exceeded)
7919 << StartingType <<
getLangOpts().ArrowDepth <<
Base->getSourceRange();
7921 Diag(OpLoc, diag::note_operator_arrow_depth)
7934 : &NoArrowOperatorFound);
7935 if (Result.isInvalid()) {
7936 if (NoArrowOperatorFound) {
7937 if (FirstIteration) {
7938 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
7939 << BaseType << 1 <<
Base->getSourceRange()
7941 OpKind = tok::period;
7944 Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
7945 << BaseType <<
Base->getSourceRange();
7949 diag::note_member_reference_arrow_from_operator_arrow);
7954 Base = Result.get();
7956 OperatorArrows.push_back(OpCall->getDirectCallee());
7957 BaseType =
Base->getType();
7959 if (!CTypes.insert(CBaseType).second) {
7960 Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType;
7964 FirstIteration =
false;
7967 if (OpKind == tok::arrow) {
7971 BaseType = AT->getElementType();
7993 MayBePseudoDestructor =
true;
8005 diag::err_incomplete_member_access)) {
8020 if (
Base->hasPlaceholderType()) {
8025 ObjectType =
Base->getType();
8033 if (OpKind == tok::arrow) {
8043 ObjectType =
Base->getType();
8048 }
else if (!
Base->isTypeDependent()) {
8050 S.
Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
8051 << ObjectType <<
true
8056 OpKind = tok::period;
8098 Diag(OpLoc, diag::ext_pseudo_dtor_on_void) <<
Base->getSourceRange();
8100 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
8101 << ObjectType <<
Base->getSourceRange();
8109 if (DestructedTypeInfo) {
8122 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
8123 << ObjectType << 0 <<
Base->getSourceRange();
8127 *
this, DestructedType))
8132 ObjectType = DestructedType;
8133 OpKind = tok::arrow;
8135 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
8136 << ObjectType << DestructedType <<
Base->getSourceRange()
8140 DestructedType = ObjectType;
8141 DestructedTypeInfo =
8152 Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)
8153 << ObjectType << DestructedType <<
Base->getSourceRange()
8158 DestructedType = ObjectType;
8160 DestructedTypeStart);
8173 if (ScopeTypeInfo) {
8179 diag::err_pseudo_dtor_type_mismatch)
8184 ScopeTypeInfo =
nullptr;
8190 OpKind == tok::arrow, OpLoc,
8210 "Invalid first type name in pseudo-destructor");
8213 "Invalid second type name in pseudo-destructor");
8237 S, &SS,
true,
false, ObjectTypePtrForLookup,
8250 diag::err_pseudo_dtor_destructor_non_type)
8256 DestructedType = ObjectType;
8274 if (
T.isInvalid() || !
T.get()) {
8276 DestructedType = ObjectType;
8283 if (!DestructedType.
isNull()) {
8284 if (!DestructedTypeInfo)
8298 S, &SS,
true,
false, ObjectTypePtrForLookup,
8302 diag::err_pseudo_dtor_destructor_non_type)
8327 if (
T.isInvalid() || !
T.get()) {
8335 if (!
ScopeType.isNull() && !ScopeTypeInfo)
8341 ScopeTypeInfo, CCLoc, TildeLoc,
8372 cast<PackIndexingType>(
T.getTypePtr())->getPattern(),
8379 llvm_unreachable(
"Unsupported type in pseudo destructor");
8405 Operand->HasSideEffects(
Context,
false)) {
8408 Diag(Operand->getExprLoc(), diag::warn_side_effects_unevaluated_context);
8424 bool IsCompoundAssign =
false;
8425 bool isIncrementDecrementUnaryOp =
false;
8427 if (BO->getLHS()->getType()->isDependentType() ||
8428 BO->getRHS()->getType()->isDependentType()) {
8429 if (BO->getOpcode() != BO_Assign)
8431 }
else if (!BO->isAssignmentOp())
8434 IsCompoundAssign = BO->isCompoundAssignmentOp();
8435 LHS = dyn_cast<DeclRefExpr>(BO->getLHS());
8437 if (COCE->getOperator() != OO_Equal)
8439 LHS = dyn_cast<DeclRefExpr>(COCE->getArg(0));
8440 }
else if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
8441 if (!UO->isIncrementDecrementOp())
8443 isIncrementDecrementUnaryOp =
true;
8444 LHS = dyn_cast<DeclRefExpr>(UO->getSubExpr());
8454 if ((IsCompoundAssign || isIncrementDecrementUnaryOp) &&
8460 iter->getSecond()--;
8525 if (!
T->getDecl()->isComplete()) {
8539 diag::err_incomplete_type);
8565 if (isa<ParmVarDecl>(Var))
return true;
8566 const VarDecl *DefVD =
nullptr;
8600 while (DC && isa<CapturedDecl>(DC))
8604 "The current call operator must be synchronized with Sema's CurContext");
8625 !IsFullExprInstantiationDependent)
8634 if (
const std::optional<unsigned> Index =
8638 const bool IsVarNeverAConstantExpression =
8640 if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {
8652 DeclRefType,
nullptr)) {
8658 DeclRefType,
nullptr);
8667 if (
const std::optional<unsigned> Index =
8670 const unsigned FunctionScopeIndexOfCapturableLambda = *Index;
8673 &FunctionScopeIndexOfCapturableLambda);
8685 Consumer.getLookupResult().getLookupKind());
8698 if (ND->isCXXClassMember()) {
8702 Record = NNS->getAsType()->getAsCXXRecordDecl();
8705 dyn_cast<CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());
8712 NewSS, R,
Consumer.isAddressOfOperand()))
8716 }
else if (
auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
8718 Ivar->getIdentifier());
8739 class TransformTypos :
public TreeTransform<TransformTypos> {
8746 llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache;
8747 llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;
8759 void EmitAllDiagnostics(
bool IsAmbiguous) {
8762 if (
State.DiagHandler) {
8773 Replacement.isInvalid() ?
nullptr : Replacement.get()))
8776 State.DiagHandler(TC);
8796 bool CheckAndAdvanceTypoExprCorrectionStreams() {
8799 TransformCache.erase(TE);
8800 if (!
State.Consumer->hasMadeAnyCorrectionProgress())
8802 if (!
State.Consumer->finished())
8804 State.Consumer->resetCorrectionStream();
8810 if (
auto *OE = dyn_cast_or_null<OverloadExpr>(E))
8811 E = OverloadResolution[OE];
8815 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
8816 return DRE->getFoundDecl();
8817 if (
auto *ME = dyn_cast<MemberExpr>(E))
8828 if (Trap.hasErrorOccurred() || Res.
isInvalid())
8831 return ExprFilter(Res.
get());
8845 auto SavedTypoExprs = std::move(
TypoExprs);
8846 auto SavedAmbiguousTypoExprs = std::move(AmbiguousTypoExprs);
8848 AmbiguousTypoExprs.clear();
8850 FindTypoExprs(
TypoExprs).TraverseStmt(FixedExpr);
8855 RecursiveTransformLoop(FixedExpr, IsAmbiguous);
8865 TransformCache.erase(TE);
8868 auto SI = find(SemaTypoExprs, TE);
8869 if (SI != SemaTypoExprs.end()) {
8870 SemaTypoExprs.erase(SI);
8882 AmbiguousTypoExprs = std::move(SavedAmbiguousTypoExprs);
8898 Res = CheckForRecursiveTypos(TryTransform(E), IsAmbiguous);
8912 if (!CheckAndAdvanceTypoExprCorrectionStreams())
8917 if (!IsAmbiguous && !Res.
isInvalid() && !AmbiguousTypoExprs.empty()) {
8918 auto SavedTransformCache =
8919 llvm::SmallDenseMap<TypoExpr *, ExprResult, 2>(TransformCache);
8923 while (!AmbiguousTypoExprs.empty()) {
8924 auto TE = AmbiguousTypoExprs.back();
8936 TransformCache.erase(TE);
8937 ExprResult AmbigRes = CheckForRecursiveTypos(TryTransform(E), IsAmbiguous);
8939 if (!AmbigRes.
isInvalid() || IsAmbiguous) {
8941 SavedTransformCache.erase(TE);
8952 AmbiguousTypoExprs.remove(TE);
8954 TransformCache[TE] = SavedTransformCache[TE];
8956 TransformCache = std::move(SavedTransformCache);
8964 for (
auto Iterator = SemaTypoExprs.begin(); Iterator != SemaTypoExprs.end();) {
8965 auto TE = *Iterator;
8972 Iterator = SemaTypoExprs.erase(Iterator);
8981 : BaseTransform(
SemaRef), InitDecl(InitDecl), ExprFilter(
Filter) {}
8986 Expr *ExecConfig =
nullptr) {
8987 auto Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args,
8988 RParenLoc, ExecConfig);
8989 if (
auto *OE = dyn_cast<OverloadExpr>(Callee)) {
8990 if (Result.isUsable()) {
8991 Expr *ResultCall = Result.get();
8992 if (
auto *BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall))
8993 ResultCall = BE->getSubExpr();
8994 if (
auto *CE = dyn_cast<CallExpr>(ResultCall))
8995 OverloadResolution[OE] = CE->getCallee();
9006 bool IsAmbiguous =
false;
9007 ExprResult Res = RecursiveTransformLoop(E, IsAmbiguous);
9010 FindTypoExprs(
TypoExprs).TraverseStmt(E);
9012 EmitAllDiagnostics(IsAmbiguous);
9021 auto &CacheEntry = TransformCache[E];
9022 if (!
TypoExprs.insert(E) && !CacheEntry.isUnset()) {
9027 assert(
State.Consumer &&
"Cannot transform a cleared TypoExpr");
9039 if (!
NE.isInvalid()) {
9044 if ((Next =
State.Consumer->peekNextCorrection()) &&
9046 AmbiguousTypoExprs.insert(E);
9048 AmbiguousTypoExprs.remove(E);
9050 assert(!
NE.isUnset() &&
9051 "Typo was transformed into a valid-but-null ExprResult");
9052 return CacheEntry =
NE;
9062 bool RecoverUncorrectedTypos,
9070 auto TyposResolved = DelayedTypos.size();
9071 auto Result = TransformTypos(*
this, InitDecl,
Filter).Transform(E);
9072 TyposResolved -= DelayedTypos.size();
9073 if (Result.isInvalid() || Result.get() != E) {
9075 if (Result.isInvalid() && RecoverUncorrectedTypos) {
9083 return TT.TransformExpr(E);
9087 assert(TyposResolved == 0 &&
"Corrected typo but got same Expr back?");
9093 bool DiscardedValue,
bool IsConstexpr,
9094 bool IsTemplateArgument) {
9103 if (DiscardedValue) {
9128 CheckCompletedExpr(
FullExpr.get(), CC, IsConstexpr);
9177 while (DC && isa<CapturedDecl>(DC))
9180 if (IsInLambdaDeclContext && CurrentLSI &&
9225 llvm_unreachable(
"Invalid LookupResult Kind!");
9253 "Exactly one of TypeName and TemplateId must be specified.");
9321 E,
false, NoexceptLoc,
9349 auto *Param = cast<TemplateTypeParmDecl>(TPL->
getParam(0));
9354 assert(TC &&
"Type Constraint cannot be null here");
9356 assert(IDC &&
"ImmediatelyDeclaredConstraint can't be null here.");
9361 [&](llvm::raw_ostream &OS) {
9362 IDC->printPretty(OS, nullptr,
9363 getPrintingPolicy());
9365 IsSimple, NoexceptLoc, ReturnTypeRequirement);
9367 SubstitutedConstraintExpr =
9368 cast<ConceptSpecializationExpr>(Constraint.
get());
9373 ReturnTypeRequirement, Status,
9374 SubstitutedConstraintExpr);
9383 IsSimple, NoexceptLoc,
9384 ReturnTypeRequirement);
9417 InvalidConstraintEntity,
9433 if (Param->hasDefaultArg())
9437 Diag(Param->getDefaultArgRange().getBegin(),
9438 diag::err_requires_expr_local_parameter_default_argument);
9441 Param->setDeclContext(Body);
9443 if (Param->getIdentifier()) {
9452 assert(
CurContext &&
"DeclContext imbalance!");
9454 assert(
CurContext &&
"Popped translation unit!");
9463 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 clang::Expr interface and subclasses for C++ expressions.
Defines Expressions and AST nodes for C++2a concepts.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::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.
This file declares semantic analysis for CUDA constructs.
static void collectPublicBases(CXXRecordDecl *RD, llvm::DenseMap< CXXRecordDecl *, unsigned > &SubobjectsSeen, llvm::SmallPtrSetImpl< CXXRecordDecl * > &VBases, llvm::SetVector< CXXRecordDecl * > &PublicSubobjectsSeen, bool ParentIsPublic)
static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, const TypeSourceInfo *Lhs, const TypeSourceInfo *Rhs, SourceLocation KeyLoc)
static bool DiagnoseVLAInCXXTypeTrait(Sema &S, const TypeSourceInfo *T, clang::tok::TokenKind TypeTraitID)
Checks that type T is not a VLA.
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 TypeTraitReturnType GetReturnType(TypeTrait Kind)
static ExprResult attemptRecovery(Sema &SemaRef, const TypoCorrectionConsumer &Consumer, const TypoCorrection &TC)
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 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 bool resolveAllocationOverload(Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl< Expr * > &Args, bool &PassAlignment, FunctionDecl *&Operator, OverloadCandidateSet *AlignedCandidates, Expr *AlignArg, bool Diagnose)
static QualType adjustCVQualifiersForCXXThisWithinLambda(ArrayRef< FunctionScopeInfo * > FunctionScopes, QualType ThisTy, DeclContext *CurSemaContext, ASTContext &ASTCtx)
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 HasNoThrowOperator(const RecordType *RT, OverloadedOperatorKind Op, Sema &Self, SourceLocation KeyLoc, ASTContext &C, bool(CXXRecordDecl::*HasTrivial)() const, bool(CXXRecordDecl::*HasNonTrivial)() const, bool(CXXMethodDecl::*IsDesiredOp)() const)
static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E)
static UsualDeallocFnInfo resolveDeallocationOverload(Sema &S, LookupResult &R, bool WantSize, bool WantAlign, 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 doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc, QualType allocType)
Determine whether a given type is a class for which 'delete[]' would call a member 'operator delete[]...
static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT, SourceLocation KeyLoc, TypeSourceInfo *TInfo)
static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT, QualType T, Expr *DimExpr, SourceLocation KeyLoc)
static bool isValidVectorForConditionalCondition(ASTContext &Ctx, QualType CondTy)
static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT, SourceLocation Loc, QualType ArgTy)
Check the completeness of a type in a unary type trait.
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 ExprResult CheckConvertibilityForTypeTraits(Sema &Self, const TypeSourceInfo *Lhs, const TypeSourceInfo *Rhs, SourceLocation KeyLoc, llvm::BumpPtrAllocator &OpaqueExprAllocator)
static bool EvaluateBooleanTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc, bool IsDependent)
static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD)
Determine whether the given function is a non-placement deallocation function.
static NamedDecl * getDeclFromExpr(Expr *E)
This file provides some common utility functions for processing Lambdas.
This file declares semantic analysis for Objective-C.
Defines the clang::TokenKind enum and support functions.
Defines the clang::TypeLoc interface and its subclasses.
Defines enumerations for the type traits support.
C Language Family Type Representation.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
MSGuidDecl * getMSGuidDecl(MSGuidDeclParts Parts) const
Return a declaration for the global GUID object representing the given GUID value.
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
unsigned getIntWidth(QualType T) const
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
DeclarationNameTable DeclarationNames
QualType getRecordType(const RecordDecl *Decl) const
QualType getScalableVectorType(QualType EltTy, unsigned NumElts, unsigned NumFields=1) const
Return the unique reference to a scalable vector type of the specified element type and scalable numb...
QualType getArrayParameterType(QualType Ty) const
Return the uniqued reference to a specified array parameter type from the original array type.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getMSGuidType() const
Retrieve the implicitly-predeclared 'struct _GUID' type.
QualType getReferenceQualifiedType(const Expr *e) const
getReferenceQualifiedType - Given an expr, will return the type for that expression,...
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
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 ConstantArrayType * getAsConstantArrayType(QualType T) const
const LangOptions & getLangOpts() const
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
CanQualType BoundMemberTy
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
CharUnits getExnObjectAlignment() const
Return the alignment (in bytes) of the thrown exception object.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getObjCIdType() const
Represents the Objective-CC id type.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
FunctionProtoType::ExceptionSpecInfo mergeExceptionSpecs(FunctionProtoType::ExceptionSpecInfo ESI1, FunctionProtoType::ExceptionSpecInfo ESI2, SmallVectorImpl< QualType > &ExceptionTypeStorage, bool AcceptDependent)
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getExceptionObjectType(QualType T) const
QualType getCommonSugaredType(QualType X, QualType Y, bool Unqualified=false)
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
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 getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
const TargetInfo & getTargetInfo() const
void addCopyConstructorForExceptionObject(CXXRecordDecl *RD, CXXConstructorDecl *CD)
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
QualType getWideCharType() const
Return the type of wide characters.
QualType getLogicalOperationType() const
The result type of logical operations, '<', '>', '!=', etc.
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.
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
TranslationUnitDecl * getTranslationUnitDecl() const
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
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.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
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)
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
This class is used for builtin types like 'int'.
Represents a base class of a C++ class.
Represents binding an expression to a temporary.
const Expr * getSubExpr() const
static CXXBindTemporaryExpr * Create(const ASTContext &C, CXXTemporary *Temp, Expr *SubExpr)
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.
Represents a C++ base or member initializer.
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.
bool isUsualDeallocationFunction(SmallVectorImpl< const FunctionDecl * > &PreventedBy) const
Determine whether this is a usual deallocation function (C++ [basic.stc.dynamic.deallocation]p2),...
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
QualType getFunctionObjectParameterType() const
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
static CXXNewExpr * Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete, bool ShouldPassAlignment, 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.
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class....
bool hasNonTrivialCopyAssignment() const
Determine whether this class has a non-trivial copy assignment operator (C++ [class....
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
bool hasTrivialMoveConstructor() const
Determine whether this class has a trivial move constructor (C++11 [class.copy]p12)
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class....
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
bool hasTrivialCopyAssignment() const
Determine whether this class has a trivial copy assignment operator (C++ [class.copy]p11,...
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 hasNonTrivialMoveConstructor() const
Determine whether this class has a non-trivial move constructor (C++11 [class.copy]p12)
bool hasDefinition() const
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
bool hasNonTrivialMoveAssignment() const
Determine whether this class has a non-trivial move assignment operator (C++11 [class....
bool hasNonTrivialDefaultConstructor() const
Determine whether this class has a non-trivial default constructor (C++11 [class.ctor]p5).
bool hasNonTrivialCopyConstructor() const
Determine whether this class has a non-trivial copy constructor (C++ [class.copy]p6,...
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type.
Represents a C++ nested-name-specifier or a global scope specifier.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
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.
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.
char * location_data() const
Retrieve the data associated with the source-location information.
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]).
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
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.
void setExprNeedsCleanups(bool SideEffects)
bool cleanupsHaveSideEffects() const
bool exprNeedsCleanups() const
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.
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)
The results of name lookup within a DeclContext.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
void addDecl(Decl *D)
Add the declaration D into this context.
A reference to a declared variable, function, enum, etc.
Captures information about "declaration specifiers".
bool hasAutoTypeSpec() const
TST getTypeSpecType() const
SourceLocation getBeginLoc() const LLVM_READONLY
Expr * getPackIndexingExpr() const
static const TST TST_typename_pack_indexing
ParsedType getRepAsType() const
SourceLocation getEllipsisLoc() const
static const TST TST_decltype
Expr * getRepAsExpr() const
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.
bool isInvalidDecl() const
SourceLocation getLocation() const
void setLocalOwningModule(Module *M)
void setImplicit(bool I=true)
@ 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.
DeclContext * getDeclContext()
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible.
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 ...
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
SourceLocation getBeginLoc() const LLVM_READONLY
Information about one declarator, including the parsed type information and the identifier.
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.
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
void setRParenLoc(SourceLocation Loc)
void setDecltypeLoc(SourceLocation Loc)
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
RAII object that enters a new expression evaluation context.
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...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EnumDecl * getDecl() const
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.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
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.
An expression trait intrinsic.
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
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.
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 ...
QualType getReturnType() const
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
bool isVariadic() const
Whether this function is variadic.
bool isDeleted() const
Whether this function has been deleted.
StringLiteral * getDeletedMessage() const
Get the message that indicates why this function was deleted.
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, Expr *TrailingRequiresClause=nullptr)
bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
size_t param_size() const
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
const ParmVarDecl * getParamDecl(unsigned i) const
Represents a prototype with parameter type info, e.g.
unsigned getNumParams() const
QualType getParamType(unsigned i) const
bool isVariadic() const
Whether this function prototype is variadic.
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
Declaration of a template function.
ExtInfo withNoReturn(bool noReturn) const
bool getProducesResult() const
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
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....
StringRef getName() const
Return the actual identifier string.
bool tryAddTopLevelDecl(NamedDecl *D, DeclarationName Name)
Try to add the given declaration to the top level scope, if it (or a redeclaration of it) hasn't alre...
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
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 an C or C++ initializer list.
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'.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
clang::ObjCRuntime ObjCRuntime
bool hasGlobalAllocationFunctionVisibility() const
bool allowsNonTrivialObjCLifetimeQualifiers() const
True if any ObjC types may have non-trivial lifetime qualifiers.
bool hasHiddenGlobalAllocationFunctionVisibility() const
bool hasProtectedGlobalAllocationFunctionVisibility() const
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.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
@ NotFound
No entity found met the criteria.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
@ Found
Name lookup found a single declaration that met the criteria.
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
DeclClass * getAsSingle() const
void setLookupName(DeclarationName Name)
Sets the name to look up.
bool empty() const
Return true if no decls were found.
CXXRecordDecl * getNamingClass() const
Returns the 'naming class' for this lookup, i.e.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Filter makeFilter()
Create a filter for this result set.
bool isClassLookup() const
Returns whether these results arose from performing a lookup into a class.
void setNamingClass(CXXRecordDecl *Record)
Sets the 'naming class' for this lookup.
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.
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
A pointer to member type per C++ 8.3.3 - Pointers to members.
const Type * getClass() const
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.
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...
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
A C++ nested-name-specifier augmented with source location information.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
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...
Represents an ObjC class declaration.
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
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.
Represents a class type in Objective C.
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface.
bool hasEmptyCollections() const
Are the empty collection symbols available?
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 parethesized 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)
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
IdentifierTable & getIdentifierTable()
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 isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
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.
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 hasNonTrivialObjCLifetime() const
The collection of all-type qualifiers we support.
void removeCVRQualifiers(unsigned mask)
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
bool hasCVRQualifiers() const
bool hasUnaligned() const
unsigned getAddressSpaceAttributePrintValue() const
Get the address space attribute value to be printed by diagnostics.
void setAddressSpace(LangAS space)
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B)
Returns true if address space A is equal to or a superset of B.
unsigned getCVRUQualifiers() const
void setObjCGCAttr(GC type)
ObjCLifetime getObjCLifetime() const
static Qualifiers fromCVRUMask(unsigned CVRU)
LangAS getAddressSpace() const
void setObjCLifetime(ObjCLifetime type)
Represents a struct/union/class.
bool canPassInRegisters() const
Determine whether this class can be passed in registers.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
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.
@ 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.
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...
ARCConversionResult CheckObjCConversion(SourceRange castRange, QualType castType, Expr *&op, CheckedConversionKind CCK, bool Diagnose=true, bool DiagnoseCFAudited=false, BinaryOperatorKind Opc=BO_PtrMemD)
Checks for invalid conversions and casts between retainable pointers and other pointer kinds for ARC ...
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
FindCompositeObjCPointerType - Helper method to find composite type of two objective-c pointer types ...
ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S, IdentifierInfo *II, bool AllowBuiltinCreation=false)
The parser has read a name in, and Sema has detected that we're currently inside an ObjC method.
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.
SemaDiagnosticBuilder DiagIfDeviceCode(SourceLocation Loc, unsigned DiagID, DeviceDiagnosticReason Reason=DeviceDiagnosticReason::Sycl|DeviceDiagnosticReason::Esimd)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...
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...
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Sema - This implements semantic analysis and AST building for C.
FunctionDecl * FindUsualDeallocationFunction(SourceLocation StartLoc, bool CanProvideSize, bool Overaligned, DeclarationName Name)
void DeclareGlobalNewDelete()
DeclareGlobalNewDelete - Declare the global forms of operator new and delete.
QualType CheckSizelessVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
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 ).
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....
@ 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 CheckCXXThisType(SourceLocation Loc, QualType Type)
Check whether the type of 'this' is valid in the current context.
TypeResult ActOnTemplateIdType(Scope *S, 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)
IfExistsResult
Describes the result of an "if-exists" condition check.
@ IER_DoesNotExist
The symbol does not exist.
@ IER_Dependent
The name is a dependent name, so the results will differ from one instantiation to the next.
@ IER_Error
An error occurred.
@ IER_Exists
The symbol exists.
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, ArithConvKind ACK)
UsualArithmeticConversions - Performs various conversions that are common to binary operators (C99 6....
ExprResult ActOnExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
ActOnExpressionTrait - Parsed one of the unary type trait support pseudo-functions.
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'.
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)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
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),...
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.
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)
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())
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)
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.
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace.
bool CheckTypeTraitArity(unsigned Arity, SourceLocation Loc, size_t N)
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)
ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, ParsedType LhsTy, Expr *DimExpr, SourceLocation RParen)
ActOnArrayTypeTrait - Parsed one of the binary type trait support pseudo-functions.
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)
ActOnCXXThrow - Parse throw expressions.
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)
EnumDecl * getStdAlignValT() const
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
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 CheckMemberPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess)
CheckMemberPointerConversion - Check the member pointer conversion from the expression From to the ty...
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,...
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
@ UPPC_IfExists
Microsoft __if_exists.
@ UPPC_IfNotExists
Microsoft __if_not_exists.
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 isPotentialImplicitMemberAccess(const CXXScopeSpec &SS, LookupResult &R, bool IsAddressOfOperand)
Check whether an expression might be an implicit class member access.
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)
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
const LangOptions & LangOpts
bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, AllocationFunctionScope NewScope, AllocationFunctionScope DeleteScope, QualType AllocType, bool IsArray, bool &PassAlignment, MultiExprArg PlaceArgs, FunctionDecl *&OperatorNew, FunctionDecl *&OperatorDelete, bool Diagnose=true)
Finds the overloads of operator new and delete that are appropriate for the allocation.
const LangOptions & getLangOpts() const
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)
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 BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc)
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.
ExprResult BuildExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
ExprResult BuildCXXUuidof(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a Microsoft __uuidof expression with a type operand.
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)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
bool isInLifetimeExtendingContext() const
static bool isCast(CheckedConversionKind CCK)
ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr)
Prepare SplattedExpr for a vector splat operation, adding implicit casts if necessary.
IfExistsResult CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS, const DeclarationNameInfo &TargetNameInfo)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, bool Diagnose=true, bool WantSize=false, bool WantAligned=false)
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
Module * getCurrentModule() const
Get the module unit whose scope we are currently within.
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 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)
llvm::SmallVector< TypoExpr *, 2 > TypoExprs
Holds TypoExprs that are created from createDelayedTypo.
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
@ Compatible
Compatible - the types are compatible according to the standard.
@ Incompatible
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST.
ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, Declarator &D, Expr *Initializer)
ActOnCXXNew - Parsed a C++ 'new' expression.
SourceManager & getSourceManager() const
@ ACK_Conditional
A conditional (?:) operator.
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 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.
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 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...
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
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)
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=std::nullopt, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
QualType CXXCheckConditionalOperands(ExprResult &cond, ExprResult &lhs, ExprResult &rhs, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc)
Check the operands of ?: under C++ semantics.
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)
@ CCEK_ArrayBound
Array bound in array declarator or new-expression.
ASTContext & getASTContext() const
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....
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
QualType BuildDecltypeType(Expr *E, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
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...
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
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,...
FPOptions & getCurFPFeatures()
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 isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const
Determine whether FD is an aligned allocation or deallocation function that is unavailable.
DiagnosticsEngine & Diags
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)
ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< ParsedType > Args, SourceLocation RParenLoc)
Parsed one of the type trait support pseudo-functions.
concepts::NestedRequirement * BuildNestedRequirement(Expr *E)
FunctionDecl * FindDeallocationFunctionForDestructor(SourceLocation StartLoc, CXXRecordDecl *RD)
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)
ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, TypeSourceInfo *TSInfo, Expr *DimExpr, SourceLocation RParen)
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,...
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr * > Args, SmallVectorImpl< Expr * > &AllArgs, VariadicCallType CallType=VariadicDoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
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.
AssignConvertType CheckAssignmentConstraints(SourceLocation Loc, QualType LHSType, QualType RHSType)
CheckAssignmentConstraints - Perform type checking for assignment, argument passing,...
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
void clearDelayedTypo(TypoExpr *TE)
Clears the state of the given TypoExpr.
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)
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
const TypoExprState & getTypoExprState(TypoExpr *TE) const
FullExprArg MakeFullExpr(Expr *Arg)
ExprResult ActOnCXXThis(SourceLocation Loc)
ExprResult ActOnDecltypeExpression(Expr *E)
Process the expression contained within a decltype.
AllocationFunctionScope
The scope in which to find allocation functions.
@ AFS_Both
Look for allocation functions in both the global scope and in the scope of the allocated class.
@ AFS_Class
Only look for allocation functions in the scope of the allocated class.
@ AFS_Global
Only look for allocation functions in the global scope.
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
void 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 Element
Element - Between the second and third conversion a vector or matrix element 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
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
bool isItaniumFamily() const
Does this ABI generally fall into the Itanium family of ABIs?
unsigned getNewAlign() const
Return the largest alignment for which a suitably-sized allocation with '::operator new(size_t)' is g...
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
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.
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)
NamedDecl * getParam(unsigned Idx)
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, std::optional< unsigned > 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.
static TypeTraitExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, TypeTrait Kind, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc, bool Value)
Create a new type trait expression.
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 isStructureType() const
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
bool isBooleanType() const
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
bool isIncompleteArrayType() const
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool isRValueReferenceType() const
bool isFundamentalType() const
Tests whether the type is categorized as a fundamental type.
bool isVoidPointerType() const
bool isArithmeticType() const
bool isPointerType() 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 isInterfaceType() const
bool isVariableArrayType() 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
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
bool isMemberDataPointerType() const
bool isLValueReferenceType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type.
bool isAnyComplexType() const
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,...
bool isCompoundType() const
Tests whether the type is categorized as a compound type.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isMemberPointerType() const
bool isMatrixType() const
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
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.
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
bool isStructureOrClassType() const
bool isMemberFunctionPointerType() const
bool isVectorType() const
bool isRealFloatingType() const
Floating point categories.
bool isFloatingType() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
bool isAnyPointerType() const
TypeClass getTypeClass() 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
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
bool isScopedEnumeralType() const
Determine whether this type is a scoped enumeration type.
Simple class containing the result of Sema::CorrectTypo.
SourceRange getCorrectionRange() const
void WillReplaceSpecifier(bool ForceReplacement)
unsigned getEditDistance(bool Normalized=true) const
Gets the "edit distance" of the typo correction from the typo.
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
void setCorrectionDecl(NamedDecl *CDecl)
Clears the list of NamedDecls before adding the new one.
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represents a C++ unqualified-id that has been parsed.
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 ...
The iterator over UnresolvedSets.
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.
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
bool isUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
Represents a GCC generic vector type.
unsigned getNumElements() const
bool isTypeConstraint() const
bool isSubstitutionFailure() const
TemplateParameterList * getTypeConstraintTemplateParameterList() 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.
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.
Requirement::SubstitutionDiagnostic * createSubstDiagAt(Sema &S, SourceLocation Location, EntityPrinter Printer)
create a Requirement::SubstitutionDiagnostic with only a SubstitutedEntity and DiagLoc using Sema's a...
bool NE(InterpState &S, CodePtr OpPC)
bool This(InterpState &S, CodePtr OpPC)
bool Cast(InterpState &S, CodePtr OpPC)
std::string toString(const til::SExpr *E)
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
The JSON file list parser is used to communicate input to InstallAPI.
bool isLambdaCallWithImplicitObjectParameter(const DeclContext *DC)
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
ArrayTypeTrait
Names for the array type traits.
unsigned getTypeTraitArity(TypeTrait T) LLVM_READONLY
Return the arity of the type trait T.
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.
std::optional< unsigned > getStackIndexOfNearestEnclosingCaptureCapableLambda(ArrayRef< const sema::FunctionScopeInfo * > FunctionScopes, ValueDecl *VarToCapture, Sema &S)
Examines the FunctionScopeInfo stack to determine the nearest enclosing lambda (to the current lambda...
bool isReservedInAllContexts(ReservedIdentifierStatus Status)
Determine whether an identifier is reserved in all contexts.
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
@ 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.
@ LCK_StarThis
Capturing the *this object by copy.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
bool isLambdaCallWithExplicitObjectParameter(const DeclContext *DC)
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ 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])
llvm::VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS)
ActionResult< Expr * > ExprResult
@ Class
The "class" keyword.
LangAS
Defines the address space values used by the address space qualifier of QualType.
CastKind
CastKind - The kind of operation required for a conversion.
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.
const char * getTraitSpelling(ExpressionTrait T) LLVM_READONLY
Return the spelling of the type trait TT. Never null.
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
const FunctionProtoType * T
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
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
@ 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.
@ Other
Other implicit parameter.
TypeTrait
Names for traits that operate specifically on types.
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.
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
MutableArrayRef< Expr * > MultiExprArg
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.
enum clang::DeclaratorChunk::@221 Kind
SourceLocation Loc
Loc - The place where this type was defined.
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
FunctionType::ExtInfo ExtInfo
Parts of a decomposed MSGuidDecl.
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
ReferenceConversions
The conversions that would be performed on an lvalue of type T2 when binding a reference of type T1 t...
std::unique_ptr< TypoCorrectionConsumer > Consumer
Information about a template-id annotation token.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
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.
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...