Implement bytes() conversion function

PiperOrigin-RevId: 346894277

Author: TristonianJones

conformance/BUILD

@@ -87,8 +87,6 @@ cc_binary(
             # TODO(issues/94): Missing timestamp conversion functions (type / string)
             "--skip_test=timestamps/timestamp_conversions/toType_timestamp,toString_timestamp",
             "--skip_test=timestamps/duration_conversions/toType_duration,toString_duration",
-            # TODO(issues/78): Missing bytes() conversion functions
-            "--skip_test=conversions/bytes",
             # TODO(issues/81): Conversion functions for int(), uint() which can be
             # uncommented when the spec changes to truncation rather than rounding.
             "--skip_test=conversions/int/double_nearest,double_nearest_neg,double_half_away_neg,double_half_away_pos",

eval/public/builtin_func_registrar.cc

@@ -1013,6 +1013,30 @@ absl::Status RegisterTimestampFunctions(CelFunctionRegistry* registry,
   return absl::OkStatus();
 }
 
+absl::Status RegisterBytesConversionFunctions(CelFunctionRegistry* registry,
+                                              const InterpreterOptions&) {
+  // bytes -> bytes
+  auto status = FunctionAdapter<CelValue::BytesHolder, CelValue::BytesHolder>::
+      CreateAndRegister(
+          builtin::kBytes, false,
+          [](Arena*, CelValue::BytesHolder value) -> CelValue::BytesHolder {
+            return value;
+          },
+          registry);
+  if (!status.ok()) return status;
+
+  // string -> bytes
+  status = FunctionAdapter<CelValue, CelValue::StringHolder>::CreateAndRegister(
+      builtin::kBytes, false,
+      [](Arena* arena, CelValue::StringHolder value) -> CelValue {
+        return CelValue::CreateBytesView(value.value());
+      },
+      registry);
+  if (!status.ok()) return status;
+
+  return absl::OkStatus();
+}
+
 absl::Status RegisterDoubleConversionFunctions(CelFunctionRegistry* registry,
                                                const InterpreterOptions&) {
   // double -> double
@@ -1121,6 +1145,8 @@ absl::Status RegisterStringConversionFunctions(
     return absl::OkStatus();
   }
 
+  // TODO(issues/82): ensure the bytes conversion to string handles UTF-8
+  // properly, and avoids unncessary allocations.
   // bytes -> string
   auto status = FunctionAdapter<CelValue::StringHolder, CelValue::BytesHolder>::
       CreateAndRegister(
@@ -1229,7 +1255,10 @@ absl::Status RegisterUintConversionFunctions(CelFunctionRegistry* registry,
 
 absl::Status RegisterConversionFunctions(CelFunctionRegistry* registry,
                                          const InterpreterOptions& options) {
-  auto status = RegisterDoubleConversionFunctions(registry, options);
+  auto status = RegisterBytesConversionFunctions(registry, options);
+  if (!status.ok()) return status;
+
+  status = RegisterDoubleConversionFunctions(registry, options);
   if (!status.ok()) return status;
 
   // duration() conversion from string.

eval/public/builtin_func_test.cc

@@ -121,6 +121,17 @@ class BuiltinsTest : public ::testing::Test {
   }
 
   // Helper method. Looks up in registry and tests Type conversions.
+  void TestTypeConverts(absl::string_view operation, const CelValue& ref,
+                        CelValue::BytesHolder result) {
+    CelValue result_value;
+
+    ASSERT_NO_FATAL_FAILURE(PerformRun(operation, {}, {ref}, &result_value));
+
+    ASSERT_EQ(result_value.IsBytes(), true);
+    ASSERT_EQ(result_value.BytesOrDie(), result)
+        << operation << " for " << CelValue::TypeName(ref.type());
+  }
+
   void TestTypeConverts(absl::string_view operation, const CelValue& ref,
                         double result) {
     CelValue result_value;
@@ -693,6 +704,18 @@ TEST_F(BuiltinsTest, TestTimestampFunctions) {
                 3L);
 }
 
+TEST_F(BuiltinsTest, TestBytesConversions_bytes) {
+  std::string txt = "hello";
+  CelValue::BytesHolder result = CelValue::BytesHolder(&txt);
+  TestTypeConverts(builtin::kBytes, CelValue::CreateBytes(&txt), result);
+}
+
+TEST_F(BuiltinsTest, TestBytesConversions_string) {
+  std::string txt = "hello";
+  CelValue::BytesHolder result = CelValue::BytesHolder(&txt);
+  TestTypeConverts(builtin::kBytes, CelValue::CreateString(&txt), result);
+}
+
 TEST_F(BuiltinsTest, TestDoubleConversions_double) {
   double ref = 100.1;
   TestTypeConverts(builtin::kDouble, CelValue::CreateDouble(ref), 100.1);

eval/public/cel_builtins.h

@@ -71,6 +71,7 @@ constexpr char kMilliseconds[] = "getMilliseconds";
 
 // Type conversions
 // TODO(issues/23): Add other type conversion methods.
+constexpr char kBytes[] = "bytes";
 constexpr char kDouble[] = "double";
 constexpr char kDyn[] = "dyn";
 constexpr char kInt[] = "int";