SkSL::ConstructorScalarCast Class Reference

#include <SkSLConstructorScalarCast.h>

Inheritance diagram for SkSL::ConstructorScalarCast:

Public Member Functions
	ConstructorScalarCast (Position pos, const Type &type, std::unique_ptr< Expression > arg)
std::unique_ptr< Expression >	clone (Position pos) const override
Public Member Functions inherited from SkSL::SingleArgumentConstructor
	SingleArgumentConstructor (Position pos, Kind kind, const Type *type, std::unique_ptr< Expression > argument)
std::unique_ptr< Expression > &	argument ()
const std::unique_ptr< Expression > &	argument () const
SkSpan< std::unique_ptr< Expression > >	argumentSpan () final
SkSpan< const std::unique_ptr< Expression > >	argumentSpan () const final
Public Member Functions inherited from SkSL::AnyConstructor
	AnyConstructor (Position pos, Kind kind, const Type *type)
virtual SkSpan< std::unique_ptr< Expression > >	argumentSpan ()=0
virtual SkSpan< const std::unique_ptr< Expression > >	argumentSpan () const =0
std::string	description (OperatorPrecedence) const override
const Type &	componentType () const
bool	supportsConstantValues () const override
std::optional< double >	getConstantValue (int n) const override
ComparisonResult	compareConstant (const Expression &other) const override
Public Member Functions inherited from SkSL::Expression
	Expression (Position pos, Kind kind, const Type *type)
Kind	kind () const
const Type &	type () const
bool	isAnyConstructor () const
bool	isIntLiteral () const
bool	isFloatLiteral () const
bool	isBoolLiteral () const
AnyConstructor &	asAnyConstructor ()
const AnyConstructor &	asAnyConstructor () const
bool	isIncomplete (const Context &context) const
virtual ComparisonResult	compareConstant (const Expression &other) const
CoercionCost	coercionCost (const Type &target) const
virtual bool	supportsConstantValues () const
virtual std::optional< double >	getConstantValue (int n) const
virtual std::unique_ptr< Expression >	clone (Position pos) const =0
std::unique_ptr< Expression >	clone () const
std::string	description () const final
virtual std::string	description (OperatorPrecedence parentPrecedence) const =0
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< Expression >	Convert (const Context &context, Position pos, const Type &rawType, ExpressionArray args)
static std::unique_ptr< Expression >	Make (const Context &context, Position pos, const Type &type, std::unique_ptr< Expression > arg)
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::kConstructorScalarCast

Additional Inherited Members
Public Types inherited from SkSL::Expression
enum class	ComparisonResult { kUnknown = -1 , kNotEqual , kEqual }
using	Kind = ExpressionKind
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

Represents the construction of a scalar cast, such as float(intVariable).

These always contain exactly 1 scalar of a differing type, and are never constant.

Definition at line 30 of file SkSLConstructorScalarCast.h.

Constructor & Destructor Documentation

ConstructorScalarCast()

SkSL::ConstructorScalarCast::ConstructorScalarCast ( Position  pos, const Type &  type, std::unique_ptr< Expression >  arg  )

inline

Definition at line 34 of file SkSLConstructorScalarCast.h.

        : INHERITED(pos, kIRNodeKind, &type, std::move(arg)) {}

Member Function Documentation

clone()

std::unique_ptr< Expression > SkSL::ConstructorScalarCast::clone ( Position  pos ) const

inlineoverridevirtual

Implements SkSL::Expression.

Definition at line 51 of file SkSLConstructorScalarCast.h.

                                                                 {
        return std::make_unique<ConstructorScalarCast>(pos, this->type(), argument()->clone());
    }

Convert()

std::unique_ptr< Expression > SkSL::ConstructorScalarCast::Convert ( const Context &  context, Position  pos, const Type &  rawType, ExpressionArray  args  )

static

Definition at line 23 of file SkSLConstructorScalarCast.cpp.

                                                                                 {
    // As you might expect, scalar-cast constructors should only be created with scalar types.
    const Type& type = rawType.scalarTypeForLiteral();
    SkASSERT(type.isScalar());
 
    if (args.size() != 1) {
        context.fErrors->error(pos, "invalid arguments to '" + type.displayName() +
                                    "' constructor, (expected exactly 1 argument, but found " +
                                    std::to_string(args.size()) + ")");
        return nullptr;
    }
 
    const Type& argType = args[0]->type();
    if (!argType.isScalar()) {
        // Casting a vector-type into its scalar component type is treated as a slice in GLSL.
        // We don't allow those casts in SkSL; recommend a .x swizzle instead.
        const char* swizzleHint = "";
        if (argType.componentType().matches(type)) {
            if (argType.isVector()) {
                swizzleHint = "; use '.x' instead";
            } else if (argType.isMatrix()) {
                swizzleHint = "; use '[0][0]' instead";
            }
        }
 
        context.fErrors->error(pos,
                               "'" + argType.displayName() + "' is not a valid parameter to '" +
                               type.displayName() + "' constructor" + swizzleHint);
        return nullptr;
    }
    if (type.checkForOutOfRangeLiteral(context, *args[0])) {
        return nullptr;
    }
 
    return ConstructorScalarCast::Make(context, pos, type, std::move(args[0]));
}

Make()

std::unique_ptr< Expression > SkSL::ConstructorScalarCast::Make ( const Context &  context, Position  pos, const Type &  type, std::unique_ptr< Expression >  arg  )

static

Definition at line 63 of file SkSLConstructorScalarCast.cpp.

                                                                                       {
    SkASSERT(type.isScalar());
    SkASSERT(type.isAllowedInES2(context));
    SkASSERT(arg->type().isScalar());
 
    // No cast required when the types match.
    if (arg->type().matches(type)) {
        arg->setPosition(pos);
        return arg;
    }
    // Look up the value of constant variables. This allows constant-expressions like `int(zero)` to
    // be replaced with a literal zero.
    arg = ConstantFolder::MakeConstantValueForVariable(pos, std::move(arg));
 
    // We can cast scalar literals at compile-time when possible. (If the resulting literal would be
    // out of range for its type, we report an error and return zero to minimize error cascading.
    // This can occur when code is inlined, so we can't necessarily catch it during Convert. As
    // such, it's not safe to return null or assert.)
    if (arg->is<Literal>()) {
        double value = arg->as<Literal>().value();
        if (type.checkForOutOfRangeLiteral(context, value, arg->fPosition)) {
            value = 0.0;
        }
        return Literal::Make(pos, value, &type);
    }
 
    // We allow scalar casts to abstract types `$floatLiteral` or `$intLiteral`. This can be used to
    // represent various expressions where SkSL still allows type flexibility. For instance, the
    // expression `float x = myBool ? 1 : 0` is allowed in SkSL despite the apparent type mismatch,
    // and the resolved type of expression `myBool ? 1 : 0` is actually `$intLiteral`. This
    // expression could also be rewritten as `$intLiteral(myBool)` to replace a ternary with a cast.
    //
    // If we are casting an expression of the form `$intLiteral(...)` or `$floatLiteral(...)`, we
    // can eliminate the intermediate constructor-cast since it no longer adds value.
    if (arg->is<ConstructorScalarCast>() && arg->type().isLiteral()) {
        std::unique_ptr<Expression> inner = std::move(arg->as<ConstructorScalarCast>().argument());
        return ConstructorScalarCast::Make(context, pos, type, std::move(inner));
    }
 
    return std::make_unique<ConstructorScalarCast>(pos, type, std::move(arg));
}

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::ConstructorScalarCast::kIRNodeKind = Kind::kConstructorScalarCast

inlinestaticconstexpr

Definition at line 32 of file SkSLConstructorScalarCast.h.

---

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

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