Plan map creation

Author: l46kok

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

@@ -17,6 +17,7 @@ java_library(
         ":eval_and",
         ":eval_attribute",
         ":eval_const",
+        ":eval_create_map",
         ":eval_create_struct",
         ":eval_or",
         ":eval_unary",
@@ -216,6 +217,22 @@ java_library(
     ],
 )
 
+java_library(
+    name = "eval_create_map",
+    srcs = ["EvalCreateMap.java"],
+    deps = [
+        ":attribute",
+        ":cel_value_interpretable",
+        "//common/values",
+        "//common/values:cel_value",
+        "//common/values:cel_value_provider",
+        "//runtime:evaluation_exception",
+        "//runtime:interpretable",
+        "@maven//:com_google_errorprone_error_prone_annotations",
+        "@maven//:com_google_guava_guava",
+    ],
+)
+
 java_library(
     name = "eval_helpers",
     srcs = ["EvalHelpers.java"],

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

@@ -0,0 +1,43 @@
+package dev.cel.runtime.planner;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.annotations.Immutable;
+import dev.cel.common.values.CelValue;
+import dev.cel.common.values.ImmutableMapValue;
+import dev.cel.runtime.CelEvaluationException;
+import dev.cel.runtime.GlobalResolver;
+
+@Immutable
+final class EvalCreateMap implements CelValueInterpretable {
+
+
+  @SuppressWarnings("Immutable")
+  private final CelValueInterpretable[] keys;
+
+  @SuppressWarnings("Immutable")
+  private final CelValueInterpretable[] values;
+
+  @Override
+  public CelValue eval(GlobalResolver resolver) throws CelEvaluationException {
+    ImmutableMap.Builder<CelValue, CelValue> builder = ImmutableMap.builder();
+    for (int i = 0; i < keys.length; i++) {
+      builder.put(keys[i].eval(resolver), values[i].eval(resolver));
+    }
+    return ImmutableMapValue.create(builder.build());
+  }
+
+  static EvalCreateMap create(
+      CelValueInterpretable[] keys,
+      CelValueInterpretable[] values
+  ) {
+    return new EvalCreateMap(keys, values);
+  }
+
+  private EvalCreateMap(
+      CelValueInterpretable[] keys,
+      CelValueInterpretable[] values
+  ) {
+    this.keys = keys;
+    this.values = values;
+  }
+}

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

@@ -8,24 +8,27 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Map.Entry;
 
 @Immutable
 final class EvalCreateStruct implements CelValueInterpretable {
 
   private final CelValueProvider valueProvider;
   private final String typeName;
 
-  // Regular hashmap used for performance. Planner must not mutate the map post-construction.
+
+  @SuppressWarnings("Immutable")
+  private final String[] keys;
+
   @SuppressWarnings("Immutable")
-  private final Map<String, CelValueInterpretable> fields;
+  private final CelValueInterpretable[] values;
+
 
   @Override
   public CelValue eval(GlobalResolver resolver) throws CelEvaluationException {
     Map<String, Object> fieldValues = new HashMap<>();
-    for (Entry<String, CelValueInterpretable> entry : fields.entrySet()) {
-      Object value = entry.getValue().eval(resolver).value();
-      fieldValues.put(entry.getKey(), value);
+    for (int i = 0; i < keys.length; i++) {
+      Object value = values[i].eval(resolver).value();
+      fieldValues.put(keys[i], value);
     }
 
     return valueProvider.newValue(typeName, Collections.unmodifiableMap(fieldValues))
@@ -35,18 +38,21 @@ public CelValue eval(GlobalResolver resolver) throws CelEvaluationException {
   static EvalCreateStruct create(
       CelValueProvider valueProvider,
       String typeName,
-      Map<String, CelValueInterpretable> fields
+      String[] keys,
+      CelValueInterpretable[] values
   ) {
-    return new EvalCreateStruct(valueProvider, typeName, fields);
+    return new EvalCreateStruct(valueProvider, typeName, keys, values);
   }
 
   private EvalCreateStruct(
       CelValueProvider valueProvider,
       String typeName,
-      Map<String, CelValueInterpretable> fields
+      String[] keys,
+      CelValueInterpretable[] values
   ) {
     this.valueProvider = valueProvider;
     this.typeName = typeName;
-    this.fields = fields;
+    this.keys = keys;
+    this.values = values;
   }
 }

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

@@ -10,6 +10,7 @@
 import dev.cel.common.ast.CelConstant;
 import dev.cel.common.ast.CelExpr;
 import dev.cel.common.ast.CelExpr.CelCall;
+import dev.cel.common.ast.CelExpr.CelMap;
 import dev.cel.common.ast.CelExpr.CelStruct;
 import dev.cel.common.ast.CelExpr.CelStruct.Entry;
 import dev.cel.common.ast.CelReference;
@@ -24,8 +25,8 @@
 import dev.cel.runtime.CelLiteRuntime.Program;
 import dev.cel.runtime.DefaultDispatcher;
 
-import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.NoSuchElementException;
 import java.util.Optional;
 
@@ -54,16 +55,16 @@ private CelValueInterpretable plan(
       case LIST:
         break;
       case STRUCT:
-        return planCreateObject(celExpr, ctx);
+        return planCreateStruct(celExpr, ctx);
       case MAP:
-        break;
+        return planCreateMap(celExpr, ctx);
       case COMPREHENSION:
         break;
       case NOT_SET:
         throw new UnsupportedOperationException("Unsupported kind: " + celExpr.getKind());
     }
 
-    throw new IllegalArgumentException("foo");
+    throw new IllegalArgumentException("Not yet implemented");
   }
 
   private CelValueInterpretable planIdent(
@@ -149,20 +150,39 @@ private CelValueInterpretable planCall(CelExpr expr, PlannerContext ctx) {
     }
   }
 
-  private CelValueInterpretable planCreateObject(CelExpr celExpr, PlannerContext ctx) {
+  private CelValueInterpretable planCreateStruct(CelExpr celExpr, PlannerContext ctx) {
     CelStruct struct = celExpr.struct();
-    // TODO: maybe do this via type provider?
+    // TODO: maybe perform the check via type provider?
     valueProvider.newValue(struct.messageName(), new HashMap<>())
         .orElseThrow(() -> new IllegalArgumentException("Undefined type name: " + struct.messageName()));
 
-    HashMap<String, CelValueInterpretable> fieldMap = new HashMap<>();
-    for (Entry entry : struct.entries()) {
-      CelValueInterpretable value = plan(entry.value(), ctx);
-      fieldMap.put(entry.fieldKey(), value);
+    List<Entry> entries = struct.entries();
+    String[] keys = new String[entries.size()];
+    CelValueInterpretable[] values = new CelValueInterpretable[entries.size()];
+
+    for (int i = 0; i < entries.size(); i++) {
+      Entry entry = entries.get(i);
+      keys[i] = entry.fieldKey();
+      values[i] = plan(entry.value(), ctx);
+    }
+
+    return EvalCreateStruct.create(valueProvider, struct.messageName(), keys, values);
+  }
+
+  private CelValueInterpretable planCreateMap(CelExpr celExpr, PlannerContext ctx) {
+    CelMap map = celExpr.map();
+
+    List<CelMap.Entry> entries = map.entries();
+    CelValueInterpretable[] keys = new CelValueInterpretable[entries.size()];
+    CelValueInterpretable[] values = new CelValueInterpretable[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 EvalCreateStruct.create(valueProvider, struct.messageName(),
-        Collections.unmodifiableMap(fieldMap));
+    return EvalCreateMap.create(keys, values);
   }
 
   /**

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

@@ -52,6 +52,7 @@
 import java.nio.charset.StandardCharsets;
 
 import dev.cel.runtime.DefaultDispatcher;
+import java.util.Map;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -211,7 +212,7 @@ public void planIdent_variable() throws Exception {
   }
 
   @Test
-  public void planCreateObject() throws Exception {
+  public void planCreateStruct() throws Exception {
     CelAbstractSyntaxTree ast = compile("cel.expr.conformance.proto3.TestAllTypes{}");
     Program program = PLANNER.plan(ast);
 
@@ -221,13 +222,27 @@ public void planCreateObject() throws Exception {
   }
 
   @Test
-  public void planCreateObject_withFields() throws Exception {
-    CelAbstractSyntaxTree ast = compile("cel.expr.conformance.proto3.TestAllTypes{single_string: 'foo'}");
+  public void planCreateStruct_withFields() throws Exception {
+    CelAbstractSyntaxTree ast = compile("cel.expr.conformance.proto3.TestAllTypes{"
+        + "single_string: 'foo',"
+        + "single_bool: true"
+        + "}");
     Program program = PLANNER.plan(ast);
 
     Object result = program.eval();
 
-    assertThat(result).isEqualTo(TestAllTypes.newBuilder().setSingleString("foo").build());
+    assertThat(result).isEqualTo(TestAllTypes.newBuilder().setSingleString("foo").setSingleBool(true).build());
+  }
+
+  @Test
+  public void planCreateMap() throws Exception {
+    CelAbstractSyntaxTree ast = compile("{'foo': 1, true: 'bar'}");
+
+    Program program = PLANNER.plan(ast);
+
+    Map<Object, Object> result = (Map<Object, Object>) program.eval();
+
+    assertThat(result).containsExactly("foo", 1L, true, "bar").inOrder();
   }
 
   @SuppressWarnings("ImmutableEnumChecker") // Test only