absl::Span<const cel::Value> arguments) {

for (size_t i = 0; i < arguments.size(); i++) {

if (arguments[i]->Is<cel::UnknownValue>() ||

arguments[i]->Is<cel::ErrorValue>()) {

return !descriptor.is_strict();

}

}

return true;

absl::Span<const cel::Value> arguments) {

auto types_size = descriptor.types().size();

if (types_size != arguments.size()) {

return false;

}

for (size_t i = 0; i < types_size; i++) {

const auto& arg = arguments[i];

cel::Kind param_kind = descriptor.types()[i];

if (arg->kind() != param_kind && param_kind != cel::Kind::kAny) {

return false;

}

}

return true;

if (type_name == "int" || type_name == "uint") {

return absl::StrCat(type_name, "64");

}

return std::string(type_name);

std::string call_sig_string = "";

for (size_t i = 0; i < args.size(); i++) {

const auto& arg = args[i];

if (!call_sig_string.empty()) {

absl::StrAppend(&call_sig_string, ", ");

}

absl::StrAppend(

&call_sig_string,

ToLegacyKindName(cel::KindToString(ValueKindToKind(arg->kind()))));

}

return absl::StrCat("(", call_sig_string, ")");

ExecutionFrame* frame, absl::Span<const cel::Value> args,

absl::Span<const AttributeTrail> attrs) {

std::vector<cel::Value> result;

result.reserve(args.size());

for (size_t i = 0; i < args.size(); i++) {

const AttributeTrail& trail = attrs.subspan(i, 1)[0];

if (frame->attribute_utility().CheckForUnknown(trail,

/*use_partial=*/true)) {

result.push_back(

frame->attribute_utility().CreateUnknownSet(trail.attribute()));

} else {

result.push_back(args.at(i));

}

}

return result;

if (!result->Is<cel::ErrorValue>()) {

return false;

}

const auto& status = result.GetError().NativeValue();

if (status.code() != absl::StatusCode::kUnavailable) {

return false;

}

auto payload = status.GetPayload(

cel::runtime_internal::kPayloadUrlUnknownFunctionResult);

return payload.has_value() && payload.value() == "true";

public:

// Constructs FunctionStep that uses overloads specified.

AbstractFunctionStep(const std::string& name, size_t num_arguments,

bool receiver_style, int64_t expr_id)

: ExpressionStepBase(expr_id),

name_(name),

num_arguments_(num_arguments),

receiver_style_(receiver_style) {}

absl::Status Evaluate(ExecutionFrame* frame) const override;

// Handles overload resolution and updating result appropriately.

// Shouldn't update frame state.

//

// A non-ok result is an unrecoverable error, either from an illegal

// evaluation state or forwarded from an extension function. Errors where

// evaluation can reasonably condition are returned in the result as a

// cel::ErrorValue.

absl::StatusOr<Value> DoEvaluate(ExecutionFrame* frame) const;

virtual absl::StatusOr<ResolveResult> ResolveFunction(

absl::Span<const cel::Value> args, const ExecutionFrame* frame) const = 0;

protected:

std::string name_;

size_t num_arguments_;

bool receiver_style_;

const cel::FunctionOverloadReference& overload, int64_t expr_id,

absl::Span<const cel::Value> args, ExecutionFrameBase& frame) {

cel::Function::InvokeContext context(frame.descriptor_pool(),

frame.message_factory(), frame.arena());

if (overload.descriptor.is_contextual()) {

context.set_embedder_context(frame.embedder_context());

}

CEL_ASSIGN_OR_RETURN(Value result,

overload.implementation.Invoke(args, context));

if (frame.unknown_function_results_enabled() &&

IsUnknownFunctionResultError(result)) {

return frame.attribute_utility().CreateUnknownSet(overload.descriptor,

expr_id, args);

}

return result;

absl::Span<const cel::Value> args, bool receiver_style,

ExecutionFrameBase& frame) {

// No matching overloads.

// Such absence can be caused by presence of CelError in arguments.

// To enable behavior of functions that accept CelError( &&, || ), CelErrors

// should be propagated along execution path.

for (size_t i = 0; i < args.size(); i++) {

const auto& arg = args[i];

if (cel::InstanceOf<cel::ErrorValue>(arg)) {

return arg;

}

}

if (frame.unknown_processing_enabled()) {

// Already converted partial unknowns to unknown sets so just merge.

absl::optional<UnknownValue> unknown_set =

frame.attribute_utility().MergeUnknowns(args);

if (unknown_set.has_value()) {

return *unknown_set;

}

}

// If no errors or unknowns in input args, create new CelError for missing

// overload.

std::string signature;

if (receiver_style) {

if (args.empty()) {

// Should not be possible, but return a sensible error in case of logic

// error.

return ErrorValue(

CreateNoMatchingOverloadError(absl::StrCat("().", name, "()")));

}

return ErrorValue(CreateNoMatchingOverloadError(absl::StrCat(

"(",

ToLegacyKindName(cel::KindToString(ValueKindToKind(args[0].kind()))),

").", name, CallArgTypeString(args.subspan(1)))));

}

return cel::ErrorValue(CreateNoMatchingOverloadError(

absl::StrCat(name, CallArgTypeString(args))));

ExecutionFrame* frame) const {

// Create Span object that contains input arguments to the function.

auto input_args = frame->value_stack().GetSpan(num_arguments_);

std::vector<cel::Value> unknowns_args;

// Preprocess args. If an argument is partially unknown, convert it to an

// unknown attribute set.

if (frame->enable_unknowns()) {

auto input_attrs = frame->value_stack().GetAttributeSpan(num_arguments_);

unknowns_args = CheckForPartialUnknowns(frame, input_args, input_attrs);

input_args = absl::MakeConstSpan(unknowns_args);

}

// Derived class resolves to a single function overload or none.

CEL_ASSIGN_OR_RETURN(ResolveResult matched_function,

ResolveFunction(input_args, frame));

// Overload found and is allowed to consume the arguments.

if (matched_function.has_value() &&

ShouldAcceptOverload(matched_function->descriptor, input_args)) {

return Invoke(*matched_function, id(), input_args, *frame);

}

return NoOverloadResult(name_, input_args, receiver_style_, *frame);

if (!frame->value_stack().HasEnough(num_arguments_)) {

return absl::Status(absl::StatusCode::kInternal, "Value stack underflow");

}

// DoEvaluate may return a status for non-recoverable errors (e.g.

// unexpected typing, illegal expression state). Application errors that can

// reasonably be handled as a cel error will appear in the result value.

CEL_ASSIGN_OR_RETURN(auto result, DoEvaluate(frame));

frame->value_stack().PopAndPush(num_arguments_, std::move(result));

return absl::OkStatus();

absl::Span<const cel::Value> input_args,

absl::Span<const cel::FunctionOverloadReference> overloads) {

ResolveResult result = absl::nullopt;

for (const auto& overload : overloads) {

if (ArgumentKindsMatch(overload.descriptor, input_args)) {

// More than one overload matches our arguments.

if (result.has_value()) {

return absl::Status(absl::StatusCode::kInternal,

"Cannot resolve overloads");

}

result.emplace(overload);

}

}

return result;

absl::Span<const cel::Value> input_args, absl::string_view name,

bool receiver_style,

absl::Span<const cel::FunctionRegistry::LazyOverload> providers,

const ExecutionFrameBase& frame) {

ResolveResult result = absl::nullopt;

std::vector<cel::Kind> arg_types(input_args.size());

std::transform(

input_args.begin(), input_args.end(), arg_types.begin(),

[](const cel::Value& value) { return ValueKindToKind(value->kind()); });

cel::FunctionDescriptor matcher{name, receiver_style, arg_types};

const cel::ActivationInterface& activation = frame.activation();

for (auto provider : providers) {

// The LazyFunctionStep has so far only resolved by function shape, check

// that the runtime argument kinds agree with the specific descriptor for

// the provider candidates.

if (!ArgumentKindsMatch(provider.descriptor, input_args)) {

continue;

}

CEL_ASSIGN_OR_RETURN(auto overload,

provider.provider.GetFunction(matcher, activation));

if (overload.has_value()) {

// More than one overload matches our arguments.

if (result.has_value()) {

return absl::Status(absl::StatusCode::kInternal,

"Cannot resolve overloads");

}

result.emplace(overload.value());

}

}

return result;

public:

EagerFunctionStep(std::vector<cel::FunctionOverloadReference> overloads,

const std::string& name, size_t num_args,

bool receiver_style, int64_t expr_id)

: AbstractFunctionStep(name, num_args, receiver_style, expr_id),

overloads_(std::move(overloads)) {}

absl::StatusOr<ResolveResult> ResolveFunction(

absl::Span<const cel::Value> input_args,

const ExecutionFrame* frame) const override {

return ResolveStatic(input_args, overloads_);

}

private:

std::vector<cel::FunctionOverloadReference> overloads_;

public:

// Constructs LazyFunctionStep that attempts to lookup function implementation

// at runtime.

LazyFunctionStep(const std::string& name, size_t num_args,

bool receiver_style,

std::vector<cel::FunctionRegistry::LazyOverload> providers,

int64_t expr_id)

: AbstractFunctionStep(name, num_args, receiver_style, expr_id),

providers_(std::move(providers)) {}

absl::StatusOr<ResolveResult> ResolveFunction(

absl::Span<const cel::Value> input_args,

const ExecutionFrame* frame) const override;

private:

std::vector<cel::FunctionRegistry::LazyOverload> providers_;

absl::Span<const cel::Value> input_args,

const ExecutionFrame* frame) const {

return ResolveLazy(input_args, name_, receiver_style_, providers_, *frame);

public:

explicit StaticResolver(std::vector<cel::FunctionOverloadReference> overloads)

: overloads_(std::move(overloads)) {}

absl::StatusOr<ResolveResult> Resolve(ExecutionFrameBase& frame,

absl::Span<const Value> input) const {

return ResolveStatic(input, overloads_);

}

private:

std::vector<cel::FunctionOverloadReference> overloads_;

public:

explicit LazyResolver(

std::vector<cel::FunctionRegistry::LazyOverload> providers,

std::string name, bool receiver_style)

: providers_(std::move(providers)),

name_(std::move(name)),

receiver_style_(receiver_style) {}

absl::StatusOr<ResolveResult> Resolve(ExecutionFrameBase& frame,

absl::Span<const Value> input) const {

return ResolveLazy(input, name_, receiver_style_, providers_, frame);

}

private:

std::vector<cel::FunctionRegistry::LazyOverload> providers_;

std::string name_;

bool receiver_style_;

public:

DirectFunctionStepImpl(

int64_t expr_id, const std::string& name,

std::vector<std::unique_ptr<DirectExpressionStep>> arg_steps,

bool receiver_style, Resolver&& resolver)

: DirectExpressionStep(expr_id),

name_(name),

arg_steps_(std::move(arg_steps)),

receiver_style_(receiver_style),

resolver_(std::forward<Resolver>(resolver)) {}

absl::Status Evaluate(ExecutionFrameBase& frame, cel::Value& result,

AttributeTrail& trail) const override {

absl::InlinedVector<Value, 2> args;

absl::InlinedVector<AttributeTrail, 2> arg_trails;

args.resize(arg_steps_.size());

arg_trails.resize(arg_steps_.size());

for (size_t i = 0; i < arg_steps_.size(); i++) {

CEL_RETURN_IF_ERROR(

arg_steps_[i]->Evaluate(frame, args[i], arg_trails[i]));

}

if (frame.unknown_processing_enabled()) {

for (size_t i = 0; i < arg_trails.size(); i++) {

if (frame.attribute_utility().CheckForUnknown(arg_trails[i],

/*use_partial=*/true)) {

args[i] = frame.attribute_utility().CreateUnknownSet(

arg_trails[i].attribute());

}

}

}

CEL_ASSIGN_OR_RETURN(ResolveResult resolved_function,

resolver_.Resolve(frame, args));

if (resolved_function.has_value() &&

ShouldAcceptOverload(resolved_function->descriptor, args)) {

CEL_ASSIGN_OR_RETURN(result,

Invoke(*resolved_function, expr_id_, args, frame));

return absl::OkStatus();

}

result = NoOverloadResult(name_, args, receiver_style_, frame);

return absl::OkStatus();

}

absl::optional<std::vector<const DirectExpressionStep*>> GetDependencies()

const override {

std::vector<const DirectExpressionStep*> dependencies;

dependencies.reserve(arg_steps_.size());

for (const auto& arg_step : arg_steps_) {

dependencies.push_back(arg_step.get());

}

return dependencies;

}

absl::optional<std::vector<std::unique_ptr<DirectExpressionStep>>>

ExtractDependencies() override {

return std::move(arg_steps_);

}

private:

friend Resolver;

std::string name_;

std::vector<std::unique_ptr<DirectExpressionStep>> arg_steps_;

bool receiver_style_;

Resolver resolver_;

int64_t expr_id, const cel::CallExpr& call,

std::vector<std::unique_ptr<DirectExpressionStep>> deps,

std::vector<cel::FunctionOverloadReference> overloads) {

return std::make_unique<DirectFunctionStepImpl<StaticResolver>>(

expr_id, call.function(), std::move(deps), call.has_target(),

StaticResolver(std::move(overloads)));

int64_t expr_id, const cel::CallExpr& call,

std::vector<std::unique_ptr<DirectExpressionStep>> deps,

std::vector<cel::FunctionRegistry::LazyOverload> providers) {

return std::make_unique<DirectFunctionStepImpl<LazyResolver>>(

expr_id, call.function(), std::move(deps), call.has_target(),

LazyResolver(std::move(providers), call.function(), call.has_target()));

const cel::CallExpr& call_expr, int64_t expr_id,

std::vector<cel::FunctionRegistry::LazyOverload> lazy_overloads) {

bool receiver_style = call_expr.has_target();

size_t num_args = call_expr.args().size() + (receiver_style ? 1 : 0);

const std::string& name = call_expr.function();

return std::make_unique<LazyFunctionStep>(name, num_args, receiver_style,

std::move(lazy_overloads), expr_id);

const cel::CallExpr& call_expr, int64_t expr_id,

std::vector<cel::FunctionOverloadReference> overloads) {

bool receiver_style = call_expr.has_target();

size_t num_args = call_expr.args().size() + (receiver_style ? 1 : 0);

const std::string& name = call_expr.function();

return std::make_unique<EagerFunctionStep>(std::move(overloads), name,

num_args, receiver_style, expr_id);