Plan CreateMap

PiperOrigin-RevId: 828705611

Author: l46kok

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

@@ -17,6 +17,7 @@ java_library(
         ":eval_attribute",
         ":eval_const",
         ":eval_create_list",
+        ":eval_create_map",
         ":planned_program",
         "//:auto_value",
         "//common:cel_ast",
@@ -104,3 +105,16 @@ java_library(
         "@maven//:com_google_guava_guava",
     ],
 )
+
+java_library(
+    name = "eval_create_map",
+    srcs = ["EvalCreateMap.java"],
+    deps = [
+        "//runtime",
+        "//runtime:evaluation_listener",
+        "//runtime:function_resolver",
+        "//runtime:interpretable",
+        "@maven//:com_google_errorprone_error_prone_annotations",
+        "@maven//:com_google_guava_guava",
+    ],
+)

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

@@ -0,0 +1,77 @@
+// 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 com.google.common.collect.ImmutableMap;
+import com.google.errorprone.annotations.Immutable;
+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;
+
+@Immutable
+final class EvalCreateMap implements Interpretable {
+
+  // Array contents are not mutated
+  @SuppressWarnings("Immutable")
+  private final Interpretable[] keys;
+
+  // Array contents are not mutated
+  @SuppressWarnings("Immutable")
+  private final Interpretable[] values;
+
+  @Override
+  public Object eval(GlobalResolver resolver) throws CelEvaluationException {
+    ImmutableMap.Builder<Object, Object> builder =
+        ImmutableMap.builderWithExpectedSize(keys.length);
+    for (int i = 0; i < keys.length; i++) {
+      builder.put(keys[i].eval(resolver), values[i].eval(resolver));
+    }
+    return builder.buildOrThrow();
+  }
+
+
+  @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 EvalCreateMap create(Interpretable[] keys, Interpretable[] values) {
+    return new EvalCreateMap(keys, values);
+  }
+
+  private EvalCreateMap(Interpretable[] keys, Interpretable[] values) {
+    Preconditions.checkArgument(keys.length == values.length);
+    this.keys = keys;
+    this.values = values;
+  }
+}

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

@@ -24,6 +24,7 @@
 import dev.cel.common.ast.CelConstant;
 import dev.cel.common.ast.CelExpr;
 import dev.cel.common.ast.CelExpr.CelList;
+import dev.cel.common.ast.CelExpr.CelMap;
 import dev.cel.common.ast.CelReference;
 import dev.cel.common.types.CelKind;
 import dev.cel.common.types.CelType;
@@ -69,6 +70,8 @@ private Interpretable plan(CelExpr celExpr, PlannerContext ctx) {
         return planIdent(celExpr, ctx);
       case LIST:
         return planCreateList(celExpr, ctx);
+      case MAP:
+        return planCreateMap(celExpr, ctx);
       case NOT_SET:
         throw new UnsupportedOperationException("Unsupported kind: " + celExpr.getKind());
       default:
@@ -141,6 +144,22 @@ private Interpretable planCreateList(CelExpr celExpr, PlannerContext ctx) {
     return EvalCreateList.create(values);
   }
 
+  private Interpretable planCreateMap(CelExpr celExpr, PlannerContext ctx) {
+    CelMap map = celExpr.map();
+
+    ImmutableList<CelMap.Entry> entries = map.entries();
+    Interpretable[] keys = new Interpretable[entries.size()];
+    Interpretable[] values = new Interpretable[entries.size()];
+
+    for (int i = 0; i < entries.size(); i++) {
+      CelMap.Entry entry = entries.get(i);
+      keys[i] = plan(entry.key(), ctx);
+      values[i] = plan(entry.value(), ctx);
+    }
+
+    return EvalCreateMap.create(keys, values);
+  }
+
   @AutoValue
   abstract static class PlannerContext {
 

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

@@ -124,6 +124,17 @@ public void plan_createList() throws Exception {
     assertThat(result).containsExactly(1L, "foo", true, ImmutableList.of(2L, false)).inOrder();
   }
 
+  @Test
+  @SuppressWarnings("unchecked") // test only
+  public void plan_createMap() throws Exception {
+    CelAbstractSyntaxTree ast = compile("{'foo': 1, true: 'bar'}");
+    Program program = PLANNER.plan(ast);
+
+    ImmutableMap<Object, Object> result = (ImmutableMap<Object, Object>) program.eval();
+
+    assertThat(result).containsExactly("foo", 1L, true, "bar").inOrder();
+  }
+
   @Test
   public void planIdent_typeLiteral(@TestParameter TypeLiteralTestCase testCase) throws Exception {
     if (isParseOnly) {