Introduce versioning for the CEL "strings" extension library.

Tests are added to ensure that each function/macro is only available in the versions it's expected to be in.

PiperOrigin-RevId: 875348651

Author: dmitriplotnikov

checker/optional.cc

@@ -116,7 +116,7 @@ class OptionalOverloads {
   static constexpr char kOptionalMapIndexValue[] = "optional_map_index_value";
 };
 
-absl::Status RegisterOptionalDecls(TypeCheckerBuilder& builder) {
+absl::Status RegisterOptionalDecls(TypeCheckerBuilder& builder, int version) {
   CEL_ASSIGN_OR_RETURN(
       auto of,
       MakeFunctionDecl(OptionalNames::kOptionalOf,
@@ -219,19 +219,26 @@ absl::Status RegisterOptionalDecls(TypeCheckerBuilder& builder) {
   CEL_RETURN_IF_ERROR(builder.AddFunction(std::move(or_value)));
   CEL_RETURN_IF_ERROR(builder.AddFunction(std::move(opt_index)));
   CEL_RETURN_IF_ERROR(builder.AddFunction(std::move(select)));
+  CEL_RETURN_IF_ERROR(builder.MergeFunction(std::move(index)));
+
+  if (version == 0 || version == 1) {
+    return absl::OkStatus();
+  }
+
   CEL_RETURN_IF_ERROR(builder.AddFunction(std::move(first)));
   CEL_RETURN_IF_ERROR(builder.AddFunction(std::move(last)));
-  CEL_RETURN_IF_ERROR(builder.MergeFunction(std::move(index)));
 
   return absl::OkStatus();
 }
 
 }  // namespace
 
-CheckerLibrary OptionalCheckerLibrary() {
+CheckerLibrary OptionalCheckerLibrary(int version) {
   return CheckerLibrary({
       "optional",
-      &RegisterOptionalDecls,
+      [version](TypeCheckerBuilder& builder) {
+        return RegisterOptionalDecls(builder, version);
+      },
   });
 }
 

checker/optional.h

@@ -19,8 +19,11 @@
 
 namespace cel {
 
+constexpr int kOptionalExtensionLatestVersion = 2;
+
 // Library for CEL optional definitions.
-CheckerLibrary OptionalCheckerLibrary();
+CheckerLibrary OptionalCheckerLibrary(
+    int version = kOptionalExtensionLatestVersion);
 
 }  // namespace cel
 

compiler/BUILD

@@ -105,6 +105,8 @@ cc_test(
         ":compiler",
         ":compiler_factory",
         ":optional",
+        ":standard_library",
+        "//checker:optional",
         "//checker:standard_library",
         "//checker:type_check_issue",
         "//checker:validation_result",
@@ -114,6 +116,7 @@ cc_test(
         "//internal:testing",
         "//internal:testing_descriptor_pool",
         "//testutil:baseline_tests",
+        "@com_google_absl//absl/algorithm:container",
         "@com_google_absl//absl/status:status_matchers",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",

compiler/optional.cc

@@ -22,15 +22,18 @@
 
 namespace cel {
 
-CompilerLibrary OptionalCompilerLibrary() {
+CompilerLibrary OptionalCompilerLibrary(int version) {
   CompilerLibrary library =
-      CompilerLibrary::FromCheckerLibrary(OptionalCheckerLibrary());
+      CompilerLibrary::FromCheckerLibrary(OptionalCheckerLibrary(version));
 
-  library.configure_parser = [](ParserBuilder& builder) {
+  library.configure_parser = [version](ParserBuilder& builder) {
     builder.GetOptions().enable_optional_syntax = true;
     absl::Status status;
-    status.Update(builder.AddMacro(OptFlatMapMacro()));
     status.Update(builder.AddMacro(OptMapMacro()));
+    if (version == 0) {
+      return status;
+    }
+    status.Update(builder.AddMacro(OptFlatMapMacro()));
     return status;
   };
 

compiler/optional.h

@@ -14,12 +14,14 @@
 #ifndef THIRD_PARTY_CEL_CPP_COMPILER_OPTIONALS_H_
 #define THIRD_PARTY_CEL_CPP_COMPILER_OPTIONALS_H_
 
+#include "checker/optional.h"
 #include "compiler/compiler.h"
 
 namespace cel {
 
 // CompilerLibrary that enables support for CEL optional types.
-CompilerLibrary OptionalCompilerLibrary();
+CompilerLibrary OptionalCompilerLibrary(
+    int version = kOptionalExtensionLatestVersion);
 
 }  // namespace cel
 

compiler/optional_test.cc

@@ -16,12 +16,15 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
+#include "absl/algorithm/container.h"
 #include "absl/status/status_matchers.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
+#include "checker/optional.h"
 #include "checker/standard_library.h"
 #include "checker/type_check_issue.h"
 #include "checker/validation_result.h"
@@ -30,6 +33,7 @@
 #include "common/type.h"
 #include "compiler/compiler.h"
 #include "compiler/compiler_factory.h"
+#include "compiler/standard_library.h"
 #include "internal/testing.h"
 #include "internal/testing_descriptor_pool.h"
 #include "testutil/baseline_tests.h"
@@ -42,6 +46,8 @@ using ::absl_testing::IsOk;
 using ::cel::expr::conformance::proto3::TestAllTypes;
 using ::cel::test::FormatBaselineAst;
 using ::testing::HasSubstr;
+using ::testing::IsEmpty;
+using ::testing::ValuesIn;
 
 struct TestCase {
   std::string expr;
@@ -271,5 +277,108 @@ TEST(OptionalTest, NotEnabled) {
               HasSubstr("undeclared reference to 'optional'"));
 }
 
+struct OptionalExtensionVersionTestCase {
+  std::string expr;
+  std::vector<int> expected_supported_versions;
+};
+
+class OptionalExtensionVersionTest
+    : public ::testing::TestWithParam<OptionalExtensionVersionTestCase> {};
+
+TEST_P(OptionalExtensionVersionTest, OptionalExtensionVersions) {
+  const OptionalExtensionVersionTestCase& test_case = GetParam();
+  for (int version = 0; version <= cel::kOptionalExtensionLatestVersion;
+       ++version) {
+    CompilerLibrary compiler_library = OptionalCompilerLibrary(version);
+
+    CompilerOptions compiler_options;
+    compiler_options.parser_options.enable_optional_syntax = true;
+
+    ASSERT_OK_AND_ASSIGN(
+        std::unique_ptr<CompilerBuilder> builder,
+        cel::NewCompilerBuilder(internal::GetTestingDescriptorPool(),
+                                compiler_options));
+    ASSERT_THAT(builder->AddLibrary(StandardCompilerLibrary()), IsOk());
+    ASSERT_THAT(builder->AddLibrary(std::move(compiler_library)), IsOk());
+
+    ASSERT_OK_AND_ASSIGN(std::unique_ptr<Compiler> compiler, builder->Build());
+    ASSERT_OK_AND_ASSIGN(ValidationResult result,
+                         compiler->Compile(test_case.expr));
+    if (absl::c_contains(test_case.expected_supported_versions, version)) {
+      EXPECT_THAT(result.GetIssues(), IsEmpty())
+          << "Expected no issues for expr: " << test_case.expr
+          << " at version: " << version << " but got: " << result.FormatError();
+    } else {
+      EXPECT_THAT(result.GetIssues(),
+                  Contains(Property(&TypeCheckIssue::message,
+                                    HasSubstr("undeclared reference"))))
+          << "Expected undeclared reference for expr: " << test_case.expr
+          << " at version: " << version;
+    }
+  }
+};
+
+std::vector<OptionalExtensionVersionTestCase>
+CreateOptionalExtensionVersionParams() {
+  return {
+      OptionalExtensionVersionTestCase{
+          .expr = "optional_type",
+          .expected_supported_versions = {0, 1, 2},
+      },
+      OptionalExtensionVersionTestCase{
+          .expr = "optional.of('foo').optMap(x, x)",
+          .expected_supported_versions = {0, 1, 2},
+      },
+      OptionalExtensionVersionTestCase{
+          .expr = "optional.of('foo')",
+          .expected_supported_versions = {0, 1, 2},
+      },
+      OptionalExtensionVersionTestCase{
+          .expr = "optional.ofNonZeroValue(1)",
+          .expected_supported_versions = {0, 1, 2},
+      },
+      OptionalExtensionVersionTestCase{
+          .expr = "optional.of('foo').value()",
+          .expected_supported_versions = {0, 1, 2},
+      },
+      OptionalExtensionVersionTestCase{
+          .expr = "optional.of('foo').hasValue()",
+          .expected_supported_versions = {0, 1, 2},
+      },
+      OptionalExtensionVersionTestCase{
+          .expr = "optional.of(1).or(optional.of(2))",
+          .expected_supported_versions = {0, 1, 2},
+      },
+      OptionalExtensionVersionTestCase{
+          .expr = "optional.of(1).orValue(2)",
+          .expected_supported_versions = {0, 1, 2},
+      },
+      OptionalExtensionVersionTestCase{
+          .expr = "[1, 2, 3][?5]",
+          .expected_supported_versions = {0, 1, 2},
+      },
+      OptionalExtensionVersionTestCase{
+          .expr = "dyn(1).?bar",
+          .expected_supported_versions = {0, 1, 2},
+      },
+      OptionalExtensionVersionTestCase{
+          .expr = "optional.of('foo').optFlatMap(x, optional.of(x))",
+          .expected_supported_versions = {1, 2},
+      },
+      OptionalExtensionVersionTestCase{
+          .expr = "[1, 2, 3].first()",
+          .expected_supported_versions = {2},
+      },
+      OptionalExtensionVersionTestCase{
+          .expr = "[1, 2, 3].last()",
+          .expected_supported_versions = {2},
+      },
+  };
+}
+
+INSTANTIATE_TEST_SUITE_P(OptionalExtensionVersionTest,
+                         OptionalExtensionVersionTest,
+                         ValuesIn(CreateOptionalExtensionVersionParams()));
+
 }  // namespace
 }  // namespace cel

extensions/BUILD

@@ -143,10 +143,14 @@ cc_test(
         ":math_ext_decls",
         ":math_ext_macros",
         "//checker:standard_library",
+        "//checker:type_check_issue",
         "//checker:validation_result",
         "//common:decl",
         "//common:function_descriptor",
+        "//common:type",
+        "//compiler",
         "//compiler:compiler_factory",
+        "//compiler:standard_library",
         "//eval/public:activation",
         "//eval/public:builtin_func_registrar",
         "//eval/public:cel_expr_builder_factory",
@@ -162,6 +166,7 @@ cc_test(
         "//runtime:activation",
         "//runtime:runtime_options",
         "//runtime:standard_runtime_builder_factory",
+        "@com_google_absl//absl/algorithm:container",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:status_matchers",
         "@com_google_absl//absl/strings",
@@ -456,6 +461,7 @@ cc_test(
     srcs = ["lists_functions_test.cc"],
     deps = [
         ":lists_functions",
+        "//checker:type_check_issue",
         "//checker:validation_result",
         "//common:source",
         "//common:value",
@@ -476,6 +482,7 @@ cc_test(
         "//runtime:runtime_builder",
         "//runtime:runtime_options",
         "//runtime:standard_runtime_builder_factory",
+        "@com_google_absl//absl/algorithm:container",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:status_matchers",
         "@com_google_absl//absl/strings:string_view",
@@ -595,11 +602,13 @@ cc_test(
     deps = [
         ":strings",
         "//checker:standard_library",
+        "//checker:type_check_issue",
         "//checker:type_checker_builder",
         "//checker:validation_result",
         "//common:decl",
         "//common:type",
         "//common:value",
+        "//compiler",
         "//compiler:compiler_factory",
         "//compiler:standard_library",
         "//extensions/protobuf:runtime_adapter",
@@ -613,6 +622,7 @@ cc_test(
         "//runtime:runtime_options",
         "//runtime:standard_runtime_builder_factory",
         "//testutil:baseline_tests",
+        "@com_google_absl//absl/algorithm:container",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:status_matchers",
         "@com_google_cel_spec//proto/cel/expr:syntax_cc_proto",