Plan specialized call for Conditional

PiperOrigin-RevId: 839399795

Author: l46kok

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

@@ -16,6 +16,7 @@ java_library(
         ":attribute",
         ":eval_and",
         ":eval_attribute",
+        ":eval_conditional",
         ":eval_const",
         ":eval_create_list",
         ":eval_create_map",
@@ -168,6 +169,18 @@ java_library(
     ],
 )
 
+java_library(
+    name = "eval_conditional",
+    srcs = ["EvalConditional.java"],
+    deps = [
+        "//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"],
@@ -188,7 +201,7 @@ java_library(
     name = "eval_create_list",
     srcs = ["EvalCreateList.java"],
     deps = [
-        "//runtime",
+        "//runtime:evaluation_exception",
         "//runtime:evaluation_listener",
         "//runtime:function_resolver",
         "//runtime:interpretable",
@@ -201,7 +214,7 @@ java_library(
     name = "eval_create_map",
     srcs = ["EvalCreateMap.java"],
     deps = [
-        "//runtime",
+        "//runtime:evaluation_exception",
         "//runtime:evaluation_listener",
         "//runtime:function_resolver",
         "//runtime:interpretable",

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

@@ -0,0 +1,78 @@
+// 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 com.google.common.base.Preconditions;
+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 EvalConditional implements Interpretable {
+
+  @SuppressWarnings("Immutable")
+  private final Interpretable[] args;
+
+  @Override
+  public Object eval(GlobalResolver resolver) throws CelEvaluationException {
+    Interpretable condition = args[0];
+    Interpretable truthy = args[1];
+    Interpretable falsy = args[2];
+    // TODO: Handle unknowns
+    Object condResult = condition.eval(resolver);
+    if (!(condResult instanceof Boolean)) {
+      throw new IllegalArgumentException(
+          String.format("Expected boolean value, found :%s", condResult));
+    }
+
+    // TODO: Handle exhaustive eval
+    if ((boolean) condResult) {
+      return truthy.eval(resolver);
+    }
+
+    return falsy.eval(resolver);
+  }
+
+  @Override
+  public Object eval(GlobalResolver resolver, CelEvaluationListener listener) {
+    // TODO: Implement support
+    throw new UnsupportedOperationException("Not yet supported");
+  }
+
+  @Override
+  public Object eval(GlobalResolver resolver, CelFunctionResolver lateBoundFunctionResolver) {
+    // TODO: Implement support
+    throw new UnsupportedOperationException("Not yet supported");
+  }
+
+  @Override
+  public Object eval(
+      GlobalResolver resolver,
+      CelFunctionResolver lateBoundFunctionResolver,
+      CelEvaluationListener listener) {
+    // TODO: Implement support
+    throw new UnsupportedOperationException("Not yet supported");
+  }
+
+  static EvalConditional create(Interpretable[] args) {
+    return new EvalConditional(args);
+  }
+
+  private EvalConditional(Interpretable[] args) {
+    Preconditions.checkArgument(args.length == 3);
+    this.args = args;
+  }
+}

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

@@ -177,6 +177,8 @@ private Interpretable planCall(CelExpr expr, PlannerContext ctx) {
           return EvalOr.create(evaluatedArgs);
         case LOGICAL_AND:
           return EvalAnd.create(evaluatedArgs);
+        case CONDITIONAL:
+          return EvalConditional.create(evaluatedArgs);
         default:
           // fall-through
       }

runtime/src/test/java/dev/cel/runtime/planner/ProgramPlannerTest.java

@@ -526,6 +526,35 @@ public void plan_call_logicalAnd_throws(String expression) throws Exception {
     assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.DIVIDE_BY_ZERO);
   }
 
+  @Test
+  @TestParameters("{expression: 'false ? (1 / 0) > 2 : false', expectedResult: false}")
+  @TestParameters("{expression: 'false ? (1 / 0) > 2 : true', expectedResult: true}")
+  @TestParameters("{expression: 'true ? false : (1 / 0) > 2', expectedResult: false}")
+  @TestParameters("{expression: 'true ? true : (1 / 0) > 2', expectedResult: true}")
+  public void plan_call_conditional_shortCircuit(String expression, boolean expectedResult)
+      throws Exception {
+    CelAbstractSyntaxTree ast = compile(expression);
+    Program program = PLANNER.plan(ast);
+
+    boolean result = (boolean) program.eval();
+
+    assertThat(result).isEqualTo(expectedResult);
+  }
+
+  @Test
+  @TestParameters("{expression: '(1 / 0) > 2 ? true : true'}")
+  @TestParameters("{expression: 'true ? (1 / 0) > 2 : true'}")
+  @TestParameters("{expression: 'false ? true : (1 / 0) > 2'}")
+  public void plan_call_conditional_throws(String expression) throws Exception {
+    CelAbstractSyntaxTree ast = compile(expression);
+    Program program = PLANNER.plan(ast);
+
+    CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval);
+    assertThat(e).hasMessageThat().isEqualTo("evaluation error: / by zero");
+    assertThat(e).hasCauseThat().isInstanceOf(ArithmeticException.class);
+    assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.DIVIDE_BY_ZERO);
+  }
+
   private CelAbstractSyntaxTree compile(String expression) throws Exception {
     CelAbstractSyntaxTree ast = CEL_COMPILER.parse(expression).getAst();
     if (isParseOnly) {