Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/SemaExprCXX_8cpp_source.html below:

clang: lib/Sema/SemaExprCXX.cpp Source File

;

llvm_unreachable(

);

);

*RD = dyn_cast<CXXRecordDecl>(ND);

(RD && RD->isInjectedClassName()) {

InjectedClassName = RD;

(!InjectedClassName) {

diag::err_incomplete_nested_name_spec) << CurClass << SS.

();

EnteringContext) {

Failed =

;

IsAcceptableResult = [&](

*

) ->

{

*

= dyn_cast<TypeDecl>(

->getUnderlyingDecl());

NumAcceptableResults = 0;

(IsAcceptableResult(

))

++NumAcceptableResults;

(

*RD = dyn_cast<CXXRecordDecl>(

))

(RD->isInjectedClassName())

= cast<NamedDecl>(RD->getParent());

(FoundDeclSet.insert(

).second)

FoundDecls.push_back(

);

(

.isAmbiguous() && NumAcceptableResults == 1) {

(NameLoc, diag::ext_dtor_name_ambiguous);

(

*TD = dyn_cast<TypeDecl>(

->getUnderlyingDecl()))

(!IsAcceptableResult(

))

(

.isAmbiguous())

(IsAcceptableResult(

)) {

IsDependent =

;

LookupInObjectType = [&]() ->

{

(Failed || SearchType.

())

CheckLookupResult(

);

CheckLookupResult(

);

CheckLookupResult(

);

(

= LookupInNestedNameSpec(PrefixSS))

NumNonExtensionDecls = FoundDecls.size();

(

+ II.

()).str());

(SS.

(), diag::ext_qualified_dtor_named_in_lexical_scope)

(FoundDecls.back()->getLocation(), diag::note_destructor_type_here)

FoundDecls.resize(NumNonExtensionDecls);

std::stable_sort(FoundDecls.begin(), FoundDecls.end(),

return isa<TypeDecl>(A->getUnderlyingDecl()) >

isa<TypeDecl>(B->getUnderlyingDecl());

MakeFixItHint = [&]{

(!SearchType.

())

Destroyed = dyn_cast_or_null<CXXRecordDecl>(S->getEntity());

(FoundDecls.empty()) {

(NameLoc, diag::err_undeclared_destructor_name)

<< &II << MakeFixItHint();

}

(!SearchType.

() && FoundDecls.size() == 1) {

(

*TD = dyn_cast<TypeDecl>(FoundDecls[0]->getUnderlyingDecl())) {

assert(!SearchType.

() &&

);

(NameLoc, diag::err_destructor_expr_type_mismatch)

<<

<< SearchType << MakeFixItHint();

(NameLoc, diag::err_destructor_expr_nontype)

<< &II << MakeFixItHint();

(NameLoc, SearchType.

() ? diag::err_destructor_name_nontype

: diag::err_destructor_expr_mismatch)

<< &II << SearchType << MakeFixItHint();

(

*TD = dyn_cast<TypeDecl>(FoundD->getUnderlyingDecl()))

(FoundD->getLocation(), diag::note_destructor_type_here)

(FoundD->getLocation(), diag::note_destructor_nontype_here)

);

Name.getSourceRange(),

(StringRef(

) + II->

()).str());

(

, diag::warn_deprecated_literal_operator_id) << II << Hint;

(

, diag::warn_reserved_extern_symbol)

<< II << static_cast<int>(Status) << Hint;

(Name.getBeginLoc(), diag::err_literal_operator_id_outside_namespace)

llvm_unreachable(

);

(

(TypeidLoc, diag::err_variably_modified_typeid) <<

);

WasEvaluated =

;

*RecordD = cast<CXXRecordDecl>(RecordT->getDecl());

WasEvaluated =

;

(

(TypeidLoc, diag::err_variably_modified_typeid)

? diag::warn_side_effects_typeid

: diag::warn_side_effects_unevaluated_context);

(

(OpLoc, diag::err_openclcxx_not_supported)

(

(OpLoc, diag::err_need_header_before_typeid));

(

(OpLoc, diag::err_need_header_before_typeid));

(

(OpLoc, diag::err_no_typeid_with_fno_rtti));

(

*CTE = dyn_cast<CXXTypeidExpr>(

.get()))

(CTE->isPotentiallyEvaluated() && !CTE->isMostDerived(

))

(OpLoc, diag::warn_no_typeid_with_rtti_disabled)

(

*Uuid = TD->getMostRecentDecl()->getAttr<UuidAttr>()) {

UuidAttrs.insert(Uuid);

(

*CTSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {

UuidAttr *UuidForTA =

;

UuidAttrs.insert(UuidForTA);

(!Operand->getType()->isDependentType()) {

(UuidAttrs.empty())

(

(TypeidLoc, diag::err_uuidof_without_guid));

(UuidAttrs.size() > 1)

(

(TypeidLoc, diag::err_uuidof_with_multiple_guids));

Guid = UuidAttrs.back()->getGuidDecl();

(UuidAttrs.empty())

(

(TypeidLoc, diag::err_uuidof_without_guid));

(UuidAttrs.size() > 1)

(

(TypeidLoc, diag::err_uuidof_with_multiple_guids));

Guid = UuidAttrs.back()->getGuidDecl();

assert((Kind == tok::kw_true || Kind == tok::kw_false) &&

);

IsThrownVarInScope =

;

(

*DRE = dyn_cast<DeclRefExpr>(Ex->

()))

(

*Var = dyn_cast<VarDecl>(DRE->getDecl());

Var && Var->hasLocalStorage() &&

!Var->getType().isVolatileQualified()) {

(; S; S = S->getParent()) {

(S->isDeclScope(Var)) {

IsThrownVarInScope =

;

IsThrownVarInScope) {

IsOpenMPGPUTarget =

().OpenMPIsTargetDevice && (

.isNVPTX() ||

.isAMDGCN());

(!IsOpenMPGPUTarget && !

().CXXExceptions &&

(OpLoc, diag::err_exceptions_disabled) <<

;

(IsOpenMPGPUTarget)

(OpLoc, diag::warn_throw_not_valid_on_target) <<

.str();

<<

<< llvm::to_underlying(

().CurrentTarget());

(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) <<

;

(OpLoc, diag::err_acc_branch_in_out_compute_construct)

llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,

llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,

llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,

ParentIsPublic) {

*BaseDecl = BS.getType()->getAsCXXRecordDecl();

NewSubobject = VBases.insert(BaseDecl).second;

NewSubobject =

;

++SubobjectsSeen[BaseDecl];

PublicPath = ParentIsPublic && BS.getAccessSpecifier() ==

;

PublicSubobjectsSeen.insert(BaseDecl);

llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;

llvm::SmallSet<CXXRecordDecl *, 2> VBases;

llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;

SubobjectsSeen[RD] = 1;

PublicSubobjectsSeen.insert(RD);

(

*PublicSubobject : PublicSubobjectsSeen) {

(SubobjectsSeen[PublicSubobject] > 1)

Objects.push_back(PublicSubobject);

isPointer =

;

isPointer ? diag::err_throw_incomplete_ptr

: diag::err_throw_incomplete,

diag::err_throw_abstract_type,

))

(diag::err_access_dtor_exception) << Ty);

(

*Subobject : UnambiguousPublicSubobjects) {

(ExnObjAlign < TypeAlign) {

(ThrowLoc, diag::warn_throw_underaligned_obj);

(ThrowLoc, diag::note_throw_underaligned_obj)

(!isPointer &&

().AssumeNothrowExceptionDtor) {

Ty = Dtor->getType();

(ThrowLoc, diag::err_throw_object_throwing_dtor) << RD;

(

I = FunctionScopes.size();

I-- && isa<LambdaScopeInfo>(FunctionScopes[I]) &&

cast<LambdaScopeInfo>(FunctionScopes[I])->CallOperator);

CurLSI = cast<LambdaScopeInfo>(FunctionScopes[I]);

(

.isCopyCapture()) {

);

IsThisCaptured =

[](

*Closure,

&IsByCopy,

&IsConst) {

(

&&

: Closure->

()) {

(

.capturesThis()) {

IsByCopyCapture =

;

IsConstCapture =

;

IsThisCaptured(Closure, IsByCopyCapture, IsConstCapture)) {

(IsByCopyCapture) {

(method && method->isImplicitObjectMemberFunction())

ThisTy = method->getThisType().getNonReferenceType();

: S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(

)

(!Enabled || !ContextDecl)

= Template->getTemplatedDecl();

= cast<CXXRecordDecl>(ContextDecl);

this->Enabled =

;

.

(DiagLoc, diag::note_lambda_this_capture_fixit)

BuildAndDiagnose,

*

FunctionScopeIndexToStopAt,

ByCopy) {

assert((!ByCopy ||

) &&

);

MaxFunctionScopesIndex = FunctionScopeIndexToStopAt

? *FunctionScopeIndexToStopAt

NumCapturingClosures = 0;

(

idx = MaxFunctionScopesIndex; idx >= 0; idx--) {

(CSI->CXXThisCaptureIndex != 0) {

CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed(BuildAndDiagnose);

(BuildAndDiagnose) {

(

, diag::err_this_capture)

<< (

&& idx == MaxFunctionScopesIndex);

(

&& idx == MaxFunctionScopesIndex)) {

NumCapturingClosures++;

(BuildAndDiagnose) {

(

, diag::err_this_capture)

<< (

&& idx == MaxFunctionScopesIndex);

(!BuildAndDiagnose)

;

isa<LambdaScopeInfo>(

[MaxFunctionScopesIndex])) &&

(

idx = MaxFunctionScopesIndex; NumCapturingClosures;

--idx, --NumCapturingClosures) {

isNested = NumCapturingClosures > 1;

(!

.isNull())

*Method = dyn_cast<CXXMethodDecl>(DC);

(Method && Method->isExplicitObjectMemberFunction()) {

(

, diag::err_invalid_this_use) << 1;

(

, diag::err_invalid_this_use) << 1;

(

, diag::err_invalid_this_use) << 0;

(This->isTypeDependent())

IsDependent = [&]() {

*LSI = dyn_cast<sema::LambdaScopeInfo>(

);

(LSI->Lambda && !LSI->Lambda->Encloses(

) &&

LSI->AfterParameterList)

(LSI->isCXXThisCaptured()) {

(!LSI->getCXXThisCapture().isCopyCapture())

*MD = LSI->CallOperator;

(MD->getType().isNull())

Ty && MD->isExplicitObjectMemberFunction() &&

This->setCapturedByCopyInLambdaWithExplicitObjectParameter(IsDependent);

ListInitialization) {

RParenOrBraceLoc, ListInitialization);

(!

.isInvalid() &&

.get()->isInstantiationDependent() &&

!

.get()->isTypeDependent())

(

.isInvalid())

RParenOrBraceLoc, exprs, Ty);

ListInitialization) {

? ListInitialization

TyBeginLoc, LParenOrBraceLoc, RParenOrBraceLoc)

(Deduced && !Deduced->

() &&

isa<DeducedTemplateSpecializationType>(Deduced)) {

}

(Deduced && !Deduced->

()) {

(ListInitialization) {

*ILE = cast<InitListExpr>(Exprs[0]);

Inits =

(ILE->getInits(), ILE->getNumInits());

(

(TyBeginLoc, diag::err_auto_expr_init_no_expression)

<< Ty << FullRange);

(Inits.size() > 1) {

*FirstBad = Inits[1];

diag::err_auto_expr_init_multiple_expressions)

<< Ty << FullRange);

(TyBeginLoc, diag::warn_cxx20_compat_auto_expr) << FullRange;

*Deduce = Inits[0];

(isa<InitListExpr>(Deduce))

<< ListInitialization << Ty << FullRange);

(

(TyBeginLoc, diag::err_auto_expr_deduction_failure)

<< Ty << Deduce->

() << FullRange

RParenOrBraceLoc, ListInitialization);

(Exprs.size() == 1 && !ListInitialization &&

!isa<InitListExpr>(Exprs[0])) {

*Arg = Exprs[0];

(!ListInitialization)

(

(TyBeginLoc, diag::err_value_init_for_array_type)

(

(TyBeginLoc, diag::err_init_for_function_type)

<< Ty << FullRange);

(ListInitialization &&

cast<InitListExpr>(Exprs[0])->getNumInits() == 0) {

Exprs[0]->getBeginLoc(), Exprs[0]->getEndLoc());

diag::err_invalid_incomplete_type_use,

(

.isInvalid())

Inner = BTE->getSubExpr();

(

*CE = dyn_cast<ConstantExpr>(Inner);

CE && CE->isImmediateInvocation())

Inner = CE->getSubExpr();

(!isa<CXXTemporaryObjectExpr>(Inner) &&

!isa<CXXScalarValueInitExpr>(Inner)) {

:

(LParenOrBraceLoc, RParenOrBraceLoc);

(

*

: R) {

(

*FD = dyn_cast<FunctionDecl>(

)) {

llvm::none_of(PreventedBy, [&](

*FD) {

);

UsualParams = 1;

(S.

().SizedDeallocation && UsualParams < FD->getNumParams() &&

(S.

().AlignedAllocation && UsualParams < FD->getNumParams() &&

UsualDeallocFnInfo {

UsualDeallocFnInfo() :

(), FD(nullptr) {}

NumBaseParams = 1;

(FD->isDestroyingOperatorDelete()) {

(NumBaseParams < FD->getNumParams() &&

FD->getParamDecl(NumBaseParams)->getType(),

(NumBaseParams < FD->getNumParams() &&

FD->getParamDecl(NumBaseParams)->getType()->isAlignValT()) {

HasAlignValT =

;

()

{

FD; }

isBetterThan(

UsualDeallocFnInfo &

,

WantSize,

WantAlign)

{

(Destroying !=

.Destroying)

(HasAlignValT !=

.HasAlignValT)

HasAlignValT == WantAlign;

(HasSizeT !=

.HasSizeT)

HasSizeT == WantSize;

CUDAPref >

.CUDAPref;

Destroying, HasSizeT, HasAlignValT;

UsualDeallocFnInfo Best;

(

I = R.

(),

= R.

(); I !=

; ++I) {

UsualDeallocFnInfo Info(S, I.getPair());

BestFns->push_back(Info);

(Best.isBetterThan(Info, WantSize, WantAlign))

(BestFns && Info.isBetterThan(Best, WantSize, WantAlign))

BestFns->push_back(Info);

(!record)

;

(ops.

())

;

Best && Best.HasSizeT;

std::optional<Expr *> ArraySize;

(

.getNumTypeObjects() > 0 &&

(

.getDeclSpec().hasAutoTypeSpec())

.DropFirstTypeObject();

(

I = 0, N =

.getNumTypeObjects(); I < N; ++I) {

(

*NumElts = (

*)Array.NumElts) {

(!NumElts->isTypeDependent() && !NumElts->isValueDependent()) {

NumElts,

, diag::err_new_array_nonconst,

)

(

.isInvalidType())

DirectInitRange = List->getSourceRange();

PlacementLParen, PlacementArgs, PlacementRParen,

TypeIdParens, AllocType, TInfo, ArraySize, DirectInitRange,

*

,

IsCPlusPlus20) {

IsCPlusPlus20 || PLE->getNumExprs() == 0;

(isa<ImplicitValueInitExpr>(

))

!CCE->isListInitialization() &&

CCE->getConstructor()->isDefaultConstructor();

assert(isa<InitListExpr>(

) &&

);

(!

().AlignedAllocationUnavailable)

std::optional<unsigned> AlignmentParam;

StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling(

IsDelete = Kind == OO_Delete || Kind == OO_Array_Delete;

(

, diag::err_aligned_allocation_unavailable)

<< OSVersion.getAsString() << OSVersion.empty();

(

, diag::note_silence_aligned_allocation_unavailable);

std::optional<Expr *> ArraySize,

(DirectInitRange.

()) {

assert(

&&

);

}

(isa_and_nonnull<InitListExpr>(

))

);

);

Exprs =

(List->getExprs(), List->getNumExprs());

(InitStyle) {

DirectInitRange.

());

llvm_unreachable(

);

(Deduced && !Deduced->isDeduced() &&

isa<DeducedTemplateSpecializationType>(Deduced)) {

(*ArraySize ? (*ArraySize)->getExprLoc() : TypeRange.

(),

diag::err_deduced_class_template_compound_type)

<< (*ArraySize ? (*ArraySize)->getSourceRange() : TypeRange));

AllocTypeInfo, Entity, Kind, Exprs);

(AllocType.

())

}

(Deduced && !Deduced->isDeduced()) {

*ILE = cast<InitListExpr>(Exprs[0]);

Inits =

(ILE->getInits(), ILE->getNumInits());

(

(StartLoc, diag::err_auto_new_requires_ctor_arg)

<< AllocType << TypeRange);

(Inits.size() > 1) {

*FirstBad = Inits[1];

diag::err_auto_new_ctor_multiple_expressions)

<< AllocType << TypeRange);

<< AllocType << TypeRange;

*Deduce = Inits[0];

(isa<InitListExpr>(Deduce))

<< Braced << AllocType << TypeRange);

(

(StartLoc, diag::err_auto_new_deduction_failure)

<< AllocType << Deduce->

() << TypeRange

AllocType = Array->getElementType();

(ArraySize && *ArraySize &&

(*ArraySize)->getType()->isNonOverloadPlaceholderType()) {

ArraySize = result.

();

std::optional<uint64_t> KnownArraySize;

(ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {

(*ArraySize)->getType()->getAs<

>())

(StartLoc, diag::warn_cxx98_compat_array_size_conversion)

<< (*ArraySize)->getType() << 0 <<

;

SizeConvertDiagnoser(

*ArraySize)

ArraySize(ArraySize) {}

S.

(

, diag::err_array_size_not_integral)

S.

(

, diag::err_array_size_incomplete_type)

S.

(

, diag::err_array_size_explicit_conversion) <<

<< ConvTy;

S.

(Conv->

(), diag::note_array_size_conversion)

S.

(

, diag::err_array_size_ambiguous_conversion) <<

;

S.

(Conv->

(), diag::note_array_size_conversion)

? diag::warn_cxx98_compat_array_size_conversion

: diag::ext_array_size_conversion)

} SizeDiagnoser(*ArraySize);

ArraySize = ConvertedSize.

();

SizeType = (*ArraySize)->getType();

(std::optional<llvm::APSInt>

=

(*ArraySize)->getIntegerConstantExpr(

)) {

(

->isSigned() &&

->isNegative()) {

diag::err_typecheck_negative_array_size)

<< (*ArraySize)->getSourceRange());

ActiveSizeBits =

((*ArraySize)->getBeginLoc(), diag::err_array_too_large)

<<

(*

, 10) << (*ArraySize)->getSourceRange());

KnownArraySize =

->getZExtValue();

}

(TypeIdParens.

()) {

((*ArraySize)->getBeginLoc(), diag::ext_new_paren_array_nonconst)

<< (*ArraySize)->getSourceRange()

Alignment =

PassAlignment =

().AlignedAllocation &&

Alignment > NewAlignment;

AllocType, ArraySize.has_value(), PassAlignment, PlacementArgs,

OperatorNew, OperatorDelete))

UsualArrayDeleteWantsSize =

;

UsualArrayDeleteWantsSize =

NumImplicitArgs = PassAlignment ? 2 : 1;

NumImplicitArgs, PlacementArgs, AllPlaceArgs,

(!AllPlaceArgs.empty())

PlacementArgs = AllPlaceArgs;

llvm::APInt SingleEltSize(

std::optional<llvm::APInt> AllocationSize;

AllocationSize = SingleEltSize;

AllocationSize = llvm::APInt(SizeTyWidth, *KnownArraySize)

.umul_ov(SingleEltSize, Overflow);

);

, AllocationSize.value_or(llvm::APInt::getZero(SizeTyWidth)),

CK_IntegralCast, &AlignmentLiteral,

CallArgs.reserve(NumImplicitArgs + PlacementArgs.size());

CallArgs.emplace_back(AllocationSize

?

*

(&AllocationSizeLiteral)

: &OpaqueAllocationSize);

CallArgs.emplace_back(&DesiredAlignment);

CallArgs.insert(CallArgs.end(), PlacementArgs.begin(), PlacementArgs.end());

(OperatorNew, Proto,

, CallArgs,

, StartLoc,

, CallType);

(PlacementArgs.empty() && !PassAlignment &&

(OperatorNew->isImplicit() ||

(OperatorNew->getBeginLoc().isValid() &&

(Alignment > NewAlignment)

(StartLoc, diag::warn_overaligned_type)

InitRange(Exprs.front()->getBeginLoc(),

Exprs.back()->getEndLoc());

(StartLoc, diag::err_new_array_init_args) << InitRange;

InitType = AllocType;

dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.

()))

FullInit = Binder->getSubExpr();

(ArraySize && !*ArraySize) {

(TypeRange.

(), diag::err_new_array_size_unknown_from_init)

(OperatorDelete) {

PassAlignment, UsualArrayDeleteWantsSize,

PlacementArgs, TypeIdParens, ArraySize, InitStyle,

(

, diag::err_bad_new_type)

<< AllocType << 0 << R;

(

, diag::err_bad_new_type)

<< AllocType << 1 << R;

, AllocType, diag::err_new_incomplete_or_sizeless_type, R))

diag::err_allocation_of_abstract_type))

(

, diag::err_variably_modified_new_type)

(

, diag::err_address_space_qualified_new)

(

, diag::err_arc_new_array_without_ownership)

Alloc != AllocEnd; ++Alloc) {

*

= (*Alloc)->getUnderlyingDecl();

(PassAlignment) {

PassAlignment =

;

Args.erase(Args.begin() + 1);

Operator, &Candidates, AlignArg,

(Args[1]->getType()->isObjectPointerType() ||

Args[1]->getType()->isArrayType())) {

S.

(R.

(), diag::err_need_header_before_placement_new)

(AlignedCandidates) {

.Function->getNumParams() > 1 &&

.Function->getParamDecl(1)->getType()->isAlignValT();

AlignedArgs.reserve(Args.size() + 1);

AlignedArgs.push_back(Args[0]);

AlignedArgs.push_back(AlignArg);

AlignedArgs.append(Args.begin() + 1, Args.end());

S.

(R.

(), diag::err_ovl_no_viable_function_in_call)

(AlignedCandidates)

AlignedCandidates->

(S, AlignedArgs, AlignedCands,

,

S.

(diag::err_ovl_ambiguous_call)

Candidates, Best->Function, Args);

llvm_unreachable(

);

AllocArgs.reserve((PassAlignment ? 2 : 1) + PlaceArgs.size());

AllocArgs.push_back(&Size);

(PassAlignment) {

AllocArgs.push_back(&Align);

AllocArgs.insert(AllocArgs.end(), PlaceArgs.begin(), PlaceArgs.end());

IsArray ? OO_Array_New : OO_New);

(PlaceArgs.empty()) {

(StartLoc, diag::err_openclcxx_not_supported) <<

;

(StartLoc, diag::err_openclcxx_placement_new);

assert(!R.

() &&

);

assert(!R.

() &&

);

OperatorNew,

,

OperatorDelete =

;

OperatorNew->getDeclName().getCXXOverloadedOperator() == OO_Array_New

(Filter.hasNext()) {

*FD = dyn_cast<FunctionDecl>(Filter.next()->getUnderlyingDecl());

(FD && FD->isDestroyingOperatorDelete())

FoundGlobalDelete = FoundDelete.

();

(FoundDelete.

()) {

isPlacementNew = !PlaceArgs.empty() || OperatorNew->param_size() != 1 ||

OperatorNew->isVariadic();

(isPlacementNew) {

(

I = 1, N = Proto->getNumParams(); I < N; ++I)

ArgTypes.push_back(Proto->getParamType(I));

EPI.

= Proto->isVariadic();

ExpectedFunctionType

DEnd = FoundDelete.

();

dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {

Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());

ExpectedFunctionType,

ExpectedFunctionType))

Matches.push_back(std::make_pair(

.getPair(), Fn));

*

, FoundDelete,

FoundGlobalDelete,

Matches.push_back(std::make_pair(Selected.Found, Selected.FD));

(

Fn : BestDeallocFns)

Matches.push_back(std::make_pair(Fn.Found, Fn.FD));

(Matches.size() == 1) {

OperatorDelete = Matches[0].second;

UsualDeallocFnInfo Info(*

,

IsSizedDelete = Info.HasSizeT;

(IsSizedDelete && !FoundGlobalDelete) {

NonSizedDelete =

(NonSizedDelete && !NonSizedDelete.HasSizeT &&

NonSizedDelete.HasAlignValT == Info.HasAlignValT)

IsSizedDelete =

;

(IsSizedDelete) {

PlaceArgs.back()->getEndLoc());

(StartLoc, diag::err_placement_new_non_placement_delete) << R;

(!OperatorDelete->isImplicit())

(OperatorDelete->getLocation(), diag::note_previous_decl)

}

(!Matches.empty()) {

(StartLoc, diag::warn_ambiguous_suitable_delete_function_found)

<< DeleteName << AllocElemType;

(

&Match : Matches)

(Match.second->getLocation(),

diag::note_member_declared_here) << DeleteName;

(TheGlobalModuleFragment) {

(TheGlobalModuleFragment) {

AlignValT->setModuleOwnershipKind(

AlignValT->setLocalOwningModule(TheGlobalModuleFragment);

AlignValT->setImplicit(

);

Params.push_back(Param);

HasSizedVariant =

().SizedDeallocation &&

(Kind == OO_Delete || Kind == OO_Array_Delete);

HasAlignedVariant =

().AlignedAllocation;

NumSizeVariants = (HasSizedVariant ? 2 : 1);

NumAlignVariants = (HasAlignedVariant ? 2 : 1);

(

Sized = 0; Sized < NumSizeVariants; ++Sized) {

Params.push_back(SizeT);

(

Aligned = 0; Aligned < NumAlignVariants; ++Aligned) {

DeclareGlobalAllocationFunctions(OO_New, VoidPtr, SizeT);

DeclareGlobalAllocationFunctions(OO_Array_New, VoidPtr, SizeT);

DeclareGlobalAllocationFunctions(OO_Delete,

.

, VoidPtr);

DeclareGlobalAllocationFunctions(OO_Array_Delete,

.

, VoidPtr);

PopGlobalModuleFragment();

Alloc != AllocEnd; ++Alloc) {

(

->getNumParams() == Params.size()) {

(

*

:

->parameters())

FuncParams.push_back(

->setVisibleDespiteOwningModule();

,

,

));

HasBadAllocExceptionSpec

= (Name.getCXXOverloadedOperator() == OO_New ||

Name.getCXXOverloadedOperator() == OO_Array_New);

(HasBadAllocExceptionSpec) {

assert(

&&

);

CreateAllocationFunctionDecl = [&](

*ExtraAttr) {

Alloc->setImplicit();

Alloc->setVisibleDespiteOwningModule();

(HasBadAllocExceptionSpec &&

().NewInfallible &&

ReturnsNonNullAttr::CreateImplicit(

, Alloc->getLocation()));

(TheGlobalModuleFragment) {

Alloc->setModuleOwnershipKind(

Alloc->setLocalOwningModule(TheGlobalModuleFragment);

Alloc->addAttr(VisibilityAttr::CreateImplicit(

? VisibilityAttr::Hidden

? VisibilityAttr::Protected

: VisibilityAttr::Default));

,

,

));

ParamDecls.back()->setImplicit();

Alloc->setParams(ParamDecls);

Alloc->addAttr(ExtraAttr);

CreateAllocationFunctionDecl(

);

CreateAllocationFunctionDecl(CUDAHostAttr::CreateImplicit(

));

CreateAllocationFunctionDecl(CUDADeviceAttr::CreateImplicit(

));

CanProvideSize,

assert(

.FD &&

);

OperatorDelete;

WantSize,

WantAligned) {

(

.isAmbiguous())

.suppressDiagnostics();

Overaligned, &Matches);

(Matches.size() == 1) {

Operator = cast<CXXMethodDecl>(Matches[0].FD);

(StartLoc, diag::err_deleted_function_use)

<< (Msg !=

) << (Msg ? Msg->

() : StringRef());

(!Matches.empty()) {

(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found)

(

&Match : Matches)

(Match.FD->getLocation(), diag::note_member_declared_here) << Name;

(!

.empty()) {

(StartLoc, diag::err_no_suitable_delete_member_function_found)

diag::note_member_declared_here) << Name;

Operator =

;

MismatchingNewDeleteDetector {

MismatchResult {

MemberInitMismatches,

MismatchingNewDeleteDetector(

EndOfTU)

: Field(nullptr), IsArrayForm(

), EndOfTU(EndOfTU),

HasUndefinedConstructors(

) {}

MismatchResult analyzeField(

*Field,

DeleteWasArrayForm);

HasUndefinedConstructors;

MismatchResult analyzeMemberExpr(

*ME);

MismatchResult analyzeInClassInitializer();

MismatchingNewDeleteDetector::MismatchResult

MismatchingNewDeleteDetector::analyzeDeleteExpr(

*DE) {

assert(DE &&

);

(

*ME = dyn_cast<const MemberExpr>(

)) {

analyzeMemberExpr(ME);

}

(

*

= dyn_cast<const DeclRefExpr>(

)) {

(!hasMatchingVarInit(

))

VarInitMismatches;

MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(

*

) {

assert(

!=

&&

);

(

*ILE = dyn_cast<const InitListExpr>(

)) {

(ILE->getNumInits() == 1)

= dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts());

dyn_cast_or_null<const CXXNewExpr>(

);

MismatchingNewDeleteDetector::hasMatchingNewInCtorInit(

(NE = getNewExprFromInitListOrExpr(CI->

()))) {

(

->isArray() == IsArrayForm)

NewExprs.push_back(NE);

MismatchingNewDeleteDetector::hasMatchingNewInCtor(

HasUndefinedConstructors =

;

(

*CI : cast<const CXXConstructorDecl>(

)->inits()) {

(hasMatchingNewInCtorInit(CI))

MismatchingNewDeleteDetector::MismatchResult

MismatchingNewDeleteDetector::analyzeInClassInitializer() {

assert(Field !=

&&

);

*InitExpr =

->getInClassInitializer();

EndOfTU ? NoMismatch : AnalyzeLater;

(

*NE = getNewExprFromInitListOrExpr(InitExpr)) {

(

->isArray() != IsArrayForm) {

NewExprs.push_back(NE);

MemberInitMismatches;

MismatchingNewDeleteDetector::MismatchResult

MismatchingNewDeleteDetector::analyzeField(

*Field,

DeleteWasArrayForm) {

assert(Field !=

&&

);

this->Field =

;

IsArrayForm = DeleteWasArrayForm;

(

*CD : RD->

()) {

(hasMatchingNewInCtor(CD))

(HasUndefinedConstructors)

EndOfTU ? NoMismatch : AnalyzeLater;

(!NewExprs.empty())

MemberInitMismatches;

->hasInClassInitializer() ? analyzeInClassInitializer()

MismatchingNewDeleteDetector::MismatchResult

MismatchingNewDeleteDetector::analyzeMemberExpr(

*ME) {

assert(ME !=

&&

);

analyzeField(F, IsArrayForm);

MismatchingNewDeleteDetector::hasMatchingVarInit(

*

) {

(

*VD = dyn_cast<const VarDecl>(

->getDecl())) {

(VD->hasInit() && (NE = getNewExprFromInitListOrExpr(VD->getInit())) &&

->isArray() != IsArrayForm) {

NewExprs.push_back(NE);

NewExprs.empty();

MismatchingNewDeleteDetector &Detector) {

(!Detector.IsArrayForm)

.

(DeleteLoc, diag::warn_mismatched_delete_new)

<< Detector.IsArrayForm << H;

(

*NE : Detector.NewExprs)

.

(NE->getExprLoc(), diag::note_allocated_here)

<< Detector.IsArrayForm;

Sema::AnalyzeDeleteExprMismatch(

*DE) {

MismatchingNewDeleteDetector Detector(

);

(Detector.analyzeDeleteExpr(DE)) {

MismatchingNewDeleteDetector::VarInitMismatches:

MismatchingNewDeleteDetector::MemberInitMismatches: {

MismatchingNewDeleteDetector::AnalyzeLater: {

MismatchingNewDeleteDetector::NoMismatch:

DeleteWasArrayForm) {

MismatchingNewDeleteDetector Detector(

);

(Detector.analyzeField(Field, DeleteWasArrayForm)) {

MismatchingNewDeleteDetector::VarInitMismatches:

llvm_unreachable(

);

MismatchingNewDeleteDetector::AnalyzeLater:

llvm_unreachable(

);

MismatchingNewDeleteDetector::MemberInitMismatches:

MismatchingNewDeleteDetector::NoMismatch:

ArrayForm,

*ExE) {

ArrayFormAsWritten = ArrayForm;

UsualArrayDeleteWantsSize =

;

(ConvPtrType->getPointeeType()->isIncompleteOrObjectType())

S.

(

, diag::err_delete_operand) <<

;

S.

(

, diag::err_delete_incomplete_class_type) <<

;

S.

(

, diag::err_delete_explicit_conversion) <<

<< ConvTy;

S.

(

, diag::err_ambiguous_delete_operand) <<

;

llvm_unreachable(

);

(!Converter.match(

))

diag::err_address_space_qualified_delete)

(StartLoc,

.CPlusPlus26 ? diag::err_delete_incomplete

: diag::ext_delete_void_ptr_operand)

(

(StartLoc, diag::err_delete_operand)

? diag::err_delete_incomplete

: diag::warn_delete_incomplete,

PointeeRD = cast<CXXRecordDecl>(RT->getDecl());

(StartLoc, diag::warn_delete_array_type)

ArrayForm ? OO_Array_Delete : OO_Delete);

UsualArrayDeleteWantsSize =

(isa_and_nonnull<CXXMethodDecl>(OperatorDelete))

UsualArrayDeleteWantsSize =

UsualDeallocFnInfo(*

,

(Dtor->isCalledByDelete(OperatorDelete)) {

(!OperatorDelete) {

(StartLoc, diag::err_openclcxx_not_supported) <<

;

CanProvideSize =

IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||

Overaligned, DeleteName);

(OperatorDelete->isInvalidDecl())

IsVirtualDelete =

;

(Dtor->isCalledByDelete(OperatorDelete))

(diag::err_access_dtor) << PointeeElem);

IsVirtualDelete = Dtor->isVirtual();

ParamType = OperatorDelete->getParamDecl(0)->getType();

.

, UseGlobal, ArrayForm, ArrayFormAsWritten,

UsualArrayDeleteWantsSize, OperatorDelete, Ex.

(), StartLoc);

AnalyzeDeleteExprMismatch(

);

IsDelete ? OO_Delete : OO_New);

assert(!R.

() &&

);

assert(!R.

() &&

);

FnOvl != FnOvlEnd; ++FnOvl) {

*

= (*FnOvl)->getUnderlyingDecl();

);

S.

(R.

(), diag::err_builtin_operator_new_delete_not_usual)

<< (IsDelete ? 1 : 0) <<

;

S.

(FnDecl->

(), diag::note_non_usual_function_declared_here)

S.

(diag::err_ovl_no_viable_function_in_call)

S.

(diag::err_ovl_ambiguous_call)

Candidates, Best->Function, Args);

llvm_unreachable(

);

*TheCall = cast<CallExpr>(TheCallResult.

());

(TheCall->

(), diag::err_builtin_requires_language)

<< (IsDelete ?

:

)

OperatorNewOrDelete))

assert(OperatorNewOrDelete &&

);

(

i = 0; i != TheCall->

(); ++i) {

assert(Callee &&

->getCastKind() == CK_BuiltinFnToFnPtr &&

);

TheCallResult;

IsDelete,

CallCanBeVirtual,

WarnOnNonAbstractTypes,

(

, diag::warn_delete_abstract_non_virtual_dtor) << (IsDelete ? 0 : 1)

}

(WarnOnNonAbstractTypes) {

(

, diag::warn_delete_non_virtual_dtor) << (IsDelete ? 0 : 1)

std::string TypeStr;

(DtorLoc, diag::note_delete_non_virtual)

(

.isInvalid())

diag::err_invalid_use_of_function_type)

diag::err_invalid_use_of_array_type)

llvm_unreachable(

);

diag::err_constexpr_if_condition_expression_is_not_constant);

From = Cast->getSubExpr();

(!ToPtrType->getPointeeType().hasQualifiers()) {

(StrLit->getKind()) {

(ToPointeeType->getKind() == BuiltinType::Char_U ||

ToPointeeType->getKind() == BuiltinType::Char_S);

assert(

&&

);

HadMultipleCandidates,

: llvm_unreachable(

);

CK_ConstructorConversion: {

diag::err_allocation_of_abstract_type))

CastLoc, Ty, FoundDecl, cast<CXXConstructorDecl>(Method),

ConstructorArgs, HadMultipleCandidates,

,

,

,

(

.isInvalid())

CK_UserDefinedConversion: {

HadMultipleCandidates);

(

.isInvalid())

CK_UserDefinedConversion,

.get(),

,

.get()->getValueKind(),

assert(FD &&

);

= CK_UserDefinedConversion;

= CK_ConstructorConversion;

From = CastArg.

();

(diag::err_typecheck_ambiguous_condition)

llvm_unreachable(

);

ToType, From->

(), From, Action);

assert(Diagnosed &&

); (void)Diagnosed;

ElType = ToVec->getElementType();

,

,

,

,

,

,

ToAtomicType = ToType;

ToType = ToAtomic->getValueType();

InitialFromType = FromType;

(SCS.

) {

FromType = FromAtomic->getValueType().getUnqualifiedType();

From = FromRes.

();

);

llvm_unreachable(

);

);

CK = CK_FloatingComplexCast;

CK = CK_FloatingComplexToIntegralComplex;

CK = CK_IntegralComplexToFloatingComplex;

CK = CK_IntegralComplexCast;

, CCK).

();

, CCK).

();

, CCK).

();

, CCK).

();

, CCK).

();

, CCK).

();

, CCK).

();

diag::ext_typecheck_convert_incompatible_pointer)

diag::ext_typecheck_convert_incompatible_pointer)

}

(

().allowsNonTrivialObjCLifetimeQualifiers() &&

!

().CheckObjCARCUnavailableWeakConversion(ToType,

(From->

(), diag::err_arc_convesion_of_weak_unavailable)

(!FromPteeType.

() && !ToPteeType.

() &&

(Kind == CK_BlockPointerToObjCPointerCast) {

&BasePath, CCK).

();

ElType = ToComplex->getElementType();

isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).

();

isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).

();

isFloatingComplex ? CK_FloatingRealToComplex

: CK_IntegralRealToComplex).

();

ElType = FromComplex->getElementType();

isFloatingComplex ? CK_FloatingComplexToReal

: CK_IntegralComplexToReal,

isFloatingComplex ? CK_FloatingCast

: CK_IntegralToFloating,

isFloatingComplex ? CK_FloatingToIntegral

AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;

From = FromRes.

();

);

CK_ZeroToOCLOpaqueType,

llvm_unreachable(

);

);

);

TruncTy = FromVec->getElementType();

llvm_unreachable(

);

(SCS.

) {

CK = CK_AddressSpaceConversion;

CK = CK_AddressSpaceConversion;

<< InitialFromType << ToType;

? diag::ext_deprecated_string_literal_conversion

: diag::warn_deprecated_string_literal_conversion)

llvm_unreachable(

);

(!ToAtomicType.

()) {

S.

(

->getTypeLoc().getBeginLoc(), diag::err_vla_unsupported)

<< 1 << TypeTraitID;

S.

(

->getTypeLoc().getBeginLoc(), diag::err_atomic_unsupported)

: llvm_unreachable(

);

UTT_IsCompleteType:

UTT_IsIntegral:

UTT_IsFloatingPoint:

UTT_IsBoundedArray:

UTT_IsReferenceable:

UTT_IsLvalueReference:

UTT_IsRvalueReference:

UTT_IsMemberFunctionPointer:

UTT_IsMemberObjectPointer:

UTT_IsScopedEnum:

UTT_IsFunction:

UTT_IsReference:

UTT_IsArithmetic:

UTT_IsFundamental:

UTT_IsCompound:

UTT_IsMemberPointer:

UTT_IsTypedResourceElementCompatible:

UTT_IsVolatile:

UTT_IsUnboundedArray:

UTT_IsUnsigned:

UTT_IsInterfaceClass:

UTT_IsPolymorphic:

UTT_IsAbstract:

, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);

, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);

UTT_IsAggregate:

UTT_IsImplicitLifetime:

, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);

UTT_IsTriviallyCopyable:

UTT_IsStandardLayout:

UTT_IsBitwiseCloneable:

UTT_IsTriviallyRelocatable:

UTT_IsTriviallyEqualityComparable:

UTT_CanPassInRegs:

UTT_HasNothrowAssign:

UTT_HasNothrowMoveAssign:

UTT_HasNothrowConstructor:

UTT_HasNothrowCopy:

UTT_HasTrivialAssign:

UTT_HasTrivialMoveAssign:

UTT_HasTrivialDefaultConstructor:

UTT_HasTrivialMoveConstructor:

UTT_HasTrivialCopy:

UTT_HasTrivialDestructor:

UTT_HasVirtualDestructor:

UTT_HasUniqueObjectRepresentations:

UTT_IsDestructible:

UTT_IsNothrowDestructible:

UTT_IsTriviallyDestructible:

UTT_IsIntangibleType:

, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);

((RD->*HasTrivial)() && !(RD->*HasNonTrivial)())

(

.LookupQualifiedName(Res, RD)) {

FoundOperator =

;

Op != OpEnd; ++Op) {

(isa<FunctionTemplateDecl>(*Op))

((Operator->*IsDesiredOp)()) {

FoundOperator =

;

CPT =

.ResolveExceptionSpec(KeyLoc, CPT);

FoundOperator;

(

->isUnion())

(

->isLambda())

->isCapturelessLambda();

->getTypeForDecl()->getCanonicalTypeUnqualified().withConst(),

Functions, &Operand, &Operand);

*

= dyn_cast<CXXOperatorCallExpr>(

.get());

ParamT = Callee->getParamDecl(0)->getType();

(!Callee->isDefaulted())

(!ParamT->isReferenceType() && !

->isTriviallyCopyable())

(ParamT.getNonReferenceType()->getUnqualifiedDesugaredType() !=

->getTypeForDecl())

llvm::all_of(

->bases(),

if (const auto *RD = BS.getType()->getAsCXXRecordDecl())

return HasNonDeletedDefaultedEqualityComparison(

auto Type = FD->getType();

if (Type->isArrayType())

Type = Type->getBaseElementTypeUnsafe()

->getCanonicalTypeUnqualified();

if (Type->isReferenceType() || Type->isEnumeralType())

if (const auto *RD = Type->getAsCXXRecordDecl())

return HasNonDeletedDefaultedEqualityComparison(S, RD, KeyLoc);

CanonicalType,

);

assert(!

->

() &&

);

: llvm_unreachable(

);

UTT_IsIntegral:

UTT_IsFloatingPoint:

(

*CAT =

.getAsConstantArrayType(

))

CAT->getSize() != 0;

UTT_IsBoundedArray:

(

*CAT =

.getAsConstantArrayType(

))

CAT->getSize() != 0;

UTT_IsUnboundedArray:

UTT_IsLvalueReference:

UTT_IsRvalueReference:

UTT_IsMemberFunctionPointer:

UTT_IsMemberObjectPointer:

UTT_IsScopedEnum:

UTT_IsFunction:

UTT_IsReference:

UTT_IsArithmetic:

UTT_IsFundamental:

(

.getObjCLifetime()) {

UTT_IsCompound:

UTT_IsMemberPointer:

.isConstQualified();

UTT_IsVolatile:

.isVolatileQualified();

.isTrivialType(

);

UTT_IsTriviallyCopyable:

.isTriviallyCopyableType(

);

UTT_IsStandardLayout:

.isPODType(

);

UTT_IsPolymorphic:

UTT_IsAbstract:

UTT_IsAggregate:

UTT_IsInterfaceClass:

RD->

<FinalAttr>();

UTT_IsUnsigned:

UTT_HasTrivialDefaultConstructor:

(

.isPODType(

))

(

*RD =

.getBaseElementType(

)->getAsCXXRecordDecl())

UTT_HasTrivialMoveConstructor:

(

.isPODType(

))

(

*RD =

.getBaseElementType(

)->getAsCXXRecordDecl())

UTT_HasTrivialCopy:

UTT_HasTrivialMoveAssign:

(

.isPODType(

))

(

*RD =

.getBaseElementType(

)->getAsCXXRecordDecl())

UTT_HasTrivialAssign:

(

.isConstQualified())

(

.isPODType(

))

UTT_IsDestructible:

UTT_IsTriviallyDestructible:

UTT_IsNothrowDestructible:

(UTT == UTT_IsTriviallyDestructible &&

.isDestructedType())

(

*RD =

.getBaseElementType(

)->getAsCXXRecordDecl()) {

(UTT == UTT_IsNothrowDestructible) {

CPT =

.ResolveExceptionSpec(KeyLoc, CPT);

UTT_HasTrivialDestructor:

(

*RD =

.getBaseElementType(

)->getAsCXXRecordDecl())

UTT_HasNothrowAssign:

(

.getBaseElementType(

).isConstQualified())

UTT_HasNothrowMoveAssign:

(

.isPODType(

))

UTT_HasNothrowCopy:

FoundConstructor =

;

(

*ND :

.LookupConstructors(RD)) {

(isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))

(isa<UsingDecl>(ND))

*Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());

(Constructor->isCopyConstructor(FoundTQs)) {

FoundConstructor =

;

CPT =

.ResolveExceptionSpec(KeyLoc, CPT);

FoundConstructor;

UTT_HasNothrowConstructor:

(

*RD =

.getBaseElementType(

)->getAsCXXRecordDecl()) {

FoundConstructor =

;

(

*ND :

.LookupConstructors(RD)) {

(isa<FunctionTemplateDecl>(ND->getUnderlyingDecl()))

(isa<UsingDecl>(ND))

*Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl());

(Constructor->isDefaultConstructor()) {

FoundConstructor =

;

CPT =

.ResolveExceptionSpec(KeyLoc, CPT);

FoundConstructor;

UTT_HasVirtualDestructor:

UTT_IsCompleteType:

UTT_HasUniqueObjectRepresentations:

.hasUniqueObjectRepresentations(

);

UTT_IsTriviallyRelocatable:

.isTriviallyRelocatableType(

);

UTT_IsBitwiseCloneable:

.isBitwiseCloneableType(

);

UTT_IsReferenceable:

.isReferenceable();

UTT_CanPassInRegs:

.Diag(KeyLoc, diag::err_builtin_pass_in_regs_non_class) <<

;

UTT_IsTriviallyEqualityComparable:

UTT_IsImplicitLifetime: {

tok::kw___builtin_is_implicit_lifetime);

tok::kw___builtin_is_implicit_lifetime);

UTT_IsIntangibleType:

assert(

.getLangOpts().HLSL &&

);

diag::err_incomplete_type))

tok::kw___builtin_hlsl_is_intangible))

UTT_IsTypedResourceElementCompatible:

assert(

.getLangOpts().HLSL &&

);

.HLSL().IsTypedResourceElementCompatible(

);

KeyLoc, llvm::BumpPtrAllocator &OpaqueExprAllocator) {

LhsT =

.Context.getRValueReferenceType(LhsT);

(

.Failed())

(Kind <=

&& Kind != BTT_ReferenceBindsToTemporary &&

Kind != BTT_ReferenceConstructsFromTemporary &&

Kind != BTT_ReferenceConvertsFromTemporary)

Args[1], RParenLoc);

clang::BTT_ReferenceBindsToTemporary:

clang::BTT_ReferenceConstructsFromTemporary:

clang::BTT_ReferenceConvertsFromTemporary:

clang::TT_IsConstructible:

clang::TT_IsNothrowConstructible:

clang::TT_IsTriviallyConstructible: {

assert(!Args.empty());

(

*TSI : Args) {

diag::err_incomplete_type_used_in_type_trait_expr))

llvm::BumpPtrAllocator OpaqueExprAllocator;

ArgExprs.reserve(Args.size() - 1);

(

I = 1, N = Args.size(); I != N; ++I) {

ArgTy = Args[I]->getType();

Kind == clang::BTT_ReferenceConvertsFromTemporary

(

.Failed())

(Kind == clang::TT_IsConstructible)

(Kind == clang::BTT_ReferenceBindsToTemporary ||

Kind == clang::BTT_ReferenceConstructsFromTemporary ||

Kind == clang::BTT_ReferenceConvertsFromTemporary) {

(!

.isDirectReferenceBinding())

(Kind == clang::BTT_ReferenceBindsToTemporary)

(

->isReferenceType())

OpaqueExprAllocator)

(Kind == clang::TT_IsNothrowConstructible)

(Kind == clang::TT_IsTriviallyConstructible) {

(

.getNonReferenceType().hasNonTrivialObjCLifetime())

llvm_unreachable(

);

: llvm_unreachable(

);

UTT_HasNothrowAssign:

UTT_HasNothrowMoveAssign:

Replacement = BTT_IsNothrowAssignable;

UTT_HasNothrowCopy:

UTT_HasNothrowConstructor:

Replacement = TT_IsNothrowConstructible;

UTT_HasTrivialAssign:

UTT_HasTrivialMoveAssign:

Replacement = BTT_IsTriviallyAssignable;

UTT_HasTrivialCopy:

Replacement = UTT_IsTriviallyCopyable;

UTT_HasTrivialDefaultConstructor:

UTT_HasTrivialMoveConstructor:

Replacement = TT_IsTriviallyConstructible;

UTT_HasTrivialDestructor:

Replacement = UTT_IsTriviallyDestructible;

S.

(KWLoc, diag::warn_deprecated_builtin)

(Arity && N != Arity) {

(

, diag::err_type_trait_arity)

(!Arity && N == 0) {

(

, diag::err_type_trait_arity)

TypeTraitReturnType::Bool;

*

, Kind, KWLoc, Args[0]->getType()))

DiagnoseBuiltinDeprecation(*

, Kind, KWLoc);

(

I = 0, N = Args.size(); I != N; ++I) {

(Args[I]->getType()->isDependentType()) {

TypeTraitReturnType::Bool: {

KWLoc, Kind, Args, RParenLoc,

);

llvm_unreachable(

);

ConvertedArgs.reserve(Args.size());

(

I = 0, N = Args.size(); I != N; ++I) {

ConvertedArgs.push_back(TInfo);

);

BTT_IsBaseOf: {

(!rhsRecord || !lhsRecord) {

(!LHSObjTy || !RHSObjTy)

(!BaseInterface || !DerivedInterface)

(

.RequireCompleteType(

diag::err_incomplete_type_used_in_type_trait_expr))

assert(

.Context.hasSameUnqualifiedType(LhsT, RhsT)

== (lhsRecord == rhsRecord));

(rhsRecord && rhsRecord->getDecl()->isUnion())

(lhsRecord == rhsRecord)

(

.RequireCompleteType(

diag::err_incomplete_type_used_in_type_trait_expr))

cast<CXXRecordDecl>(rhsRecord->getDecl())

->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->

()));

BTT_IsVirtualBaseOf: {

(!BaseRecord || !DerivedRecord) {

tok::kw___builtin_is_virtual_base_of);

tok::kw___builtin_is_virtual_base_of);

(BaseRecord->

() || DerivedRecord->isUnionType())

!DerivedRecord->isStructureOrClassType())

diag::err_incomplete_type))

cast<CXXRecordDecl>(DerivedRecord->getDecl())

->isVirtuallyDerivedFrom(cast<CXXRecordDecl>(BaseRecord->

()));

.Context.hasSameType(LhsT, RhsT);

BTT_TypeCompatible: {

Lhs =

.getASTContext().getUnqualifiedArrayType(LhsT, LhsQuals);

Rhs =

.getASTContext().getUnqualifiedArrayType(RhsT, RhsQuals);

.Context.typesAreCompatible(Lhs, Rhs);

BTT_IsConvertible:

BTT_IsConvertibleTo:

BTT_IsNothrowConvertible: {

llvm::BumpPtrAllocator OpaqueExprAllocator;

OpaqueExprAllocator);

(

.isInvalid())

(BTT != BTT_IsNothrowConvertible)

BTT_IsAssignable:

BTT_IsNothrowAssignable:

BTT_IsTriviallyAssignable: {

.RequireCompleteType(

diag::err_incomplete_type_used_in_type_trait_expr))

.RequireCompleteType(

diag::err_incomplete_type_used_in_type_trait_expr))

LhsT =

.Context.getRValueReferenceType(LhsT);

RhsT =

.Context.getRValueReferenceType(RhsT);

(

.isInvalid())

.CheckUnusedVolatileAssignment(

.get());

(BTT == BTT_IsAssignable)

(BTT == BTT_IsNothrowAssignable)

(BTT == BTT_IsTriviallyAssignable) {

!

.get()->hasNonTrivialCall(

.Context);

llvm_unreachable(

);

BTT_IsLayoutCompatible: {

diag::err_incomplete_type);

diag::err_incomplete_type);

.IsLayoutCompatible(LhsT, RhsT);

BTT_IsPointerInterconvertibleBaseOf: {

!

.getASTContext().hasSameUnqualifiedType(LhsT, RhsT)) {

diag::err_incomplete_type);

tok::kw___is_pointer_interconvertible_base_of);

tok::kw___is_pointer_interconvertible_base_of);

.IsPointerInterconvertibleBaseOf(Lhs, Rhs);

BTT_IsDeducible: {

*TSTToBeDeduced = cast<DeducedTemplateSpecializationType>(LhsT);

.DeduceTemplateArgumentsFromType(

TSTToBeDeduced->getTemplateName().getAsTemplateDecl(), RhsT,

BTT_IsScalarizedLayoutCompatible: {

diag::err_incomplete_type))

diag::err_incomplete_type))

, Lhs, tok::kw___builtin_hlsl_is_scalarized_layout_compatible);

, Rhs, tok::kw___builtin_hlsl_is_scalarized_layout_compatible);

.HLSL().IsScalarizedLayoutCompatible(LhsT, RhsT);

llvm_unreachable(

);

llvm_unreachable(

);

assert(!

->

() &&

);

(

*AT =

.Context.getAsArrayType(

)) {

= AT->getElementType();

ATT_ArrayExtent: {

llvm::APSInt

;

(

.VerifyIntegerConstantExpression(

DimExpr, &

, diag::err_dimension_expr_not_constant_integer)

(

.isSigned() &&

.isNegative()) {

.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer)

Matched =

;

(

*AT =

.Context.getAsArrayType(

)) {

= AT->getElementType();

CAT->getLimitedSize();

llvm_unreachable(

);

ET_IsLValueExpr:

->

();

ET_IsRValueExpr:

llvm_unreachable(

);

);

*OpSpelling = isIndirect ?

:

;

(

, diag::err_bad_memptr_rhs)

(

, diag::err_bad_memptr_lhs)

<< OpSpelling << 1 << LHSType

OpSpelling, (

)isIndirect)) {

(

, diag::err_bad_memptr_lhs) << OpSpelling

(

, diag::err_pointer_to_member_type) << isIndirect;

(Proto->getRefQualifier()) {

(Proto->isConst() && !Proto->isVolatile())

? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue

: diag::ext_pointer_to_const_ref_member_on_rvalue);

(

, diag::err_pointer_to_member_oper_value_classify)

(

, diag::err_pointer_to_member_oper_value_classify)

(

->isFunctionType()) {

}

(isIndirect) {

&HaveConversion,

HaveConversion =

;

HaveConversion =

;

FDerivedFromT = FRec && TRec && FRec != TRec &&

.IsDerivedFrom(QuestionLoc, FTy, TTy);

(FRec && TRec && (FRec == TRec || FDerivedFromT ||

.IsDerivedFrom(QuestionLoc, TTy, FTy))) {

(FRec == TRec || FDerivedFromT) {

HaveConversion =

;

HaveConversion = !InitSeq.

();

*Args[2] = { LHS.

(), RHS.

() };

.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args,

LHS.

(), Best->BuiltinParamTypes[0], Best->Conversions[0],

RHS.

(), Best->BuiltinParamTypes[1], Best->Conversions[1],

.MarkFunctionReferenced(QuestionLoc, Best->Function);

(

.DiagnoseConditionalForNull(LHS.

(), RHS.

(), QuestionLoc))

.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)

.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl)

llvm_unreachable(

);

*Arg =

.get();

(

.isInvalid())

assert(!EltTy->

() &&

);

assert(!EltTy->

() &&

);

CondElementTy = CondVT->getElementType();

CondElementCount = CondVT->getNumElements();

(LHSVT && RHSVT) {

(isa<ExtVectorType>(CondVT) != isa<ExtVectorType>(LHSVT)) {

(QuestionLoc, diag::err_conditional_vector_cond_result_mismatch)

<<

isa<ExtVectorType>(CondVT);

(QuestionLoc, diag::err_conditional_vector_mismatched)

<< LHSType << RHSType;

}

(LHSVT || RHSVT) {

LHS, RHS, QuestionLoc,

,

,

(ResultType.isNull())

(QuestionLoc, diag::err_conditional_vector_operand_type)

assert(!ResultType.isNull() && ResultType->isVectorType() &&

);

*ResultVectorTy = ResultType->castAs<

>();

ResultElementTy = ResultVectorTy->getElementType();

ResultElementCount = ResultVectorTy->getNumElements();

(ResultElementCount != CondElementCount) {

(QuestionLoc, diag::err_conditional_vector_size) << CondType

(QuestionLoc, diag::err_conditional_vector_element_size) << CondType

llvm::ElementCount CondElementCount =

(LHSBT && RHSBT) {

(QuestionLoc, diag::err_conditional_vector_mismatched)

<< LHSType << RHSType;

ResultType = LHSType;

}

(LHSBT || RHSBT) {

(ResultType.isNull())

ResultElementTy = LHSType;

(QuestionLoc, diag::err_conditional_vector_operand_type)

ResultElementTy, CondElementCount.getKnownMinValue());

assert(!ResultType.isNull() && ResultType->isSveVLSBuiltinType() &&

);

*ResultBuiltinTy = ResultType->castAs<

>();

llvm::ElementCount ResultElementCount =

(ResultElementCount != CondElementCount) {

(QuestionLoc, diag::err_conditional_vector_size)

<< CondType << ResultType;

(QuestionLoc, diag::err_conditional_vector_element_size)

<< CondType << ResultType;

IsVectorConditional =

IsSizelessVectorConditional =

CondRes = IsVectorConditional || IsSizelessVectorConditional

(LVoid || RVoid) {

(IsVectorConditional) {

IsThrow = LVoid ? LThrow : RThrow;

(DiagLoc.

(), diag::err_conditional_vector_has_void)

<< DiagLoc << IsThrow;

(LThrow != RThrow) {

*NonThrow = LThrow ? RHS.

() : LHS.

();

(QuestionLoc, diag::err_conditional_void_nonvoid)

<< (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)

(IsVectorConditional)

(IsSizelessVectorConditional)

(QuestionLoc, diag::err_wasm_table_conditional_expression)

HaveL2R, HaveR2L;

(HaveL2R && HaveR2L) {

(QuestionLoc, diag::err_conditional_ambiguous)

}

(HaveR2L) {

ReferenceConversions::Qualification |

ReferenceConversions::NestedQualification |

ReferenceConversions::Function;

!(RefConv & ~AllowedConversions) &&

!(RefConv & ~AllowedConversions) &&

(Same && LVK == RVK && LVK !=

&&

diag::err_typecheck_cond_incompatible_operands) << LTy << RTy

(!Composite.

())

(!Composite.

())

(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)

T2IsPointerLike = T2->isAnyPointerType() || T2->isMemberPointerType() ||

T2->isNullPtrType();

(!T1IsPointerLike && !T2IsPointerLike)

(T1IsPointerLike &&

? CK_NullToMemberPointer

: CK_NullToPointer).

();

(T2IsPointerLike &&

? CK_NullToMemberPointer

: CK_NullToPointer).

();

(!T1IsPointerLike || !T2IsPointerLike)

);

{

, ObjCPointer, MemberPointer, Array } K;

*ClassOrBound;

Step(

K,

*ClassOrBound =

)

: K(K), ClassOrBound(ClassOrBound) {}

(

*CAT = cast_or_null<ConstantArrayType>(ClassOrBound))

ArraySizeModifier::Normal, 0);

llvm_unreachable(

);

NeedConstBefore = 0;

assert(!Composite1.

() && !Composite2.

());

(!Steps.empty()) {

}

(Steps.size() == 1) {

(MaybeQ1 == MaybeQ2) {

assert(Steps.size() == 1);

assert(Steps.size() == 1);

Steps.back().Quals = Quals;

(Q1 != Quals || Q2 != Quals)

NeedConstBefore = Steps.size() - 1;

*CAT1 = dyn_cast<ConstantArrayType>(Arr1);

*CAT2 = dyn_cast<ConstantArrayType>(Arr2);

(CAT1 && CAT2 && CAT1->getSize() == CAT2->getSize()) {

Steps.emplace_back(Step::Array, CAT1);

IAT1 = isa<IncompleteArrayType>(Arr1);

IAT2 = isa<IncompleteArrayType>(Arr2);

((IAT1 && IAT2) ||

((

)CAT1 != (

)CAT2) &&

(Steps.empty() || Steps.back().K != Step::Array))) {

Steps.emplace_back(Step::Array);

NeedConstBefore = Steps.size();

Steps.emplace_back(Step::Pointer);

Steps.emplace_back(Step::ObjCPointer);

(Steps.empty())

Steps.emplace_back(Step::MemberPointer,

);

Steps.emplace_back(Step::Pointer);

(Steps.size() == 1) {

FPT1->getParamTypes(), EPI1);

FPT2->getParamTypes(), EPI2);

(Steps.size() == 1 && Steps.front().K == Step::Pointer &&

Composite2 = Composite1;

Composite1 = Composite2;

Composite1 = Composite2;

Composite2 = Composite1;

(

I = 0; I != NeedConstBefore; ++I)

Steps[I].Quals.addConst();

(

&S : llvm::reverse(Steps))

Composite = S.rebuild(

, Composite);

E1 = E1Result.

();

E2 = E2Result.

();

assert(!isa<CXXBindTemporaryExpr>(

) &&

);

ReturnsRetained;

*Callee =

->getCallee()->IgnoreParens();

= BinOp->getRHS()->getType();

(

*Mem = dyn_cast<MemberExpr>(Callee))

= Mem->getMemberDecl()->getType();

}

(isa<StmtExpr>(

)) {

ReturnsRetained =

;

}

(isa<CastExpr>(

) &&

isa<BlockExpr>(cast<CastExpr>(

)->getSubExpr())) {

= Send->getMethodDecl();

}

(

*BoxedExpr = dyn_cast<ObjCBoxedExpr>(

)) {

= BoxedExpr->getBoxingMethod();

(ArrayLit->getNumElements() == 0 &&

= ArrayLit->getArrayWithObjectsMethod();

= dyn_cast<ObjCDictionaryLiteral>(

)) {

(DictLit->getNumElements() == 0 &&

= DictLit->getDictWithObjectsMethod();

ReturnsRetained = (

&&

->

<NSReturnsRetainedAttr>());

(!ReturnsRetained &&

ck = (ReturnsRetained ? CK_ARCConsumeObject

: CK_ARCReclaimReturnedObject);

RT = cast<RecordType>(

);

Type::ConstantArray:

Type::IncompleteArray:

Type::VariableArray:

Type::DependentSizedArray:

= cast<ArrayType>(

)->getElementType().getTypePtr();

(diag::err_access_dtor_temp)

assert(SubExpr &&

);

assert(SubStmt &&

);

);

(

.isInvalid())

(

*PE = dyn_cast<ParenExpr>(

)) {

(SubExpr.

() == PE->getSubExpr())

(BO->getOpcode() == BO_Comma) {

(RHS.

() == BO->getRHS())

BO->

(), BO->getValueKind(),

BO->getObjectKind(), BO->getOperatorLoc(),

BO->getFPFeatures());

(

.isInvalid())

(

I = 0, N =

.back().DelayedDecltypeCalls.size();

(

== TopCall)

->getBeginLoc(),

,

->getDirectCallee()))

(

I = 0, N =

.back().DelayedDecltypeBinds.size();

(

== TopBind)

->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();

(diag::err_access_dtor_temp)

<<

->getType());

SkipStart = OperatorArrows.size(), SkipCount = 0;

(OperatorArrows.size() > Limit) {

SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2;

SkipCount = OperatorArrows.size() - (Limit - 1);

(

I = 0; I < OperatorArrows.size();

) {

(I == SkipStart) {

S.

(OperatorArrows[I]->getLocation(),

diag::note_operator_arrows_suppressed)

S.

(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here)

<< OperatorArrows[I]->getCallResultType();

&MayBePseudoDestructor) {

MayBePseudoDestructor =

;

(OpKind == tok::arrow)

MayBePseudoDestructor =

;

(OpKind == tok::arrow) {

NoArrowOperatorFound =

;

FirstIteration =

;

(OperatorArrows.size() >=

().ArrowDepth) {

(OpLoc, diag::err_operator_arrow_depth_exceeded)

<< StartingType <<

().ArrowDepth <<

->getSourceRange();

(OpLoc, diag::note_operator_arrow_depth)

: &NoArrowOperatorFound);

(

.isInvalid()) {

(NoArrowOperatorFound) {

(FirstIteration) {

(OpLoc, diag::err_typecheck_member_reference_suggestion)

<< BaseType << 1 <<

->getSourceRange()

OpKind = tok::period;

(OpLoc, diag::err_typecheck_member_reference_arrow)

<< BaseType <<

->getSourceRange();

diag::note_member_reference_arrow_from_operator_arrow);

OperatorArrows.push_back(OpCall->getDirectCallee());

BaseType =

->getType();

(!CTypes.insert(CBaseType).second) {

(OpLoc, diag::err_operator_arrow_circular) << StartingType;

FirstIteration =

;

(OpKind == tok::arrow) {

BaseType = AT->getElementType();

MayBePseudoDestructor =

;

diag::err_incomplete_member_access)) {

(

->hasPlaceholderType()) {

ObjectType =

->getType();

(OpKind == tok::arrow) {

ObjectType =

->getType();

}

(!

->isTypeDependent()) {

S.

(OpLoc, diag::err_typecheck_member_reference_suggestion)

<< ObjectType <<

OpKind = tok::period;

(OpLoc, diag::ext_pseudo_dtor_on_void) <<

->getSourceRange();

(OpLoc, diag::err_pseudo_dtor_base_not_scalar)

<< ObjectType <<

->getSourceRange();

(DestructedTypeInfo) {

(OpKind == tok::period && ObjectType->

() &&

(OpLoc, diag::err_typecheck_member_reference_suggestion)

<< ObjectType <<

0 <<

->getSourceRange();

*

, DestructedType))

ObjectType = DestructedType;

OpKind = tok::arrow;

(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)

<< ObjectType << DestructedType <<

->getSourceRange()

DestructedType = ObjectType;

DestructedTypeInfo =

(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals)

<< ObjectType << DestructedType <<

->getSourceRange()

DestructedType = ObjectType;

DestructedTypeStart);

(ScopeTypeInfo) {

(!ScopeType->isDependentType() && !ObjectType->

() &&

diag::err_pseudo_dtor_type_mismatch)

<< ObjectType << ScopeType <<

->getSourceRange()

ScopeTypeInfo =

;

OpKind == tok::arrow, OpLoc,

);

);

(!SS.

()) {

S, &SS,

,

, ObjectTypePtrForLookup,

diag::err_pseudo_dtor_destructor_non_type)

DestructedType = ObjectType;

(

.isInvalid() || !

.get()) {

DestructedType = ObjectType;

(!DestructedType.

()) {

(!DestructedTypeInfo)

S, &SS,

,

, ObjectTypePtrForLookup,

diag::err_pseudo_dtor_destructor_non_type)

(

.isInvalid() || !

.get()) {

(!ScopeType.isNull() && !ScopeTypeInfo)

ScopeTypeInfo, CCLoc, TildeLoc,

cast<PackIndexingType>(

.getTypePtr())->getPattern(),

llvm_unreachable(

);

Operand = R.

();

Operand->HasSideEffects(

,

)) {

(Operand->getExprLoc(), diag::warn_side_effects_unevaluated_context);

IsCompoundAssign =

;

isIncrementDecrementUnaryOp =

;

(BO->getLHS()->getType()->isDependentType() ||

BO->getRHS()->getType()->isDependentType()) {

(BO->getOpcode() != BO_Assign)

}

(!BO->isAssignmentOp())

IsCompoundAssign = BO->isCompoundAssignmentOp();

LHS = dyn_cast<DeclRefExpr>(BO->getLHS());

(COCE->getOperator() != OO_Equal)

LHS = dyn_cast<DeclRefExpr>(COCE->getArg(0));

(!UO->isIncrementDecrementOp())

isIncrementDecrementUnaryOp =

;

LHS = dyn_cast<DeclRefExpr>(UO->getSubExpr());

((IsCompoundAssign || isIncrementDecrementUnaryOp) &&

iter->getSecond()--;

(!

->getDecl()->isComplete()) {

diag::err_incomplete_type);

(isa<ParmVarDecl>(Var))

;

*DefVD =

;

(isa_and_nonnull<CapturedDecl>(DC))

);

!IsFullExprInstantiationDependent)

(

std::optional<unsigned> Index =

IsVarNeverAConstantExpression =

(!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {

, CaptureType,

DeclRefType,

)) {

DeclRefType,

);

(

std::optional<unsigned> Index =

FunctionScopeIndexOfCapturableLambda = *Index;

&FunctionScopeIndexOfCapturableLambda);

.getLookupResult().getLookupKind());

(ND->isCXXClassMember()) {

= NNS->getAsType()->getAsCXXRecordDecl();

dyn_cast<CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());

NewSS, R,

.isAddressOfOperand()))

,

);

}

(

*Ivar = dyn_cast<ObjCIvarDecl>(ND)) {

Ivar->getIdentifier());

: TypoExprs(TypoExprs) {}

VisitTypoExpr(

*TE)

{

TypoExprs.insert(TE);

TransformTypos :

<TransformTypos> {

llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache;

llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution;

EmitAllDiagnostics(

IsAmbiguous) {

&State = SemaRef.getTypoExprState(TE);

(State.DiagHandler) {

Replacement.isInvalid() ?

: Replacement.get()))

State.DiagHandler(TC);

SemaRef.clearDelayedTypo(TE);

CheckAndAdvanceTypoExprCorrectionStreams() {

(

*TE : TypoExprs) {

&State = SemaRef.getTypoExprState(TE);

TransformCache.erase(TE);

(!State.Consumer->hasMadeAnyCorrectionProgress())

(!State.Consumer->finished())

State.Consumer->resetCorrectionStream();

(

*OE = dyn_cast_or_null<OverloadExpr>(

))

= OverloadResolution[OE];

(

*DRE = dyn_cast<DeclRefExpr>(

))

DRE->getFoundDecl();

(

*ME = dyn_cast<MemberExpr>(

))

(Trap.hasErrorOccurred() || Res.

())

ExprFilter(Res.

());

*FixedExpr = Res.

();

SavedTypoExprs = std::move(TypoExprs);

SavedAmbiguousTypoExprs = std::move(AmbiguousTypoExprs);

AmbiguousTypoExprs.clear();

FindTypoExprs(TypoExprs).TraverseStmt(FixedExpr);

(!TypoExprs.empty()) {

RecursiveTransformLoop(FixedExpr, IsAmbiguous);

&SemaTypoExprs = SemaRef.TypoExprs;

(

*TE : TypoExprs) {

TransformCache.erase(TE);

SemaRef.clearDelayedTypo(TE);

SI = find(SemaTypoExprs, TE);

(SI != SemaTypoExprs.end()) {

SemaTypoExprs.erase(SI);

SavedTypoExprs.set_union(TypoExprs);

TypoExprs = std::move(SavedTypoExprs);

AmbiguousTypoExprs = std::move(SavedAmbiguousTypoExprs);

SavedTypoExprs = std::move(SemaRef.TypoExprs);

SemaRef.TypoExprs.clear();

Res = CheckForRecursiveTypos(TryTransform(

), IsAmbiguous);

(!CheckAndAdvanceTypoExprCorrectionStreams())

(!IsAmbiguous && !Res.

() && !AmbiguousTypoExprs.empty()) {

SavedTransformCache =

llvm::SmallDenseMap<TypoExpr *, ExprResult, 2>(TransformCache);

(!AmbiguousTypoExprs.empty()) {

TE = AmbiguousTypoExprs.back();

SemaRef.getTypoExprState(TE).Consumer->saveCurrentPosition();

TC = SemaRef.getTypoExprState(TE).Consumer->peekNextCorrection();

TransformCache.erase(TE);

AmbigRes = CheckForRecursiveTypos(TryTransform(

), IsAmbiguous);

(!AmbigRes.

() || IsAmbiguous) {

SemaRef.getTypoExprState(TE).Consumer->resetCorrectionStream();

SavedTransformCache.erase(TE);

IsAmbiguous =

;

}

((Next = SemaRef.getTypoExprState(TE).Consumer->peekNextCorrection()) &&

AmbiguousTypoExprs.remove(TE);

SemaRef.getTypoExprState(TE).Consumer->restoreSavedPosition();

TransformCache[TE] = SavedTransformCache[TE];

TransformCache = std::move(SavedTransformCache);

&SemaTypoExprs = SemaRef.TypoExprs;

(

Iterator = SemaTypoExprs.begin(); Iterator != SemaTypoExprs.end();) {

TE = *Iterator;

FI = find(TypoExprs, TE);

(FI != TypoExprs.end()) {

SemaRef.clearDelayedTypo(TE);

Iterator = SemaTypoExprs.erase(Iterator);

SemaRef.TypoExprs = std::move(SavedTypoExprs);

: BaseTransform(SemaRef), InitDecl(InitDecl), ExprFilter(

) {}

*ExecConfig =

) {

Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args,

RParenLoc, ExecConfig);

(

*OE = dyn_cast<OverloadExpr>(Callee)) {

(Result.isUsable()) {

*ResultCall = Result.get();

(

*BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall))

ResultCall = BE->getSubExpr();

(

*CE = dyn_cast<CallExpr>(ResultCall))

OverloadResolution[OE] = CE->getCallee();

IsAmbiguous =

;

Res = RecursiveTransformLoop(

, IsAmbiguous);

FindTypoExprs(TypoExprs).TraverseStmt(

);

EmitAllDiagnostics(IsAmbiguous);

&CacheEntry = TransformCache[

];

(!TypoExprs.insert(

) && !CacheEntry.isUnset()) {

assert(State.Consumer &&

);

(

TC = State.Consumer->getNextCorrection()) {

State.RecoveryHandler(SemaRef,

, TC) :

(!

.isInvalid()) {

((Next = State.Consumer->peekNextCorrection()) &&

AmbiguousTypoExprs.insert(

);

AmbiguousTypoExprs.remove(

);

assert(!

.isUnset() &&

);

CacheEntry =

;

RecoverUncorrectedTypos,

TyposResolved = DelayedTypos.size();

= TransformTypos(*

, InitDecl, Filter).Transform(

);

TyposResolved -= DelayedTypos.size();

(

.isInvalid() && RecoverUncorrectedTypos) {

TT.TransformExpr(

);

assert(TyposResolved == 0 &&

);

DiscardedValue,

IsConstexpr,

IsTemplateArgument) {

(DiscardedValue) {

CheckCompletedExpr(

.get(), CC, IsConstexpr);

(isa_and_nonnull<CapturedDecl>(DC))

(IsInLambdaDeclContext && CurrentLSI &&

RedeclarationKind::NotForRedeclaration);

llvm_unreachable(

);

);

(

.isInvalid())

,

, NoexceptLoc,

*Param = cast<TemplateTypeParmDecl>(TPL->

(0));

assert(TC &&

);

assert(IDC &&

);

[&](llvm::raw_ostream &

) {

IDC->printPretty(OS,

nullptr,

getPrintingPolicy());

IsSimple, NoexceptLoc, ReturnTypeRequirement);

SubstitutedConstraintExpr =

cast<ConceptSpecializationExpr>(Constraint.

());

ReturnTypeRequirement, Status,

SubstitutedConstraintExpr);

IsSimple, NoexceptLoc,

ReturnTypeRequirement);

InvalidConstraintEntity,

(Param->getType()->isVoidType()) {

(LocalParameters.size() > 1) {

(Param->getBeginLoc(), diag::err_void_only_param);

}

(Param->getIdentifier()) {

(Param->getBeginLoc(), diag::err_param_with_void_type);

}

(Param->getType().hasQualifiers()) {

(Param->getBeginLoc(), diag::err_void_param_qualified);

}

(Param->hasDefaultArg()) {

(Param->getDefaultArgRange().getBegin(),

diag::err_requires_expr_local_parameter_default_argument);

}

(Param->isExplicitObjectParameter()) {

(Param->getExplicitObjectParamThisLoc(),

diag::err_requires_expr_explicit_object_parameter);

Param->setDeclContext(Body);

(Param->getIdentifier()) {

assert(

&&

);

assert(

&&

);

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 CanQualType GetReturnType(QualType RetTy)

Returns the "extra-canonicalized" return type, which discards qualifiers on the return type.

enum clang::sema::@1704::IndirectLocalPathEntry::EntryKind Kind

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.

llvm::MachO::Record Record

Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.

Defines the clang::Preprocessor interface.

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

This file declares semantic analysis for CUDA constructs.

static void 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 HasNonDeletedDefaultedEqualityComparison(Sema &S, const CXXRecordDecl *Decl, 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 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 QualType adjustVectorType(ASTContext &Context, QualType FromTy, QualType ToType, QualType *ElTy=nullptr)

static void CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(Expr *const FE, LambdaScopeInfo *const CurrentLSI, Sema &S)

Check if the current lambda has any potential captures that must be captured by any of its enclosing ...

static void getUuidAttrOfType(Sema &SemaRef, QualType QT, llvm::SmallSetVector< const UuidAttr *, 1 > &UuidAttrs)

Grabs __declspec(uuid()) off a type, or returns 0 if we cannot resolve to a single GUID.

static 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 DiagnoseAtomicInCXXTypeTrait(Sema &S, const TypeSourceInfo *T, clang::tok::TokenKind TypeTraitID)

Checks that type T is not an atomic type (_Atomic).

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 isTriviallyEqualityComparableType(Sema &S, QualType Type, SourceLocation KeyLoc)

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 declares semantic analysis for HLSL constructs.

This file provides some common utility functions for processing Lambdas.

This file declares semantic analysis for Objective-C.

This file declares semantic analysis functions specific to PowerPC.

static QualType getPointeeType(const MemRegion *R)

Defines the clang::TokenKind enum and support functions.

Defines the clang::TypeLoc interface and its subclasses.

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...

TranslationUnitDecl * getTranslationUnitDecl() const

const ConstantArrayType * getAsConstantArrayType(QualType T) const

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 LangOptions & getLangOpts() const

bool hasUniqueObjectRepresentations(QualType Ty, bool CheckIfTriviallyCopyable=true) const

Return true if the specified type has unique object representations according to (C++17 [meta....

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

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.

const TargetInfo & getTargetInfo() const

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.

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.

Represents a constant array type that does not decay to a pointer when used as a function parameter.

QualType getConstantArrayType(const ASTContext &Ctx) const

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.