SkSL::ExpressionStatement Class Reference

#include <SkSLExpressionStatement.h>

Inheritance diagram for SkSL::ExpressionStatement:

Public Member Functions
	ExpressionStatement (std::unique_ptr< Expression > expression)
const std::unique_ptr< Expression > &	expression () const
std::unique_ptr< Expression > &	expression ()
std::string	description () const override
Public Member Functions inherited from SkSL::Statement
	Statement (Position pos, Kind kind)
Kind	kind () const
virtual bool	isEmpty () const
Public Member Functions inherited from SkSL::IRNode
virtual	~IRNode ()
virtual std::string	description () const =0
	IRNode (const IRNode &)=delete
IRNode &	operator= (const IRNode &)=delete
Position	position () const
void	setPosition (Position p)
template<typename T >
bool	is () const
template<typename T >
const T &	as () const
template<typename T >
T &	as ()

Static Public Member Functions
static std::unique_ptr< Statement >	Convert (const Context &context, std::unique_ptr< Expression > expr)
static std::unique_ptr< Statement >	Make (const Context &context, std::unique_ptr< Expression > expr)
Static Public Member Functions inherited from SkSL::Poolable
static void *	operator new (const size_t size)
static void	operator delete (void *ptr)

Static Public Attributes
static constexpr Kind	kIRNodeKind = Kind::kExpression

Additional Inherited Members
Public Types inherited from SkSL::Statement
using	Kind = StatementKind
Public Attributes inherited from SkSL::IRNode
Position	fPosition
Protected Member Functions inherited from SkSL::IRNode
	IRNode (Position position, int kind)
Protected Attributes inherited from SkSL::IRNode
int	fKind

Detailed Description

A lone expression being used as a statement.

Definition at line 26 of file SkSLExpressionStatement.h.

Constructor & Destructor Documentation

ExpressionStatement()

SkSL::ExpressionStatement::ExpressionStatement ( std::unique_ptr< Expression >  expression )

inline

Definition at line 30 of file SkSLExpressionStatement.h.

        : INHERITED(expression->fPosition, kIRNodeKind)
        , fExpression(std::move(expression)) {}

Member Function Documentation

Convert()

std::unique_ptr< Statement > SkSL::ExpressionStatement::Convert ( const Context &  context, std::unique_ptr< Expression >  expr  )

static

Definition at line 21 of file SkSLExpressionStatement.cpp.

                                                                                        {
    // Expression-statements need to represent a complete expression.
    // Report an error on intermediate expressions, like FunctionReference or TypeReference.
    if (expr->isIncomplete(context)) {
        return nullptr;
    }
    return ExpressionStatement::Make(context, std::move(expr));
}

description()

std::string SkSL::ExpressionStatement::description ( ) const

overridevirtual

Implements SkSL::IRNode.

Definition at line 58 of file SkSLExpressionStatement.cpp.

                                                 {
    return this->expression()->description(OperatorPrecedence::kStatement) + ";";
}

expression() [1/2]

std::unique_ptr< Expression > & SkSL::ExpressionStatement::expression ( )

inline

Definition at line 46 of file SkSLExpressionStatement.h.

                                            {
        return fExpression;
    }

expression() [2/2]

const std::unique_ptr< Expression > & SkSL::ExpressionStatement::expression ( ) const

inline

Definition at line 42 of file SkSLExpressionStatement.h.

                                                        {
        return fExpression;
    }

Make()

std::unique_ptr< Statement > SkSL::ExpressionStatement::Make ( const Context &  context, std::unique_ptr< Expression >  expr  )

static

Definition at line 31 of file SkSLExpressionStatement.cpp.

                                                                                     {
    SkASSERT(!expr->isIncomplete(context));
 
    if (context.fConfig->fSettings.fOptimize) {
        // Expression-statements without any side effect can be replaced with a Nop.
        if (!Analysis::HasSideEffects(*expr)) {
            return Nop::Make();
        }
 
        // If this is an assignment statement like `a += b;`, the ref-kind of `a` will be set as
        // read-write; `a` is written-to by the +=, and read-from by the consumer of the expression.
        // We can demote the ref-kind to "write" safely, because the result of the expression is
        // discarded; that is, `a` is never actually read-from.
        if (expr->is<BinaryExpression>()) {
            BinaryExpression& binary = expr->as<BinaryExpression>();
            if (VariableReference* assignedVar = binary.isAssignmentIntoVariable()) {
                if (assignedVar->refKind() == VariableRefKind::kReadWrite) {
                    assignedVar->setRefKind(VariableRefKind::kWrite);
                }
            }
        }
    }
 
    return std::make_unique<ExpressionStatement>(std::move(expr));
}

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::ExpressionStatement::kIRNodeKind = Kind::kExpression

inlinestaticconstexpr

Definition at line 28 of file SkSLExpressionStatement.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/sksl/ir/SkSLExpressionStatement.h
• third_party/skia/src/sksl/ir/SkSLExpressionStatement.cpp