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

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

clang: lib/Sema/SemaStmt.cpp Source File

;

HasLeadingEmptyMacro) {

(!

||

->isInvalidDecl())

(

->getLocation(), diag::err_non_variable_decl_in_for);

->setInvalidDecl();

var->setInit(

);

var->setType(

.withConst());

var->setARCPseudoStrong(

);

{ Equality, Inequality, Relational, ThreeWay } Kind;

(!Op->isComparisonOp())

(Op->getOpcode() == BO_EQ)

(Op->getOpcode() == BO_NE)

(Op->getOpcode() == BO_Cmp)

assert(Op->isRelationalOp());

= Op->getOperatorLoc();

CanAssign = Op->getLHS()->IgnoreParenImpCasts()->isLValue();

(Op->getOperator()) {

OO_ExclaimEqual:

OO_GreaterEqual:

= Op->getOperatorLoc();

CanAssign = Op->getArg(0)->IgnoreParenImpCasts()->isLValue();

S.

(

, diag::warn_unused_comparison)

(Kind == Inequality)

S.

(

, diag::note_inequality_comparison_to_or_assign)

(Kind == Equality)

S.

(

, diag::note_equality_comparison_to_assign)

StringRef Msg = A->getMessage();

S.

(

, diag::warn_unused_return_type)

<< IsCtor << A << OffendingDecl <<

<< R1 << R2;

S.

(

, diag::warn_unused_constructor)

<< A <<

<< R1 << R2;

S.

(

, diag::warn_unused_result) << A <<

<< R1 << R2;

S.

(

, diag::warn_unused_return_type)

<< IsCtor << A << OffendingDecl <<

<< Msg << R1 << R2;

S.

(

, diag::warn_unused_constructor)

<< A <<

<< Msg << R1 << R2;

S.

(

, diag::warn_unused_result) << A <<

<< Msg << R1 << R2;

DiagnoseUnused(

&S,

*

, std::optional<unsigned> DiagID) {

NoDiscardOnly = !DiagID.has_value();

*WarnExpr;

(!NoDiscardOnly) {

(

*Temps = dyn_cast<FullExpr>(

))

= Temps->getSubExpr();

= TempExpr->getSubExpr();

(

*Cast = dyn_cast<CastExpr>(

))

(

->getCastKind() == CK_NoOp ||

->getCastKind() == CK_ConstructorConversion ||

->getCastKind() == CK_IntegralCast)

=

->getSubExpr()->IgnoreImpCasts();

(

*CE = dyn_cast<CallExpr>(

)) {

[OffendingDecl, A] = CE->getUnusedResultAttr(S.

);

cast_or_null<WarnUnusedResultAttr>(A),

, R1, R2,

(

*FD = CE->getCalleeDecl()) {

(FD->hasAttr<PureAttr>()) {

S.

(

, diag::warn_unused_call) << R1 << R2 <<

;

(FD->hasAttr<ConstAttr>()) {

S.

(

, diag::warn_unused_call) << R1 << R2 <<

;

}

(

*CE = dyn_cast<CXXConstructExpr>(

)) {

*OffendingDecl =

;

*A = Ctor->

<WarnUnusedResultAttr>();

OffendingDecl = Ctor->getParent();

A = OffendingDecl->

<WarnUnusedResultAttr>();

}

(

*ILE = dyn_cast<InitListExpr>(

)) {

(

*TD = ILE->getType()->getAsTagDecl()) {

}

(ShouldSuppress)

(S.

().ObjCAutoRefCount && ME->isDelegateInitCall()) {

S.

(

, diag::err_arc_unused_init_message) << R1;

*Source = POE->getSyntacticForm();

(S.

.OpenMP && isa<CallExpr>(Source) &&

POE->getNumSemanticExprs() == 1 &&

isa<CallExpr>(POE->getSemanticExpr(0)))

DiagnoseUnused(S, POE->getSemanticExpr(0), DiagID);

(isa<ObjCSubscriptRefExpr>(Source))

DiagID = diag::warn_unused_container_subscript_expr;

(isa<ObjCPropertyRefExpr>(Source))

DiagID = diag::warn_unused_property_expr;

= dyn_cast<CXXFunctionalCastExpr>(

)) {

*

= FC->getSubExpr();

= TE->getSubExpr();

(isa<CXXTemporaryObjectExpr>(

))

(

*RD = CE->getType()->getAsCXXRecordDecl())

(!RD->getAttr<WarnUnusedAttr>())

S.

(

, diag::warn_unused_voidptr)

S.

(

, diag::warn_unused_volatile) << R1 << R2;

(DiagID == diag::warn_unused_comma_left_operand && S.

())

S.

(*DiagID) << R1 << R2);

DiagnoseUnused(*

,

, std::nullopt);

S =

->getSubStmt();

*

= dyn_cast_if_present<Expr>(S);

DiagnoseUnused(*

,

, DiagID);

NumElts = Elts.size();

MixedDeclsCodeID =

().C99

? diag::warn_mixed_decls_code

: diag::ext_mixed_decls_code;

(; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)

(; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)

*

= *cast<DeclStmt>(Elts[i])->decl_begin();

(

i = 0; i != NumElts - 1; ++i)

CheckAndFinish = [&](

*

) {

llvm::APSInt TempVal;

Val,

,

,

(Converted.

() == Val.

())

Converted = CheckAndFinish(Val.

());

assert((LHSVal.

() || LHSVal.

()) &&

);

);

(CaseLoc, diag::err_case_not_in_switch);

(CaseLoc, diag::err_acc_branch_in_out_compute_construct)

CaseLoc, DotDotDotLoc, ColonLoc);

cast<CaseStmt>(S)->setSubStmt(SubStmt);

(DefaultLoc, diag::err_default_not_in_switch);

(DefaultLoc, diag::err_acc_branch_in_out_compute_construct)

(IdentLoc, diag::err_redefinition_of_label) << TheDecl->

();

(IdentLoc, diag::warn_reserved_extern_symbol)

<< TheDecl << static_cast<int>(Status);

(

()->isInOpenACCComputeConstructScope())

(isa<OpenACCUpdateConstruct>(SubStmt)) {

(

*A : Attrs) {

(A->getKind() == attr::MustTail) {

(!SemanticAttrs.empty())

(!checkMustTailAttr(St, MTA))

IgnoreImplicitAsWritten = [](

*

) ->

* {

Sema::checkMustTailAttr(

*St,

&MTA) {

);

IgnoreParenImplicitAsWritten = [](

*

) ->

* {

*

= cast<ReturnStmt>(St)->getRetValue();

*CE = dyn_cast_or_null<CallExpr>(IgnoreParenImplicitAsWritten(

));

(

*EWC = dyn_cast<ExprWithCleanups>(

)) {

(EWC->cleanupsHaveSideEffects()) {

(St->

(), diag::err_musttail_needs_trivial_args) << &MTA;

ft_non_static_member,

ft_pointer_to_member,

} MemberType = ft_non_member;

} CallerType, CalleeType;

GetMethodType = [

, St, MTA](

*CMD, FuncType &

,

IsCallee) ->

{

(isa<CXXConstructorDecl, CXXDestructorDecl>(CMD)) {

<< IsCallee << isa<CXXDestructorDecl>(CMD);

(CMD->getBeginLoc(), diag::note_musttail_structors_forbidden)

<< isa<CXXDestructorDecl>(CMD);

.MemberType = FuncType::ft_static_member;

.This = CMD->getFunctionObjectParameterType();

.MemberType = FuncType::ft_non_static_member;

*CallerDecl = dyn_cast<FunctionDecl>(

);

(St->

(), diag::err_musttail_forbidden_from_this_context)

}

(

*CMD = dyn_cast<CXXMethodDecl>(

)) {

(!GetMethodType(CMD, CallerType,

))

*CalleeBinOp = dyn_cast<BinaryOperator>(CalleeExpr);

? CE->getCalleeDecl()->getBeginLoc()

dyn_cast_or_null<CXXMethodDecl>(CE->getCalleeDecl())) {

(!GetMethodType(CMD, CalleeType,

))

}

(CalleeBinOp && CalleeBinOp->isPtrMemOp()) {

CalleeType.This =

(MPT->getClass(), 0);

CalleeType.MemberType = FuncType::ft_pointer_to_member;

}

(isa<CXXPseudoDestructorExpr>(CalleeExpr)) {

(!CalleeType.Func || !CallerType.Func) {

(St->

(), diag::err_musttail_needs_prototype) << &MTA;

(!CalleeType.Func && CE->getDirectCallee()) {

(CE->getDirectCallee()->getBeginLoc(),

diag::note_musttail_fix_non_prototype);

(!CallerType.Func)

(CallerDecl->getBeginLoc(), diag::note_musttail_fix_non_prototype);

(CallerType.Func->getCallConv() != CalleeType.Func->getCallConv()) {

(

*ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl()))

<<

<< ND->getDeclName();

(St->

(), diag::err_musttail_callconv_mismatch) <<

;

(CalleeLoc, diag::note_musttail_callconv_mismatch)

(CalleeType.Func->isVariadic() || CallerType.Func->isVariadic()) {

*CalleeDecl = CE->getCalleeDecl();

(CalleeDecl && CalleeDecl->hasAttr<CXX11NoReturnAttr>()) {

(CallerType.This.isNull() != CalleeType.This.isNull()) {

(

*ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl())) {

<< CallerType.MemberType << CalleeType.MemberType <<

<< ND->getDeclName();

(CalleeLoc, diag::note_musttail_callee_defined_here)

<< ND->getDeclName();

<< CallerType.MemberType << CalleeType.MemberType <<

;

CheckTypesMatch = [

](FuncType CallerType, FuncType CalleeType,

Select) ->

{

(!CallerType.This.isNull() &&

(!DoTypesMatch(CallerType.Func->getReturnType(),

(CallerType.Func->getNumParams() != CalleeType.Func->getNumParams()) {

<< CalleeType.Func->getNumParams();

N = CallerType.Func->getNumParams();

(

I = 0; I < N; I++) {

(!DoTypesMatch(CalleeParams[I], CallerParams[I],

PD << static_cast<int>(I) + 1;

(!CheckTypesMatch(CallerType, CalleeType, PD)) {

(

*ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl()))

<<

<< ND->getDeclName();

(CalleeLoc, PD);

(

ArgExpr : CE->arguments()) {

, ArgExpr->getType(),

);

CommaVisitor(

&SemaRef) : Inherited(SemaRef.Context), SemaRef(SemaRef) {}

(

->getOpcode() == BO_Comma)

ConstevalOrNegatedConsteval =

*CondExpr = Cond.

().second;

assert((CondExpr || ConstevalOrNegatedConsteval) &&

);

CommaVisitor(*this).Visit(CondExpr);

(!ConstevalOrNegatedConsteval && !elseStmt)

(ConstevalOrNegatedConsteval ||

DiagnoseLikelihood = [&](

*S) {

diag::warn_attribute_has_no_effect_on_compile_time_if)

<< A << ConstevalOrNegatedConsteval << A->getRange();

diag::note_attribute_has_no_effect_on_compile_time_if_here)

<< ConstevalOrNegatedConsteval

<<

(IfLoc, (ConstevalOrNegatedConsteval

DiagnoseLikelihood(thenStmt);

DiagnoseLikelihood(elseStmt);

std::tuple<bool, const Attr *, const Attr *> LHC =

(std::get<0>(LHC)) {

*ThenAttr = std::get<1>(LHC);

*ElseAttr = std::get<2>(LHC);

diag::warn_attributes_likelihood_ifstmt_conflict)

<< ThenAttr << ThenAttr->

();

<< ElseAttr << ElseAttr->

();

(ConstevalOrNegatedConsteval) {

(FD && FD->isImmediateFunction())

.

(IfLoc, diag::warn_consteval_if_always_true) << Immediate;

(isa<OpenACCUpdateConstruct>(thenStmt)) {

(IfLoc, StatementKind, LParenLoc, InitStmt, Cond, RParenLoc,

thenStmt, ElseLoc, elseStmt);

isa<ObjCAvailabilityCheckExpr>(Cond.

().second))

Cond.

().first, Cond.

().second, LParenLoc,

RParenLoc, thenStmt, ElseLoc, elseStmt);

CaseCompareFunctor {

operator()(

std::pair<llvm::APSInt, CaseStmt*> &LHS,

llvm::APSInt &RHS) {

LHS.first < RHS;

operator()(

std::pair<llvm::APSInt, CaseStmt*> &LHS,

std::pair<llvm::APSInt, CaseStmt*> &RHS) {

LHS.first < RHS.first;

operator()(

llvm::APSInt &LHS,

std::pair<llvm::APSInt, CaseStmt*> &RHS) {

LHS < RHS.first;

(

std::pair<llvm::APSInt, CaseStmt*>& lhs,

std::pair<llvm::APSInt, CaseStmt*>& rhs) {

(lhs.first < rhs.first)

(lhs.first == rhs.first &&

lhs.second->getCaseLoc() < rhs.second->getCaseLoc())

(

std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,

std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)

lhs.first < rhs.first;

(

std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,

std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)

lhs.first == rhs.first;

(

*FE = dyn_cast<FullExpr>(

))

= FE->getSubExpr();

(

*ImpCast = dyn_cast<ImplicitCastExpr>(

)) {

(ImpCast->getCastKind() != CK_IntegralCast)

;

= ImpCast->getSubExpr();

SwitchConvertDiagnoser(

*Cond)

S.

(

, diag::err_typecheck_statement_requires_integer) <<

;

S.

(

, diag::err_switch_incomplete_class_type)

S.

(

, diag::err_switch_explicit_conversion) <<

<< ConvTy;

S.

(

, diag::err_switch_multiple_conversions) <<

;

llvm_unreachable(

);

} SwitchDiagnoser(Cond);

Cond = CondResult.

();

*CondExpr = Cond.

().second;

assert((Cond.

() || CondExpr) &&

);

(SwitchLoc, diag::warn_bool_switch_condition)

LParenLoc, RParenLoc);

(llvm::APSInt &Val,

BitWidth,

IsSigned) {

Val = Val.extOrTrunc(BitWidth);

Val.setIsSigned(IsSigned);

UnpromotedWidth,

UnpromotedSign) {

(UnpromotedWidth < Val.getBitWidth()) {

llvm::APSInt ConvVal(Val);

(ConvVal, UnpromotedWidth, UnpromotedSign);

(ConvVal, Val.getBitWidth(), Val.isSigned());

*CaseExpr,

EnumValsTy::iterator &EI,

EnumValsTy::iterator &EIEnd,

llvm::APSInt &Val) {

(

*VD = dyn_cast<VarDecl>(DRE->getDecl())) {

(ED->

<FlagEnumAttr>())

(EI != EIEnd && EI->first < Val)

(EI != EIEnd && EI->first == Val)

(!CondEnumType || !CaseEnumType)

(!CaseEnumType->getDecl()->getIdentifier() &&

!CaseEnumType->getDecl()->getTypedefNameForAnonDecl())

S.

(Case->

(), diag::warn_comparison_of_mixed_enum_types_switch)

assert(SS ==

()->SwitchStack.back().getPointer() &&

);

(isa<OpenACCUpdateConstruct>(BodyStmt)) {

SS->

(BodyStmt, SwitchLoc);

*CondExprBeforePromotion = CondExpr;

HasDependentValue

CondWidthBeforePromotion

CondIsSignedBeforePromotion

CaseValsTy CaseVals;

std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy;

CaseRangesTy CaseRanges;

CaseListIsErroneous =

;

(

*DS = dyn_cast<DefaultStmt>(SC)) {

(TheDefaultStmt) {

(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined);

CaseListIsErroneous =

;

TheDefaultStmt = DS;

HasDependentValue =

;

*LoBeforePromotion = Lo;

CondIsSignedBeforePromotion);

HasDependentValue =

;

CaseRanges.push_back(std::make_pair(LoVal, CS));

CaseVals.push_back(std::make_pair(LoVal, CS));

(!HasDependentValue) {

llvm::APSInt ConstantCondValue;

HasConstantCond =

;

(!TheDefaultStmt) {

(

.Val.isInt())

ConstantCondValue =

.Val.getInt();

assert(!HasConstantCond ||

(ConstantCondValue.getBitWidth() == CondWidth &&

ConstantCondValue.isSigned() == CondIsSigned));

(SwitchLoc, diag::warn_switch_default);

ShouldCheckConstantCond = HasConstantCond;

(!CaseVals.empty()) {

(

i = 0, e = CaseVals.size(); i != e; ++i) {

(ShouldCheckConstantCond &&

CaseVals[i].first == ConstantCondValue)

ShouldCheckConstantCond =

;

(i != 0 && CaseVals[i].first == CaseVals[i-1].first) {

StringRef PrevString, CurrString;

(

*DeclRef = dyn_cast<DeclRefExpr>(PrevCase)) {

PrevString = DeclRef->getDecl()->getName();

(

*DeclRef = dyn_cast<DeclRefExpr>(CurrCase)) {

CurrString = DeclRef->getDecl()->getName();

CaseVals[i-1].first.toString(CaseValStr);

(PrevString == CurrString)

(CaseVals[i].second->getLHS()->getBeginLoc(),

diag::err_duplicate_case)

<< (PrevString.empty() ? CaseValStr.str() : PrevString);

(CaseVals[i].second->getLHS()->getBeginLoc(),

diag::err_duplicate_case_differing_expr)

<< (PrevString.empty() ? CaseValStr.str() : PrevString)

<< (CurrString.empty() ? CaseValStr.str() : CurrString)

(CaseVals[i - 1].second->getLHS()->getBeginLoc(),

diag::note_duplicate_case_prev);

CaseListIsErroneous =

;

(!CaseRanges.empty()) {

llvm::stable_sort(CaseRanges);

std::vector<llvm::APSInt> HiVals;

(

i = 0, e = CaseRanges.size(); i != e; ++i) {

llvm::APSInt &LoVal = CaseRanges[i].first;

*CR = CaseRanges[i].second;

*HiBeforePromotion = Hi;

CondWidthBeforePromotion, CondIsSignedBeforePromotion);

(LoVal > HiVal) {

CaseRanges.erase(CaseRanges.begin()+i);

(ShouldCheckConstantCond &&

LoVal <= ConstantCondValue &&

ConstantCondValue <= HiVal)

ShouldCheckConstantCond =

;

HiVals.push_back(HiVal);

(

i = 0, e = CaseRanges.size(); i != e; ++i) {

llvm::APSInt &CRLo = CaseRanges[i].first;

llvm::APSInt &CRHi = HiVals[i];

*CR = CaseRanges[i].second;

llvm::APSInt OverlapVal(32);

CaseValsTy::iterator I =

llvm::lower_bound(CaseVals, CRLo, CaseCompareFunctor());

(I != CaseVals.end() && I->first < CRHi) {

OverlapVal = I->first;

OverlapStmt = I->second;

I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor());

(I != CaseVals.begin() && (I-1)->first >= CRLo) {

OverlapVal = (I-1)->first;

OverlapStmt = (I-1)->second;

(i && CRLo <= HiVals[i-1]) {

OverlapVal = HiVals[i-1];

OverlapStmt = CaseRanges[i-1].second;

diag::note_duplicate_case_prev);

CaseListIsErroneous =

;

(!CaseListIsErroneous && !CaseListIsIncomplete &&

ShouldCheckConstantCond) {

(CondExpr->

(), diag::warn_missing_case_for_condition)

<<

(ConstantCondValue, 10)

(!CaseListIsErroneous && !CaseListIsIncomplete && !HasConstantCond &&

llvm::APSInt Val = EDI->getInitVal();

EnumVals.push_back(std::make_pair(Val, EDI));

EI = EnumVals.begin(), EIEnd =

std::unique(EnumVals.begin(), EnumVals.end(),

);

(CaseValsTy::const_iterator CI = CaseVals.begin();

CI != CaseVals.end(); CI++) {

*CaseExpr = CI->second->getLHS();

<< CondTypeBeforePromotion;

EI = EnumVals.begin();

(CaseRangesTy::const_iterator RI = CaseRanges.begin();

RI != CaseRanges.end(); RI++) {

*CaseExpr = RI->second->getLHS();

<< CondTypeBeforePromotion;

RI->second->getRHS()->EvaluateKnownConstInt(

);

CaseExpr = RI->second->getRHS();

<< CondTypeBeforePromotion;

CI = CaseVals.begin();

RI = CaseRanges.begin();

hasCasesNotInSwitch =

;

(EI = EnumVals.begin(); EI != EIEnd; EI++) {

(EI->second->getAvailability()) {

(EI->second->hasAttr<UnusedAttr>())

(CI != CaseVals.end() && CI->first < EI->first)

(CI != CaseVals.end() && CI->first == EI->first)

(; RI != CaseRanges.end(); RI++) {

RI->second->getRHS()->EvaluateKnownConstInt(

);

(EI->first <= Hi)

(RI == CaseRanges.end() || EI->first < RI->first) {

hasCasesNotInSwitch =

;

UnhandledNames.push_back(EI->second->getDeclName());

(TheDefaultStmt && UnhandledNames.empty() && ED->

())

(!UnhandledNames.empty()) {

? diag::warn_def_missing_case

: diag::warn_missing_case)

(

I = 0,

= std::min(UnhandledNames.size(), (

)3);

DB << UnhandledNames[I];

(!hasCasesNotInSwitch)

diag::warn_empty_switch_body);

(CaseListIsErroneous)

*ED = ET->getDecl();

(ED->

<FlagEnumAttr>()) {

(SrcExpr->

(), diag::warn_not_in_enum_assignment)

llvm::APSInt Val = EDI->getInitVal();

EnumVals.push_back(std::make_pair(Val, EDI));

(EnumVals.empty())

EnumValsTy::iterator EIend =

std::unique(EnumVals.begin(), EnumVals.end(),

);

EnumValsTy::const_iterator EI = EnumVals.begin();

(EI != EIend && EI->first < RhsVal)

(EI == EIend || EI->first != RhsVal) {

(SrcExpr->

(), diag::warn_not_in_enum_assignment)

CondVal = Cond.

();

CheckBreakContinueBinding(CondVal.second);

(CondVal.second &&

!

.

(diag::warn_comma_operator, CondVal.second->getExprLoc()))

CommaVisitor(*this).Visit(CondVal.second);

(isa<OpenACCUpdateConstruct>(Body)) {

(isa<NullStmt>(Body))

WhileLoc, LParenLoc, RParenLoc);

assert(Cond &&

);

CheckBreakContinueBinding(Cond);

Cond = CondResult.

();

Cond = CondResult.

();

CommaVisitor(*this).Visit(Cond);

(isa<OpenACCUpdateConstruct>(Body)) {

(

)

(Body, Cond, DoLoc, WhileLoc, CondRParen);

DeclSetVector &Decls;

DeclExtractor(

&S, DeclSetVector &Decls,

Inherited(S.Context),

isSimple() {

Simple; }

VisitStmt(

*S) { Simple =

; }

Visit(

->getLHS());

Visit(

->getRHS());

Visit(

->getSubExpr());

(

->getOpcode() == UO_Deref)

Visit(

->getSubExpr());

Visit(

->getCond());

Visit(

->getTrueExpr());

Visit(

->getFalseExpr());

Visit(

->getSubExpr());

Visit(

->getOpaqueValue()->getSourceExpr());

Visit(

->getFalseExpr());

*VD = dyn_cast<VarDecl>(

->getDecl());

DeclSetVector &Decls;

DeclMatcher(

&S, DeclSetVector &Decls,

*Statement) :

Inherited(S.Context), Decls(Decls), FoundDecl(

) {

(!Statement)

;

(

->getCastKind() == CK_LValueToRValue)

CheckLValueToRValueCast(

->getSubExpr());

Visit(

->getSubExpr());

CheckLValueToRValueCast(

*

) {

(isa<DeclRefExpr>(

)) {

Visit(CO->getCond());

CheckLValueToRValueCast(CO->getTrueExpr());

CheckLValueToRValueCast(CO->getFalseExpr());

dyn_cast<BinaryConditionalOperator>(

)) {

CheckLValueToRValueCast(BCO->getOpaqueValue()->getSourceExpr());

CheckLValueToRValueCast(BCO->getFalseExpr());

(

*VD = dyn_cast<VarDecl>(

->getDecl()))

(Decls.count(VD))

(

*OVE = dyn_cast<OpaqueValueExpr>(S))

Visit(OVE->getSourceExpr());

FoundDeclInUse() {

FoundDecl; }

CheckForLoopConditionalStatement(

&S,

*Second,

(!Second)

;

DeclSetVector Decls;

DeclExtractor DE(S, Decls, Ranges);

(!DE.isSimple())

;

(Decls.size() == 0)

;

(

*VD : Decls)

(DeclMatcher(S, Decls, Second).FoundDeclInUse() ||

DeclMatcher(S, Decls, Third).FoundDeclInUse() ||

DeclMatcher(S, Decls, Body).FoundDeclInUse())

(Decls.size() > 4) {

(

*VD : Decls)

(

: Ranges)

S.

(Ranges.begin()->getBegin(), PDiag);

ProcessIterationStmt(

&S,

* Statement,

&Increment,

(

Cleanups = dyn_cast<ExprWithCleanups>(Statement))

(!Cleanups->cleanupsHaveSideEffects())

(

*UO = dyn_cast<UnaryOperator>(Statement)) {

(UO->getOpcode()) {

:

;

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

:

;

DRE = dyn_cast<DeclRefExpr>(

->getArg(0));

InSwitch =

;

BreakContinueFinder(

&S,

* Body) :

Inherited(S.Context) {

ContinueLoc =

->getContinueLoc();

BreakLoc =

->getBreakLoc();

VisitSwitchStmt(

* S) {

(

*

= S->getInit())

(

*CondVar = S->getConditionVariableDeclStmt())

(

*Cond = S->getCond())

(

*Body = S->getBody())

VisitForStmt(

*S) {

(

*

= S->getInit())

VisitWhileStmt(

*) {

VisitDoStmt(

*) {

(

*

= S->getInit())

(

*

= S->getRangeStmt())

(

*

= S->getBeginStmt())

(

*End = S->getEndStmt())

(

*Element = S->getElement())

(

*Collection = S->getCollection())

ContinueFound() {

ContinueLoc.

(); }

BreakFound() {

BreakLoc.

(); }

CheckForRedundantIteration(

&S,

*Third,

*Body) {

(!Body || !Third)

;

(!LastStmt)

;

LoopIncrement, LastIncrement;

(!ProcessIterationStmt(S, Third, LoopIncrement, LoopDRE))

;

(!ProcessIterationStmt(S, LastStmt, LastIncrement, LastDRE))

;

(LoopIncrement != LastIncrement ||

(BreakContinueFinder(S, Body).ContinueFound())

;

S.

(LastDRE->

(), diag::warn_redundant_loop_iteration)

<< LastDRE->

() << LastIncrement;

Sema::CheckBreakContinueBinding(

*

) {

BreakContinueFinder BCFinder(*

,

);

(BCFinder.BreakFound() && BreakParent) {

(BCFinder.GetBreakLoc(), diag::warn_break_binds_to_switch);

(BCFinder.GetBreakLoc(), diag::warn_loop_ctrl_binds_to_inner)

(BCFinder.GetContinueLoc(), diag::warn_loop_ctrl_binds_to_inner)

*NonVarSeen =

;

VarDeclSeen =

;

(

*DI : DS->decls()) {

(

*VD = dyn_cast<VarDecl>(DI)) {

VarDeclSeen =

;

(DI->getLocation(), diag::err_non_local_variable_decl_in_for);

DI->setInvalidDecl();

}

(!NonVarSeen) {

(NonVarSeen && !VarDeclSeen)

(NonVarSeen->

(), diag::err_non_variable_decl_in_for);

CheckBreakContinueBinding(Second.

().second);

CheckBreakContinueBinding(third.

());

(!Second.

().first)

CheckForLoopConditionalStatement(*

, Second.

().second, third.

(),

CheckForRedundantIteration(*

, third.

(), Body);

(Second.

().second &&

Second.

().second->getExprLoc()))

CommaVisitor(*this).Visit(Second.

().second);

(isa<NullStmt>(Body))

Body, ForLoc, LParenLoc, RParenLoc);

(

->getType()->isUndeducedType()) {

(!isa<InitListExpr>(

) &&

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

SemaRef.

(

, DiagID) <<

->getType();

->getTypeSourceInfo()->getTypeLoc(),

, InitType, Info);

SemaRef.

(

, DiagID) <<

->getType();

(InitType.

()) {

->setType(InitType);

BeginEndFunction {

NoteForRangeBeginEndFunction(

&SemaRef,

*

,

BeginEndFunction BEF) {

std::string Description;

IsTemplate =

;

FunTmpl->getTemplateParameters(), *

->getTemplateSpecializationArgs());

SemaRef.

(

, diag::note_for_range_begin_end)

<< BEF << IsTemplate << Description <<

->

();

(InitStmt->

(), diag::err_objc_for_range_init_stmt)

assert(DS &&

);

DepthStr = std::to_string(S->getDepth() / 2);

*RangeVar = BuildForRangeVarDecl(*

, RangeLoc,

std::string(

) + DepthStr);

diag::err_for_range_deduction_failure)) {

ForLoc, CoawaitLoc, InitStmt, ColonLoc, RangeDecl.

(),

,

, DS, RParenLoc, Kind,

LifetimeExtendTemps);

*EndExpr, BeginEndFunction *BEF) {

BuildBegin = [&] {

BeginMemberLookup, CandidateSet,

BeginRange, BeginExpr);

<< ColonLoc << BEF_begin << BeginRange->

();

BeginExpr->

());

diag::err_for_range_iter_deduction_failure)) {

NoteForRangeBeginEndFunction(SemaRef, BeginExpr->

(), *BEF);

BuildEnd = [&] {

EndMemberLookup, CandidateSet,

<< ColonLoc << BEF_end << EndRange->

();

diag::err_for_range_iter_deduction_failure)) {

NoteForRangeBeginEndFunction(SemaRef, EndExpr->

(), *BEF);

(BeginMemberLookup.

() != EndMemberLookup.

()) {

BuildNonmember = [&](

(BuildFound()) {

SemaRef.

(diag::err_for_range_invalid)

<< BeginRange->

() << BEFFound),

diag::note_for_range_member_begin_end_ignored)

<< BeginRange->

() << BEFFound;

llvm_unreachable(

);

(BeginMemberLookup.

())

BuildNonmember(BEF_end, EndMemberLookup, BuildEnd, BuildBegin);

BuildNonmember(BEF_begin, BeginMemberLookup, BuildBegin, BuildEnd);

S, ForLoc, CoawaitLoc, InitStmt, LoopVarDecl, ColonLoc,

SemaRef.

(RangeLoc, diag::err_for_range_dereference)

S, ForLoc, CoawaitLoc, InitStmt, LoopVarDecl, ColonLoc,

*RangeDS = cast<DeclStmt>(RangeDecl);

*LoopVarDS = cast<DeclStmt>(LoopVarDecl);

(

*DD = dyn_cast<DecompositionDecl>(LoopVar))

(

*Binding : DD->bindings()) {

(!Binding->isParameterPack())

}

(!BeginDeclStmt.

()) {

diag::err_for_range_incomplete_type))

(

*MTE : LifetimeExtendTemps)

DepthStr = std::to_string(S->getDepth() / 2);

*BeginVar = BuildForRangeVarDecl(*

, ColonLoc,

,

std::string(

) + DepthStr);

std::string(

) + DepthStr);

BeginExpr = BeginRangeRef;

diag::err_for_range_iter_deduction_failure)) {

NoteForRangeBeginEndFunction(*

, BeginExpr.

(), BEF_begin);

dyn_cast<VariableArrayType>(UnqAT)) {

VAT->desugar(), RangeLoc))

VAT->getElementType(), RangeLoc))

(SizeOfEachElementExprR.

())

SizeOfVLAExprR.

(), SizeOfEachElementExprR.

());

llvm_unreachable(

);

EndExpr =

(S, ColonLoc, tok::plus, EndRangeRef.

(),

diag::err_for_range_iter_deduction_failure)) {

NoteForRangeBeginEndFunction(*

, EndExpr.

(), BEF_end);

BeginEndFunction BEFFailure;

*

, BeginRangeRef.

(), EndRangeRef.

(), RangeType, BeginVar,

EndVar, ColonLoc, CoawaitLoc, &CandidateSet, &BeginExpr, &EndExpr,

BEFFailure == BEF_begin) {

ArrayTy = PVD->getOriginalType();

PointerTy = PVD->getType();

(

->getBeginLoc(), diag::err_range_on_array_parameter)

<< RangeLoc << PVD << ArrayTy << PointerTy;

(PVD->getLocation(), diag::note_declared_at);

CoawaitLoc, InitStmt,

LoopVarDecl, ColonLoc,

*

= BEFFailure ? EndRangeRef.

() : BeginRangeRef.

();

(diag::err_for_range_invalid)

<< RangeLoc <<

->getType()

);

? diag::warn_for_range_begin_end_types_differ

: diag::ext_for_range_begin_end_types_differ)

<< BeginType << EndType;

NoteForRangeBeginEndFunction(*

, BeginExpr.

(), BEF_begin);

NoteForRangeBeginEndFunction(*

, EndExpr.

(), BEF_end);

NotEqExpr =

(S, ColonLoc, tok::exclaimequal,

BeginRef.

(), EndRef.

());

(RangeLoc, diag::note_for_range_invalid_iterator)

<< RangeLoc << 0 << BeginRangeRef.

()->

();

NoteForRangeBeginEndFunction(*

, BeginExpr.

(), BEF_begin);

NoteForRangeBeginEndFunction(*

, EndExpr.

(), BEF_end);

IncrExpr =

(S, ColonLoc, tok::plusplus, BeginRef.

());

(!IncrExpr.isInvalid() && CoawaitLoc.

())

(!IncrExpr.isInvalid())

(IncrExpr.isInvalid()) {

(RangeLoc, diag::note_for_range_invalid_iterator)

<< RangeLoc << 2 << BeginRangeRef.

()->

() ;

NoteForRangeBeginEndFunction(*

, BeginExpr.

(), BEF_begin);

(RangeLoc, diag::note_for_range_invalid_iterator)

<< RangeLoc << 1 << BeginRangeRef.

()->

();

NoteForRangeBeginEndFunction(*

, BeginExpr.

(), BEF_begin);

NoteForRangeBeginEndFunction(*

, BeginExpr.

(), BEF_begin);

InitStmt, RangeDS, cast_or_null<DeclStmt>(BeginDeclStmt.

()),

cast_or_null<DeclStmt>(EndDeclStmt.

()), NotEqExpr.

(),

IncrExpr.get(), LoopVarDS,

, ForLoc, CoawaitLoc,

ColonLoc, RParenLoc);

(

Cleanups = dyn_cast<ExprWithCleanups>(InitExpr))

(!Cleanups->cleanupsHaveSideEffects())

InitExpr = Cleanups->getSubExpr();

dyn_cast<MaterializeTemporaryExpr>(InitExpr);

(!isa<CXXOperatorCallExpr>(

) && !isa<UnaryOperator>(

)) {

(isa<UnaryOperator>(

)) {

ReferenceReturnType = ReturnType;

(!ReferenceReturnType.

()) {

diag::warn_for_range_const_ref_binds_temp_built_from_ref)

<< VD << VariableType << ReferenceReturnType;

SemaRef.

(VD->

(), diag::note_use_type_or_non_reference)

<< NonReferenceType << NewReferenceType << VD->

()

SemaRef.

(VD->

(), diag::warn_for_range_ref_binds_ret_temp)

<< VD << RangeInitType;

SemaRef.

(VD->

(), diag::note_use_non_reference_type)

RD->hasAttr<TrivialABIAttr>();

(!CE->getConstructor()->isCopyConstructor())

}

(

*CE = dyn_cast<CastExpr>(InitExpr)) {

(CE->getCastKind() != CK_LValueToRValue)

<< VD << VariableType;

diag::warn_for_range_const_ref_binds_temp_built_from_ref,

SemaRef.

.

(diag::warn_for_range_ref_binds_ret_temp,

->getRangeInit()->getType());

(isa<ObjCForCollectionStmt>(S))

diag::warn_empty_range_based_for_body);

(

()->isInOpenACCComputeConstructScope())

= ExprRes.

();

= ExprRes.

();

(

()->isInOpenACCComputeConstructScope())

&DestScope) {

S.

(

, diag::warn_jump_out_of_seh_finally);

(

(ContinueLoc, diag::err_continue_not_in_loop));

(S->isConditionVarScope()) {

(

(ContinueLoc, diag::err_continue_from_cond_var_init));

(S->isOpenACCComputeConstructScope())

(ContinueLoc, diag::err_acc_branch_in_out_compute_construct)

(

(BreakLoc, diag::err_break_not_in_loop_or_switch));

(S->isOpenMPLoopScope())

(

(BreakLoc, diag::err_omp_loop_cannot_use_stmt)

(S->isOpenACCComputeConstructScope() ||

(S->isLoopScope() && S->getParent() &&

S->getParent()->isOpenACCComputeConstructScope()))

(BreakLoc, diag::err_acc_branch_in_out_compute_construct)

*DR = dyn_cast<DeclRefExpr>(

->

());

(!DR || DR->refersToEnclosingVariableOrCapture())

*VD = dyn_cast<VarDecl>(DR->getDecl());

(VD->

() == Decl::ParmVar)

(VD->

() != Decl::Var)

(VD->

<BlocksAttr>())

invalidNRVO = [&] {

((ReturnType->

() == Type::TypeClass::Auto &&

invalidNRVO();

invalidNRVO();

*Step = llvm::find_if(

.steps(), [](

&Step) {

return Step.Kind == InitializationSequence::SK_ConstructorInitialization ||

Step.Kind == InitializationSequence::SK_UserConversion;

(Step !=

.step_end()) {

*FD = Step->Function.Function;

(isa<CXXConstructorDecl>(FD)

: cast<CXXMethodDecl>(FD)->getRefQualifier() ==

)

SupressSimplerImplicitMoves) {

*InitExpr = &AsRvalue;

->getBeginLoc());

Res =

.getFailedOverloadResult();

.Perform(*

, Entity, Kind,

);

SupressSimplerImplicitMoves) {

HasDeducedReturnType =

RetValExp = ER.

();

(HasDeducedReturnType) {

assert(AT &&

);

(RetValExp && !isa<InitListExpr>(RetValExp)) {

(

.isInvalid())

RetValExp =

.get();

(ReturnLoc, diag::err_lambda_return_init_list)

(

*CurBlock = dyn_cast<BlockScopeInfo>(CurCap)) {

(ReturnLoc, diag::err_noreturn_block_has_return_expr);

}

(

*CurRegion = dyn_cast<CapturedRegionScopeInfo>(CurCap)) {

(ReturnLoc, diag::err_return_in_captured_stmt) << CurRegion->getRegionName();

assert(CurLambda &&

);

(ReturnLoc, diag::err_noreturn_lambda_has_return_expr);

(RetValExp && !isa<InitListExpr>(RetValExp) &&

(ReturnLoc, diag::ext_return_has_void_expr) <<

<< 2;

(ReturnLoc, diag::err_return_block_has_expr);

RetValExp =

;

}

(!RetValExp) {

(

(ReturnLoc, diag::err_block_return_missing_expr));

Entity, NRInfo, RetValExp, SupressSimplerImplicitMoves);

RetValExp = Res.

();

CheckReturnValExpr(RetValExp, FnRetType, ReturnLoc);

RetValExp = ER.

();

(

*CurBlock = dyn_cast<BlockScopeInfo>(CurCap);

CurBlock->TheDecl->setInvalidDecl();

LocalTypedefNameReferencer(

&S) : S(S) {}

VisitRecordType(

*RT)

;

LocalTypedefNameReferencer::VisitRecordType(

*RT) {

*R = dyn_cast<CXXRecordDecl>(RT->

());

(!R || !R->isLocalClass() || !R->isLocalClass()->isExternallyVisible() ||

R->isDependentType())

(

*TmpD : R->decls())

(

*

= dyn_cast<TypedefNameDecl>(TmpD))

(

->getAccess() !=

|| R->hasFriends())

(isa_and_nonnull<InitListExpr>(RetExpr)) {

: diag::err_auto_fn_return_init_list)

assert(AT->

() &&

);

(ReturnLoc, diag::err_auto_fn_return_void_but_not_auto)

<< OrigResultType.

();

(FindResult.Expression)

TemplateSpecLoc = FindResult.Expression->getNameLoc();

OrigResultType, RetExpr, Deduced, Info,

,

, &FailedTSC);

(ReturnLoc, diag::err_typecheck_missing_return_type_incompatible)

(ReturnLoc, diag::err_auto_fn_different_deductions)

(RetExpr->

(), diag::err_auto_fn_deduction_failure)

LocalTypedefNameReferencer(*this).TraverseType(RetExpr->

());

RetValExp,

,

);

(

()->isInOpenACCComputeConstructScope())

(ReturnLoc, diag::err_acc_branch_in_out_compute_construct)

);

(ReturnLoc, diag::err_return_in_coroutine);

CheckInvalidBuiltinCountedByRef(RetVal.

(), ReturnArgKind);

*

(cast<ReturnStmt>(R.

())->getNRVOCandidate());

AllowRecovery) {

SupressSimplerImplicitMoves =

SupressSimplerImplicitMoves);

*Attrs =

;

isObjCMethod =

;

(ReturnLoc, diag::warn_noreturn_function_has_return_expr) << FD;

(FD->

() && RetValExp)

(isa<CXXBoolLiteralExpr>(RetValExp))

(ReturnLoc, diag::warn_main_returns_bool_literal)

(FD->

<CmseNSEntryAttr>() && RetValExp) {

(

*RT = dyn_cast<RecordType>(FnRetType.

())) {

(RetValExp->

(), diag::warn_cmse_nonsecure_union) << 1;

isObjCMethod =

;

*ATy = dyn_cast<ArrayType>(RetValExp->

());

(ATy && ATy->getElementType().isWebAssemblyReferenceType()) {

(ReturnLoc, diag::err_wasm_table_art) << 1;

RetValExp = ER.

();

AT->isDeduced() ? FnRetType :

());

(Recovery.isInvalid())

RetValExp = Recovery.get();

(

*ILE = dyn_cast<InitListExpr>(RetValExp)) {

FunctionKind = 0;

(isa<ObjCMethodDecl>(CurDecl))

(isa<CXXConstructorDecl>(CurDecl))

(isa<CXXDestructorDecl>(CurDecl))

(ReturnLoc, diag::err_return_init_list)

RetValExp = AllowRecovery

ILE->getRBraceLoc(), ILE->inits())

= diag::ext_return_has_expr;

(isa<CXXConstructorDecl>(CurDecl) ||

isa<CXXDestructorDecl>(CurDecl))

= diag::err_ctor_dtor_returns_void;

= diag::ext_return_has_void_expr;

(

.isInvalid())

RetValExp =

.get();

(

== diag::err_ctor_dtor_returns_void) {

(ReturnLoc,

) << CurDecl << isa<CXXDestructorDecl>(CurDecl)

(

!= diag::ext_return_has_void_expr ||

FunctionKind = 0;

(isa<ObjCMethodDecl>(CurDecl))

(isa<CXXConstructorDecl>(CurDecl))

(isa<CXXDestructorDecl>(CurDecl))

(ReturnLoc,

)

RetValExp = ER.

();

}

(!RetValExp && !HasDependentReturnType) {

(ReturnLoc, diag::err_constexpr_return_missing_expr)

DiagID =

().C99 ? diag::ext_return_missing_expr

: diag::warn_return_missing_expr;

);

IsMethod = FD ==

;

(ReturnLoc, DiagID) << ND << IsMethod;

assert(RetValExp || HasDependentReturnType);

RetType = RelatedRetType.

() ? FnRetType : RelatedRetType;

Entity, NRInfo, RetValExp, SupressSimplerImplicitMoves);

RetValExp->

(), RetValExp, RetType);

(!RelatedRetType.

()) {

CheckReturnValExpr(RetValExp, FnRetType, ReturnLoc, isObjCMethod, Attrs,

RetValExp = ER.

();

(

->getNRVOCandidate())

*HandlerBlock) {

(CatchLoc, cast_or_null<VarDecl>(ExDecl), HandlerBlock);

CatchHandlerType {

LLVM_PREFERRED_TYPE(

)

IsPointer : 1;

llvm::DenseMapInfo<CatchHandlerType>;

Unique { ForDenseMap };

CatchHandlerType(

QT, Unique) : QT(QT), IsPointer(

) {}

CatchHandlerType(

QT,

IsPointer)

: QT(QT), IsPointer(IsPointer) {}

underlying()

{

QT; }

isPointer()

{

IsPointer; }

(

CatchHandlerType &LHS,

CatchHandlerType &RHS) {

(LHS.IsPointer != RHS.IsPointer)

LHS.QT == RHS.QT;

<>

DenseMapInfo<CatchHandlerType> {

CatchHandlerType(DenseMapInfo<QualType>::getEmptyKey(),

CatchHandlerType::ForDenseMap);

CatchHandlerType(DenseMapInfo<QualType>::getTombstoneKey(),

CatchHandlerType::ForDenseMap);

DenseMapInfo<QualType>::getHashValue(

.underlying());

(

CatchHandlerType &LHS,

CatchHandlerType &RHS) {

CatchTypePublicBases {

llvm::DenseMap<QualType, CXXCatchStmt *> &TypesToCheck;

CatchTypePublicBases(

llvm::DenseMap<QualType, CXXCatchStmt *> &

,

: TypesToCheck(

), FoundHandler(nullptr), TestAgainstType(QT) {}

*getFoundHandler()

{

FoundHandler; }

getFoundHandlerType()

{

FoundHandlerType; }

(S->getAccessSpecifier() == AccessSpecifier::AS_public) {

Check = S->getType().getCanonicalType();

&M = TypesToCheck;

I = M.find(Check);

(I->second->getCaughtType()->isPointerType() ==

FoundHandler = I->second;

FoundHandlerType = Check;

IsOpenMPGPUTarget =

().OpenMPIsTargetDevice && (

.isNVPTX() ||

.isAMDGCN());

(!IsOpenMPGPUTarget && !

().CXXExceptions &&

(TryLoc, diag::err_exceptions_disabled) <<

;

(IsOpenMPGPUTarget)

(TryLoc, diag::warn_try_not_valid_on_target) <<

.str();

<<

<< llvm::to_underlying(

().CurrentTarget());

(TryLoc, diag::err_omp_simd_region_cannot_use_stmt) <<

;

(TryLoc, diag::err_mixing_cxx_try_seh_try) << 0;

NumHandlers = Handlers.size();

assert(!Handlers.empty() &&

);

llvm::DenseMap<QualType, CXXCatchStmt *> HandledBaseTypes;

llvm::DenseMap<CatchHandlerType, CXXCatchStmt *> HandledTypes;

(

i = 0; i < NumHandlers; ++i) {

(i < NumHandlers - 1)

Underlying = HandlerCHT.underlying();

(!RD->hasDefinition())

Paths.setOrigin(RD);

CatchTypePublicBases CTPB(HandledBaseTypes,

(RD->lookupInBases(CTPB, Paths)) {

(!Paths.isAmbiguous(

diag::warn_exception_caught_by_earlier_handler)

diag::note_previous_exception_handler)

R = HandledTypes.insert(

diag::warn_exception_caught_by_earlier_handler)

diag::note_previous_exception_handler)

assert(TryBlock && Handler);

(TryLoc, diag::err_seh_try_outside_functions);

(TryLoc, diag::err_seh_try_unsupported);

assert(FilterExpr &&

);

(FilterExpr->

(), diag::err_filter_expression_integral)

*SEHTryParent = CurScope;

SEHTryParent = SEHTryParent->

();

QualifierLoc, NameInfo,

cast<CompoundStmt>(Nested));

NumParams) {

assert(NumParams > 0 &&

);

CaptureInits.push_back(

.get());

std::optional<int>

NumParams) {

(

, diag::err_sme_openmp_captured_region) << *ErrorIndex;

OpenMPCaptureLevel) {

(

, diag::err_sme_openmp_captured_region) << *ErrorIndex;

ContextIsFound =

;

ParamNum = 0;

I !=

; ++I, ++ParamNum) {

(I->second.isNull()) {

assert(!ContextIsFound &&

);

ContextIsFound =

;

assert(ContextIsFound &&

);

(!ContextIsFound) {

Captures, CaptureInits, CD, RD);

Defines the clang::ASTContext interface.

This file provides some common utility functions for processing Lambda related AST Constructs.

Defines the clang::Expr interface and subclasses for C++ expressions.

llvm::MachO::Record Record

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.

This file declares semantic analysis for Objective-C.

This file declares semantic analysis for OpenMP constructs and clauses.

static bool CmpEnumVals(const std::pair< llvm::APSInt, EnumConstantDecl * > &lhs, const std::pair< llvm::APSInt, EnumConstantDecl * > &rhs)

CmpEnumVals - Comparison predicate for sorting enumeration values.

static bool FinishForRangeVarDecl(Sema &SemaRef, VarDecl *Decl, Expr *Init, SourceLocation Loc, int DiagID)

Finish building a variable declaration for a for-range statement.

static bool CmpCaseVals(const std::pair< llvm::APSInt, CaseStmt * > &lhs, const std::pair< llvm::APSInt, CaseStmt * > &rhs)

CmpCaseVals - Comparison predicate for sorting case values.

SmallVector< std::pair< llvm::APSInt, EnumConstantDecl * >, 64 > EnumValsTy

static bool ShouldDiagnoseSwitchCaseNotInEnum(const Sema &S, const EnumDecl *ED, const Expr *CaseExpr, EnumValsTy::iterator &EI, EnumValsTy::iterator &EIEnd, const llvm::APSInt &Val)

Returns true if we should emit a diagnostic about this case expression not being a part of the enum u...

static bool DiagnoseUnusedComparison(Sema &S, const Expr *E)

Diagnose unused comparisons, both builtin and overloaded operators.

static bool EqEnumVals(const std::pair< llvm::APSInt, EnumConstantDecl * > &lhs, const std::pair< llvm::APSInt, EnumConstantDecl * > &rhs)

EqEnumVals - Comparison preficate for uniqing enumeration values.

static std::optional< int > isOpenMPCapturedRegionInArmSMEFunction(Sema const &S, CapturedRegionKind Kind)

static bool hasDeducedReturnType(FunctionDecl *FD)

Determine whether the declared return type of the specified function contains 'auto'.

static bool ObjCEnumerationCollection(Expr *Collection)

static void DiagnoseForRangeConstVariableCopies(Sema &SemaRef, const VarDecl *VD)

static StmtResult RebuildForRangeWithDereference(Sema &SemaRef, Scope *S, SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt, Stmt *LoopVarDecl, SourceLocation ColonLoc, Expr *Range, SourceLocation RangeLoc, SourceLocation RParenLoc)

Speculatively attempt to dereference an invalid range expression.

static void checkEnumTypesInSwitchStmt(Sema &S, const Expr *Cond, const Expr *Case)

static void DiagnoseForRangeReferenceVariableCopies(Sema &SemaRef, const VarDecl *VD, QualType RangeInitType)

static void DiagnoseForRangeVariableCopies(Sema &SemaRef, const CXXForRangeStmt *ForStmt)

DiagnoseForRangeVariableCopies - Diagnose three cases and fixes for them.

static bool CheckSimplerImplicitMovesMSVCWorkaround(const Sema &S, const Expr *E)

static bool VerifyInitializationSequenceCXX98(const Sema &S, const InitializationSequence &Seq)

Verify that the initialization sequence that was picked for the first overload resolution is permissi...

static QualType GetTypeBeforeIntegralPromotion(const Expr *&E)

GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of potentially integral-promoted expr...

static Sema::ForRangeStatus BuildNonArrayForRange(Sema &SemaRef, Expr *BeginRange, Expr *EndRange, QualType RangeType, VarDecl *BeginVar, VarDecl *EndVar, SourceLocation ColonLoc, SourceLocation CoawaitLoc, OverloadCandidateSet *CandidateSet, ExprResult *BeginExpr, ExprResult *EndExpr, BeginEndFunction *BEF)

Create the initialization, compare, and increment steps for the range-based for loop expression.

static bool hasTrivialABIAttr(QualType VariableType)

Determines whether the VariableType's declaration is a record with the clang::trivial_abi attribute.

static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned)

static bool buildCapturedStmtCaptureList(Sema &S, CapturedRegionScopeInfo *RSI, SmallVectorImpl< CapturedStmt::Capture > &Captures, SmallVectorImpl< Expr * > &CaptureInits)

static bool DiagnoseNoDiscard(Sema &S, const NamedDecl *OffendingDecl, const WarnUnusedResultAttr *A, SourceLocation Loc, SourceRange R1, SourceRange R2, bool IsCtor)

static void checkCaseValue(Sema &S, SourceLocation Loc, const llvm::APSInt &Val, unsigned UnpromotedWidth, bool UnpromotedSign)

Check the specified case value is in range for the given unpromoted switch type.

static void CheckJumpOutOfSEHFinally(Sema &S, SourceLocation Loc, const Scope &DestScope)

Defines the Objective-C statement AST node classes.

enum clang::format::@1315::AnnotatingParser::Context::@350 ContextType

Defines the clang::TypeLoc interface and its subclasses.

Allows QualTypes to be sorted and hence used in maps and sets.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

SourceManager & getSourceManager()

CharUnits getTypeAlignInChars(QualType T) const

Return the ABI-specified alignment of a (complete) type T, in characters.

unsigned getIntWidth(QualType T) const

QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const

getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.

QualType getAutoRRefDeductType() const

C++11 deduction pattern for 'auto &&' type.

QualType getTagDeclType(const TagDecl *Decl) const

Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.

bool hasSameType(QualType T1, QualType T2) const

Determine whether the given types T1 and T2 are equivalent.

QualType getPointerType(QualType T) const

Return the uniqued reference to the type for a pointer to the specified type.

QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const

Return the uniqued reference to the type for an lvalue reference to the specified type.

QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const

Return the unique reference to the type for the specified type declaration.

QualType getPointerDiffType() const

Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.

TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const

Allocate a TypeSourceInfo where all locations have been initialized to a given location,...

QualType getObjCObjectPointerType(QualType OIT) const

Return a ObjCObjectPointerType type for the given ObjCObjectType.

CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const

Return a conservative estimate of the alignment of the specified decl D.

bool hasSameUnqualifiedType(QualType T1, QualType T2) const

Determine whether the given types are equivalent after cvr-qualifiers have been removed.

uint64_t getTypeSize(QualType T) const

Return the size of the specified (complete) type T, in bits.

bool hasSimilarType(QualType T1, QualType T2) const

Determine if two types are similar, according to the C++ rules.

const TargetInfo & getTargetInfo() const

QualType getAutoDeductType() const

C++11 deduction pattern for 'auto' type.

void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)

Change the result type of a function type once it is deduced.

Represents an array type, per C99 6.7.5.2 - Array Declarators.

Attr - This represents one attribute.

SourceLocation getLocation() const

SourceRange getRange() const

static AttributedStmt * Create(const ASTContext &C, SourceLocation Loc, ArrayRef< const Attr * > Attrs, Stmt *SubStmt)

Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.

bool isDecltypeAuto() const

BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...

A builtin binary operation expression such as "x + y" or "x <= y".

BreakStmt - This represents a break.

CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....

Represents a path from a specific derived class (which is not represented as part of the path) to a p...

BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...

Represents a base class of a C++ class.

Represents binding an expression to a temporary.

A boolean literal, per ([C++ lex.bool] Boolean literals).

CXXCatchStmt - This represents a C++ catch block.

SourceLocation getBeginLoc() const LLVM_READONLY

VarDecl * getExceptionDecl() const

QualType getCaughtType() const

Represents a call to a C++ constructor.

Represents a C++ constructor within a class.

Represents a C++ conversion function within a class.

CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...

Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....

Represents a call to a member function that may be written either with member call syntax (e....

Represents a static or instance method of a struct/union/class.

A call to an overloaded operator written using operator syntax.

Represents a C++ struct/union/class.

static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)

An expression "T()" which creates an rvalue of a non-class type T.

Represents a C++ nested-name-specifier or a global scope specifier.

NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const

Retrieve a nested-name-specifier with location information, copied into the given AST context.

static CXXTryStmt * Create(const ASTContext &C, SourceLocation tryLoc, CompoundStmt *tryBlock, ArrayRef< Stmt * > handlers)

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

static CanQual< Type > CreateUnsafe(QualType Other)

Builds a canonical type from a QualType.

QualType withConst() const

Retrieves a version of this type with const applied.

Represents the body of a CapturedStmt, and serves as its DeclContext.

static DeclContext * castToDeclContext(const CapturedDecl *D)

void setContextParam(unsigned i, ImplicitParamDecl *P)

void setParam(unsigned i, ImplicitParamDecl *P)

static CapturedDecl * Create(ASTContext &C, DeclContext *DC, unsigned NumParams)

Describes the capture of either a variable, or 'this', or variable-length array type.

This captures a statement into a function.

Stmt * getCapturedStmt()

Retrieve the statement being captured.

static CapturedStmt * Create(const ASTContext &Context, Stmt *S, CapturedRegionKind Kind, ArrayRef< Capture > Captures, ArrayRef< Expr * > CaptureInits, CapturedDecl *CD, RecordDecl *RD)

CaseStmt - Represent a case statement.

static CaseStmt * Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs, SourceLocation caseLoc, SourceLocation ellipsisLoc, SourceLocation colonLoc)

Build a case statement.

CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...

CompoundStmt - This represents a group of statements like { stmt stmt }.

static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt * > Stmts, FPOptionsOverride FPFeatures, SourceLocation LB, SourceLocation RB)

ConditionalOperator - The ?: ternary operator.

ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.

Represents the canonical version of C arrays with a specified constant size.

ContinueStmt - This represents a continue.

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

DeclContext * getParent()

getParent - Returns the containing DeclContext.

bool isFileContext() const

bool isDependentContext() const

Determines whether this context is dependent on a template parameter.

void addDecl(Decl *D)

Add the declaration D into this context.

bool isStdNamespace() const

bool isFunctionOrMethod() const

void addHiddenDecl(Decl *D)

Add the declaration D to this context without modifying any lookup tables.

bool isSingleDecl() const

A reference to a declared variable, function, enum, etc.

SourceLocation getLocation() const

DeclStmt - Adaptor class for mixing declarations with statements and expressions.

bool isSingleDecl() const

isSingleDecl - This method returns true if this DeclStmt refers to a single Decl.

const Decl * getSingleDecl() const

SourceLocation getBeginLoc() const LLVM_READONLY

Decl - This represents one declaration (or definition), e.g.

void setInvalidDecl(bool Invalid=true)

setInvalidDecl - Indicates the Decl had a semantic error.

void markUsed(ASTContext &C)

Mark the declaration used, in the sense of odr-use.

static Decl * castFromDeclContext(const DeclContext *)

bool isInvalidDecl() const

SourceLocation getLocation() const

void setImplicit(bool I=true)

void setLocation(SourceLocation L)

DeclContext * getDeclContext()

SourceLocation getTypeSpecEndLoc() const

SourceLocation getTypeSpecStartLoc() const

SourceLocation getBeginLoc() const LLVM_READONLY

TypeSourceInfo * getTypeSourceInfo() const

QualType getDeducedType() const

Get the type deduced for this placeholder type, or null if it has not been deduced.

SourceLocation getDefaultLoc() const

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

bool isIgnored(unsigned DiagID, SourceLocation Loc) const

Determine whether the diagnostic is known to be ignored.

DoStmt - This represents a 'do/while' stmt.

Recursive AST visitor that supports extension via dynamic dispatch.

enumerator_range enumerators() const

bool isClosed() const

Returns true if this enum is either annotated with enum_extensibility(closed) or isn't annotated with...

bool isClosedNonFlag() const

Returns true if this enum is annotated with neither flag_enum nor enum_extensibility(open).

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.

EnumDecl * getDecl() const

EvaluatedExprVisitor - This class visits 'Expr *'s.

This represents one expression.

bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const

EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...

@ SE_AllowSideEffects

Allow any unmodeled side effect.

Expr * IgnoreParenCasts() LLVM_READONLY

Skip past any parentheses and casts which might surround this expression until reaching a fixed point...

bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc, SourceRange &R1, SourceRange &R2, ASTContext &Ctx) const

isUnusedResultAWarning - Return true if this immediate expression should be warned about if the resul...

bool isValueDependent() const

Determines whether the value of this expression depends on.

bool isTypeDependent() const

Determines whether the type of this expression depends on.

llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const

EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.

Expr * IgnoreParenImpCasts() LLVM_READONLY

Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...

bool containsErrors() const

Whether this expression contains subexpressions which had errors, e.g.

Expr * IgnoreParens() LLVM_READONLY

Skip past any parentheses which might surround this expression until reaching a fixed point.

Decl * getReferencedDeclOfCallee()

bool isInstantiationDependent() const

Whether this expression is instantiation-dependent, meaning that it depends in some way on.

bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const

Expr * IgnoreImpCasts() LLVM_READONLY

Skip past any implicit casts which might surround this expression until reaching a fixed point.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

bool isKnownToHaveBooleanValue(bool Semantic=true) const

isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...

Represents difference between two FPOptions values.

FPOptionsOverride getChangesFrom(const FPOptions &Base) const

Return difference with the given option set.

Represents a member of a struct/union/class.

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.

ForStmt - This represents a 'for (init;cond;inc)' stmt.

SourceLocation getRParenLoc() const

SourceLocation getBeginLoc() const

FullExpr - Represents a "full-expression" node.

Represents a function declaration or definition.

const ParmVarDecl * getParamDecl(unsigned i) const

void setUsesSEHTry(bool UST)

bool isNoReturn() const

Determines whether this function is known to be 'noreturn', through an attribute on its declaration o...

QualType getReturnType() const

bool isConstexpr() const

Whether this is a (C++11) constexpr function or constexpr constructor.

bool isMain() const

Determines whether this function is "main", which is the entry point into an executable program.

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

bool isOverloadedOperator() const

Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".

OverloadedOperatorKind getOverloadedOperator() const

getOverloadedOperator - Which C++ overloaded operator this function represents, if any.

Represents a prototype with parameter type info, e.g.

Declaration of a template function.

FunctionType - C99 6.7.5.3 - Function Declarators.

static StringRef getNameForCallConv(CallingConv CC)

bool getNoReturnAttr() const

Determine whether this function type includes the GNU noreturn attribute.

QualType getReturnType() const

GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...

GotoStmt - This represents a direct goto.

One of these records is kept for each identifier that is lexed.

IdentifierInfo & get(StringRef Name)

Return the identifier token info for the specified named identifier.

static IfStmt * Create(const ASTContext &Ctx, SourceLocation IL, IfStatementKind Kind, Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LPL, SourceLocation RPL, Stmt *Then, SourceLocation EL=SourceLocation(), Stmt *Else=nullptr)

Create an IfStmt.

ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....

ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...

static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)

static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)

Create implicit parameter.

IndirectGotoStmt - This represents an indirect goto.

static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)

Create a copy initialization.

Describes the sequence of initializations required to initialize a given object or reference with a s...

Describes an entity that is being initialized.

static InitializedEntity InitializeResult(SourceLocation ReturnLoc, QualType Type)

Create the initialization entity for the result of a function.

static InitializedEntity InitializeRelatedResult(ObjCMethodDecl *MD, QualType Type)

Create the initialization entity for a related result.

unsigned allocateManglingNumber() const

static InitializedEntity InitializeVariable(VarDecl *Var)

Create the initialization entity for a variable.

static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)

Create the initialization entity for a parameter.

static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)

Returns a new integer literal with value 'V' and type 'type'.

Represents the declaration of a label.

void setLocStart(SourceLocation L)

LabelStmt * getStmt() const

void setStmt(LabelStmt *T)

bool isMSAsmLabel() const

LabelStmt - Represents a label, which has a substatement.

Represents the results of name lookup.

bool empty() const

Return true if no decls were found.

Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name.

Represents a prvalue temporary that is written into memory so that a reference can bind to it.

Expr * getSubExpr() const

Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.

MemberExpr - [C99 6.5.2.3] Structure and Union Members.

A pointer to member type per C++ 8.3.3 - Pointers to members.

This represents a decl that may have a name.

IdentifierInfo * getIdentifier() const

Get the identifier that names this declaration, if there is one.

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const

Determine if the declaration obeys the reserved identifier rules of the given language.

A C++ nested-name-specifier augmented with source location information.

NullStmt - This is the null statement ";": C99 6.8.3p3.

Represents Objective-C's collection statement.

An expression that sends a message to the given Objective-C object or class.

ObjCMethodDecl - Represents an instance or class method declaration.

bool hasRelatedResultType() const

Determine whether this method has a result type that is related to the message receiver's type.

QualType getReturnType() const

ObjCInterfaceDecl * getClassInterface()

Represents a pointer to an Objective C object.

Wrapper for void* pointer.

void * getAsOpaquePtr() const

OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....

@ CSK_Normal

Normal lookup.

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

static FindResult find(Expr *E)

Finds the overloaded expression in the given expression E of OverloadTy.

ParenExpr - This represents a parenthesized expression, e.g.

Represents a parameter to a function.

ParsedAttributes - A collection of parsed attributes.

Wrapper for source info for pointers.

SourceLocation getStarLoc() const

IdentifierTable & getIdentifierTable()

PseudoObjectExpr - An expression which accesses a pseudo-object l-value.

ArrayRef< Expr * > semantics()

A (possibly-)qualified type.

bool isVolatileQualified() const

Determine whether this type is volatile-qualified.

QualType withRestrict() const

QualType withConst() const

bool isTriviallyCopyConstructibleType(const ASTContext &Context) const

Return true if this is a trivially copyable type.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

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 isConstQualified() const

Determine whether this type is const-qualified.

@ OCL_Strong

Assigning into this object requires the old value to be released and the new value to be retained.

Represents a struct/union/class.

static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)

bool isOrContainsUnion() const

Returns whether this record is a union, or contains (at any nesting level) a union member.

virtual void completeDefinition()

Note that the definition of this type is now complete.

void setCapturedRecord()

Mark the record as a record for captured variables in CapturedStmt construct.

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

RecordDecl * getDecl() const

ReturnStmt - This represents a return, optionally of an expression: return; return 4;.

void setRetValue(Expr *E)

static ReturnStmt * Create(const ASTContext &Ctx, SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate)

Create a return statement.

static SEHExceptStmt * Create(const ASTContext &C, SourceLocation ExceptLoc, Expr *FilterExpr, Stmt *Block)

static SEHFinallyStmt * Create(const ASTContext &C, SourceLocation FinallyLoc, Stmt *Block)

Represents a __leave statement.

static SEHTryStmt * Create(const ASTContext &C, bool isCXXTry, SourceLocation TryLoc, Stmt *TryBlock, Stmt *Handler)

Scope - A scope is a transient data structure that is used while parsing the program.

const Scope * getFnParent() const

getFnParent - Return the closest scope that is a function body.

bool Contains(const Scope &rhs) const

Returns if rhs has a higher scope depth than this.

unsigned getFlags() const

getFlags - Return the flags for this scope.

Scope * getContinueParent()

getContinueParent - Return the closest scope that a continue statement would be affected by.

bool isSEHTryScope() const

Determine whether this scope is a SEH '__try' block.

Scope * getBreakParent()

getBreakParent - Return the closest scope that a break statement would be affected by.

const Scope * getParent() const

getParent - Return the scope that this is nested in.

void updateNRVOCandidate(VarDecl *VD)

@ SwitchScope

This is a scope that corresponds to a switch statement.

A generic diagnostic builder for errors which may or may not be deferred.

SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)

Emit a diagnostic.

PartialDiagnostic PDiag(unsigned DiagID=0)

Build a partial diagnostic.

SemaDiagnosticBuilder DiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)

Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...

StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc, Stmt *First, Expr *collection, SourceLocation RParenLoc)

StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body)

FinishObjCForCollectionStmt - Attach the body to a objective-C foreach statement.

bool inferObjCARCLifetime(ValueDecl *decl)

void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init)

Check if the current region is an OpenMP loop region and if it is, mark loop control variable,...

void setOpenMPCaptureKind(FieldDecl *FD, const ValueDecl *D, unsigned Level)

Sets OpenMP capture kind (OMPC_private, OMPC_firstprivate, OMPC_map etc.) for FD based on DSA for the...

std::pair< VarDecl *, Expr * > get() const

RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...

Sema - This implements semantic analysis and AST building for C.

ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)

Package the given type and TSI into a ParsedType.

SmallVector< Scope *, 2 > CurrentSEHFinally

Stack of active SEH __finally scopes. Can be empty.

LocalInstantiationScope * CurrentInstantiationScope

The current instantiation scope used to store local variables.

Scope * getCurScope() const

Retrieve the parser's current scope.

void DiagnoseDiscardedExprMarkedNodiscard(const Expr *E)

DiagnoseDiscardedExprMarkedNodiscard - Given an expression that is semantically a discarded-value exp...

void ProcessStmtAttributes(Stmt *Stmt, const ParsedAttributes &InAttrs, SmallVectorImpl< const Attr * > &OutAttrs)

Process the attributes before creating an attributed statement.

ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op, Expr *Input, bool IsAfterAmp=false)

Unary Operators. 'Tok' is the token for the operator.

StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc, bool IsIfExists, NestedNameSpecifierLoc QualifierLoc, DeclarationNameInfo NameInfo, Stmt *Nested)

ExprResult IgnoredValueConversions(Expr *E)

IgnoredValueConversions - Given that an expression's result is syntactically ignored,...

@ LookupMemberName

Member name lookup, which finds the names of class/struct/union members.

bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc, StringRef Keyword)

StmtResult BuildAttributedStmt(SourceLocation AttrsLoc, ArrayRef< const Attr * > Attrs, Stmt *SubStmt)

StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope)

StmtResult ActOnForEachLValueExpr(Expr *E)

In an Objective C collection iteration statement: for (x in y) x can be an arbitrary l-value expressi...

void ActOnForEachDeclStmt(DeclGroupPtrTy Decl)

void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)

ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)

CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...

@ Switch

An integral condition for a 'switch' statement.

SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes

Stack containing information about each of the nested function, block, and method scopes that are cur...

PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())

Pop a function (or block or lambda or captured region) scope from the stack.

bool checkAndRewriteMustTailAttr(Stmt *St, const Attr &MTA)

Check whether the given statement can have musttail applied to it, issuing a diagnostic and returning...

StmtResult ActOnGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc, LabelDecl *TheDecl)

StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, Scope *CurScope)

void setFunctionHasBranchIntoScope()

ExprResult ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val)

ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)

VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...

StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue=true)

FieldDecl * BuildCaptureField(RecordDecl *RD, const sema::Capture &Capture)

Build a FieldDecl suitable to hold the given capture.

StmtResult BuildIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)

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 UsualUnaryConversions(Expr *E)

UsualUnaryConversions - Performs various conversions that are common to most operators (C99 6....

void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc)

Look for instances where it is likely the comma operator is confused with another operator.

ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond)

bool DiagIfReachable(SourceLocation Loc, ArrayRef< const Stmt * > Stmts, const PartialDiagnostic &PD)

Conditionally issue a diagnostic based on the statements's reachability analysis.

void FinalizeDeclaration(Decl *D)

FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...

void ActOnCapturedRegionError()

DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)

ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)

ASTContext & getASTContext() const

ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)

void PopExpressionEvaluationContext()

StmtResult ActOnSEHTryBlock(bool IsCXXTry, SourceLocation TryLoc, Stmt *TryBlock, Stmt *Handler)

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.

ObjCMethodDecl * getCurMethodDecl()

getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...

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)

void setFunctionHasIndirectGoto()

ExprResult BuildCaptureInit(const sema::Capture &Capture, SourceLocation ImplicitCaptureLoc, bool IsOpenMPMapping=false)

Initialize the given capture with a suitable expression.

StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch, Stmt *Body)

NamedReturnInfo getNamedReturnInfo(Expr *&E, SimplerImplicitMoveMode Mode=SimplerImplicitMoveMode::Normal)

Determine whether the given expression might be move-eligible or copy-elidable in either a (co_)retur...

std::unique_ptr< sema::FunctionScopeInfo, PoppedFunctionScopeDeleter > PoppedFunctionScopePtr

void DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID)

DiagnoseUnusedExprResult - If the statement passed in is an expression whose result is unused,...

FPOptions & getCurFPFeatures()

@ UPPC_Expression

An arbitrary expression.

const LangOptions & getLangOpts() const

StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc, ConditionResult Cond, SourceLocation RParenLoc, Stmt *Body)

bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)

If the given type contains an unexpanded parameter pack, diagnose the error.

const LangOptions & LangOpts

sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)

Retrieve the current lambda scope info, if any.

void ActOnStartOfCompoundStmt(bool IsStmtExpr)

bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD, SourceLocation ReturnLoc, Expr *RetExpr, const AutoType *AT)

Deduce the return type for a function from a returned expression, per C++1y [dcl.spec....

void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)

Perform marking for a reference to an arbitrary declaration.

TypeLoc getReturnTypeLoc(FunctionDecl *FD) const

StmtResult ActOnExprStmtError()

const VarDecl * getCopyElisionCandidate(NamedReturnInfo &Info, QualType ReturnType)

Updates given NamedReturnInfo's move-eligible and copy-elidable statuses, considering the function re...

NamedDecl * getCurFunctionOrMethodDecl() const

getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...

StmtResult ActOnNullStmt(SourceLocation SemiLoc, bool HasLeadingEmptyMacro=false)

RecordDecl * CreateCapturedStmtRecordDecl(CapturedDecl *&CD, SourceLocation Loc, unsigned NumParams)

void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope, CapturedRegionKind Kind, unsigned NumParams)

sema::FunctionScopeInfo * getCurFunction() const

void PushCompoundScope(bool IsStmtExpr)

DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group)

BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...

AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)

Check assignment constraints for an assignment of RHS to LHSType.

void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType, Expr *SrcExpr)

DiagnoseAssignmentEnum - Warn if assignment to enum is a constant integer not in the range of enum va...

ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E)

std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const

Determines whether we are currently in a context where template argument substitution failures are no...

bool findMacroSpelling(SourceLocation &loc, StringRef name)

Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...

void DiagnoseEmptyStmtBody(SourceLocation StmtLoc, const Stmt *Body, unsigned DiagID)

Emit DiagID if statement located on StmtLoc has a suspicious null statement as a Body,...

void DiagnoseEmptyLoopBody(const Stmt *S, const Stmt *PossibleBody)

Warn if a for/while loop statement S, which is followed by PossibleBody, has a suspicious null statem...

ExprResult DefaultLvalueConversion(Expr *E)

DeclContext * CurContext

CurContext - This is the current declaration context of parsing.

DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)

Retrieves the declaration name from a parsed unqualified-id.

bool isUnevaluatedContext() const

Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.

StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, NamedReturnInfo &NRInfo, bool SupressSimplerImplicitMoves)

ActOnCapScopeReturnStmt - Utility routine to type-check return statements for capturing scopes.

AssignConvertType

AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...

StmtResult ActOnCapturedRegionEnd(Stmt *S)

StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)

StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc, Expr *DestExp)

ExprResult CheckPlaceholderExpr(Expr *E)

Check for operands with placeholder types and complain if found.

bool inTemplateInstantiation() const

Determine whether we are currently performing template instantiation.

SourceManager & getSourceManager() const

ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity, const NamedReturnInfo &NRInfo, Expr *Value, bool SupressSimplerImplicitMoves=false)

Perform the initialization of a potentially-movable value, which is the result of return value.

void ActOnInitializerError(Decl *Dcl)

ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...

StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt, Stmt *LoopVar, SourceLocation ColonLoc, Expr *Collection, SourceLocation RParenLoc, BuildForRangeKind Kind, ArrayRef< MaterializeTemporaryExpr * > LifetimeExtendTemps={})

ActOnCXXForRangeStmt - Check and build a C++11 for-range statement.

StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, bool AllowRecovery=false)

ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr)

Binary Operators. 'Tok' is the token for the operator.

void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K, unsigned OpenMPCaptureLevel=0)

void setFunctionHasMustTail()

void setFunctionHasBranchProtectedScope()

StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block)

StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope)

@ CCEK_CaseValue

Expression in a case label.

StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt, SourceLocation ColonLoc, Stmt *RangeDecl, Stmt *Begin, Stmt *End, Expr *Cond, Expr *Inc, Stmt *LoopVarDecl, SourceLocation RParenLoc, BuildForRangeKind Kind, ArrayRef< MaterializeTemporaryExpr * > LifetimeExtendTemps={})

BuildCXXForRangeStmt - Build or instantiate a C++11 for-range statement.

StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body, SourceLocation WhileLoc, SourceLocation CondLParen, Expr *Cond, SourceLocation CondRParen)

StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc)

StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc, bool IsIfExists, CXXScopeSpec &SS, UnqualifiedId &Name, Stmt *Nested)

@ PotentiallyEvaluated

The current expression is potentially evaluated at run time, which means that code may be generated t...

@ ImmediateFunctionContext

In addition of being constant evaluated, the current expression occurs in an immediate function conte...

StmtResult ActOnSEHExceptBlock(SourceLocation Loc, Expr *FilterExpr, Stmt *Block)

void ActOnAfterCompoundStatementLeadingPragmas()

StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)

bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)

Ensure that the type T is a complete type.

void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)

bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)

Perform qualified name lookup into a given context.

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.

StmtResult ActOnAttributedStmt(const ParsedAttributes &AttrList, Stmt *SubStmt)

SourceManager & SourceMgr

DiagnosticsEngine & Diags

StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope)

void ActOnStartSEHFinallyBlock()

ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)

void ActOnAbortSEHFinallyBlock()

QualType SubstAutoTypeDependent(QualType TypeWithAuto)

@ BFRK_Check

Determining whether a for-range statement could be built.

@ BFRK_Build

Initial building of a for-range statement.

@ BFRK_Rebuild

Instantiation or recovery rebuild of a for-range statement.

StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc, Decl *ExDecl, Stmt *HandlerBlock)

ActOnCXXCatchBlock - Takes an exception declaration and a handler block and creates a proper catch ha...

void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt)

ActOnCaseStmtBody - This installs a statement as the body of a case.

void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)

AddInitializerToDecl - Adds the initializer Init to the declaration dcl.

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

SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD=nullptr)

ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())

Attempts to produce a RecoveryExpr after some AST node cannot be created.

StmtResult ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)

std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)

Produces a formatted string that describes the binding of template parameters to template arguments.

ExprResult ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, bool IsType, void *TyOrEx, SourceRange ArgRange)

ActOnUnaryExprOrTypeTraitExpr - Handle sizeof(type) and sizeof expr and the same for alignof and __al...

ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc, SourceLocation RangeLoc, const DeclarationNameInfo &NameInfo, LookupResult &MemberLookup, OverloadCandidateSet *CandidateSet, Expr *Range, ExprResult *CallExpr)

Build a call to 'begin' or 'end' for a C++11 for-range statement.

sema::CompoundScopeInfo & getCurCompoundScope() const

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)

void ActOnFinishOfCompoundStmt()

StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, ArrayRef< Stmt * > Elts, bool isStmtExpr)

bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, bool AllowMask) const

IsValueInFlagEnum - Determine if a value is allowed as part of a flag enum.

StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl, SourceLocation ColonLoc, Stmt *SubStmt)

StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock, ArrayRef< Stmt * > Handlers)

ActOnCXXTryBlock - Takes a try compound-statement and a number of handlers and creates a try statemen...

StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc, Stmt *SubStmt, Scope *CurScope)

StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS, SourceLocation DotDotDotLoc, ExprResult RHS, SourceLocation ColonLoc)

StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body)

FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.

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

ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

SourceLocation getLocWithOffset(IntTy Offset) const

Return a source location with the specified offset from this SourceLocation.

bool isMacroBodyExpansion(SourceLocation Loc) const

Tests whether the given source location represents the expansion of a macro body.

bool isInSystemMacro(SourceLocation loc) const

Returns whether Loc is expanded from a macro in a system header.

bool isInSystemHeader(SourceLocation Loc) const

Returns if a SourceLocation is in a system header.

A trivial tuple used to represent a source range.

SourceLocation getBegin() const

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

static std::tuple< bool, const Attr *, const Attr * > determineLikelihoodConflict(const Stmt *Then, const Stmt *Else)

static const Attr * getLikelihoodAttr(const Stmt *S)

SourceLocation getBeginLoc() const LLVM_READONLY

const SwitchCase * getNextSwitchCase() const

SwitchStmt - This represents a 'switch' stmt.

static SwitchStmt * Create(const ASTContext &Ctx, Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LParenLoc, SourceLocation RParenLoc)

Create a switch statement.

SwitchCase * getSwitchCaseList()

void setAllEnumCasesCovered()

Set a flag in the SwitchStmt indicating that if the 'switch (X)' is a switch over an enum value then ...

Represents the declaration of a struct/union/class/enum.

bool isCompleteDefinition() const

Return true if this decl has its body fully specified.

TypedefNameDecl * getTypedefNameForAnonDecl() const

void startDefinition()

Starts the definition of this tag declaration.

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

bool isSEHTrySupported() const

Whether the target supports SEH __try.

TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...

void NoteCandidates(Sema &S, SourceLocation Loc)

NoteCandidates - When no template specialization match is found, prints diagnostic messages containin...

Base wrapper for a particular "section" of type source info.

QualType getType() const

Get the type for which this source info wrapper provides information.

T castAs() const

Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.

T getAsAdjusted() const

Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...

A container of type source information.

TypeLoc getTypeLoc() const

Return the TypeLoc wrapper for the type source info.

QualType getType() const

Return the type wrapped by this type source info.

The base class of the type hierarchy.

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

bool isSignedIntegerOrEnumerationType() const

Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...

bool isRValueReferenceType() 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

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

AutoType * getContainedAutoType() const

Get the AutoType whose type will be deduced for a variable with an initializer of this type.

bool isSpecificBuiltinType(unsigned K) const

Test for a particular builtin type.

bool isDependentType() const

Whether this type is a dependent type, meaning that its definition somehow depends on a template para...

bool containsErrors() const

Whether this type is an error type.

const ArrayType * getAsArrayTypeUnsafe() const

A variant of getAs<> for array types which silently discards qualifiers from the outermost type.

bool isUndeducedType() const

Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...

bool isObjectType() const

Determine whether this type is an object type.

bool isIncompleteType(NamedDecl **Def=nullptr) const

Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...

TypeClass getTypeClass() const

bool isCanonicalUnqualified() const

Determines if this type would be canonical if it had no further qualification.

const T * getAs() const

Member-template getAs<specific type>'.

bool isRecordType() const

UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...

Represents a C++ unqualified-id that has been parsed.

void setType(QualType newType)

Represents a variable declaration or definition.

static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

bool hasGlobalStorage() const

Returns true for all variables that do not have local storage.

bool isExceptionVariable() const

Determine whether this variable is the exception variable in a C++ catch statememt or an Objective-C ...

const Expr * getInit() const

bool hasLocalStorage() const

Returns true if a variable with function scope is a non-static local variable.

bool isLocalVarDecl() const

Returns true for local variable declarations other than parameters.

bool hasDependentAlignment() const

Determines if this variable's alignment is dependent.

Represents a C array with a specified size that is not an integer-constant-expression.

WhileStmt - This represents a 'while' stmt.

static WhileStmt * Create(const ASTContext &Ctx, VarDecl *Var, Expr *Cond, Stmt *Body, SourceLocation WL, SourceLocation LParenLoc, SourceLocation RParenLoc)

Create a while statement.

ValueDecl * getVariable() const

bool isVariableCapture() const

SourceLocation getLocation() const

Retrieve the location at which this variable was captured.

bool isVLATypeCapture() const

bool isThisCapture() const

bool isReferenceCapture() const

Retains information about a captured region.

unsigned short OpenMPLevel

unsigned short CapRegionKind

The kind of captured region.

RecordDecl * TheRecordDecl

The captured record type.

CapturedDecl * TheCapturedDecl

The CapturedDecl for this statement.

QualType ReturnType

ReturnType - The target type of return statements in this context, or null if unknown.

SmallVector< Capture, 4 > Captures

Captures - The captures.

bool HasImplicitReturnType

Contains information about the compound statement currently being parsed.

FPOptions InitialFPFeatures

FP options at the beginning of the compound statement, prior to any pragma.

void setHasEmptyLoopBodies()

Retains information about a function, method, or block that is currently being parsed.

llvm::PointerIntPair< SwitchStmt *, 1, bool > SwitchInfo

A SwitchStmt, along with a flag indicating if its list of case statements is incomplete (because we d...

SourceLocation FirstCXXOrObjCTryLoc

First C++ 'try' or ObjC @try statement in the current function.

SourceLocation FirstCoroutineStmtLoc

First coroutine statement in the current function.

StringRef getFirstCoroutineStmtKeyword() const

SourceLocation FirstReturnLoc

First 'return' statement in the current function.

enum clang::sema::FunctionScopeInfo::@245 FirstTryType

SourceLocation FirstSEHTryLoc

First SEH '__try' statement in the current function.

void setHasCXXTry(SourceLocation TryLoc)

SmallVector< CompoundScopeInfo, 4 > CompoundScopes

The stack of currently active compound statement scopes in the function.

void setHasSEHTry(SourceLocation TryLoc)

SmallVector< SwitchInfo, 8 > SwitchStack

SwitchStack - This is the current set of active switch statements in the block.

CXXMethodDecl * CallOperator

The lambda's compiler-generated operator().

Provides information about an attempted template argument deduction, whose success or failure was des...

TemplateArgument SecondArg

The second template argument to which the template argument deduction failure refers.

TemplateArgument FirstArg

The first template argument to which the template argument deduction failure refers.

Defines the clang::TargetInfo interface.

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

const internal::VariadicAllOfMatcher< Decl > decl

Matches declarations.

bool This(InterpState &S, CodePtr OpPC)

bool Cast(InterpState &S, CodePtr OpPC)

void checkExprLifetimeMustTailArg(Sema &SemaRef, const InitializedEntity &Entity, Expr *Init)

Check that the lifetime of the given expr (and its subobjects) is sufficient, assuming that it is pas...

The JSON file list parser is used to communicate input to InstallAPI.

Expr * IgnoreElidableImplicitConstructorSingleStep(Expr *E)

@ OR_Deleted

Succeeded, but refers to a deleted function.

@ OR_Success

Overload resolution succeeded.

bool isReservedInAllContexts(ReservedIdentifierStatus Status)

Determine whether an identifier is reserved in all contexts.

IfStatementKind

In an if statement, this denotes whether the statement is a constexpr or consteval if statement.

Expr * IgnoreExprNodes(Expr *E, FnTys &&... Fns)

Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, Recursively apply each of the f...

@ RQ_None

No ref-qualifier was provided.

@ OCD_AllCandidates

Requests that all candidates be shown.

@ Seq

'seq' clause, allowed on 'loop' and 'routine' directives.

bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)

CapturedRegionKind

The different kinds of captured statement.

@ Result

The result type of a method or function.

bool hasArmZT0State(const FunctionDecl *FD)

Returns whether the given FunctionDecl has Arm ZT0 state.

ActionResult< Expr * > ExprResult

@ Struct

The "struct" keyword.

bool isLambdaConversionOperator(CXXConversionDecl *C)

ActionResult< Stmt * > StmtResult

@ VK_XValue

An x-value expression is a reference to an object with independent storage but which can be "moved",...

@ VK_LValue

An l-value expression is a reference to an object with independent storage.

Expr * IgnoreParensSingleStep(Expr *E)

const FunctionProtoType * T

Expr * IgnoreImplicitAsWrittenSingleStep(Expr *E)

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.

@ Inconsistent

Template argument deduction produced inconsistent deduced values for the given template parameter.

@ AlreadyDiagnosed

Some error which was already diagnosed.

bool IsArmStreamingFunction(const FunctionDecl *FD, bool IncludeLocallyStreaming)

Returns whether the given FunctionDecl has an __arm[_locally]_streaming attribute.

@ CapturedContext

Parameter for captured context.

bool hasArmZAState(const FunctionDecl *FD)

Returns whether the given FunctionDecl has Arm ZA state.

Diagnostic wrappers for TextAPI types for error reporting.

DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...

EvalResult is a struct with detailed info about an evaluated expression.

@ MoveEligibleAndCopyElidable

bool isMoveEligible() const

bool isCopyElidable() const

const VarDecl * Candidate

static CatchHandlerType getEmptyKey()

static CatchHandlerType getTombstoneKey()

static unsigned getHashValue(const CatchHandlerType &Base)

static bool isEqual(const CatchHandlerType &LHS, const CatchHandlerType &RHS)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4