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

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

clang: lib/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.cpp Source File

<

... NameTypes>

(

...(NameTypes) > 0) {

(

*NextNS = dyn_cast_or_null<NamespaceDecl>(NS.

()))

(RD.

() ==

) {

(

*N = dyn_cast_or_null<NamespaceDecl>(RD.

()))

N->isStdNamespace() ||

(RD.

() ==

) {

*N = dyn_cast_or_null<NamespaceDecl>(RD.

());

(RD.

() ==

) {

*N = dyn_cast_or_null<NamespaceDecl>(RD.

());

N !=

&&

LatticeTransferState = TransferState<UncheckedOptionalAccessLattice>;

(CXXRecordDecl, optionalOrDerivedClass) {

desugarsToOptionalType() {

hasUnqualifiedDesugaredType(

desugarsToOptionalOrDerivedType() {

hasUnqualifiedDesugaredType(

hasOptionalType() {

hasType(desugarsToOptionalType()); }

hasOptionalOrDerivedType() {

hasType(desugarsToOptionalOrDerivedType());

QualType getPublicType(

Expr *

) {

*

= dyn_cast<ImplicitCastExpr>(

->IgnoreParens());

(Cast ==

||

->getCastKind() != CK_UncheckedDerivedToBase) {

QualType Ty =

->getType();

(Ty->isPointerType())

Ty->getPointeeType();

CastingFromThis = isa<CXXThisExpr>(

->getSubExpr());

CXXBaseSpecifier *PublicBase =

;

(

CXXBaseSpecifier *

:

->path()) {

(

->getAccessSpecifier() !=

&& !CastingFromThis)

CastingFromThis =

;

(PublicBase !=

)

PublicBase->getType();

getPublicType(

->getSubExpr());

QualType getPublicReceiverType(

CXXMemberCallExpr &MCE) {

getPublicType(MCE.getImplicitObjectArgument());

ast_matchers::internal::Matcher<QualType>, InnerMatcher) {

InnerMatcher.matches(getPublicReceiverType(

), Finder, Builder);

isOptionalMemberCallWithNameMatcher(

ast_matchers::internal::Matcher<NamedDecl> matcher,

std::optional<StatementMatcher> &Ignorable = std::nullopt) {

publicReceiverType(desugarsToOptionalType()),

isOptionalOperatorCallWithName(

llvm::StringRef operator_name,

std::optional<StatementMatcher> &Ignorable = std::nullopt) {

isMakeOptionalCall() {

,

,

,

,

))),

nulloptTypeDecl() {

,

,

hasNulloptType() {

hasType(nulloptTypeDecl()); }

,

,

));

isOptionalNulloptConstructor() {

hasParameter(0, hasNulloptType()))),

hasOptionalOrDerivedType());

isOptionalInPlaceConstructor() {

hasOptionalOrDerivedType());

isOptionalValueOrConversionConstructor() {

argumentCountIs(1), hasArgument(0,

(hasNulloptType())),

hasOptionalOrDerivedType());

isOptionalValueOrConversionAssignment() {

(isCopyAssignmentOperator(), isMoveAssignmentOperator())))),

argumentCountIs(2), hasArgument(1,

(hasNulloptType())));

isOptionalNulloptAssignment() {

argumentCountIs(2), hasArgument(1, hasNulloptType()));

isStdSwapCall() {

hasArgument(0, hasOptionalOrDerivedType()),

hasArgument(1, hasOptionalOrDerivedType()));

isStdForwardCall() {

hasArgument(0, hasOptionalOrDerivedType()));

llvm::StringLiteral ValueOrCallID =

;

isValueOrStringEmptyCall() {

onImplicitObjectArgument(ignoringImplicit(

ofClass(optionalClass()))),

.bind(ValueOrCallID))));

isValueOrNotEqX() {

ComparesToSame = [](ast_matchers::internal::Matcher<Stmt> Arg) {

ofClass(optionalClass()))),

.bind(ValueOrCallID)),

ignoringImplicit(Arg));

isZeroParamConstMemberCall() {

isZeroParamConstMemberOperatorCall() {

isNonConstMemberCall() {

isNonConstMemberOperatorCall() {

isCallReturningOptional() {

(desugarsToOptionalOrDerivedType(),

(pointee(desugarsToOptionalOrDerivedType()))))));

<

L,

R>

isComparisonOperatorCall(L lhs_arg_matcher, R rhs_arg_matcher) {

argumentCountIs(2), hasArgument(0, lhs_arg_matcher),

hasArgument(1, rhs_arg_matcher));

Formula &forceBoolValue(Environment &

,

Expr &Expr) {

(

!=

)

->formula();

->formula();

StorageLocation &locForHasValue(

RecordStorageLocation &OptionalLoc) {

OptionalLoc.getSyntheticField(

);

StorageLocation &locForValue(

RecordStorageLocation &OptionalLoc) {

OptionalLoc.getSyntheticField(

);

setHasValue(RecordStorageLocation &OptionalLoc, BoolValue &HasValueVal,

Environment &

) {

.

(locForHasValue(OptionalLoc), HasValueVal);

BoolValue *getHasValue(Environment &

, RecordStorageLocation *OptionalLoc) {

(OptionalLoc ==

)

StorageLocation &HasValueLoc = locForHasValue(*OptionalLoc);

*HasValueVal =

.

<BoolValue>(HasValueLoc);

(HasValueVal ==

) {

QualType valueTypeFromOptionalDecl(

CXXRecordDecl &RD) {

&CTSD = cast<ClassTemplateSpecializationDecl>(RD);

CTSD.getTemplateArgs()[0].getAsType();

countOptionalWrappers(

ASTContext &ASTCtx, QualType Type) {

1 + countOptionalWrappers(

valueTypeFromOptionalDecl(*Optional).getDesugaredType(ASTCtx));

StorageLocation *getLocBehindPossiblePointer(

Expr &

,

Environment &

) {

(

.isPRValue()) {

(

*PointerVal = dyn_cast_or_null<PointerValue>(

.

(

)))

&PointerVal->getPointeeLoc();

transferUnwrapCall(

Expr *UnwrapExpr,

Expr *ObjectExpr,

LatticeTransferState &State) {

(

*OptionalLoc = cast_or_null<RecordStorageLocation>(

getLocBehindPossiblePointer(*ObjectExpr, State.Env))) {

(State.Env.getStorageLocation(*UnwrapExpr) ==

)

State.Env.setStorageLocation(*UnwrapExpr, locForValue(*OptionalLoc));

transferArrowOpCall(

Expr *UnwrapExpr,

Expr *ObjectExpr,

LatticeTransferState &State) {

(

*OptionalLoc = cast_or_null<RecordStorageLocation>(

getLocBehindPossiblePointer(*ObjectExpr, State.Env)))

*UnwrapExpr, State.Env.create<PointerValue>(locForValue(*OptionalLoc)));

transferMakeOptionalCall(

CallExpr *

,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

setHasValue(State.Env.getResultObjectLocation(*

),

State.Env.getBoolLiteralValue(

), State.Env);

transferOptionalHasValueCall(

CXXMemberCallExpr *CallExpr,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

(

*HasValueVal = getHasValue(

State.Env.setValue(*CallExpr, *HasValueVal);

transferOptionalIsNullCall(

CXXMemberCallExpr *CallExpr,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

(

*HasValueVal = getHasValue(

State.Env.setValue(*CallExpr, State.Env.makeNot(*HasValueVal));

transferValueOrImpl(

LatticeTransferState &State,

Formula &(*ModelPred)(Environment &

,

Formula &ExprVal,

Formula &HasValueVal)) {

&

= State.Env;

(HasValueVal ==

)

.

(ModelPred(

, forceBoolValue(

, *ValueOrPredExpr),

HasValueVal->formula()));

transferValueOrStringEmptyCall(

*ComparisonExpr,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

transferValueOrImpl(ComparisonExpr,

, State,

[](Environment &

,

Formula &ExprVal,

Formula &HasValueVal) ->

Formula & {

transferValueOrNotEqX(

Expr *ComparisonExpr,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

transferValueOrImpl(ComparisonExpr,

, State,

[](Environment &

,

Formula &ExprVal,

Formula &HasValueVal) ->

Formula & {

transferCallReturningOptional(

CallExpr *

,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

RecordStorageLocation *

=

;

(

->isPRValue()) {

= &State.Env.getResultObjectLocation(*

);

= State.Env.get<RecordStorageLocation>(*E);

(

==

) {

= &cast<RecordStorageLocation>(State.Env.createStorageLocation(*

));

State.Env.setStorageLocation(*

, *

);

(State.Env.getValue(locForHasValue(*

)) !=

)

setHasValue(*

, State.Env.makeAtomicBoolValue(), State.Env);

handleConstMemberCall(

CallExpr *CE,

dataflow::RecordStorageLocation *

,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

FunctionDecl *DirectCallee = CE->getDirectCallee();

(DirectCallee ==

)

StorageLocation &

=

State.Lattice.getOrCreateConstMethodReturnStorageLocation(

*

, DirectCallee, State.Env, [&](StorageLocation &

) {

setHasValue(cast<RecordStorageLocation>(Loc),

State.Env.makeAtomicBoolValue(), State.Env);

(CE->isGLValue()) {

State.Env.setStorageLocation(*CE,

);

&ResultLoc = State.Env.getResultObjectLocation(*CE);

(cast<RecordStorageLocation>(

), ResultLoc, State.Env);

(CE->getType()->isBooleanType() || CE->getType()->isPointerType())) {

*Val = State.Lattice.getOrCreateConstMethodReturnValue(*

, CE,

State.Env.setValue(*CE, *Val);

transferCallReturningOptional(CE,

, State);

transferValue_ConstMemberCall(

CXXMemberCallExpr *MCE,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

handleConstMemberCall(

transferValue_ConstMemberOperatorCall(

CXXOperatorCallExpr *OCE,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

*

= cast_or_null<dataflow::RecordStorageLocation>(

State.Env.getStorageLocation(*OCE->getArg(0)));

handleNonConstMemberCall(

CallExpr *CE,

dataflow::RecordStorageLocation *

,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

(

&[Field, FieldLoc] :

->children()) {

QualType FieldType =

->getType();

(!FieldType.isConstQualified() &&

*FieldRecordLoc = cast_or_null<RecordStorageLocation>(FieldLoc);

(FieldRecordLoc) {

setHasValue(*FieldRecordLoc, State.Env.makeAtomicBoolValue(),

State.Lattice.clearConstMethodReturnValues(*

);

State.Lattice.clearConstMethodReturnStorageLocations(*

);

transferCallReturningOptional(CE,

, State);

transferValue_NonConstMemberCall(

CXXMemberCallExpr *MCE,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

handleNonConstMemberCall(

transferValue_NonConstMemberOperatorCall(

CXXOperatorCallExpr *OCE,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

*

= cast_or_null<dataflow::RecordStorageLocation>(

State.Env.getStorageLocation(*OCE->getArg(0)));

constructOptionalValue(

Expr &

, Environment &

,

BoolValue &HasValueVal) {

setHasValue(

, HasValueVal,

);

BoolValue &valueOrConversionHasValue(QualType DestType,

Expr &

,

MatchFinder::MatchResult &MatchRes,

LatticeTransferState &State) {

DestTypeOptionalWrappersCount =

countOptionalWrappers(*MatchRes.Context, DestType);

ArgTypeOptionalWrappersCount = countOptionalWrappers(

*MatchRes.Context,

.getType().getNonReferenceType());

(DestTypeOptionalWrappersCount != ArgTypeOptionalWrappersCount)

State.Env.getBoolLiteralValue(

);

*

= State.Env.get<RecordStorageLocation>(

);

(

*HasValueVal = getHasValue(State.Env,

))

State.Env.makeAtomicBoolValue();

transferValueOrConversionConstructor(

CXXConstructExpr *

,

MatchFinder::MatchResult &MatchRes,

LatticeTransferState &State) {

assert(

->getNumArgs() > 0);

constructOptionalValue(

valueOrConversionHasValue(

->getConstructor()->getThisType()->getPointeeType(), *

->getArg(0),

transferAssignment(

CXXOperatorCallExpr *

, BoolValue &HasValueVal,

LatticeTransferState &State) {

assert(

->getNumArgs() > 0);

(

*

= State.Env.get<RecordStorageLocation>(*

->getArg(0))) {

setHasValue(*

, HasValueVal, State.Env);

State.Env.setStorageLocation(*

, *

);

transferValueOrConversionAssignment(

CXXOperatorCallExpr *

,

MatchFinder::MatchResult &MatchRes,

LatticeTransferState &State) {

assert(

->getNumArgs() > 1);

valueOrConversionHasValue(

->getArg(0)->getType().getNonReferenceType(),

*

->getArg(1), MatchRes, State),

transferNulloptAssignment(

CXXOperatorCallExpr *

,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

transferAssignment(

, State.Env.getBoolLiteralValue(

), State);

transferSwap(RecordStorageLocation *Loc1, RecordStorageLocation *Loc2,

Environment &

) {

(Loc1 ==

) {

(Loc2 !=

)

(Loc2 ==

) {

BoolValue *BoolVal1 = getHasValue(

, Loc1);

(BoolVal1 ==

)

BoolValue *BoolVal2 = getHasValue(

, Loc2);

(BoolVal2 ==

)

setHasValue(*Loc1, *BoolVal2,

);

setHasValue(*Loc2, *BoolVal1,

);

transferSwapCall(

CXXMemberCallExpr *

,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

assert(

->getNumArgs() == 1);

*OtherLoc = State.Env.get<RecordStorageLocation>(*

->getArg(0));

transferStdSwapCall(

CallExpr *

,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

assert(

->getNumArgs() == 2);

*Arg0Loc = State.Env.get<RecordStorageLocation>(*

->getArg(0));

*Arg1Loc = State.Env.get<RecordStorageLocation>(*

->getArg(1));

transferSwap(Arg0Loc, Arg1Loc, State.Env);

transferStdForwardCall(

CallExpr *

,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

assert(

->getNumArgs() == 1);

(

*

= State.Env.getStorageLocation(*

->getArg(0)))

State.Env.setStorageLocation(*

, *

);

Formula &evaluateEquality(Arena &A,

Formula &EqVal,

Formula &LHS,

Formula &RHS) {

A.makeImplies(EqVal, A.makeOr(A.makeAnd(LHS, RHS),

A.makeAnd(A.makeNot(LHS), A.makeNot(RHS)))),

A.makeImplies(A.makeNot(EqVal), A.makeOr(LHS, RHS)));

MatchFinder::MatchResult &,

LatticeTransferState &State) {

Environment &

= State.Env;

*CmpValue = &forceBoolValue(

, *CmpExpr);

*Arg0Loc =

.

<RecordStorageLocation>(*CmpExpr->

(0));

(

*LHasVal = getHasValue(

, Arg0Loc)) {

*Arg1Loc =

.

<RecordStorageLocation>(*CmpExpr->

(1));

(

*RHasVal = getHasValue(

, Arg1Loc)) {

(CmpExpr->

() == clang::OO_ExclaimEqual)

CmpValue = &A.makeNot(*CmpValue);

.

(evaluateEquality(A, *CmpValue, LHasVal->formula(),

RHasVal->formula()));

*CmpValue = &forceBoolValue(

, *CmpExpr);

*

=

.

<RecordStorageLocation>(*E);

(

*HasVal = getHasValue(

,

)) {

(CmpExpr->

() == clang::OO_ExclaimEqual)

CmpValue = &A.makeNot(*CmpValue);

evaluateEquality(A, *CmpValue, HasVal->formula(), A.makeLiteral(

)));

*CmpValue = &forceBoolValue(

, *CmpExpr);

*

=

.

<RecordStorageLocation>(*E);

(

*HasVal = getHasValue(

,

)) {

(CmpExpr->

() == clang::OO_ExclaimEqual)

CmpValue = &A.makeNot(*CmpValue);

.

(evaluateEquality(A, *CmpValue, HasVal->formula(),

A.makeLiteral(

)));

std::optional<StatementMatcher>

ignorableOptional(

UncheckedOptionalAccessModelOptions &Options) {

(Options.IgnoreSmartPointerDereference) {

(hasArgument(0,

(hasOptionalType()))))));

valueCall(

std::optional<StatementMatcher> &IgnorableOptional) {

isOptionalMemberCallWithNameMatcher(

(

),

valueOperatorCall(

std::optional<StatementMatcher> &IgnorableOptional) {

(

(isOptionalOperatorCallWithName(

, IgnorableOptional),

isOptionalOperatorCallWithName(

, IgnorableOptional)));

buildTransferMatchSwitch() {

CFGMatchSwitchBuilder<LatticeTransferState>()

.CaseOfCFGStmt<CallExpr>(isMakeOptionalCall(), transferMakeOptionalCall)

.CaseOfCFGStmt<CXXConstructExpr>(

isOptionalInPlaceConstructor(),

[](

CXXConstructExpr *

,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

constructOptionalValue(*

, State.Env,

State.Env.getBoolLiteralValue(

));

.CaseOfCFGStmt<CXXConstructExpr>(

isOptionalNulloptConstructor(),

[](

CXXConstructExpr *

,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

constructOptionalValue(*

, State.Env,

State.Env.getBoolLiteralValue(

));

.CaseOfCFGStmt<CXXConstructExpr>(isOptionalValueOrConversionConstructor(),

transferValueOrConversionConstructor)

.CaseOfCFGStmt<CXXOperatorCallExpr>(

isOptionalValueOrConversionAssignment(),

transferValueOrConversionAssignment)

.CaseOfCFGStmt<CXXOperatorCallExpr>(isOptionalNulloptAssignment(),

transferNulloptAssignment)

.CaseOfCFGStmt<CXXMemberCallExpr>(

valueCall(std::nullopt),

[](

CXXMemberCallExpr *

,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

transferUnwrapCall(

,

->getImplicitObjectArgument(), State);

.CaseOfCFGStmt<CallExpr>(isOptionalOperatorCallWithName(

),

[](

CallExpr *

,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

transferUnwrapCall(

,

->getArg(0), State);

.CaseOfCFGStmt<CallExpr>(isOptionalOperatorCallWithName(

),

[](

CallExpr *

,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

transferArrowOpCall(

,

->getArg(0), State);

.CaseOfCFGStmt<CXXMemberCallExpr>(

isOptionalMemberCallWithNameMatcher(

transferOptionalHasValueCall)

.CaseOfCFGStmt<CXXMemberCallExpr>(

isOptionalMemberCallWithNameMatcher(

(

)),

transferOptionalHasValueCall)

.CaseOfCFGStmt<CXXMemberCallExpr>(

isOptionalMemberCallWithNameMatcher(

(

)),

transferOptionalIsNullCall)

.CaseOfCFGStmt<CXXMemberCallExpr>(

isOptionalMemberCallWithNameMatcher(

(

)),

[](

CXXMemberCallExpr *

,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

(RecordStorageLocation *

=

setHasValue(*

, State.Env.getBoolLiteralValue(

), State.Env);

.CaseOfCFGStmt<CXXMemberCallExpr>(

isOptionalMemberCallWithNameMatcher(

(

)),

[](

CXXMemberCallExpr *

,

MatchFinder::MatchResult &,

LatticeTransferState &State) {

(RecordStorageLocation *

=

setHasValue(*

, State.Env.getBoolLiteralValue(

),

.CaseOfCFGStmt<CXXMemberCallExpr>(

isOptionalMemberCallWithNameMatcher(

(

)),

.CaseOfCFGStmt<CallExpr>(isStdSwapCall(), transferStdSwapCall)

.CaseOfCFGStmt<CallExpr>(isStdForwardCall(), transferStdForwardCall)

.CaseOfCFGStmt<Expr>(isValueOrStringEmptyCall(),

transferValueOrStringEmptyCall)

.CaseOfCFGStmt<Expr>(isValueOrNotEqX(), transferValueOrNotEqX)

.CaseOfCFGStmt<CXXOperatorCallExpr>(

isComparisonOperatorCall(hasOptionalType(), hasOptionalType()),

transferOptionalAndOptionalCmp)

.CaseOfCFGStmt<CXXOperatorCallExpr>(

isComparisonOperatorCall(hasOptionalType(), hasNulloptType()),

MatchFinder::MatchResult &, LatticeTransferState &State) {

transferOptionalAndNulloptCmp(Cmp, Cmp->getArg(0), State.Env);

.CaseOfCFGStmt<CXXOperatorCallExpr>(

isComparisonOperatorCall(hasNulloptType(), hasOptionalType()),

MatchFinder::MatchResult &, LatticeTransferState &State) {

transferOptionalAndNulloptCmp(Cmp, Cmp->getArg(1), State.Env);

.CaseOfCFGStmt<CXXOperatorCallExpr>(

isComparisonOperatorCall(

(

(hasOptionalType(), hasNulloptType()))),

MatchFinder::MatchResult &, LatticeTransferState &State) {

transferOptionalAndValueCmp(Cmp, Cmp->getArg(0), State.Env);

.CaseOfCFGStmt<CXXOperatorCallExpr>(

isComparisonOperatorCall(

(

(hasOptionalType(), hasNulloptType())),

MatchFinder::MatchResult &, LatticeTransferState &State) {

transferOptionalAndValueCmp(Cmp, Cmp->getArg(1), State.Env);

.CaseOfCFGStmt<CXXOperatorCallExpr>(

[](

CXXOperatorCallExpr *

,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

dyn_cast_or_null<RecordStorageLocation>(

getLocBehindPossiblePointer(*

->getArg(0), State.Env)),

State, [](StorageLocation &

) {});

.CaseOfCFGStmt<CXXOperatorCallExpr>(

[](

CXXOperatorCallExpr *

,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

dyn_cast_or_null<RecordStorageLocation>(

getLocBehindPossiblePointer(*

->getArg(0), State.Env)),

State, [](StorageLocation &

) {});

.CaseOfCFGStmt<CXXMemberCallExpr>(

[](

CXXMemberCallExpr *

,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

[](StorageLocation &

) {});

.CaseOfCFGStmt<CXXMemberCallExpr>(

[](

CXXMemberCallExpr *

,

MatchFinder::MatchResult &

,

LatticeTransferState &State) {

[](StorageLocation &

) {});

.CaseOfCFGStmt<CXXMemberCallExpr>(isZeroParamConstMemberCall(),

transferValue_ConstMemberCall)

.CaseOfCFGStmt<CXXOperatorCallExpr>(isZeroParamConstMemberOperatorCall(),

transferValue_ConstMemberOperatorCall)

.CaseOfCFGStmt<CXXMemberCallExpr>(isNonConstMemberCall(),

transferValue_NonConstMemberCall)

.CaseOfCFGStmt<CXXOperatorCallExpr>(

isNonConstMemberOperatorCall(),

transferValue_NonConstMemberOperatorCall)

.CaseOfCFGStmt<CallExpr>(isCallReturningOptional(),

transferCallReturningOptional)

Environment &

) {

(

*OptionalLoc = cast_or_null<RecordStorageLocation>(

getLocBehindPossiblePointer(*ObjectExpr,

))) {

*Prop =

.

(locForHasValue(*OptionalLoc));

(

*HasValueVal = cast_or_null<BoolValue>(Prop)) {

(

.

(HasValueVal->formula()))

{ObjectExpr->getBeginLoc()};

buildDiagnoseMatchSwitch(

UncheckedOptionalAccessModelOptions &Options) {

IgnorableOptional = ignorableOptional(Options);

CFGMatchSwitchBuilder<

Environment,

.CaseOfCFGStmt<CXXMemberCallExpr>(

valueCall(IgnorableOptional),

[](

CXXMemberCallExpr *

,

MatchFinder::MatchResult &,

Environment &

) {

diagnoseUnwrapCall(

->getImplicitObjectArgument(),

);

.CaseOfCFGStmt<CallExpr>(valueOperatorCall(IgnorableOptional),

[](

CallExpr *

,

MatchFinder::MatchResult &,

Environment &

) {

diagnoseUnwrapCall(

->getArg(0),

);

TransferMatchSwitch(buildTransferMatchSwitch()) {

.getDataflowAnalysisContext().setSyntheticFieldCallback(

[&Ctx](

Ty) -> llvm::StringMap<QualType> {

{{

, valueTypeFromOptionalDecl(*

)},

{

, Ctx.BoolTy}};

LatticeTransferState State(L,

);

: DiagnoseMatchSwitch(buildDiagnoseMatchSwitch(Options)) {}

Defines the clang::ASTContext interface.

#define AST_MATCHER(Type, DefineMatcher)

AST_MATCHER(Type, DefineMatcher) { ... } defines a zero parameter function named DefineMatcher() that...

#define AST_MATCHER_P(Type, DefineMatcher, ParamType, Param)

AST_MATCHER_P(Type, DefineMatcher, ParamType, Param) { ... } defines a single-parameter function name...

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

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

llvm::MachO::RecordLoc RecordLoc

Defines an enumeration for C++ overloaded operators.

Defines the clang::SourceLocation class and associated facilities.

C Language Family Type Representation.

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

Represents a top-level expression in a basic block.

Represents a base class of a C++ class.

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

A call to an overloaded operator written using operator syntax.

OverloadedOperatorKind getOperator() const

Returns the kind of overloaded operator that this expression refers to.

Represents a C++ struct/union/class.

bool hasDefinition() const

Expr * getArg(unsigned Arg)

getArg - Return the specified argument.

DeclContext * getParent()

getParent - Returns the containing DeclContext.

bool isTranslationUnit() const

DeclContext * getDeclContext()

bool isIdentifier() const

Predicate functions for querying what type of name this is.

This represents one expression.

StringRef getName() const

Get the name of identifier for this declaration as a StringRef.

DeclarationName getDeclName() const

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

Represent a C++ namespace.

A (possibly-)qualified type.

CXXRecordDecl * getAsCXXRecordDecl() const

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

const Formula & makeImplies(const Formula &LHS, const Formula &RHS)

Returns a formula for LHS => RHS.

A mixin for a lattice that additionally maintains a cache of stable method call return values to mode...

Base class template for dataflow analyses built on a single lattice type.

ASTContext & getASTContext() final

Holds the state of the program (store and heap) at a given program point.

StorageLocation * getStorageLocation(const ValueDecl &D) const

Returns the storage location assigned to D in the environment, or null if D isn't assigned a storage ...

BoolValue & makeAtomicBoolValue() const

Returns an atomic boolean value.

bool proves(const Formula &) const

Returns true if the formula is always true when this point is reached.

Value * getValue(const StorageLocation &Loc) const

Returns the value assigned to Loc in the environment or null if Loc isn't assigned a value in the env...

void assume(const Formula &)

Record a fact that must be true if this point in the program is reached.

RecordStorageLocation & getResultObjectLocation(const Expr &RecordPRValue) const

Returns the location of the result object for a record-type prvalue.

void setValue(const StorageLocation &Loc, Value &Val)

Assigns Val as the value of Loc in the environment.

std::enable_if_t< std::is_base_of_v< StorageLocation, T >, T * > get(const ValueDecl &D) const

Returns the result of casting getStorageLocation(...) to a subclass of StorageLocation (using cast_or...

UncheckedOptionalAccessDiagnoser(UncheckedOptionalAccessModelOptions Options={})

Dataflow analysis that models whether optionals hold values or not.

UncheckedOptionalAccessModel(ASTContext &Ctx, dataflow::Environment &Env)

void transfer(const CFGElement &Elt, UncheckedOptionalAccessLattice &L, Environment &Env)

static ast_matchers::DeclarationMatcher optionalClassDecl()

Returns a matcher for the optional classes covered by this model.

const internal::VariadicOperatorMatcherFunc< 1, 1 > unless

Matches if the provided matcher does not match.

internal::Matcher< Decl > DeclarationMatcher

Types of matchers for the top-level classes in the AST class hierarchy.

const internal::VariadicDynCastAllOfMatcher< Stmt, StringLiteral > stringLiteral

Matches string literals (also matches wide string literals).

internal::Matcher< NamedDecl > hasName(StringRef Name)

Matches NamedDecl nodes that have the specified name.

const internal::VariadicDynCastAllOfMatcher< Stmt, CallExpr > callExpr

Matches call expressions.

const internal::VariadicDynCastAllOfMatcher< Decl, NamedDecl > namedDecl

Matches a declaration of anything that could have a name.

internal::TrueMatcher anything()

Matches any node.

const internal::VariadicFunction< internal::Matcher< NamedDecl >, StringRef, internal::hasAnyNameFunc > hasAnyName

Matches NamedDecl nodes that have any of the specified names.

const internal::MapAnyOfMatcher< BinaryOperator, CXXOperatorCallExpr, CXXRewrittenBinaryOperator > binaryOperation

Matches nodes which can be used with binary operators.

const internal::VariadicDynCastAllOfMatcher< Stmt, CXXMemberCallExpr > cxxMemberCallExpr

Matches member call expressions.

const internal::VariadicDynCastAllOfMatcher< Decl, CXXConstructorDecl > cxxConstructorDecl

Matches C++ constructor declarations.

internal::PolymorphicMatcher< internal::ValueEqualsMatcher, void(internal::AllNodeBaseTypes), ValueT > equals(const ValueT &Value)

Matches literals that are equal to the given value of type ValueT.

internal::Matcher< Stmt > StatementMatcher

const internal::VariadicDynCastAllOfMatcher< Stmt, CXXConstructExpr > cxxConstructExpr

Matches constructor call expressions (including implicit ones).

const internal::VariadicDynCastAllOfMatcher< Stmt, CXXOperatorCallExpr > cxxOperatorCallExpr

Matches overloaded operator calls.

internal::PolymorphicMatcher< internal::HasOverloadedOperatorNameMatcher, AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl), std::vector< std::string > > hasOverloadedOperatorName(StringRef Name)

Matches overloaded operator names.

const internal::VariadicDynCastAllOfMatcher< Decl, FunctionDecl > functionDecl

Matches function declarations.

const AstTypeMatcher< RecordType > recordType

Matches record types (e.g.

const internal::VariadicDynCastAllOfMatcher< Stmt, MemberExpr > memberExpr

Matches member expressions.

const internal::VariadicDynCastAllOfMatcher< Decl, CXXRecordDecl > cxxRecordDecl

Matches C++ class declarations.

const AstTypeMatcher< ReferenceType > referenceType

Matches both lvalue and rvalue reference types.

const internal::VariadicDynCastAllOfMatcher< Decl, RecordDecl > recordDecl

Matches class, struct, and union declarations.

const internal::VariadicDynCastAllOfMatcher< Stmt, IntegerLiteral > integerLiteral

Matches integer literals of all sizes / encodings, e.g.

const internal::VariadicDynCastAllOfMatcher< Stmt, CXXNullPtrLiteralExpr > cxxNullPtrLiteralExpr

Matches nullptr literal.

internal::PolymorphicMatcher< internal::HasDeclarationMatcher, void(internal::HasDeclarationSupportedTypes), internal::Matcher< Decl > > hasDeclaration(const internal::Matcher< Decl > &InnerMatcher)

Matches a node if the declaration associated with that node matches the given matcher.

const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr

Matches expressions.

const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits< unsigned >::max()> anyOf

Matches if any of the given matchers matches.

const internal::VariadicDynCastAllOfMatcher< Decl, CXXMethodDecl > cxxMethodDecl

Matches method declarations.

const internal::VariadicAllOfMatcher< QualType > qualType

Matches QualTypes in the clang AST.

const internal::VariadicDynCastAllOfMatcher< Stmt, CXXThisExpr > cxxThisExpr

Matches implicit and explicit this expressions.

static bool isFullyQualifiedNamespaceEqualTo(const NamespaceDecl &NS, llvm::StringRef Name, NameTypes... Names)

void transferSmartPointerLikeCachedDeref(const CallExpr *DerefExpr, RecordStorageLocation *SmartPointerLoc, TransferState< LatticeT > &State, llvm::function_ref< void(StorageLocation &)> InitializeLoc)

A transfer function for operator* (and value) calls that can be cached.

static bool hasOptionalClassName(const CXXRecordDecl &RD)

void transferSmartPointerLikeCachedGet(const CallExpr *GetExpr, RecordStorageLocation *SmartPointerLoc, TransferState< LatticeT > &State, llvm::function_ref< void(StorageLocation &)> InitializeLoc)

A transfer function for operator-> (and get) calls that can be cached.

ast_matchers::StatementMatcher isSmartPointerLikeGetMethodCall()

ast_matchers::StatementMatcher isSmartPointerLikeValueMethodCall()

void copyRecord(RecordStorageLocation &Src, RecordStorageLocation &Dst, Environment &Env)

Copies a record (struct, class, or union) from Src to Dst.

static bool isSupportedOptionalType(QualType Ty)

ast_matchers::StatementMatcher isSmartPointerLikeOperatorArrow()

RecordStorageLocation * getImplicitObjectLocation(const CXXMemberCallExpr &MCE, const Environment &Env)

Returns the storage location for the implicit object of a CXXMemberCallExpr, or null if none is defin...

static const CXXRecordDecl * getOptionalBaseClass(const CXXRecordDecl *RD)

ast_matchers::StatementMatcher isSmartPointerLikeOperatorStar()

Matchers: For now, these match on any class with an operator* or operator-> where the return types ha...

bool Cast(InterpState &S, CodePtr OpPC)

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

@ Result

The result type of a method or function.

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