Support parsed-only evaluation for lists extensions, remove check for heterogeneous equality for sorting

PiperOrigin-RevId: 899285209

Author: l46kok

extensions/src/main/java/dev/cel/extensions/CelListsExtensions.java

@@ -128,15 +128,21 @@ public enum Function {
                 "list_sort",
                 "Sorts a list with comparable elements.",
                 ListType.create(TypeParamType.create("T")),
-                ListType.create(TypeParamType.create("T"))))),
+                ListType.create(TypeParamType.create("T")))),
+        CelFunctionBinding.from(
+            "list_sort", Collection.class, (list) -> sort((Collection<Object>) list))),
     SORT_BY(
         CelFunctionDecl.newFunctionDeclaration(
             "lists.@sortByAssociatedKeys",
             CelOverloadDecl.newGlobalOverload(
                 "list_sortByAssociatedKeys",
                 "Sorts a list by a key value. Used by the 'sortBy' macro",
                 ListType.create(TypeParamType.create("T")),
-                ListType.create(TypeParamType.create("T")))));
+                ListType.create(TypeParamType.create("T")))),
+        CelFunctionBinding.from(
+            "list_sortByAssociatedKeys",
+            Collection.class,
+            (list) -> sortByAssociatedKeys((Collection<List<Object>>) list)));
 
     private final CelFunctionDecl functionDecl;
     private final ImmutableSet<CelFunctionBinding> functionBindings;
@@ -147,7 +153,8 @@ String getFunction() {
 
     Function(CelFunctionDecl functionDecl, CelFunctionBinding... functionBindings) {
       this.functionDecl = functionDecl;
-      this.functionBindings = ImmutableSet.copyOf(functionBindings);
+      this.functionBindings =
+          CelFunctionBinding.fromOverloads(functionDecl.name(), functionBindings);
     }
   }
 
@@ -240,32 +247,13 @@ public void setRuntimeOptions(CelRuntimeBuilder runtimeBuilder) {
   @Override
   public void setRuntimeOptions(
       CelRuntimeBuilder runtimeBuilder, RuntimeEquality runtimeEquality, CelOptions celOptions) {
-    for (Function function : functions) {
-      runtimeBuilder.addFunctionBindings(function.functionBindings);
-      for (CelOverloadDecl overload : function.functionDecl.overloads()) {
-        switch (overload.overloadId()) {
-          case "list_distinct":
-            runtimeBuilder.addFunctionBindings(
-                CelFunctionBinding.from(
-                    "list_distinct", Collection.class, (list) -> distinct(list, runtimeEquality)));
-            break;
-          case "list_sort":
-            runtimeBuilder.addFunctionBindings(
-                CelFunctionBinding.from(
-                    "list_sort", Collection.class, (list) -> sort(list, celOptions)));
-            break;
-          case "list_sortByAssociatedKeys":
-            runtimeBuilder.addFunctionBindings(
-                CelFunctionBinding.from(
-                    "list_sortByAssociatedKeys",
-                    Collection.class,
-                    (list) -> sortByAssociatedKeys(list, celOptions)));
-            break;
-          default:
-            // Nothing to add
-        }
-      }
-    }
+    functions.forEach(function -> runtimeBuilder.addFunctionBindings(function.functionBindings));
+
+    runtimeBuilder.addFunctionBindings(
+        CelFunctionBinding.fromOverloads(
+            "distinct",
+            CelFunctionBinding.from(
+                "list_distinct", Collection.class, (list) -> distinct(list, runtimeEquality))));
   }
 
   private static ImmutableList<Object> slice(Collection<Object> list, long from, long to) {
@@ -369,22 +357,19 @@ private static List<Object> reverse(Collection<Object> list) {
     }
   }
 
-  private static ImmutableList<Object> sort(Collection<Object> objects, CelOptions options) {
+  private static ImmutableList<Object> sort(Collection<Object> objects) {
     return ImmutableList.sortedCopyOf(
-        new CelObjectComparator(options.enableHeterogeneousNumericComparisons()), objects);
+        new CelObjectComparator(), objects);
   }
 
   private static class CelObjectComparator implements Comparator<Object> {
-    private final boolean enableHeterogeneousNumericComparisons;
 
-    CelObjectComparator(boolean enableHeterogeneousNumericComparisons) {
-      this.enableHeterogeneousNumericComparisons = enableHeterogeneousNumericComparisons;
-    }
+    CelObjectComparator() {}
 
     @SuppressWarnings({"unchecked"})
     @Override
     public int compare(Object o1, Object o2) {
-      if (o1 instanceof Number && o2 instanceof Number && enableHeterogeneousNumericComparisons) {
+      if (o1 instanceof Number && o2 instanceof Number) {
         return ComparisonFunctions.numericCompare((Number) o1, (Number) o2);
       }
 
@@ -444,12 +429,12 @@ private static Optional<CelExpr> sortByMacro(
 
   @SuppressWarnings({"unchecked", "rawtypes"})
   private static ImmutableList<Object> sortByAssociatedKeys(
-      Collection<List<Object>> keyValuePairs, CelOptions options) {
+      Collection<List<Object>> keyValuePairs) {
     List<Object>[] array = keyValuePairs.toArray(new List[0]);
     Arrays.sort(
         array,
         new CelObjectByKeyComparator(
-            new CelObjectComparator(options.enableHeterogeneousNumericComparisons())));
+            new CelObjectComparator()));
     ImmutableList.Builder<Object> builder = ImmutableList.builderWithExpectedSize(array.length);
     for (List<Object> pair : array) {
       builder.add(pair.get(1));

extensions/src/test/java/dev/cel/extensions/BUILD.bazel

@@ -40,6 +40,7 @@ java_library(
         "//runtime:lite_runtime_factory",
         "//runtime:partial_vars",
         "//runtime:unknown_attributes",
+        "//testing:cel_runtime_flavor",
         "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto",
         "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto",
         "@cel_spec//proto/cel/expr/conformance/test:simple_java_proto",