Plan specialized calls for Logical OR/AND

PiperOrigin-RevId: 836484895

Author: l46kok

runtime/src/main/java/dev/cel/runtime/BUILD.bazel

@@ -128,6 +128,7 @@ java_library(
         ":resolved_overload",
         "//:auto_value",
         "//common:error_codes",
+        "//common/annotations",
         "@maven//:com_google_code_findbugs_annotations",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven//:com_google_guava_guava",
@@ -146,6 +147,7 @@ cel_android_library(
         ":resolved_overload_android",
         "//:auto_value",
         "//common:error_codes",
+        "//common/annotations",
         "@maven//:com_google_code_findbugs_annotations",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven_android//:com_google_guava_guava",
@@ -1172,6 +1174,7 @@ java_library(
         ":function_overload",
         ":unknown_attributes",
         "//:auto_value",
+        "//common/annotations",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven//:com_google_guava_guava",
         "@maven//:com_google_protobuf_protobuf_java",
@@ -1187,6 +1190,7 @@ cel_android_library(
         ":function_overload_android",
         ":unknown_attributes_android",
         "//:auto_value",
+        "//common/annotations",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven_android//:com_google_guava_guava",
         "@maven_android//:com_google_protobuf_protobuf_javalite",

runtime/src/main/java/dev/cel/runtime/CelResolvedOverload.java

@@ -18,6 +18,7 @@
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.annotations.Immutable;
 import com.google.protobuf.MessageLite;
+import dev.cel.common.annotations.Internal;
 import java.util.List;
 import java.util.Map;
 
@@ -27,7 +28,8 @@
  */
 @AutoValue
 @Immutable
-abstract class CelResolvedOverload {
+@Internal
+public abstract class CelResolvedOverload {
 
   /** The overload id of the function. */
   public abstract String getOverloadId();
@@ -79,7 +81,14 @@ public static CelResolvedOverload of(
    * Returns true if the overload's expected argument types match the types of the given arguments.
    */
   boolean canHandle(Object[] arguments) {
-    ImmutableList<Class<?>> parameterTypes = getParameterTypes();
+    return canHandle(arguments, getParameterTypes(), isStrict());
+  }
+
+  /**
+   * Returns true if the overload's expected argument types match the types of the given arguments.
+   */
+  public static boolean canHandle(
+      Object[] arguments, ImmutableList<Class<?>> parameterTypes, boolean isStrict) {
     if (parameterTypes.size() != arguments.length) {
       return false;
     }
@@ -99,7 +108,7 @@ boolean canHandle(Object[] arguments) {
 
       if (arg instanceof Exception || arg instanceof CelUnknownSet) {
         // Only non-strict functions can accept errors/unknowns as arguments to a function
-        if (!isStrict()) {
+        if (!isStrict) {
           // Skip assignability check below, but continue to validate remaining args
           continue;
         }

runtime/src/main/java/dev/cel/runtime/DefaultDispatcher.java

@@ -14,6 +14,7 @@
 
 package dev.cel.runtime;
 
+import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.auto.value.AutoBuilder;
@@ -22,17 +23,27 @@
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.errorprone.annotations.Immutable;
 import dev.cel.common.CelErrorCode;
+import dev.cel.common.annotations.Internal;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
-/** Default implementation of dispatcher. */
+/**
+ * Default implementation of dispatcher.
+ *
+ * <p>CEL Library Internals. Do Not Use.
+ */
 @Immutable
-final class DefaultDispatcher implements CelFunctionResolver {
+@Internal
+public final class DefaultDispatcher implements CelFunctionResolver {
 
   private final ImmutableMap<String, CelResolvedOverload> overloads;
 
+  public Optional<CelResolvedOverload> findOverload(String functionName) {
+    return Optional.ofNullable(overloads.get(functionName));
+  }
+
   @Override
   public Optional<CelResolvedOverload> findOverloadMatchingArgs(
       String functionName, List<String> overloadIds, Object[] args) throws CelEvaluationException {
@@ -101,24 +112,26 @@ Optional<CelResolvedOverload> findSingleNonStrictOverload(List<String> overloadI
     return Optional.empty();
   }
 
-  static Builder newBuilder() {
+  public static Builder newBuilder() {
     return new AutoBuilder_DefaultDispatcher_Builder();
   }
 
+  /** Builder for {@link DefaultDispatcher}. */
   @AutoBuilder(ofClass = DefaultDispatcher.class)
-  abstract static class Builder {
+  public abstract static class Builder {
 
     abstract ImmutableMap<String, CelResolvedOverload> overloads();
 
     abstract ImmutableMap.Builder<String, CelResolvedOverload> overloadsBuilder();
 
     @CanIgnoreReturnValue
-    Builder addOverload(
+    public Builder addOverload(
         String overloadId,
         List<Class<?>> argTypes,
         boolean isStrict,
         CelFunctionOverload overload) {
       checkNotNull(overloadId);
+      checkArgument(!overloadId.isEmpty(), "Overload ID cannot be empty.");
       checkNotNull(argTypes);
       checkNotNull(overload);
 
@@ -127,7 +140,7 @@ Builder addOverload(
       return this;
     }
 
-    abstract DefaultDispatcher build();
+    public abstract DefaultDispatcher build();
   }
 
   DefaultDispatcher(ImmutableMap<String, CelResolvedOverload> overloads) {

runtime/src/main/java/dev/cel/runtime/planner/BUILD.bazel

@@ -14,24 +14,32 @@ java_library(
     ],
     deps = [
         ":attribute",
+        ":eval_and",
         ":eval_attribute",
         ":eval_const",
         ":eval_create_list",
         ":eval_create_map",
         ":eval_create_struct",
+        ":eval_or",
+        ":eval_unary",
+        ":eval_var_args_call",
+        ":eval_zero_arity",
         ":planned_program",
         "//:auto_value",
         "//common:cel_ast",
         "//common:container",
+        "//common:operator",
         "//common/annotations",
         "//common/ast",
         "//common/types",
         "//common/types:type_providers",
         "//common/values:cel_value_provider",
+        "//runtime:dispatcher",
         "//runtime:evaluation_exception",
         "//runtime:evaluation_exception_builder",
         "//runtime:interpretable",
         "//runtime:program",
+        "//runtime:resolved_overload",
         "@maven//:com_google_code_findbugs_annotations",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven//:com_google_guava_guava",
@@ -45,6 +53,7 @@ java_library(
         "//:auto_value",
         "//runtime:activation",
         "//runtime:evaluation_exception",
+        "//runtime:evaluation_exception_builder",
         "//runtime:function_resolver",
         "//runtime:interpretable",
         "//runtime:program",
@@ -95,6 +104,70 @@ java_library(
     ],
 )
 
+java_library(
+    name = "eval_zero_arity",
+    srcs = ["EvalZeroArity.java"],
+    deps = [
+        "//runtime:evaluation_exception",
+        "//runtime:evaluation_listener",
+        "//runtime:function_resolver",
+        "//runtime:interpretable",
+        "//runtime:resolved_overload",
+    ],
+)
+
+java_library(
+    name = "eval_unary",
+    srcs = ["EvalUnary.java"],
+    deps = [
+        "//runtime:evaluation_exception",
+        "//runtime:evaluation_listener",
+        "//runtime:function_resolver",
+        "//runtime:interpretable",
+        "//runtime:resolved_overload",
+    ],
+)
+
+java_library(
+    name = "eval_var_args_call",
+    srcs = ["EvalVarArgsCall.java"],
+    deps = [
+        "//runtime:evaluation_exception",
+        "//runtime:evaluation_listener",
+        "//runtime:function_resolver",
+        "//runtime:interpretable",
+        "//runtime:resolved_overload",
+    ],
+)
+
+java_library(
+    name = "eval_or",
+    srcs = ["EvalOr.java"],
+    deps = [
+        ":eval_helpers",
+        "//common/values",
+        "//runtime:evaluation_exception",
+        "//runtime:evaluation_listener",
+        "//runtime:function_resolver",
+        "//runtime:interpretable",
+        "@maven//:com_google_guava_guava",
+    ],
+)
+
+java_library(
+    name = "eval_and",
+    srcs = ["EvalAnd.java"],
+    deps = [
+        ":eval_helpers",
+        "//common/values",
+        "//runtime:evaluation_exception",
+        "//runtime:evaluation_listener",
+        "//runtime:function_resolver",
+        "//runtime:interpretable",
+        "@maven//:com_google_guava_guava",
+    ],
+)
+
 java_library(
     name = "eval_create_struct",
     srcs = ["EvalCreateStruct.java"],
@@ -136,3 +209,12 @@ java_library(
         "@maven//:com_google_guava_guava",
     ],
 )
+
+java_library(
+    name = "eval_helpers",
+    srcs = ["EvalHelpers.java"],
+    deps = [
+        "//common/values",
+        "//runtime:interpretable",
+    ],
+)

runtime/src/main/java/dev/cel/runtime/planner/EvalAnd.java

@@ -0,0 +1,83 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dev.cel.runtime.planner;
+
+import static dev.cel.runtime.planner.EvalHelpers.evalNonstrictly;
+
+import com.google.common.base.Preconditions;
+import dev.cel.common.values.ErrorValue;
+import dev.cel.runtime.CelEvaluationException;
+import dev.cel.runtime.CelEvaluationListener;
+import dev.cel.runtime.CelFunctionResolver;
+import dev.cel.runtime.GlobalResolver;
+import dev.cel.runtime.Interpretable;
+
+final class EvalAnd implements Interpretable {
+
+  @SuppressWarnings("Immutable")
+  private final Interpretable[] args;
+
+  @Override
+  public Object eval(GlobalResolver resolver) {
+    ErrorValue errorValue = null;
+    for (Interpretable arg : args) {
+      Object argVal = evalNonstrictly(arg, resolver);
+      if (argVal instanceof Boolean) {
+        // Short-circuit on false
+        if (!((boolean) argVal)) {
+          return false;
+        }
+      } else if (argVal instanceof ErrorValue) {
+        errorValue = (ErrorValue) argVal;
+      }
+    }
+
+    if (errorValue != null) {
+      return errorValue;
+    }
+
+    return true;
+  }
+
+  @Override
+  public Object eval(GlobalResolver resolver, CelEvaluationListener listener)
+      throws CelEvaluationException {
+    return null;
+  }
+
+  @Override
+  public Object eval(GlobalResolver resolver, CelFunctionResolver lateBoundFunctionResolver)
+      throws CelEvaluationException {
+    return null;
+  }
+
+  @Override
+  public Object eval(
+      GlobalResolver resolver,
+      CelFunctionResolver lateBoundFunctionResolver,
+      CelEvaluationListener listener)
+      throws CelEvaluationException {
+    return null;
+  }
+
+  static EvalAnd create(Interpretable[] args) {
+    return new EvalAnd(args);
+  }
+
+  private EvalAnd(Interpretable[] args) {
+    Preconditions.checkArgument(args.length == 2);
+    this.args = args;
+  }
+}

runtime/src/main/java/dev/cel/runtime/planner/EvalHelpers.java

@@ -0,0 +1,32 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dev.cel.runtime.planner;
+
+import dev.cel.common.values.ErrorValue;
+import dev.cel.runtime.GlobalResolver;
+import dev.cel.runtime.Interpretable;
+
+final class EvalHelpers {
+
+  static Object evalNonstrictly(Interpretable interpretable, GlobalResolver resolver) {
+    try {
+      return interpretable.eval(resolver);
+    } catch (Exception e) {
+      return ErrorValue.create(e);
+    }
+  }
+
+  private EvalHelpers() {}
+}