Method DoEvaluate

eval/eval/create_list_step.cc:71–122

}

absl::Status CreateListStep::DoEvaluate(ExecutionFrame* frame,
                                        Value* result) const {
  auto args = frame->value_stack().GetSpan(list_size_);

  for (const auto& arg : args) {
    if (arg.IsError()) {
      *result = arg;
      return absl::OkStatus();
    }
  }

  if (frame->enable_unknowns()) {
    absl::optional<UnknownValue> unknown_set =
        frame->attribute_utility().IdentifyAndMergeUnknowns(
            args, frame->value_stack().GetAttributeSpan(list_size_),
            /*use_partial=*/true);
    if (unknown_set.has_value()) {
      *result = std::move(*unknown_set);
      return absl::OkStatus();
    }
  }

  ListValueBuilderPtr builder = NewListValueBuilder(frame->arena());
  builder->Reserve(args.size());

  for (size_t i = 0; i < args.size(); ++i) {
    const auto& arg = args[i];
    if (optional_indices_.contains(static_cast<int32_t>(i))) {
      if (auto optional_arg = arg.AsOptional(); optional_arg) {
        if (!optional_arg->HasValue()) {
          continue;
        }
        Value optional_arg_value;
        optional_arg->Value(&optional_arg_value);
        if (optional_arg_value.IsError()) {
          // Error should never be in optional, but better safe than sorry.
          *result = std::move(optional_arg_value);
          return absl::OkStatus();
        }
        CEL_RETURN_IF_ERROR(builder->Add(std::move(optional_arg_value)));
      } else {
        *result = cel::TypeConversionError(arg.GetTypeName(), "optional_type");
        return absl::OkStatus();
      }
    } else {
      CEL_RETURN_IF_ERROR(builder->Add(arg));
    }
  }

  *result = std::move(*builder).Build();
  return absl::OkStatus();
}

absl::flat_hash_set<int32_t> MakeOptionalIndicesSet(
    const cel::ListExpr& create_list_expr) {