Implement optional.unwrap() and .unwrapOpt() functions.

PiperOrigin-RevId: 721534371

Author: seirl

runtime/BUILD

@@ -546,6 +546,7 @@ cc_library(
         "//runtime/internal:runtime_impl",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
+        "@com_google_absl//absl/strings:str_format",
         "@com_google_absl//absl/strings:string_view",
         "@com_google_absl//absl/types:optional",
     ],

runtime/optional_types.cc

@@ -23,6 +23,7 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "base/function_adapter.h"
@@ -211,6 +212,33 @@ absl::StatusOr<Value> OptionalOptIndexOptionalValue(
   return ErrorValue{runtime_internal::CreateNoMatchingOverloadError("_[?_]")};
 }
 
+absl::StatusOr<Value> ListUnwrapOpt(ValueManager& value_manager,
+                                    const ListValue& list) {
+  CEL_ASSIGN_OR_RETURN(auto builder,
+                       value_manager.NewListValueBuilder(ListType()));
+  CEL_ASSIGN_OR_RETURN(auto list_size, list.Size());
+  builder->Reserve(list_size);
+
+  absl::Status status = list.ForEach(
+      value_manager, [&](const Value& value) -> absl::StatusOr<bool> {
+        if (auto optional_value = value.AsOptional(); optional_value) {
+          if (optional_value->HasValue()) {
+            CEL_RETURN_IF_ERROR(builder->Add(optional_value->Value()));
+          }
+        } else {
+          return absl::InvalidArgumentError(absl::StrFormat(
+              "optional.unwrap() expected a list(optional(T)), but %s "
+              "was found in the list.",
+              value.GetTypeName()));
+        }
+        return true;
+      });
+  if (!status.ok()) {
+    return ErrorValue(status);
+  }
+  return std::move(*builder).Build();
+}
+
 absl::Status RegisterOptionalTypeFunctions(FunctionRegistry& registry,
                                            const RuntimeOptions& options) {
   if (!options.enable_qualified_type_identifiers) {
@@ -274,6 +302,16 @@ absl::Status RegisterOptionalTypeFunctions(FunctionRegistry& registry,
                             Value>::CreateDescriptor("_[?_]", false),
       BinaryFunctionAdapter<absl::StatusOr<Value>, OpaqueValue, Value>::
           WrapFunction(&OptionalOptIndexOptionalValue)));
+  CEL_RETURN_IF_ERROR(registry.Register(
+      UnaryFunctionAdapter<absl::StatusOr<Value>, ListValue>::CreateDescriptor(
+          "optional.unwrap", false),
+      UnaryFunctionAdapter<absl::StatusOr<Value>, ListValue>::WrapFunction(
+          &ListUnwrapOpt)));
+  CEL_RETURN_IF_ERROR(registry.Register(
+      UnaryFunctionAdapter<absl::StatusOr<Value>, ListValue>::CreateDescriptor(
+          "unwrapOpt", true),
+      UnaryFunctionAdapter<absl::StatusOr<Value>, ListValue>::WrapFunction(
+          &ListUnwrapOpt)));
   return absl::OkStatus();
 }
 

runtime/optional_types_test.cc

@@ -271,7 +271,32 @@ INSTANTIATE_TEST_SUITE_P(
             {"optional_orValue_present", "optional.of(1).orValue(2)",
              IntValueIs(1)},
             {"list_of_optional", "[optional.of(1)][0].orValue(1)",
-             IntValueIs(1)}}),
+             IntValueIs(1)},
+            {"list_unwrap_empty", "optional.unwrap([]) == []",
+             BoolValueIs(true)},
+            {"list_unwrap_empty_optional_none",
+             "optional.unwrap([optional.none(), optional.none()]) == []",
+             BoolValueIs(true)},
+            {"list_unwrap_three_elements",
+             "optional.unwrap([optional.of(42), optional.none(), "
+             "optional.of(\"a\")]) == [42, \"a\"]",
+             BoolValueIs(true)},
+            {"list_unwrap_no_none",
+             "optional.unwrap([optional.of(42), optional.of(\"a\")]) == [42, "
+             "\"a\"]",
+             BoolValueIs(true)},
+            {"list_unwrapOpt_empty", "[].unwrapOpt() == []", BoolValueIs(true)},
+            {"list_unwrapOpt_empty_optional_none",
+             "[optional.none(), optional.none()].unwrapOpt() == []",
+             BoolValueIs(true)},
+            {"list_unwrapOpt_three_elements",
+             "[optional.of(42), optional.none(), "
+             "optional.of(\"a\")].unwrapOpt() == [42, \"a\"]",
+             BoolValueIs(true)},
+            {"list_unwrapOpt_no_none",
+             "[optional.of(42), optional.of(\"a\")].unwrapOpt() == [42, \"a\"]",
+             BoolValueIs(true)},
+        }),
         /*enable_short_circuiting*/ testing::Bool()));
 
 class UnreachableFunction final : public cel::Function {