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

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

clang: lib/Analysis/Consumed.cpp Source File

;

consumed;

(

&B : *

)

(std::optional<CFGStmt> CS = B.getAs<

>())

CS->getStmt()->getBeginLoc();

StmtNode->getBeginLoc();

(std::optional<CFGStmt> CS = BI->getAs<

>())

CS->getStmt()->getBeginLoc();

llvm_unreachable(

);

(

&S : CWAttr->callableStates()) {

CallableWhenAttr::Unknown:

CallableWhenAttr::Unconsumed:

CallableWhenAttr::Consumed:

(MappedAttrState == State)

RD->hasAttr<ConsumableAttr>();

RD->hasAttr<ConsumableAutoCastAttr>();

RD->hasAttr<ConsumableSetOnReadAttr>();

llvm_unreachable(

);

FunDecl->

<TestTypestateAttr>();

ConsumableAttr *CAttr =

(CAttr->getDefaultState()) {

ConsumableAttr::Unknown:

ConsumableAttr::Unconsumed:

ConsumableAttr::Consumed:

llvm_unreachable(

);

(PTAttr->getParamState()) {

ParamTypestateAttr::Unknown:

ParamTypestateAttr::Unconsumed:

ParamTypestateAttr::Consumed:

llvm_unreachable(

);

(RTSAttr->getState()) {

ReturnTypestateAttr::Unknown:

ReturnTypestateAttr::Unconsumed:

ReturnTypestateAttr::Consumed:

llvm_unreachable(

);

(STAttr->getNewState()) {

SetTypestateAttr::Unknown:

SetTypestateAttr::Unconsumed:

SetTypestateAttr::Consumed:

llvm_unreachable(

);

;

llvm_unreachable(

);

(FunDecl->

<TestTypestateAttr>()->getTestState()) {

TestTypestateAttr::Unconsumed:

TestTypestateAttr::Consumed:

llvm_unreachable(

);

VarTestResult {

} InfoType = IT_None;

: InfoType(IT_VarTest) {

VarTestResult &LTest,

VarTestResult &RTest)

: InfoType(IT_BinTest) {

: InfoType(IT_BinTest) {

.LTest.TestsFor = LTestsFor;

.RTest.TestsFor = RTestsFor;

: InfoType(IT_Tmp),

(

) {}

assert(InfoType == IT_State);

assert(InfoType == IT_VarTest);

assert(InfoType == IT_BinTest);

assert(InfoType == IT_BinTest);

assert(InfoType == IT_Var);

assert(InfoType == IT_Tmp);

assert(InfoType == IT_BinTest);

assert(InfoType == IT_BinTest);

()

{

InfoType != IT_None; }

()

{

InfoType == IT_State; }

()

{

InfoType == IT_VarTest; }

()

{

InfoType == IT_BinTest; }

()

{

InfoType == IT_Var; }

()

{

InfoType == IT_Tmp; }

InfoType == IT_VarTest || InfoType == IT_BinTest;

InfoType == IT_Var || InfoType == IT_Tmp;

assert(InfoType == IT_VarTest || InfoType == IT_BinTest);

(InfoType == IT_VarTest) {

}

(InfoType == IT_BinTest) {

MapType = llvm::DenseMap<const Stmt *, PropagationInfo>;

PairType= std::pair<const Stmt *, PropagationInfo>;

InfoEntry = MapType::iterator;

ConstInfoEntry = MapType::const_iterator;

MapType PropagationMap;

InfoEntry findInfo(

*

) {

(

Cleanups = dyn_cast<ExprWithCleanups>(

))

(!Cleanups->cleanupsHaveSideEffects())

= Cleanups->getSubExpr();

ConstInfoEntry findInfo(

*

)

{

(

Cleanups = dyn_cast<ExprWithCleanups>(

))

(!Cleanups->cleanupsHaveSideEffects())

= Cleanups->getSubExpr();

forwardInfo(

*From,

*To);

: Analyzer(Analyzer), StateMap(StateMap) {}

ConstInfoEntry Entry = findInfo(StmtNode);

(Entry != PropagationMap.end())

Entry->second;

StateMap = NewStateMap;

ConsumedStmtVisitor::forwardInfo(

*From,

*To) {

InfoEntry Entry = findInfo(From);

(Entry != PropagationMap.end())

insertInfo(To, Entry->second);

ConsumedStmtVisitor::copyInfo(

*From,

*To,

InfoEntry Entry = findInfo(From);

(Entry != PropagationMap.end()) {

InfoEntry Entry = findInfo(From);

(Entry != PropagationMap.end()) {

InfoEntry Entry = findInfo(To);

(Entry != PropagationMap.end()) {

assert(!PInfo.

());

CallableWhenAttr *CWAttr = FunDecl->

<CallableWhenAttr>();

(PInfo.

()) {

(isa<CXXOperatorCallExpr>(

) && isa<CXXMethodDecl>(FunD))

(

Index = Offset; Index <

->getNumArgs(); ++Index) {

InfoEntry Entry = findInfo(

->getArg(Index));

(Entry == PropagationMap.end() || Entry->second.isTest())

(ParamTypestateAttr *PTA = Param->

<ParamTypestateAttr>()) {

(ParamState != ExpectedState)

->getArg(Index)->getExprLoc(),

(!(Entry->second.isVar() || Entry->second.isTmp()))

(ReturnTypestateAttr *RT = Param->

<ReturnTypestateAttr>())

InfoEntry Entry = findInfo(ObjArg);

(Entry != PropagationMap.end()) {

(SetTypestateAttr *STA = FunD->

<SetTypestateAttr>()) {

(PInfo.

()) {

(PInfo.

()) {

PropagationMap.insert(PairType(

,

ConsumedStmtVisitor::propagateReturnType(

*

,

(ReturnTypestateAttr *RTA = Fun->

<ReturnTypestateAttr>())

InfoEntry LEntry = findInfo(BinOp->

()),

REntry = findInfo(BinOp->

());

VarTestResult LTest, RTest;

(LEntry != PropagationMap.end() && LEntry->second.isVarTest()) {

LTest = LEntry->second.getVarTest();

LTest.Var =

;

(REntry != PropagationMap.end() && REntry->second.isVarTest()) {

RTest = REntry->second.getVarTest();

RTest.Var =

;

(!(LTest.Var ==

&& RTest.Var ==

))

forwardInfo(BinOp->

(), BinOp);

(

->isCallToStdMove()) {

propagateReturnType(

, FunDecl);

forwardInfo(Cast->getSubExpr(), Cast);

InfoEntry Entry = findInfo(Temp->

());

(Entry != PropagationMap.end() && !Entry->second.isTest()) {

StateMap->

(Temp, Entry->second.getAsState(StateMap));

ThisType = Constructor->getFunctionObjectParameterType();

(ReturnTypestateAttr *RTA = Constructor->getAttr<ReturnTypestateAttr>()) {

}

(Constructor->isDefaultConstructor()) {

PropagationMap.insert(PairType(

,

}

(Constructor->isMoveConstructor()) {

}

(Constructor->isCopyConstructor()) {

copyInfo(

->getArg(0),

, NS);

propagateReturnType(

, MD);

*FunDecl = dyn_cast_or_null<FunctionDecl>(

->getDirectCallee());

(!FunDecl)

;

(

->getOperator() == OO_Equal) {

setInfo(

->getArg(0), CS);

(

*MCall = dyn_cast<CXXMemberCallExpr>(

))

(MCall, MCall->getImplicitObjectArgument(), FunDecl);

propagateReturnType(

, FunDecl);

(

*Var = dyn_cast_or_null<VarDecl>(DeclRef->

()))

(

*DI : DeclS->

())

(isa<VarDecl>(DI))

(

*Var = dyn_cast_or_null<VarDecl>(DeclS->

()))

forwardInfo(MExpr->

(), MExpr);

(

ParamTypestateAttr *PTA = Param->

<ParamTypestateAttr>())

StateMap->

(Param, ParamState);

(ExpectedState !=

) {

InfoEntry Entry = findInfo(Ret->getRetValue());

(Entry != PropagationMap.end()) {

(RetState != ExpectedState)

InfoEntry Entry = findInfo(UOp->

());

(Entry == PropagationMap.end())

;

PropagationMap.insert(PairType(UOp, Entry->second));

(Entry->second.isTest())

PropagationMap.insert(PairType(UOp, Entry->second.invertTest()));

(VIT != PropagationMap.end()) {

ThenStates->

(Test.Var, Test.TestsFor);

}

(VarState == Test.TestsFor) {

VarTestResult &LTest = PInfo.

(),

ThenStates->

(LTest.Var, LTest.TestsFor);

}

(LState == LTest.TestsFor &&

(RState)) {

(RState == RTest.TestsFor)

}

(LState == LTest.TestsFor) {

(RState == RTest.TestsFor)

ThenStates->

(RTest.Var, RTest.TestsFor);

(RState == RTest.TestsFor)

assert(CurrBlock &&

);

assert(TargetBlock &&

);

CurrBlockOrder = VisitOrder[CurrBlock->

()];

PE = TargetBlock->

(); PI != PE; ++PI) {

(*PI && CurrBlockOrder < VisitOrder[(*PI)->getBlockID()] )

std::unique_ptr<ConsumedStateMap> &OwnedStateMap) {

assert(

&&

);

&Entry = StateMapsArray[

->getBlockID()];

Entry->intersect(*StateMap);

}

(OwnedStateMap)

Entry = std::move(OwnedStateMap);

Entry = std::make_unique<ConsumedStateMap>(*StateMap);

std::unique_ptr<ConsumedStateMap> StateMap) {

assert(

&&

);

&Entry = StateMapsArray[

->getBlockID()];

Entry->intersect(*StateMap);

Entry = std::move(StateMap);

assert(

&&

);

assert(StateMapsArray[

->getBlockID()] &&

);

StateMapsArray[

->getBlockID()].get();

StateMapsArray[

->getBlockID()] =

;

std::unique_ptr<ConsumedStateMap>

assert(

&&

);

&Entry = StateMapsArray[

->getBlockID()];

assert(From &&

);

assert(To &&

);

assert(

&&

);

(

->pred_size() < 2)

BlockVisitOrder = VisitOrder[

->getBlockID()];

PE =

->pred_end(); PI != PE; ++PI) {

(*PI && BlockVisitOrder < VisitOrder[(*PI)->getBlockID()])

(

&DM :

) {

(isa<ParmVarDecl>(DM.first)) {

*Param = cast<ParmVarDecl>(DM.first);

ReturnTypestateAttr *RTA = Param->getAttr<ReturnTypestateAttr>();

(DM.second != ExpectedState)

VarMapType::const_iterator Entry =

.find(Var);

(Entry !=

.end())

Entry->second;

TmpMapType::const_iterator Entry =

.find(Tmp);

(Entry !=

.end())

Entry->second;

(this->From && this->From ==

.From && !

.Reachable) {

(

&DM :

.VarMap) {

LocalState = this->

(DM.first);

(LocalState != DM.second)

(

&DM : LoopBackStates->

) {

LocalState = this->

(DM.first);

(LocalState != DM.second) {

DM.first->getNameAsString());

(

&DM :

->VarMap)

(this->

(DM.first) != DM.second)

(

*Constructor = dyn_cast<CXXConstructorDecl>(

)) {

ReturnType = Constructor->getFunctionObjectParameterType();

ReturnType =

->getCallResultType();

(

ReturnTypestateAttr *RTSAttr =

->

<ReturnTypestateAttr>()) {

(!RD || !RD->

<ConsumableAttr>()) {

RTSAttr->getLocation(), ReturnType.

());

ExpectedReturnState =

;

ExpectedReturnState =

;

ExpectedReturnState =

;

ConsumedAnalyzer::splitState(

*CurrBlock,

std::unique_ptr<ConsumedStateMap> FalseStates(

(

*IfNode =

(IfNode->isConsteval())

*Cond = IfNode->getCond();

PInfo = Visitor.getInfo(Cond);

(!PInfo.

() && isa<BinaryOperator>(Cond))

PInfo = Visitor.getInfo(cast<BinaryOperator>(Cond)->getRHS());

CurrStates->setSource(Cond);

FalseStates->setSource(Cond);

}

(

*BinOp =

PInfo = Visitor.getInfo(BinOp->getLHS());

((BinOp = dyn_cast_or_null<BinaryOperator>(BinOp->getLHS()))) {

PInfo = Visitor.getInfo(BinOp->getRHS());

CurrStates->setSource(BinOp);

FalseStates->setSource(BinOp);

VarTestResult &Test = PInfo.

();

(BinOp->getOpcode() == BO_LAnd) {

CurrStates->setState(Test.Var, Test.TestsFor);

CurrStates->markUnreachable();

}

(BinOp->getOpcode() == BO_LOr) {

FalseStates->setState(Test.Var,

(VarState == Test.TestsFor)

FalseStates->markUnreachable();

BlockInfo.

(*SI, std::move(CurrStates));

CurrStates =

;

BlockInfo.

(*SI, std::move(FalseStates));

*

= dyn_cast_or_null<FunctionDecl>(AC.getDecl());

*CFGraph = AC.getCFG();

determineExpectedReturnState(AC,

);

CurrStates = std::make_unique<ConsumedStateMap>();

(

*PI :

->parameters())

(

*CurrBlock : *SortedGraph) {

CurrStates = BlockInfo.getInfo(CurrBlock);

}

(!CurrStates->isReachable()) {

CurrStates =

;

Visitor.

(CurrStates.get());

(

&B : *CurrBlock) {

(B.getKind()) {

CurrStates->remove(BTE);

(!splitState(CurrBlock, Visitor)) {

CurrStates->setSource(

);

(CurrBlock->succ_size() > 1 ||

(CurrBlock->succ_size() == 1 &&

(*CurrBlock->succ_begin())->pred_size() > 1)) {

*RawState = CurrStates.get();

SE = CurrBlock->succ_end(); SI != SE; ++SI) {

(*SI ==

)

;

(BlockInfo.isBackEdge(CurrBlock, *SI)) {

BlockInfo.borrowInfo(*SI)->intersectAtLoopHead(

(BlockInfo.allBackEdgesVisited(CurrBlock, *SI))

BlockInfo.discardInfo(*SI);

BlockInfo.addInfo(*SI, RawState, CurrStates);

CurrStates =

;

(CurrBlock == &AC.getCFG()->getExit() &&

->getCallResultType()->isVoidType())

CurrStates->checkParamsForReturnTypestate(

->

(),

CurrStates =

;

This file defines AnalysisDeclContext, a class that manages the analysis context data for context sen...

static void splitVarStateForIfBinOp(const PropagationInfo &PInfo, ConsumedStateMap *ThenStates, ConsumedStateMap *ElseStates)

static ConsumedState invertConsumedUnconsumed(ConsumedState State)

static bool isCallableInState(const CallableWhenAttr *CWAttr, ConsumedState State)

static ConsumedState mapParamTypestateAttrState(const ParamTypestateAttr *PTAttr)

static bool isRValueRef(QualType ParamType)

static ConsumedState mapReturnTypestateAttrState(const ReturnTypestateAttr *RTSAttr)

static ConsumedState testsFor(const FunctionDecl *FunDecl)

static bool isConsumableType(const QualType &QT)

static StringRef stateToString(ConsumedState State)

static void splitVarStateForIf(const IfStmt *IfNode, const VarTestResult &Test, ConsumedStateMap *ThenStates, ConsumedStateMap *ElseStates)

static bool isTestingFunction(const FunctionDecl *FunDecl)

static bool isAutoCastType(const QualType &QT)

static SourceLocation getFirstStmtLoc(const CFGBlock *Block)

static void setStateForVarOrTmp(ConsumedStateMap *StateMap, const PropagationInfo &PInfo, ConsumedState State)

static ConsumedState mapConsumableAttrState(const QualType QT)

static ConsumedState mapSetTypestateAttrState(const SetTypestateAttr *STAttr)

static SourceLocation getLastStmtLoc(const CFGBlock *Block)

static bool isSetOnReadPtrType(const QualType &QT)

static bool isKnownState(ConsumedState State)

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

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

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines an enumeration for C++ overloaded operators.

Defines the clang::SourceLocation class and associated facilities.

C Language Family Type Representation.

AnalysisDeclContext contains the context data for the function, method or block under analysis.

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

Represents C++ object destructor implicitly generated for automatic object or temporary bound to cons...

const VarDecl * getVarDecl() const

const Stmt * getTriggerStmt() const

Represents a single basic block in a source-level CFG.

reverse_iterator rbegin()

CFGTerminator getTerminator() const

succ_iterator succ_begin()

Stmt * getTerminatorStmt()

AdjacentBlocks::const_iterator const_pred_iterator

unsigned pred_size() const

pred_iterator pred_begin()

unsigned getBlockID() const

AdjacentBlocks::const_iterator const_succ_iterator

unsigned succ_size() const

Represents a top-level expression in a basic block.

T castAs() const

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

const CXXDestructorDecl * getDestructorDecl(ASTContext &astContext) const

const Stmt * getStmt() const

Represents C++ object destructor implicitly generated at the end of full expression for temporary obj...

const CXXBindTemporaryExpr * getBindTemporaryExpr() const

Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt.

unsigned getNumBlockIDs() const

Returns the total number of BlockIDs allocated (which start at 0).

Represents binding an expression to a temporary.

const Expr * getSubExpr() const

Represents a call to a C++ constructor.

Represents a C++ constructor within a class.

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.

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

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

ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.

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

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

This represents one expression.

Expr * IgnoreImplicit() LLVM_READONLY

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

Expr * IgnoreParens() LLVM_READONLY

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

Represents a function declaration or definition.

const ParmVarDecl * getParamDecl(unsigned i) const

unsigned getNumParams() const

Return the number of parameters this function must have based on its FunctionType.

QualType getCallResultType() const

Determine the type of an expression that calls this function.

IfStmt - This represents an if/then/else.

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.

std::string getNameAsString() const

Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...

Represents a parameter to a function.

A (possibly-)qualified type.

bool isConstQualified() const

Determine whether this type is const-qualified.

static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)

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

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

RetTy Visit(PTR(Stmt) S, ParamTys... P)

Stmt - This represents one statement.

SourceLocation getEndLoc() const LLVM_READONLY

CXXRecordDecl * getAsCXXRecordDecl() const

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

bool isRValueReferenceType() const

bool isReferenceType() const

const CXXRecordDecl * getPointeeCXXRecordDecl() const

If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to.

QualType getPointeeType() const

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

bool isPointerOrReferenceType() const

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

Expr * getSubExpr() const

Represents a variable declaration or definition.

const Expr * getInit() const

A class that handles the analysis of uniqueness violations.

ConsumedWarningsHandlerBase & WarningsHandler

ConsumedState getExpectedReturnState() const

void run(AnalysisDeclContext &AC)

Check a function's CFG for consumed violations.

ConsumedStateMap * borrowInfo(const CFGBlock *Block)

bool isBackEdgeTarget(const CFGBlock *Block)

std::unique_ptr< ConsumedStateMap > getInfo(const CFGBlock *Block)

void addInfo(const CFGBlock *Block, ConsumedStateMap *StateMap, std::unique_ptr< ConsumedStateMap > &OwnedStateMap)

void discardInfo(const CFGBlock *Block)

bool allBackEdgesVisited(const CFGBlock *CurrBlock, const CFGBlock *TargetBlock)

bool isBackEdge(const CFGBlock *From, const CFGBlock *To)

void clearTemporaries()

Clear the TmpMap.

void checkParamsForReturnTypestate(SourceLocation BlameLoc, ConsumedWarningsHandlerBase &WarningsHandler) const

Warn if any of the parameters being tracked are not in the state they were declared to be in upon ret...

void intersect(const ConsumedStateMap &Other)

Merge this state map with another map.

ConsumedState getState(const VarDecl *Var) const

Get the consumed state of a given variable.

void intersectAtLoopHead(const CFGBlock *LoopHead, const CFGBlock *LoopBack, const ConsumedStateMap *LoopBackStates, ConsumedWarningsHandlerBase &WarningsHandler)

void remove(const CXXBindTemporaryExpr *Tmp)

Remove the temporary value from our state map.

void markUnreachable()

Mark the block as unreachable.

bool operator!=(const ConsumedStateMap *Other) const

Tests to see if there is a mismatch in the states stored in two maps.

void setState(const VarDecl *Var, ConsumedState State)

Set the consumed state of a given variable.

void VisitUnaryOperator(const UnaryOperator *UOp)

PropagationInfo getInfo(const Expr *StmtNode) const

void VisitVarDecl(const VarDecl *Var)

void VisitCXXMemberCallExpr(const CXXMemberCallExpr *Call)

void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Temp)

void VisitMemberExpr(const MemberExpr *MExpr)

void reset(ConsumedStateMap *NewStateMap)

void VisitReturnStmt(const ReturnStmt *Ret)

void VisitDeclStmt(const DeclStmt *DelcS)

void checkCallability(const PropagationInfo &PInfo, const FunctionDecl *FunDecl, SourceLocation BlameLoc)

void VisitCallExpr(const CallExpr *Call)

void VisitDeclRefExpr(const DeclRefExpr *DeclRef)

void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Temp)

bool handleCall(const CallExpr *Call, const Expr *ObjArg, const FunctionDecl *FunD)

ConsumedStmtVisitor(ConsumedAnalyzer &Analyzer, ConsumedStateMap *StateMap)

void VisitCXXConstructExpr(const CXXConstructExpr *Call)

void VisitBinaryOperator(const BinaryOperator *BinOp)

void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *Call)

void VisitCastExpr(const CastExpr *Cast)

void VisitParmVarDecl(const ParmVarDecl *Param)

virtual void warnUseOfTempInInvalidState(StringRef MethodName, StringRef State, SourceLocation Loc)

Warn about use-while-consumed errors.

virtual void warnParamTypestateMismatch(SourceLocation LOC, StringRef ExpectedState, StringRef ObservedState)

virtual void warnLoopStateMismatch(SourceLocation Loc, StringRef VariableName)

Warn that a variable's state doesn't match at the entry and exit of a loop.

virtual void warnUseInInvalidState(StringRef MethodName, StringRef VariableName, StringRef State, SourceLocation Loc)

Warn about use-while-consumed errors.

virtual void emitDiagnostics()

Emit the warnings and notes left by the analysis.

virtual void warnReturnTypestateMismatch(SourceLocation Loc, StringRef ExpectedState, StringRef ObservedState)

Warn about return typestate mismatches.

virtual void warnReturnTypestateForUnconsumableType(SourceLocation Loc, StringRef TypeName)

Warn about return typestates set for unconsumable types.

virtual ~ConsumedWarningsHandlerBase()

virtual void warnParamReturnTypestateMismatch(SourceLocation Loc, StringRef VariableName, StringRef ExpectedState, StringRef ObservedState)

Warn about parameter typestate mismatches upon return.

const VarTestResult & getRTest() const

PropagationInfo(const BinaryOperator *Source, EffectiveOp EOp, const VarTestResult &LTest, const VarTestResult &RTest)

const CXXBindTemporaryExpr * Tmp

PropagationInfo(const VarTestResult &VarTest)

EffectiveOp testEffectiveOp() const

PropagationInfo(const BinaryOperator *Source, EffectiveOp EOp, const VarDecl *LVar, ConsumedState LTestsFor, const VarDecl *RVar, ConsumedState RTestsFor)

const ConsumedState & getState() const

const VarTestResult & getVarTest() const

const VarDecl * getVar() const

PropagationInfo(ConsumedState State)

PropagationInfo(const VarDecl *Var)

PropagationInfo(const VarDecl *Var, ConsumedState TestsFor)

PropagationInfo(const CXXBindTemporaryExpr *Tmp)

const VarTestResult & getLTest() const

bool isPointerToValue() const

PropagationInfo()=default

const CXXBindTemporaryExpr * getTmp() const

PropagationInfo invertTest() const

ConsumedState getAsState(const ConsumedStateMap *StateMap) const

const BinaryOperator * testSourceNode() const

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

@ Other

Other implicit parameter.

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