Plan CreateMap

PiperOrigin-RevId: 828705611

Author: l46kok

common/src/main/java/dev/cel/common/ast/CelConstant.java

@@ -207,4 +207,26 @@ public static CelConstant ofObjectValue(Object value) {
 
     throw new IllegalArgumentException("Value is not a CelConstant: " + value);
   }
+
+  /** Gets the underlying value held by this constant. */
+  public Object objectValue() {
+    switch (getKind()) {
+      case NULL_VALUE:
+        return nullValue();
+      case BOOLEAN_VALUE:
+        return booleanValue();
+      case INT64_VALUE:
+        return int64Value();
+      case UINT64_VALUE:
+        return uint64Value();
+      case DOUBLE_VALUE:
+        return doubleValue();
+      case STRING_VALUE:
+        return stringValue();
+      case BYTES_VALUE:
+        return bytesValue();
+      default:
+        throw new IllegalStateException("Unsupported kind: " + getKind());
+    }
+  }
 }

common/src/main/java/dev/cel/common/types/BUILD.bazel

@@ -183,6 +183,20 @@ java_library(
     ],
 )
 
+java_library(
+    name = "default_type_provider",
+    srcs = [
+        "DefaultTypeProvider.java",
+    ],
+    tags = [
+    ],
+    deps = [
+        ":type_providers",
+        ":types",
+        "@maven//:com_google_guava_guava",
+    ],
+)
+
 cel_android_library(
     name = "cel_types_android",
     srcs = ["CelTypes.java"],

common/src/main/java/dev/cel/common/types/DefaultTypeProvider.java

@@ -0,0 +1,52 @@
+// 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.common.types;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableMap;
+import java.util.Optional;
+
+/** {@code DefaultTypeProvider} is a registry of common CEL types. */
+public class DefaultTypeProvider implements CelTypeProvider {
+
+  private static final DefaultTypeProvider INSTANCE = new DefaultTypeProvider();
+  private final ImmutableMap<String, CelType> commonTypes;
+
+  @Override
+  public ImmutableCollection<CelType> types() {
+    return commonTypes.values();
+  }
+
+  @Override
+  public Optional<CelType> findType(String typeName) {
+    return Optional.ofNullable(commonTypes.get(typeName));
+  }
+
+  public static DefaultTypeProvider getInstance() {
+    return INSTANCE;
+  }
+
+  private DefaultTypeProvider() {
+    ImmutableMap.Builder<String, CelType> typeMapBuilder = ImmutableMap.builder();
+    typeMapBuilder.putAll(SimpleType.TYPE_MAP);
+    typeMapBuilder.put("list", ListType.create(SimpleType.DYN));
+    typeMapBuilder.put("map", MapType.create(SimpleType.DYN, SimpleType.DYN));
+    typeMapBuilder.put(
+        "optional_type",
+        // TODO: Move to CelOptionalLibrary and register it on demand
+        OptionalType.create(SimpleType.DYN));
+    this.commonTypes = typeMapBuilder.buildOrThrow();
+  }
+}

common/src/main/java/dev/cel/common/types/SimpleType.java

@@ -44,7 +44,7 @@ public abstract class SimpleType extends CelType {
   public static final CelType TIMESTAMP = create(CelKind.TIMESTAMP, "google.protobuf.Timestamp");
   public static final CelType UINT = create(CelKind.UINT, "uint");
 
-  private static final ImmutableMap<String, CelType> TYPE_MAP =
+  public static final ImmutableMap<String, CelType> TYPE_MAP =
       ImmutableMap.of(
           DYN.name(), DYN,
           BOOL.name(), BOOL,

common/src/main/java/dev/cel/common/values/CelValueConverter.java

@@ -33,15 +33,16 @@
 @SuppressWarnings("unchecked") // Unchecked cast of generics due to type-erasure (ex: MapValue).
 @Internal
 @Immutable
-abstract class CelValueConverter {
+public abstract class CelValueConverter {
 
   /** Adapts a {@link CelValue} to a plain old Java Object. */
   public Object fromCelValueToJavaObject(CelValue celValue) {
     Preconditions.checkNotNull(celValue);
 
     if (celValue instanceof MapValue) {
       MapValue<CelValue, CelValue> mapValue = (MapValue<CelValue, CelValue>) celValue;
-      ImmutableMap.Builder<Object, Object> mapBuilder = ImmutableMap.builder();
+      ImmutableMap.Builder<Object, Object> mapBuilder =
+          ImmutableMap.builderWithExpectedSize(mapValue.size());
       for (Entry<CelValue, CelValue> entry : mapValue.value().entrySet()) {
         Object key = fromCelValueToJavaObject(entry.getKey());
         Object value = fromCelValueToJavaObject(entry.getValue());
@@ -51,7 +52,8 @@ public Object fromCelValueToJavaObject(CelValue celValue) {
       return mapBuilder.buildOrThrow();
     } else if (celValue instanceof ListValue) {
       ListValue<CelValue> listValue = (ListValue<CelValue>) celValue;
-      ImmutableList.Builder<Object> listBuilder = ImmutableList.builder();
+      ImmutableList.Builder<Object> listBuilder =
+          ImmutableList.builderWithExpectedSize(listValue.size());
       for (CelValue element : listValue.value()) {
         listBuilder.add(fromCelValueToJavaObject(element));
       }

common/types/BUILD.bazel

@@ -50,6 +50,12 @@ java_library(
     exports = ["//common/src/main/java/dev/cel/common/types:cel_proto_message_types"],
 )
 
+java_library(
+    name = "default_type_provider",
+    visibility = ["//:internal"],
+    exports = ["//common/src/main/java/dev/cel/common/types:default_type_provider"],
+)
+
 java_library(
     name = "cel_v1alpha1_types",
     visibility = ["//:internal"],

runtime/planner/BUILD.bazel

@@ -0,0 +1,11 @@
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(
+    default_applicable_licenses = ["//:license"],
+    default_visibility = ["//:internal"],
+)
+
+java_library(
+    name = "program_planner",
+    exports = ["//runtime/src/main/java/dev/cel/runtime/planner:program_planner"],
+)

runtime/src/main/java/dev/cel/runtime/planner/Attribute.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.collect.ImmutableList;
+import com.google.errorprone.annotations.Immutable;
+import dev.cel.common.types.CelTypeProvider;
+import dev.cel.common.types.TypeType;
+import dev.cel.runtime.GlobalResolver;
+
+@Immutable
+interface Attribute {
+  Object resolve(GlobalResolver ctx);
+
+  final class MaybeAttribute implements Attribute {
+    private final ImmutableList<Attribute> attributes;
+
+    @Override
+    public Object resolve(GlobalResolver ctx) {
+      for (Attribute attr : attributes) {
+        Object value = attr.resolve(ctx);
+        if (value != null) {
+          return value;
+        }
+      }
+
+      // TODO: Handle unknowns
+      throw new UnsupportedOperationException("Unknown attributes is not supported yet");
+    }
+
+    MaybeAttribute(ImmutableList<Attribute> attributes) {
+      this.attributes = attributes;
+    }
+  }
+
+  final class NamespacedAttribute implements Attribute {
+    private final ImmutableList<String> namespacedNames;
+    private final CelTypeProvider typeProvider;
+
+    @Override
+    public Object resolve(GlobalResolver ctx) {
+      for (String name : namespacedNames) {
+        Object value = ctx.resolve(name);
+        if (value != null) {
+          // TODO: apply qualifiers
+          return value;
+        }
+
+        TypeType type = typeProvider.findType(name).map(TypeType::create).orElse(null);
+        if (type != null) {
+          return type;
+        }
+      }
+
+      // TODO: Handle unknowns
+      throw new UnsupportedOperationException("Unknown attributes is not supported yet");
+    }
+
+    NamespacedAttribute(CelTypeProvider typeProvider, ImmutableList<String> namespacedNames) {
+      this.typeProvider = typeProvider;
+      this.namespacedNames = namespacedNames;
+    }
+  }
+}

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

@@ -0,0 +1,49 @@
+// 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.collect.ImmutableList;
+import com.google.errorprone.annotations.Immutable;
+import dev.cel.common.CelContainer;
+import dev.cel.common.types.CelTypeProvider;
+import dev.cel.runtime.planner.Attribute.MaybeAttribute;
+import dev.cel.runtime.planner.Attribute.NamespacedAttribute;
+
+@Immutable
+final class AttributeFactory {
+
+  private final CelContainer unusedContainer;
+  private final CelTypeProvider typeProvider;
+
+  NamespacedAttribute newAbsoluteAttribute(String... names) {
+    return new NamespacedAttribute(typeProvider, ImmutableList.copyOf(names));
+  }
+
+  MaybeAttribute newMaybeAttribute(String... names) {
+    // TODO: Resolve container names
+    return new MaybeAttribute(
+        ImmutableList.of(new NamespacedAttribute(typeProvider, ImmutableList.copyOf(names))));
+  }
+
+  static AttributeFactory newAttributeFactory(
+      CelContainer celContainer, CelTypeProvider typeProvider) {
+    return new AttributeFactory(celContainer, typeProvider);
+  }
+
+  private AttributeFactory(CelContainer container, CelTypeProvider typeProvider) {
+    this.unusedContainer = container;
+    this.typeProvider = typeProvider;
+  }
+}