Support container resolution for calls and struct creation in planner

PiperOrigin-RevId: 838980202

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

@@ -28,6 +28,7 @@
 import dev.cel.common.ast.CelExpr.CelCall;
 import dev.cel.common.ast.CelExpr.CelList;
 import dev.cel.common.ast.CelExpr.CelMap;
+import dev.cel.common.ast.CelExpr.CelSelect;
 import dev.cel.common.ast.CelExpr.CelStruct;
 import dev.cel.common.ast.CelExpr.CelStruct.Entry;
 import dev.cel.common.ast.CelReference;
@@ -58,6 +59,7 @@ public final class ProgramPlanner {
   private final CelValueProvider valueProvider;
   private final DefaultDispatcher dispatcher;
   private final AttributeFactory attributeFactory;
+  private final CelContainer container;
 
   /**
    * Plans a {@link Program} from the provided parsed-only or type-checked {@link
@@ -168,7 +170,6 @@ private Interpretable planCall(CelExpr expr, PlannerContext ctx) {
       evaluatedArgs[argIndex + offset] = plan(args.get(argIndex), ctx);
     }
 
-    // TODO: Handle all specialized calls (logical operators, conditionals, equals etc)
     String functionName = resolvedFunction.functionName();
     Operator operator = Operator.findReverse(functionName).orElse(null);
     if (operator != null) {
@@ -177,6 +178,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
       }
@@ -207,16 +210,7 @@ private Interpretable planCall(CelExpr expr, PlannerContext ctx) {
 
   private Interpretable planCreateStruct(CelExpr celExpr, PlannerContext ctx) {
     CelStruct struct = celExpr.struct();
-    CelType structType =
-        typeProvider
-            .findType(struct.messageName())
-            .orElseThrow(
-                () -> new IllegalArgumentException("Undefined type name: " + struct.messageName()));
-    if (!structType.kind().equals(CelKind.STRUCT)) {
-      throw new IllegalArgumentException(
-          String.format(
-              "Expected struct type for %s, got %s", structType.name(), structType.kind()));
-    }
+    StructType structType = resolveStructType(struct);
 
     ImmutableList<Entry> entries = struct.entries();
     String[] keys = new String[entries.size()];
@@ -228,7 +222,7 @@ private Interpretable planCreateStruct(CelExpr celExpr, PlannerContext ctx) {
       values[i] = plan(entry.value(), ctx);
     }
 
-    return EvalCreateStruct.create(valueProvider, (StructType) structType, keys, values);
+    return EvalCreateStruct.create(valueProvider, structType, keys, values);
   }
 
   private Interpretable planCreateList(CelExpr celExpr, PlannerContext ctx) {
@@ -267,7 +261,7 @@ private Interpretable planCreateMap(CelExpr celExpr, PlannerContext ctx) {
   private ResolvedFunction resolveFunction(
       CelExpr expr, ImmutableMap<Long, CelReference> referenceMap) {
     CelCall call = expr.call();
-    Optional<CelExpr> target = call.target();
+    Optional<CelExpr> maybeTarget = call.target();
     String functionName = call.function();
 
     CelReference reference = referenceMap.get(expr.id());
@@ -279,22 +273,89 @@ private ResolvedFunction resolveFunction(
                 .setFunctionName(functionName)
                 .setOverloadId(reference.overloadIds().get(0));
 
-        target.ifPresent(builder::setTarget);
+        maybeTarget.ifPresent(builder::setTarget);
 
         return builder.build();
       }
     }
 
-    // Parsed-only.
-    // TODO: Handle containers.
-    if (!target.isPresent()) {
+    // Parsed-only function resolution.
+    //
+    // There are two distinct cases we must handle:
+    //
+    // 1. Non-qualified function calls. This will resolve into either:
+    //    - A simple global call foo()
+    //    - A fully qualified global call through normal container resolution foo.bar.qux()
+    // 2. Qualified function calls:
+    //    - A member call on an identifier foo.bar()
+    //    - A fully qualified global call, through normal container resolution or abbreviations
+    //      foo.bar.qux()
+    if (!maybeTarget.isPresent()) {
+      for (String cand : container.resolveCandidateNames(functionName)) {
+        CelResolvedOverload overload = dispatcher.findOverload(cand).orElse(null);
+        if (overload != null) {
+          return ResolvedFunction.newBuilder().setFunctionName(cand).build();
+        }
+      }
+
+      // Normal global call
       return ResolvedFunction.newBuilder().setFunctionName(functionName).build();
-    } else {
-      return ResolvedFunction.newBuilder()
-          .setFunctionName(functionName)
-          .setTarget(target.get())
-          .build();
     }
+
+    CelExpr target = maybeTarget.get();
+    String qualifiedPrefix = toQualifiedName(target).orElse(null);
+    if (qualifiedPrefix != null) {
+      String qualifiedName = qualifiedPrefix + "." + functionName;
+      for (String cand : container.resolveCandidateNames(qualifiedName)) {
+        CelResolvedOverload overload = dispatcher.findOverload(cand).orElse(null);
+        if (overload != null) {
+          return ResolvedFunction.newBuilder().setFunctionName(cand).build();
+        }
+      }
+    }
+
+    // Normal member call
+    return ResolvedFunction.newBuilder().setFunctionName(functionName).setTarget(target).build();
+  }
+
+  private StructType resolveStructType(CelStruct struct) {
+    String messageName = struct.messageName();
+    for (String typeName : container.resolveCandidateNames(messageName)) {
+      CelType structType = typeProvider.findType(typeName).orElse(null);
+      if (structType == null) {
+        continue;
+      }
+
+      if (!structType.kind().equals(CelKind.STRUCT)) {
+        throw new IllegalArgumentException(
+            String.format(
+                "Expected struct type for %s, got %s", structType.name(), structType.kind()));
+      }
+
+      return (StructType) structType;
+    }
+
+    throw new IllegalArgumentException("Undefined type name: " + messageName);
+  }
+
+  /** Converts a given expression into a qualified name, if possible. */
+  private Optional<String> toQualifiedName(CelExpr operand) {
+    switch (operand.getKind()) {
+      case IDENT:
+        return Optional.of(operand.ident().name());
+      case SELECT:
+        CelSelect select = operand.select();
+        String maybeQualified = toQualifiedName(select.operand()).orElse(null);
+        if (maybeQualified != null) {
+          return Optional.of(maybeQualified + "." + select.field());
+        }
+
+        break;
+      default:
+        // fall-through
+    }
+
+    return Optional.empty();
   }
 
   @AutoValue
@@ -336,17 +397,22 @@ private static PlannerContext create(CelAbstractSyntaxTree ast) {
   }
 
   public static ProgramPlanner newPlanner(
-      CelTypeProvider typeProvider, CelValueProvider valueProvider, DefaultDispatcher dispatcher) {
-    return new ProgramPlanner(typeProvider, valueProvider, dispatcher);
+      CelTypeProvider typeProvider,
+      CelValueProvider valueProvider,
+      DefaultDispatcher dispatcher,
+      CelContainer container) {
+    return new ProgramPlanner(typeProvider, valueProvider, dispatcher, container);
   }
 
   private ProgramPlanner(
-      CelTypeProvider typeProvider, CelValueProvider valueProvider, DefaultDispatcher dispatcher) {
+      CelTypeProvider typeProvider,
+      CelValueProvider valueProvider,
+      DefaultDispatcher dispatcher,
+      CelContainer container) {
     this.typeProvider = typeProvider;
     this.valueProvider = valueProvider;
-    // TODO: Container support
     this.dispatcher = dispatcher;
-    this.attributeFactory =
-        AttributeFactory.newAttributeFactory(CelContainer.newBuilder().build(), typeProvider);
+    this.container = container;
+    this.attributeFactory = AttributeFactory.newAttributeFactory(container, typeProvider);
   }
 }

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

@@ -18,6 +18,7 @@ java_library(
         "//common:cel_descriptor_util",
         "//common:cel_source",
         "//common:compiler_common",
+        "//common:container",
         "//common:error_codes",
         "//common:operator",
         "//common:options",