SkSL::FunctionCall Class Reference

#include <SkSLFunctionCall.h>

Inheritance diagram for SkSL::FunctionCall:

Public Member Functions
	FunctionCall (Position pos, const Type *type, const FunctionDeclaration *function, ExpressionArray arguments)
const FunctionDeclaration &	function () const
ExpressionArray &	arguments ()
const ExpressionArray &	arguments () const
std::unique_ptr< Expression >	clone (Position pos) const override
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, const FunctionDeclaration &function, ExpressionArray arguments)
static std::unique_ptr< Expression >	Convert (const Context &context, Position pos, std::unique_ptr< Expression > functionValue, ExpressionArray arguments)
static std::unique_ptr< Expression >	Make (const Context &context, Position pos, const Type *returnType, const FunctionDeclaration &function, ExpressionArray arguments)
static const FunctionDeclaration *	FindBestFunctionForCall (const Context &context, const FunctionDeclaration *overloads, const ExpressionArray &arguments)
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::kFunctionCall

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

A function invocation.

Definition at line 31 of file SkSLFunctionCall.h.

Constructor & Destructor Documentation

FunctionCall()

SkSL::FunctionCall::FunctionCall ( Position  pos, const Type *  type, const FunctionDeclaration *  function, ExpressionArray  arguments  )

inline

Definition at line 35 of file SkSLFunctionCall.h.

        : INHERITED(pos, kIRNodeKind, type)
        , fFunction(*function)
        , fArguments(std::move(arguments)) {}

Member Function Documentation

arguments() [1/2]

ExpressionArray & SkSL::FunctionCall::arguments ( )

inline

Definition at line 68 of file SkSLFunctionCall.h.

                                 {
        return fArguments;
    }

arguments() [2/2]

const ExpressionArray & SkSL::FunctionCall::arguments ( ) const

inline

Definition at line 72 of file SkSLFunctionCall.h.

                                             {
        return fArguments;
    }

clone()

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

overridevirtual

Implements SkSL::Expression.

Definition at line 1005 of file SkSLFunctionCall.cpp.

                                                                {
    return std::make_unique<FunctionCall>(pos, &this->type(), &this->function(),
                                          this->arguments().clone());
}

Convert() [1/2]

std::unique_ptr< Expression > SkSL::FunctionCall::Convert ( const Context &  context, Position  pos, const FunctionDeclaration &  function, ExpressionArray  arguments  )

static

Definition at line 1164 of file SkSLFunctionCall.cpp.

                                                                             {
    // Reject ES3 function calls in strict ES2 mode.
    if (context.fConfig->strictES2Mode() && function.modifierFlags().isES3()) {
        context.fErrors->error(pos, "call to '" + function.description() + "' is not supported");
        return nullptr;
    }
 
    // Reject function calls with the wrong number of arguments.
    if (function.parameters().size() != SkToSizeT(arguments.size())) {
        std::string msg = "call to '" + std::string(function.name()) + "' expected " +
                          std::to_string(function.parameters().size()) + " argument";
        if (function.parameters().size() != 1) {
            msg += "s";
        }
        msg += ", but found " + std::to_string(arguments.size());
        context.fErrors->error(pos, msg);
        return nullptr;
    }
 
    // If the arguments do not match the parameter types due to mismatched modifiers, reject the
    // function call.
    for (int i = 0; i < arguments.size(); i++) {
        const Expression& arg = *arguments[i];
        const Variable& param = *function.parameters()[i];
        if (!argument_and_parameter_flags_match(arg, param)) {
            context.fErrors->error(arg.position(), "expected argument of type '" +
                                                   param.layout().paddedDescription() +
                                                   param.modifierFlags().paddedDescription() +
                                                   param.type().description() + "'");
            return nullptr;
        }
    }
 
    // Resolve generic types.
    FunctionDeclaration::ParamTypes types;
    const Type* returnType;
    if (!function.determineFinalTypes(arguments, &types, &returnType)) {
        std::string msg = "no match for " + std::string(function.name()) +
                          build_argument_type_list(arguments);
        context.fErrors->error(pos, msg);
        return nullptr;
    }
 
    for (int i = 0; i < arguments.size(); i++) {
        // Coerce each argument to the proper type.
        arguments[i] = types[i]->coerceExpression(std::move(arguments[i]), context);
        if (!arguments[i]) {
            return nullptr;
        }
        // Update the refKind on out-parameters, and ensure that they are actually assignable.
        ModifierFlags paramFlags = function.parameters()[i]->modifierFlags();
        if (paramFlags & ModifierFlag::kOut) {
            const VariableRefKind refKind = (paramFlags & ModifierFlag::kIn)
                                                    ? VariableReference::RefKind::kReadWrite
                                                    : VariableReference::RefKind::kPointer;
            if (!Analysis::UpdateVariableRefKind(arguments[i].get(), refKind, context.fErrors)) {
                return nullptr;
            }
        }
    }
 
    if (function.isMain()) {
        context.fErrors->error(pos, "call to 'main' is not allowed");
        return nullptr;
    }
 
    if (function.intrinsicKind() == k_eval_IntrinsicKind) {
        // This is a method call on an effect child. Translate it into a ChildCall, which simplifies
        // handling in the generators and analysis code.
        const Variable& child = *arguments.back()->as<VariableReference>().variable();
        arguments.pop_back();
        return ChildCall::Make(context, pos, returnType, child, std::move(arguments));
    }
 
    return Make(context, pos, returnType, function, std::move(arguments));
}

Convert() [2/2]

std::unique_ptr< Expression > SkSL::FunctionCall::Convert ( const Context &  context, Position  pos, std::unique_ptr< Expression >  functionValue, ExpressionArray  arguments  )

static

Definition at line 1117 of file SkSLFunctionCall.cpp.

                                                                             {
    switch (functionValue->kind()) {
        case Expression::Kind::kTypeReference:
            return Constructor::Convert(context,
                                        pos,
                                        functionValue->as<TypeReference>().value(),
                                        std::move(arguments));
        case Expression::Kind::kFunctionReference: {
            const FunctionReference& ref = functionValue->as<FunctionReference>();
            const FunctionDeclaration* best = FindBestFunctionForCall(context, ref.overloadChain(),
                                                                      arguments);
            if (best) {
                return FunctionCall::Convert(context, pos, *best, std::move(arguments));
            }
            std::string msg = "no match for " + std::string(ref.overloadChain()->name()) +
                              build_argument_type_list(arguments);
            context.fErrors->error(pos, msg);
            return nullptr;
        }
        case Expression::Kind::kMethodReference: {
            MethodReference& ref = functionValue->as<MethodReference>();
            arguments.push_back(std::move(ref.self()));
 
            const FunctionDeclaration* best = FindBestFunctionForCall(context, ref.overloadChain(),
                                                                      arguments);
            if (best) {
                return FunctionCall::Convert(context, pos, *best, std::move(arguments));
            }
            std::string msg =
                    "no match for " + arguments.back()->type().displayName() +
                    "::" + std::string(ref.overloadChain()->name().substr(1)) +
                    build_argument_type_list(SkSpan(arguments).first(arguments.size() - 1));
            context.fErrors->error(pos, msg);
            return nullptr;
        }
        case Expression::Kind::kPoison:
            functionValue->fPosition = pos;
            return functionValue;
        default:
            context.fErrors->error(pos, "not a function");
            return nullptr;
    }
}

description()

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

overridevirtual

Implements SkSL::Expression.

Definition at line 1010 of file SkSLFunctionCall.cpp.

                                                            {
    std::string result = std::string(this->function().name()) + "(";
    auto separator = SkSL::String::Separator();
    for (const std::unique_ptr<Expression>& arg : this->arguments()) {
        result += separator();
        result += arg->description(OperatorPrecedence::kSequence);
    }
    result += ")";
    return result;
}

FindBestFunctionForCall()

const FunctionDeclaration * SkSL::FunctionCall::FindBestFunctionForCall ( const Context &  context, const FunctionDeclaration *  overloads, const ExpressionArray &  arguments  )

static

Definition at line 1088 of file SkSLFunctionCall.cpp.

                                          {
    if (!overloadChain->nextOverload()) {
        return overloadChain;
    }
    CoercionCost bestCost = CoercionCost::Impossible();
    const FunctionDeclaration* best = nullptr;
    for (const FunctionDeclaration* f = overloadChain; f != nullptr; f = f->nextOverload()) {
        CoercionCost cost = call_cost(context, *f, arguments);
        if (cost <= bestCost) {
            bestCost = cost;
            best = f;
        }
    }
    return bestCost.fImpossible ? nullptr : best;
}

function()

const FunctionDeclaration & SkSL::FunctionCall::function ( ) const

inline

Definition at line 64 of file SkSLFunctionCall.h.

                                                {
        return fFunction;
    }

Make()

std::unique_ptr< Expression > SkSL::FunctionCall::Make ( const Context &  context, Position  pos, const Type *  returnType, const FunctionDeclaration &  function, ExpressionArray  arguments  )

static

Definition at line 1244 of file SkSLFunctionCall.cpp.

                                                                          {
    SkASSERT(function.parameters().size() == SkToSizeT(arguments.size()));
 
    // We might be able to optimize built-in intrinsics.
    if (function.isIntrinsic() && has_compile_time_constant_arguments(arguments)) {
        // The function is an intrinsic and all inputs are compile-time constants. Optimize it.
        if (std::unique_ptr<Expression> expr = optimize_intrinsic_call(context,
                                                                       pos,
                                                                       function.intrinsicKind(),
                                                                       arguments,
                                                                       *returnType)) {
            expr->fPosition = pos;
            return expr;
        }
    }
 
    return std::make_unique<FunctionCall>(pos, returnType, &function, std::move(arguments));
}

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::FunctionCall::kIRNodeKind = Kind::kFunctionCall

inlinestaticconstexpr

Definition at line 33 of file SkSLFunctionCall.h.

---

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

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