cel-expr · copybara-service · Jun 10, 2025 · Jun 10, 2025
diff --git a/extensions/BUILD b/extensions/BUILD
@@ -48,11 +48,14 @@ cc_library(
     srcs = ["proto_ext.cc"],
     hdrs = ["proto_ext.h"],
     deps = [
-        "//common:ast",
+        "//common:expr",
+        "//compiler",
+        "//internal:status_macros",
         "//parser:macro",
         "//parser:macro_expr_factory",
         "//parser:macro_registry",
         "//parser:options",
+        "//parser:parser_interface",
         "@com_google_absl//absl/functional:overload",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
@@ -394,7 +397,11 @@ cc_library(
     hdrs = ["sets_functions.h"],
     deps = [
         "//base:function_adapter",
+        "//checker:type_checker_builder",
+        "//common:decl",
+        "//common:type",
         "//common:value",
+        "//compiler",
         "//internal:status_macros",
         "//runtime:function_registry",
         "//runtime:runtime_options",
@@ -410,15 +417,21 @@ cc_test(
     srcs = ["sets_functions_test.cc"],
     deps = [
         ":sets_functions",
+        "//checker:standard_library",
+        "//checker:validation_result",
+        "//common:ast_proto",
+        "//common:minimal_descriptor_pool",
+        "//compiler:compiler_factory",
         "//eval/public:activation",
         "//eval/public:builtin_func_registrar",
         "//eval/public:cel_expr_builder_factory",
         "//eval/public:cel_expression",
         "//eval/public:cel_function_adapter",
         "//eval/public:cel_options",
+        "//eval/public:cel_value",
         "//internal:testing",
-        "//parser",
         "//runtime:runtime_options",
+        "@com_google_absl//absl/status:status_matchers",
         "@com_google_cel_spec//proto/cel/expr:syntax_cc_proto",
         "@com_google_protobuf//:protobuf",
     ],

diff --git a/extensions/math_ext_decls.cc b/extensions/math_ext_decls.cc
@@ -83,25 +83,32 @@ absl::Status AddMinMaxDecls(TypeCheckerBuilder& builder) {
   max_decl.set_name("math.@max");
 
   for (const Type& type : kNumerics) {
+    // Unary overloads
     CEL_RETURN_IF_ERROR(min_decl.AddOverload(MakeOverloadDecl(
         absl::StrCat(kMinOverloadPrefix, OverloadTypeName(type)), type, type)));
 
     CEL_RETURN_IF_ERROR(max_decl.AddOverload(MakeOverloadDecl(
         absl::StrCat(kMaxOverloadPrefix, OverloadTypeName(type)), type, type)));
 
+    // Pairwise overloads
     for (const Type& other_type : kNumerics) {
+      Type out_type = DynType();
+      if (type.kind() == other_type.kind()) {
+        out_type = type;
+      }
       CEL_RETURN_IF_ERROR(min_decl.AddOverload(MakeOverloadDecl(
           absl::StrCat(kMinOverloadPrefix, OverloadTypeName(type), "_",
                        OverloadTypeName(other_type)),
-          DynType(), type, other_type)));
+          out_type, type, other_type)));
 
       CEL_RETURN_IF_ERROR(max_decl.AddOverload(MakeOverloadDecl(
           absl::StrCat(kMaxOverloadPrefix, OverloadTypeName(type), "_",
                        OverloadTypeName(other_type)),
-          DynType(), type, other_type)));
+          out_type, type, other_type)));
     }
   }
 
+  // List overloads
   for (const Type& type : kListNumerics) {
     CEL_RETURN_IF_ERROR(min_decl.AddOverload(MakeOverloadDecl(
         absl::StrCat(kMinOverloadPrefix, OverloadTypeName(type)),

diff --git a/extensions/proto_ext.cc b/extensions/proto_ext.cc
@@ -19,14 +19,18 @@
 #include <vector>
 
 #include "absl/functional/overload.h"
+#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
 #include "absl/types/variant.h"
-#include "common/ast.h"
+#include "common/expr.h"
+#include "compiler/compiler.h"
+#include "internal/status_macros.h"
 #include "parser/macro.h"
 #include "parser/macro_expr_factory.h"
+#include "parser/parser_interface.h"
 
 namespace cel::extensions {
 
@@ -76,6 +80,13 @@ bool IsExtensionCall(const Expr& target) {
   return false;
 }
 
+absl::Status ConfigureParser(ParserBuilder& builder) {
+  for (const auto& macro : proto_macros()) {
+    CEL_RETURN_IF_ERROR(builder.AddMacro(macro));
+  }
+  return absl::OkStatus();
+}
+
 }  // namespace
 
 std::vector<Macro> proto_macros() {
@@ -110,4 +121,8 @@ std::vector<Macro> proto_macros() {
   return {*hasExt, *getExt};
 }
 
+CompilerLibrary ProtoExtCompilerLibrary() {
+  return CompilerLibrary("cel.lib.ext.proto", ConfigureParser);
+}
+
 }  // namespace cel::extensions
diff --git a/extensions/proto_ext.h b/extensions/proto_ext.h
@@ -18,6 +18,7 @@
 #include <vector>
 
 #include "absl/status/status.h"
+#include "compiler/compiler.h"
 #include "parser/macro.h"
 #include "parser/macro_registry.h"
 #include "parser/options.h"
@@ -28,6 +29,9 @@ namespace cel::extensions {
 // objects in CEL. Specifically, the proto.getExt() and proto.hasExt() macros.
 std::vector<Macro> proto_macros();
 
+// Library for the proto extensions.
+CompilerLibrary ProtoExtCompilerLibrary();
+
 inline absl::Status RegisterProtoMacros(MacroRegistry& registry,
                                         const ParserOptions&) {
   return registry.RegisterMacros(proto_macros());

diff --git a/extensions/sets_functions.cc b/extensions/sets_functions.cc
@@ -18,6 +18,9 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "base/function_adapter.h"
+#include "checker/type_checker_builder.h"
+#include "common/decl.h"
+#include "common/type.h"
 #include "common/value.h"
 #include "internal/status_macros.h"
 #include "runtime/function_registry.h"
@@ -118,8 +121,34 @@ absl::Status RegisterSetsEquivalentFunction(FunctionRegistry& registry) {
                             const ListValue&>::WrapFunction(SetsEquivalent));
 }
 
+absl::Status RegisterSetsDecls(TypeCheckerBuilder& b) {
+  ListType list_t(b.arena(), TypeParamType("T"));
+  CEL_ASSIGN_OR_RETURN(
+      auto decl,
+      MakeFunctionDecl("sets.contains",
+                       MakeOverloadDecl("list_sets_contains_list", BoolType(),
+                                        list_t, list_t)));
+  CEL_RETURN_IF_ERROR(b.AddFunction(decl));
+
+  CEL_ASSIGN_OR_RETURN(
+      decl, MakeFunctionDecl("sets.equivalent",
+                             MakeOverloadDecl("list_sets_equivalent_list",
+                                              BoolType(), list_t, list_t)));
+  CEL_RETURN_IF_ERROR(b.AddFunction(decl));
+
+  CEL_ASSIGN_OR_RETURN(
+      decl, MakeFunctionDecl("sets.intersects",
+                             MakeOverloadDecl("list_sets_intersects_list",
+                                              BoolType(), list_t, list_t)));
+  return b.AddFunction(decl);
+}
+
 }  // namespace
 
+CheckerLibrary SetsCheckerLibrary() {
+  return {.id = "cel.lib.ext.sets", .configure = RegisterSetsDecls};
+}
+
 absl::Status RegisterSetsFunctions(FunctionRegistry& registry,
                                    const RuntimeOptions& options) {
   CEL_RETURN_IF_ERROR(RegisterSetsContainsFunction(registry));

diff --git a/extensions/sets_functions.h b/extensions/sets_functions.h
@@ -16,11 +16,20 @@
 #define THIRD_PARTY_CEL_CPP_EXTENSIONS_SETS_FUNCTIONS_H_
 
 #include "absl/status/status.h"
+#include "checker/type_checker_builder.h"
+#include "compiler/compiler.h"
 #include "runtime/function_registry.h"
 #include "runtime/runtime_options.h"
 
 namespace cel::extensions {
 
+// Declarations for the sets functions.
+CheckerLibrary SetsCheckerLibrary();
+
+inline CompilerLibrary SetsCompilerLibrary() {
+  return CompilerLibrary::FromCheckerLibrary(SetsCheckerLibrary());
+}
+
 // Register set functions.
 absl::Status RegisterSetsFunctions(FunctionRegistry& registry,
                                    const RuntimeOptions& options);

diff --git a/extensions/sets_functions_test.cc b/extensions/sets_functions_test.cc
@@ -16,27 +16,28 @@
 
 #include <memory>
 #include <string>
-#include <vector>
 
 #include "cel/expr/syntax.pb.h"
+#include "absl/status/status_matchers.h"
+#include "checker/standard_library.h"
+#include "checker/validation_result.h"
+#include "common/ast_proto.h"
+#include "common/minimal_descriptor_pool.h"
+#include "compiler/compiler_factory.h"
 #include "eval/public/activation.h"
 #include "eval/public/builtin_func_registrar.h"
 #include "eval/public/cel_expr_builder_factory.h"
 #include "eval/public/cel_expression.h"
 #include "eval/public/cel_function_adapter.h"
 #include "eval/public/cel_options.h"
+#include "eval/public/cel_value.h"
 #include "internal/testing.h"
-#include "parser/parser.h"
 #include "runtime/runtime_options.h"
 #include "google/protobuf/arena.h"
 
 namespace cel::extensions {
 namespace {
-using ::cel::expr::Expr;
-using ::cel::expr::ParsedExpr;
-using ::cel::expr::SourceInfo;
 
-using ::google::api::expr::parser::ParseWithMacros;
 using ::google::api::expr::runtime::Activation;
 using ::google::api::expr::runtime::CelExpressionBuilder;
 using ::google::api::expr::runtime::CelValue;
@@ -55,13 +56,20 @@ class CelSetsFunctionsTest : public testing::TestWithParam<TestInfo> {};
 
 TEST_P(CelSetsFunctionsTest, EndToEnd) {
   const TestInfo& test_info = GetParam();
-  std::vector<Macro> all_macros = Macro::AllMacros();
-  auto result = ParseWithMacros(test_info.expr, all_macros, "<input>");
-  EXPECT_THAT(result, IsOk());
+  ASSERT_OK_AND_ASSIGN(auto compiler_builder,
+                       NewCompilerBuilder(cel::GetMinimalDescriptorPool()));
 
-  ParsedExpr parsed_expr = *result;
-  Expr expr = parsed_expr.expr();
-  SourceInfo source_info = parsed_expr.source_info();
+  ASSERT_THAT(compiler_builder->AddLibrary(StandardCheckerLibrary()), IsOk());
+  ASSERT_THAT(compiler_builder->AddLibrary(SetsCompilerLibrary()), IsOk());
+  ASSERT_OK_AND_ASSIGN(auto compiler, compiler_builder->Build());
+
+  ASSERT_OK_AND_ASSIGN(ValidationResult compiled,
+                       compiler->Compile(test_info.expr));
+
+  ASSERT_TRUE(compiled.IsValid()) << compiled.FormatError();
+
+  cel::expr::CheckedExpr checked_expr;
+  ASSERT_THAT(AstToCheckedExpr(*compiled.GetAst(), &checked_expr), IsOk());
 
   // Obtain CEL Expression builder.
   InterpreterOptions options;
@@ -76,8 +84,7 @@ TEST_P(CelSetsFunctionsTest, EndToEnd) {
       builder->GetRegistry(), options));
 
   // Create CelExpression from AST (Expr object).
-  ASSERT_OK_AND_ASSIGN(auto cel_expr,
-                       builder->CreateExpression(&expr, &source_info));
+  ASSERT_OK_AND_ASSIGN(auto cel_expr, builder->CreateExpression(&checked_expr));
   Arena arena;
   Activation activation;
   // Run evaluation.