Function ResolveLazy

eval/eval/function_step.cc:305–343

}

absl::StatusOr<ResolveResult> ResolveLazy(
    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;
}

class EagerFunctionStep : public AbstractFunctionStep {
 public: