#include <SkSLFieldAccess.h>

Inheritance diagram for SkSL::FieldAccess:

Public Types
using	OwnerKind = FieldAccessOwnerKind

Public Types inherited from SkSL::Expression
enum class	ComparisonResult { kUnknown = -1 , kNotEqual , kEqual }

using	Kind = ExpressionKind

Public Member Functions
	FieldAccess (Position pos, std::unique_ptr< Expression > base, int fieldIndex, OwnerKind ownerKind=OwnerKind::kDefault)

std::unique_ptr< Expression > &	base ()

const std::unique_ptr< Expression > &	base () const

int	fieldIndex () const

OwnerKind	ownerKind () const

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

size_t	initialSlot () const

std::string	description (OperatorPrecedence) const override

Public Member Functions inherited from SkSL::Expression
	Expression (Position pos, Kind kind, const Type *type)

Kind	kind () const

virtual 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

std::unique_ptr< Expression >	clone () const

std::string	description () const final

Public Member Functions inherited from SkSL::IRNode
virtual	~IRNode ()

	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, std::unique_ptr< Expression > base, std::string_view field)

static std::unique_ptr< Expression >	Make (const Context &context, Position pos, std::unique_ptr< Expression > base, int fieldIndex, OwnerKind ownerKind=OwnerKind::kDefault)

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::kFieldAccess

Additional Inherited Members
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

An expression which extracts a field from a struct, as in 'foo.bar'.

Definition at line 39 of file SkSLFieldAccess.h.

Member Typedef Documentation

◆ OwnerKind

using SkSL::FieldAccess::OwnerKind = FieldAccessOwnerKind

Definition at line 41 of file SkSLFieldAccess.h.

Constructor & Destructor Documentation

◆ FieldAccess()

SkSL::FieldAccess::FieldAccess	(	Position	pos,
		std::unique_ptr< Expression >	base,
		int	fieldIndex,
		OwnerKind	ownerKind = `OwnerKind::kDefault`
	)

inline

Definition at line 45 of file SkSLFieldAccess.h.

    : INHERITED(pos, kIRNodeKind, base->type().fields()[fieldIndex].fType)
    , fFieldIndex(fieldIndex)
    , fOwnerKind(ownerKind)
    , fBase(std::move(base)) {}

Member Function Documentation

◆ base() [1/2]

std::unique_ptr< Expression > & SkSL::FieldAccess::base ( )

inline

Definition at line 65 of file SkSLFieldAccess.h.

                                      {
        return fBase;
    }

◆ base() [2/2]

const std::unique_ptr< Expression > & SkSL::FieldAccess::base ( ) const

inline

Definition at line 69 of file SkSLFieldAccess.h.

                                                  {
        return fBase;
    }

◆ clone()

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

inlineoverridevirtual

Implements SkSL::Expression.

Definition at line 81 of file SkSLFieldAccess.h.

                                                                 {
        return std::make_unique<FieldAccess>(pos,
                                             this->base()->clone(),
                                             this->fieldIndex(),
                                             this->ownerKind());
    }

◆ Convert()

std::unique_ptr< Expression > SkSL::FieldAccess::Convert	(	const Context &	context,
		Position	pos,
		std::unique_ptr< Expression >	base,
		std::string_view	field
	)

static

Definition at line 31 of file SkSLFieldAccess.cpp.

                                                                       {
    const Type& baseType = base->type();
    if (baseType.isEffectChild()) {
        // Turn the field name into a free function name, prefixed with '$':
        std::string methodName = "$" + std::string(field);
        const Symbol* result = context.fSymbolTable->find(methodName);
        if (result && result->is<FunctionDeclaration>()) {
            return std::make_unique<MethodReference>(context, pos, std::move(base),
                                                     &result->as<FunctionDeclaration>());
        }
        context.fErrors->error(pos, "type '" + baseType.displayName() + "' has no method named '" +
                                    std::string(field) + "'");
        return nullptr;
    }
    if (baseType.isStruct()) {
        SkSpan<const Field> fields = baseType.fields();
        for (size_t i = 0; i < fields.size(); i++) {
            if (fields[i].fName == field) {
                return FieldAccess::Make(context, pos, std::move(base), (int)i);
            }
        }
    }
    if (baseType.matches(*context.fTypes.fSkCaps)) {
        return Setting::Convert(context, pos, field);
    }
 
    context.fErrors->error(pos, "type '" + baseType.displayName() +
                                "' does not have a field named '" + std::string(field) + "'");
    return nullptr;
}

◆ description()

std::string SkSL::FieldAccess::description ( OperatorPrecedence ) const

overridevirtual

Implements SkSL::Expression.

Definition at line 116 of file SkSLFieldAccess.cpp.

                                                           {
    std::string f = this->base()->description(OperatorPrecedence::kPostfix);
    if (!f.empty()) {
        f.push_back('.');
    }
    return f + std::string(this->base()->type().fields()[this->fieldIndex()].fName);
}

◆ fieldIndex()

int SkSL::FieldAccess::fieldIndex ( ) const

inline

Definition at line 73 of file SkSLFieldAccess.h.

                           {
        return fFieldIndex;
    }

◆ initialSlot()

size_t SkSL::FieldAccess::initialSlot ( ) const

Definition at line 105 of file SkSLFieldAccess.cpp.

                                      {
    SkSpan<const Field> fields = this->base()->type().fields();
    const int fieldIndex = this->fieldIndex();
 
    size_t slot = 0;
    for (int index = 0; index < fieldIndex; ++index) {
        slot += fields[index].fType->slotCount();
    }
    return slot;
}

◆ Make()

std::unique_ptr< Expression > SkSL::FieldAccess::Make	(	const Context &	context,
		Position	pos,
		std::unique_ptr< Expression >	base,
		int	fieldIndex,
		OwnerKind	ownerKind = `OwnerKind::kDefault`
	)

static

Definition at line 84 of file SkSLFieldAccess.cpp.

                                                                   {
    SkASSERT(base->type().isStruct());
    SkASSERT(fieldIndex >= 0);
    SkASSERT(fieldIndex < (int)base->type().fields().size());
 
    // Replace `knownStruct.field` with the field's value if there are no side-effects involved.
    const Expression* expr = ConstantFolder::GetConstantValueForVariable(*base);
    if (expr->is<ConstructorStruct>()) {
        if (std::unique_ptr<Expression> field = extract_field(pos, expr->as<ConstructorStruct>(),
                                                              fieldIndex)) {
            return field;
        }
    }
 
    return std::make_unique<FieldAccess>(pos, std::move(base), fieldIndex, ownerKind);
}

◆ ownerKind()

OwnerKind SkSL::FieldAccess::ownerKind ( ) const

inline

Definition at line 77 of file SkSLFieldAccess.h.

                                {
        return fOwnerKind;
    }

Member Data Documentation

◆ kIRNodeKind

constexpr Kind SkSL::FieldAccess::kIRNodeKind = Kind::kFieldAccess

inlinestaticconstexpr

Definition at line 43 of file SkSLFieldAccess.h.

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

third_party/skia/src/sksl/ir/SkSLFieldAccess.h
third_party/skia/src/sksl/ir/SkSLFieldAccess.cpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ OwnerKind

Constructor & Destructor Documentation

◆ FieldAccess()

Member Function Documentation

◆ base() [1/2]

◆ base() [2/2]

◆ clone()

◆ Convert()

◆ description()

◆ fieldIndex()

◆ initialSlot()

◆ Make()

◆ ownerKind()

Member Data Documentation

◆ kIRNodeKind