consumer = LIMIT_HANDLERS.get(limit.name());
+ if (consumer == null) {
+ throw new IllegalArgumentException("Unknown limit: " + limit.name());
+ }
+ consumer.accept(optionsBuilder, value);
+ }
+ return optionsBuilder.build();
+ }
+
private void addAllCompilerExtensions(
CelCompilerBuilder celCompilerBuilder, CelOptions celOptions) {
// TODO: Add capability to accept user defined exceptions
@@ -250,7 +314,9 @@ private void addAllCompilerExtensions(
}
}
- private void addAllRuntimeExtensions(CelRuntimeBuilder celRuntimeBuilder, CelOptions celOptions) {
+ private CelRuntime extendRuntime(CelRuntime celRuntime, CelOptions celOptions) {
+ CelRuntimeBuilder celRuntimeBuilder = celRuntime.toRuntimeBuilder();
+ celRuntimeBuilder.setOptions(celOptions);
// TODO: Add capability to accept user defined exceptions
for (ExtensionConfig extensionConfig : extensions()) {
CanonicalCelExtension extension = getExtensionOrThrow(extensionConfig.name());
@@ -262,6 +328,7 @@ private void addAllRuntimeExtensions(CelRuntimeBuilder celRuntimeBuilder, CelOpt
celRuntimeBuilder.addLibraries(celRuntimeLibrary);
}
}
+ return celRuntimeBuilder.build();
}
private void applyStandardLibrarySubset(CelCompilerBuilder compilerBuilder) {
@@ -605,6 +672,10 @@ public CelType toCelType(CelTypeProvider celTypeProvider) {
return TypeParamType.create(name());
}
+ if (name().equals("dyn")) {
+ return SimpleType.DYN;
+ }
+
CelType simpleType = SimpleType.findByName(name()).orElse(null);
if (simpleType != null) {
return simpleType;
@@ -625,6 +696,39 @@ public CelType toCelType(CelTypeProvider celTypeProvider) {
}
}
+ /** Represents a feature flag that can be enabled in the environment. */
+ @AutoValue
+ public abstract static class FeatureFlag {
+ /** Normalized name of the feature flag. */
+ public abstract String name();
+
+ /** Whether the feature is enabled or disabled. */
+ public abstract boolean enabled();
+
+ public static FeatureFlag create(String name, boolean enabled) {
+ return new AutoValue_CelEnvironment_FeatureFlag(name, enabled);
+ }
+ }
+
+ /**
+ * Represents a configurable limit in the environment.
+ *
+ * A negative value indicates no limit. If not specified, the limit should be set to the
+ * library default.
+ */
+ @AutoValue
+ public abstract static class Limit {
+ /** Normalized name of the limit (e.g. cel.limit.expression_code_points */
+ public abstract String name();
+
+ /** The value of the limit, -1 means no limit. */
+ public abstract int value();
+
+ public static Limit create(String name, int value) {
+ return new AutoValue_CelEnvironment_Limit(name, value);
+ }
+ }
+
/**
* Represents a configuration for a canonical CEL extension that can be enabled in the
* environment.
@@ -683,6 +787,38 @@ public static ExtensionConfig latest(String name) {
}
}
+ @AutoValue
+ abstract static class Alias {
+ abstract String alias();
+
+ abstract String qualifiedName();
+
+ static Builder newBuilder() {
+ return new AutoValue_CelEnvironment_Alias.Builder();
+ }
+
+ @AutoValue.Builder
+ abstract static class Builder implements RequiredFieldsChecker {
+
+ abstract Optional alias();
+
+ abstract Optional qualifiedName();
+
+ abstract Builder setAlias(String alias);
+
+ abstract Builder setQualifiedName(String qualifiedName);
+
+ abstract Alias build();
+
+ @Override
+ public ImmutableList requiredFields() {
+ return ImmutableList.of(
+ RequiredField.of("alias", this::alias),
+ RequiredField.of("qualified_name", this::qualifiedName));
+ }
+ }
+ }
+
@VisibleForTesting
enum CanonicalCelExtension {
BINDINGS((options, version) -> CelExtensions.bindings()),
@@ -916,4 +1052,9 @@ public static OverloadSelector.Builder newBuilder() {
}
}
}
+
+ @FunctionalInterface
+ private static interface BooleanOptionConsumer {
+ void accept(CelOptions.Builder options, boolean value);
+ }
}
diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentExporter.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentExporter.java
index d303e0528..f86787090 100644
--- a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentExporter.java
+++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentExporter.java
@@ -22,6 +22,7 @@
import dev.cel.expr.Decl.FunctionDecl;
import dev.cel.expr.Decl.FunctionDecl.Overload;
import com.google.auto.value.AutoValue;
+import com.google.common.base.Preconditions;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ListMultimap;
@@ -30,6 +31,7 @@
import dev.cel.bundle.CelEnvironment.LibrarySubset;
import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector;
import dev.cel.bundle.CelEnvironment.OverloadDecl;
+import dev.cel.checker.CelCheckerBuilder;
import dev.cel.checker.CelStandardDeclarations.StandardFunction;
import dev.cel.checker.CelStandardDeclarations.StandardIdentifier;
import dev.cel.common.CelFunctionDecl;
@@ -41,6 +43,7 @@
import dev.cel.common.types.CelProtoTypes;
import dev.cel.common.types.CelType;
import dev.cel.common.types.CelTypes;
+import dev.cel.compiler.CelCompiler;
import dev.cel.extensions.CelExtensionLibrary;
import dev.cel.extensions.CelExtensions;
import dev.cel.parser.CelMacro;
@@ -161,6 +164,24 @@ public static CelEnvironmentExporter.Builder newBuilder() {
*
*/
public CelEnvironment export(Cel cel) {
+ return export((CelCompiler) cel);
+ }
+
+ /**
+ * Exports a {@link CelEnvironment} that describes the configuration of the given {@link
+ * CelCompiler} instance.
+ *
+ * The exported environment includes:
+ *
+ *
+ * Standard library subset: functions and their overloads that are either included or
+ * excluded from the standard library.
+ * Extension libraries: names and versions of the extension libraries that are used.
+ * Custom declarations: functions and variables that are not part of the standard library or
+ * any of the extension libraries.
+ *
+ */
+ public CelEnvironment export(CelCompiler cel) {
// Inventory is a full set of declarations and macros that are found in the configuration of
// the supplied CEL instance.
//
@@ -169,21 +190,62 @@ public CelEnvironment export(Cel cel) {
//
// Whatever is left will be included in the Environment as custom declarations.
+ // Checker builder is used to access some parts of the config not exposed in the EnvVisitable
+ // interface.
+ CelCheckerBuilder checkerBuilder = cel.toCheckerBuilder();
+
+ CelEnvironment.Builder envBuilder =
+ CelEnvironment.newBuilder().setContainer(checkerBuilder.container());
+ addOptions(envBuilder, checkerBuilder.options());
+
Set inventory = new HashSet<>();
collectInventory(inventory, cel);
-
- CelEnvironment.Builder envBuilder = CelEnvironment.newBuilder();
addExtensionConfigsAndRemoveFromInventory(envBuilder, inventory);
addStandardLibrarySubsetAndRemoveFromInventory(envBuilder, inventory);
addCustomDecls(envBuilder, inventory);
return envBuilder.build();
}
+ private void addOptions(CelEnvironment.Builder envBuilder, CelOptions options) {
+ // The set of features supported in the exported environment in Go is pretty limited right now.
+ ImmutableSet.Builder featureFlags = ImmutableSet.builder();
+ if (options.enableHeterogeneousNumericComparisons()) {
+ featureFlags.add(
+ CelEnvironment.FeatureFlag.create("cel.feature.cross_type_numeric_comparisons", true));
+ }
+ if (options.enableQuotedIdentifierSyntax()) {
+ featureFlags.add(
+ CelEnvironment.FeatureFlag.create("cel.feature.backtick_escape_syntax", true));
+ }
+ if (options.populateMacroCalls()) {
+ featureFlags.add(CelEnvironment.FeatureFlag.create("cel.feature.macro_call_tracking", true));
+ }
+ envBuilder.setFeatures(featureFlags.build());
+ ImmutableSet.Builder limits = ImmutableSet.builder();
+ if (options.maxExpressionCodePointSize() != CelOptions.DEFAULT.maxExpressionCodePointSize()) {
+ limits.add(
+ CelEnvironment.Limit.create(
+ "cel.limit.expression_code_points", options.maxExpressionCodePointSize()));
+ }
+ if (options.maxParseErrorRecoveryLimit() != CelOptions.DEFAULT.maxParseErrorRecoveryLimit()) {
+ limits.add(
+ CelEnvironment.Limit.create(
+ "cel.limit.parse_error_recovery", options.maxParseErrorRecoveryLimit()));
+ }
+ if (options.maxParseRecursionDepth() != CelOptions.DEFAULT.maxParseRecursionDepth()) {
+ limits.add(
+ CelEnvironment.Limit.create(
+ "cel.limit.parse_recursion_depth", options.maxParseRecursionDepth()));
+ }
+ envBuilder.setLimits(limits.build());
+ }
+
/**
* Collects all function overloads, variable declarations and macros from the given {@link Cel}
* instance and stores them in a map.
*/
- private void collectInventory(Set inventory, Cel cel) {
+ private void collectInventory(Set inventory, CelCompiler cel) {
+ Preconditions.checkArgument(cel instanceof EnvVisitable);
((EnvVisitable) cel)
.accept(
new EnvVisitor() {
diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlParser.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlParser.java
index 3acb73fa5..ce8857654 100644
--- a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlParser.java
+++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlParser.java
@@ -27,6 +27,7 @@
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import dev.cel.bundle.CelEnvironment.Alias;
import dev.cel.bundle.CelEnvironment.ExtensionConfig;
import dev.cel.bundle.CelEnvironment.FunctionDecl;
import dev.cel.bundle.CelEnvironment.LibrarySubset;
@@ -35,12 +36,14 @@
import dev.cel.bundle.CelEnvironment.OverloadDecl;
import dev.cel.bundle.CelEnvironment.TypeDecl;
import dev.cel.bundle.CelEnvironment.VariableDecl;
+import dev.cel.common.CelContainer;
import dev.cel.common.CelIssue;
import dev.cel.common.formats.CelFileSource;
import dev.cel.common.formats.ParserContext;
import dev.cel.common.formats.YamlHelper.YamlNodeType;
import dev.cel.common.formats.YamlParserContextImpl;
import dev.cel.common.internal.CelCodePointArray;
+import java.util.Optional;
import org.jspecify.annotations.Nullable;
import org.yaml.snakeyaml.DumperOptions.FlowStyle;
import org.yaml.snakeyaml.nodes.MappingNode;
@@ -64,6 +67,8 @@ public final class CelEnvironmentYamlParser {
private static final ExtensionConfig ERROR_EXTENSION_DECL = ExtensionConfig.of(ERROR);
private static final FunctionSelector ERROR_FUNCTION_SELECTOR =
FunctionSelector.create(ERROR, ImmutableSet.of());
+ private static final Alias ERROR_ALIAS =
+ Alias.newBuilder().setAlias(ERROR).setQualifiedName(ERROR).build();
/** Generates a new instance of {@code CelEnvironmentYamlParser}. */
public static CelEnvironmentYamlParser newInstance() {
@@ -88,6 +93,233 @@ public CelEnvironment parse(String environmentYamlSource, String description)
return parser.parseYaml(environmentYamlSource, description);
}
+ private CelContainer parseContainer(ParserContext ctx, Node node) {
+ long valueId = ctx.collectMetadata(node);
+ // Syntax variant 1: "container: `str`"
+ if (validateYamlType(node, YamlNodeType.STRING, YamlNodeType.TEXT)) {
+ return CelContainer.ofName(newString(ctx, node));
+ }
+
+ // Syntax variant 2:
+ // container
+ // name: str
+ // abbreviations:
+ // - a1
+ // - a2
+ // aliases:
+ // - alias: a1
+ // qualified_name: q1
+ // - alias: a2
+ // qualified_name: q2
+ if (!assertYamlType(ctx, valueId, node, YamlNodeType.MAP)) {
+ return CelContainer.ofName(ERROR);
+ }
+
+ CelContainer.Builder builder = CelContainer.newBuilder();
+ MappingNode variableMap = (MappingNode) node;
+ for (NodeTuple nodeTuple : variableMap.getValue()) {
+ Node keyNode = nodeTuple.getKeyNode();
+ long keyId = ctx.collectMetadata(keyNode);
+ Node valueNode = nodeTuple.getValueNode();
+ String keyName = ((ScalarNode) keyNode).getValue();
+ switch (keyName) {
+ case "name":
+ builder.setName(newString(ctx, valueNode));
+ break;
+ case "aliases":
+ ImmutableSet aliases = parseAliases(ctx, valueNode);
+ for (Alias alias : aliases) {
+ builder.addAlias(alias.alias(), alias.qualifiedName());
+ }
+ break;
+ case "abbreviations":
+ builder.addAbbreviations(parseAbbreviations(ctx, valueNode));
+ break;
+ default:
+ ctx.reportError(keyId, String.format("Unsupported container tag: %s", keyName));
+ break;
+ }
+ }
+
+ return builder.build();
+ }
+
+ private ImmutableSet parseFeatures(
+ ParserContext ctx, Node node) {
+ long valueId = ctx.collectMetadata(node);
+ if (!validateYamlType(node, YamlNodeType.LIST, YamlNodeType.TEXT)) {
+ ctx.reportError(valueId, "Unsupported features format");
+ }
+
+ ImmutableSet.Builder featureFlags = ImmutableSet.builder();
+
+ SequenceNode featureListNode = (SequenceNode) node;
+ for (Node featureMapNode : featureListNode.getValue()) {
+ long featureMapId = ctx.collectMetadata(featureMapNode);
+ if (!assertYamlType(ctx, featureMapId, featureMapNode, YamlNodeType.MAP)) {
+ continue;
+ }
+
+ MappingNode featureMap = (MappingNode) featureMapNode;
+ String name = "";
+ boolean enabled = true;
+ for (NodeTuple nodeTuple : featureMap.getValue()) {
+ Node keyNode = nodeTuple.getKeyNode();
+ long keyId = ctx.collectMetadata(keyNode);
+ Node valueNode = nodeTuple.getValueNode();
+ String keyName = ((ScalarNode) keyNode).getValue();
+ switch (keyName) {
+ case "name":
+ name = newString(ctx, valueNode);
+ break;
+ case "enabled":
+ enabled = newBoolean(ctx, valueNode);
+ break;
+ default:
+ ctx.reportError(keyId, String.format("Unsupported feature tag: %s", keyName));
+ break;
+ }
+ }
+ if (name.isEmpty()) {
+ ctx.reportError(featureMapId, "Missing required attribute(s): name");
+ continue;
+ }
+ featureFlags.add(CelEnvironment.FeatureFlag.create(name, enabled));
+ }
+ return featureFlags.build();
+ }
+
+ private ImmutableSet parseLimits(ParserContext ctx, Node node) {
+ long valueId = ctx.collectMetadata(node);
+ if (!validateYamlType(node, YamlNodeType.LIST, YamlNodeType.TEXT)) {
+ ctx.reportError(valueId, "Unsupported limits format");
+ }
+
+ ImmutableSet.Builder limits = ImmutableSet.builder();
+
+ SequenceNode featureListNode = (SequenceNode) node;
+ for (Node featureMapNode : featureListNode.getValue()) {
+ long featureMapId = ctx.collectMetadata(featureMapNode);
+ if (!assertYamlType(ctx, featureMapId, featureMapNode, YamlNodeType.MAP)) {
+ continue;
+ }
+
+ MappingNode featureMap = (MappingNode) featureMapNode;
+ String name = "";
+ Optional value = Optional.empty();
+ // Shorthand syntax for limit: "cel.limit.foo: 1"
+ if (featureMap.getValue().size() == 1) {
+ NodeTuple nodeTuple = featureMap.getValue().get(0);
+ Node keyNode = nodeTuple.getKeyNode();
+ Node valueNode = nodeTuple.getValueNode();
+ String keyName = ((ScalarNode) keyNode).getValue();
+ if (!keyName.equals("name") && !keyName.equals("value")) {
+ limits.add(CelEnvironment.Limit.create(keyName, newInteger(ctx, valueNode)));
+ continue;
+ }
+ // Fall through to check against the long syntax.
+ }
+ // Long syntax for limit:
+ // limits:
+ // - name: cel.limit.foo
+ // value: 1
+ for (NodeTuple nodeTuple : featureMap.getValue()) {
+ Node keyNode = nodeTuple.getKeyNode();
+ long keyId = ctx.collectMetadata(keyNode);
+ Node valueNode = nodeTuple.getValueNode();
+ String keyName = ((ScalarNode) keyNode).getValue();
+ switch (keyName) {
+ case "name":
+ name = newString(ctx, valueNode);
+ break;
+ case "value":
+ value = Optional.of(newInteger(ctx, valueNode));
+ break;
+ default:
+ ctx.reportError(keyId, String.format("Unsupported limits tag: %s", keyName));
+ break;
+ }
+ }
+ if (name.isEmpty()) {
+ ctx.reportError(featureMapId, "Missing required attribute(s): name");
+ continue;
+ }
+ if (!value.isPresent()) {
+ ctx.reportError(featureMapId, "Missing required attribute(s): value");
+ continue;
+ }
+ limits.add(CelEnvironment.Limit.create(name, value.get()));
+ }
+ return limits.build();
+ }
+
+ private ImmutableSet parseAliases(ParserContext ctx, Node node) {
+ ImmutableSet.Builder aliasSetBuilder = ImmutableSet.builder();
+ long valueId = ctx.collectMetadata(node);
+ if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) {
+ return aliasSetBuilder.build();
+ }
+
+ SequenceNode variableListNode = (SequenceNode) node;
+ for (Node elementNode : variableListNode.getValue()) {
+ aliasSetBuilder.add(parseAlias(ctx, elementNode));
+ }
+
+ return aliasSetBuilder.build();
+ }
+
+ private Alias parseAlias(ParserContext ctx, Node node) {
+ long id = ctx.collectMetadata(node);
+ if (!assertYamlType(ctx, id, node, YamlNodeType.MAP)) {
+ return ERROR_ALIAS;
+ }
+
+ Alias.Builder builder = Alias.newBuilder();
+ MappingNode attrMap = (MappingNode) node;
+ for (NodeTuple nodeTuple : attrMap.getValue()) {
+ Node keyNode = nodeTuple.getKeyNode();
+ long keyId = ctx.collectMetadata(keyNode);
+ Node valueNode = nodeTuple.getValueNode();
+ String keyName = ((ScalarNode) keyNode).getValue();
+ switch (keyName) {
+ case "alias":
+ builder.setAlias(newString(ctx, valueNode));
+ break;
+ case "qualified_name":
+ builder.setQualifiedName(newString(ctx, valueNode));
+ break;
+ default:
+ ctx.reportError(keyId, String.format("Unsupported alias tag: %s", keyName));
+ break;
+ }
+ }
+
+ if (!assertRequiredFields(ctx, id, builder.getMissingRequiredFieldNames())) {
+ return ERROR_ALIAS;
+ }
+
+ return builder.build();
+ }
+
+ private ImmutableSet parseAbbreviations(ParserContext ctx, Node node) {
+ long valueId = ctx.collectMetadata(node);
+ if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) {
+ return ImmutableSet.of(ERROR);
+ }
+
+ ImmutableSet.Builder builder = ImmutableSet.builder();
+ SequenceNode nameListNode = (SequenceNode) node;
+ for (Node elementNode : nameListNode.getValue()) {
+ long elementId = ctx.collectMetadata(elementNode);
+ if (!assertYamlType(ctx, elementId, elementNode, YamlNodeType.STRING)) {
+ return ImmutableSet.of(ERROR);
+ }
+
+ builder.add(((ScalarNode) elementNode).getValue());
+ }
+ return builder.build();
+ }
+
private ImmutableSet parseVariables(ParserContext ctx, Node node) {
long valueId = ctx.collectMetadata(node);
ImmutableSet.Builder variableSetBuilder = ImmutableSet.builder();
@@ -620,7 +852,7 @@ private CelEnvironment.Builder parseConfig(ParserContext ctx, Node node) {
builder.setDescription(newString(ctx, valueNode));
break;
case "container":
- builder.setContainer(newString(ctx, valueNode));
+ builder.setContainer(parseContainer(ctx, valueNode));
break;
case "variables":
builder.setVariables(parseVariables(ctx, valueNode));
@@ -634,6 +866,12 @@ private CelEnvironment.Builder parseConfig(ParserContext ctx, Node node) {
case "stdlib":
builder.setStandardLibrarySubset(parseLibrarySubset(ctx, valueNode));
break;
+ case "features":
+ builder.setFeatures(parseFeatures(ctx, valueNode));
+ break;
+ case "limits":
+ builder.setLimits(parseLimits(ctx, valueNode));
+ break;
default:
ctx.reportError(id, "Unknown config tag: " + fieldName);
// continue handling the rest of the nodes
diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlSerializer.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlSerializer.java
index 687bf4ff9..179faf2ac 100644
--- a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlSerializer.java
+++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlSerializer.java
@@ -16,10 +16,13 @@
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
+import dev.cel.bundle.CelEnvironment.Alias;
import dev.cel.bundle.CelEnvironment.LibrarySubset;
import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector;
import dev.cel.bundle.CelEnvironment.LibrarySubset.OverloadSelector;
+import dev.cel.common.CelContainer;
import java.util.Comparator;
+import java.util.Map;
import org.yaml.snakeyaml.DumperOptions;
import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.nodes.Node;
@@ -55,6 +58,10 @@ private CelEnvironmentYamlSerializer() {
CelEnvironment.LibrarySubset.FunctionSelector.class, new RepresentFunctionSelector());
this.multiRepresenters.put(
CelEnvironment.LibrarySubset.OverloadSelector.class, new RepresentOverloadSelector());
+ this.multiRepresenters.put(CelEnvironment.Alias.class, new RepresentAlias());
+ this.multiRepresenters.put(CelContainer.class, new RepresentContainer());
+ this.multiRepresenters.put(CelEnvironment.FeatureFlag.class, new RepresentFeatureFlag());
+ this.multiRepresenters.put(CelEnvironment.Limit.class, new RepresentLimit());
}
public static String toYaml(CelEnvironment environment) {
@@ -72,7 +79,9 @@ public Node representData(Object data) {
if (!environment.description().isEmpty()) {
configMap.put("description", environment.description());
}
- if (!environment.container().isEmpty()) {
+ if (!environment.container().name().isEmpty()
+ || !environment.container().abbreviations().isEmpty()
+ || !environment.container().aliases().isEmpty()) {
configMap.put("container", environment.container());
}
if (!environment.extensions().isEmpty()) {
@@ -87,10 +96,53 @@ public Node representData(Object data) {
if (environment.standardLibrarySubset().isPresent()) {
configMap.put("stdlib", environment.standardLibrarySubset().get());
}
+ if (!environment.features().isEmpty()) {
+ configMap.put("features", environment.features().asList());
+ }
+ if (!environment.limits().isEmpty()) {
+ configMap.put("limits", environment.limits().asList());
+ }
return represent(configMap.buildOrThrow());
}
}
+ private final class RepresentContainer implements Represent {
+
+ @Override
+ public Node representData(Object data) {
+ CelContainer container = (CelContainer) data;
+ ImmutableMap.Builder configMap = ImmutableMap.builder();
+ if (!container.name().isEmpty()) {
+ configMap.put("name", container.name());
+ }
+ if (!container.abbreviations().isEmpty()) {
+ configMap.put("abbreviations", container.abbreviations());
+ }
+ if (!container.aliases().isEmpty()) {
+ ImmutableList.Builder aliases = ImmutableList.builder();
+ for (Map.Entry entry : container.aliases().entrySet()) {
+ aliases.add(
+ Alias.newBuilder()
+ .setAlias(entry.getKey())
+ .setQualifiedName(entry.getValue())
+ .build());
+ }
+ configMap.put("aliases", aliases.build());
+ }
+ return represent(configMap.buildOrThrow());
+ }
+ }
+
+ private final class RepresentAlias implements Represent {
+
+ @Override
+ public Node representData(Object data) {
+ Alias alias = (Alias) data;
+ return represent(
+ ImmutableMap.of("alias", alias.alias(), "qualified_name", alias.qualifiedName()));
+ }
+ }
+
private final class RepresentExtensionConfig implements Represent {
@Override
public Node representData(Object data) {
@@ -214,4 +266,30 @@ public Node representData(Object data) {
return represent(ImmutableMap.of("id", overloadSelector.id()));
}
}
+
+ private final class RepresentFeatureFlag implements Represent {
+
+ @Override
+ public Node representData(Object data) {
+ CelEnvironment.FeatureFlag featureFlag = (CelEnvironment.FeatureFlag) data;
+ return represent(
+ ImmutableMap.builder()
+ .put("name", featureFlag.name())
+ .put("enabled", featureFlag.enabled())
+ .buildOrThrow());
+ }
+ }
+
+ private final class RepresentLimit implements Represent {
+
+ @Override
+ public Node representData(Object data) {
+ CelEnvironment.Limit limit = (CelEnvironment.Limit) data;
+ return represent(
+ ImmutableMap.builder()
+ .put("name", limit.name())
+ .put("value", limit.value() < 0 ? -1 : limit.value())
+ .buildOrThrow());
+ }
+ }
}
diff --git a/bundle/src/main/java/dev/cel/bundle/CelExperimentalFactory.java b/bundle/src/main/java/dev/cel/bundle/CelExperimentalFactory.java
new file mode 100644
index 000000000..2275d1c56
--- /dev/null
+++ b/bundle/src/main/java/dev/cel/bundle/CelExperimentalFactory.java
@@ -0,0 +1,61 @@
+// Copyright 2026 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.bundle;
+
+import dev.cel.checker.CelCheckerLegacyImpl;
+import dev.cel.common.CelOptions;
+import dev.cel.common.annotations.Beta;
+import dev.cel.compiler.CelCompilerImpl;
+import dev.cel.parser.CelParserImpl;
+import dev.cel.runtime.CelRuntimeImpl;
+
+/**
+ * Experimental helper class to configure the entire CEL stack in a common interface, backed by the
+ * new {@code ProgramPlanner} architecture.
+ *
+ * All APIs and behaviors surfaced here are subject to change.
+ */
+@Beta
+public final class CelExperimentalFactory {
+
+ /**
+ * Creates a builder for configuring CEL for the parsing, optional type-checking, and evaluation
+ * of expressions using the Program Planner.
+ *
+ *
The {@code ProgramPlanner} architecture provides key benefits over the legacy runtime:
+ *
+ *
+ * Performance: Programs can be cached for improving evaluation speed.
+ * Parsed-only expression evaluation: Unlike the traditional stack which required
+ * supplying type-checked expressions, this architecture handles both parsed-only and
+ * type-checked expressions.
+ *
+ */
+ public static CelBuilder plannerCelBuilder() {
+ return CelImpl.newBuilder(
+ CelCompilerImpl.newBuilder(
+ CelParserImpl.newBuilder(),
+ CelCheckerLegacyImpl.newBuilder().setStandardEnvironmentEnabled(true)),
+ CelRuntimeImpl.newBuilder())
+ // CEL-Internal-2
+ .setOptions(
+ CelOptions.current()
+ .enableHeterogeneousNumericComparisons(true)
+ .enableTimestampEpoch(true)
+ .build());
+ }
+
+ private CelExperimentalFactory() {}
+}
diff --git a/bundle/src/main/java/dev/cel/bundle/CelFactory.java b/bundle/src/main/java/dev/cel/bundle/CelFactory.java
index a2080bc25..6cc6d8192 100644
--- a/bundle/src/main/java/dev/cel/bundle/CelFactory.java
+++ b/bundle/src/main/java/dev/cel/bundle/CelFactory.java
@@ -40,6 +40,7 @@ public static CelBuilder standardCelBuilder() {
CelParserImpl.newBuilder(), CelCheckerLegacyImpl.newBuilder()),
CelRuntimeLegacyImpl.newBuilder())
.setOptions(CelOptions.current().build())
+ // CEL-Internal-2
.setStandardEnvironmentEnabled(true);
}
diff --git a/bundle/src/main/java/dev/cel/bundle/CelImpl.java b/bundle/src/main/java/dev/cel/bundle/CelImpl.java
index bc92cca7a..ae0ab2395 100644
--- a/bundle/src/main/java/dev/cel/bundle/CelImpl.java
+++ b/bundle/src/main/java/dev/cel/bundle/CelImpl.java
@@ -54,6 +54,7 @@
import dev.cel.runtime.CelEvaluationException;
import dev.cel.runtime.CelRuntime;
import dev.cel.runtime.CelRuntimeBuilder;
+import dev.cel.runtime.CelRuntimeImpl;
import dev.cel.runtime.CelRuntimeLibrary;
import dev.cel.runtime.CelStandardFunctions;
import java.util.Arrays;
@@ -142,6 +143,8 @@ static CelImpl combine(CelCompiler compiler, CelRuntime runtime) {
* Create a new builder for constructing a {@code CelImpl} instance.
*
* By default, {@link CelOptions#DEFAULT} are enabled, as is the CEL standard environment.
+ *
+ *
CEL Library Internals. Do Not Use. Consumers should use {@code CelFactory} instead.
*/
static CelBuilder newBuilder(
CelCompilerBuilder compilerBuilder, CelRuntimeBuilder celRuntimeBuilder) {
@@ -199,6 +202,10 @@ public CelContainer container() {
@Override
public CelBuilder setContainer(CelContainer container) {
compilerBuilder.setContainer(container);
+ if (runtimeBuilder instanceof CelRuntimeImpl.Builder) {
+ runtimeBuilder.setContainer(container);
+ }
+
return this;
}
diff --git a/bundle/src/test/java/dev/cel/bundle/BUILD.bazel b/bundle/src/test/java/dev/cel/bundle/BUILD.bazel
index 26cbe392d..ffa3322fe 100644
--- a/bundle/src/test/java/dev/cel/bundle/BUILD.bazel
+++ b/bundle/src/test/java/dev/cel/bundle/BUILD.bazel
@@ -17,6 +17,7 @@ java_library(
deps = [
"//:java_truth",
"//bundle:cel",
+ "//bundle:cel_impl",
"//bundle:environment",
"//bundle:environment_exception",
"//bundle:environment_exporter",
@@ -34,7 +35,6 @@ java_library(
"//common:proto_ast",
"//common:source_location",
"//common/ast",
- "//common/internal:proto_time_utils",
"//common/resources/testdata/proto3:standalone_global_enum_java_proto",
"//common/testing",
"//common/types",
@@ -55,6 +55,7 @@ java_library(
"//runtime:evaluation_listener",
"//runtime:function_binding",
"//runtime:unknown_attributes",
+ "//testing/protos:single_file_java_proto",
"@cel_spec//proto/cel/expr:checked_java_proto",
"@cel_spec//proto/cel/expr:syntax_java_proto",
"@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto",
diff --git a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentExporterTest.java b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentExporterTest.java
index fd178857f..f70f1d466 100644
--- a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentExporterTest.java
+++ b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentExporterTest.java
@@ -31,6 +31,7 @@
import dev.cel.bundle.CelEnvironment.OverloadDecl;
import dev.cel.bundle.CelEnvironment.TypeDecl;
import dev.cel.bundle.CelEnvironment.VariableDecl;
+import dev.cel.common.CelContainer;
import dev.cel.common.CelFunctionDecl;
import dev.cel.common.CelOptions;
import dev.cel.common.CelOverloadDecl;
@@ -109,7 +110,7 @@ public void standardLibrarySubset_favorExclusion() throws Exception {
FunctionSelector.create("matches", ImmutableSet.of()),
FunctionSelector.create(
"timestamp", ImmutableSet.of("string_to_timestamp"))))
- .setExcludedMacros(ImmutableSet.of("map", "filter"))
+ .setExcludedMacros(ImmutableSet.of("map", "existsOne", "filter"))
.build());
}
@@ -238,5 +239,55 @@ public void customVariables() {
celEnvironment.variables().stream().map(VariableDecl::name).collect(toImmutableList()))
.containsNoneOf("double", "null_type");
}
+
+ @Test
+ public void container() {
+ Cel cel =
+ CelFactory.standardCelBuilder()
+ .setContainer(
+ CelContainer.newBuilder()
+ .setName("cntnr")
+ .addAbbreviations("foo.Bar", "baz.Qux")
+ .addAlias("nm", "user.name")
+ .addAlias("id", "user.id")
+ .build())
+ .build();
+
+ CelEnvironmentExporter exporter = CelEnvironmentExporter.newBuilder().build();
+ CelEnvironment celEnvironment = exporter.export(cel);
+ CelContainer container = celEnvironment.container();
+ assertThat(container.name()).isEqualTo("cntnr");
+ assertThat(container.abbreviations()).containsExactly("foo.Bar", "baz.Qux").inOrder();
+ assertThat(container.aliases()).containsAtLeast("nm", "user.name", "id", "user.id").inOrder();
+ }
+
+ @Test
+ public void options() {
+ Cel cel =
+ CelFactory.standardCelBuilder()
+ .setOptions(
+ CelOptions.current()
+ .maxExpressionCodePointSize(100)
+ .maxParseErrorRecoveryLimit(10)
+ .maxParseRecursionDepth(10)
+ .enableQuotedIdentifierSyntax(true)
+ .enableHeterogeneousNumericComparisons(true)
+ .populateMacroCalls(true)
+ .build())
+ .build();
+
+ CelEnvironmentExporter exporter = CelEnvironmentExporter.newBuilder().build();
+ CelEnvironment celEnvironment = exporter.export(cel);
+ assertThat(celEnvironment.features())
+ .containsExactly(
+ CelEnvironment.FeatureFlag.create("cel.feature.backtick_escape_syntax", true),
+ CelEnvironment.FeatureFlag.create("cel.feature.cross_type_numeric_comparisons", true),
+ CelEnvironment.FeatureFlag.create("cel.feature.macro_call_tracking", true));
+ assertThat(celEnvironment.limits())
+ .containsExactly(
+ CelEnvironment.Limit.create("cel.limit.expression_code_points", 100),
+ CelEnvironment.Limit.create("cel.limit.parse_error_recovery", 10),
+ CelEnvironment.Limit.create("cel.limit.parse_recursion_depth", 10));
+ }
}
diff --git a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentTest.java b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentTest.java
index 56a4a241c..f7eb254d7 100644
--- a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentTest.java
+++ b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentTest.java
@@ -24,6 +24,7 @@
import dev.cel.bundle.CelEnvironment.LibrarySubset;
import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector;
import dev.cel.common.CelAbstractSyntaxTree;
+import dev.cel.common.CelContainer;
import dev.cel.common.CelOptions;
import dev.cel.common.CelValidationException;
import dev.cel.common.CelValidationResult;
@@ -43,12 +44,33 @@ public void newBuilder_defaults() {
assertThat(environment.source()).isEmpty();
assertThat(environment.name()).isEmpty();
assertThat(environment.description()).isEmpty();
- assertThat(environment.container()).isEmpty();
+ assertThat(environment.container().name()).isEmpty();
+ assertThat(environment.container().abbreviations()).isEmpty();
+ assertThat(environment.container().aliases()).isEmpty();
assertThat(environment.extensions()).isEmpty();
assertThat(environment.variables()).isEmpty();
assertThat(environment.functions()).isEmpty();
}
+ @Test
+ public void container() {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setContainer(
+ CelContainer.newBuilder()
+ .setName("cntr")
+ .addAbbreviations("foo.Bar", "baz.Qux")
+ .addAlias("nm", "user.name")
+ .addAlias("id", "user.id")
+ .build())
+ .build();
+
+ assertThat(environment.container().name()).isEqualTo("cntr");
+ assertThat(environment.container().abbreviations()).containsExactly("foo.Bar", "baz.Qux");
+ assertThat(environment.container().aliases())
+ .containsExactly("nm", "user.name", "id", "user.id");
+ }
+
@Test
public void extend_allExtensions() throws Exception {
ImmutableSet extensionConfigs =
@@ -78,6 +100,99 @@ public void extend_allExtensions() throws Exception {
assertThat(result).isTrue();
}
+ @Test
+ public void extend_allFeatureFlags() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setFeatures(
+ CelEnvironment.FeatureFlag.create("cel.feature.macro_call_tracking", true),
+ CelEnvironment.FeatureFlag.create("cel.feature.backtick_escape_syntax", true),
+ CelEnvironment.FeatureFlag.create(
+ "cel.feature.cross_type_numeric_comparisons", true))
+ .build();
+
+ Cel cel =
+ environment.extend(
+ CelFactory.standardCelBuilder()
+ .setStandardMacros(CelStandardMacro.STANDARD_MACROS)
+ .build(),
+ CelOptions.DEFAULT);
+ CelAbstractSyntaxTree ast =
+ cel.compile("[{'foo.bar': 1}, {'foo.bar': 2}].all(e, e.`foo.bar` < 2.5)").getAst();
+ assertThat(ast.getSource().getMacroCalls()).hasSize(1);
+ boolean result = (boolean) cel.createProgram(ast).eval();
+ assertThat(result).isTrue();
+ }
+
+ @Test
+ public void extend_allLimits() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setLimits(
+ CelEnvironment.Limit.create("cel.limit.expression_code_points", 20),
+ CelEnvironment.Limit.create("cel.limit.parse_error_recovery", 10),
+ CelEnvironment.Limit.create("cel.limit.parse_recursion_depth", 10))
+ .build();
+
+ Cel cel =
+ environment.extend(
+ CelFactory.standardCelBuilder()
+ .setStandardMacros(CelStandardMacro.STANDARD_MACROS)
+ .build(),
+ CelOptions.DEFAULT);
+ CelOptions checkerOptions = cel.toCheckerBuilder().options();
+ assertThat(checkerOptions.maxExpressionCodePointSize()).isEqualTo(20);
+ assertThat(checkerOptions.maxParseErrorRecoveryLimit()).isEqualTo(10);
+ assertThat(checkerOptions.maxParseRecursionDepth()).isEqualTo(10);
+
+ CelAbstractSyntaxTree ast = cel.compile("1 + 2 + 3 + 4 + 5").getAst();
+ Long result = (Long) cel.createProgram(ast).eval();
+ assertThat(result).isEqualTo(15L);
+
+ CelValidationResult validationResult = cel.compile("1 + 2 + 3 + 4 + 5 + 6");
+ assertThat(validationResult.hasError()).isTrue();
+ assertThat(validationResult.getErrorString())
+ .contains("expression code point size exceeds limit: size: 21, limit 20");
+ }
+
+ @Test
+ public void extend_unsupportedFeatureFlag_throws() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setFeatures(CelEnvironment.FeatureFlag.create("unknown.feature", true))
+ .build();
+
+ IllegalArgumentException e =
+ assertThrows(
+ IllegalArgumentException.class,
+ () ->
+ environment.extend(
+ CelFactory.standardCelBuilder()
+ .setStandardMacros(CelStandardMacro.STANDARD_MACROS)
+ .build(),
+ CelOptions.DEFAULT));
+ assertThat(e).hasMessageThat().contains("Unknown feature flag: unknown.feature");
+ }
+
+ @Test
+ public void extend_unsupportedLimit_throws() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setLimits(CelEnvironment.Limit.create("unknown.limit", 5))
+ .build();
+
+ IllegalArgumentException e =
+ assertThrows(
+ IllegalArgumentException.class,
+ () ->
+ environment.extend(
+ CelFactory.standardCelBuilder()
+ .setStandardMacros(CelStandardMacro.STANDARD_MACROS)
+ .build(),
+ CelOptions.DEFAULT));
+ assertThat(e).hasMessageThat().contains("Unknown limit: unknown.limit");
+ }
+
@Test
public void extensionVersion_specific() throws Exception {
CelEnvironment environment =
diff --git a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlParserTest.java b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlParserTest.java
index fb51f3f87..e98f6110e 100644
--- a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlParserTest.java
+++ b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlParserTest.java
@@ -33,14 +33,15 @@
import dev.cel.bundle.CelEnvironment.TypeDecl;
import dev.cel.bundle.CelEnvironment.VariableDecl;
import dev.cel.common.CelAbstractSyntaxTree;
+import dev.cel.common.CelContainer;
import dev.cel.common.CelOptions;
import dev.cel.common.CelSource;
import dev.cel.common.ast.CelExpr;
import dev.cel.common.types.SimpleType;
import dev.cel.parser.CelUnparserFactory;
import dev.cel.runtime.CelEvaluationListener;
-import dev.cel.runtime.CelLateFunctionBindings;
import dev.cel.runtime.CelFunctionBinding;
+import dev.cel.runtime.CelLateFunctionBindings;
import java.io.IOException;
import java.net.URL;
import java.util.Optional;
@@ -80,6 +81,62 @@ public void environment_setBasicProperties() throws Exception {
.build());
}
+ @Test
+ public void environment_setFeatures() throws Exception {
+ String yamlConfig =
+ "name: hello\n"
+ + "description: empty\n"
+ + "features:\n"
+ + " - name: 'cel.feature.macro_call_tracking'\n"
+ + " enabled: true\n"
+ + " - name: 'cel.feature.backtick_escape_syntax'\n"
+ + " enabled: false";
+
+ CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig);
+
+ assertThat(environment)
+ .isEqualTo(
+ CelEnvironment.newBuilder()
+ .setSource(environment.source().get())
+ .setName("hello")
+ .setDescription("empty")
+ .setFeatures(
+ ImmutableSet.of(
+ CelEnvironment.FeatureFlag.create("cel.feature.macro_call_tracking", true),
+ CelEnvironment.FeatureFlag.create(
+ "cel.feature.backtick_escape_syntax", false)))
+ .build());
+ }
+
+ @Test
+ public void environment_setLimits() throws Exception {
+ String yamlConfig =
+ "name: hello\n"
+ + "description: empty\n"
+ + "limits:\n"
+ + " - name: 'cel.limit.expression_code_points'\n"
+ + " value: 1000\n"
+ + " - name: 'cel.limit.parse_error_recovery'\n"
+ + " value: 10\n"
+ + " - name: 'cel.limit.parse_recursion_depth'\n"
+ + " value: 7";
+
+ CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig);
+
+ assertThat(environment)
+ .isEqualTo(
+ CelEnvironment.newBuilder()
+ .setSource(environment.source().get())
+ .setName("hello")
+ .setDescription("empty")
+ .setLimits(
+ ImmutableSet.of(
+ CelEnvironment.Limit.create("cel.limit.expression_code_points", 1000),
+ CelEnvironment.Limit.create("cel.limit.parse_error_recovery", 10),
+ CelEnvironment.Limit.create("cel.limit.parse_recursion_depth", 7)))
+ .build());
+ }
+
@Test
public void environment_setExtensions() throws Exception {
String yamlConfig =
@@ -346,6 +403,36 @@ public void environment_setContainer() throws Exception {
assertThat(environment.extend(CEL_WITH_MESSAGE_TYPES, CelOptions.DEFAULT)).isNotNull();
}
+ @Test
+ public void environment_setContainerWithAliasesAndAbbreviations() throws Exception {
+ String yamlConfig =
+ "container:\n"
+ + " name: 'google.rpc.context'\n"
+ + " abbreviations:\n"
+ + " - 'pkg3.lib3.Baz'\n"
+ + " - pkg4.lib4.Qux\n"
+ + " aliases:\n"
+ + " - alias: 'foo'\n"
+ + " qualified_name: 'pkg1.lib1.Foo'\n"
+ + " - alias: bar\n"
+ + " qualified_name: pkg2.lib2.Bar\n";
+
+ CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig);
+
+ assertThat(environment)
+ .isEqualTo(
+ CelEnvironment.newBuilder()
+ .setContainer(
+ CelContainer.newBuilder()
+ .setName("google.rpc.context")
+ .addAbbreviations("pkg3.lib3.Baz", "pkg4.lib4.Qux")
+ .addAlias("foo", "pkg1.lib1.Foo")
+ .addAlias("bar", "pkg2.lib2.Bar")
+ .build())
+ .setSource(environment.source().get())
+ .build());
+ }
+
@Test
public void environment_withInlinedVariableDecl() throws Exception {
String yamlConfig =
@@ -623,6 +710,58 @@ private enum EnvironmentParseErrorTestcase {
"ERROR: typeAliases) {
return new TypeProvider() {
@Override
diff --git a/checker/src/main/java/dev/cel/checker/BUILD.bazel b/checker/src/main/java/dev/cel/checker/BUILD.bazel
index 5479934c4..99d4da586 100644
--- a/checker/src/main/java/dev/cel/checker/BUILD.bazel
+++ b/checker/src/main/java/dev/cel/checker/BUILD.bazel
@@ -177,13 +177,17 @@ java_library(
":standard_decl",
"//:auto_value",
"//common:cel_ast",
+ "//common:cel_source",
"//common:compiler_common",
"//common:container",
+ "//common:mutable_ast",
+ "//common:operator",
"//common:options",
"//common:proto_ast",
"//common/annotations",
"//common/ast",
"//common/ast:expr_converter",
+ "//common/ast:mutable_expr",
"//common/internal:errors",
"//common/internal:file_descriptor_converter",
"//common/types",
@@ -191,7 +195,6 @@ java_library(
"//common/types:cel_types",
"//common/types:type_providers",
"//parser:macro",
- "//parser:operator",
"@cel_spec//proto/cel/expr:checked_java_proto",
"@cel_spec//proto/cel/expr:syntax_java_proto",
"@maven//:com_google_errorprone_error_prone_annotations",
@@ -239,10 +242,10 @@ java_library(
deps = [
":cel_ident_decl",
"//common:compiler_common",
+ "//common:operator",
"//common/types",
"//common/types:cel_types",
"//common/types:type_providers",
- "//parser:operator",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_guava_guava",
],
diff --git a/checker/src/main/java/dev/cel/checker/CelCheckerBuilder.java b/checker/src/main/java/dev/cel/checker/CelCheckerBuilder.java
index e19cf5b70..a7d531f88 100644
--- a/checker/src/main/java/dev/cel/checker/CelCheckerBuilder.java
+++ b/checker/src/main/java/dev/cel/checker/CelCheckerBuilder.java
@@ -35,6 +35,9 @@ public interface CelCheckerBuilder {
@CanIgnoreReturnValue
CelCheckerBuilder setOptions(CelOptions options);
+ /** Retrieves the currently configured {@link CelOptions} in the builder. */
+ CelOptions options();
+
/**
* Set the {@link CelContainer} to use as the namespace for resolving CEL expression variables and
* functions.
diff --git a/checker/src/main/java/dev/cel/checker/CelCheckerLegacyImpl.java b/checker/src/main/java/dev/cel/checker/CelCheckerLegacyImpl.java
index 41d1ca073..ceab0fa93 100644
--- a/checker/src/main/java/dev/cel/checker/CelCheckerLegacyImpl.java
+++ b/checker/src/main/java/dev/cel/checker/CelCheckerLegacyImpl.java
@@ -202,6 +202,11 @@ public CelCheckerBuilder setOptions(CelOptions celOptions) {
return this;
}
+ @Override
+ public CelOptions options() {
+ return this.celOptions;
+ }
+
@Override
public CelCheckerBuilder setContainer(CelContainer container) {
checkNotNull(container);
@@ -421,11 +426,6 @@ CelStandardDeclarations standardDeclarations() {
return this.standardDeclarations;
}
- @VisibleForTesting
- CelOptions options() {
- return this.celOptions;
- }
-
@VisibleForTesting
CelTypeProvider celTypeProvider() {
return this.celTypeProvider;
@@ -456,9 +456,12 @@ public CelCheckerLegacyImpl build() {
}
CelTypeProvider messageTypeProvider =
- new ProtoMessageTypeProvider(
- CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(
- fileTypeSet, celOptions.resolveTypeDependencies()));
+ ProtoMessageTypeProvider.newBuilder()
+ .setAllowJsonFieldNames(celOptions.enableJsonFieldNames())
+ .setResolveTypeDependencies(celOptions.resolveTypeDependencies())
+ .addFileDescriptors(fileTypeSet)
+ .build();
+
if (celTypeProvider != null && fileTypeSet.isEmpty()) {
messageTypeProvider = celTypeProvider;
} else if (celTypeProvider != null) {
diff --git a/checker/src/main/java/dev/cel/checker/CelStandardDeclarations.java b/checker/src/main/java/dev/cel/checker/CelStandardDeclarations.java
index 94b7ad313..12ad47c62 100644
--- a/checker/src/main/java/dev/cel/checker/CelStandardDeclarations.java
+++ b/checker/src/main/java/dev/cel/checker/CelStandardDeclarations.java
@@ -23,6 +23,7 @@
import com.google.errorprone.annotations.Immutable;
import dev.cel.common.CelFunctionDecl;
import dev.cel.common.CelOverloadDecl;
+import dev.cel.common.Operator;
import dev.cel.common.types.CelType;
import dev.cel.common.types.CelTypes;
import dev.cel.common.types.ListType;
@@ -30,7 +31,6 @@
import dev.cel.common.types.SimpleType;
import dev.cel.common.types.TypeParamType;
import dev.cel.common.types.TypeType;
-import dev.cel.parser.Operator;
/**
* Standard declarations for CEL.
diff --git a/checker/src/main/java/dev/cel/checker/Env.java b/checker/src/main/java/dev/cel/checker/Env.java
index d5692d48c..75ed7cf1f 100644
--- a/checker/src/main/java/dev/cel/checker/Env.java
+++ b/checker/src/main/java/dev/cel/checker/Env.java
@@ -38,6 +38,7 @@
import dev.cel.common.ast.CelConstant;
import dev.cel.common.ast.CelExpr;
import dev.cel.common.ast.CelExprConverter;
+import dev.cel.common.ast.CelMutableExpr;
import dev.cel.common.ast.CelReference;
import dev.cel.common.internal.Errors;
import dev.cel.common.types.CelKind;
@@ -288,28 +289,31 @@ public Map getTypeMap() {
* Returns the type associated with an expression by expression id. It's an error to call this
* method if the type is not present.
*
- * @deprecated Use {@link #getType(CelExpr)} instead.
+ * @deprecated Do not use. Migrate to CEL-Java fluent APIs.
*/
@Deprecated
public Type getType(Expr expr) {
Preconditions.checkNotNull(expr);
- return CelProtoTypes.celTypeToType(getType(CelExprConverter.fromExpr(expr)));
+ CelExpr celExpr = CelExprConverter.fromExpr(expr);
+ CelType celType =
+ Preconditions.checkNotNull(typeMap.get(celExpr.id()), "expression has no type");
+ return CelProtoTypes.celTypeToType(celType);
}
/**
- * Returns the type associated with an expression by expression id. It's an error to call this
- * method if the type is not present.
+ * Returns the type associated with a mutable expression by expression id. It's an error to call
+ * this method if the type is not present.
*/
- public CelType getType(CelExpr expr) {
+ CelType getType(CelMutableExpr expr) {
return Preconditions.checkNotNull(typeMap.get(expr.id()), "expression has no type");
}
/**
- * Sets the type associated with an expression by id. It's an error if the type is already set and
- * is different than the provided one. Returns the expression parameter.
+ * Sets the type associated with a mutable expression by id. It's an error if the type is already
+ * set and is different than the provided one. Returns the expression parameter.
*/
@CanIgnoreReturnValue
- public CelExpr setType(CelExpr expr, CelType type) {
+ CelMutableExpr setType(CelMutableExpr expr, CelType type) {
CelType oldType = typeMap.put(expr.id(), type);
Preconditions.checkState(
oldType == null || oldType.equals(type),
@@ -320,10 +324,10 @@ public CelExpr setType(CelExpr expr, CelType type) {
}
/**
- * Sets the reference associated with an expression. It's an error if the reference is already set
- * and is different.
+ * Sets the reference associated with a mutable expression. It's an error if the reference is
+ * already set and is different.
*/
- public void setRef(CelExpr expr, CelReference reference) {
+ void setRef(CelMutableExpr expr, CelReference reference) {
CelReference oldReference = referenceMap.put(expr.id(), reference);
Preconditions.checkState(
oldReference == null || oldReference.equals(reference),
@@ -451,38 +455,87 @@ public Env add(String name, Type type) {
* until the root package is reached. If {@code container} starts with {@code .}, the resolution
* is in the root container only.
*
- * Returns {@code null} if the function cannot be found.
+ *
Returns {@code null} if the ident cannot be found.
*/
public @Nullable CelIdentDecl tryLookupCelIdent(CelContainer container, String name) {
- for (String cand : container.resolveCandidateNames(name)) {
- // First determine whether we know this name already.
- CelIdentDecl decl = findIdentDecl(cand);
+ // A name with a leading '.' always resolves in the root scope, bypassing local scopes.
+ if (!name.startsWith(".")) {
+ // Check if this is a qualified ident, or a field selection.
+ String simpleName = name;
+ int dotIndex = name.indexOf('.');
+ if (dotIndex > 0) {
+ simpleName = name.substring(0, dotIndex);
+ }
+
+ // Attempt to find the decl with just the ident name to account for shadowed variables.
+ CelIdentDecl decl = tryLookupCelIdentFromLocalScopes(simpleName);
if (decl != null) {
- return decl;
+ // Appears to be a field selection on a local.
+ // Return null instead of attempting to resolve qualified name at the root scope
+ return dotIndex > 0 ? null : decl;
}
+ }
- // Next try to import the name as a reference to a message type.
- // This is done via the type provider.
- Optional type = typeProvider.lookupCelType(cand);
- if (type.isPresent()) {
- decl = CelIdentDecl.newIdentDeclaration(cand, type.get());
- decls.get(0).putIdent(decl);
+ for (String cand : container.resolveCandidateNames(name)) {
+ CelIdentDecl decl = tryLookupCelIdent(cand);
+ if (decl != null) {
return decl;
}
+ }
- // Next try to import this as an enum value by splitting the name in a type prefix and
- // the enum inside.
- Integer enumValue = typeProvider.lookupEnumValue(cand);
- if (enumValue != null) {
- decl =
- CelIdentDecl.newBuilder()
- .setName(cand)
- .setType(SimpleType.INT)
- .setConstant(CelConstant.ofValue(enumValue))
- .build();
+ return null;
+ }
- decls.get(0).putIdent(decl);
- return decl;
+ private @Nullable CelIdentDecl tryLookupCelIdent(String cand) {
+ // First determine whether we know this name already.
+ CelIdentDecl decl = findIdentDecl(cand);
+ if (decl != null) {
+ return decl;
+ }
+
+ // Next try to import the name as a reference to a message type.
+ // This is done via the type provider.
+ Optional type = typeProvider.lookupCelType(cand);
+ if (type.isPresent()) {
+ decl = CelIdentDecl.newIdentDeclaration(cand, type.get());
+ decls.get(0).putIdent(decl);
+ return decl;
+ }
+
+ // Next try to import this as an enum value by splitting the name in a type prefix and
+ // the enum inside.
+ Integer enumValue = typeProvider.lookupEnumValue(cand);
+ if (enumValue != null) {
+ decl =
+ CelIdentDecl.newBuilder()
+ .setName(cand)
+ .setType(SimpleType.INT)
+ .setConstant(CelConstant.ofValue(enumValue))
+ .build();
+
+ decls.get(0).putIdent(decl);
+ return decl;
+ }
+ return null;
+ }
+
+ /**
+ * Lookup a local identifier by name. This searches only comprehension scopes, bypassing standard
+ * environment or user-defined environment.
+ *
+ * Returns {@code null} if not found in local scopes.
+ */
+ @Nullable CelIdentDecl tryLookupCelIdentFromLocalScopes(String name) {
+ int firstUserSpaceScope = 2;
+ // Iterate from the top of the stack down to the first local scope.
+ // Note that:
+ // Scope 0: Standard environment
+ // Scope 1: User defined environment
+ // Scope 2 and onwards: comprehension scopes
+ for (int i = decls.size() - 1; i >= firstUserSpaceScope; i--) {
+ CelIdentDecl ident = decls.get(i).getIdent(name);
+ if (ident != null) {
+ return ident;
}
}
return null;
diff --git a/checker/src/main/java/dev/cel/checker/ExprChecker.java b/checker/src/main/java/dev/cel/checker/ExprChecker.java
index d4dbf7994..e3ce99e67 100644
--- a/checker/src/main/java/dev/cel/checker/ExprChecker.java
+++ b/checker/src/main/java/dev/cel/checker/ExprChecker.java
@@ -29,11 +29,22 @@
import dev.cel.common.CelAbstractSyntaxTree;
import dev.cel.common.CelContainer;
import dev.cel.common.CelFunctionDecl;
+import dev.cel.common.CelMutableAst;
import dev.cel.common.CelOverloadDecl;
import dev.cel.common.CelProtoAbstractSyntaxTree;
+import dev.cel.common.CelSource;
+import dev.cel.common.Operator;
import dev.cel.common.annotations.Internal;
import dev.cel.common.ast.CelConstant;
import dev.cel.common.ast.CelExpr;
+import dev.cel.common.ast.CelMutableExpr;
+import dev.cel.common.ast.CelMutableExpr.CelMutableCall;
+import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension;
+import dev.cel.common.ast.CelMutableExpr.CelMutableIdent;
+import dev.cel.common.ast.CelMutableExpr.CelMutableList;
+import dev.cel.common.ast.CelMutableExpr.CelMutableMap;
+import dev.cel.common.ast.CelMutableExpr.CelMutableSelect;
+import dev.cel.common.ast.CelMutableExpr.CelMutableStruct;
import dev.cel.common.ast.CelReference;
import dev.cel.common.types.CelKind;
import dev.cel.common.types.CelProtoTypes;
@@ -42,13 +53,14 @@
import dev.cel.common.types.ListType;
import dev.cel.common.types.MapType;
import dev.cel.common.types.OptionalType;
+import dev.cel.common.types.ProtoMessageType;
import dev.cel.common.types.SimpleType;
import dev.cel.common.types.TypeType;
-import dev.cel.parser.Operator;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import org.jspecify.annotations.Nullable;
/**
@@ -61,6 +73,11 @@
@Internal
@Deprecated
public final class ExprChecker {
+ private static final CelSource.Extension JSON_NAME_EXTENSION =
+ CelSource.Extension.create(
+ "json_name",
+ CelSource.Extension.Version.of(1, 1),
+ CelSource.Extension.Component.COMPONENT_RUNTIME);
/**
* Deprecated type-check API.
@@ -130,16 +147,23 @@ public static CelAbstractSyntaxTree typecheck(
env.enableCompileTimeOverloadResolution(),
env.enableHomogeneousLiterals(),
env.enableNamespacedDeclarations());
- CelExpr expr = checker.visit(ast.getExpr());
+
+ CelMutableAst mutableAst = CelMutableAst.fromCelAst(ast);
+ checker.visit(mutableAst.expr());
if (expectedResultType.isPresent()) {
- checker.assertType(expr, expectedResultType.get());
+ checker.assertType(mutableAst.expr(), expectedResultType.get());
}
// Walk over the final type map substituting any type parameters either by their bound value or
// by DYN.
Map typeMap =
Maps.transformValues(env.getTypeMap(), checker.inferenceContext::finalize);
- return CelAbstractSyntaxTree.newCheckedAst(expr, ast.getSource(), env.getRefMap(), typeMap);
+ CelAbstractSyntaxTree parsedAst = mutableAst.toParsedAst(/* retainSourcePositions= */ true);
+ return CelAbstractSyntaxTree.newCheckedAst(
+ parsedAst.getExpr(),
+ parsedAst.getSource().toBuilder().addAllExtensions(checker.extensions).build(),
+ env.getRefMap(),
+ typeMap);
}
private final Env env;
@@ -150,6 +174,7 @@ public static CelAbstractSyntaxTree typecheck(
private final boolean compileTimeOverloadResolution;
private final boolean homogeneousLiterals;
private final boolean namespacedDeclarations;
+ private final Set extensions;
private ExprChecker(
Env env,
@@ -167,35 +192,42 @@ private ExprChecker(
this.compileTimeOverloadResolution = compileTimeOverloadResolution;
this.homogeneousLiterals = homogeneousLiterals;
this.namespacedDeclarations = namespacedDeclarations;
+ this.extensions = new HashSet<>();
}
/** Visit the {@code expr} value, routing to overloads based on the kind of expression. */
- @CheckReturnValue
- public CelExpr visit(CelExpr expr) {
- switch (expr.exprKind().getKind()) {
+ public void visit(CelMutableExpr expr) {
+ switch (expr.getKind()) {
case CONSTANT:
- return visit(expr, expr.constant());
+ visit(expr, expr.constant());
+ break;
case IDENT:
- return visit(expr, expr.ident());
+ visit(expr, expr.ident());
+ break;
case SELECT:
- return visit(expr, expr.select());
+ visit(expr, expr.select());
+ break;
case CALL:
- return visit(expr, expr.call());
+ visit(expr, expr.call());
+ break;
case LIST:
- return visit(expr, expr.list());
+ visit(expr, expr.list());
+ break;
case STRUCT:
- return visit(expr, expr.struct());
+ visit(expr, expr.struct());
+ break;
case MAP:
- return visit(expr, expr.map());
+ visit(expr, expr.map());
+ break;
case COMPREHENSION:
- return visit(expr, expr.comprehension());
+ visit(expr, expr.comprehension());
+ break;
default:
throw new IllegalArgumentException("unexpected expr kind");
}
}
- @CheckReturnValue
- private CelExpr visit(CelExpr expr, CelConstant constant) {
+ private void visit(CelMutableExpr expr, CelConstant constant) {
switch (constant.getKind()) {
case INT64_VALUE:
env.setType(expr, SimpleType.INT);
@@ -227,30 +259,29 @@ private CelExpr visit(CelExpr expr, CelConstant constant) {
default:
throw new IllegalArgumentException("unexpected constant case: " + constant.getKind());
}
- return expr;
}
- @CheckReturnValue
- private CelExpr visit(CelExpr expr, CelExpr.CelIdent ident) {
+ private void visit(CelMutableExpr expr, CelMutableIdent ident) {
CelIdentDecl decl = env.lookupIdent(expr.id(), getPosition(expr), container, ident.name());
checkNotNull(decl);
if (decl.equals(Env.ERROR_IDENT_DECL)) {
// error reported
env.setType(expr, SimpleType.ERROR);
- env.setRef(expr, makeReference(decl));
- return expr;
+ env.setRef(expr, makeReference(decl.name(), decl));
+ return;
}
- if (!decl.name().equals(ident.name())) {
+
+ String refName = maybeDisambiguate(ident.name(), decl.name());
+
+ if (!refName.equals(ident.name())) {
// Overwrite the identifier with its fully qualified name.
- expr = replaceIdentSubtree(expr, decl.name());
+ expr.setIdent(CelMutableIdent.create(refName));
}
env.setType(expr, decl.type());
- env.setRef(expr, makeReference(decl));
- return expr;
+ env.setRef(expr, makeReference(refName, decl));
}
- @CheckReturnValue
- private CelExpr visit(CelExpr expr, CelExpr.CelSelect select) {
+ private void visit(CelMutableExpr expr, CelMutableSelect select) {
// Before traversing down the tree, try to interpret as qualified name.
String qname = asQualifiedName(expr);
if (qname != null) {
@@ -260,47 +291,39 @@ private CelExpr visit(CelExpr expr, CelExpr.CelSelect select) {
env.reportError(expr.id(), getPosition(expr), "expression does not select a field");
env.setType(expr, SimpleType.BOOL);
} else {
+ String refName = maybeDisambiguate(qname, decl.name());
+
if (namespacedDeclarations) {
// Rewrite the node to be a variable reference to the resolved fully-qualified
// variable name.
- expr = replaceIdentSubtree(expr, decl.name());
+ expr.setIdent(CelMutableIdent.create(refName));
}
env.setType(expr, decl.type());
- env.setRef(expr, makeReference(decl));
+ env.setRef(expr, makeReference(refName, decl));
}
- return expr;
+ return;
}
}
// Interpret as field selection, first traversing down the operand.
- CelExpr visitedOperand = visit(select.operand());
- if (namespacedDeclarations && !select.operand().equals(visitedOperand)) {
- // Subtree has been rewritten. Replace the operand.
- expr = replaceSelectOperandSubtree(expr, visitedOperand);
- }
- CelType resultType = visitSelectField(expr, visitedOperand, select.field(), false);
+ visit(select.operand());
+
+ CelType resultType = visitSelectField(expr, select.operand(), select.field(), false);
if (select.testOnly()) {
resultType = SimpleType.BOOL;
}
env.setType(expr, resultType);
- return expr;
}
- @CheckReturnValue
- private CelExpr visit(CelExpr expr, CelExpr.CelCall call) {
+ private void visit(CelMutableExpr expr, CelMutableCall call) {
String functionName = call.function();
if (Operator.OPTIONAL_SELECT.getFunction().equals(functionName)) {
- return visitOptionalCall(expr, call);
+ visitOptionalCall(expr, call);
+ return;
}
// Traverse arguments.
- ImmutableList argsList = call.args();
- for (int i = 0; i < argsList.size(); i++) {
- CelExpr arg = argsList.get(i);
- CelExpr visitedArg = visit(arg);
- if (namespacedDeclarations && !visitedArg.equals(arg)) {
- // Argument has been overwritten.
- expr = replaceCallArgumentSubtree(expr, visitedArg, i);
- }
+ for (CelMutableExpr arg : call.args()) {
+ visit(arg);
}
int position = getPosition(expr);
@@ -314,7 +337,7 @@ private CelExpr visit(CelExpr expr, CelExpr.CelCall call) {
if (!decl.name().equals(call.function())) {
if (namespacedDeclarations) {
// Overwrite the function name with its fully qualified resolved name.
- expr = replaceCallSubtree(expr, decl.name());
+ expr.setCall(CelMutableCall.create(decl.name(), call.args()));
}
}
} else {
@@ -329,17 +352,12 @@ private CelExpr visit(CelExpr expr, CelExpr.CelCall call) {
// The function name is namespaced and so preserving the target operand would
// be an inaccurate representation of the desired evaluation behavior.
// Overwrite with fully-qualified resolved function name sans receiver target.
- expr = replaceCallSubtree(expr, decl.name());
+ expr.setCall(CelMutableCall.create(decl.name(), call.args()));
}
} else {
// Regular instance call.
- CelExpr target = call.target().get();
- CelExpr visitedTargetExpr = visit(target);
- if (namespacedDeclarations && !visitedTargetExpr.equals(target)) {
- // Visiting target contained a namespaced function. Rewrite the call expression here by
- // setting the target to the new subtree.
- expr = replaceCallSubtree(expr, visitedTargetExpr);
- }
+ CelMutableExpr target = call.target().get();
+ visit(target);
resolution =
resolveOverload(
expr.id(),
@@ -352,32 +370,26 @@ private CelExpr visit(CelExpr expr, CelExpr.CelCall call) {
env.setType(expr, resolution.type());
env.setRef(expr, resolution.reference());
-
- return expr;
}
- @CheckReturnValue
- private CelExpr visit(CelExpr expr, CelExpr.CelStruct struct) {
+ private void visit(CelMutableExpr expr, CelMutableStruct struct) {
// Determine the type of the message.
CelType messageType = SimpleType.ERROR;
CelIdentDecl decl =
env.lookupIdent(expr.id(), getPosition(expr), container, struct.messageName());
if (!struct.messageName().equals(decl.name())) {
- expr =
- expr.toBuilder()
- .setStruct(struct.toBuilder().setMessageName(decl.name()).build())
- .build();
+ struct.setMessageName(decl.name());
}
env.setRef(expr, CelReference.newBuilder().setName(decl.name()).build());
CelType type = decl.type();
- if (type.kind() != CelKind.ERROR) {
- if (type.kind() != CelKind.TYPE) {
+ if (!type.kind().equals(CelKind.ERROR)) {
+ if (!type.kind().equals(CelKind.TYPE)) {
// expected type of types
env.reportError(expr.id(), getPosition(expr), "'%s' is not a type", CelTypes.format(type));
} else {
messageType = ((TypeType) type).type();
- if (messageType.kind() != CelKind.STRUCT) {
+ if (!messageType.kind().equals(CelKind.STRUCT)) {
env.reportError(
expr.id(),
getPosition(expr),
@@ -396,26 +408,20 @@ private CelExpr visit(CelExpr expr, CelExpr.CelStruct struct) {
}
// Check the field initializers.
- ImmutableList entriesList = struct.entries();
- for (int i = 0; i < entriesList.size(); i++) {
- CelExpr.CelStruct.Entry entry = entriesList.get(i);
- CelExpr visitedValueExpr = visit(entry.value());
- if (namespacedDeclarations && !visitedValueExpr.equals(entry.value())) {
- // Subtree has been rewritten. Replace the struct value.
- expr = replaceStructEntryValueSubtree(expr, visitedValueExpr, i);
- }
+ List entriesList = struct.entries();
+ for (CelMutableStruct.Entry entry : entriesList) {
+ CelMutableExpr value = entry.value();
+ visit(value);
+
CelType fieldType =
getFieldType(entry.id(), getPosition(entry), messageType, entry.fieldKey()).celType();
- CelType valueType = env.getType(visitedValueExpr);
+ CelType valueType = env.getType(value);
if (entry.optionalEntry()) {
if (valueType instanceof OptionalType) {
valueType = unwrapOptional(valueType);
} else {
assertIsAssignable(
- visitedValueExpr.id(),
- getPosition(visitedValueExpr),
- valueType,
- OptionalType.create(valueType));
+ value.id(), getPosition(value), valueType, OptionalType.create(valueType));
}
}
if (!inferenceContext.isAssignable(fieldType, valueType)) {
@@ -428,48 +434,32 @@ private CelExpr visit(CelExpr expr, CelExpr.CelStruct struct) {
CelTypes.format(valueType));
}
}
- return expr;
}
- @CheckReturnValue
- private CelExpr visit(CelExpr expr, CelExpr.CelMap map) {
+ private void visit(CelMutableExpr expr, CelMutableMap map) {
CelType mapKeyType = null;
CelType mapValueType = null;
- ImmutableList entriesList = map.entries();
- for (int i = 0; i < entriesList.size(); i++) {
- CelExpr.CelMap.Entry entry = entriesList.get(i);
- CelExpr visitedMapKeyExpr = visit(entry.key());
- if (namespacedDeclarations && !visitedMapKeyExpr.equals(entry.key())) {
- // Subtree has been rewritten. Replace the map key.
- expr = replaceMapEntryKeySubtree(expr, visitedMapKeyExpr, i);
- }
- mapKeyType =
- joinTypes(
- visitedMapKeyExpr.id(),
- getPosition(visitedMapKeyExpr),
- mapKeyType,
- env.getType(visitedMapKeyExpr));
-
- CelExpr visitedValueExpr = visit(entry.value());
- if (namespacedDeclarations && !visitedValueExpr.equals(entry.value())) {
- // Subtree has been rewritten. Replace the map value.
- expr = replaceMapEntryValueSubtree(expr, visitedValueExpr, i);
- }
- CelType valueType = env.getType(visitedValueExpr);
+ List entriesList = map.entries();
+ for (CelMutableMap.Entry entry : entriesList) {
+ CelMutableExpr key = entry.key();
+ visit(key);
+
+ mapKeyType = joinTypes(key.id(), getPosition(key), mapKeyType, env.getType(key));
+
+ CelMutableExpr value = entry.value();
+ visit(value);
+
+ CelType valueType = env.getType(value);
if (entry.optionalEntry()) {
if (valueType instanceof OptionalType) {
valueType = unwrapOptional(valueType);
} else {
assertIsAssignable(
- visitedValueExpr.id(),
- getPosition(visitedValueExpr),
- valueType,
- OptionalType.create(valueType));
+ value.id(), getPosition(value), valueType, OptionalType.create(valueType));
}
}
- mapValueType =
- joinTypes(visitedValueExpr.id(), getPosition(visitedValueExpr), mapValueType, valueType);
+ mapValueType = joinTypes(value.id(), getPosition(value), mapValueType, valueType);
}
if (mapKeyType == null) {
// If the map is empty, assign free type variables to key and value type.
@@ -477,46 +467,39 @@ private CelExpr visit(CelExpr expr, CelExpr.CelMap map) {
mapValueType = inferenceContext.newTypeVar("value");
}
env.setType(expr, MapType.create(mapKeyType, mapValueType));
- return expr;
}
- @CheckReturnValue
- private CelExpr visit(CelExpr expr, CelExpr.CelList list) {
+ private void visit(CelMutableExpr expr, CelMutableList list) {
CelType elemsType = null;
- ImmutableList elementsList = list.elements();
+ List elementsList = list.elements();
HashSet optionalIndices = new HashSet<>(list.optionalIndices());
for (int i = 0; i < elementsList.size(); i++) {
- CelExpr visitedElem = visit(elementsList.get(i));
- if (namespacedDeclarations && !visitedElem.equals(elementsList.get(i))) {
- // Subtree has been rewritten. Replace the list element
- expr = replaceListElementSubtree(expr, visitedElem, i);
- }
- CelType elemType = env.getType(visitedElem);
+ CelMutableExpr elem = elementsList.get(i);
+ visit(elem);
+
+ CelType elemType = env.getType(elem);
if (optionalIndices.contains(i)) {
if (elemType instanceof OptionalType) {
elemType = unwrapOptional(elemType);
} else {
- assertIsAssignable(
- visitedElem.id(), getPosition(visitedElem), elemType, OptionalType.create(elemType));
+ assertIsAssignable(elem.id(), getPosition(elem), elemType, OptionalType.create(elemType));
}
}
- elemsType = joinTypes(visitedElem.id(), getPosition(visitedElem), elemsType, elemType);
+ elemsType = joinTypes(elem.id(), getPosition(elem), elemsType, elemType);
}
if (elemsType == null) {
// If the list is empty, assign free type var to elem type.
elemsType = inferenceContext.newTypeVar("elem");
}
env.setType(expr, ListType.create(elemsType));
- return expr;
}
- @CheckReturnValue
- private CelExpr visit(CelExpr expr, CelExpr.CelComprehension compre) {
- CelExpr visitedRange = visit(compre.iterRange());
- CelExpr visitedInit = visit(compre.accuInit());
- CelType accuType = env.getType(visitedInit);
- CelType rangeType = inferenceContext.specialize(env.getType(visitedRange));
+ private void visit(CelMutableExpr expr, CelMutableComprehension compre) {
+ visit(compre.iterRange());
+ visit(compre.accuInit());
+ CelType accuType = env.getType(compre.accuInit());
+ CelType rangeType = inferenceContext.specialize(env.getType(compre.iterRange()));
CelType varType;
CelType varType2 = null;
switch (rangeType.kind()) {
@@ -551,7 +534,7 @@ private CelExpr visit(CelExpr expr, CelExpr.CelComprehension compre) {
default:
env.reportError(
expr.id(),
- getPosition(visitedRange),
+ getPosition(compre.iterRange()),
"expression of type '%s' cannot be range of a comprehension "
+ "(must be list, map, or dynamic)",
CelTypes.format(rangeType));
@@ -569,46 +552,50 @@ private CelExpr visit(CelExpr expr, CelExpr.CelComprehension compre) {
if (!Strings.isNullOrEmpty(compre.iterVar2())) {
env.add(CelIdentDecl.newIdentDeclaration(compre.iterVar2(), varType2));
}
- CelExpr condition = visit(compre.loopCondition());
- assertType(condition, SimpleType.BOOL);
- CelExpr visitedStep = visit(compre.loopStep());
- assertType(visitedStep, accuType);
+ visit(compre.loopCondition());
+ assertType(compre.loopCondition(), SimpleType.BOOL);
+ visit(compre.loopStep());
+ assertType(compre.loopStep(), accuType);
// Forget iteration variable, as result expression must only depend on accu.
env.exitScope();
- CelExpr visitedResult = visit(compre.result());
+ visit(compre.result());
env.exitScope();
- if (namespacedDeclarations) {
- if (!visitedRange.equals(compre.iterRange())) {
- expr = replaceComprehensionRangeSubtree(expr, visitedRange);
- }
- if (!visitedInit.equals(compre.accuInit())) {
- expr = replaceComprehensionAccuInitSubtree(expr, visitedInit);
- }
- if (!visitedStep.equals(compre.loopStep())) {
- expr = replaceComprehensionStepSubtree(expr, visitedStep);
- }
- if (!visitedResult.equals(compre.result())) {
- expr = replaceComprehensionResultSubtree(expr, visitedResult);
- }
- }
- env.setType(expr, inferenceContext.specialize(env.getType(visitedResult)));
- return expr;
+
+ env.setType(expr, inferenceContext.specialize(env.getType(compre.result())));
}
- private CelReference makeReference(CelIdentDecl decl) {
- CelReference.Builder ref = CelReference.newBuilder().setName(decl.name());
+ private CelReference makeReference(String name, CelIdentDecl decl) {
+ CelReference.Builder ref = CelReference.newBuilder().setName(name);
if (decl.constant().isPresent()) {
ref.setValue(decl.constant().get());
}
return ref.build();
}
+ /**
+ * Returns the reference name, prefixed with a leading dot only if disambiguation is needed.
+ * Disambiguation is needed when: the original name had a leading dot, and there's a local
+ * variable that would shadow the resolved name.
+ */
+ private String maybeDisambiguate(String originalName, String resolvedName) {
+ if (!originalName.startsWith(".")) {
+ return resolvedName;
+ }
+ String simpleName = originalName.substring(1);
+ int dotIndex = simpleName.indexOf('.');
+ String localName = dotIndex > 0 ? simpleName.substring(0, dotIndex) : simpleName;
+ if (env.tryLookupCelIdentFromLocalScopes(localName) != null) {
+ return "." + resolvedName;
+ }
+ return resolvedName;
+ }
+
private OverloadResolution resolveOverload(
long callExprId,
int position,
@Nullable CelFunctionDecl function,
- @Nullable CelExpr target,
- List args) {
+ @Nullable CelMutableExpr target,
+ List args) {
if (function == null || function.equals(Env.ERROR_FUNCTION_DECL)) {
// Error reported, just return error value.
return OverloadResolution.of(CelReference.newBuilder().build(), SimpleType.ERROR);
@@ -617,7 +604,7 @@ private OverloadResolution resolveOverload(
if (target != null) {
argTypes.add(env.getType(target));
}
- for (CelExpr arg : args) {
+ for (CelMutableExpr arg : args) {
argTypes.add(env.getType(arg));
}
CelType resultType = null; // For most common result type.
@@ -693,7 +680,7 @@ private OverloadResolution resolveOverload(
// Return value from visit is not needed as the subtree is not rewritten here.
@SuppressWarnings("CheckReturnValue")
private CelType visitSelectField(
- CelExpr expr, CelExpr operand, String field, boolean isOptional) {
+ CelMutableExpr expr, CelMutableExpr operand, String field, boolean isOptional) {
CelType operandType = inferenceContext.specialize(env.getType(operand));
CelType resultType = SimpleType.ERROR;
@@ -703,14 +690,18 @@ private CelType visitSelectField(
}
if (!Types.isDynOrError(operandType)) {
- if (operandType.kind() == CelKind.STRUCT) {
+ if (operandType.kind().equals(CelKind.STRUCT)) {
TypeProvider.FieldType fieldType =
getFieldType(expr.id(), getPosition(expr), operandType, field);
+ ProtoMessageType protoMessageType = resolveProtoMessageType(operandType);
+ if (protoMessageType != null && protoMessageType.isJsonName(field)) {
+ extensions.add(JSON_NAME_EXTENSION);
+ }
// Type of the field
resultType = fieldType.celType();
- } else if (operandType.kind() == CelKind.MAP) {
+ } else if (operandType.kind().equals(CelKind.MAP)) {
resultType = ((MapType) operandType).valueType();
- } else if (operandType.kind() == CelKind.TYPE_PARAM) {
+ } else if (operandType.kind().equals(CelKind.TYPE_PARAM)) {
// Mark the operand as type DYN to avoid cases where the free type variable might take on
// an incorrect type if used in multiple locations.
//
@@ -740,25 +731,48 @@ private CelType visitSelectField(
return resultType;
}
- private CelExpr visitOptionalCall(CelExpr expr, CelExpr.CelCall call) {
- CelExpr operand = call.args().get(0);
- CelExpr field = call.args().get(1);
- if (!field.exprKind().getKind().equals(CelExpr.ExprKind.Kind.CONSTANT)
- || field.constant().getKind() != CelConstant.Kind.STRING_VALUE) {
- env.reportError(expr.id(), getPosition(field), "unsupported optional field selection");
- return expr;
+ private @Nullable ProtoMessageType resolveProtoMessageType(CelType operandType) {
+ if (operandType instanceof ProtoMessageType) {
+ return (ProtoMessageType) operandType;
+ }
+
+ if (operandType.kind().equals(CelKind.STRUCT)) {
+ // This is either a StructTypeReference or just a Struct. Attempt to search for
+ // ProtoMessageType that may exist in in the type provider.
+ TypeType typeDef =
+ typeProvider
+ .lookupCelType(operandType.name())
+ .filter(t -> t instanceof TypeType)
+ .map(TypeType.class::cast)
+ .orElse(null);
+ if (typeDef == null || typeDef.parameters().size() != 1) {
+ return null;
+ }
+
+ CelType maybeProtoMessageType = typeDef.parameters().get(0);
+ if (maybeProtoMessageType instanceof ProtoMessageType) {
+ return (ProtoMessageType) maybeProtoMessageType;
+ }
}
- CelExpr visitedOperand = visit(operand);
- if (namespacedDeclarations && !operand.equals(visitedOperand)) {
- // Subtree has been rewritten. Replace the operand.
- expr = replaceCallArgumentSubtree(expr, visitedOperand, 0);
+ return null;
+ }
+
+ private void visitOptionalCall(CelMutableExpr expr, CelMutableCall call) {
+ CelMutableExpr operand = call.args().get(0);
+ CelMutableExpr field = call.args().get(1);
+ if (!field.getKind().equals(CelExpr.ExprKind.Kind.CONSTANT)
+ || !field.constant().getKind().equals(CelConstant.Kind.STRING_VALUE)) {
+
+ env.reportError(expr.id(), getPosition(field), "unsupported optional field selection");
+ return;
}
+
+ visit(operand);
+
CelType resultType = visitSelectField(expr, operand, field.constant().stringValue(), true);
env.setType(expr, resultType);
env.setRef(expr, CelReference.newBuilder().addOverloadIds("select_optional_field").build());
-
- return expr;
}
/**
@@ -766,8 +780,8 @@ private CelExpr visitOptionalCall(CelExpr expr, CelExpr.CelCall call) {
* expression and returns the name they constitute, or null if the expression cannot be
* interpreted like this.
*/
- private @Nullable String asQualifiedName(CelExpr expr) {
- switch (expr.exprKind().getKind()) {
+ private @Nullable String asQualifiedName(CelMutableExpr expr) {
+ switch (expr.getKind()) {
case IDENT:
return expr.ident().name();
case SELECT:
@@ -839,16 +853,16 @@ private CelType unwrapOptional(CelType type) {
return type.parameters().get(0);
}
- private void assertType(CelExpr expr, CelType type) {
+ private void assertType(CelMutableExpr expr, CelType type) {
assertIsAssignable(expr.id(), getPosition(expr), env.getType(expr), type);
}
- private int getPosition(CelExpr expr) {
+ private int getPosition(CelMutableExpr expr) {
Integer pos = positionMap.get(expr.id());
return pos == null ? 0 : pos;
}
- private int getPosition(CelExpr.CelStruct.Entry entry) {
+ private int getPosition(CelMutableStruct.Entry entry) {
Integer pos = positionMap.get(entry.id());
return pos == null ? 0 : pos;
}
@@ -871,81 +885,4 @@ public static OverloadResolution of(CelReference reference, CelType type) {
/** Helper object to represent a {@link TypeProvider.FieldType} lookup failure. */
private static final TypeProvider.FieldType ERROR = TypeProvider.FieldType.of(Types.ERROR);
-
- private static CelExpr replaceIdentSubtree(CelExpr expr, String name) {
- CelExpr.CelIdent newIdent = CelExpr.CelIdent.newBuilder().setName(name).build();
- return expr.toBuilder().setIdent(newIdent).build();
- }
-
- private static CelExpr replaceSelectOperandSubtree(CelExpr expr, CelExpr operand) {
- CelExpr.CelSelect newSelect = expr.select().toBuilder().setOperand(operand).build();
- return expr.toBuilder().setSelect(newSelect).build();
- }
-
- private static CelExpr replaceCallArgumentSubtree(CelExpr expr, CelExpr newArg, int index) {
- CelExpr.CelCall newCall = expr.call().toBuilder().setArg(index, newArg).build();
- return expr.toBuilder().setCall(newCall).build();
- }
-
- private static CelExpr replaceCallSubtree(CelExpr expr, String functionName) {
- CelExpr.CelCall newCall =
- expr.call().toBuilder().setFunction(functionName).clearTarget().build();
- return expr.toBuilder().setCall(newCall).build();
- }
-
- private static CelExpr replaceCallSubtree(CelExpr expr, CelExpr target) {
- CelExpr.CelCall newCall = expr.call().toBuilder().setTarget(target).build();
- return expr.toBuilder().setCall(newCall).build();
- }
-
- private static CelExpr replaceListElementSubtree(CelExpr expr, CelExpr element, int index) {
- CelExpr.CelList newList = expr.list().toBuilder().setElement(index, element).build();
- return expr.toBuilder().setList(newList).build();
- }
-
- private static CelExpr replaceStructEntryValueSubtree(CelExpr expr, CelExpr newValue, int index) {
- CelExpr.CelStruct struct = expr.struct();
- CelExpr.CelStruct.Entry newEntry =
- struct.entries().get(index).toBuilder().setValue(newValue).build();
- struct = struct.toBuilder().setEntry(index, newEntry).build();
- return expr.toBuilder().setStruct(struct).build();
- }
-
- private static CelExpr replaceMapEntryKeySubtree(CelExpr expr, CelExpr newKey, int index) {
- CelExpr.CelMap map = expr.map();
- CelExpr.CelMap.Entry newEntry = map.entries().get(index).toBuilder().setKey(newKey).build();
- map = map.toBuilder().setEntry(index, newEntry).build();
- return expr.toBuilder().setMap(map).build();
- }
-
- private static CelExpr replaceMapEntryValueSubtree(CelExpr expr, CelExpr newValue, int index) {
- CelExpr.CelMap map = expr.map();
- CelExpr.CelMap.Entry newEntry = map.entries().get(index).toBuilder().setValue(newValue).build();
- map = map.toBuilder().setEntry(index, newEntry).build();
- return expr.toBuilder().setMap(map).build();
- }
-
- private static CelExpr replaceComprehensionAccuInitSubtree(CelExpr expr, CelExpr newAccuInit) {
- CelExpr.CelComprehension newComprehension =
- expr.comprehension().toBuilder().setAccuInit(newAccuInit).build();
- return expr.toBuilder().setComprehension(newComprehension).build();
- }
-
- private static CelExpr replaceComprehensionRangeSubtree(CelExpr expr, CelExpr newRange) {
- CelExpr.CelComprehension newComprehension =
- expr.comprehension().toBuilder().setIterRange(newRange).build();
- return expr.toBuilder().setComprehension(newComprehension).build();
- }
-
- private static CelExpr replaceComprehensionStepSubtree(CelExpr expr, CelExpr newStep) {
- CelExpr.CelComprehension newComprehension =
- expr.comprehension().toBuilder().setLoopStep(newStep).build();
- return expr.toBuilder().setComprehension(newComprehension).build();
- }
-
- private static CelExpr replaceComprehensionResultSubtree(CelExpr expr, CelExpr newResult) {
- CelExpr.CelComprehension newComprehension =
- expr.comprehension().toBuilder().setResult(newResult).build();
- return expr.toBuilder().setComprehension(newComprehension).build();
- }
}
diff --git a/checker/src/test/java/dev/cel/checker/BUILD.bazel b/checker/src/test/java/dev/cel/checker/BUILD.bazel
index 1b8ee9557..1821a5d85 100644
--- a/checker/src/test/java/dev/cel/checker/BUILD.bazel
+++ b/checker/src/test/java/dev/cel/checker/BUILD.bazel
@@ -27,6 +27,7 @@ java_library(
"//common:compiler_common",
"//common:container",
"//common:mutable_ast",
+ "//common:operator",
"//common:options",
"//common:proto_ast",
"//common:source_location",
@@ -42,7 +43,6 @@ java_library(
"//compiler",
"//compiler:compiler_builder",
"//parser:macro",
- "//parser:operator",
"//testing:adorner",
"//testing:cel_baseline_test_case",
"@maven//:junit_junit",
diff --git a/checker/src/test/java/dev/cel/checker/CelProtoExprVisitorTest.java b/checker/src/test/java/dev/cel/checker/CelProtoExprVisitorTest.java
index d9e311ca2..3cab304ac 100644
--- a/checker/src/test/java/dev/cel/checker/CelProtoExprVisitorTest.java
+++ b/checker/src/test/java/dev/cel/checker/CelProtoExprVisitorTest.java
@@ -22,12 +22,12 @@
import com.google.auto.value.AutoValue;
import dev.cel.common.CelAbstractSyntaxTree;
import dev.cel.common.CelContainer;
+import dev.cel.common.Operator;
import dev.cel.common.types.SimpleType;
import dev.cel.compiler.CelCompiler;
import dev.cel.compiler.CelCompilerFactory;
import dev.cel.expr.conformance.proto3.TestAllTypes;
import dev.cel.parser.CelStandardMacro;
-import dev.cel.parser.Operator;
import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
diff --git a/checker/src/test/java/dev/cel/checker/ExprCheckerTest.java b/checker/src/test/java/dev/cel/checker/ExprCheckerTest.java
index c3b26785a..d5d5d9a3a 100644
--- a/checker/src/test/java/dev/cel/checker/ExprCheckerTest.java
+++ b/checker/src/test/java/dev/cel/checker/ExprCheckerTest.java
@@ -199,6 +199,10 @@ public void referenceTypeRelative() throws Exception {
public void referenceTypeAbsolute() throws Exception {
source = ".cel.expr.conformance.proto3.TestAllTypes";
runTest();
+
+ declareVariable("app.config", SimpleType.INT);
+ source = "[0].exists(app, .app.config == 1)";
+ runTest();
}
@Test
diff --git a/checker/src/test/resources/referenceTypeAbsolute.baseline b/checker/src/test/resources/referenceTypeAbsolute.baseline
index 7680854d4..401e6fe0c 100644
--- a/checker/src/test/resources/referenceTypeAbsolute.baseline
+++ b/checker/src/test/resources/referenceTypeAbsolute.baseline
@@ -1,3 +1,36 @@
Source: .cel.expr.conformance.proto3.TestAllTypes
=====>
cel.expr.conformance.proto3.TestAllTypes~type(cel.expr.conformance.proto3.TestAllTypes)^cel.expr.conformance.proto3.TestAllTypes
+
+Source: [0].exists(app, .app.config == 1)
+declare app.config {
+ value int
+}
+=====>
+__comprehension__(
+ // Variable
+ app,
+ // Target
+ [
+ 0~int
+ ]~list(int),
+ // Accumulator
+ @result,
+ // Init
+ false~bool,
+ // LoopCondition
+ @not_strictly_false(
+ !_(
+ @result~bool^@result
+ )~bool^logical_not
+ )~bool^not_strictly_false,
+ // LoopStep
+ _||_(
+ @result~bool^@result,
+ _==_(
+ .app.config~int^.app.config,
+ 1~int
+ )~bool^equals
+ )~bool^logical_or,
+ // Result
+ @result~bool^@result)~bool
diff --git a/codelab/README.md b/codelab/README.md
index 6de1a2fb0..f7d248b13 100644
--- a/codelab/README.md
+++ b/codelab/README.md
@@ -1065,8 +1065,8 @@ public void validate_invalidTimestampLiteral_returnsError() throws Exception {
assertThat(validationResult.hasError()).isTrue();
assertThat(validationResult.getErrorString())
.isEqualTo(
- "ERROR: aliases();
+ abstract ImmutableMap aliasMap();
+
+ /**
+ * Returns the aliases configured in the container.
+ *
+ * The key of the map is the alias and the value is the corresponding fully qualified name.
+ */
+ public ImmutableMap aliases() {
+ return aliasMap().entrySet().stream()
+ .filter(e -> e.getValue().kind().equals(AliasKind.ALIAS))
+ .collect(toImmutableMap(Map.Entry::getKey, e -> e.getValue().qualifiedName()));
+ }
+
+ public ImmutableList abbreviations() {
+ return aliasMap().entrySet().stream()
+ .filter(e -> e.getValue().kind().equals(AliasKind.ABBREVIATION))
+ .map(e -> e.getValue().qualifiedName())
+ .collect(toImmutableList());
+ }
/** Builder for {@link CelContainer} */
@AutoValue.Builder
public abstract static class Builder {
- private final LinkedHashMap aliases = new LinkedHashMap<>();
+ private final LinkedHashMap aliasMap = new LinkedHashMap<>();
abstract String name();
/** Sets the fully-qualified name of the container. */
public abstract Builder setName(String name);
- abstract Builder setAliases(ImmutableMap aliases);
+ abstract Builder setAliasMap(ImmutableMap aliasMap);
/** See {@link #addAbbreviations(ImmutableSet)} for documentation. */
@CanIgnoreReturnValue
@@ -170,7 +193,7 @@ public Builder addAlias(String alias, String qualifiedName) {
private void aliasAs(AliasKind kind, String qualifiedName, String alias) {
validateAliasOrThrow(kind, qualifiedName, alias);
- aliases.put(alias, qualifiedName);
+ aliasMap.put(alias, AliasEntry.create(kind, qualifiedName));
}
private void validateAliasOrThrow(AliasKind kind, String qualifiedName, String alias) {
@@ -185,12 +208,12 @@ private void validateAliasOrThrow(AliasKind kind, String qualifiedName, String a
String.format("qualified name must not begin with a leading '.': %s", qualifiedName));
}
- String aliasRef = aliases.get(alias);
+ AliasEntry aliasRef = aliasMap.get(alias);
if (aliasRef != null) {
throw new IllegalArgumentException(
String.format(
"%s collides with existing reference: name=%s, %s=%s, existing=%s",
- kind, qualifiedName, kind, alias, aliasRef));
+ kind, qualifiedName, kind, alias, aliasRef.qualifiedName()));
}
String containerName = name();
@@ -206,7 +229,7 @@ private void validateAliasOrThrow(AliasKind kind, String qualifiedName, String a
@CheckReturnValue
public CelContainer build() {
- setAliases(ImmutableMap.copyOf(aliases));
+ setAliasMap(ImmutableMap.copyOf(aliasMap));
return autoBuild();
}
}
@@ -263,7 +286,7 @@ public ImmutableSet resolveCandidateNames(String typeName) {
public Builder toBuilder() {
Builder builder = autoToBuilder();
- builder.aliases.putAll(aliases());
+ builder.aliasMap.putAll(aliasMap());
return builder;
}
@@ -284,12 +307,12 @@ private Optional findAlias(String name) {
simple = name.substring(0, dot);
qualifier = name.substring(dot);
}
- String alias = aliases().get(simple);
+ AliasEntry alias = aliasMap().get(simple);
if (alias == null) {
return Optional.empty();
}
- return Optional.of(alias + qualifier);
+ return Optional.of(alias.qualifiedName() + qualifier);
}
private static boolean isIdentifierChar(int r) {
@@ -301,7 +324,7 @@ private static boolean isIdentifierChar(int r) {
return r == '.' || r == '_' || Character.isLetter(r) || Character.isDigit(r);
}
- private enum AliasKind {
+ enum AliasKind {
ALIAS,
ABBREVIATION;
@@ -310,4 +333,17 @@ public String toString() {
return this.name().toLowerCase(Locale.getDefault());
}
}
+
+ /** Represents an alias or abbreviation. */
+ @AutoValue
+ @Immutable
+ abstract static class AliasEntry {
+ static AliasEntry create(AliasKind kind, String qualifiedName) {
+ return new AutoValue_CelContainer_AliasEntry(kind, qualifiedName);
+ }
+
+ abstract AliasKind kind();
+
+ abstract String qualifiedName();
+ }
}
diff --git a/common/src/main/java/dev/cel/common/CelException.java b/common/src/main/java/dev/cel/common/CelException.java
index 9d80a9ba1..55c8623a4 100644
--- a/common/src/main/java/dev/cel/common/CelException.java
+++ b/common/src/main/java/dev/cel/common/CelException.java
@@ -27,11 +27,6 @@ public CelException(String message, Throwable cause) {
super(message, cause);
}
- public CelException(String message, CelErrorCode errorCode) {
- super(message);
- this.errorCode = errorCode;
- }
-
public CelException(String message, Throwable cause, CelErrorCode errorCode) {
super(message, cause);
this.errorCode = errorCode;
diff --git a/common/src/main/java/dev/cel/common/CelMutableAst.java b/common/src/main/java/dev/cel/common/CelMutableAst.java
index fd3fe28f8..dd57d8b4e 100644
--- a/common/src/main/java/dev/cel/common/CelMutableAst.java
+++ b/common/src/main/java/dev/cel/common/CelMutableAst.java
@@ -70,8 +70,19 @@ public Optional getType(long exprId) {
/** Converts this mutable AST into a parsed {@link CelAbstractSyntaxTree}. */
public CelAbstractSyntaxTree toParsedAst() {
+ return toParsedAst(false);
+ }
+
+ /**
+ * Converts this mutable AST into a parsed {@link CelAbstractSyntaxTree}.
+ *
+ * @param retainSourcePositions If true, the source positions (line offsets, code points) will be
+ * retained in the resulting AST. If false, they will be scrubbed.
+ */
+ public CelAbstractSyntaxTree toParsedAst(boolean retainSourcePositions) {
return CelAbstractSyntaxTree.newParsedAst(
- CelMutableExprConverter.fromMutableExpr(mutatedExpr), source.toCelSource());
+ CelMutableExprConverter.fromMutableExpr(mutatedExpr),
+ source.toCelSource(retainSourcePositions));
}
/**
diff --git a/common/src/main/java/dev/cel/common/CelMutableSource.java b/common/src/main/java/dev/cel/common/CelMutableSource.java
index 459042c6d..cf85f5af6 100644
--- a/common/src/main/java/dev/cel/common/CelMutableSource.java
+++ b/common/src/main/java/dev/cel/common/CelMutableSource.java
@@ -17,10 +17,12 @@
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.collect.ImmutableMap.toImmutableMap;
+import com.google.common.collect.ImmutableList;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import dev.cel.common.CelSource.Extension;
import dev.cel.common.ast.CelMutableExpr;
import dev.cel.common.ast.CelMutableExprConverter;
+import dev.cel.common.internal.CelCodePointArray;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
@@ -38,6 +40,9 @@ public final class CelMutableSource {
private String description;
private final Map macroCalls;
private final Set extensions;
+ private final CelCodePointArray codePoints;
+ private final ImmutableList lineOffsets;
+ private final Map positions;
@CanIgnoreReturnValue
public CelMutableSource addMacroCalls(long exprId, CelMutableExpr expr) {
@@ -88,8 +93,13 @@ public Set getExtensions() {
return extensions;
}
- public CelSource toCelSource() {
- return CelSource.newBuilder()
+ public CelSource toCelSource(boolean retainSourcePositions) {
+ CelSource.Builder builder =
+ retainSourcePositions
+ ? CelSource.newBuilder(codePoints, lineOffsets).addPositionsMap(positions)
+ : CelSource.newBuilder();
+
+ return builder
.setDescription(description)
.addAllExtensions(extensions)
.addAllMacroCalls(
@@ -101,7 +111,13 @@ public CelSource toCelSource() {
}
public static CelMutableSource newInstance() {
- return new CelMutableSource("", new HashMap<>(), new HashSet<>());
+ return new CelMutableSource(
+ "",
+ new HashMap<>(),
+ new HashSet<>(),
+ CelCodePointArray.fromString(""),
+ ImmutableList.of(),
+ new HashMap<>());
}
public static CelMutableSource fromCelSource(CelSource source) {
@@ -117,13 +133,24 @@ public static CelMutableSource fromCelSource(CelSource source) {
"Unexpected source collision at ID: " + prev.id());
},
HashMap::new)),
- source.getExtensions());
+ source.getExtensions(),
+ source.getContent(),
+ source.getLineOffsets(),
+ source.getPositionsMap());
}
CelMutableSource(
- String description, Map macroCalls, Set extensions) {
+ String description,
+ Map macroCalls,
+ Set extensions,
+ CelCodePointArray codePoints,
+ ImmutableList lineOffsets,
+ Map positions) {
this.description = checkNotNull(description);
this.macroCalls = checkNotNull(macroCalls);
this.extensions = checkNotNull(extensions);
+ this.codePoints = checkNotNull(codePoints);
+ this.lineOffsets = checkNotNull(lineOffsets);
+ this.positions = checkNotNull(positions);
}
}
diff --git a/common/src/main/java/dev/cel/common/CelOptions.java b/common/src/main/java/dev/cel/common/CelOptions.java
index 3cbfb62b1..9cf9a9caa 100644
--- a/common/src/main/java/dev/cel/common/CelOptions.java
+++ b/common/src/main/java/dev/cel/common/CelOptions.java
@@ -83,6 +83,8 @@ public enum ProtoUnsetFieldOptions {
public abstract boolean enableNamespacedDeclarations();
+ public abstract boolean enableJsonFieldNames();
+
// Evaluation related options
public abstract boolean disableCelStandardEquality();
@@ -115,12 +117,6 @@ public enum ProtoUnsetFieldOptions {
public abstract ProtoUnsetFieldOptions fromProtoUnsetFieldOption();
- public abstract boolean enableStringConversion();
-
- public abstract boolean enableStringConcatenation();
-
- public abstract boolean enableListConcatenation();
-
public abstract boolean enableComprehension();
public abstract int maxRegexProgramSize();
@@ -150,6 +146,7 @@ public static Builder newBuilder() {
.enableTimestampEpoch(false)
.enableHeterogeneousNumericComparisons(false)
.enableNamespacedDeclarations(true)
+ .enableJsonFieldNames(false)
// Evaluation options
.disableCelStandardEquality(true)
.evaluateCanonicalTypesToNativeValues(false)
@@ -166,9 +163,6 @@ public static Builder newBuilder() {
.comprehensionMaxIterations(-1)
.unwrapWellKnownTypesOnFunctionDispatch(true)
.fromProtoUnsetFieldOption(ProtoUnsetFieldOptions.BIND_DEFAULT)
- .enableStringConversion(true)
- .enableStringConcatenation(true)
- .enableListConcatenation(true)
.enableComprehension(true)
.maxRegexProgramSize(-1);
}
@@ -184,6 +178,7 @@ public static Builder current() {
.enableUnsignedLongs(true)
.enableRegexPartialMatch(true)
.errorOnDuplicateMapKeys(true)
+ .evaluateCanonicalTypesToNativeValues(true)
.errorOnIntWrap(true)
.resolveTypeDependencies(true)
.disableCelStandardEquality(false);
@@ -465,7 +460,10 @@ public abstract static class Builder {
* Timestamp: {@code java.time.Instant} instead of {@code com.google.protobuf.Timestamp}.
* Duration: {@code java.time.Duration} instead of {@code com.google.protobuf.Duration}.
*
+ *
+ * @deprecated Do not use. This flag is enabled by default and will be removed in the future.
*/
+ @Deprecated
public abstract Builder evaluateCanonicalTypesToNativeValues(boolean value);
/**
@@ -487,24 +485,6 @@ public abstract static class Builder {
*/
public abstract Builder fromProtoUnsetFieldOption(ProtoUnsetFieldOptions value);
- /**
- * Enables string() overloads for the runtime. This option exists to maintain parity with
- * cel-cpp interpreter options.
- */
- public abstract Builder enableStringConversion(boolean value);
-
- /**
- * Enables string concatenation overload for the runtime. This option exists to maintain parity
- * with cel-cpp interpreter options.
- */
- public abstract Builder enableStringConcatenation(boolean value);
-
- /**
- * Enables list concatenation overload for the runtime. This option exists to maintain parity
- * with cel-cpp interpreter options.
- */
- public abstract Builder enableListConcatenation(boolean value);
-
/**
* Enables comprehension (macros) for the runtime. Setting false has the same effect with
* assigning 0 for {@link #comprehensionMaxIterations()}. This option exists to maintain parity
@@ -525,6 +505,16 @@ public abstract static class Builder {
*/
public abstract Builder maxRegexProgramSize(int value);
+ /**
+ * Use the `json_name` field option on a protobuf message as the name of the field.
+ *
+ * If enabled, the compiler will only accept the `json_name` and no longer recognize the
+ * original protobuf field name. Use with caution as this may break existing expressions during
+ * compilation. The runtime continues to support both names for maintaining backwards
+ * compatibility.
+ */
+ public abstract Builder enableJsonFieldNames(boolean value);
+
public abstract CelOptions build();
}
}
diff --git a/common/src/main/java/dev/cel/common/CelSource.java b/common/src/main/java/dev/cel/common/CelSource.java
index 2678a0a2c..d64049f61 100644
--- a/common/src/main/java/dev/cel/common/CelSource.java
+++ b/common/src/main/java/dev/cel/common/CelSource.java
@@ -148,8 +148,13 @@ public static Builder newBuilder(String text) {
return newBuilder(CelCodePointArray.fromString(text));
}
- public static Builder newBuilder(CelCodePointArray codePointArray) {
- return new Builder(codePointArray, codePointArray.lineOffsets());
+ public static Builder newBuilder(CelCodePointArray codePoints) {
+ return newBuilder(codePoints, codePoints.lineOffsets());
+ }
+
+ public static Builder newBuilder(
+ CelCodePointArray codePoints, ImmutableList lineOffsets) {
+ return new Builder(codePoints, lineOffsets);
}
/** Builder for {@link CelSource}. */
diff --git a/parser/src/main/java/dev/cel/parser/Operator.java b/common/src/main/java/dev/cel/common/Operator.java
similarity index 88%
rename from parser/src/main/java/dev/cel/parser/Operator.java
rename to common/src/main/java/dev/cel/common/Operator.java
index 25bd2ca5b..c49c78267 100644
--- a/parser/src/main/java/dev/cel/parser/Operator.java
+++ b/common/src/main/java/dev/cel/common/Operator.java
@@ -1,4 +1,4 @@
-// Copyright 2022 Google LLC
+// 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.
@@ -12,17 +12,17 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package dev.cel.parser;
+package dev.cel.common;
import com.google.common.collect.ImmutableMap;
-import dev.cel.common.ast.CelExpr;
import java.util.Objects;
import java.util.Optional;
/**
* Package-private enumeration of Common Expression Language operators.
*
- * Equivalent to https://pkg.go.dev/github.com/google/cel-go/common/operators.
+ *
Equivalent to operators .
*/
public enum Operator {
CONDITIONAL("_?_:_"),
@@ -45,7 +45,9 @@ public enum Operator {
HAS("has"),
ALL("all"),
EXISTS("exists"),
+ @Deprecated // Prefer EXISTS_ONE_NEW.
EXISTS_ONE("exists_one"),
+ EXISTS_ONE_NEW("existsOne"),
MAP("map"),
FILTER("filter"),
NOT_STRICTLY_FALSE("@not_strictly_false"),
@@ -96,7 +98,7 @@ String getSymbol() {
.buildOrThrow();
/** Lookup an operator by its unmangled name, as used with the source text of an expression. */
- static Optional find(String text) {
+ public static Optional find(String text) {
return Optional.ofNullable(OPERATORS.get(text));
}
@@ -109,6 +111,7 @@ static Optional find(String text) {
.put(EQUALS.getFunction(), EQUALS)
.put(EXISTS.getFunction(), EXISTS)
.put(EXISTS_ONE.getFunction(), EXISTS_ONE)
+ .put(EXISTS_ONE_NEW.getFunction(), EXISTS_ONE_NEW)
.put(FILTER.getFunction(), FILTER)
.put(GREATER.getFunction(), GREATER)
.put(GREATER_EQUALS.getFunction(), GREATER_EQUALS)
@@ -193,26 +196,23 @@ static Optional findReverseBinaryOperator(String op) {
return Optional.ofNullable(REVERSE_OPERATORS.get(op));
}
- static int lookupPrecedence(String op) {
+ /**
+ * Returns the precedence of the operator.
+ *
+ * @return Integer value describing precedence. Higher value means higher precedence. Returns 0 if
+ * the operator is not found.
+ */
+ public static int lookupPrecedence(String op) {
return PRECEDENCES.getOrDefault(op, 0);
}
- static Optional lookupUnaryOperator(String op) {
+ /** Looks up the associated unary operator based on its function name (Ex: !_ -> !) */
+ public static Optional lookupUnaryOperator(String op) {
return Optional.ofNullable(UNARY_OPERATORS.get(op));
}
- static Optional lookupBinaryOperator(String op) {
+ /** Looks up the associated binary operator based on its function name (Ex: _||_ -> ||) */
+ public static Optional lookupBinaryOperator(String op) {
return Optional.ofNullable(BINARY_OPERATORS.get(op));
}
-
- static boolean isOperatorLowerPrecedence(String op, CelExpr expr) {
- if (!expr.exprKind().getKind().equals(CelExpr.ExprKind.Kind.CALL)) {
- return false;
- }
- return lookupPrecedence(op) < lookupPrecedence(expr.call().function());
- }
-
- static boolean isOperatorLeftRecursive(String op) {
- return !op.equals(LOGICAL_AND.getFunction()) && !op.equals(LOGICAL_OR.getFunction());
- }
}
diff --git a/common/src/main/java/dev/cel/common/ast/CelExprFactory.java b/common/src/main/java/dev/cel/common/ast/CelExprFactory.java
index 9ad23952e..b69dab05c 100644
--- a/common/src/main/java/dev/cel/common/ast/CelExprFactory.java
+++ b/common/src/main/java/dev/cel/common/ast/CelExprFactory.java
@@ -264,12 +264,5 @@ protected long nextExprId() {
return ++exprId;
}
- /** Attempts to decrement the next expr ID if possible. */
- protected void maybeDeleteId(long id) {
- if (id == exprId - 1) {
- exprId--;
- }
- }
-
protected CelExprFactory() {}
}
diff --git a/common/src/main/java/dev/cel/common/exceptions/BUILD.bazel b/common/src/main/java/dev/cel/common/exceptions/BUILD.bazel
new file mode 100644
index 000000000..672238cf0
--- /dev/null
+++ b/common/src/main/java/dev/cel/common/exceptions/BUILD.bazel
@@ -0,0 +1,138 @@
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(
+ default_applicable_licenses = ["//:license"],
+ default_visibility = [
+ "//common/exceptions:__pkg__",
+ "//publish:__pkg__",
+ ],
+)
+
+java_library(
+ name = "runtime_exception",
+ srcs = ["CelRuntimeException.java"],
+ # used_by_android
+ tags = [
+ ],
+ deps = [
+ "//common:error_codes",
+ "//common/annotations",
+ ],
+)
+
+java_library(
+ name = "attribute_not_found",
+ srcs = ["CelAttributeNotFoundException.java"],
+ # used_by_android
+ tags = [
+ ],
+ deps = [
+ ":runtime_exception",
+ "//common:error_codes",
+ "//common/annotations",
+ ],
+)
+
+java_library(
+ name = "divide_by_zero",
+ srcs = ["CelDivideByZeroException.java"],
+ # used_by_android
+ tags = [
+ ],
+ deps = [
+ ":runtime_exception",
+ "//common:error_codes",
+ "//common/annotations",
+ ],
+)
+
+java_library(
+ name = "index_out_of_bounds",
+ srcs = ["CelIndexOutOfBoundsException.java"],
+ # used_by_android
+ tags = [
+ ],
+ deps = [
+ ":runtime_exception",
+ "//common:error_codes",
+ "//common/annotations",
+ ],
+)
+
+java_library(
+ name = "bad_format",
+ srcs = ["CelBadFormatException.java"],
+ # used_by_android
+ tags = [
+ ],
+ deps = [
+ ":runtime_exception",
+ "//common:error_codes",
+ "//common/annotations",
+ ],
+)
+
+java_library(
+ name = "numeric_overflow",
+ srcs = ["CelNumericOverflowException.java"],
+ # used_by_android
+ tags = [
+ ],
+ deps = [
+ ":runtime_exception",
+ "//common:error_codes",
+ "//common/annotations",
+ ],
+)
+
+java_library(
+ name = "invalid_argument",
+ srcs = ["CelInvalidArgumentException.java"],
+ # used_by_android
+ tags = [
+ ],
+ deps = [
+ ":runtime_exception",
+ "//common:error_codes",
+ "//common/annotations",
+ ],
+)
+
+java_library(
+ name = "iteration_budget_exceeded",
+ srcs = ["CelIterationLimitExceededException.java"],
+ # used_by_android
+ tags = [
+ ],
+ deps = [
+ ":runtime_exception",
+ "//common:error_codes",
+ "//common/annotations",
+ ],
+)
+
+java_library(
+ name = "duplicate_key",
+ srcs = ["CelDuplicateKeyException.java"],
+ # used_by_android
+ tags = [
+ ],
+ deps = [
+ ":runtime_exception",
+ "//common:error_codes",
+ "//common/annotations",
+ ],
+)
+
+java_library(
+ name = "overload_not_found",
+ srcs = ["CelOverloadNotFoundException.java"],
+ # used_by_android
+ tags = [
+ ],
+ deps = [
+ ":runtime_exception",
+ "//common:error_codes",
+ "//common/annotations",
+ ],
+)
diff --git a/common/src/main/java/dev/cel/common/exceptions/CelAttributeNotFoundException.java b/common/src/main/java/dev/cel/common/exceptions/CelAttributeNotFoundException.java
new file mode 100644
index 000000000..d805c9cf4
--- /dev/null
+++ b/common/src/main/java/dev/cel/common/exceptions/CelAttributeNotFoundException.java
@@ -0,0 +1,61 @@
+// 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.exceptions;
+
+import dev.cel.common.CelErrorCode;
+import dev.cel.common.annotations.Internal;
+import java.util.Arrays;
+import java.util.Collection;
+
+/** Indicates an attempt to access a map or object using an invalid attribute or key. */
+@Internal
+public final class CelAttributeNotFoundException extends CelRuntimeException {
+
+ public static CelAttributeNotFoundException of(String message) {
+ return new CelAttributeNotFoundException(message);
+ }
+
+ public static CelAttributeNotFoundException forMissingMapKey(String key) {
+ return new CelAttributeNotFoundException(String.format("key '%s' is not present in map.", key));
+ }
+
+ public static CelAttributeNotFoundException forFieldResolution(String... fields) {
+ return forFieldResolution(Arrays.asList(fields));
+ }
+
+ public static CelAttributeNotFoundException forFieldResolution(Collection fields) {
+ return new CelAttributeNotFoundException(formatErrorMessage(fields));
+ }
+
+ public static CelAttributeNotFoundException forMissingAttributes(Collection attributes) {
+ return new CelAttributeNotFoundException(
+ "No such attribute(s): " + String.join(", ", attributes));
+ }
+
+ private static String formatErrorMessage(Collection fields) {
+ String maybePlural = "";
+ if (fields.size() > 1) {
+ maybePlural = "s";
+ }
+
+ return String.format(
+ "Error resolving field%s '%s'. Field selections must be performed on messages or maps.",
+ maybePlural, String.join(", ", fields));
+ }
+
+ private CelAttributeNotFoundException(String message) {
+ super(message, CelErrorCode.ATTRIBUTE_NOT_FOUND);
+ }
+}
diff --git a/common/src/main/java/dev/cel/common/exceptions/CelBadFormatException.java b/common/src/main/java/dev/cel/common/exceptions/CelBadFormatException.java
new file mode 100644
index 000000000..ba4db602a
--- /dev/null
+++ b/common/src/main/java/dev/cel/common/exceptions/CelBadFormatException.java
@@ -0,0 +1,31 @@
+// 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.exceptions;
+
+import dev.cel.common.CelErrorCode;
+import dev.cel.common.annotations.Internal;
+
+/** Indicates that a data conversion failed due to a mismatch in the format specification. */
+@Internal
+public final class CelBadFormatException extends CelRuntimeException {
+
+ public CelBadFormatException(Throwable cause) {
+ super(cause, CelErrorCode.BAD_FORMAT);
+ }
+
+ public CelBadFormatException(String errorMessage) {
+ super(errorMessage, CelErrorCode.BAD_FORMAT);
+ }
+}
diff --git a/runtime/src/main/java/dev/cel/runtime/standard/ArithmeticHelpers.java b/common/src/main/java/dev/cel/common/exceptions/CelDivideByZeroException.java
similarity index 59%
rename from runtime/src/main/java/dev/cel/runtime/standard/ArithmeticHelpers.java
rename to common/src/main/java/dev/cel/common/exceptions/CelDivideByZeroException.java
index 310e9401f..c507797c5 100644
--- a/runtime/src/main/java/dev/cel/runtime/standard/ArithmeticHelpers.java
+++ b/common/src/main/java/dev/cel/common/exceptions/CelDivideByZeroException.java
@@ -12,20 +12,20 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package dev.cel.runtime.standard;
+package dev.cel.common.exceptions;
import dev.cel.common.CelErrorCode;
+import dev.cel.common.annotations.Internal;
-final class ArithmeticHelpers {
+/** Indicates that a division by zero occurred. */
+@Internal
+public final class CelDivideByZeroException extends CelRuntimeException {
- static CelErrorCode getArithmeticErrorCode(ArithmeticException e) {
- String exceptionMessage = e.getMessage();
- // The two known cases for an arithmetic exception is divide by zero and overflow.
- if (exceptionMessage.equals("/ by zero")) {
- return CelErrorCode.DIVIDE_BY_ZERO;
- }
- return CelErrorCode.NUMERIC_OVERFLOW;
+ public CelDivideByZeroException() {
+ super("/ by zero", CelErrorCode.DIVIDE_BY_ZERO);
}
- private ArithmeticHelpers() {}
+ public CelDivideByZeroException(Throwable cause) {
+ super(cause, CelErrorCode.DIVIDE_BY_ZERO);
+ }
}
diff --git a/common/src/main/java/dev/cel/common/exceptions/CelDuplicateKeyException.java b/common/src/main/java/dev/cel/common/exceptions/CelDuplicateKeyException.java
new file mode 100644
index 000000000..f4c99d516
--- /dev/null
+++ b/common/src/main/java/dev/cel/common/exceptions/CelDuplicateKeyException.java
@@ -0,0 +1,31 @@
+// Copyright 2026 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.exceptions;
+
+import dev.cel.common.CelErrorCode;
+import dev.cel.common.annotations.Internal;
+
+/** Indicates an attempt to create a map using duplicate keys. */
+@Internal
+public final class CelDuplicateKeyException extends CelRuntimeException {
+
+ public static CelDuplicateKeyException of(Object key) {
+ return new CelDuplicateKeyException(String.format("duplicate map key [%s]", key));
+ }
+
+ private CelDuplicateKeyException(String message) {
+ super(message, CelErrorCode.DUPLICATE_ATTRIBUTE);
+ }
+}
diff --git a/common/src/main/java/dev/cel/common/exceptions/CelIndexOutOfBoundsException.java b/common/src/main/java/dev/cel/common/exceptions/CelIndexOutOfBoundsException.java
new file mode 100644
index 000000000..72a6cd1c0
--- /dev/null
+++ b/common/src/main/java/dev/cel/common/exceptions/CelIndexOutOfBoundsException.java
@@ -0,0 +1,27 @@
+// 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.exceptions;
+
+import dev.cel.common.CelErrorCode;
+import dev.cel.common.annotations.Internal;
+
+/** Indicates that a list index access was attempted using an index that is out of bounds. */
+@Internal
+public final class CelIndexOutOfBoundsException extends CelRuntimeException {
+
+ public CelIndexOutOfBoundsException(Object index) {
+ super("Index out of bounds: " + index, CelErrorCode.INDEX_OUT_OF_BOUNDS);
+ }
+}
diff --git a/common/src/main/java/dev/cel/common/exceptions/CelInvalidArgumentException.java b/common/src/main/java/dev/cel/common/exceptions/CelInvalidArgumentException.java
new file mode 100644
index 000000000..6a2b4ab72
--- /dev/null
+++ b/common/src/main/java/dev/cel/common/exceptions/CelInvalidArgumentException.java
@@ -0,0 +1,31 @@
+// 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.exceptions;
+
+import dev.cel.common.CelErrorCode;
+import dev.cel.common.annotations.Internal;
+
+/** Indicates that an invalid argument was supplied to a function. */
+@Internal
+public final class CelInvalidArgumentException extends CelRuntimeException {
+
+ public CelInvalidArgumentException(Throwable cause) {
+ super(cause, CelErrorCode.INVALID_ARGUMENT);
+ }
+
+ public CelInvalidArgumentException(String message) {
+ super(message, CelErrorCode.INVALID_ARGUMENT);
+ }
+}
diff --git a/common/src/main/java/dev/cel/common/exceptions/CelIterationLimitExceededException.java b/common/src/main/java/dev/cel/common/exceptions/CelIterationLimitExceededException.java
new file mode 100644
index 000000000..cfaa25f35
--- /dev/null
+++ b/common/src/main/java/dev/cel/common/exceptions/CelIterationLimitExceededException.java
@@ -0,0 +1,30 @@
+// 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.exceptions;
+
+import dev.cel.common.CelErrorCode;
+import dev.cel.common.annotations.Internal;
+import java.util.Locale;
+
+/** Indicates that the iteration budget for a comprehension has been exceeded. */
+@Internal
+public final class CelIterationLimitExceededException extends CelRuntimeException {
+
+ public CelIterationLimitExceededException(int budget) {
+ super(
+ String.format(Locale.US, "Iteration budget exceeded: %d", budget),
+ CelErrorCode.ITERATION_BUDGET_EXCEEDED);
+ }
+}
diff --git a/common/src/main/java/dev/cel/common/exceptions/CelNumericOverflowException.java b/common/src/main/java/dev/cel/common/exceptions/CelNumericOverflowException.java
new file mode 100644
index 000000000..78fbe807e
--- /dev/null
+++ b/common/src/main/java/dev/cel/common/exceptions/CelNumericOverflowException.java
@@ -0,0 +1,34 @@
+// 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.exceptions;
+
+import dev.cel.common.CelErrorCode;
+import dev.cel.common.annotations.Internal;
+
+/**
+ * Indicates that a numeric overflow occurred due to arithmetic operations or conversions resulting
+ * in a value outside the representable range.
+ */
+@Internal
+public final class CelNumericOverflowException extends CelRuntimeException {
+
+ public CelNumericOverflowException(String message) {
+ super(message, CelErrorCode.NUMERIC_OVERFLOW);
+ }
+
+ public CelNumericOverflowException(Throwable cause) {
+ super(cause, CelErrorCode.NUMERIC_OVERFLOW);
+ }
+}
diff --git a/common/src/main/java/dev/cel/common/exceptions/CelOverloadNotFoundException.java b/common/src/main/java/dev/cel/common/exceptions/CelOverloadNotFoundException.java
new file mode 100644
index 000000000..d7c4a01a8
--- /dev/null
+++ b/common/src/main/java/dev/cel/common/exceptions/CelOverloadNotFoundException.java
@@ -0,0 +1,43 @@
+// Copyright 2026 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.exceptions;
+
+import dev.cel.common.CelErrorCode;
+import dev.cel.common.annotations.Internal;
+import java.util.Collection;
+import java.util.Collections;
+
+/** Indicates that a matching overload could not be found during function dispatch. */
+@Internal
+public final class CelOverloadNotFoundException extends CelRuntimeException {
+
+ public CelOverloadNotFoundException(String functionName) {
+ this(functionName, Collections.emptyList());
+ }
+
+ public CelOverloadNotFoundException(String functionName, Collection overloadIds) {
+ super(formatErrorMessage(functionName, overloadIds), CelErrorCode.OVERLOAD_NOT_FOUND);
+ }
+
+ private static String formatErrorMessage(String functionName, Collection overloadIds) {
+ StringBuilder sb = new StringBuilder();
+ sb.append("No matching overload for function '").append(functionName).append("'.");
+ if (!overloadIds.isEmpty()) {
+ sb.append(" Overload candidates: ").append(String.join(", ", overloadIds));
+ }
+
+ return sb.toString();
+ }
+}
diff --git a/common/src/main/java/dev/cel/common/CelRuntimeException.java b/common/src/main/java/dev/cel/common/exceptions/CelRuntimeException.java
similarity index 80%
rename from common/src/main/java/dev/cel/common/CelRuntimeException.java
rename to common/src/main/java/dev/cel/common/exceptions/CelRuntimeException.java
index 6f194c474..c87e192bd 100644
--- a/common/src/main/java/dev/cel/common/CelRuntimeException.java
+++ b/common/src/main/java/dev/cel/common/exceptions/CelRuntimeException.java
@@ -12,8 +12,9 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package dev.cel.common;
+package dev.cel.common.exceptions;
+import dev.cel.common.CelErrorCode;
import dev.cel.common.annotations.Internal;
/**
@@ -21,14 +22,16 @@
*
* Note: This is not to be confused with the notion of CEL Runtime. Use {@code
* CelEvaluationException} instead to signify an evaluation error.
- *
- *
TODO: Make this class abstract and define specific exception classes that
- * corresponds to the CelErrorCode.
*/
@Internal
-public class CelRuntimeException extends RuntimeException {
+public abstract class CelRuntimeException extends RuntimeException {
private final CelErrorCode errorCode;
+ CelRuntimeException(String errorMessage, CelErrorCode errorCode) {
+ super(errorMessage);
+ this.errorCode = errorCode;
+ }
+
public CelRuntimeException(Throwable cause, CelErrorCode errorCode) {
super(cause);
this.errorCode = errorCode;
diff --git a/common/src/main/java/dev/cel/common/formats/BUILD.bazel b/common/src/main/java/dev/cel/common/formats/BUILD.bazel
index 16918cb3a..e906c8ba2 100644
--- a/common/src/main/java/dev/cel/common/formats/BUILD.bazel
+++ b/common/src/main/java/dev/cel/common/formats/BUILD.bazel
@@ -71,6 +71,7 @@ java_library(
],
deps = [
"//:auto_value",
+ "//common:cel_source_helper",
"//common:source",
"//common:source_location",
"//common/internal",
diff --git a/common/src/main/java/dev/cel/common/internal/BUILD.bazel b/common/src/main/java/dev/cel/common/internal/BUILD.bazel
index 690b1cc75..912b4de4b 100644
--- a/common/src/main/java/dev/cel/common/internal/BUILD.bazel
+++ b/common/src/main/java/dev/cel/common/internal/BUILD.bazel
@@ -7,6 +7,7 @@ package(
],
default_visibility = [
"//common/internal:__pkg__",
+ "//publish:__pkg__",
],
)
@@ -14,7 +15,6 @@ package(
INTERNAL_SOURCES = [
"BasicCodePointArray.java",
"CelCodePointArray.java",
- "CodePointStream.java",
"Constants.java",
"EmptyCodePointArray.java",
"Latin1CodePointArray.java",
@@ -34,6 +34,19 @@ CEL_DESCRIPTOR_POOL_SOURCES = [
"DefaultDescriptorPool.java",
]
+java_library(
+ name = "code_point_stream",
+ srcs = ["CodePointStream.java"],
+ tags = [
+ ],
+ deps = [
+ ":internal",
+ "//common/annotations",
+ "@maven//:com_google_guava_guava",
+ "@maven//:org_antlr_antlr4_runtime",
+ ],
+)
+
java_library(
name = "internal",
srcs = INTERNAL_SOURCES,
@@ -48,7 +61,6 @@ java_library(
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_guava_guava",
"@maven//:com_google_protobuf_protobuf_java",
- "@maven//:org_antlr_antlr4_runtime",
],
)
@@ -65,7 +77,6 @@ cel_android_library(
"//common/values:values_android",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_guava_guava",
- "@maven//:org_antlr_antlr4_runtime",
"@maven_android//:com_google_guava_guava",
"@maven_android//:com_google_protobuf_protobuf_javalite",
],
@@ -173,11 +184,9 @@ java_library(
":proto_lite_adapter",
":proto_message_factory",
":well_known_proto",
- "//:auto_value",
- "//common:error_codes",
"//common:options",
- "//common:runtime_exception",
"//common/annotations",
+ "//common/exceptions:numeric_overflow",
"//common/values",
"//common/values:cel_byte_string",
"@maven//:com_google_code_findbugs_annotations",
@@ -194,11 +203,10 @@ java_library(
],
deps = [
":well_known_proto",
- "//common:error_codes",
"//common:options",
"//common:proto_json_adapter",
- "//common:runtime_exception",
"//common/annotations",
+ "//common/exceptions:numeric_overflow",
"//common/internal:proto_time_utils",
"//common/values",
"//common/values:cel_byte_string",
@@ -429,6 +437,7 @@ cel_android_library(
deps = [
"//common/annotations",
"@maven//:com_google_errorprone_error_prone_annotations",
+ "@maven//:com_google_guava_guava",
"@maven_android//:com_google_guava_guava",
"@maven_android//:com_google_protobuf_protobuf_javalite",
],
@@ -440,9 +449,8 @@ java_library(
tags = [
],
deps = [
- "//common:error_codes",
- "//common:runtime_exception",
"//common/annotations",
+ "//common/exceptions:bad_format",
"@maven//:com_google_guava_guava",
"@maven//:com_google_protobuf_protobuf_java",
],
@@ -454,9 +462,8 @@ cel_android_library(
tags = [
],
deps = [
- "//common:error_codes",
- "//common:runtime_exception",
"//common/annotations",
+ "//common/exceptions:bad_format",
"@maven_android//:com_google_guava_guava",
"@maven_android//:com_google_protobuf_protobuf_javalite",
],
diff --git a/common/src/main/java/dev/cel/common/internal/CelCodePointArray.java b/common/src/main/java/dev/cel/common/internal/CelCodePointArray.java
index 2bc606981..1f3124c93 100644
--- a/common/src/main/java/dev/cel/common/internal/CelCodePointArray.java
+++ b/common/src/main/java/dev/cel/common/internal/CelCodePointArray.java
@@ -57,7 +57,6 @@ public boolean isEmpty() {
@Override
public abstract String toString();
- @SuppressWarnings("AndroidJdkLibsChecker") // PrimitiveIterator added in 23
public static CelCodePointArray fromString(String text) {
if (isNullOrEmpty(text)) {
return EmptyCodePointArray.INSTANCE;
diff --git a/common/src/main/java/dev/cel/common/internal/Constants.java b/common/src/main/java/dev/cel/common/internal/Constants.java
index 7a9ffa1ec..d2c0719ec 100644
--- a/common/src/main/java/dev/cel/common/internal/Constants.java
+++ b/common/src/main/java/dev/cel/common/internal/Constants.java
@@ -32,7 +32,6 @@
*
CEL Library Internals. Do Not Use.
*/
@Internal
-@SuppressWarnings("AndroidJdkLibsChecker") // PrimitiveIterator added in 23
public final class Constants {
private static final String DOUBLE_QUOTE = "\"";
diff --git a/common/src/main/java/dev/cel/common/internal/Converter.java b/common/src/main/java/dev/cel/common/internal/Converter.java
index 2437d3093..2c52d0219 100644
--- a/common/src/main/java/dev/cel/common/internal/Converter.java
+++ b/common/src/main/java/dev/cel/common/internal/Converter.java
@@ -21,7 +21,6 @@
*
*
CEL Library Internals. Do Not Use.
*/
-@SuppressWarnings("AndroidJdkLibsChecker") // FunctionalInterface added in 24
@FunctionalInterface
@Internal
public interface Converter {
diff --git a/common/src/main/java/dev/cel/common/internal/DateTimeHelpers.java b/common/src/main/java/dev/cel/common/internal/DateTimeHelpers.java
index 9abe39b4b..805a9bd75 100644
--- a/common/src/main/java/dev/cel/common/internal/DateTimeHelpers.java
+++ b/common/src/main/java/dev/cel/common/internal/DateTimeHelpers.java
@@ -16,9 +16,8 @@
import com.google.common.base.Strings;
import com.google.protobuf.Timestamp;
-import dev.cel.common.CelErrorCode;
-import dev.cel.common.CelRuntimeException;
import dev.cel.common.annotations.Internal;
+import dev.cel.common.exceptions.CelBadFormatException;
import java.time.DateTimeException;
import java.time.Duration;
import java.time.Instant;
@@ -184,7 +183,7 @@ private static ZoneId timeZone(String tz) {
try {
int ind = tz.indexOf(":");
if (ind == -1) {
- throw new CelRuntimeException(e, CelErrorCode.BAD_FORMAT);
+ throw new CelBadFormatException(e);
}
int hourOffset = Integer.parseInt(tz.substring(0, ind));
@@ -199,13 +198,13 @@ private static ZoneId timeZone(String tz) {
return ZoneId.of(formattedOffset);
} catch (DateTimeException e2) {
- throw new CelRuntimeException(e2, CelErrorCode.BAD_FORMAT);
+ throw new CelBadFormatException(e2);
}
}
}
/** Throws an {@link IllegalArgumentException} if the given {@link Timestamp} is not valid. */
- private static void checkValid(Instant instant) {
+ public static void checkValid(Instant instant) {
long seconds = instant.getEpochSecond();
if (seconds < TIMESTAMP_SECONDS_MIN || seconds > TIMESTAMP_SECONDS_MAX) {
diff --git a/common/src/main/java/dev/cel/common/internal/ProtoAdapter.java b/common/src/main/java/dev/cel/common/internal/ProtoAdapter.java
index cd4be2f5e..b6648a5b8 100644
--- a/common/src/main/java/dev/cel/common/internal/ProtoAdapter.java
+++ b/common/src/main/java/dev/cel/common/internal/ProtoAdapter.java
@@ -31,10 +31,9 @@
import com.google.protobuf.MapEntry;
import com.google.protobuf.Message;
import com.google.protobuf.MessageOrBuilder;
-import dev.cel.common.CelErrorCode;
import dev.cel.common.CelOptions;
-import dev.cel.common.CelRuntimeException;
import dev.cel.common.annotations.Internal;
+import dev.cel.common.exceptions.CelNumericOverflowException;
import dev.cel.common.values.CelByteString;
import dev.cel.common.values.NullValue;
import java.util.ArrayList;
@@ -193,7 +192,9 @@ public Optional adaptFieldToValue(FieldDescriptor fieldDescriptor, Objec
if (bidiConverter == BidiConverter.IDENTITY) {
return Optional.of(fieldValue);
}
- return Optional.of(AdaptingTypes.adaptingList((List) fieldValue, bidiConverter));
+ ArrayList convertedList =
+ new ArrayList<>(AdaptingTypes.adaptingList((List) fieldValue, bidiConverter));
+ return Optional.of(convertedList);
}
return Optional.of(
@@ -203,8 +204,29 @@ public Optional adaptFieldToValue(FieldDescriptor fieldDescriptor, Objec
@SuppressWarnings({"unchecked", "rawtypes"})
public Optional adaptValueToFieldType(
FieldDescriptor fieldDescriptor, Object fieldValue) {
- if (isWrapperType(fieldDescriptor) && fieldValue.equals(NullValue.NULL_VALUE)) {
- return Optional.empty();
+ if (fieldValue instanceof NullValue) {
+ // `null` assignment to fields indicate that the field would not be set
+ // in a protobuf message (e.g: Message{msg_field: null} -> Message{})
+ //
+ // We explicitly check below for invalid null assignments, such as repeated
+ // or map fields. (e.g: Message{repeated_field: null} -> Error)
+ if (fieldDescriptor.isMapField()
+ || fieldDescriptor.isRepeated()
+ || fieldDescriptor.getJavaType() != FieldDescriptor.JavaType.MESSAGE
+ || WellKnownProto.JSON_STRUCT_VALUE
+ .typeName()
+ .equals(fieldDescriptor.getMessageType().getFullName())
+ || WellKnownProto.JSON_LIST_VALUE
+ .typeName()
+ .equals(fieldDescriptor.getMessageType().getFullName())) {
+ throw new IllegalArgumentException("Unsupported field type");
+ }
+
+ String typeFullName = fieldDescriptor.getMessageType().getFullName();
+ if (!WellKnownProto.ANY_VALUE.typeName().equals(typeFullName)
+ && !WellKnownProto.JSON_VALUE.typeName().equals(typeFullName)) {
+ return Optional.empty();
+ }
}
if (fieldDescriptor.isMapField()) {
Descriptor entryDescriptor = fieldDescriptor.getMessageType();
@@ -245,28 +267,48 @@ private BidiConverter fieldToValueConverter(FieldDescriptor fieldDescriptor) {
case SFIXED32:
case SINT32:
case INT32:
- return INT_CONVERTER;
+ return unwrapAndConvert(INT_CONVERTER);
case FIXED32:
case UINT32:
if (celOptions.enableUnsignedLongs()) {
- return UNSIGNED_UINT32_CONVERTER;
+ return unwrapAndConvert(UNSIGNED_UINT32_CONVERTER);
}
- return SIGNED_UINT32_CONVERTER;
+ return unwrapAndConvert(SIGNED_UINT32_CONVERTER);
case FIXED64:
case UINT64:
if (celOptions.enableUnsignedLongs()) {
- return UNSIGNED_UINT64_CONVERTER;
+ return unwrapAndConvert(UNSIGNED_UINT64_CONVERTER);
}
- return BidiConverter.IDENTITY;
+ return BidiConverter.of(
+ BidiConverter.IDENTITY.forwardConverter(),
+ value -> BidiConverter.IDENTITY.backwardConverter().convert(maybeUnwrap(value)));
case FLOAT:
- return DOUBLE_CONVERTER;
+ return unwrapAndConvert(DOUBLE_CONVERTER);
+ case DOUBLE:
+ case SFIXED64:
+ case SINT64:
+ case INT64:
+ return BidiConverter.of(
+ BidiConverter.IDENTITY.forwardConverter(),
+ value -> BidiConverter.IDENTITY.backwardConverter().convert(maybeUnwrap(value)));
case BYTES:
if (celOptions.evaluateCanonicalTypesToNativeValues()) {
return BidiConverter.of(
- ProtoAdapter::adaptProtoByteStringToValue, ProtoAdapter::adaptCelByteStringToProto);
+ ProtoAdapter::adaptProtoByteStringToValue,
+ value -> adaptCelByteStringToProto(maybeUnwrap(value)));
}
- return BidiConverter.IDENTITY;
+ return BidiConverter.of(
+ BidiConverter.IDENTITY.forwardConverter(),
+ value -> BidiConverter.IDENTITY.backwardConverter().convert(maybeUnwrap(value)));
+ case STRING:
+ return BidiConverter.of(
+ BidiConverter.IDENTITY.forwardConverter(),
+ value -> BidiConverter.IDENTITY.backwardConverter().convert(maybeUnwrap(value)));
+ case BOOL:
+ return BidiConverter.of(
+ BidiConverter.IDENTITY.forwardConverter(),
+ value -> BidiConverter.IDENTITY.backwardConverter().convert(maybeUnwrap(value)));
case ENUM:
return BidiConverter.of(
value -> (long) ((EnumValueDescriptor) value).getNumber(),
@@ -349,19 +391,11 @@ private static String typeName(Descriptor protoType) {
return protoType.getFullName();
}
- private static boolean isWrapperType(FieldDescriptor fieldDescriptor) {
- if (fieldDescriptor.getJavaType() != FieldDescriptor.JavaType.MESSAGE) {
- return false;
- }
- String fieldTypeName = fieldDescriptor.getMessageType().getFullName();
- return WellKnownProto.isWrapperType(fieldTypeName);
- }
-
private static int intCheckedCast(long value) {
try {
return Ints.checkedCast(value);
} catch (IllegalArgumentException e) {
- throw new CelRuntimeException(e, CelErrorCode.NUMERIC_OVERFLOW);
+ throw new CelNumericOverflowException(e);
}
}
@@ -369,7 +403,21 @@ private static int unsignedIntCheckedCast(long value) {
try {
return UnsignedInts.checkedCast(value);
} catch (IllegalArgumentException e) {
- throw new CelRuntimeException(e, CelErrorCode.NUMERIC_OVERFLOW);
+ throw new CelNumericOverflowException(e);
+ }
+ }
+
+ private Object maybeUnwrap(Object value) {
+ if (value instanceof Message) {
+ return adaptProtoToValue((MessageOrBuilder) value);
}
+ return value;
+ }
+
+ private BidiConverter unwrapAndConvert(
+ final BidiConverter original) {
+ return BidiConverter.of(
+ original.forwardConverter()::convert,
+ value -> original.backwardConverter().convert((Number) maybeUnwrap(value)));
}
}
diff --git a/common/src/main/java/dev/cel/common/internal/ProtoJavaQualifiedNames.java b/common/src/main/java/dev/cel/common/internal/ProtoJavaQualifiedNames.java
index cf393455b..f27181a50 100644
--- a/common/src/main/java/dev/cel/common/internal/ProtoJavaQualifiedNames.java
+++ b/common/src/main/java/dev/cel/common/internal/ProtoJavaQualifiedNames.java
@@ -14,18 +14,10 @@
package dev.cel.common.internal;
-import com.google.common.base.CaseFormat;
-import com.google.common.base.Joiner;
-import com.google.common.base.Strings;
-import com.google.common.io.Files;
-import com.google.protobuf.DescriptorProtos.FileOptions;
import com.google.protobuf.Descriptors.Descriptor;
-import com.google.protobuf.Descriptors.EnumDescriptor;
import com.google.protobuf.Descriptors.FileDescriptor;
-import com.google.protobuf.Descriptors.GenericDescriptor;
-import com.google.protobuf.Descriptors.ServiceDescriptor;
+import com.google.protobuf.GeneratorNames;
import dev.cel.common.annotations.Internal;
-import java.util.ArrayDeque;
/**
* Helper class for constructing a fully qualified Java class name from a protobuf descriptor.
@@ -34,10 +26,6 @@
*/
@Internal
public final class ProtoJavaQualifiedNames {
- // Controls how many times we should recursively inspect a nested message for building fully
- // qualified java class name before aborting.
- private static final int SAFE_RECURSE_LIMIT = 50;
-
/**
* Retrieves the full Java class name from the given descriptor
*
@@ -48,44 +36,7 @@ public final class ProtoJavaQualifiedNames {
* (Nested class with java multiple files disabled)
*/
public static String getFullyQualifiedJavaClassName(Descriptor descriptor) {
- return getFullyQualifiedJavaClassNameImpl(descriptor);
- }
-
- private static String getFullyQualifiedJavaClassNameImpl(GenericDescriptor descriptor) {
- StringBuilder fullClassName = new StringBuilder();
-
- fullClassName.append(getJavaPackageName(descriptor.getFile())).append(".");
-
- String javaOuterClass = getJavaOuterClassName(descriptor.getFile());
- if (!Strings.isNullOrEmpty(javaOuterClass)) {
- fullClassName.append(javaOuterClass).append("$");
- }
-
- // Recursively build the target class name in case if the message is nested.
- ArrayDeque classNames = new ArrayDeque<>();
- GenericDescriptor d = descriptor;
-
- int recurseCount = 0;
- while (d != null) {
- classNames.push(d.getName());
-
- if (d instanceof EnumDescriptor) {
- d = ((EnumDescriptor) d).getContainingType();
- } else {
- d = ((Descriptor) d).getContainingType();
- }
- recurseCount++;
- if (recurseCount >= SAFE_RECURSE_LIMIT) {
- throw new IllegalStateException(
- String.format(
- "Recursion limit of %d hit while inspecting descriptor: %s",
- SAFE_RECURSE_LIMIT, descriptor.getFullName()));
- }
- }
-
- Joiner.on("$").appendTo(fullClassName, classNames);
-
- return fullClassName.toString();
+ return GeneratorNames.getBytecodeClassName(descriptor);
}
/**
@@ -94,68 +45,7 @@ private static String getFullyQualifiedJavaClassNameImpl(GenericDescriptor descr
* on package name generation
*/
public static String getJavaPackageName(FileDescriptor fileDescriptor) {
- FileOptions options = fileDescriptor.getFile().getOptions();
- StringBuilder javaPackageName = new StringBuilder();
- if (options.hasJavaPackage()) {
- javaPackageName.append(options.getJavaPackage());
- } else {
- javaPackageName
- // CEL-Internal-1
- .append(fileDescriptor.getPackage());
- }
-
- // CEL-Internal-2
-
- return javaPackageName.toString();
- }
-
- /**
- * Gets a wrapping outer class name from the descriptor. The outer class name differs depending on
- * the proto options set. See
- * https://developers.google.com/protocol-buffers/docs/reference/java-generated#invocation
- */
- private static String getJavaOuterClassName(FileDescriptor descriptor) {
- FileOptions options = descriptor.getOptions();
-
- if (options.getJavaMultipleFiles()) {
- // If java_multiple_files is enabled, protoc does not generate a wrapper outer class
- return "";
- }
-
- if (options.hasJavaOuterClassname()) {
- return options.getJavaOuterClassname();
- } else {
- // If an outer class name is not explicitly set, the name is converted into
- // Pascal case based on the snake cased file name
- // Ex: messages_proto.proto becomes MessagesProto
- String protoFileNameWithoutExtension =
- Files.getNameWithoutExtension(descriptor.getFile().getFullName());
- String outerClassName =
- CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, protoFileNameWithoutExtension);
- if (hasConflictingClassName(descriptor.getFile(), outerClassName)) {
- outerClassName += "OuterClass";
- }
- return outerClassName;
- }
- }
-
- private static boolean hasConflictingClassName(FileDescriptor file, String name) {
- for (EnumDescriptor enumDesc : file.getEnumTypes()) {
- if (name.equals(enumDesc.getName())) {
- return true;
- }
- }
- for (ServiceDescriptor serviceDesc : file.getServices()) {
- if (name.equals(serviceDesc.getName())) {
- return true;
- }
- }
- for (Descriptor messageDesc : file.getMessageTypes()) {
- if (name.equals(messageDesc.getName())) {
- return true;
- }
- }
- return false;
+ return GeneratorNames.getFileJavaPackage(fileDescriptor.toProto());
}
private ProtoJavaQualifiedNames() {}
diff --git a/common/src/main/java/dev/cel/common/internal/ProtoLiteAdapter.java b/common/src/main/java/dev/cel/common/internal/ProtoLiteAdapter.java
index e05d92f68..3b13ecea1 100644
--- a/common/src/main/java/dev/cel/common/internal/ProtoLiteAdapter.java
+++ b/common/src/main/java/dev/cel/common/internal/ProtoLiteAdapter.java
@@ -42,11 +42,10 @@
import com.google.protobuf.UInt32Value;
import com.google.protobuf.UInt64Value;
import com.google.protobuf.Value;
-import dev.cel.common.CelErrorCode;
import dev.cel.common.CelOptions;
import dev.cel.common.CelProtoJsonAdapter;
-import dev.cel.common.CelRuntimeException;
import dev.cel.common.annotations.Internal;
+import dev.cel.common.exceptions.CelNumericOverflowException;
import dev.cel.common.values.CelByteString;
import java.time.Instant;
import java.util.Map;
@@ -284,14 +283,14 @@ private Message adaptValueToUint32(Object value) {
try {
return UInt32Value.of(unsignedIntCheckedCast((Long) value));
} catch (IllegalArgumentException e) {
- throw new CelRuntimeException(e, CelErrorCode.NUMERIC_OVERFLOW);
+ throw new CelNumericOverflowException(e);
}
}
if (value instanceof UnsignedLong) {
try {
return UInt32Value.of(unsignedIntCheckedCast(((UnsignedLong) value).longValue()));
} catch (IllegalArgumentException e) {
- throw new CelRuntimeException(e, CelErrorCode.NUMERIC_OVERFLOW);
+ throw new CelNumericOverflowException(e);
}
}
@@ -316,7 +315,7 @@ private static int intCheckedCast(long value) {
try {
return Ints.checkedCast(value);
} catch (IllegalArgumentException e) {
- throw new CelRuntimeException(e, CelErrorCode.NUMERIC_OVERFLOW);
+ throw new CelNumericOverflowException(e);
}
}
@@ -324,7 +323,7 @@ private static int unsignedIntCheckedCast(long value) {
try {
return UnsignedInts.checkedCast(value);
} catch (IllegalArgumentException e) {
- throw new CelRuntimeException(e, CelErrorCode.NUMERIC_OVERFLOW);
+ throw new CelNumericOverflowException(e);
}
}
diff --git a/common/src/main/java/dev/cel/common/internal/ProtoTimeUtils.java b/common/src/main/java/dev/cel/common/internal/ProtoTimeUtils.java
index cc705fccd..36671842d 100644
--- a/common/src/main/java/dev/cel/common/internal/ProtoTimeUtils.java
+++ b/common/src/main/java/dev/cel/common/internal/ProtoTimeUtils.java
@@ -18,6 +18,7 @@
import static com.google.common.math.LongMath.checkedMultiply;
import static com.google.common.math.LongMath.checkedSubtract;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Strings;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.protobuf.Duration;
@@ -49,12 +50,16 @@
public final class ProtoTimeUtils {
// Timestamp for "0001-01-01T00:00:00Z"
- private static final long TIMESTAMP_SECONDS_MIN = -62135596800L;
-
+ @VisibleForTesting
+ static final long TIMESTAMP_SECONDS_MIN = -62135596800L;
// Timestamp for "9999-12-31T23:59:59Z"
- private static final long TIMESTAMP_SECONDS_MAX = 253402300799L;
- private static final long DURATION_SECONDS_MIN = -315576000000L;
- private static final long DURATION_SECONDS_MAX = 315576000000L;
+ @VisibleForTesting
+ static final long TIMESTAMP_SECONDS_MAX = 253402300799L;
+ @VisibleForTesting
+ static final long DURATION_SECONDS_MIN = -315576000000L;
+ @VisibleForTesting
+ static final long DURATION_SECONDS_MAX = 315576000000L;
+
private static final int MILLIS_PER_SECOND = 1000;
private static final int NANOS_PER_SECOND = 1000000000;
@@ -344,7 +349,8 @@ public static Timestamp parse(String value) throws ParseException {
}
}
try {
- return normalizedTimestamp(seconds, nanos);
+ Timestamp timestamp = normalizedTimestamp(seconds, nanos);
+ return checkValid(timestamp);
} catch (IllegalArgumentException e) {
ParseException ex =
new ParseException(
@@ -532,8 +538,7 @@ private static Timestamp normalizedTimestamp(long seconds, int nanos) {
nanos = nanos + NANOS_PER_SECOND; // no overflow since nanos is negative (and we're adding)
seconds = checkedSubtract(seconds, 1);
}
- Timestamp timestamp = Timestamp.newBuilder().setSeconds(seconds).setNanos(nanos).build();
- return checkValid(timestamp);
+ return Timestamp.newBuilder().setSeconds(seconds).setNanos(nanos).build();
}
private static Duration normalizedDuration(long seconds, int nanos) {
@@ -549,8 +554,7 @@ private static Duration normalizedDuration(long seconds, int nanos) {
nanos -= NANOS_PER_SECOND; // no overflow since nanos is positive (and we're subtracting)
seconds++; // no overflow since seconds is negative (and we're incrementing)
}
- Duration duration = Duration.newBuilder().setSeconds(seconds).setNanos(nanos).build();
- return checkValid(duration);
+ return Duration.newBuilder().setSeconds(seconds).setNanos(nanos).build();
}
private static String formatNanos(int nanos) {
diff --git a/common/src/main/java/dev/cel/common/types/BUILD.bazel b/common/src/main/java/dev/cel/common/types/BUILD.bazel
index 579fd31c5..de65d0b1f 100644
--- a/common/src/main/java/dev/cel/common/types/BUILD.bazel
+++ b/common/src/main/java/dev/cel/common/types/BUILD.bazel
@@ -7,6 +7,7 @@ package(
],
default_visibility = [
"//common/types:__pkg__",
+ "//publish:__pkg__",
],
)
@@ -183,6 +184,36 @@ java_library(
],
)
+java_library(
+ name = "default_type_provider",
+ srcs = [
+ "DefaultTypeProvider.java",
+ ],
+ tags = [
+ ],
+ deps = [
+ ":type_providers",
+ ":types",
+ "@maven//:com_google_errorprone_error_prone_annotations",
+ "@maven//:com_google_guava_guava",
+ ],
+)
+
+cel_android_library(
+ name = "default_type_provider_android",
+ srcs = [
+ "DefaultTypeProvider.java",
+ ],
+ tags = [
+ ],
+ deps = [
+ ":type_providers_android",
+ ":types_android",
+ "@maven//:com_google_errorprone_error_prone_annotations",
+ "@maven_android//:com_google_guava_guava",
+ ],
+)
+
cel_android_library(
name = "cel_types_android",
srcs = ["CelTypes.java"],
diff --git a/common/src/main/java/dev/cel/common/types/DefaultTypeProvider.java b/common/src/main/java/dev/cel/common/types/DefaultTypeProvider.java
new file mode 100644
index 000000000..372a50e73
--- /dev/null
+++ b/common/src/main/java/dev/cel/common/types/DefaultTypeProvider.java
@@ -0,0 +1,55 @@
+// 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 com.google.errorprone.annotations.Immutable;
+import java.util.Optional;
+
+/** {@code DefaultTypeProvider} is a registry of common CEL types. */
+@Immutable
+public class DefaultTypeProvider implements CelTypeProvider {
+
+ private static final DefaultTypeProvider INSTANCE = new DefaultTypeProvider();
+ private final ImmutableMap commonTypes;
+
+ @Override
+ public ImmutableCollection types() {
+ return commonTypes.values();
+ }
+
+ @Override
+ public Optional findType(String typeName) {
+ return Optional.ofNullable(commonTypes.get(typeName));
+ }
+
+ public static DefaultTypeProvider getInstance() {
+ return INSTANCE;
+ }
+
+ private DefaultTypeProvider() {
+ ImmutableMap.Builder 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("type", TypeType.create(SimpleType.DYN));
+ typeMapBuilder.put(
+ "optional_type",
+ // TODO: Move to CelOptionalLibrary and register it on demand
+ OptionalType.create(SimpleType.DYN));
+ this.commonTypes = typeMapBuilder.buildOrThrow();
+ }
+}
diff --git a/common/src/main/java/dev/cel/common/types/EnumType.java b/common/src/main/java/dev/cel/common/types/EnumType.java
index 076ebe527..836b68a6c 100644
--- a/common/src/main/java/dev/cel/common/types/EnumType.java
+++ b/common/src/main/java/dev/cel/common/types/EnumType.java
@@ -62,7 +62,6 @@ public Optional findNameByNumber(Integer enumNumber) {
/** Functional interface for lookup up an enum number by its local or fully qualified name. */
@Immutable
@FunctionalInterface
- @SuppressWarnings("AndroidJdkLibsChecker") // FunctionalInterface added in 24
public interface EnumNumberResolver {
Optional findNumber(String enumName);
}
@@ -70,7 +69,6 @@ public interface EnumNumberResolver {
/** Functional interface for looking up an enum name by its number. */
@Immutable
@FunctionalInterface
- @SuppressWarnings("AndroidJdkLibsChecker") // FunctionalInterface added in 24
public interface EnumNameResolver {
Optional findName(Integer enumNumber);
}
diff --git a/common/src/main/java/dev/cel/common/types/ProtoMessageType.java b/common/src/main/java/dev/cel/common/types/ProtoMessageType.java
index 7ac3f4fd3..11e48bbe6 100644
--- a/common/src/main/java/dev/cel/common/types/ProtoMessageType.java
+++ b/common/src/main/java/dev/cel/common/types/ProtoMessageType.java
@@ -29,14 +29,17 @@
public final class ProtoMessageType extends StructType {
private final StructType.FieldResolver extensionResolver;
+ private final JsonNameResolver jsonNameResolver;
ProtoMessageType(
String name,
ImmutableSet fieldNames,
StructType.FieldResolver fieldResolver,
- StructType.FieldResolver extensionResolver) {
+ StructType.FieldResolver extensionResolver,
+ JsonNameResolver jsonNameResolver) {
super(name, fieldNames, fieldResolver);
this.extensionResolver = extensionResolver;
+ this.jsonNameResolver = jsonNameResolver;
}
/** Find an {@code Extension} by its fully-qualified {@code extensionName}. */
@@ -46,20 +49,35 @@ public Optional findExtension(String extensionName) {
.map(type -> Extension.of(extensionName, type, this));
}
+ /** Returns true if the field name is a json name. */
+ public boolean isJsonName(String fieldName) {
+ return jsonNameResolver.isJsonName(fieldName);
+ }
+
/**
* Create a new instance of the {@code ProtoMessageType} using the {@code visibleFields} set as a
* mask of the fields from the backing proto.
*/
public ProtoMessageType withVisibleFields(ImmutableSet visibleFields) {
- return new ProtoMessageType(name, visibleFields, fieldResolver, extensionResolver);
+ return new ProtoMessageType(
+ name, visibleFields, fieldResolver, extensionResolver, jsonNameResolver);
}
public static ProtoMessageType create(
String name,
ImmutableSet fieldNames,
FieldResolver fieldResolver,
- FieldResolver extensionResolver) {
- return new ProtoMessageType(name, fieldNames, fieldResolver, extensionResolver);
+ FieldResolver extensionResolver,
+ JsonNameResolver jsonNameResolver) {
+ return new ProtoMessageType(
+ name, fieldNames, fieldResolver, extensionResolver, jsonNameResolver);
+ }
+
+ /** Functional interface for resolving whether a field name is a json name. */
+ @FunctionalInterface
+ @Immutable
+ public interface JsonNameResolver {
+ boolean isJsonName(String fieldName);
}
/** {@code Extension} contains the name, type, and target message type of the extension. */
diff --git a/common/src/main/java/dev/cel/common/types/ProtoMessageTypeProvider.java b/common/src/main/java/dev/cel/common/types/ProtoMessageTypeProvider.java
index 4b97178d0..022f5cd8e 100644
--- a/common/src/main/java/dev/cel/common/types/ProtoMessageTypeProvider.java
+++ b/common/src/main/java/dev/cel/common/types/ProtoMessageTypeProvider.java
@@ -14,15 +14,14 @@
package dev.cel.common.types;
-import static com.google.common.collect.ImmutableList.toImmutableList;
import static com.google.common.collect.ImmutableMap.toImmutableMap;
import com.google.common.collect.ImmutableCollection;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.CheckReturnValue;
import com.google.errorprone.annotations.Immutable;
import com.google.protobuf.DescriptorProtos.FileDescriptorSet;
@@ -34,6 +33,7 @@
import dev.cel.common.CelDescriptorUtil;
import dev.cel.common.CelDescriptors;
import dev.cel.common.internal.FileDescriptorSetConverter;
+import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
@@ -68,28 +68,53 @@ public final class ProtoMessageTypeProvider implements CelTypeProvider {
.buildOrThrow();
private final ImmutableMap allTypes;
+ private final boolean allowJsonFieldNames;
+ /** Returns a new builder for {@link ProtoMessageTypeProvider}. */
+ public static Builder newBuilder() {
+ return new Builder();
+ }
+
+ /**
+ * @deprecated Use {@link #newBuilder()} instead.
+ */
+ @Deprecated
public ProtoMessageTypeProvider() {
- this(CelDescriptors.builder().build());
+ this(CelDescriptors.builder().build(), false);
}
+ /**
+ * @deprecated Use {@link #newBuilder()} instead.
+ */
+ @Deprecated
public ProtoMessageTypeProvider(FileDescriptorSet descriptorSet) {
this(
CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(
- FileDescriptorSetConverter.convert(descriptorSet)));
+ FileDescriptorSetConverter.convert(descriptorSet)),
+ false);
}
+ /**
+ * @deprecated Use {@link #newBuilder()} instead.
+ */
+ @Deprecated
public ProtoMessageTypeProvider(Iterable descriptors) {
this(
CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(
- ImmutableSet.copyOf(Iterables.transform(descriptors, Descriptor::getFile))));
+ ImmutableSet.copyOf(Iterables.transform(descriptors, Descriptor::getFile))),
+ false);
}
+ /**
+ * @deprecated Use {@link #newBuilder()} instead.
+ */
+ @Deprecated
public ProtoMessageTypeProvider(ImmutableSet fileDescriptors) {
- this(CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(fileDescriptors));
+ this(CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(fileDescriptors), false);
}
- public ProtoMessageTypeProvider(CelDescriptors celDescriptors) {
+ private ProtoMessageTypeProvider(CelDescriptors celDescriptors, boolean allowJsonFieldNames) {
+ this.allowJsonFieldNames = allowJsonFieldNames;
this.allTypes =
ImmutableMap.builder()
.putAll(createEnumTypes(celDescriptors.enumDescriptors()))
@@ -120,8 +145,18 @@ private ImmutableMap createProtoMessageTypes(
if (protoMessageTypes.containsKey(descriptor.getFullName())) {
continue;
}
- ImmutableList fieldNames =
- descriptor.getFields().stream().map(FieldDescriptor::getName).collect(toImmutableList());
+
+ ImmutableSet.Builder fieldNamesBuilder = ImmutableSet.builder();
+ ImmutableSet.Builder jsonNamesBuilder = ImmutableSet.builder();
+ for (FieldDescriptor fd : descriptor.getFields()) {
+ if (allowJsonFieldNames) {
+ fieldNamesBuilder.add(fd.getJsonName());
+ jsonNamesBuilder.add(fd.getJsonName());
+ } else {
+ fieldNamesBuilder.add(fd.getName());
+ }
+ }
+ ImmutableSet jsonNames = jsonNamesBuilder.build();
Map extensionFields = new HashMap<>();
for (FieldDescriptor extension : extensionMap.get(descriptor.getFullName())) {
@@ -133,9 +168,10 @@ private ImmutableMap createProtoMessageTypes(
descriptor.getFullName(),
ProtoMessageType.create(
descriptor.getFullName(),
- ImmutableSet.copyOf(fieldNames),
+ fieldNamesBuilder.build(),
new FieldResolver(this, descriptor)::findField,
- new FieldResolver(this, extensions)::findField));
+ new FieldResolver(this, extensions)::findField,
+ jsonNames::contains));
}
return ImmutableMap.copyOf(protoMessageTypes);
}
@@ -158,19 +194,42 @@ private ImmutableMap createEnumTypes(
}
private static class FieldResolver {
- private final CelTypeProvider celTypeProvider;
+ private final ProtoMessageTypeProvider protoMessageTypeProvider;
private final ImmutableMap fields;
- private FieldResolver(CelTypeProvider celTypeProvider, Descriptor descriptor) {
+ private static ImmutableMap collectJsonFieldDescriptorMap(
+ Descriptor descriptor) {
+ ImmutableMap.Builder builder = ImmutableMap.builder();
+ for (FieldDescriptor fd : descriptor.getFields()) {
+ if (!fd.getJsonName().isEmpty()) {
+ builder.put(fd.getJsonName(), fd);
+ } else {
+ builder.put(fd.getName(), fd);
+ }
+ }
+
+ return builder.buildOrThrow();
+ }
+
+ private static ImmutableMap collectFieldDescriptorMap(
+ Descriptor descriptor) {
+ return descriptor.getFields().stream()
+ .collect(toImmutableMap(FieldDescriptor::getName, Function.identity()));
+ }
+
+ private FieldResolver(
+ ProtoMessageTypeProvider protoMessageTypeProvider, Descriptor descriptor) {
this(
- celTypeProvider,
- descriptor.getFields().stream()
- .collect(toImmutableMap(FieldDescriptor::getName, Function.identity())));
+ protoMessageTypeProvider,
+ protoMessageTypeProvider.allowJsonFieldNames
+ ? collectJsonFieldDescriptorMap(descriptor)
+ : collectFieldDescriptorMap(descriptor));
}
private FieldResolver(
- CelTypeProvider celTypeProvider, ImmutableMap fields) {
- this.celTypeProvider = celTypeProvider;
+ ProtoMessageTypeProvider protoMessageTypeProvider,
+ ImmutableMap fields) {
+ this.protoMessageTypeProvider = protoMessageTypeProvider;
this.fields = fields;
}
@@ -203,11 +262,11 @@ private Optional findFieldInternal(FieldDescriptor fieldDescriptor) {
String messageName = descriptor.getFullName();
fieldType =
CelTypes.getWellKnownCelType(messageName)
- .orElse(celTypeProvider.findType(descriptor.getFullName()).orElse(null));
+ .orElse(protoMessageTypeProvider.findType(descriptor.getFullName()).orElse(null));
break;
case ENUM:
EnumDescriptor enumDescriptor = fieldDescriptor.getEnumType();
- fieldType = celTypeProvider.findType(enumDescriptor.getFullName()).orElse(null);
+ fieldType = protoMessageTypeProvider.findType(enumDescriptor.getFullName()).orElse(null);
break;
default:
fieldType = PROTO_TYPE_TO_CEL_TYPE.get(fieldDescriptor.getType());
@@ -222,4 +281,83 @@ private Optional findFieldInternal(FieldDescriptor fieldDescriptor) {
return Optional.of(fieldType);
}
}
+
+ /** Builder for {@link ProtoMessageTypeProvider}. */
+ public static final class Builder {
+ private final ImmutableSet.Builder fileDescriptors = ImmutableSet.builder();
+ private boolean allowJsonFieldNames;
+ private boolean resolveTypeDependencies;
+ private CelDescriptors celDescriptors;
+
+ /** Adds a {@link FileDescriptor} to the provider. */
+ @CanIgnoreReturnValue
+ public Builder addFileDescriptors(FileDescriptor... fileDescriptors) {
+ return addFileDescriptors(Arrays.asList(fileDescriptors));
+ }
+
+ /** Adds a collection of {@link FileDescriptor}s to the provider. */
+ @CanIgnoreReturnValue
+ public Builder addFileDescriptors(Iterable fileDescriptors) {
+ this.fileDescriptors.addAll(fileDescriptors);
+ return this;
+ }
+
+ /** Adds a collection of {@link Descriptor}s. The parent file of each descriptor is added. */
+ @CanIgnoreReturnValue
+ public Builder addDescriptors(Iterable descriptors) {
+ this.fileDescriptors.addAll(Iterables.transform(descriptors, Descriptor::getFile));
+ return this;
+ }
+
+ /**
+ * Use the `json_name` field option on a protobuf message as the name of the field.
+ *
+ * If enabled, the type checker will only accept the `json_name` and will no longer recognize
+ * the original protobuf field name. This is to avoid ambiguity between the two names.
+ */
+ @CanIgnoreReturnValue
+ public Builder setAllowJsonFieldNames(boolean allowJsonFieldNames) {
+ this.allowJsonFieldNames = allowJsonFieldNames;
+ return this;
+ }
+
+ /**
+ * If true, all transitive dependencies of the added {@link FileDescriptor}s will be resolved
+ * and their types will be made available to the type provider. By default, this is disabled.
+ */
+ @CanIgnoreReturnValue
+ public Builder setResolveTypeDependencies(boolean resolveTypeDependencies) {
+ this.resolveTypeDependencies = resolveTypeDependencies;
+ return this;
+ }
+
+ /**
+ * Sets the CEL descriptors. Note this cannot be used in conjunction with other descriptor
+ * adders such as {@link #addDescriptors}.
+ */
+ @CanIgnoreReturnValue
+ public Builder setCelDescriptors(CelDescriptors celDescriptors) {
+ this.celDescriptors = celDescriptors;
+ return this;
+ }
+
+ /** Builds the {@link ProtoMessageTypeProvider}. */
+ public ProtoMessageTypeProvider build() {
+ ImmutableSet fds = fileDescriptors.build();
+ if (celDescriptors != null && !fds.isEmpty()) {
+ throw new IllegalArgumentException(
+ "Both CelDescriptors and FileDescriptors cannot be set at the same time.");
+ }
+
+ if (celDescriptors == null) {
+ celDescriptors =
+ CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(
+ fileDescriptors.build(), resolveTypeDependencies);
+ }
+
+ return new ProtoMessageTypeProvider(celDescriptors, allowJsonFieldNames);
+ }
+
+ private Builder() {}
+ }
}
diff --git a/common/src/main/java/dev/cel/common/types/SimpleType.java b/common/src/main/java/dev/cel/common/types/SimpleType.java
index cbf02e9c6..93bd5326d 100644
--- a/common/src/main/java/dev/cel/common/types/SimpleType.java
+++ b/common/src/main/java/dev/cel/common/types/SimpleType.java
@@ -44,9 +44,8 @@ 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 TYPE_MAP =
+ public static final ImmutableMap TYPE_MAP =
ImmutableMap.of(
- DYN.name(), DYN,
BOOL.name(), BOOL,
BYTES.name(), BYTES,
DOUBLE.name(), DOUBLE,
diff --git a/common/src/main/java/dev/cel/common/types/StructType.java b/common/src/main/java/dev/cel/common/types/StructType.java
index ba4251559..b91b6fef0 100644
--- a/common/src/main/java/dev/cel/common/types/StructType.java
+++ b/common/src/main/java/dev/cel/common/types/StructType.java
@@ -99,7 +99,6 @@ public static StructType create(
*/
@Immutable
@FunctionalInterface
- @SuppressWarnings("AndroidJdkLibsChecker") // FunctionalInterface added in 24
public interface FieldResolver {
/** Find the {@code CelType} for the given {@code fieldName} if the field is defined. */
Optional findField(String fieldName);
diff --git a/common/src/main/java/dev/cel/common/values/BUILD.bazel b/common/src/main/java/dev/cel/common/values/BUILD.bazel
index 9ffa5bad3..53ffdda3d 100644
--- a/common/src/main/java/dev/cel/common/values/BUILD.bazel
+++ b/common/src/main/java/dev/cel/common/values/BUILD.bazel
@@ -7,32 +7,19 @@ package(
],
default_visibility = [
"//common/values:__pkg__",
+ "//publish:__pkg__",
],
)
# keep sorted
CEL_VALUES_SOURCES = [
- "BoolValue.java",
- "BytesValue.java",
"CelValueConverter.java",
- "DoubleValue.java",
- "DurationValue.java",
- "EnumValue.java",
"ErrorValue.java",
- "ImmutableListValue.java",
- "ImmutableMapValue.java",
- "IntValue.java",
- "ListValue.java",
- "MapValue.java",
"NullValue.java",
"OpaqueValue.java",
"OptionalValue.java",
"SelectableValue.java",
- "StringValue.java",
"StructValue.java",
- "TimestampValue.java",
- "TypeValue.java",
- "UintValue.java",
]
# keep sorted
@@ -71,7 +58,7 @@ java_library(
tags = [
],
deps = [
- ":cel_value",
+ "//common/values",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_guava_guava",
],
@@ -83,7 +70,7 @@ cel_android_library(
tags = [
],
deps = [
- ":cel_value_android",
+ "//common/values:values_android",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven_android//:com_google_guava_guava",
],
@@ -95,7 +82,6 @@ java_library(
tags = [
],
deps = [
- "//common/values:cel_value",
"//common/values:cel_value_provider",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_guava_guava",
@@ -108,7 +94,6 @@ cel_android_library(
tags = [
],
deps = [
- ":cel_value_android",
"//common/values:cel_value_provider_android",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven_android//:com_google_guava_guava",
@@ -124,8 +109,6 @@ java_library(
":cel_byte_string",
":cel_value",
"//:auto_value",
- "//common:error_codes",
- "//common:runtime_exception",
"//common/annotations",
"//common/types",
"//common/types:type_providers",
@@ -144,8 +127,6 @@ cel_android_library(
":cel_byte_string",
":cel_value_android",
"//:auto_value",
- "//common:error_codes",
- "//common:runtime_exception",
"//common/annotations",
"//common/types:type_providers_android",
"//common/types:types_android",
@@ -173,11 +154,11 @@ java_library(
],
deps = [
":cel_byte_string",
- ":cel_value",
":values",
"//common/annotations",
"//common/internal:proto_time_utils",
"//common/internal:well_known_proto",
+ "//common/values",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_guava_guava",
"@maven//:com_google_protobuf_protobuf_java",
@@ -191,7 +172,6 @@ cel_android_library(
],
deps = [
":cel_byte_string",
- ":cel_value_android",
":values_android",
"//common/annotations",
"//common/internal:proto_time_utils_android",
@@ -209,9 +189,9 @@ java_library(
],
deps = [
":base_proto_cel_value_converter",
- ":cel_value",
":values",
"//:auto_value",
+ "//common:options",
"//common/annotations",
"//common/internal:cel_descriptor_pools",
"//common/internal:dynamic_proto",
@@ -231,14 +211,13 @@ java_library(
tags = [
],
deps = [
- ":base_proto_message_value_provider",
- ":cel_value",
":proto_message_value",
"//common:options",
"//common/annotations",
"//common/internal:dynamic_proto",
"//common/internal:proto_message_factory",
- "//common/values:base_proto_cel_value_converter",
+ "//common/values",
+ "//common/values:cel_value_provider",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_protobuf_protobuf_java",
],
@@ -254,7 +233,6 @@ java_library(
],
deps = [
":base_proto_cel_value_converter",
- ":cel_value",
":values",
"//:auto_value",
"//common/annotations",
@@ -282,7 +260,6 @@ cel_android_library(
],
deps = [
":base_proto_cel_value_converter_android",
- ":cel_value_android",
":values_android",
"//:auto_value",
"//common/annotations",
@@ -307,7 +284,6 @@ java_library(
],
deps = [
":base_proto_message_value_provider",
- ":cel_value",
":proto_message_lite_value",
"//common/annotations",
"//common/internal:cel_lite_descriptor_pool",
@@ -327,7 +303,6 @@ cel_android_library(
],
deps = [
":base_proto_message_value_provider_android",
- ":cel_value_android",
":proto_message_lite_value_android",
"//common/annotations",
"//common/internal:cel_lite_descriptor_pool_android",
diff --git a/common/src/main/java/dev/cel/common/values/BaseProtoCelValueConverter.java b/common/src/main/java/dev/cel/common/values/BaseProtoCelValueConverter.java
index 450b273c2..6851deed5 100644
--- a/common/src/main/java/dev/cel/common/values/BaseProtoCelValueConverter.java
+++ b/common/src/main/java/dev/cel/common/values/BaseProtoCelValueConverter.java
@@ -17,16 +17,23 @@
import static com.google.common.collect.ImmutableList.toImmutableList;
import static com.google.common.collect.ImmutableMap.toImmutableMap;
+import com.google.common.base.CaseFormat;
+import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.primitives.UnsignedLong;
import com.google.errorprone.annotations.Immutable;
import com.google.protobuf.BoolValue;
import com.google.protobuf.ByteString;
+import com.google.protobuf.BytesValue;
import com.google.protobuf.DoubleValue;
import com.google.protobuf.Duration;
+import com.google.protobuf.FieldMask;
import com.google.protobuf.FloatValue;
import com.google.protobuf.Int32Value;
import com.google.protobuf.Int64Value;
-import com.google.protobuf.MessageLite;
+import com.google.protobuf.ListValue;
import com.google.protobuf.MessageLiteOrBuilder;
import com.google.protobuf.StringValue;
import com.google.protobuf.Struct;
@@ -37,7 +44,8 @@
import dev.cel.common.annotations.Internal;
import dev.cel.common.internal.ProtoTimeUtils;
import dev.cel.common.internal.WellKnownProto;
-import java.util.Optional;
+import java.util.ArrayList;
+import java.util.List;
/**
* {@code BaseProtoCelValueConverter} contains the common logic for converting between native Java
@@ -51,77 +59,79 @@
@Internal
public abstract class BaseProtoCelValueConverter extends CelValueConverter {
- public abstract CelValue fromProtoMessageToCelValue(MessageLite msg);
-
/** {@inheritDoc} Protobuf semantics take precedence for conversion. */
@Override
- public CelValue fromJavaObjectToCelValue(Object value) {
+ public Object toRuntimeValue(Object value) {
Preconditions.checkNotNull(value);
- Optional wellKnownProto = WellKnownProto.getByClass(value.getClass());
- if (wellKnownProto.isPresent()) {
- return fromWellKnownProtoToCelValue((MessageLiteOrBuilder) value, wellKnownProto.get());
- }
-
if (value instanceof ByteString) {
- return BytesValue.create(CelByteString.of(((ByteString) value).toByteArray()));
+ return CelByteString.of(((ByteString) value).toByteArray());
} else if (value instanceof com.google.protobuf.NullValue) {
return NullValue.NULL_VALUE;
}
- return super.fromJavaObjectToCelValue(value);
+ return super.toRuntimeValue(value);
}
- protected CelValue fromWellKnownProtoToCelValue(
- MessageLiteOrBuilder message, WellKnownProto wellKnownProto) {
+ protected Object fromWellKnownProto(MessageLiteOrBuilder message, WellKnownProto wellKnownProto) {
switch (wellKnownProto) {
case JSON_VALUE:
- return adaptJsonValueToCelValue((Value) message);
+ return adaptJsonValue((Value) message);
case JSON_STRUCT_VALUE:
- return adaptJsonStructToCelValue((Struct) message);
+ return adaptJsonStruct((Struct) message);
case JSON_LIST_VALUE:
- return adaptJsonListToCelValue((com.google.protobuf.ListValue) message);
+ return adaptJsonList((ListValue) message);
case DURATION:
- return DurationValue.create(ProtoTimeUtils.toJavaDuration((Duration) message));
+ return ProtoTimeUtils.toJavaDuration((Duration) message);
case TIMESTAMP:
- return TimestampValue.create(ProtoTimeUtils.toJavaInstant((Timestamp) message));
+ return ProtoTimeUtils.toJavaInstant((Timestamp) message);
case BOOL_VALUE:
- return fromJavaPrimitiveToCelValue(((BoolValue) message).getValue());
+ return normalizePrimitive(((BoolValue) message).getValue());
case BYTES_VALUE:
- return fromJavaPrimitiveToCelValue(
- ((com.google.protobuf.BytesValue) message).getValue().toByteArray());
+ return normalizePrimitive(((BytesValue) message).getValue().toByteArray());
case DOUBLE_VALUE:
- return fromJavaPrimitiveToCelValue(((DoubleValue) message).getValue());
+ return normalizePrimitive(((DoubleValue) message).getValue());
case FLOAT_VALUE:
- return fromJavaPrimitiveToCelValue(((FloatValue) message).getValue());
+ return normalizePrimitive(((FloatValue) message).getValue());
case INT32_VALUE:
- return fromJavaPrimitiveToCelValue(((Int32Value) message).getValue());
+ return normalizePrimitive(((Int32Value) message).getValue());
case INT64_VALUE:
- return fromJavaPrimitiveToCelValue(((Int64Value) message).getValue());
+ return normalizePrimitive(((Int64Value) message).getValue());
case STRING_VALUE:
- return fromJavaPrimitiveToCelValue(((StringValue) message).getValue());
+ return normalizePrimitive(((StringValue) message).getValue());
case UINT32_VALUE:
- return UintValue.create(((UInt32Value) message).getValue());
+ return UnsignedLong.valueOf(((UInt32Value) message).getValue());
case UINT64_VALUE:
- return UintValue.create(((UInt64Value) message).getValue());
+ return UnsignedLong.fromLongBits(((UInt64Value) message).getValue());
+ case FIELD_MASK:
+ FieldMask fieldMask = (FieldMask) message;
+ List paths = new ArrayList<>(fieldMask.getPathsCount());
+ for (String path : fieldMask.getPathsList()) {
+ if (!path.isEmpty()) {
+ paths.add(CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, path));
+ }
+ }
+ return normalizePrimitive(Joiner.on(",").join(paths));
+ case EMPTY:
+ return ImmutableMap.of();
default:
throw new UnsupportedOperationException(
- "Unsupported message to CelValue conversion - " + message);
+ "Unsupported well known proto conversion - " + wellKnownProto);
}
}
- private CelValue adaptJsonValueToCelValue(Value value) {
+ private Object adaptJsonValue(Value value) {
switch (value.getKindCase()) {
case BOOL_VALUE:
- return fromJavaPrimitiveToCelValue(value.getBoolValue());
+ return normalizePrimitive(value.getBoolValue());
case NUMBER_VALUE:
- return fromJavaPrimitiveToCelValue(value.getNumberValue());
+ return normalizePrimitive(value.getNumberValue());
case STRING_VALUE:
- return fromJavaPrimitiveToCelValue(value.getStringValue());
+ return normalizePrimitive(value.getStringValue());
case LIST_VALUE:
- return adaptJsonListToCelValue(value.getListValue());
+ return adaptJsonList(value.getListValue());
case STRUCT_VALUE:
- return adaptJsonStructToCelValue(value.getStructValue());
+ return adaptJsonStruct(value.getStructValue());
case NULL_VALUE:
case KIND_NOT_SET: // Fall-through is intended
return NullValue.NULL_VALUE;
@@ -130,28 +140,23 @@ private CelValue adaptJsonValueToCelValue(Value value) {
"Unsupported Json to CelValue conversion: " + value.getKindCase());
}
- private ListValue adaptJsonListToCelValue(com.google.protobuf.ListValue listValue) {
- return ImmutableListValue.create(
- listValue.getValuesList().stream()
- .map(this::adaptJsonValueToCelValue)
- .collect(toImmutableList()));
+ private ImmutableList adaptJsonList(ListValue listValue) {
+ return listValue.getValuesList().stream().map(this::adaptJsonValue).collect(toImmutableList());
}
- private MapValue adaptJsonStructToCelValue(
- Struct struct) {
- return ImmutableMapValue.create(
- struct.getFieldsMap().entrySet().stream()
- .collect(
- toImmutableMap(
- e -> {
- CelValue key = fromJavaObjectToCelValue(e.getKey());
- if (!(key instanceof dev.cel.common.values.StringValue)) {
- throw new IllegalStateException(
- "Expected a string type for the key, but instead got: " + key);
- }
- return (dev.cel.common.values.StringValue) key;
- },
- e -> adaptJsonValueToCelValue(e.getValue()))));
+ private ImmutableMap adaptJsonStruct(Struct struct) {
+ return struct.getFieldsMap().entrySet().stream()
+ .collect(
+ toImmutableMap(
+ e -> {
+ Object key = toRuntimeValue(e.getKey());
+ if (!(key instanceof String)) {
+ throw new IllegalStateException(
+ "Expected a string type for the key, but instead got: " + key);
+ }
+ return (String) key;
+ },
+ e -> adaptJsonValue(e.getValue())));
}
protected BaseProtoCelValueConverter() {}
diff --git a/common/src/main/java/dev/cel/common/values/BytesValue.java b/common/src/main/java/dev/cel/common/values/BytesValue.java
deleted file mode 100644
index d4c309364..000000000
--- a/common/src/main/java/dev/cel/common/values/BytesValue.java
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2023 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.values;
-
-import com.google.auto.value.AutoValue;
-import com.google.errorprone.annotations.Immutable;
-import dev.cel.common.types.CelType;
-import dev.cel.common.types.SimpleType;
-
-/** BytesValue is a simple CelValue wrapper around CelByteString (immutable byte string). */
-@AutoValue
-@Immutable
-public abstract class BytesValue extends CelValue {
-
- @Override
- public abstract CelByteString value();
-
- @Override
- public boolean isZeroValue() {
- return value().isEmpty();
- }
-
- @Override
- public CelType celType() {
- return SimpleType.BYTES;
- }
-
- public static BytesValue create(CelByteString value) {
- return new AutoValue_BytesValue(value);
- }
-}
diff --git a/common/src/main/java/dev/cel/common/values/CelValueConverter.java b/common/src/main/java/dev/cel/common/values/CelValueConverter.java
index a281318f8..2af0a76cb 100644
--- a/common/src/main/java/dev/cel/common/values/CelValueConverter.java
+++ b/common/src/main/java/dev/cel/common/values/CelValueConverter.java
@@ -17,9 +17,9 @@
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
-import com.google.common.primitives.UnsignedLong;
import com.google.errorprone.annotations.Immutable;
import dev.cel.common.annotations.Internal;
+import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
@@ -33,117 +33,133 @@
@SuppressWarnings("unchecked") // Unchecked cast of generics due to type-erasure (ex: MapValue).
@Internal
@Immutable
-abstract class CelValueConverter {
+public class CelValueConverter {
- /** Adapts a {@link CelValue} to a plain old Java Object. */
- public Object fromCelValueToJavaObject(CelValue celValue) {
- Preconditions.checkNotNull(celValue);
+ private static final CelValueConverter DEFAULT_INSTANCE = new CelValueConverter();
- if (celValue instanceof MapValue) {
- MapValue mapValue = (MapValue) celValue;
- ImmutableMap.Builder mapBuilder = ImmutableMap.builder();
- for (Entry entry : mapValue.value().entrySet()) {
- Object key = fromCelValueToJavaObject(entry.getKey());
- Object value = fromCelValueToJavaObject(entry.getValue());
- mapBuilder.put(key, value);
- }
+ public static CelValueConverter getDefaultInstance() {
+ return DEFAULT_INSTANCE;
+ }
+
+ /**
+ * Unwraps the {@code value} into its plain old Java Object representation.
+ *
+ * The value may be a {@link CelValue}, a {@link Collection} or a {@link Map}.
+ */
+ public Object maybeUnwrap(Object value) {
+ if (value instanceof CelValue) {
+ return unwrap((CelValue) value);
+ }
- return mapBuilder.buildOrThrow();
- } else if (celValue instanceof ListValue) {
- ListValue listValue = (ListValue) celValue;
- ImmutableList.Builder listBuilder = ImmutableList.builder();
- for (CelValue element : listValue.value()) {
- listBuilder.add(fromCelValueToJavaObject(element));
+ if (value instanceof Collection) {
+ Collection collection = (Collection) value;
+ ImmutableList.Builder builder =
+ ImmutableList.builderWithExpectedSize(collection.size());
+ for (Object element : collection) {
+ builder.add(maybeUnwrap(element));
}
- return listBuilder.build();
- } else if (celValue instanceof OptionalValue) {
- OptionalValue optionalValue = (OptionalValue) celValue;
- if (optionalValue.isZeroValue()) {
- return Optional.empty();
+
+ return builder.build();
+ }
+
+ if (value instanceof Map) {
+ Map map = (Map) value;
+ ImmutableMap.Builder builder =
+ ImmutableMap.builderWithExpectedSize(map.size());
+ for (Map.Entry entry : map.entrySet()) {
+ builder.put(maybeUnwrap(entry.getKey()), maybeUnwrap(entry.getValue()));
}
- return Optional.of(fromCelValueToJavaObject(optionalValue.value()));
+ return builder.buildOrThrow();
}
- return celValue.value();
+ return value;
}
- /** Adapts a plain old Java Object to a {@link CelValue}. */
- public CelValue fromJavaObjectToCelValue(Object value) {
+ /**
+ * Canonicalizes an inbound {@code value} into a suitable Java object representation for
+ * evaluation.
+ */
+ public Object toRuntimeValue(Object value) {
Preconditions.checkNotNull(value);
if (value instanceof CelValue) {
- return (CelValue) value;
+ return value;
}
- if (value instanceof Iterable) {
- return toListValue((Iterable) value);
+ if (value instanceof Collection) {
+ return toListValue((Collection) value);
} else if (value instanceof Map) {
return toMapValue((Map) value);
} else if (value instanceof Optional) {
- Optional optionalValue = (Optional) value;
+ Optional optionalValue = (Optional) value;
return optionalValue
- .map(o -> OptionalValue.create(fromJavaObjectToCelValue(o)))
+ .map(this::toRuntimeValue)
+ .map(OptionalValue::create)
.orElse(OptionalValue.EMPTY);
- } else if (value instanceof Exception) {
- return ErrorValue.create((Exception) value);
}
- return fromJavaPrimitiveToCelValue(value);
+ return normalizePrimitive(value);
}
- /** Adapts a plain old Java Object that are considered primitives to a {@link CelValue}. */
- protected CelValue fromJavaPrimitiveToCelValue(Object value) {
+ protected Object normalizePrimitive(Object value) {
Preconditions.checkNotNull(value);
- if (value instanceof Boolean) {
- return BoolValue.create((Boolean) value);
- } else if (value instanceof Long) {
- return IntValue.create((Long) value);
- } else if (value instanceof Integer) {
- return IntValue.create((Integer) value);
- } else if (value instanceof String) {
- return StringValue.create((String) value);
+ if (value instanceof Integer) {
+ return ((Integer) value).longValue();
} else if (value instanceof byte[]) {
- return BytesValue.create(CelByteString.of((byte[]) value));
- } else if (value instanceof Double) {
- return DoubleValue.create((Double) value);
+ return CelByteString.of((byte[]) value);
} else if (value instanceof Float) {
- return DoubleValue.create(Double.valueOf((Float) value));
- } else if (value instanceof UnsignedLong) {
- return UintValue.create((UnsignedLong) value);
- } else if (value instanceof CelByteString) {
- return BytesValue.create((CelByteString) value);
+ return ((Float) value).doubleValue();
}
- // Fall back to an Opaque value, as a custom class was supplied in the runtime. The legacy
- // interpreter allows this but this should not be allowed when a new runtime is introduced.
- // TODO: Migrate consumers to directly supply an appropriate CelValue.
- return OpaqueValue.create(value.toString(), value);
+ return value;
+ }
+
+ /** Adapts a {@link CelValue} to a plain old Java Object. */
+ private static Object unwrap(CelValue celValue) {
+ Preconditions.checkNotNull(celValue);
+
+ if (celValue instanceof OptionalValue) {
+ OptionalValue optionalValue = (OptionalValue) celValue;
+ if (optionalValue.isZeroValue()) {
+ return Optional.empty();
+ }
+
+ return Optional.of(optionalValue.value());
+ }
+
+ if (celValue instanceof ErrorValue) {
+ return celValue;
+ }
+
+ return celValue.value();
}
- private ListValue toListValue(Iterable iterable) {
+ private ImmutableList toListValue(Collection iterable) {
Preconditions.checkNotNull(iterable);
- ImmutableList.Builder listBuilder = ImmutableList.builder();
+ ImmutableList.Builder listBuilder =
+ ImmutableList.builderWithExpectedSize(iterable.size());
for (Object entry : iterable) {
- listBuilder.add(fromJavaObjectToCelValue(entry));
+ listBuilder.add(toRuntimeValue(entry));
}
- return ImmutableListValue.create(listBuilder.build());
+ return listBuilder.build();
}
- private MapValue toMapValue(Map map) {
+ private ImmutableMap toMapValue(Map map) {
Preconditions.checkNotNull(map);
- ImmutableMap.Builder mapBuilder = ImmutableMap.builder();
+ ImmutableMap.Builder mapBuilder =
+ ImmutableMap.builderWithExpectedSize(map.size());
for (Entry entry : map.entrySet()) {
- CelValue mapKey = fromJavaObjectToCelValue(entry.getKey());
- CelValue mapValue = fromJavaObjectToCelValue(entry.getValue());
+ Object mapKey = toRuntimeValue(entry.getKey());
+ Object mapValue = toRuntimeValue(entry.getValue());
mapBuilder.put(mapKey, mapValue);
}
- return ImmutableMapValue.create(mapBuilder.buildOrThrow());
+ return mapBuilder.buildOrThrow();
}
protected CelValueConverter() {}
diff --git a/common/src/main/java/dev/cel/common/values/CelValueProvider.java b/common/src/main/java/dev/cel/common/values/CelValueProvider.java
index e5080e180..20ae865e7 100644
--- a/common/src/main/java/dev/cel/common/values/CelValueProvider.java
+++ b/common/src/main/java/dev/cel/common/values/CelValueProvider.java
@@ -23,10 +23,12 @@
public interface CelValueProvider {
/**
- * Constructs a new struct value.
- *
- * Note that the return type is defined as CelValue rather than StructValue to account for
- * special cases such as wrappers where its primitive is returned.
+ * Constructs a new struct value, or a primitive value in case the fully qualified struct name is
+ * a wrapper.
*/
- Optional newValue(String structType, Map fields);
+ Optional newValue(String structType, Map fields);
+
+ default CelValueConverter celValueConverter() {
+ return CelValueConverter.getDefaultInstance();
+ }
}
diff --git a/common/src/main/java/dev/cel/common/values/CombinedCelValueProvider.java b/common/src/main/java/dev/cel/common/values/CombinedCelValueProvider.java
index a674beb8d..8fe62cb7b 100644
--- a/common/src/main/java/dev/cel/common/values/CombinedCelValueProvider.java
+++ b/common/src/main/java/dev/cel/common/values/CombinedCelValueProvider.java
@@ -38,9 +38,9 @@ public static CombinedCelValueProvider combine(CelValueProvider... providers) {
}
@Override
- public Optional newValue(String structType, Map fields) {
+ public Optional newValue(String structType, Map fields) {
for (CelValueProvider provider : celValueProviders) {
- Optional newValue = provider.newValue(structType, fields);
+ Optional newValue = provider.newValue(structType, fields);
if (newValue.isPresent()) {
return newValue;
}
diff --git a/common/src/main/java/dev/cel/common/values/DoubleValue.java b/common/src/main/java/dev/cel/common/values/DoubleValue.java
deleted file mode 100644
index 97e0c86b6..000000000
--- a/common/src/main/java/dev/cel/common/values/DoubleValue.java
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2023 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.values;
-
-import com.google.errorprone.annotations.Immutable;
-import dev.cel.common.types.CelType;
-import dev.cel.common.types.SimpleType;
-
-/** DoubleValue is a simple CelValue wrapper around Java doubles. */
-@Immutable
-public final class DoubleValue extends CelValue {
- private final double value;
-
- @Override
- public Double value() {
- return value;
- }
-
- public double doubleValue() {
- return value;
- }
-
- @Override
- public boolean isZeroValue() {
- return value() == 0;
- }
-
- @Override
- public CelType celType() {
- return SimpleType.DOUBLE;
- }
-
- public static DoubleValue create(double value) {
- return new DoubleValue(value);
- }
-
- @Override
- public int hashCode() {
- int h = 1;
- h *= 1000003;
- h ^= Double.hashCode(value);
- return h;
- }
-
- @Override
- public boolean equals(Object o) {
- if (o == this) {
- return true;
- }
-
- if (!(o instanceof DoubleValue)) {
- return false;
- }
-
- return Double.doubleToLongBits(((DoubleValue) o).doubleValue())
- == Double.doubleToLongBits(this.doubleValue());
- }
-
- private DoubleValue(double value) {
- this.value = value;
- }
-}
diff --git a/common/src/main/java/dev/cel/common/values/DurationValue.java b/common/src/main/java/dev/cel/common/values/DurationValue.java
deleted file mode 100644
index 702109de2..000000000
--- a/common/src/main/java/dev/cel/common/values/DurationValue.java
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2023 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.values;
-
-import com.google.auto.value.AutoValue;
-import com.google.errorprone.annotations.Immutable;
-import dev.cel.common.types.CelType;
-import dev.cel.common.types.SimpleType;
-import java.time.Duration;
-
-/** DurationValue is a simple CelValue wrapper around {@link java.time.Duration} */
-@AutoValue
-@Immutable
-public abstract class DurationValue extends CelValue {
-
- @Override
- public abstract Duration value();
-
- @Override
- public boolean isZeroValue() {
- return value().isZero();
- }
-
- @Override
- public CelType celType() {
- return SimpleType.DURATION;
- }
-
- public static DurationValue create(Duration value) {
- return new AutoValue_DurationValue(value);
- }
-}
diff --git a/common/src/main/java/dev/cel/common/values/EnumValue.java b/common/src/main/java/dev/cel/common/values/EnumValue.java
deleted file mode 100644
index 1a8ea3e7c..000000000
--- a/common/src/main/java/dev/cel/common/values/EnumValue.java
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2023 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.values;
-
-import com.google.auto.value.AutoValue;
-import com.google.errorprone.annotations.Immutable;
-import dev.cel.common.types.CelType;
-import dev.cel.common.types.SimpleType;
-
-/**
- * EnumValue is a simple CelValue wrapper around Java enums.
- *
- * Note: CEL-Java currently does not support strongly typed enum. This value class will not be
- * used until the said support is added in.
- */
-@AutoValue
-@Immutable(containerOf = "E")
-public abstract class EnumValue> extends CelValue {
-
- @Override
- public abstract Enum value();
-
- @Override
- public boolean isZeroValue() {
- return false;
- }
-
- @Override
- public CelType celType() {
- // (b/178627883) Strongly typed enum is not supported yet
- return SimpleType.INT;
- }
-
- public static > EnumValue create(Enum value) {
- return new AutoValue_EnumValue<>(value);
- }
-}
diff --git a/common/src/main/java/dev/cel/common/values/ErrorValue.java b/common/src/main/java/dev/cel/common/values/ErrorValue.java
index 818f86850..6bc04cda4 100644
--- a/common/src/main/java/dev/cel/common/values/ErrorValue.java
+++ b/common/src/main/java/dev/cel/common/values/ErrorValue.java
@@ -33,6 +33,8 @@
"Immutable") // Exception is technically not immutable as the stacktrace is malleable.
public abstract class ErrorValue extends CelValue {
+ public abstract long exprId();
+
@Override
public abstract Exception value();
@@ -46,7 +48,7 @@ public CelType celType() {
return SimpleType.ERROR;
}
- public static ErrorValue create(Exception value) {
- return new AutoValue_ErrorValue(value);
+ public static ErrorValue create(long exprId, Exception value) {
+ return new AutoValue_ErrorValue(exprId, value);
}
}
diff --git a/common/src/main/java/dev/cel/common/values/ImmutableListValue.java b/common/src/main/java/dev/cel/common/values/ImmutableListValue.java
deleted file mode 100644
index 1a0d6a0ce..000000000
--- a/common/src/main/java/dev/cel/common/values/ImmutableListValue.java
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright 2023 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.values;
-
-import com.google.common.collect.ImmutableList;
-import com.google.errorprone.annotations.Immutable;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
-import java.util.ListIterator;
-
-/**
- * ImmutableListValue is a representation of an immutable list containing zero or more {@link
- * CelValue}.
- */
-@Immutable
-@SuppressWarnings(
- "PreferredInterfaceType") // We intentionally store List type to avoid copying on instantiation
-public final class ImmutableListValue extends ListValue {
-
- @SuppressWarnings("Immutable") // ListValue APIs prohibit mutation.
- private final List originalList;
-
- @SuppressWarnings("Immutable") // The value is lazily populated only once via synchronization.
- private volatile ImmutableList cachedImmutableList = null;
-
- public static ImmutableListValue create(List value) {
- return new ImmutableListValue<>(value);
- }
-
- private ImmutableListValue(List originalList) {
- this.originalList = ImmutableList.copyOf(originalList);
- }
-
- @Override
- public ImmutableList value() {
- if (cachedImmutableList == null) {
- synchronized (this) {
- if (cachedImmutableList == null) {
- cachedImmutableList = ImmutableList.copyOf(originalList);
- }
- }
- }
-
- return cachedImmutableList;
- }
-
- @Override
- public int size() {
- return originalList.size();
- }
-
- @Override
- public boolean isEmpty() {
- return originalList.isEmpty();
- }
-
- @Override
- public boolean contains(Object o) {
- return originalList.contains(o);
- }
-
- @Override
- public Iterator iterator() {
- return originalList.iterator();
- }
-
- @Override
- public Object[] toArray() {
- return originalList.toArray();
- }
-
- @Override
- public T[] toArray(T[] a) {
- return originalList.toArray(a);
- }
-
- @Override
- public boolean containsAll(Collection c) {
- return originalList.containsAll(c);
- }
-
- @Override
- public E get(int index) {
- return originalList.get(index);
- }
-
- @Override
- public int indexOf(Object o) {
- return originalList.indexOf(o);
- }
-
- @Override
- public int lastIndexOf(Object o) {
- return originalList.lastIndexOf(o);
- }
-
- @Override
- public ListIterator listIterator() {
- return originalList.listIterator();
- }
-
- @Override
- public ListIterator listIterator(int index) {
- return originalList.listIterator(index);
- }
-
- @Override
- public List subList(int fromIndex, int toIndex) {
- return originalList.subList(fromIndex, toIndex);
- }
-
- @Override
- public int hashCode() {
- return originalList.hashCode();
- }
-
- @Override
- public boolean equals(Object obj) {
- return originalList.equals(obj);
- }
-}
diff --git a/common/src/main/java/dev/cel/common/values/ImmutableMapValue.java b/common/src/main/java/dev/cel/common/values/ImmutableMapValue.java
deleted file mode 100644
index eb429a19d..000000000
--- a/common/src/main/java/dev/cel/common/values/ImmutableMapValue.java
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright 2023 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.values;
-
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableMap;
-import com.google.errorprone.annotations.Immutable;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * MapValue is an abstract representation of an immutable map containing {@link CelValue} as keys
- * and values.
- */
-@Immutable(containerOf = {"K", "V"})
-@SuppressWarnings(
- "PreferredInterfaceType") // We intentionally store List type to avoid copying on instantiation
-public final class ImmutableMapValue
- extends MapValue {
-
- @SuppressWarnings("Immutable") // MapValue APIs prohibit mutation.
- private final Map originalMap;
-
- @SuppressWarnings("Immutable") // The value is lazily populated only once via synchronization.
- private volatile ImmutableMap cachedImmutableMap = null;
-
- public static ImmutableMapValue create(
- Map value) {
- return new ImmutableMapValue<>(value);
- }
-
- private ImmutableMapValue(Map originalMap) {
- Preconditions.checkNotNull(originalMap);
- this.originalMap = originalMap;
- }
-
- @Override
- public ImmutableMap value() {
- if (cachedImmutableMap == null) {
- synchronized (this) {
- if (cachedImmutableMap == null) {
- cachedImmutableMap = ImmutableMap.copyOf(originalMap);
- }
- }
- }
-
- return cachedImmutableMap;
- }
-
- @Override
- public int size() {
- return originalMap.size();
- }
-
- @Override
- public boolean isEmpty() {
- return originalMap.isEmpty();
- }
-
- @Override
- public boolean containsKey(Object key) {
- return originalMap.containsKey(key);
- }
-
- @Override
- public boolean containsValue(Object val) {
- return originalMap.containsValue(val);
- }
-
- @Override
- public int hashCode() {
- return originalMap.hashCode();
- }
-
- @Override
- public boolean equals(Object obj) {
- return originalMap.equals(obj);
- }
-
- // Note that the following three methods are produced from the immutable map to avoid key/value
- // mutation.
- @Override
- public Set keySet() {
- return value().keySet();
- }
-
- @Override
- public Collection values() {
- return value().values();
- }
-
- @Override
- public Set> entrySet() {
- return value().entrySet();
- }
-}
diff --git a/common/src/main/java/dev/cel/common/values/IntValue.java b/common/src/main/java/dev/cel/common/values/IntValue.java
deleted file mode 100644
index b756804f6..000000000
--- a/common/src/main/java/dev/cel/common/values/IntValue.java
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2023 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.values;
-
-import com.google.errorprone.annotations.Immutable;
-import dev.cel.common.types.CelType;
-import dev.cel.common.types.SimpleType;
-
-/** IntValue is a simple CelValue wrapper around Java longs. */
-@Immutable
-public final class IntValue extends CelValue {
- private final long value;
-
- @Override
- public Long value() {
- return value;
- }
-
- public long longValue() {
- return value;
- }
-
- @Override
- public boolean isZeroValue() {
- return value() == 0;
- }
-
- @Override
- public CelType celType() {
- return SimpleType.INT;
- }
-
- public static IntValue create(long value) {
- return new IntValue(value);
- }
-
- @Override
- public int hashCode() {
- int h = 1;
- h *= 1000003;
- h ^= Long.hashCode(value);
- return h;
- }
-
- @Override
- public boolean equals(Object o) {
- if (o == this) {
- return true;
- }
-
- if (!(o instanceof IntValue)) {
- return false;
- }
-
- return ((IntValue) o).value == this.value;
- }
-
- private IntValue(long value) {
- this.value = value;
- }
-}
diff --git a/common/src/main/java/dev/cel/common/values/ListValue.java b/common/src/main/java/dev/cel/common/values/ListValue.java
deleted file mode 100644
index 814884d34..000000000
--- a/common/src/main/java/dev/cel/common/values/ListValue.java
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright 2023 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.values;
-
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import com.google.errorprone.annotations.DoNotCall;
-import com.google.errorprone.annotations.Immutable;
-import dev.cel.common.types.CelType;
-import dev.cel.common.types.ListType;
-import dev.cel.common.types.SimpleType;
-import java.util.Collection;
-import java.util.Comparator;
-import java.util.List;
-import java.util.function.UnaryOperator;
-import org.jspecify.annotations.Nullable;
-
-/**
- * ListValue is an abstract representation of a generic list containing zero or more {@link
- * CelValue}.
- *
- * All methods that can mutate the list are disallowed.
- */
-@Immutable
-public abstract class ListValue extends CelValue implements List {
- private static final ListType LIST_TYPE = ListType.create(SimpleType.DYN);
-
- @Override
- @SuppressWarnings("Immutable") // ListValue APIs prohibit mutation.
- public abstract List value();
-
- @Override
- public boolean isZeroValue() {
- return isEmpty();
- }
-
- @Override
- public CelType celType() {
- return LIST_TYPE;
- }
-
- /**
- * Guaranteed to throw an exception and leave the list unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final void clear() {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the list unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final boolean retainAll(Collection c) {
- return false;
- }
-
- /**
- * Guaranteed to throw an exception and leave the list unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @CanIgnoreReturnValue
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final E set(int index, E element) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the list unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final void replaceAll(UnaryOperator operator) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the list unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final void sort(@Nullable Comparator c) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the list unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final void add(int index, E element) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the list unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final boolean add(E e) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the list unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @CanIgnoreReturnValue
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final boolean addAll(int index, Collection newElements) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the list unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final boolean addAll(Collection c) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the list unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @CanIgnoreReturnValue
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final E remove(int index) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the list unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final boolean remove(Object o) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the list unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final boolean removeAll(Collection c) {
- throw new UnsupportedOperationException();
- }
-}
diff --git a/common/src/main/java/dev/cel/common/values/MapValue.java b/common/src/main/java/dev/cel/common/values/MapValue.java
deleted file mode 100644
index 0f79b0464..000000000
--- a/common/src/main/java/dev/cel/common/values/MapValue.java
+++ /dev/null
@@ -1,253 +0,0 @@
-// Copyright 2023 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.values;
-
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import com.google.errorprone.annotations.DoNotCall;
-import com.google.errorprone.annotations.Immutable;
-import dev.cel.common.CelErrorCode;
-import dev.cel.common.CelRuntimeException;
-import dev.cel.common.types.CelType;
-import dev.cel.common.types.MapType;
-import dev.cel.common.types.SimpleType;
-import java.util.Map;
-import java.util.Optional;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import org.jspecify.annotations.Nullable;
-
-/**
- * MapValue is an abstract representation of a generic map containing {@link CelValue} as keys and
- * values.
- *
- * All methods that can mutate the map are disallowed.
- */
-@Immutable(containerOf = {"K", "V"})
-public abstract class MapValue extends CelValue
- implements Map, SelectableValue {
-
- private static final MapType MAP_TYPE = MapType.create(SimpleType.DYN, SimpleType.DYN);
-
- @Override
- public abstract Map value();
-
- @Override
- public boolean isZeroValue() {
- return isEmpty();
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public V get(Object key) {
- return select((K) key);
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public V select(K field) {
- return (V)
- find(field)
- .orElseThrow(
- () ->
- new CelRuntimeException(
- new IllegalArgumentException(
- String.format("key '%s' is not present in map.", field.value())),
- CelErrorCode.ATTRIBUTE_NOT_FOUND));
- }
-
- @Override
- public Optional find(K field) {
- return value().containsKey(field) ? Optional.of(value().get(field)) : Optional.empty();
- }
-
- @Override
- public CelType celType() {
- return MAP_TYPE;
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @CanIgnoreReturnValue
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final V put(K key, V value) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @CanIgnoreReturnValue
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final V putIfAbsent(K key, V value) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final boolean replace(K key, V oldValue, V newValue) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final V replace(K key, V value) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final V computeIfAbsent(K key, Function mappingFunction) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final V computeIfPresent(
- K key, BiFunction remappingFunction) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final V compute(
- K key, BiFunction remappingFunction) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final V merge(
- K key, V value, BiFunction function) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final void putAll(Map map) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final void replaceAll(BiFunction function) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final V remove(Object o) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final boolean remove(Object key, Object value) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Guaranteed to throw an exception and leave the map unmodified.
- *
- * @throws UnsupportedOperationException always
- * @deprecated Unsupported operation.
- */
- @Deprecated
- @Override
- @DoNotCall("Always throws UnsupportedOperationException")
- public final void clear() {
- throw new UnsupportedOperationException();
- }
-}
diff --git a/common/src/main/java/dev/cel/common/values/OptionalValue.java b/common/src/main/java/dev/cel/common/values/OptionalValue.java
index 3866ef72b..9a2204fca 100644
--- a/common/src/main/java/dev/cel/common/values/OptionalValue.java
+++ b/common/src/main/java/dev/cel/common/values/OptionalValue.java
@@ -19,6 +19,7 @@
import com.google.errorprone.annotations.Immutable;
import dev.cel.common.types.OptionalType;
import dev.cel.common.types.SimpleType;
+import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Optional;
import org.jspecify.annotations.Nullable;
@@ -30,12 +31,11 @@
*/
@AutoValue
@Immutable(containerOf = "E")
-public abstract class OptionalValue extends CelValue
- implements SelectableValue {
+public abstract class OptionalValue extends CelValue implements SelectableValue {
private static final OptionalType OPTIONAL_TYPE = OptionalType.create(SimpleType.DYN);
/** Sentinel value representing an empty optional ('optional.none()' in CEL) */
- public static final OptionalValue