typeMasks);
/**
- * Add one or more {@link CelRuntime.CelFunctionBinding} objects to the CEL runtime.
+ * Add one or more {@link CelFunctionBinding} objects to the CEL runtime.
*
* Functions with duplicate overload ids will be replaced in favor of the new overload.
*/
@CanIgnoreReturnValue
- CelBuilder addFunctionBindings(CelRuntime.CelFunctionBinding... bindings);
+ CelBuilder addFunctionBindings(CelFunctionBinding... bindings);
/**
- * Bind a collection of {@link CelRuntime.CelFunctionBinding} objects to the runtime.
+ * Bind a collection of {@link CelFunctionBinding} objects to the runtime.
*
*
Functions with duplicate overload ids will be replaced in favor of the new overload.
*/
@CanIgnoreReturnValue
- CelBuilder addFunctionBindings(Iterable bindings);
+ CelBuilder addFunctionBindings(Iterable bindings);
+
+ /** Adds bindings for functions that are allowed to be late-bound (resolved at execution time). */
+ @CanIgnoreReturnValue
+ CelBuilder addLateBoundFunctions(String... lateBoundFunctionNames);
+
+ /** Adds bindings for functions that are allowed to be late-bound (resolved at execution time). */
+ @CanIgnoreReturnValue
+ CelBuilder addLateBoundFunctions(Iterable lateBoundFunctionNames);
/** Set the expected {@code resultType} for the type-checked expression. */
@CanIgnoreReturnValue
@@ -295,6 +309,24 @@ public interface CelBuilder {
@CanIgnoreReturnValue
CelBuilder addRuntimeLibraries(Iterable libraries);
+ /**
+ * Override the standard declarations for the type-checker. This can be used to subset the
+ * standard environment to only expose the desired declarations to the type-checker. {@link
+ * #setStandardEnvironmentEnabled(boolean)} must be set to false for this to take effect.
+ */
+ @CanIgnoreReturnValue
+ CelBuilder setStandardDeclarations(CelStandardDeclarations standardDeclarations);
+
+ /**
+ * Override the standard functions for the runtime. This can be used to subset the standard
+ * environment to only expose the desired function overloads to the runtime.
+ *
+ * {@link #setStandardEnvironmentEnabled(boolean)} must be set to false for this to take
+ * effect.
+ */
+ @CanIgnoreReturnValue
+ CelBuilder setStandardFunctions(CelStandardFunctions standardFunctions);
+
/**
* Sets a proto ExtensionRegistry to assist with unpacking Any messages containing a proto2
extension field.
diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironment.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironment.java
new file mode 100644
index 000000000..ccbaef61b
--- /dev/null
+++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironment.java
@@ -0,0 +1,1112 @@
+// 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.bundle;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.CheckReturnValue;
+import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector;
+import dev.cel.checker.CelStandardDeclarations;
+import dev.cel.checker.CelStandardDeclarations.StandardFunction;
+import dev.cel.checker.CelStandardDeclarations.StandardOverload;
+import dev.cel.checker.ProtoTypeMask;
+import dev.cel.common.CelContainer;
+import dev.cel.common.CelFunctionDecl;
+import dev.cel.common.CelOptions;
+import dev.cel.common.CelOverloadDecl;
+import dev.cel.common.CelVarDecl;
+import dev.cel.common.Source;
+import dev.cel.common.types.CelType;
+import dev.cel.common.types.CelTypeProvider;
+import dev.cel.common.types.ListType;
+import dev.cel.common.types.MapType;
+import dev.cel.common.types.OptionalType;
+import dev.cel.common.types.SimpleType;
+import dev.cel.common.types.TypeParamType;
+import dev.cel.common.types.TypeType;
+import dev.cel.compiler.CelCompiler;
+import dev.cel.compiler.CelCompilerBuilder;
+import dev.cel.compiler.CelCompilerLibrary;
+import dev.cel.extensions.CelExtensions;
+import dev.cel.parser.CelStandardMacro;
+import dev.cel.runtime.CelRuntime;
+import dev.cel.runtime.CelRuntimeBuilder;
+import dev.cel.runtime.CelRuntimeLibrary;
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.function.ObjIntConsumer;
+
+/**
+ * CelEnvironment is a native representation of a CEL environment for compiler and runtime. This
+ * object is amenable to being serialized into YAML, textproto or other formats as needed.
+ */
+@AutoValue
+public abstract class CelEnvironment {
+
+ @VisibleForTesting
+ static final ImmutableMap CEL_EXTENSION_CONFIG_MAP =
+ ImmutableMap.of(
+ "bindings", CanonicalCelExtension.BINDINGS,
+ "encoders", CanonicalCelExtension.ENCODERS,
+ "lists", CanonicalCelExtension.LISTS,
+ "math", CanonicalCelExtension.MATH,
+ "optional", CanonicalCelExtension.OPTIONAL,
+ "protos", CanonicalCelExtension.PROTOS,
+ "regex", CanonicalCelExtension.REGEX,
+ "sets", CanonicalCelExtension.SETS,
+ "strings", CanonicalCelExtension.STRINGS,
+ "two-var-comprehensions", CanonicalCelExtension.COMPREHENSIONS);
+
+ private static final ImmutableMap> LIMIT_HANDLERS =
+ ImmutableMap.of(
+ "cel.limit.expression_code_points",
+ CelOptions.Builder::maxExpressionCodePointSize,
+ "cel.limit.parse_error_recovery",
+ CelOptions.Builder::maxParseErrorRecoveryLimit,
+ "cel.limit.parse_recursion_depth",
+ CelOptions.Builder::maxParseRecursionDepth);
+
+ private static final ImmutableMap FEATURE_HANDLERS =
+ ImmutableMap.of(
+ "cel.feature.macro_call_tracking",
+ CelOptions.Builder::populateMacroCalls,
+ "cel.feature.backtick_escape_syntax",
+ CelOptions.Builder::enableQuotedIdentifierSyntax,
+ "cel.feature.cross_type_numeric_comparisons",
+ CelOptions.Builder::enableHeterogeneousNumericComparisons);
+
+ /** Environment source in textual format (ex: textproto, YAML). */
+ public abstract Optional source();
+
+ /** Name of the environment. */
+ public abstract String name();
+
+ /** Container, which captures default namespace and aliases for value resolution. */
+ public abstract Optional container();
+
+ /**
+ * An optional description of the environment (example: location of the file containing the config
+ * content).
+ */
+ public abstract String description();
+
+ /** Converts this {@code CelEnvironment} object into a builder. */
+ public abstract Builder toBuilder();
+
+ /**
+ * Canonical extensions to enable in the environment, such as Optional, String and Math
+ * extensions.
+ */
+ public abstract ImmutableSet extensions();
+
+ /** New variable declarations to add in the compilation environment. */
+ public abstract ImmutableSet variables();
+
+ /** New function declarations to add in the compilation environment. */
+ public abstract ImmutableSet functions();
+
+ /** Standard library subset (which macros, functions to include/exclude) */
+ public abstract Optional standardLibrarySubset();
+
+ /** Feature flags to enable in the environment. */
+ public abstract ImmutableSet features();
+
+ /** Limits to set in the environment. */
+ public abstract ImmutableSet limits();
+
+ /** Context variable to enable in the environment. */
+ public abstract Optional contextVariable();
+
+ /** Builder for {@link CelEnvironment}. */
+ @AutoValue.Builder
+ public abstract static class Builder {
+
+ public abstract ImmutableSet.Builder extensionsBuilder();
+
+ // For testing only, to empty out the source.
+ abstract Builder setSource(Optional source);
+
+ public abstract Builder setSource(Source source);
+
+ public abstract Builder setName(String name);
+
+ public abstract Builder setDescription(String description);
+
+ public abstract Builder setContainer(CelContainer container);
+
+ @CanIgnoreReturnValue
+ public Builder setContainer(String container) {
+ return setContainer(CelContainer.ofName(container));
+ }
+
+ @CanIgnoreReturnValue
+ public Builder addExtensions(ExtensionConfig... extensions) {
+ checkNotNull(extensions);
+ return addExtensions(Arrays.asList(extensions));
+ }
+
+ @CanIgnoreReturnValue
+ public Builder addExtensions(Iterable extensions) {
+ checkNotNull(extensions);
+ this.extensionsBuilder().addAll(extensions);
+ return this;
+ }
+
+ @CanIgnoreReturnValue
+ public Builder setVariables(VariableDecl... variables) {
+ return setVariables(ImmutableSet.copyOf(variables));
+ }
+
+ public abstract Builder setVariables(ImmutableSet variables);
+
+ @CanIgnoreReturnValue
+ public Builder setFunctions(FunctionDecl... functions) {
+ return setFunctions(ImmutableSet.copyOf(functions));
+ }
+
+ public abstract Builder setFunctions(ImmutableSet functions);
+
+ public abstract Builder setStandardLibrarySubset(LibrarySubset stdLibrarySubset);
+
+ @CanIgnoreReturnValue
+ public Builder setFeatures(FeatureFlag... featureFlags) {
+ return setFeatures(ImmutableSet.copyOf(featureFlags));
+ }
+
+ public abstract Builder setFeatures(ImmutableSet featureFlags);
+
+ @CanIgnoreReturnValue
+ public Builder setLimits(Limit... limits) {
+ return setLimits(ImmutableSet.copyOf(limits));
+ }
+
+ public abstract Builder setLimits(ImmutableSet limits);
+
+ public abstract Builder setContextVariable(ContextVariable contextVariable);
+
+ abstract CelEnvironment autoBuild();
+
+ @CheckReturnValue
+ public final CelEnvironment build() {
+ CelEnvironment env = autoBuild();
+ LibrarySubset librarySubset = env.standardLibrarySubset().orElse(null);
+ if (librarySubset != null) {
+ if (!librarySubset.includedMacros().isEmpty()
+ && !librarySubset.excludedMacros().isEmpty()) {
+ throw new IllegalArgumentException(
+ "Invalid subset: cannot both include and exclude macros");
+ }
+ if (!librarySubset.includedFunctions().isEmpty()
+ && !librarySubset.excludedFunctions().isEmpty()) {
+ throw new IllegalArgumentException(
+ "Invalid subset: cannot both include and exclude functions");
+ }
+ }
+ return env;
+ }
+ }
+
+ /** Creates a new builder to construct a {@link CelEnvironment} instance. */
+ public static Builder newBuilder() {
+ return new AutoValue_CelEnvironment.Builder()
+ .setName("")
+ .setDescription("")
+ .setVariables(ImmutableSet.of())
+ .setFunctions(ImmutableSet.of())
+ .setFeatures(ImmutableSet.of())
+ .setLimits(ImmutableSet.of());
+ }
+
+ /** Extends the provided {@link CelCompiler} environment with this configuration. */
+ public CelCompiler extend(CelCompiler celCompiler, CelOptions celOptions)
+ throws CelEnvironmentException {
+ celOptions = applyEnvironmentOptions(celOptions);
+ try {
+ CelTypeProvider celTypeProvider = celCompiler.getTypeProvider();
+ CelCompilerBuilder compilerBuilder =
+ celCompiler
+ .toCompilerBuilder()
+ .setOptions(celOptions)
+ .setTypeProvider(celTypeProvider)
+ .addVarDeclarations(
+ variables().stream()
+ .map(v -> v.toCelVarDecl(celTypeProvider))
+ .collect(toImmutableList()))
+ .addFunctionDeclarations(
+ functions().stream()
+ .map(f -> f.toCelFunctionDecl(celTypeProvider))
+ .collect(toImmutableList()));
+
+ container().ifPresent(compilerBuilder::setContainer);
+
+ addAllCompilerExtensions(compilerBuilder, celOptions);
+
+ applyStandardLibrarySubset(compilerBuilder);
+
+ contextVariable()
+ .ifPresent(
+ cv ->
+ compilerBuilder.addProtoTypeMasks(
+ ProtoTypeMask.ofAllFields(cv.typeName()).withFieldsAsVariableDeclarations()));
+
+ return compilerBuilder.build();
+ } catch (RuntimeException e) {
+ throw new CelEnvironmentException(e.getMessage(), e);
+ }
+ }
+
+ /** Extends the provided {@link Cel} environment with this configuration. */
+ public Cel extend(Cel cel, CelOptions celOptions) throws CelEnvironmentException {
+ celOptions = applyEnvironmentOptions(celOptions);
+ try {
+ // Casting is necessary to only extend the compiler here
+ CelCompiler celCompiler = extend((CelCompiler) cel, celOptions);
+
+ CelRuntime celRuntime = extendRuntime(cel, celOptions);
+
+ return CelFactory.combine(celCompiler, celRuntime);
+ } catch (RuntimeException e) {
+ throw new CelEnvironmentException(e.getMessage(), e);
+ }
+ }
+
+ private CelOptions applyEnvironmentOptions(CelOptions celOptions) {
+ CelOptions.Builder optionsBuilder = celOptions.toBuilder();
+ for (FeatureFlag featureFlag : features()) {
+ BooleanOptionConsumer consumer = FEATURE_HANDLERS.get(featureFlag.name());
+ if (consumer == null) {
+ throw new IllegalArgumentException("Unknown feature flag: " + featureFlag.name());
+ }
+ consumer.accept(optionsBuilder, featureFlag.enabled());
+ }
+ for (Limit limit : limits()) {
+ int value = limit.value() < 0 ? -1 : limit.value();
+ ObjIntConsumer 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
+ for (ExtensionConfig extensionConfig : extensions()) {
+ CanonicalCelExtension extension = getExtensionOrThrow(extensionConfig.name());
+ if (extension.compilerExtensionProvider() != null) {
+ CelCompilerLibrary celCompilerLibrary =
+ extension
+ .compilerExtensionProvider()
+ .getCelCompilerLibrary(celOptions, extensionConfig.version());
+ celCompilerBuilder.addLibraries(celCompilerLibrary);
+ }
+ }
+ }
+
+ 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());
+ if (extension.runtimeExtensionProvider() != null) {
+ CelRuntimeLibrary celRuntimeLibrary =
+ extension
+ .runtimeExtensionProvider()
+ .getCelRuntimeLibrary(celOptions, extensionConfig.version());
+ celRuntimeBuilder.addLibraries(celRuntimeLibrary);
+ }
+ }
+ return celRuntimeBuilder.build();
+ }
+
+ private void applyStandardLibrarySubset(CelCompilerBuilder compilerBuilder) {
+ if (!standardLibrarySubset().isPresent()) {
+ return;
+ }
+
+ LibrarySubset librarySubset = standardLibrarySubset().get();
+ if (librarySubset.disabled()) {
+ compilerBuilder.setStandardEnvironmentEnabled(false);
+ return;
+ }
+
+ if (librarySubset.macrosDisabled()) {
+ compilerBuilder.setStandardMacros(ImmutableList.of());
+ } else if (!librarySubset.includedMacros().isEmpty()) {
+ compilerBuilder.setStandardMacros(
+ librarySubset.includedMacros().stream()
+ .flatMap(name -> getStandardMacrosOrThrow(name).stream())
+ .collect(toImmutableSet()));
+ } else if (!librarySubset.excludedMacros().isEmpty()) {
+ ImmutableSet set =
+ librarySubset.excludedMacros().stream()
+ .flatMap(name -> getStandardMacrosOrThrow(name).stream())
+ .collect(toImmutableSet());
+ compilerBuilder.setStandardMacros(
+ CelStandardMacro.STANDARD_MACROS.stream()
+ .filter(macro -> !set.contains(macro))
+ .collect(toImmutableSet()));
+ }
+
+ if (!librarySubset.includedFunctions().isEmpty()) {
+ ImmutableSet includedFunctions = librarySubset.includedFunctions();
+ compilerBuilder
+ .setStandardEnvironmentEnabled(false)
+ .setStandardDeclarations(
+ CelStandardDeclarations.newBuilder()
+ .filterFunctions(
+ (function, overload) ->
+ FunctionSelector.matchesAny(function, overload, includedFunctions))
+ .build());
+ } else if (!librarySubset.excludedFunctions().isEmpty()) {
+ ImmutableSet excludedFunctions = librarySubset.excludedFunctions();
+ compilerBuilder
+ .setStandardEnvironmentEnabled(false)
+ .setStandardDeclarations(
+ CelStandardDeclarations.newBuilder()
+ .filterFunctions(
+ (function, overload) ->
+ !FunctionSelector.matchesAny(function, overload, excludedFunctions))
+ .build());
+ }
+ }
+
+ private static ImmutableSet getStandardMacrosOrThrow(String macroName) {
+ ImmutableSet.Builder builder = ImmutableSet.builder();
+ for (CelStandardMacro macro : CelStandardMacro.STANDARD_MACROS) {
+ if (macro.getFunction().equals(macroName)) {
+ builder.add(macro);
+ }
+ }
+ ImmutableSet macros = builder.build();
+ if (macros.isEmpty()) {
+ throw new IllegalArgumentException("unrecognized standard macro `" + macroName + "'");
+ }
+ return macros;
+ }
+
+ private static CanonicalCelExtension getExtensionOrThrow(String extensionName) {
+ CanonicalCelExtension extension = CEL_EXTENSION_CONFIG_MAP.get(extensionName);
+ if (extension == null) {
+ throw new IllegalArgumentException("Unrecognized extension: " + extensionName);
+ }
+
+ return extension;
+ }
+
+ /** Represents a context variable declaration. */
+ @AutoValue
+ public abstract static class ContextVariable {
+ /** Fully qualified type name of the context variable. */
+ public abstract String typeName();
+
+ public static ContextVariable create(String typeName) {
+ return new AutoValue_CelEnvironment_ContextVariable(typeName);
+ }
+ }
+
+ /** Represents a policy variable declaration. */
+ @AutoValue
+ public abstract static class VariableDecl {
+
+ /** Fully qualified variable name. */
+ public abstract String name();
+
+ /** The type of the variable. */
+ public abstract TypeDecl type();
+
+ public abstract Optional description();
+
+ /** Builder for {@link VariableDecl}. */
+ @AutoValue.Builder
+ public abstract static class Builder implements RequiredFieldsChecker {
+
+ public abstract Optional name();
+
+ public abstract Optional type();
+
+ public abstract VariableDecl.Builder setName(String name);
+
+ public abstract VariableDecl.Builder setType(TypeDecl typeDecl);
+
+ public abstract VariableDecl.Builder setDescription(String name);
+
+ @Override
+ public ImmutableList requiredFields() {
+ return ImmutableList.of(
+ RequiredField.of("name", this::name), RequiredField.of("type", this::type));
+ }
+
+ /** Builds a new instance of {@link VariableDecl}. */
+ public abstract VariableDecl build();
+ }
+
+ public static VariableDecl.Builder newBuilder() {
+ return new AutoValue_CelEnvironment_VariableDecl.Builder();
+ }
+
+ /** Creates a new builder to construct a {@link VariableDecl} instance. */
+ public static VariableDecl create(String name, TypeDecl type) {
+ return newBuilder().setName(name).setType(type).build();
+ }
+
+ /** Converts this policy variable declaration into a {@link CelVarDecl}. */
+ public CelVarDecl toCelVarDecl(CelTypeProvider celTypeProvider) {
+ return CelVarDecl.newVarDeclaration(name(), type().toCelType(celTypeProvider));
+ }
+ }
+
+ /** Represents a policy function declaration. */
+ @AutoValue
+ public abstract static class FunctionDecl {
+
+ public abstract String name();
+
+ public abstract Optional description();
+
+ public abstract ImmutableSet overloads();
+
+ /** Builder for {@link FunctionDecl}. */
+ @AutoValue.Builder
+ public abstract static class Builder implements RequiredFieldsChecker {
+
+ public abstract Optional name();
+
+ public abstract Optional> overloads();
+
+ public abstract FunctionDecl.Builder setName(String name);
+
+ public abstract FunctionDecl.Builder setDescription(String description);
+
+ public abstract FunctionDecl.Builder setOverloads(ImmutableSet overloads);
+
+ @Override
+ public ImmutableList requiredFields() {
+ return ImmutableList.of(
+ RequiredField.of("name", this::name), RequiredField.of("overloads", this::overloads));
+ }
+
+ /** Builds a new instance of {@link FunctionDecl}. */
+ public abstract FunctionDecl build();
+ }
+
+ /** Creates a new builder to construct a {@link FunctionDecl} instance. */
+ public static FunctionDecl.Builder newBuilder() {
+ return new AutoValue_CelEnvironment_FunctionDecl.Builder();
+ }
+
+ /** Creates a new {@link FunctionDecl} with the provided function name and its overloads. */
+ public static FunctionDecl create(String name, ImmutableSet overloads) {
+ return newBuilder().setName(name).setOverloads(overloads).build();
+ }
+
+ /** Converts this policy function declaration into a {@link CelFunctionDecl}. */
+ public CelFunctionDecl toCelFunctionDecl(CelTypeProvider celTypeProvider) {
+ return CelFunctionDecl.newFunctionDeclaration(
+ name(),
+ overloads().stream()
+ .map(o -> o.toCelOverloadDecl(celTypeProvider))
+ .collect(toImmutableList()));
+ }
+ }
+
+ /** Represents an overload declaration on a policy function. */
+ @AutoValue
+ public abstract static class OverloadDecl {
+
+ /**
+ * A unique overload ID. Required. This should follow the typical naming convention used in CEL
+ * (e.g: targetType_func_argType1_argType...)
+ */
+ public abstract String id();
+
+ /** Target of the function overload if it's a receiver style (example: foo in `foo.f(...)`) */
+ public abstract Optional target();
+
+ /** List of function overload type values. */
+ public abstract ImmutableList arguments();
+
+ /** Examples for the overload. */
+ public abstract ImmutableList examples();
+
+ /** Return type of the overload. Required. */
+ public abstract TypeDecl returnType();
+
+ /** Builder for {@link OverloadDecl}. */
+ @AutoValue.Builder
+ public abstract static class Builder implements RequiredFieldsChecker {
+
+ public abstract Optional id();
+
+ public abstract Optional returnType();
+
+ public abstract OverloadDecl.Builder setId(String overloadId);
+
+ public abstract OverloadDecl.Builder setTarget(TypeDecl target);
+
+ // This should stay package-private to encourage add/set methods to be used instead.
+ abstract ImmutableList.Builder argumentsBuilder();
+
+ abstract ImmutableList.Builder examplesBuilder();
+
+ public abstract OverloadDecl.Builder setArguments(ImmutableList args);
+
+ @CanIgnoreReturnValue
+ public OverloadDecl.Builder addExamples(Iterable examples) {
+ this.examplesBuilder().addAll(checkNotNull(examples));
+ return this;
+ }
+
+ @CanIgnoreReturnValue
+ public OverloadDecl.Builder addExamples(String... examples) {
+ return addExamples(Arrays.asList(examples));
+ }
+
+ @CanIgnoreReturnValue
+ public OverloadDecl.Builder addArguments(Iterable args) {
+ this.argumentsBuilder().addAll(checkNotNull(args));
+ return this;
+ }
+
+ @CanIgnoreReturnValue
+ public OverloadDecl.Builder addArguments(TypeDecl... args) {
+ return addArguments(Arrays.asList(args));
+ }
+
+ public abstract OverloadDecl.Builder setReturnType(TypeDecl returnType);
+
+ @Override
+ public ImmutableList requiredFields() {
+ return ImmutableList.of(
+ RequiredField.of("id", this::id), RequiredField.of("return", this::returnType));
+ }
+
+ /** Builds a new instance of {@link OverloadDecl}. */
+ @CheckReturnValue
+ public abstract OverloadDecl build();
+ }
+
+ /** Creates a new builder to construct a {@link OverloadDecl} instance. */
+ public static OverloadDecl.Builder newBuilder() {
+ return new AutoValue_CelEnvironment_OverloadDecl.Builder().setArguments(ImmutableList.of());
+ }
+
+ /** Converts this policy function overload into a {@link CelOverloadDecl}. */
+ public CelOverloadDecl toCelOverloadDecl(CelTypeProvider celTypeProvider) {
+ CelOverloadDecl.Builder builder =
+ CelOverloadDecl.newBuilder()
+ .setIsInstanceFunction(false)
+ .setOverloadId(id())
+ .setResultType(returnType().toCelType(celTypeProvider));
+
+ target()
+ .ifPresent(
+ t ->
+ builder
+ .setIsInstanceFunction(true)
+ .addParameterTypes(t.toCelType(celTypeProvider)));
+
+ for (TypeDecl type : arguments()) {
+ builder.addParameterTypes(type.toCelType(celTypeProvider));
+ }
+
+ return builder.build();
+ }
+ }
+
+ /**
+ * Represents an abstract type declaration used to declare functions and variables in a policy.
+ */
+ @AutoValue
+ public abstract static class TypeDecl {
+
+ public abstract String name();
+
+ public abstract ImmutableList params();
+
+ public abstract boolean isTypeParam();
+
+ /** Builder for {@link TypeDecl}. */
+ @AutoValue.Builder
+ public abstract static class Builder implements RequiredFieldsChecker {
+
+ public abstract Optional name();
+
+ public abstract TypeDecl.Builder setName(String name);
+
+ // This should stay package-private to encourage add/set methods to be used instead.
+ abstract ImmutableList.Builder paramsBuilder();
+
+ public abstract TypeDecl.Builder setParams(ImmutableList typeDecls);
+
+ @CanIgnoreReturnValue
+ public TypeDecl.Builder addParams(TypeDecl... params) {
+ return addParams(Arrays.asList(params));
+ }
+
+ @CanIgnoreReturnValue
+ public TypeDecl.Builder addParams(Iterable params) {
+ this.paramsBuilder().addAll(checkNotNull(params));
+ return this;
+ }
+
+ public abstract TypeDecl.Builder setIsTypeParam(boolean isTypeParam);
+
+ @Override
+ public ImmutableList requiredFields() {
+ return ImmutableList.of(RequiredField.of("type_name", this::name));
+ }
+
+ @CheckReturnValue
+ public abstract TypeDecl build();
+ }
+
+ /** Creates a new {@link TypeDecl} with the provided name. */
+ public static TypeDecl create(String name) {
+ return newBuilder().setName(name).build();
+ }
+
+ public static TypeDecl.Builder newBuilder() {
+ return new AutoValue_CelEnvironment_TypeDecl.Builder().setIsTypeParam(false);
+ }
+
+ /** Converts this type declaration into a {@link CelType}. */
+ public CelType toCelType(CelTypeProvider celTypeProvider) {
+ switch (name()) {
+ case "list":
+ if (params().size() != 1) {
+ throw new IllegalArgumentException(
+ "List type has unexpected param count: " + params().size());
+ }
+
+ CelType elementType = params().get(0).toCelType(celTypeProvider);
+ return ListType.create(elementType);
+ case "map":
+ if (params().size() != 2) {
+ throw new IllegalArgumentException(
+ "Map type has unexpected param count: " + params().size());
+ }
+
+ CelType keyType = params().get(0).toCelType(celTypeProvider);
+ CelType valueType = params().get(1).toCelType(celTypeProvider);
+ return MapType.create(keyType, valueType);
+ case "type":
+ checkState(
+ params().size() == 1, "Expected 1 parameter for type, got %s", params().size());
+ return TypeType.create(params().get(0).toCelType(celTypeProvider));
+ default:
+ if (isTypeParam()) {
+ return TypeParamType.create(name());
+ }
+
+ if (name().equals("dyn")) {
+ return SimpleType.DYN;
+ }
+
+ CelType simpleType = SimpleType.findByName(name()).orElse(null);
+ if (simpleType != null) {
+ return simpleType;
+ }
+
+ if (name().equals(OptionalType.NAME)) {
+ checkState(
+ params().size() == 1,
+ "Optional type must have exactly 1 parameter. Found %s",
+ params().size());
+ return OptionalType.create(params().get(0).toCelType(celTypeProvider));
+ }
+
+ return celTypeProvider
+ .findType(name())
+ .orElseThrow(() -> new IllegalArgumentException("Undefined type name: " + name()));
+ }
+ }
+ }
+
+ /** 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.
+ */
+ @AutoValue
+ public abstract static class ExtensionConfig {
+
+ /** Name of the extension (ex: bindings, optional, math, etc).". */
+ public abstract String name();
+
+ /**
+ * Version of the extension. Presently, this field is ignored as CEL-Java extensions are not
+ * versioned.
+ */
+ public abstract int version();
+
+ /** Builder for {@link ExtensionConfig}. */
+ @AutoValue.Builder
+ public abstract static class Builder implements RequiredFieldsChecker {
+
+ public abstract Optional name();
+
+ public abstract Optional version();
+
+ public abstract ExtensionConfig.Builder setName(String name);
+
+ public abstract ExtensionConfig.Builder setVersion(int version);
+
+ @Override
+ public ImmutableList requiredFields() {
+ return ImmutableList.of(RequiredField.of("name", this::name));
+ }
+
+ /** Builds a new instance of {@link ExtensionConfig}. */
+ public abstract ExtensionConfig build();
+ }
+
+ /** Creates a new builder to construct a {@link ExtensionConfig} instance. */
+ public static ExtensionConfig.Builder newBuilder() {
+ return new AutoValue_CelEnvironment_ExtensionConfig.Builder().setVersion(0);
+ }
+
+ /** Create a new extension config with the specified name and version set to 0. */
+ public static ExtensionConfig of(String name) {
+ return of(name, 0);
+ }
+
+ /** Create a new extension config with the specified name and version. */
+ public static ExtensionConfig of(String name, int version) {
+ return newBuilder().setName(name).setVersion(version).build();
+ }
+
+ /** Create a new extension config with the specified name and the latest version. */
+ public static ExtensionConfig latest(String name) {
+ return of(name, Integer.MAX_VALUE);
+ }
+ }
+
+ @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()),
+ PROTOS((options, version) -> CelExtensions.protos()),
+ ENCODERS(
+ (options, version) -> CelExtensions.encoders(options),
+ (options, version) -> CelExtensions.encoders(options)),
+ MATH(
+ (options, version) -> CelExtensions.math(options, version),
+ (options, version) -> CelExtensions.math(options, version)),
+ OPTIONAL(
+ (options, version) -> CelExtensions.optional(version),
+ (options, version) -> CelExtensions.optional(version)),
+ STRINGS(
+ (options, version) -> CelExtensions.strings(),
+ (options, version) -> CelExtensions.strings()),
+ SETS(
+ (options, version) -> CelExtensions.sets(options),
+ (options, version) -> CelExtensions.sets(options)),
+ REGEX((options, version) -> CelExtensions.regex(), (options, version) -> CelExtensions.regex()),
+ LISTS((options, version) -> CelExtensions.lists(), (options, version) -> CelExtensions.lists()),
+ COMPREHENSIONS(
+ (options, version) -> CelExtensions.comprehensions(),
+ (options, version) -> CelExtensions.comprehensions());
+
+ @SuppressWarnings("ImmutableEnumChecker")
+ private final CompilerExtensionProvider compilerExtensionProvider;
+
+ @SuppressWarnings("ImmutableEnumChecker")
+ private final RuntimeExtensionProvider runtimeExtensionProvider;
+
+ interface CompilerExtensionProvider {
+ CelCompilerLibrary getCelCompilerLibrary(CelOptions options, int version);
+ }
+
+ interface RuntimeExtensionProvider {
+ CelRuntimeLibrary getCelRuntimeLibrary(CelOptions options, int version);
+ }
+
+ CompilerExtensionProvider compilerExtensionProvider() {
+ return compilerExtensionProvider;
+ }
+
+ RuntimeExtensionProvider runtimeExtensionProvider() {
+ return runtimeExtensionProvider;
+ }
+
+ CanonicalCelExtension(CompilerExtensionProvider compilerExtensionProvider) {
+ this.compilerExtensionProvider = compilerExtensionProvider;
+ this.runtimeExtensionProvider = null; // Not all extensions augment the runtime.
+ }
+
+ CanonicalCelExtension(
+ CompilerExtensionProvider compilerExtensionProvider,
+ RuntimeExtensionProvider runtimeExtensionProvider) {
+ this.compilerExtensionProvider = compilerExtensionProvider;
+ this.runtimeExtensionProvider = runtimeExtensionProvider;
+ }
+ }
+
+ /**
+ * LibrarySubset indicates a subset of the macros and function supported by a subsettable library.
+ */
+ @AutoValue
+ public abstract static class LibrarySubset {
+
+ /**
+ * Disabled indicates whether the library has been disabled, typically only used for
+ * default-enabled libraries like stdlib.
+ */
+ public abstract boolean disabled();
+
+ /** DisableMacros disables macros for the given library. */
+ public abstract boolean macrosDisabled();
+
+ /** IncludeMacros specifies a set of macro function names to include in the subset. */
+ public abstract ImmutableSet includedMacros();
+
+ /**
+ * ExcludeMacros specifies a set of macro function names to exclude from the subset.
+ *
+ * Note: if IncludedMacros is non-empty, then ExcludedMacros is ignored.
+ */
+ public abstract ImmutableSet excludedMacros();
+
+ /**
+ * IncludeFunctions specifies a set of functions to include in the subset.
+ *
+ * Note: the overloads specified in the subset need only specify their ID.
+ *
+ *
Note: if IncludedFunctions is non-empty, then ExcludedFunctions is ignored.
+ */
+ public abstract ImmutableSet includedFunctions();
+
+ /**
+ * ExcludeFunctions specifies the set of functions to exclude from the subset.
+ *
+ * Note: the overloads specified in the subset need only specify their ID.
+ */
+ public abstract ImmutableSet excludedFunctions();
+
+ public static Builder newBuilder() {
+ return new AutoValue_CelEnvironment_LibrarySubset.Builder()
+ .setMacrosDisabled(false)
+ .setIncludedMacros(ImmutableSet.of())
+ .setExcludedMacros(ImmutableSet.of())
+ .setIncludedFunctions(ImmutableSet.of())
+ .setExcludedFunctions(ImmutableSet.of());
+ }
+
+ /** Builder for {@link LibrarySubset}. */
+ @AutoValue.Builder
+ public abstract static class Builder {
+
+ public abstract Builder setDisabled(boolean disabled);
+
+ public abstract Builder setMacrosDisabled(boolean disabled);
+
+ public abstract Builder setIncludedMacros(ImmutableSet includedMacros);
+
+ public abstract Builder setExcludedMacros(ImmutableSet excludedMacros);
+
+ public abstract Builder setIncludedFunctions(
+ ImmutableSet includedFunctions);
+
+ public abstract Builder setExcludedFunctions(
+ ImmutableSet excludedFunctions);
+
+ @CheckReturnValue
+ public abstract LibrarySubset build();
+ }
+
+ /**
+ * Represents a function selector, which can be used to configure included/excluded library
+ * functions.
+ */
+ @AutoValue
+ public abstract static class FunctionSelector {
+
+ public abstract String name();
+
+ public abstract ImmutableSet overloads();
+
+ /** Builder for {@link FunctionSelector}. */
+ @AutoValue.Builder
+ public abstract static class Builder implements RequiredFieldsChecker {
+
+ public abstract Optional name();
+
+ public abstract Builder setName(String name);
+
+ public abstract Builder setOverloads(ImmutableSet overloads);
+
+ @Override
+ public ImmutableList requiredFields() {
+ return ImmutableList.of(RequiredField.of("name", this::name));
+ }
+
+ /** Builds a new instance of {@link FunctionSelector}. */
+ public abstract FunctionSelector build();
+ }
+
+ /** Creates a new builder to construct a {@link FunctionSelector} instance. */
+ public static FunctionSelector.Builder newBuilder() {
+ return new AutoValue_CelEnvironment_LibrarySubset_FunctionSelector.Builder()
+ .setOverloads(ImmutableSet.of());
+ }
+
+ public static FunctionSelector create(String name, ImmutableSet overloads) {
+ return newBuilder()
+ .setName(name)
+ .setOverloads(
+ overloads.stream()
+ .map(id -> OverloadSelector.newBuilder().setId(id).build())
+ .collect(toImmutableSet()))
+ .build();
+ }
+
+ private static boolean matchesAny(
+ StandardFunction function,
+ StandardOverload overload,
+ ImmutableSet selectors) {
+ String functionName = function.functionDecl().name();
+ for (FunctionSelector functionSelector : selectors) {
+ if (!functionSelector.name().equals(functionName)) {
+ continue;
+ }
+
+ if (functionSelector.overloads().isEmpty()) {
+ return true;
+ }
+
+ String overloadId = overload.celOverloadDecl().overloadId();
+ for (OverloadSelector overloadSelector : functionSelector.overloads()) {
+ if (overloadSelector.id().equals(overloadId)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ }
+
+ /** Represents an overload selector on a function selector. */
+ @AutoValue
+ public abstract static class OverloadSelector {
+
+ /** An overload ID. Required. Follows the same format as {@link OverloadDecl#id()} */
+ public abstract String id();
+
+ /** Builder for {@link OverloadSelector}. */
+ @AutoValue.Builder
+ public abstract static class Builder implements RequiredFieldsChecker {
+
+ public abstract Optional id();
+
+ public abstract Builder setId(String overloadId);
+
+ @Override
+ public ImmutableList requiredFields() {
+ return ImmutableList.of(RequiredField.of("id", this::id));
+ }
+
+ /** Builds a new instance of {@link OverloadSelector}. */
+ @CheckReturnValue
+ public abstract OverloadSelector build();
+ }
+
+ /** Creates a new builder to construct a {@link OverloadSelector} instance. */
+ public static OverloadSelector.Builder newBuilder() {
+ return new AutoValue_CelEnvironment_LibrarySubset_OverloadSelector.Builder();
+ }
+ }
+ }
+
+ @FunctionalInterface
+ private interface BooleanOptionConsumer {
+ void accept(CelOptions.Builder options, boolean value);
+ }
+}
diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentException.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentException.java
new file mode 100644
index 000000000..58bb5cdb9
--- /dev/null
+++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentException.java
@@ -0,0 +1,29 @@
+// 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.bundle;
+
+import dev.cel.common.CelException;
+
+/** Checked exception thrown when a CEL environment is misconfigured. */
+public final class CelEnvironmentException extends CelException {
+
+ CelEnvironmentException(String message) {
+ super(message);
+ }
+
+ CelEnvironmentException(String message, Throwable cause) {
+ super(message, cause);
+ }
+}
diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentExporter.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentExporter.java
new file mode 100644
index 000000000..d233fd36f
--- /dev/null
+++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentExporter.java
@@ -0,0 +1,520 @@
+// 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.bundle;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
+import static java.util.Arrays.stream;
+
+import dev.cel.expr.Decl;
+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;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import dev.cel.bundle.CelEnvironment.ExtensionConfig;
+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;
+import dev.cel.common.CelOptions;
+import dev.cel.common.CelOverloadDecl;
+import dev.cel.common.CelVarDecl;
+import dev.cel.common.internal.EnvVisitable;
+import dev.cel.common.internal.EnvVisitor;
+import dev.cel.common.types.CelKind;
+import dev.cel.common.types.CelProtoTypes;
+import dev.cel.common.types.CelType;
+import dev.cel.compiler.CelCompiler;
+import dev.cel.extensions.CelExtensionLibrary;
+import dev.cel.extensions.CelExtensions;
+import dev.cel.parser.CelMacro;
+import dev.cel.parser.CelStandardMacro;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * {@code CelEnvironmentExporter} can be used to export the configuration of a {@link Cel} instance
+ * as a {@link CelEnvironment} object.
+ *
+ * This exporter captures details such as:
+ *
+ *
+ * Standard library subset: Functions and their overloads that are either included or
+ * excluded.
+ * Extension libraries: Names and versions of the extension libraries in use.
+ * Custom declarations: Functions and variables not part of standard or extension libraries.
+ *
+ *
+ * The exporter provides options to control the behavior of the export process, such as the
+ * maximum number of excluded standard functions and overloads before switching to an inclusion
+ * strategy.
+ */
+@AutoValue
+public abstract class CelEnvironmentExporter {
+
+ /**
+ * Maximum number of excluded standard functions and macros before switching to a format that
+ * enumerates all included functions and macros. The default is 5.
+ *
+ *
This setting is primarily for stylistic preferences and the intended use of the resulting
+ * YAML file.
+ *
+ *
For example, if you want almost all the standard library with only a few exceptions (e.g.,
+ * to ban a specific function), you would favor an exclusion-based approach by setting an
+ * appropriate threshold.
+ *
+ *
If you want full control over what is available to the CEL runtime, where no function is
+ * included unless fully vetted, you would favor an inclusion-based approach by setting the
+ * threshold to 0. This may result in a more verbose YAML file.
+ */
+ abstract int maxExcludedStandardFunctions();
+
+ /**
+ * Maximum number of excluded standard function overloads before switching to a exhaustive
+ * enumeration of included overloads. The default is 15.
+ */
+ abstract int maxExcludedStandardFunctionOverloads();
+
+ abstract ImmutableSet>
+ extensionLibraries();
+
+ /** Builder for {@link CelEnvironmentExporter}. */
+ @AutoValue.Builder
+ public abstract static class Builder {
+
+ public abstract Builder setMaxExcludedStandardFunctions(int count);
+
+ public abstract Builder setMaxExcludedStandardFunctionOverloads(int count);
+
+ abstract ImmutableSet.Builder>
+ extensionLibrariesBuilder();
+
+ @CanIgnoreReturnValue
+ public Builder addStandardExtensions(CelOptions options) {
+ addExtensionLibraries(
+ CelExtensions.getExtensionLibrary("bindings", options),
+ CelExtensions.getExtensionLibrary("encoders", options),
+ CelExtensions.getExtensionLibrary("lists", options),
+ CelExtensions.getExtensionLibrary("math", options),
+ CelExtensions.getExtensionLibrary("protos", options),
+ CelExtensions.getExtensionLibrary("regex", options),
+ CelExtensions.getExtensionLibrary("sets", options),
+ CelExtensions.getExtensionLibrary("strings", options));
+ // TODO: add support for remaining standard extensions
+ return this;
+ }
+
+ @CanIgnoreReturnValue
+ public Builder addExtensionLibraries(
+ CelExtensionLibrary... libraries) {
+ extensionLibrariesBuilder().add(libraries);
+ return this;
+ }
+
+ abstract CelEnvironmentExporter autoBuild();
+
+ public CelEnvironmentExporter build() {
+ return autoBuild();
+ }
+ }
+
+ /** Creates a new builder to construct a {@link CelEnvironmentExporter} instance. */
+ public static CelEnvironmentExporter.Builder newBuilder() {
+ return new AutoValue_CelEnvironmentExporter.Builder()
+ .setMaxExcludedStandardFunctions(5)
+ .setMaxExcludedStandardFunctionOverloads(15);
+ }
+
+ /**
+ * Exports a {@link CelEnvironment} that describes the configuration of the given {@link Cel}
+ * 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(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.
+ //
+ // Once we have the inventory, we attempt to identify sources of these declarations as
+ // standard library and extensions. The identified subsets will be removed from the inventory.
+ //
+ // 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);
+ 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, CelCompiler cel) {
+ Preconditions.checkArgument(cel instanceof EnvVisitable);
+ ((EnvVisitable) cel)
+ .accept(
+ new EnvVisitor() {
+ @Override
+ public void visitDecl(String name, List decls) {
+ for (Decl decl : decls) {
+ if (decl.hasFunction()) {
+ FunctionDecl function = decl.getFunction();
+ for (Overload overload : function.getOverloadsList()) {
+ inventory.add(
+ NamedOverload.create(
+ decl.getName(), CelOverloadDecl.overloadToCelOverload(overload)));
+ }
+ } else if (decl.hasIdent()) {
+ inventory.add(
+ CelVarDecl.newVarDeclaration(
+ decl.getName(),
+ CelProtoTypes.typeToCelType(decl.getIdent().getType())));
+ }
+ }
+ }
+
+ @Override
+ public void visitMacro(CelMacro macro) {
+ inventory.add(macro);
+ }
+ });
+ }
+
+ /**
+ * Iterates through the available extension libraries, checks if they are included in the
+ * inventory, and adds them to the environment builder. Only the highest version of a library is
+ * added to the builder. If the extension is identified, all corresponding items are removed from
+ * the inventory.
+ */
+ private void addExtensionConfigsAndRemoveFromInventory(
+ CelEnvironment.Builder envBuilder, Set inventory) {
+ ArrayList featureSets = new ArrayList<>();
+
+ for (CelExtensionLibrary extensionLibrary :
+ extensionLibraries()) {
+ for (CelExtensionLibrary.FeatureSet featureSet : extensionLibrary.versions()) {
+ featureSets.add(NamedFeatureSet.create(extensionLibrary.name(), featureSet));
+ }
+ }
+
+ featureSets.sort(
+ Comparator.comparing(NamedFeatureSet::name)
+ .thenComparing(nfs -> nfs.featureSet().version())
+ .reversed());
+
+ Set includedExtensions = new HashSet<>();
+ for (NamedFeatureSet lib : featureSets) {
+ if (includedExtensions.contains(lib.name())) {
+ // We only need to infer the highest version library, so we can skip lower versions
+ continue;
+ }
+
+ if (checkIfExtensionIsIncludedAndRemoveFromInventory(inventory, lib.featureSet())) {
+ envBuilder.addExtensions(ExtensionConfig.of(lib.name(), lib.featureSet().version()));
+ includedExtensions.add(lib.name());
+ }
+ }
+ }
+
+ private boolean checkIfExtensionIsIncludedAndRemoveFromInventory(
+ Set inventory, CelExtensionLibrary.FeatureSet featureSet) {
+ ImmutableSet functions = featureSet.functions();
+ ArrayList includedFeatures = new ArrayList<>(functions.size());
+ for (CelFunctionDecl function : functions) {
+ for (CelOverloadDecl overload : function.overloads()) {
+ NamedOverload feature = NamedOverload.create(function.name(), overload);
+ if (!inventory.contains(feature)) {
+ return false;
+ }
+ includedFeatures.add(feature);
+ }
+ }
+
+ ImmutableSet macros = featureSet.macros();
+ for (CelMacro macro : macros) {
+ if (!inventory.contains(macro)) {
+ return false;
+ }
+ includedFeatures.add(macro);
+ }
+
+ // TODO - Add checks for variables.
+
+ inventory.removeAll(includedFeatures);
+ return true;
+ }
+
+ private void addStandardLibrarySubsetAndRemoveFromInventory(
+ CelEnvironment.Builder envBuilder, Set inventory) {
+ // Claim standard identifiers for the standard library
+ for (StandardIdentifier value : StandardIdentifier.values()) {
+ inventory.remove(
+ CelVarDecl.newVarDeclaration(value.identDecl().name(), value.identDecl().type()));
+ }
+
+ Set excludedFunctions = new HashSet<>();
+ Set includedFunctions = new HashSet<>();
+ ListMultimap excludedOverloads = ArrayListMultimap.create();
+ ListMultimap includedOverloads = ArrayListMultimap.create();
+
+ stream(StandardFunction.values())
+ .map(StandardFunction::functionDecl)
+ .forEach(
+ decl -> {
+ String functionName = decl.name();
+ boolean anyOverloadIncluded = false;
+ boolean allOverloadsIncluded = true;
+ for (CelOverloadDecl overload : decl.overloads()) {
+ NamedOverload item = NamedOverload.create(functionName, overload);
+ if (inventory.remove(item)) {
+ anyOverloadIncluded = true;
+ includedOverloads.put(functionName, overload.overloadId());
+ } else {
+ allOverloadsIncluded = false;
+ excludedOverloads.put(functionName, overload.overloadId());
+ }
+ }
+ if (!anyOverloadIncluded) {
+ excludedFunctions.add(functionName);
+ }
+ if (allOverloadsIncluded) {
+ includedFunctions.add(functionName);
+ }
+ });
+
+ Set excludedMacros = new HashSet<>();
+ Set includedMacros = new HashSet<>();
+ stream(CelStandardMacro.values())
+ .map(celStandardMacro -> celStandardMacro.getDefinition())
+ .forEach(
+ macro -> {
+ if (inventory.remove(macro)) {
+ includedMacros.add(macro.getFunction());
+ } else {
+ excludedMacros.add(macro.getFunction());
+ }
+ });
+
+ LibrarySubset.Builder subsetBuilder = LibrarySubset.newBuilder().setDisabled(false);
+ if (excludedFunctions.size() + excludedMacros.size() <= maxExcludedStandardFunctions()
+ && excludedOverloads.size() <= maxExcludedStandardFunctionOverloads()) {
+ subsetBuilder
+ .setExcludedFunctions(buildFunctionSelectors(excludedFunctions, excludedOverloads))
+ .setExcludedMacros(ImmutableSet.copyOf(excludedMacros));
+ } else {
+ subsetBuilder
+ .setIncludedFunctions(buildFunctionSelectors(includedFunctions, includedOverloads))
+ .setIncludedMacros(ImmutableSet.copyOf(includedMacros));
+ }
+
+ envBuilder.setStandardLibrarySubset(subsetBuilder.build());
+ }
+
+ private ImmutableSet buildFunctionSelectors(
+ Set functions, ListMultimap functionToOverloadsMap) {
+ ImmutableSet.Builder functionSelectors = ImmutableSet.builder();
+ for (String excludedFunction : functions) {
+ functionSelectors.add(FunctionSelector.create(excludedFunction, ImmutableSet.of()));
+ }
+
+ for (String functionName : functionToOverloadsMap.keySet()) {
+ if (functions.contains(functionName)) {
+ continue;
+ }
+ functionSelectors.add(
+ FunctionSelector.create(
+ functionName, ImmutableSet.copyOf(functionToOverloadsMap.get(functionName))));
+ }
+ return functionSelectors.build();
+ }
+
+ private void addCustomDecls(CelEnvironment.Builder envBuilder, Set inventory) {
+ // Group "orphaned" function overloads and vars by their names
+ ListMultimap extraOverloads = ArrayListMultimap.create();
+ Map extraVars = new HashMap<>();
+ for (Object item : inventory) {
+ if (item instanceof NamedOverload) {
+ extraOverloads.put(
+ ((NamedOverload) item).functionName(), ((NamedOverload) item).overload());
+ } else if (item instanceof CelVarDecl) {
+ extraVars.put(((CelVarDecl) item).name(), ((CelVarDecl) item).type());
+ }
+ }
+
+ if (!extraOverloads.isEmpty()) {
+ ImmutableSet.Builder functionDeclBuilder =
+ ImmutableSet.builder();
+ for (String functionName : extraOverloads.keySet()) {
+ functionDeclBuilder.add(
+ CelEnvironment.FunctionDecl.create(
+ functionName,
+ extraOverloads.get(functionName).stream()
+ .map(this::toCelEnvOverloadDecl)
+ .collect(toImmutableSet())));
+ }
+ envBuilder.setFunctions(functionDeclBuilder.build());
+ }
+
+ if (!extraVars.isEmpty()) {
+ ImmutableSet.Builder varDeclBuilder = ImmutableSet.builder();
+ for (String ident : extraVars.keySet()) {
+ varDeclBuilder.add(
+ CelEnvironment.VariableDecl.create(ident, toCelEnvTypeDecl(extraVars.get(ident))));
+ }
+ envBuilder.setVariables(varDeclBuilder.build());
+ }
+ }
+
+ private CelEnvironment.OverloadDecl toCelEnvOverloadDecl(CelOverloadDecl overload) {
+ OverloadDecl.Builder builder =
+ OverloadDecl.newBuilder()
+ .setId(overload.overloadId())
+ .setReturnType(toCelEnvTypeDecl(overload.resultType()));
+
+ if (overload.isInstanceFunction()) {
+ builder
+ .setTarget(toCelEnvTypeDecl(overload.parameterTypes().get(0)))
+ .setArguments(
+ overload.parameterTypes().stream()
+ .skip(1)
+ .map(this::toCelEnvTypeDecl)
+ .collect(toImmutableList()));
+ } else {
+ builder.setArguments(
+ overload.parameterTypes().stream()
+ .map(this::toCelEnvTypeDecl)
+ .collect(toImmutableList()));
+ }
+ return builder.build();
+ }
+
+ private CelEnvironment.TypeDecl toCelEnvTypeDecl(CelType type) {
+ return CelEnvironment.TypeDecl.newBuilder()
+ .setName(type.name())
+ .setIsTypeParam(type.kind() == CelKind.TYPE_PARAM)
+ .addParams(
+ type.parameters().stream().map(this::toCelEnvTypeDecl).collect(toImmutableList()))
+ .build();
+ }
+
+ /** Wrapper for CelOverloadDecl, associating it with the corresponding function name. */
+ @AutoValue
+ abstract static class NamedOverload {
+ abstract String functionName();
+
+ abstract CelOverloadDecl overload();
+
+ static NamedOverload create(String functionName, CelOverloadDecl overload) {
+ return new AutoValue_CelEnvironmentExporter_NamedOverload(functionName, overload);
+ }
+ }
+
+ /**
+ * Wrapper for CelExtensionLibrary.FeatureSet, associating it with the corresponding library name.
+ */
+ @AutoValue
+ abstract static class NamedFeatureSet {
+ abstract String name();
+
+ abstract CelExtensionLibrary.FeatureSet featureSet();
+
+ static NamedFeatureSet create(String name, CelExtensionLibrary.FeatureSet featureSet) {
+ return new AutoValue_CelEnvironmentExporter_NamedFeatureSet(name, featureSet);
+ }
+ }
+}
diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlParser.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlParser.java
new file mode 100644
index 000000000..14f1c93d8
--- /dev/null
+++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlParser.java
@@ -0,0 +1,948 @@
+// 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.bundle;
+
+import static dev.cel.common.formats.YamlHelper.ERROR;
+import static dev.cel.common.formats.YamlHelper.assertRequiredFields;
+import static dev.cel.common.formats.YamlHelper.assertYamlType;
+import static dev.cel.common.formats.YamlHelper.newBoolean;
+import static dev.cel.common.formats.YamlHelper.newInteger;
+import static dev.cel.common.formats.YamlHelper.newString;
+import static dev.cel.common.formats.YamlHelper.parseYamlSource;
+import static dev.cel.common.formats.YamlHelper.validateYamlType;
+import static java.util.Collections.singletonList;
+
+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.ContextVariable;
+import dev.cel.bundle.CelEnvironment.ExtensionConfig;
+import dev.cel.bundle.CelEnvironment.FunctionDecl;
+import dev.cel.bundle.CelEnvironment.LibrarySubset;
+import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector;
+import dev.cel.bundle.CelEnvironment.LibrarySubset.OverloadSelector;
+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;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.nodes.NodeTuple;
+import org.yaml.snakeyaml.nodes.ScalarNode;
+import org.yaml.snakeyaml.nodes.SequenceNode;
+import org.yaml.snakeyaml.nodes.Tag;
+
+/**
+ * CelEnvironmentYamlParser intakes a YAML document that describes the structure of a CEL
+ * environment, parses it then creates a {@link CelEnvironment}.
+ */
+public final class CelEnvironmentYamlParser {
+ // Sentinel values to be returned for various declarations when parsing failure is encountered.
+ private static final TypeDecl ERROR_TYPE_DECL = TypeDecl.create(ERROR);
+ private static final VariableDecl ERROR_VARIABLE_DECL =
+ VariableDecl.create(ERROR, ERROR_TYPE_DECL);
+ private static final FunctionDecl ERROR_FUNCTION_DECL =
+ FunctionDecl.create(ERROR, ImmutableSet.of());
+ 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() {
+ return new CelEnvironmentYamlParser();
+ }
+
+ /** Parsers the input {@code environmentYamlSource} and returns a {@link CelEnvironment}. */
+ public CelEnvironment parse(String environmentYamlSource) throws CelEnvironmentException {
+ return parse(environmentYamlSource, "The {@code description} may be used to help tailor error messages for the location where the
+ * {@code environmentYamlSource} originates, e.g. a file name or form UI element.
+ */
+ public CelEnvironment parse(String environmentYamlSource, String description)
+ throws CelEnvironmentException {
+ CelEnvironmentYamlParser.ParserImpl parser = new CelEnvironmentYamlParser.ParserImpl();
+
+ 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 ContextVariable parseContextVariable(ParserContext ctx, Node node) {
+ long id = ctx.collectMetadata(node);
+ if (!assertYamlType(ctx, id, node, YamlNodeType.MAP)) {
+ return ContextVariable.create("");
+ }
+
+ MappingNode mapNode = (MappingNode) node;
+ String typeName = "";
+ for (NodeTuple nodeTuple : mapNode.getValue()) {
+ Node keyNode = nodeTuple.getKeyNode();
+ long keyId = ctx.collectMetadata(keyNode);
+ Node valueNode = nodeTuple.getValueNode();
+ String keyName = ((ScalarNode) keyNode).getValue();
+ switch (keyName) {
+ case "type_name":
+ typeName = newString(ctx, valueNode);
+ break;
+ default:
+ ctx.reportError(keyId, String.format("Unsupported context_variable tag: %s", keyName));
+ break;
+ }
+ }
+
+ if (typeName.isEmpty()) {
+ ctx.reportError(id, "Missing required attribute(s): type_name");
+ }
+
+ return ContextVariable.create(typeName);
+ }
+
+ private ImmutableSet parseVariables(ParserContext ctx, Node node) {
+ long valueId = ctx.collectMetadata(node);
+ ImmutableSet.Builder variableSetBuilder = ImmutableSet.builder();
+ if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) {
+ return variableSetBuilder.build();
+ }
+
+ SequenceNode variableListNode = (SequenceNode) node;
+ for (Node elementNode : variableListNode.getValue()) {
+ variableSetBuilder.add(parseVariable(ctx, elementNode));
+ }
+
+ return variableSetBuilder.build();
+ }
+
+ private VariableDecl parseVariable(ParserContext ctx, Node node) {
+ long variableId = ctx.collectMetadata(node);
+ if (!assertYamlType(ctx, variableId, node, YamlNodeType.MAP)) {
+ return ERROR_VARIABLE_DECL;
+ }
+
+ MappingNode variableMap = (MappingNode) node;
+ VariableDecl.Builder builder = VariableDecl.newBuilder();
+ TypeDecl.Builder typeDeclBuilder = null;
+ 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 "description":
+ builder.setDescription(newString(ctx, valueNode));
+ break;
+ case "type":
+ if (typeDeclBuilder != null) {
+ ctx.reportError(
+ keyId,
+ String.format(
+ "'type' tag cannot be used together with inlined 'type_name', 'is_type_param'"
+ + " or 'params': %s",
+ keyName));
+ break;
+ }
+ builder.setType(parseTypeDecl(ctx, valueNode));
+ break;
+ case "type_name":
+ case "is_type_param":
+ case "params":
+ if (typeDeclBuilder == null) {
+ typeDeclBuilder = TypeDecl.newBuilder();
+ }
+ typeDeclBuilder = parseInlinedTypeDecl(ctx, keyId, keyNode, valueNode, typeDeclBuilder);
+ break;
+ default:
+ ctx.reportError(keyId, String.format("Unsupported variable tag: %s", keyName));
+ break;
+ }
+ }
+
+ if (typeDeclBuilder != null) {
+ if (!assertRequiredFields(ctx, variableId, typeDeclBuilder.getMissingRequiredFieldNames())) {
+ return ERROR_VARIABLE_DECL;
+ }
+ builder.setType(typeDeclBuilder.build());
+ }
+
+ if (!assertRequiredFields(ctx, variableId, builder.getMissingRequiredFieldNames())) {
+ return ERROR_VARIABLE_DECL;
+ }
+
+ return builder.build();
+ }
+
+ private ImmutableSet parseFunctions(ParserContext ctx, Node node) {
+ long valueId = ctx.collectMetadata(node);
+ ImmutableSet.Builder functionSetBuilder = ImmutableSet.builder();
+ if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) {
+ return functionSetBuilder.build();
+ }
+
+ SequenceNode functionListNode = (SequenceNode) node;
+ for (Node elementNode : functionListNode.getValue()) {
+ functionSetBuilder.add(parseFunction(ctx, elementNode));
+ }
+
+ return functionSetBuilder.build();
+ }
+
+ private FunctionDecl parseFunction(ParserContext ctx, Node node) {
+ long functionId = ctx.collectMetadata(node);
+ if (!assertYamlType(ctx, functionId, node, YamlNodeType.MAP)) {
+ return ERROR_FUNCTION_DECL;
+ }
+
+ MappingNode functionMap = (MappingNode) node;
+ FunctionDecl.Builder builder = FunctionDecl.newBuilder();
+ for (NodeTuple nodeTuple : functionMap.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 "overloads":
+ builder.setOverloads(parseOverloads(ctx, valueNode));
+ break;
+ case "description":
+ builder.setDescription(newString(ctx, valueNode).trim());
+ break;
+ default:
+ ctx.reportError(keyId, String.format("Unsupported function tag: %s", keyName));
+ break;
+ }
+ }
+
+ if (!assertRequiredFields(ctx, functionId, builder.getMissingRequiredFieldNames())) {
+ return ERROR_FUNCTION_DECL;
+ }
+
+ return builder.build();
+ }
+
+ private static ImmutableSet parseOverloads(ParserContext ctx, Node node) {
+ long listId = ctx.collectMetadata(node);
+ ImmutableSet.Builder overloadSetBuilder = ImmutableSet.builder();
+ if (!assertYamlType(ctx, listId, node, YamlNodeType.LIST)) {
+ return overloadSetBuilder.build();
+ }
+
+ SequenceNode overloadListNode = (SequenceNode) node;
+ for (Node overloadMapNode : overloadListNode.getValue()) {
+ long overloadMapId = ctx.collectMetadata(overloadMapNode);
+ if (!assertYamlType(ctx, overloadMapId, overloadMapNode, YamlNodeType.MAP)) {
+ continue;
+ }
+
+ MappingNode mapNode = (MappingNode) overloadMapNode;
+ OverloadDecl.Builder overloadDeclBuilder = OverloadDecl.newBuilder();
+ for (NodeTuple nodeTuple : mapNode.getValue()) {
+ Node keyNode = nodeTuple.getKeyNode();
+ long keyId = ctx.collectMetadata(keyNode);
+ if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) {
+ continue;
+ }
+
+ Node valueNode = nodeTuple.getValueNode();
+ String fieldName = ((ScalarNode) keyNode).getValue();
+ switch (fieldName) {
+ case "id":
+ overloadDeclBuilder.setId(newString(ctx, valueNode));
+ break;
+ case "args":
+ overloadDeclBuilder.addArguments(parseOverloadArguments(ctx, valueNode));
+ break;
+ case "return":
+ overloadDeclBuilder.setReturnType(parseTypeDecl(ctx, valueNode));
+ break;
+ case "target":
+ overloadDeclBuilder.setTarget(parseTypeDecl(ctx, valueNode));
+ break;
+ case "examples":
+ overloadDeclBuilder.addExamples(parseOverloadExamples(ctx, valueNode));
+ break;
+ default:
+ ctx.reportError(keyId, String.format("Unsupported overload tag: %s", fieldName));
+ break;
+ }
+ }
+
+ if (assertRequiredFields(
+ ctx, overloadMapId, overloadDeclBuilder.getMissingRequiredFieldNames())) {
+ overloadSetBuilder.add(overloadDeclBuilder.build());
+ }
+ }
+
+ return overloadSetBuilder.build();
+ }
+
+ private static ImmutableList parseOverloadExamples(ParserContext ctx, Node node) {
+ long listValueId = ctx.collectMetadata(node);
+ if (!assertYamlType(ctx, listValueId, node, YamlNodeType.LIST)) {
+ return ImmutableList.of();
+ }
+ SequenceNode paramsListNode = (SequenceNode) node;
+ ImmutableList.Builder builder = ImmutableList.builder();
+ for (Node elementNode : paramsListNode.getValue()) {
+ long elementNodeId = ctx.collectMetadata(elementNode);
+ if (!assertYamlType(ctx, elementNodeId, elementNode, YamlNodeType.STRING)) {
+ continue;
+ }
+
+ builder.add(((ScalarNode) elementNode).getValue());
+ }
+
+ return builder.build();
+ }
+
+ private static ImmutableList parseOverloadArguments(
+ ParserContext ctx, Node node) {
+ long listValueId = ctx.collectMetadata(node);
+ if (!assertYamlType(ctx, listValueId, node, YamlNodeType.LIST)) {
+ return ImmutableList.of();
+ }
+ SequenceNode paramsListNode = (SequenceNode) node;
+ ImmutableList.Builder builder = ImmutableList.builder();
+ for (Node elementNode : paramsListNode.getValue()) {
+ builder.add(parseTypeDecl(ctx, elementNode));
+ }
+
+ return builder.build();
+ }
+
+ private static ImmutableSet parseExtensions(ParserContext ctx, Node node) {
+ long valueId = ctx.collectMetadata(node);
+ ImmutableSet.Builder extensionConfigBuilder = ImmutableSet.builder();
+ if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) {
+ return extensionConfigBuilder.build();
+ }
+
+ SequenceNode extensionListNode = (SequenceNode) node;
+ for (Node elementNode : extensionListNode.getValue()) {
+ extensionConfigBuilder.add(parseExtension(ctx, elementNode));
+ }
+
+ return extensionConfigBuilder.build();
+ }
+
+ private static ExtensionConfig parseExtension(ParserContext ctx, Node node) {
+ long extensionId = ctx.collectMetadata(node);
+ if (!assertYamlType(ctx, extensionId, node, YamlNodeType.MAP)) {
+ return ERROR_EXTENSION_DECL;
+ }
+
+ MappingNode extensionMap = (MappingNode) node;
+ ExtensionConfig.Builder builder = ExtensionConfig.newBuilder();
+ for (NodeTuple nodeTuple : extensionMap.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 "version":
+ if (validateYamlType(valueNode, YamlNodeType.INTEGER)) {
+ builder.setVersion(newInteger(ctx, valueNode));
+ break;
+ } else if (validateYamlType(valueNode, YamlNodeType.STRING, YamlNodeType.TEXT)) {
+ String versionStr = newString(ctx, valueNode);
+ if (versionStr.equals("latest")) {
+ builder.setVersion(Integer.MAX_VALUE);
+ break;
+ }
+
+ Integer versionInt = tryParse(versionStr);
+ if (versionInt != null) {
+ builder.setVersion(versionInt);
+ break;
+ }
+ // Fall-through
+ }
+ ctx.reportError(keyId, String.format("Unsupported version tag: %s", keyName));
+ break;
+ default:
+ ctx.reportError(keyId, String.format("Unsupported extension tag: %s", keyName));
+ break;
+ }
+ }
+
+ if (!assertRequiredFields(ctx, extensionId, builder.getMissingRequiredFieldNames())) {
+ return ERROR_EXTENSION_DECL;
+ }
+
+ return builder.build();
+ }
+
+ private static LibrarySubset parseLibrarySubset(ParserContext ctx, Node node) {
+ LibrarySubset.Builder builder = LibrarySubset.newBuilder().setDisabled(false);
+ MappingNode subsetMap = (MappingNode) node;
+ for (NodeTuple nodeTuple : subsetMap.getValue()) {
+ Node keyNode = nodeTuple.getKeyNode();
+ long keyId = ctx.collectMetadata(keyNode);
+ Node valueNode = nodeTuple.getValueNode();
+ String keyName = ((ScalarNode) keyNode).getValue();
+ switch (keyName) {
+ case "disabled":
+ builder.setDisabled(newBoolean(ctx, valueNode));
+ break;
+ case "disable_macros":
+ builder.setMacrosDisabled(newBoolean(ctx, valueNode));
+ break;
+ case "include_macros":
+ builder.setIncludedMacros(parseMacroNameSet(ctx, valueNode));
+ break;
+ case "exclude_macros":
+ builder.setExcludedMacros(parseMacroNameSet(ctx, valueNode));
+ break;
+ case "include_functions":
+ builder.setIncludedFunctions(parseFunctionSelectors(ctx, valueNode));
+ break;
+ case "exclude_functions":
+ builder.setExcludedFunctions(parseFunctionSelectors(ctx, valueNode));
+ break;
+ default:
+ ctx.reportError(keyId, String.format("Unsupported library subset tag: %s", keyName));
+ break;
+ }
+ }
+ return builder.build();
+ }
+
+ private static ImmutableSet parseMacroNameSet(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 static ImmutableSet parseFunctionSelectors(
+ ParserContext ctx, Node node) {
+ long valueId = ctx.collectMetadata(node);
+ ImmutableSet.Builder functionSetBuilder = ImmutableSet.builder();
+ if (!assertYamlType(ctx, valueId, node, YamlNodeType.LIST)) {
+ return functionSetBuilder.build();
+ }
+
+ SequenceNode functionListNode = (SequenceNode) node;
+ for (Node elementNode : functionListNode.getValue()) {
+ functionSetBuilder.add(parseFunctionSelector(ctx, elementNode));
+ }
+
+ return functionSetBuilder.build();
+ }
+
+ private static FunctionSelector parseFunctionSelector(ParserContext ctx, Node node) {
+ FunctionSelector.Builder builder = FunctionSelector.newBuilder();
+ long functionId = ctx.collectMetadata(node);
+ if (!assertYamlType(ctx, functionId, node, YamlNodeType.MAP)) {
+ return ERROR_FUNCTION_SELECTOR;
+ }
+
+ MappingNode functionMap = (MappingNode) node;
+ for (NodeTuple nodeTuple : functionMap.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 "overloads":
+ builder.setOverloads(parseFunctionOverloadsSelector(ctx, valueNode));
+ break;
+ default:
+ ctx.reportError(keyId, String.format("Unsupported function selector tag: %s", keyName));
+ break;
+ }
+ }
+
+ if (!assertRequiredFields(ctx, functionId, builder.getMissingRequiredFieldNames())) {
+ return ERROR_FUNCTION_SELECTOR;
+ }
+
+ return builder.build();
+ }
+
+ private static ImmutableSet parseFunctionOverloadsSelector(
+ ParserContext ctx, Node node) {
+ long listId = ctx.collectMetadata(node);
+ ImmutableSet.Builder overloadSetBuilder = ImmutableSet.builder();
+ if (!assertYamlType(ctx, listId, node, YamlNodeType.LIST)) {
+ return overloadSetBuilder.build();
+ }
+
+ SequenceNode overloadListNode = (SequenceNode) node;
+ for (Node overloadMapNode : overloadListNode.getValue()) {
+ long overloadMapId = ctx.collectMetadata(overloadMapNode);
+ if (!assertYamlType(ctx, overloadMapId, overloadMapNode, YamlNodeType.MAP)) {
+ continue;
+ }
+
+ MappingNode mapNode = (MappingNode) overloadMapNode;
+ OverloadSelector.Builder overloadDeclBuilder = OverloadSelector.newBuilder();
+ for (NodeTuple nodeTuple : mapNode.getValue()) {
+ Node keyNode = nodeTuple.getKeyNode();
+ long keyId = ctx.collectMetadata(keyNode);
+ if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) {
+ continue;
+ }
+
+ Node valueNode = nodeTuple.getValueNode();
+ String fieldName = ((ScalarNode) keyNode).getValue();
+ switch (fieldName) {
+ case "id":
+ overloadDeclBuilder.setId(newString(ctx, valueNode));
+ break;
+ default:
+ ctx.reportError(
+ keyId, String.format("Unsupported overload selector tag: %s", fieldName));
+ break;
+ }
+ }
+
+ if (assertRequiredFields(
+ ctx, overloadMapId, overloadDeclBuilder.getMissingRequiredFieldNames())) {
+ overloadSetBuilder.add(overloadDeclBuilder.build());
+ }
+ }
+
+ return overloadSetBuilder.build();
+ }
+
+ private static @Nullable Integer tryParse(String str) {
+ try {
+ return Integer.parseInt(str);
+ } catch (NumberFormatException e) {
+ return null;
+ }
+ }
+
+ @CanIgnoreReturnValue
+ private static TypeDecl.Builder parseInlinedTypeDecl(
+ ParserContext ctx, long keyId, Node keyNode, Node valueNode, TypeDecl.Builder builder) {
+ if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) {
+ return builder;
+ }
+
+ // Create a synthetic node to make this behave as if a `type: ` parent node actually exists.
+ MappingNode mapNode =
+ new MappingNode(
+ Tag.MAP, /* value= */ singletonList(new NodeTuple(keyNode, valueNode)), FlowStyle.AUTO);
+
+ return parseTypeDeclFields(ctx, mapNode, builder);
+ }
+
+ private static TypeDecl parseTypeDecl(ParserContext ctx, Node node) {
+ TypeDecl.Builder builder = TypeDecl.newBuilder();
+ long id = ctx.collectMetadata(node);
+ if (!assertYamlType(ctx, id, node, YamlNodeType.MAP)) {
+ return ERROR_TYPE_DECL;
+ }
+
+ MappingNode mapNode = (MappingNode) node;
+ return parseTypeDeclFields(ctx, mapNode, builder).build();
+ }
+
+ @CanIgnoreReturnValue
+ private static TypeDecl.Builder parseTypeDeclFields(
+ ParserContext ctx, MappingNode mapNode, TypeDecl.Builder builder) {
+ for (NodeTuple nodeTuple : mapNode.getValue()) {
+ Node keyNode = nodeTuple.getKeyNode();
+ long keyId = ctx.collectMetadata(keyNode);
+ if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) {
+ continue;
+ }
+
+ Node valueNode = nodeTuple.getValueNode();
+ String fieldName = ((ScalarNode) keyNode).getValue();
+ switch (fieldName) {
+ case "type_name":
+ builder.setName(newString(ctx, valueNode));
+ break;
+ case "is_type_param":
+ builder.setIsTypeParam(newBoolean(ctx, valueNode));
+ break;
+ case "params":
+ long listValueId = ctx.collectMetadata(valueNode);
+ if (!assertYamlType(ctx, listValueId, valueNode, YamlNodeType.LIST)) {
+ break;
+ }
+ SequenceNode paramsListNode = (SequenceNode) valueNode;
+ for (Node elementNode : paramsListNode.getValue()) {
+ builder.addParams(parseTypeDecl(ctx, elementNode));
+ }
+ break;
+ default:
+ ctx.reportError(keyId, String.format("Unsupported type decl tag: %s", fieldName));
+ break;
+ }
+ }
+ return builder;
+ }
+
+ private class ParserImpl {
+
+ private CelEnvironment parseYaml(String source, String description)
+ throws CelEnvironmentException {
+ Node node;
+ try {
+ node =
+ parseYamlSource(source)
+ .orElseThrow(
+ () ->
+ new CelEnvironmentException(
+ String.format("YAML document empty or malformed: %s", source)));
+ } catch (RuntimeException e) {
+ throw new CelEnvironmentException("YAML document is malformed: " + e.getMessage(), e);
+ }
+
+ CelFileSource environmentSource =
+ CelFileSource.newBuilder(CelCodePointArray.fromString(source))
+ .setDescription(description)
+ .build();
+ ParserContext ctx = YamlParserContextImpl.newInstance(environmentSource);
+ CelEnvironment.Builder builder = parseConfig(ctx, node);
+ environmentSource =
+ environmentSource.toBuilder().setPositionsMap(ctx.getIdToOffsetMap()).build();
+
+ if (!ctx.getIssues().isEmpty()) {
+ throw new CelEnvironmentException(
+ CelIssue.toDisplayString(ctx.getIssues(), environmentSource));
+ }
+
+ return builder.setSource(environmentSource).build();
+ }
+
+ private CelEnvironment.Builder parseConfig(ParserContext ctx, Node node) {
+ CelEnvironment.Builder builder = CelEnvironment.newBuilder();
+ long id = ctx.collectMetadata(node);
+ if (!assertYamlType(ctx, id, node, YamlNodeType.MAP)) {
+ return builder;
+ }
+
+ MappingNode rootNode = (MappingNode) node;
+ for (NodeTuple nodeTuple : rootNode.getValue()) {
+ Node keyNode = nodeTuple.getKeyNode();
+ long keyId = ctx.collectMetadata(keyNode);
+ if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) {
+ continue;
+ }
+
+ Node valueNode = nodeTuple.getValueNode();
+ String fieldName = ((ScalarNode) keyNode).getValue();
+ switch (fieldName) {
+ case "name":
+ builder.setName(newString(ctx, valueNode));
+ break;
+ case "description":
+ builder.setDescription(newString(ctx, valueNode));
+ break;
+ case "container":
+ builder.setContainer(parseContainer(ctx, valueNode));
+ break;
+ case "variables":
+ builder.setVariables(parseVariables(ctx, valueNode));
+ break;
+ case "functions":
+ builder.setFunctions(parseFunctions(ctx, valueNode));
+ break;
+ case "extensions":
+ builder.addExtensions(parseExtensions(ctx, valueNode));
+ break;
+ case "stdlib":
+ builder.setStandardLibrarySubset(parseLibrarySubset(ctx, valueNode));
+ break;
+ case "features":
+ builder.setFeatures(parseFeatures(ctx, valueNode));
+ break;
+ case "limits":
+ builder.setLimits(parseLimits(ctx, valueNode));
+ break;
+ case "context_variable":
+ builder.setContextVariable(parseContextVariable(ctx, valueNode));
+ break;
+ default:
+ ctx.reportError(id, "Unknown config tag: " + fieldName);
+ // continue handling the rest of the nodes
+ }
+ }
+
+ return builder;
+ }
+ }
+
+ private CelEnvironmentYamlParser() {}
+}
diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlSerializer.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlSerializer.java
new file mode 100644
index 000000000..9d5b4b69e
--- /dev/null
+++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironmentYamlSerializer.java
@@ -0,0 +1,293 @@
+// 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.bundle;
+
+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;
+import org.yaml.snakeyaml.representer.Represent;
+import org.yaml.snakeyaml.representer.Representer;
+
+/** Serializes a CelEnvironment into a YAML file. */
+public final class CelEnvironmentYamlSerializer extends Representer {
+
+ private static DumperOptions initDumperOptions() {
+ DumperOptions options = new DumperOptions();
+ options.setIndent(2);
+ options.setPrettyFlow(true);
+ options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+ return options;
+ }
+
+ private static final DumperOptions YAML_OPTIONS = initDumperOptions();
+
+ private static final CelEnvironmentYamlSerializer INSTANCE = new CelEnvironmentYamlSerializer();
+
+ private CelEnvironmentYamlSerializer() {
+ super(YAML_OPTIONS);
+ this.multiRepresenters.put(CelEnvironment.class, new RepresentCelEnvironment());
+ this.multiRepresenters.put(CelEnvironment.VariableDecl.class, new RepresentVariableDecl());
+ this.multiRepresenters.put(CelEnvironment.FunctionDecl.class, new RepresentFunctionDecl());
+ this.multiRepresenters.put(CelEnvironment.OverloadDecl.class, new RepresentOverloadDecl());
+ this.multiRepresenters.put(CelEnvironment.TypeDecl.class, new RepresentTypeDecl());
+ this.multiRepresenters.put(
+ CelEnvironment.ExtensionConfig.class, new RepresentExtensionConfig());
+ this.multiRepresenters.put(CelEnvironment.LibrarySubset.class, new RepresentLibrarySubset());
+ this.multiRepresenters.put(
+ 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) {
+ // Yaml is not thread-safe, so we create a new instance for each serialization.
+ Yaml yaml = new Yaml(INSTANCE, YAML_OPTIONS);
+ return yaml.dump(environment);
+ }
+
+ private final class RepresentCelEnvironment implements Represent {
+ @Override
+ public Node representData(Object data) {
+ CelEnvironment environment = (CelEnvironment) data;
+ ImmutableMap.Builder configMap = new ImmutableMap.Builder<>();
+ configMap.put("name", environment.name());
+ if (!environment.description().isEmpty()) {
+ configMap.put("description", environment.description());
+ }
+ if (environment.container().isPresent()) {
+ configMap.put("container", environment.container().get());
+ }
+ if (!environment.extensions().isEmpty()) {
+ configMap.put("extensions", environment.extensions().asList());
+ }
+ if (!environment.variables().isEmpty()) {
+ configMap.put("variables", environment.variables().asList());
+ }
+ if (!environment.functions().isEmpty()) {
+ configMap.put("functions", environment.functions().asList());
+ }
+ 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) {
+ CelEnvironment.ExtensionConfig extension = (CelEnvironment.ExtensionConfig) data;
+ ImmutableMap.Builder configMap = new ImmutableMap.Builder<>();
+ configMap.put("name", extension.name());
+ if (extension.version() > 0 && extension.version() != Integer.MAX_VALUE) {
+ configMap.put("version", extension.version());
+ }
+ return represent(configMap.buildOrThrow());
+ }
+ }
+
+ private final class RepresentVariableDecl implements Represent {
+ @Override
+ public Node representData(Object data) {
+ CelEnvironment.VariableDecl variable = (CelEnvironment.VariableDecl) data;
+ ImmutableMap.Builder configMap = new ImmutableMap.Builder<>();
+ configMap.put("name", variable.name()).put("type_name", variable.type().name());
+ if (!variable.type().params().isEmpty()) {
+ configMap.put("params", variable.type().params());
+ }
+ return represent(configMap.buildOrThrow());
+ }
+ }
+
+ private final class RepresentFunctionDecl implements Represent {
+ @Override
+ public Node representData(Object data) {
+ CelEnvironment.FunctionDecl function = (CelEnvironment.FunctionDecl) data;
+ ImmutableMap.Builder configMap = new ImmutableMap.Builder<>();
+ configMap.put("name", function.name()).put("overloads", function.overloads().asList());
+ return represent(configMap.buildOrThrow());
+ }
+ }
+
+ private final class RepresentOverloadDecl implements Represent {
+ @Override
+ public Node representData(Object data) {
+ CelEnvironment.OverloadDecl overload = (CelEnvironment.OverloadDecl) data;
+ ImmutableMap.Builder configMap = new ImmutableMap.Builder<>();
+ configMap.put("id", overload.id());
+ if (overload.target().isPresent()) {
+ configMap.put("target", overload.target().get());
+ }
+ configMap.put("args", overload.arguments()).put("return", overload.returnType());
+ return represent(configMap.buildOrThrow());
+ }
+ }
+
+ private final class RepresentTypeDecl implements Represent {
+ @Override
+ public Node representData(Object data) {
+ CelEnvironment.TypeDecl type = (CelEnvironment.TypeDecl) data;
+ ImmutableMap.Builder configMap = new ImmutableMap.Builder<>();
+ configMap.put("type_name", type.name());
+ if (!type.params().isEmpty()) {
+ configMap.put("params", type.params());
+ }
+ if (type.isTypeParam()) {
+ configMap.put("is_type_param", type.isTypeParam());
+ }
+ return represent(configMap.buildOrThrow());
+ }
+ }
+
+ private final class RepresentLibrarySubset implements Represent {
+ @Override
+ public Node representData(Object data) {
+ LibrarySubset librarySubset = (LibrarySubset) data;
+ ImmutableMap.Builder configMap = new ImmutableMap.Builder<>();
+ if (librarySubset.disabled()) {
+ configMap.put("disabled", true);
+ }
+ if (librarySubset.macrosDisabled()) {
+ configMap.put("disable_macros", true);
+ }
+ if (!librarySubset.includedMacros().isEmpty()) {
+ configMap.put("include_macros", ImmutableList.sortedCopyOf(librarySubset.includedMacros()));
+ }
+ if (!librarySubset.excludedMacros().isEmpty()) {
+ configMap.put("exclude_macros", ImmutableList.sortedCopyOf(librarySubset.excludedMacros()));
+ }
+ if (!librarySubset.includedFunctions().isEmpty()) {
+ configMap.put(
+ "include_functions",
+ ImmutableList.sortedCopyOf(
+ Comparator.comparing(FunctionSelector::name), librarySubset.includedFunctions()));
+ }
+ if (!librarySubset.excludedFunctions().isEmpty()) {
+ configMap.put(
+ "exclude_functions",
+ ImmutableList.sortedCopyOf(
+ Comparator.comparing(FunctionSelector::name), librarySubset.excludedFunctions()));
+ }
+ return represent(configMap.buildOrThrow());
+ }
+ }
+
+ private final class RepresentFunctionSelector implements Represent {
+ @Override
+ public Node representData(Object data) {
+ FunctionSelector functionSelector = (FunctionSelector) data;
+ ImmutableMap.Builder configMap = new ImmutableMap.Builder<>();
+ configMap.put("name", functionSelector.name());
+ if (!functionSelector.overloads().isEmpty()) {
+ configMap.put(
+ "overloads",
+ ImmutableList.sortedCopyOf(
+ Comparator.comparing(OverloadSelector::id), functionSelector.overloads()));
+ }
+
+ return represent(configMap.buildOrThrow());
+ }
+ }
+
+ private final class RepresentOverloadSelector implements Represent {
+ @Override
+ public Node representData(Object data) {
+ OverloadSelector overloadSelector = (OverloadSelector) 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/CelFactory.java b/bundle/src/main/java/dev/cel/bundle/CelFactory.java
index a2080bc25..ac589cfe6 100644
--- a/bundle/src/main/java/dev/cel/bundle/CelFactory.java
+++ b/bundle/src/main/java/dev/cel/bundle/CelFactory.java
@@ -20,6 +20,7 @@
import dev.cel.compiler.CelCompilerImpl;
import dev.cel.parser.CelParserImpl;
import dev.cel.runtime.CelRuntime;
+import dev.cel.runtime.CelRuntimeImpl;
import dev.cel.runtime.CelRuntimeLegacyImpl;
/** Helper class to configure the entire CEL stack in a common interface. */
@@ -40,9 +41,34 @@ public static CelBuilder standardCelBuilder() {
CelParserImpl.newBuilder(), CelCheckerLegacyImpl.newBuilder()),
CelRuntimeLegacyImpl.newBuilder())
.setOptions(CelOptions.current().build())
+ // CEL-Internal-2
.setStandardEnvironmentEnabled(true);
}
+ /**
+ * 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 {@link
+ * #standardCelBuilder()}:
+ *
+ *
+ * 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).build());
+ }
+
/** Combines a prebuilt {@link CelCompiler} and {@link CelRuntime} into {@link Cel}. */
public static Cel combine(CelCompiler celCompiler, CelRuntime celRuntime) {
return CelImpl.combine(celCompiler, celRuntime);
diff --git a/bundle/src/main/java/dev/cel/bundle/CelImpl.java b/bundle/src/main/java/dev/cel/bundle/CelImpl.java
index ad062d113..f0db128c1 100644
--- a/bundle/src/main/java/dev/cel/bundle/CelImpl.java
+++ b/bundle/src/main/java/dev/cel/bundle/CelImpl.java
@@ -28,9 +28,11 @@
import com.google.protobuf.ExtensionRegistry;
import com.google.protobuf.Message;
import dev.cel.checker.CelCheckerBuilder;
+import dev.cel.checker.CelStandardDeclarations;
import dev.cel.checker.ProtoTypeMask;
import dev.cel.checker.TypeProvider;
import dev.cel.common.CelAbstractSyntaxTree;
+import dev.cel.common.CelContainer;
import dev.cel.common.CelFunctionDecl;
import dev.cel.common.CelOptions;
import dev.cel.common.CelSource;
@@ -39,9 +41,9 @@
import dev.cel.common.internal.EnvVisitable;
import dev.cel.common.internal.EnvVisitor;
import dev.cel.common.internal.FileDescriptorSetConverter;
+import dev.cel.common.types.CelProtoTypes;
import dev.cel.common.types.CelType;
import dev.cel.common.types.CelTypeProvider;
-import dev.cel.common.types.CelTypes;
import dev.cel.common.values.CelValueProvider;
import dev.cel.compiler.CelCompiler;
import dev.cel.compiler.CelCompilerBuilder;
@@ -52,7 +54,9 @@
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;
import java.util.function.Function;
@@ -87,6 +91,11 @@ public CelValidationResult check(CelAbstractSyntaxTree ast) {
return compiler.get().check(ast);
}
+ @Override
+ public CelTypeProvider getTypeProvider() {
+ return compiler.get().getTypeProvider();
+ }
+
@Override
public CelRuntime.Program createProgram(CelAbstractSyntaxTree ast) throws CelEvaluationException {
return runtime.get().createProgram(ast);
@@ -134,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) {
@@ -184,8 +195,17 @@ public CelBuilder addMacros(Iterable macros) {
}
@Override
- public CelBuilder setContainer(String container) {
+ public CelContainer container() {
+ return compilerBuilder.container();
+ }
+
+ @Override
+ public CelBuilder setContainer(CelContainer container) {
compilerBuilder.setContainer(container);
+ if (runtimeBuilder instanceof CelRuntimeImpl.Builder) {
+ runtimeBuilder.setContainer(container);
+ }
+
return this;
}
@@ -250,21 +270,33 @@ public CelBuilder addProtoTypeMasks(Iterable typeMasks) {
}
@Override
- public CelBuilder addFunctionBindings(CelRuntime.CelFunctionBinding... bindings) {
+ public CelBuilder addFunctionBindings(dev.cel.runtime.CelFunctionBinding... bindings) {
runtimeBuilder.addFunctionBindings(bindings);
return this;
}
@Override
- public CelBuilder addFunctionBindings(Iterable bindings) {
+ public CelBuilder addFunctionBindings(Iterable bindings) {
runtimeBuilder.addFunctionBindings(bindings);
return this;
}
+ @Override
+ public CelBuilder addLateBoundFunctions(String... lateBoundFunctionNames) {
+ runtimeBuilder.addLateBoundFunctions(lateBoundFunctionNames);
+ return this;
+ }
+
+ @Override
+ public CelBuilder addLateBoundFunctions(Iterable lateBoundFunctionNames) {
+ runtimeBuilder.addLateBoundFunctions(lateBoundFunctionNames);
+ return this;
+ }
+
@Override
public CelBuilder setResultType(CelType resultType) {
checkNotNull(resultType);
- return setProtoResultType(CelTypes.celTypeToType(resultType));
+ return setProtoResultType(CelProtoTypes.celTypeToType(resultType));
}
@Override
@@ -295,6 +327,9 @@ public Builder setTypeProvider(TypeProvider typeProvider) {
@Override
public CelBuilder setTypeProvider(CelTypeProvider celTypeProvider) {
compilerBuilder.setTypeProvider(celTypeProvider);
+ if (runtimeBuilder instanceof CelRuntimeImpl.Builder) {
+ runtimeBuilder.setTypeProvider(celTypeProvider);
+ }
return this;
}
@@ -371,6 +406,20 @@ public CelBuilder addRuntimeLibraries(Iterable libraries) {
return this;
}
+ @Override
+ public CelBuilder setStandardDeclarations(CelStandardDeclarations standardDeclarations) {
+ checkNotNull(standardDeclarations);
+ compilerBuilder.setStandardDeclarations(standardDeclarations);
+ return this;
+ }
+
+ @Override
+ public CelBuilder setStandardFunctions(CelStandardFunctions standardFunctions) {
+ checkNotNull(standardFunctions);
+ runtimeBuilder.setStandardFunctions(standardFunctions);
+ return this;
+ }
+
@Override
public CelBuilder setExtensionRegistry(ExtensionRegistry extensionRegistry) {
checkNotNull(extensionRegistry);
diff --git a/bundle/src/main/java/dev/cel/bundle/RequiredFieldsChecker.java b/bundle/src/main/java/dev/cel/bundle/RequiredFieldsChecker.java
new file mode 100644
index 000000000..88bef2db5
--- /dev/null
+++ b/bundle/src/main/java/dev/cel/bundle/RequiredFieldsChecker.java
@@ -0,0 +1,49 @@
+// Copyright 2024 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 static com.google.common.collect.ImmutableList.toImmutableList;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+import java.util.Optional;
+import java.util.function.Supplier;
+
+/**
+ * Interface to be implemented on a builder that can be used to verify all required fields being
+ * set.
+ */
+interface RequiredFieldsChecker {
+
+ ImmutableList requiredFields();
+
+ default ImmutableList getMissingRequiredFieldNames() {
+ return requiredFields().stream()
+ .filter(entry -> !entry.fieldValue().get().isPresent())
+ .map(RequiredField::displayName)
+ .collect(toImmutableList());
+ }
+
+ @AutoValue
+ abstract class RequiredField {
+ abstract String displayName();
+
+ abstract Supplier> fieldValue();
+
+ static RequiredField of(String displayName, Supplier> fieldValue) {
+ return new AutoValue_RequiredFieldsChecker_RequiredField(displayName, fieldValue);
+ }
+ }
+}
diff --git a/bundle/src/test/java/dev/cel/bundle/BUILD.bazel b/bundle/src/test/java/dev/cel/bundle/BUILD.bazel
index cccfc8eed..548b4483d 100644
--- a/bundle/src/test/java/dev/cel/bundle/BUILD.bazel
+++ b/bundle/src/test/java/dev/cel/bundle/BUILD.bazel
@@ -1,47 +1,73 @@
+load("@rules_java//java:defs.bzl", "java_library")
load("//:testing.bzl", "junit4_test_suites")
-package(default_applicable_licenses = [
- "//:license",
-])
+package(
+ default_applicable_licenses = [
+ "//:license",
+ ],
+)
java_library(
name = "tests",
testonly = True,
srcs = glob(["*Test.java"]),
+ resources = [
+ "//testing/environment:dump_env",
+ "//testing/environment:extended_env",
+ "//testing/environment:library_subset_env",
+ ],
deps = [
- "//:auto_value",
"//:java_truth",
"//bundle:cel",
+ "//bundle:cel_impl",
+ "//bundle:environment",
+ "//bundle:environment_exception",
+ "//bundle:environment_exporter",
+ "//bundle:environment_yaml_parser",
"//checker",
"//checker:checker_legacy_environment",
"//checker:proto_type_mask",
- "//common",
+ "//common:cel_ast",
+ "//common:cel_descriptor_util",
+ "//common:cel_source",
"//common:compiler_common",
+ "//common:container",
+ "//common:error_codes",
"//common:options",
"//common:proto_ast",
+ "//common:source_location",
"//common/ast",
- "//common/resources/testdata/proto2:messages_extensions_proto2_java_proto",
- "//common/resources/testdata/proto2:messages_proto2_java_proto",
- "//common/resources/testdata/proto2:test_all_types_java_proto",
"//common/resources/testdata/proto3:standalone_global_enum_java_proto",
- "//common/resources/testdata/proto3:test_all_types_java_proto",
"//common/testing",
"//common/types",
- "//common/types:cel_types",
+ "//common/types:cel_proto_message_types",
+ "//common/types:cel_proto_types",
"//common/types:message_type_provider",
"//common/types:type_providers",
+ "//common/values",
+ "//common/values:cel_byte_string",
"//compiler",
"//compiler:compiler_builder",
+ "//extensions",
"//parser",
"//parser:macro",
+ "//parser:unparser",
"//runtime",
+ "//runtime:evaluation_exception_builder",
+ "//runtime:evaluation_listener",
+ "//runtime:function_binding",
"//runtime:unknown_attributes",
- "@cel_spec//proto/cel/expr:expr_java_proto",
- "@maven//:com_google_api_grpc_proto_google_common_protos",
+ "//testing:cel_runtime_flavor",
+ "//testing/protos:single_file_extension_java_proto",
+ "//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",
+ "@cel_spec//proto/cel/expr/conformance/proto3:test_all_types_java_proto",
+ "@com_google_googleapis//google/rpc/context:attribute_context_java_proto",
+ "@com_google_googleapis//google/type:type_java_proto",
"@maven//:com_google_guava_guava",
- "@maven//:com_google_guava_guava_testlib",
"@maven//:com_google_protobuf_protobuf_java",
- "@maven//:com_google_protobuf_protobuf_java_util",
"@maven//:com_google_testparameterinjector_test_parameter_injector",
"@maven//:com_google_truth_extensions_truth_proto_extension",
"@maven//:junit_junit",
diff --git a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentExporterTest.java b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentExporterTest.java
new file mode 100644
index 000000000..ae0de2c18
--- /dev/null
+++ b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentExporterTest.java
@@ -0,0 +1,370 @@
+// 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.bundle;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static java.util.stream.Collectors.toCollection;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.io.Resources;
+import com.google.testing.junit.testparameterinjector.TestParameterInjector;
+import dev.cel.bundle.CelEnvironment.ExtensionConfig;
+import dev.cel.bundle.CelEnvironment.FunctionDecl;
+import dev.cel.bundle.CelEnvironment.LibrarySubset;
+import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector;
+import dev.cel.bundle.CelEnvironment.LibrarySubset.OverloadSelector;
+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;
+import dev.cel.common.CelVarDecl;
+import dev.cel.common.types.ListType;
+import dev.cel.common.types.OpaqueType;
+import dev.cel.common.types.SimpleType;
+import dev.cel.common.types.TypeParamType;
+import dev.cel.extensions.CelExtensions;
+import java.net.URL;
+import java.util.HashSet;
+import java.util.Set;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(TestParameterInjector.class)
+public class CelEnvironmentExporterTest {
+
+ public static final CelOptions CEL_OPTIONS =
+ CelOptions.newBuilder().enableHeterogeneousNumericComparisons(true).build();
+
+ @Test
+ public void extensions_latest() {
+ Cel cel =
+ CelFactory.standardCelBuilder()
+ .addCompilerLibraries(CelExtensions.math(CEL_OPTIONS, 2))
+ .build();
+
+ CelEnvironment celEnvironment =
+ CelEnvironmentExporter.newBuilder().addStandardExtensions(CEL_OPTIONS).build().export(cel);
+
+ assertThat(celEnvironment.extensions())
+ .containsExactly(ExtensionConfig.newBuilder().setName("math").setVersion(2).build());
+ }
+
+ @Test
+ public void extensions_earlierVersion() {
+ Cel cel =
+ CelFactory.standardCelBuilder()
+ .addCompilerLibraries(CelExtensions.math(CEL_OPTIONS, 1))
+ .build();
+
+ CelEnvironment celEnvironment =
+ CelEnvironmentExporter.newBuilder().addStandardExtensions(CEL_OPTIONS).build().export(cel);
+
+ assertThat(celEnvironment.extensions())
+ .containsExactly(ExtensionConfig.newBuilder().setName("math").setVersion(1).build());
+ }
+
+ @Test
+ public void standardLibrarySubset_favorExclusion() throws Exception {
+ URL url = Resources.getResource("environment/subset_env.yaml");
+ String yamlFileContent = Resources.toString(url, UTF_8);
+ CelEnvironment environment = CelEnvironmentYamlParser.newInstance().parse(yamlFileContent);
+
+ Cel standardCel =
+ CelFactory.standardCelBuilder()
+ .addCompilerLibraries(CelExtensions.math(CEL_OPTIONS, 2))
+ .build();
+ Cel extendedCel = environment.extend(standardCel, CEL_OPTIONS);
+
+ CelEnvironment celEnvironment =
+ CelEnvironmentExporter.newBuilder()
+ .setMaxExcludedStandardFunctions(100)
+ .setMaxExcludedStandardFunctionOverloads(100)
+ .build()
+ .export(extendedCel);
+
+ assertThat(celEnvironment.standardLibrarySubset())
+ .hasValue(
+ LibrarySubset.newBuilder()
+ .setDisabled(false)
+ .setExcludedFunctions(
+ ImmutableSet.of(
+ FunctionSelector.create(
+ "_+_", ImmutableSet.of("add_bytes", "add_list", "add_string")),
+ FunctionSelector.create("duration", ImmutableSet.of("string_to_duration")),
+ FunctionSelector.create("matches", ImmutableSet.of()),
+ FunctionSelector.create(
+ "timestamp", ImmutableSet.of("string_to_timestamp"))))
+ .setExcludedMacros(ImmutableSet.of("map", "existsOne", "filter"))
+ .build());
+ }
+
+ @Test
+ public void standardLibrarySubset_favorInclusion() throws Exception {
+ URL url = Resources.getResource("environment/subset_env.yaml");
+ String yamlFileContent = Resources.toString(url, UTF_8);
+ CelEnvironment environment = CelEnvironmentYamlParser.newInstance().parse(yamlFileContent);
+
+ Cel standardCel =
+ CelFactory.standardCelBuilder()
+ .addCompilerLibraries(CelExtensions.math(CEL_OPTIONS, 2))
+ .build();
+ Cel extendedCel = environment.extend(standardCel, CEL_OPTIONS);
+
+ CelEnvironment celEnvironment =
+ CelEnvironmentExporter.newBuilder()
+ .setMaxExcludedStandardFunctions(0)
+ .setMaxExcludedStandardFunctionOverloads(0)
+ .build()
+ .export(extendedCel);
+
+ LibrarySubset actual = celEnvironment.standardLibrarySubset().get();
+
+ // "matches" is fully excluded
+ assertThat(actual.includedFunctions().stream().map(FunctionSelector::name))
+ .doesNotContain("matches");
+
+ // A subset of overloads is included. Note the absence of string_to_timestamp
+ assertThat(actual.includedFunctions())
+ .contains(
+ FunctionSelector.create(
+ "timestamp", ImmutableSet.of("int64_to_timestamp", "timestamp_to_timestamp")));
+
+ Set additionOverloads =
+ actual.includedFunctions().stream()
+ .filter(fs -> fs.name().equals("_+_"))
+ .flatMap(fs -> fs.overloads().stream())
+ .map(OverloadSelector::id)
+ .collect(toCollection(HashSet::new));
+ assertThat(additionOverloads).containsNoneOf("add_bytes", "add_list", "add_string");
+
+ assertThat(actual.includedMacros()).containsNoneOf("map", "filter");
+
+ // Random-check a few standard overloads
+ assertThat(additionOverloads).containsAtLeast("add_int64", "add_uint64", "add_double");
+
+ // Random-check a couple of standard functions
+ assertThat(actual.includedFunctions())
+ .contains(FunctionSelector.create("-_", ImmutableSet.of()));
+ assertThat(actual.includedFunctions())
+ .contains(FunctionSelector.create("getDayOfYear", ImmutableSet.of()));
+ assertThat(actual.includedMacros()).containsAtLeast("all", "exists", "exists_one", "has");
+ }
+
+ @Test
+ public void customFunctions() {
+ Cel cel =
+ CelFactory.standardCelBuilder()
+ .addCompilerLibraries(CelExtensions.math(CEL_OPTIONS, 1))
+ .addFunctionDeclarations(
+ CelFunctionDecl.newFunctionDeclaration(
+ "math.isFinite",
+ CelOverloadDecl.newGlobalOverload(
+ "math_isFinite_int64", SimpleType.BOOL, SimpleType.INT)),
+ CelFunctionDecl.newFunctionDeclaration(
+ "zipGeneric",
+ CelOverloadDecl.newGlobalOverload(
+ "zip_list_list",
+ ListType.create(ListType.create(TypeParamType.create("T"))),
+ ListType.create(TypeParamType.create("T")),
+ ListType.create(TypeParamType.create("T")))),
+ CelFunctionDecl.newFunctionDeclaration(
+ "zip",
+ CelOverloadDecl.newGlobalOverload(
+ "zip_list_int_list_int",
+ ListType.create(ListType.create(SimpleType.INT)),
+ ListType.create(SimpleType.INT),
+ ListType.create(SimpleType.INT))),
+ CelFunctionDecl.newFunctionDeclaration(
+ "addWeeks",
+ CelOverloadDecl.newMemberOverload(
+ "timestamp_addWeeks",
+ SimpleType.BOOL,
+ SimpleType.TIMESTAMP,
+ SimpleType.INT)))
+ .build();
+
+ CelEnvironmentExporter exporter =
+ CelEnvironmentExporter.newBuilder().addStandardExtensions(CEL_OPTIONS).build();
+ CelEnvironment celEnvironment = exporter.export(cel);
+
+ assertThat(celEnvironment.functions())
+ .containsAtLeast(
+ FunctionDecl.create(
+ "math.isFinite",
+ ImmutableSet.of(
+ OverloadDecl.newBuilder()
+ .setId("math_isFinite_int64")
+ .setArguments(ImmutableList.of(TypeDecl.create("int")))
+ .setReturnType(TypeDecl.create("bool"))
+ .build())),
+ FunctionDecl.create(
+ "addWeeks",
+ ImmutableSet.of(
+ OverloadDecl.newBuilder()
+ .setId("timestamp_addWeeks")
+ .setTarget(TypeDecl.create("google.protobuf.Timestamp"))
+ .setArguments(ImmutableList.of(TypeDecl.create("int")))
+ .setReturnType(TypeDecl.create("bool"))
+ .build())),
+ FunctionDecl.create(
+ "zipGeneric",
+ ImmutableSet.of(
+ OverloadDecl.newBuilder()
+ .setId("zip_list_list")
+ .setArguments(
+ ImmutableList.of(
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(
+ TypeDecl.newBuilder()
+ .setName("T")
+ .setIsTypeParam(true)
+ .build())
+ .build(),
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(
+ TypeDecl.newBuilder()
+ .setName("T")
+ .setIsTypeParam(true)
+ .build())
+ .build()))
+ .setReturnType(
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(
+ TypeDecl.newBuilder()
+ .setName("T")
+ .setIsTypeParam(true)
+ .build())
+ .build())
+ .build())
+ .build())),
+ FunctionDecl.create(
+ "zip",
+ ImmutableSet.of(
+ OverloadDecl.newBuilder()
+ .setId("zip_list_int_list_int")
+ .setArguments(
+ ImmutableList.of(
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(TypeDecl.create("int"))
+ .build(),
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(TypeDecl.create("int"))
+ .build()))
+ .setReturnType(
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(TypeDecl.create("int"))
+ .build())
+ .build())
+ .build())));
+
+ // Random-check some standard functions: we don't want to see them explicitly defined.
+ assertThat(
+ celEnvironment.functions().stream().map(FunctionDecl::name).collect(toImmutableList()))
+ .containsNoneOf("_+_", "math.abs", "_in_", "__not_strictly_false__");
+ }
+
+ @Test
+ public void customVariables() {
+ Cel cel =
+ CelFactory.standardCelBuilder()
+ .addVarDeclarations(
+ CelVarDecl.newVarDeclaration("x", SimpleType.INT),
+ CelVarDecl.newVarDeclaration("y", OpaqueType.create("foo.Bar")))
+ .build();
+
+ CelEnvironmentExporter exporter =
+ CelEnvironmentExporter.newBuilder().addStandardExtensions(CEL_OPTIONS).build();
+ CelEnvironment celEnvironment = exporter.export(cel);
+
+ assertThat(celEnvironment.variables())
+ .containsAtLeast(
+ VariableDecl.create("x", TypeDecl.create("int")),
+ VariableDecl.create("y", TypeDecl.create("foo.Bar")));
+
+ // Random-check some standard variables: we don't want to see them explicitly included in
+ // the CelEnvironment.
+ assertThat(
+ 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().get();
+ 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
new file mode 100644
index 000000000..a5a2f3e6d
--- /dev/null
+++ b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentTest.java
@@ -0,0 +1,467 @@
+// 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.bundle;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.testing.junit.testparameterinjector.TestParameterInjector;
+import dev.cel.bundle.CelEnvironment.CanonicalCelExtension;
+import dev.cel.bundle.CelEnvironment.ExtensionConfig;
+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;
+import dev.cel.common.types.CelType;
+import dev.cel.common.types.CelTypeProvider;
+import dev.cel.common.types.SimpleType;
+import dev.cel.common.types.TypeType;
+import dev.cel.compiler.CelCompiler;
+import dev.cel.compiler.CelCompilerFactory;
+import dev.cel.parser.CelStandardMacro;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(TestParameterInjector.class)
+public class CelEnvironmentTest {
+
+ @Test
+ public void newBuilder_defaults() {
+ CelEnvironment environment = CelEnvironment.newBuilder().build();
+
+ assertThat(environment.source()).isEmpty();
+ assertThat(environment.name()).isEmpty();
+ assertThat(environment.description()).isEmpty();
+ assertThat(environment.container()).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();
+
+ CelContainer container = environment.container().get();
+ assertThat(container.name()).isEqualTo("cntr");
+ assertThat(container.abbreviations()).containsExactly("foo.Bar", "baz.Qux");
+ assertThat(container.aliases()).containsExactly("nm", "user.name", "id", "user.id");
+ }
+
+ @Test
+ public void extend_allExtensions() throws Exception {
+ ImmutableSet extensionConfigs =
+ ImmutableSet.of(
+ ExtensionConfig.latest("bindings"),
+ ExtensionConfig.latest("encoders"),
+ ExtensionConfig.latest("lists"),
+ ExtensionConfig.latest("math"),
+ ExtensionConfig.latest("optional"),
+ ExtensionConfig.latest("protos"),
+ ExtensionConfig.latest("regex"),
+ ExtensionConfig.latest("sets"),
+ ExtensionConfig.latest("strings"),
+ ExtensionConfig.latest("two-var-comprehensions"));
+ CelEnvironment environment =
+ CelEnvironment.newBuilder().addExtensions(extensionConfigs).build();
+
+ Cel cel = environment.extend(CelFactory.standardCelBuilder().build(), CelOptions.DEFAULT);
+ CelAbstractSyntaxTree ast =
+ cel.compile(
+ "cel.bind(x, 10, math.greatest([1,x])) < int(' 11 '.trim()) &&"
+ + " optional.none().orValue(true) && [].flatten() == []")
+ .getAst();
+ boolean result = (boolean) cel.createProgram(ast).eval();
+
+ assertThat(extensionConfigs.size()).isEqualTo(CelEnvironment.CEL_EXTENSION_CONFIG_MAP.size());
+ assertThat(extensionConfigs.size()).isEqualTo(CanonicalCelExtension.values().length);
+ 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 =
+ CelEnvironment.newBuilder().addExtensions(ExtensionConfig.of("math", 1)).build();
+
+ Cel cel = environment.extend(CelFactory.standardCelBuilder().build(), CelOptions.DEFAULT);
+ CelAbstractSyntaxTree ast1 = cel.compile("math.abs(-4)").getAst();
+ assertThat(cel.createProgram(ast1).eval()).isEqualTo(4);
+
+ // Version 1 of the 'math' extension does not include sqrt
+ assertThat(
+ assertThrows(
+ CelValidationException.class,
+ () -> {
+ cel.compile("math.sqrt(4)").getAst();
+ }))
+ .hasMessageThat()
+ .contains("undeclared reference to 'sqrt'");
+ }
+
+ @Test
+ public void extensionVersion_latest() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder().addExtensions(ExtensionConfig.latest("math")).build();
+
+ Cel cel = environment.extend(CelFactory.standardCelBuilder().build(), CelOptions.DEFAULT);
+ CelAbstractSyntaxTree ast = cel.compile("math.sqrt(4)").getAst();
+ double result = (double) cel.createProgram(ast).eval();
+ assertThat(result).isEqualTo(2.0);
+ }
+
+ @Test
+ public void extensionVersion_unsupportedVersion_throws() {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder().addExtensions(ExtensionConfig.of("math", -5)).build();
+
+ assertThat(
+ assertThrows(
+ CelEnvironmentException.class,
+ () -> {
+ environment.extend(CelFactory.standardCelBuilder().build(), CelOptions.DEFAULT);
+ }))
+ .hasMessageThat()
+ .contains("Unsupported 'math' extension version -5");
+ }
+
+ @Test
+ public void stdlibSubset_bothIncludeExcludeSet_throws() {
+ assertThat(
+ assertThrows(
+ IllegalArgumentException.class,
+ () ->
+ CelEnvironment.newBuilder()
+ .setStandardLibrarySubset(
+ LibrarySubset.newBuilder()
+ .setDisabled(false)
+ .setIncludedMacros(ImmutableSet.of("foo"))
+ .setExcludedMacros(ImmutableSet.of("bar"))
+ .build())
+ .build()))
+ .hasMessageThat()
+ .contains("cannot both include and exclude macros");
+
+ assertThat(
+ assertThrows(
+ IllegalArgumentException.class,
+ () ->
+ CelEnvironment.newBuilder()
+ .setStandardLibrarySubset(
+ LibrarySubset.newBuilder()
+ .setDisabled(false)
+ .setIncludedFunctions(
+ ImmutableSet.of(
+ FunctionSelector.create("foo", ImmutableSet.of())))
+ .setExcludedFunctions(
+ ImmutableSet.of(
+ FunctionSelector.create("bar", ImmutableSet.of())))
+ .build())
+ .build()))
+ .hasMessageThat()
+ .contains("cannot both include and exclude functions");
+ }
+
+ @Test
+ public void stdlibSubset_disabled() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setStandardLibrarySubset(LibrarySubset.newBuilder().setDisabled(true).build())
+ .build();
+
+ CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build();
+ CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT);
+ CelValidationResult result = extendedCompiler.compile("1 != 2");
+ assertThat(result.getErrorString()).contains("undeclared reference to '_!=_'");
+ }
+
+ @Test
+ public void stdlibSubset_macrosDisabled() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setStandardLibrarySubset(
+ LibrarySubset.newBuilder().setDisabled(false).setMacrosDisabled(true).build())
+ .build();
+
+ CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build();
+ CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT);
+ CelValidationResult result =
+ extendedCompiler.compile("['hello', 'world'].exists(v, v == 'hello')");
+ assertThat(result.getErrorString()).contains("undeclared reference to 'exists'");
+ }
+
+ @Test
+ public void stdlibSubset_macrosIncluded() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setStandardLibrarySubset(
+ LibrarySubset.newBuilder()
+ .setDisabled(false)
+ .setIncludedMacros(ImmutableSet.of(CelStandardMacro.EXISTS.getFunction()))
+ .build())
+ .build();
+
+ CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build();
+ CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT);
+ CelValidationResult result =
+ extendedCompiler.compile("['hello', 'world'].exists(v, v == 'hello')");
+ assertThat(result.hasError()).isFalse();
+
+ result = extendedCompiler.compile("['hello', 'world'].exists_one(v, v == 'hello')");
+ assertThat(result.getErrorString()).contains("undeclared reference to 'exists_one'");
+ }
+
+ @Test
+ public void stdlibSubset_macrosExcluded() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setStandardLibrarySubset(
+ LibrarySubset.newBuilder()
+ .setDisabled(false)
+ .setExcludedMacros(ImmutableSet.of(CelStandardMacro.EXISTS_ONE.getFunction()))
+ .build())
+ .build();
+
+ CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build();
+ CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT);
+ CelValidationResult result =
+ extendedCompiler.compile("['hello', 'world'].exists(v, v == 'hello')");
+ assertThat(result.hasError()).isFalse();
+
+ result = extendedCompiler.compile("['hello', 'world'].exists_one(v, v == 'hello')");
+ assertThat(result.getErrorString()).contains("undeclared reference to 'exists_one'");
+ }
+
+ @Test
+ public void stdlibSubset_functionsIncluded() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setStandardLibrarySubset(
+ LibrarySubset.newBuilder()
+ .setDisabled(false)
+ .setIncludedFunctions(
+ ImmutableSet.of(
+ FunctionSelector.create("_==_", ImmutableSet.of()),
+ FunctionSelector.create("_!=_", ImmutableSet.of()),
+ FunctionSelector.create("_&&_", ImmutableSet.of())))
+ .build())
+ .build();
+
+ CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build();
+ CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT);
+ CelValidationResult result = extendedCompiler.compile("1 == 1 && 1 != 2");
+ assertThat(result.hasError()).isFalse();
+
+ result = extendedCompiler.compile("1 == 1 && 1 != 1 + 1");
+ assertThat(result.getErrorString()).contains("undeclared reference to '_+_'");
+ }
+
+ @Test
+ public void stdlibSubset_functionOverloadIncluded() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setStandardLibrarySubset(
+ LibrarySubset.newBuilder()
+ .setDisabled(false)
+ .setIncludedFunctions(
+ ImmutableSet.of(
+ FunctionSelector.create("_+_", ImmutableSet.of("add_int64"))))
+ .build())
+ .build();
+
+ CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build();
+ CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT);
+ CelValidationResult result = extendedCompiler.compile("1 + 2");
+ assertThat(result.hasError()).isFalse();
+
+ result = extendedCompiler.compile("1.0 + 2.0");
+ assertThat(result.getErrorString())
+ .contains("found no matching overload for '_+_' applied to '(double, double)'");
+ }
+
+ @Test
+ public void stdlibSubset_functionsExcluded() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setStandardLibrarySubset(
+ LibrarySubset.newBuilder()
+ .setDisabled(false)
+ .setExcludedFunctions(
+ ImmutableSet.of(FunctionSelector.create("_+_", ImmutableSet.of())))
+ .build())
+ .build();
+
+ CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build();
+ CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT);
+ CelValidationResult result = extendedCompiler.compile("1 == 1 && 1 != 2");
+ assertThat(result.hasError()).isFalse();
+
+ result = extendedCompiler.compile("1 == 1 && 1 != 1 + 1");
+ assertThat(result.getErrorString()).contains("undeclared reference to '_+_'");
+ }
+
+ @Test
+ public void stdlibSubset_functionOverloadExcluded() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setStandardLibrarySubset(
+ LibrarySubset.newBuilder()
+ .setDisabled(false)
+ .setExcludedFunctions(
+ ImmutableSet.of(
+ FunctionSelector.create("_+_", ImmutableSet.of("add_int64"))))
+ .build())
+ .build();
+
+ CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build();
+ CelCompiler extendedCompiler = environment.extend(compiler, CelOptions.DEFAULT);
+ CelValidationResult result = extendedCompiler.compile("1 == 1 && 1 != 2");
+ assertThat(result.hasError()).isFalse();
+
+ result = extendedCompiler.compile("1 == 1 && 1 != 1 + 1");
+ assertThat(result.getErrorString()).contains("found no matching overload for '_+_'");
+ }
+
+ @Test
+ public void typeDecl_toCelType_type() {
+ CelTypeProvider typeProvider =
+ CelCompilerFactory.standardCelCompilerBuilder().build().getTypeProvider();
+ CelEnvironment.TypeDecl typeDecl =
+ CelEnvironment.TypeDecl.newBuilder()
+ .setName("type")
+ .addParams(CelEnvironment.TypeDecl.create("int"))
+ .build();
+
+ CelType celType = typeDecl.toCelType(typeProvider);
+
+ assertThat(celType).isEqualTo(TypeType.create(SimpleType.INT));
+ }
+
+ @Test
+ public void typeDecl_toCelType_type_wrongParamCount_throws() {
+ CelTypeProvider typeProvider =
+ CelCompilerFactory.standardCelCompilerBuilder().build().getTypeProvider();
+ CelEnvironment.TypeDecl typeDecl = CelEnvironment.TypeDecl.newBuilder().setName("type").build();
+
+ IllegalStateException e =
+ assertThrows(IllegalStateException.class, () -> typeDecl.toCelType(typeProvider));
+ assertThat(e).hasMessageThat().contains("Expected 1 parameter for type, got 0");
+ }
+}
diff --git a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlParserTest.java b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlParserTest.java
new file mode 100644
index 000000000..043664e8e
--- /dev/null
+++ b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlParserTest.java
@@ -0,0 +1,1031 @@
+// 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.bundle;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertThrows;
+
+import com.google.common.base.Ascii;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.io.Resources;
+import com.google.rpc.context.AttributeContext;
+import com.google.testing.junit.testparameterinjector.TestParameter;
+import com.google.testing.junit.testparameterinjector.TestParameterInjector;
+import dev.cel.bundle.CelEnvironment.ExtensionConfig;
+import dev.cel.bundle.CelEnvironment.FunctionDecl;
+import dev.cel.bundle.CelEnvironment.LibrarySubset;
+import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector;
+import dev.cel.bundle.CelEnvironment.OverloadDecl;
+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.CelFunctionBinding;
+import dev.cel.runtime.CelLateFunctionBindings;
+import java.io.IOException;
+import java.net.URL;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(TestParameterInjector.class)
+public final class CelEnvironmentYamlParserTest {
+
+ private static final Cel CEL_WITH_MESSAGE_TYPES =
+ CelFactory.standardCelBuilder()
+ .addMessageTypes(AttributeContext.Request.getDescriptor())
+ .build();
+
+ private static final CelEnvironmentYamlParser ENVIRONMENT_PARSER =
+ CelEnvironmentYamlParser.newInstance();
+
+ @Test
+ public void environment_setEmpty() throws Exception {
+ assertThrows(CelEnvironmentException.class, () -> ENVIRONMENT_PARSER.parse(""));
+ }
+
+ @Test
+ public void environment_setBasicProperties() throws Exception {
+ String yamlConfig = "name: hello\n" + "description: empty\n" + "container: pb.pkg\n";
+
+ CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig);
+
+ assertThat(environment)
+ .isEqualTo(
+ CelEnvironment.newBuilder()
+ .setSource(environment.source().get())
+ .setName("hello")
+ .setDescription("empty")
+ .setContainer("pb.pkg")
+ .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 =
+ "extensions:\n"
+ + " - name: 'bindings'\n"
+ + " - name: 'encoders'\n"
+ + " - name: 'lists'\n"
+ + " - name: 'math'\n"
+ + " - name: 'optional'\n"
+ + " - name: 'protos'\n"
+ + " - name: 'sets'\n"
+ + " - name: 'strings'\n"
+ + " version: 1";
+
+ CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig);
+
+ assertThat(environment)
+ .isEqualTo(
+ CelEnvironment.newBuilder()
+ .setSource(environment.source().get())
+ .addExtensions(
+ ImmutableSet.of(
+ ExtensionConfig.of("bindings"),
+ ExtensionConfig.of("encoders"),
+ ExtensionConfig.of("lists"),
+ ExtensionConfig.of("math"),
+ ExtensionConfig.of("optional"),
+ ExtensionConfig.of("protos"),
+ ExtensionConfig.of("sets"),
+ ExtensionConfig.of("strings", 1)))
+ .build());
+ assertThat(environment.extend(CEL_WITH_MESSAGE_TYPES, CelOptions.DEFAULT)).isNotNull();
+ }
+
+ @Test
+ public void environment_setExtensionVersionToLatest() throws Exception {
+ String yamlConfig =
+ "extensions:\n" //
+ + " - name: 'bindings'\n" //
+ + " version: latest";
+
+ CelEnvironment environment = ENVIRONMENT_PARSER.parse(yamlConfig);
+
+ assertThat(environment)
+ .isEqualTo(
+ CelEnvironment.newBuilder()
+ .setSource(environment.source().get())
+ .addExtensions(ImmutableSet.of(ExtensionConfig.of("bindings", Integer.MAX_VALUE)))
+ .build());
+ assertThat(environment.extend(CEL_WITH_MESSAGE_TYPES, CelOptions.DEFAULT)).isNotNull();
+ }
+
+ @Test
+ public void environment_setExtensionVersionToInvalidValue() throws Exception {
+ String yamlConfig =
+ "extensions:\n" //
+ + " - name: 'bindings'\n" //
+ + " version: invalid";
+
+ CelEnvironmentException e =
+ assertThrows(CelEnvironmentException.class, () -> ENVIRONMENT_PARSER.parse(yamlConfig));
+ assertThat(e)
+ .hasMessageThat()
+ .contains(
+ "ERROR: capturedExpr = new AtomicReference<>();
+ CelEvaluationListener listener =
+ (expr, res) -> {
+ if (res instanceof Boolean && !(boolean) res && capturedExpr.get() == null) {
+ capturedExpr.set(expr);
+ }
+ };
+
+ String configSource =
+ "name: late_bound_function_config\n"
+ + "functions:\n"
+ + " - name: 'test'\n"
+ + " overloads:\n"
+ + " - id: 'test_bool'\n"
+ + " args:\n"
+ + " - type_name: 'bool'\n"
+ + " return:\n"
+ + " type_name: 'bool'";
+
+ CelEnvironment celEnvironment = ENVIRONMENT_PARSER.parse(configSource);
+ Cel celDetails =
+ CelFactory.standardCelBuilder()
+ .addVar("a", SimpleType.INT)
+ .addVar("b", SimpleType.INT)
+ .addVar("c", SimpleType.INT)
+ .build();
+ Cel cel = celEnvironment.extend(celDetails, CelOptions.DEFAULT);
+ CelAbstractSyntaxTree ast = cel.compile("a < 0 && b < 0 && c < 0 && test(a<0)").getAst();
+ CelLateFunctionBindings bindings =
+ CelLateFunctionBindings.from(
+ CelFunctionBinding.from("test_bool", Boolean.class, result -> result));
+
+ boolean result =
+ (boolean)
+ cel.createProgram(ast)
+ .trace(ImmutableMap.of("a", -1, "b", 1, "c", -4), bindings, listener);
+
+ assertThat(result).isFalse();
+ // Demonstrate that "b < 0" is what caused the expression to be false
+ CelAbstractSyntaxTree subtree =
+ CelAbstractSyntaxTree.newParsedAst(capturedExpr.get(), CelSource.newBuilder().build());
+ assertThat(CelUnparserFactory.newUnparser().unparse(subtree)).isEqualTo("b < 0");
+ }
+
+ private static String readFile(String path) throws IOException {
+ URL url = Resources.getResource(Ascii.toLowerCase(path));
+ return Resources.toString(url, UTF_8);
+ }
+}
diff --git a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlSerializerTest.java b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlSerializerTest.java
new file mode 100644
index 000000000..aad72a578
--- /dev/null
+++ b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentYamlSerializerTest.java
@@ -0,0 +1,250 @@
+// 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.bundle;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.common.base.Ascii;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.io.Resources;
+import dev.cel.bundle.CelEnvironment.ExtensionConfig;
+import dev.cel.bundle.CelEnvironment.FunctionDecl;
+import dev.cel.bundle.CelEnvironment.LibrarySubset;
+import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector;
+import dev.cel.bundle.CelEnvironment.OverloadDecl;
+import dev.cel.bundle.CelEnvironment.TypeDecl;
+import dev.cel.bundle.CelEnvironment.VariableDecl;
+import dev.cel.common.CelContainer;
+import java.io.IOException;
+import java.net.URL;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class CelEnvironmentYamlSerializerTest {
+
+ @Test
+ public void toYaml_success() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setName("dump_env")
+ .setDescription("dump_env description")
+ .setContainer(
+ CelContainer.newBuilder()
+ .setName("test.container")
+ .addAbbreviations("abbr1.Abbr1", "abbr2.Abbr2")
+ .addAlias("alias1", "qual.name1")
+ .addAlias("alias2", "qual.name2")
+ .build())
+ .addExtensions(
+ ImmutableSet.of(
+ ExtensionConfig.of("bindings"),
+ ExtensionConfig.of("encoders"),
+ ExtensionConfig.of("lists"),
+ ExtensionConfig.of("math"),
+ ExtensionConfig.of("optional"),
+ ExtensionConfig.of("protos"),
+ ExtensionConfig.of("sets"),
+ ExtensionConfig.of("strings", 1)))
+ .setVariables(
+ ImmutableSet.of(
+ VariableDecl.create(
+ "request", TypeDecl.create("google.rpc.context.AttributeContext.Request")),
+ VariableDecl.create(
+ "map_var",
+ TypeDecl.newBuilder()
+ .setName("map")
+ .addParams(TypeDecl.create("string"))
+ .addParams(TypeDecl.create("string"))
+ .build())))
+ .setFunctions(
+ ImmutableSet.of(
+ FunctionDecl.create(
+ "getOrDefault",
+ ImmutableSet.of(
+ OverloadDecl.newBuilder()
+ .setId("getOrDefault_key_value")
+ .setTarget(
+ TypeDecl.newBuilder()
+ .setName("map")
+ .addParams(
+ TypeDecl.newBuilder()
+ .setName("K")
+ .setIsTypeParam(true)
+ .build())
+ .addParams(
+ TypeDecl.newBuilder()
+ .setName("V")
+ .setIsTypeParam(true)
+ .build())
+ .build())
+ .setArguments(
+ ImmutableList.of(
+ TypeDecl.newBuilder()
+ .setName("K")
+ .setIsTypeParam(true)
+ .build(),
+ TypeDecl.newBuilder()
+ .setName("V")
+ .setIsTypeParam(true)
+ .build()))
+ .setReturnType(
+ TypeDecl.newBuilder().setName("V").setIsTypeParam(true).build())
+ .build())),
+ FunctionDecl.create(
+ "zip",
+ ImmutableSet.of(
+ OverloadDecl.newBuilder()
+ .setId("zip_list_int_list_int")
+ .setArguments(
+ ImmutableList.of(
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(TypeDecl.create("int"))
+ .build(),
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(TypeDecl.create("int"))
+ .build()))
+ .setReturnType(
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(TypeDecl.create("int"))
+ .build())
+ .build())
+ .build())),
+ FunctionDecl.create(
+ "zipGeneric",
+ ImmutableSet.of(
+ OverloadDecl.newBuilder()
+ .setId("zip_list_list")
+ .setArguments(
+ ImmutableList.of(
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(
+ TypeDecl.newBuilder()
+ .setName("T")
+ .setIsTypeParam(true)
+ .build())
+ .build(),
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(
+ TypeDecl.newBuilder()
+ .setName("T")
+ .setIsTypeParam(true)
+ .build())
+ .build()))
+ .setReturnType(
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(
+ TypeDecl.newBuilder()
+ .setName("list")
+ .addParams(
+ TypeDecl.newBuilder()
+ .setName("T")
+ .setIsTypeParam(true)
+ .build())
+ .build())
+ .build())
+ .build())),
+ FunctionDecl.create(
+ "coalesce",
+ ImmutableSet.of(
+ OverloadDecl.newBuilder()
+ .setId("coalesce_null_int")
+ .setTarget(TypeDecl.create("google.protobuf.Int64Value"))
+ .setArguments(ImmutableList.of(TypeDecl.create("int")))
+ .setReturnType(TypeDecl.create("int"))
+ .build()))))
+ .setStandardLibrarySubset(
+ LibrarySubset.newBuilder()
+ .setDisabled(true)
+ .setMacrosDisabled(true)
+ .setIncludedMacros(ImmutableSet.of("has", "exists"))
+ .setIncludedFunctions(
+ ImmutableSet.of(
+ FunctionSelector.create("_!=_", ImmutableSet.of()),
+ FunctionSelector.create(
+ "_+_", ImmutableSet.of("add_bytes", "add_list"))))
+ .build())
+ .setFeatures(
+ CelEnvironment.FeatureFlag.create("cel.feature.macro_call_tracking", true),
+ CelEnvironment.FeatureFlag.create("cel.feature.backtick_escape_syntax", false))
+ .setLimits(
+ 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();
+
+ String yamlOutput = CelEnvironmentYamlSerializer.toYaml(environment);
+ try {
+ String yamlFileContent = readFile("environment/dump_env.yaml");
+ // Strip the license at the beginning of the file
+ String expectedOutput = yamlFileContent.replaceAll("#.*\\n", "").replaceAll("^\\n", "");
+ assertThat(yamlOutput).isEqualTo(expectedOutput);
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private static String readFile(String path) throws IOException {
+ URL url = Resources.getResource(Ascii.toLowerCase(path));
+ return Resources.toString(url, UTF_8);
+ }
+
+ @Test
+ public void standardLibrary_excludeMacrosAndFunctions() throws Exception {
+ CelEnvironment environment =
+ CelEnvironment.newBuilder()
+ .setName("dump_env")
+ .setStandardLibrarySubset(
+ LibrarySubset.newBuilder()
+ .setDisabled(false)
+ .setExcludedMacros(ImmutableSet.of("has", "exists"))
+ .setExcludedFunctions(
+ ImmutableSet.of(
+ FunctionSelector.create("_!=_", ImmutableSet.of()),
+ FunctionSelector.create(
+ "_+_", ImmutableSet.of("add_bytes", "add_list"))))
+ .build())
+ .build();
+
+ String yamlOutput = CelEnvironmentYamlSerializer.toYaml(environment);
+
+ String expectedYaml =
+ "name: dump_env\n"
+ + "stdlib:\n"
+ + " exclude_macros:\n"
+ + " - exists\n"
+ + " - has\n"
+ + " exclude_functions:\n"
+ + " - name: _!=_\n"
+ + " - name: _+_\n"
+ + " overloads:\n"
+ + " - id: add_bytes\n"
+ + " - id: add_list\n";
+
+ assertThat(yamlOutput).isEqualTo(expectedYaml);
+ }
+}
diff --git a/bundle/src/test/java/dev/cel/bundle/CelImplTest.java b/bundle/src/test/java/dev/cel/bundle/CelImplTest.java
index 2b3cf30bb..a3ad60d40 100644
--- a/bundle/src/test/java/dev/cel/bundle/CelImplTest.java
+++ b/bundle/src/test/java/dev/cel/bundle/CelImplTest.java
@@ -16,6 +16,9 @@
import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat;
+import static dev.cel.common.CelFunctionDecl.newFunctionDeclaration;
+import static dev.cel.common.CelOverloadDecl.newGlobalOverload;
+import static dev.cel.common.CelOverloadDecl.newMemberOverload;
import static org.junit.Assert.assertThrows;
import dev.cel.expr.CheckedExpr;
@@ -38,14 +41,21 @@
import com.google.common.util.concurrent.MoreExecutors;
import com.google.protobuf.Any;
import com.google.protobuf.ByteString;
+import com.google.protobuf.DescriptorProtos.FileDescriptorProto;
import com.google.protobuf.DescriptorProtos.FileDescriptorSet;
+import com.google.protobuf.Descriptors.Descriptor;
+import com.google.protobuf.Descriptors.FileDescriptor;
import com.google.protobuf.Duration;
+import com.google.protobuf.DynamicMessage;
+import com.google.protobuf.Empty;
+import com.google.protobuf.ExtensionRegistry;
import com.google.protobuf.FieldMask;
import com.google.protobuf.Message;
-import com.google.protobuf.NullValue;
import com.google.protobuf.Struct;
+import com.google.protobuf.TextFormat;
import com.google.protobuf.Timestamp;
-import com.google.protobuf.util.Timestamps;
+import com.google.protobuf.TypeRegistry;
+import com.google.protobuf.WrappersProto;
import com.google.rpc.context.AttributeContext;
import com.google.testing.junit.testparameterinjector.TestParameter;
import com.google.testing.junit.testparameterinjector.TestParameterInjector;
@@ -55,20 +65,24 @@
import dev.cel.checker.ProtoTypeMask;
import dev.cel.checker.TypeProvider;
import dev.cel.common.CelAbstractSyntaxTree;
-import dev.cel.common.CelFunctionDecl;
+import dev.cel.common.CelContainer;
+import dev.cel.common.CelDescriptorUtil;
+import dev.cel.common.CelErrorCode;
import dev.cel.common.CelIssue;
import dev.cel.common.CelOptions;
-import dev.cel.common.CelOverloadDecl;
import dev.cel.common.CelProtoAbstractSyntaxTree;
+import dev.cel.common.CelSource.Extension;
+import dev.cel.common.CelSourceLocation;
import dev.cel.common.CelValidationException;
import dev.cel.common.CelValidationResult;
import dev.cel.common.CelVarDecl;
import dev.cel.common.ast.CelExpr;
-import dev.cel.common.ast.CelExpr.CelCreateList;
+import dev.cel.common.ast.CelExpr.CelList;
import dev.cel.common.testing.RepeatedTestProvider;
import dev.cel.common.types.CelKind;
+import dev.cel.common.types.CelProtoMessageTypes;
+import dev.cel.common.types.CelProtoTypes;
import dev.cel.common.types.CelType;
-import dev.cel.common.types.CelTypes;
import dev.cel.common.types.EnumType;
import dev.cel.common.types.ListType;
import dev.cel.common.types.MapType;
@@ -76,33 +90,45 @@
import dev.cel.common.types.ProtoMessageTypeProvider;
import dev.cel.common.types.SimpleType;
import dev.cel.common.types.StructTypeReference;
+import dev.cel.common.values.CelByteString;
+import dev.cel.common.values.NullValue;
import dev.cel.compiler.CelCompiler;
import dev.cel.compiler.CelCompilerFactory;
import dev.cel.compiler.CelCompilerImpl;
+import dev.cel.expr.conformance.proto2.Proto2ExtensionScopedMessage;
+import dev.cel.expr.conformance.proto2.TestAllTypesExtensions;
+import dev.cel.expr.conformance.proto3.TestAllTypes;
+import dev.cel.extensions.CelExtensions;
import dev.cel.parser.CelParserImpl;
import dev.cel.parser.CelStandardMacro;
import dev.cel.runtime.CelAttribute;
import dev.cel.runtime.CelAttribute.Qualifier;
import dev.cel.runtime.CelAttributePattern;
import dev.cel.runtime.CelEvaluationException;
+import dev.cel.runtime.CelEvaluationExceptionBuilder;
+import dev.cel.runtime.CelFunctionBinding;
import dev.cel.runtime.CelRuntime;
-import dev.cel.runtime.CelRuntime.CelFunctionBinding;
import dev.cel.runtime.CelRuntime.Program;
import dev.cel.runtime.CelRuntimeFactory;
import dev.cel.runtime.CelRuntimeLegacyImpl;
import dev.cel.runtime.CelUnknownSet;
import dev.cel.runtime.CelVariableResolver;
import dev.cel.runtime.UnknownContext;
+import dev.cel.testing.CelRuntimeFlavor;
+import dev.cel.testing.testdata.SingleFile;
+import dev.cel.testing.testdata.SingleFileExtensionsProto;
import dev.cel.testing.testdata.proto3.StandaloneGlobalEnum;
-import dev.cel.testing.testdata.proto3.TestAllTypesProto.TestAllTypes;
+import java.time.Instant;
import java.util.ArrayList;
+import java.util.LinkedHashMap;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
-import org.jspecify.nullness.Nullable;
+import org.jspecify.annotations.Nullable;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -150,10 +176,10 @@ public final class CelImplTest {
private static final CheckedExpr CHECKED_EXPR =
CheckedExpr.newBuilder()
.setExpr(EXPR)
- .putTypeMap(1L, CelTypes.BOOL)
- .putTypeMap(2L, CelTypes.BOOL)
- .putTypeMap(3L, CelTypes.BOOL)
- .putTypeMap(4L, CelTypes.BOOL)
+ .putTypeMap(1L, CelProtoTypes.BOOL)
+ .putTypeMap(2L, CelProtoTypes.BOOL)
+ .putTypeMap(3L, CelProtoTypes.BOOL)
+ .putTypeMap(4L, CelProtoTypes.BOOL)
.putReferenceMap(2L, Reference.newBuilder().addOverloadId("logical_and").build())
.putReferenceMap(3L, Reference.newBuilder().addOverloadId("logical_not").build())
.build();
@@ -181,13 +207,11 @@ public void build_badFileDescriptorSet() {
IllegalArgumentException.class,
() ->
standardCelBuilderWithMacros()
- .setContainer("google.rpc.context.AttributeContext")
+ .setContainer(CelContainer.ofName("cel.expr.conformance.proto2"))
.addFileTypes(
FileDescriptorSet.newBuilder()
- .addFile(AttributeContext.getDescriptor().getFile().toProto())
+ .addFile(TestAllTypesExtensions.getDescriptor().getFile().toProto())
.build())
- .setProtoResultType(
- CelTypes.createMessage("google.rpc.context.AttributeContext.Resource"))
.build());
assertThat(e).hasMessageThat().contains("file descriptor set with unresolved proto file");
}
@@ -213,7 +237,7 @@ public void check() throws Exception {
public void compile(boolean useProtoResultType) throws Exception {
CelBuilder celBuilder = standardCelBuilderWithMacros();
if (useProtoResultType) {
- celBuilder.setProtoResultType(CelTypes.BOOL);
+ celBuilder.setProtoResultType(CelProtoTypes.BOOL);
} else {
celBuilder.setResultType(SimpleType.BOOL);
}
@@ -227,7 +251,7 @@ public void compile(boolean useProtoResultType) throws Exception {
public void compile_resultTypeCheckFailure(boolean useProtoResultType) {
CelBuilder celBuilder = standardCelBuilderWithMacros();
if (useProtoResultType) {
- celBuilder.setProtoResultType(CelTypes.STRING);
+ celBuilder.setProtoResultType(CelProtoTypes.STRING);
} else {
celBuilder.setResultType(SimpleType.STRING);
}
@@ -245,13 +269,13 @@ public void compile_combinedTypeProvider() {
new ProtoMessageTypeProvider(ImmutableList.of(AttributeContext.getDescriptor()));
Cel cel =
standardCelBuilderWithMacros()
- .setContainer("google")
+ .setContainer(CelContainer.ofName("google"))
.setTypeProvider(celTypeProvider)
.addMessageTypes(com.google.type.Expr.getDescriptor())
.addProtoTypeMasks(
ImmutableList.of(ProtoTypeMask.ofAllFields("google.rpc.context.AttributeContext")))
.addVar("condition", StructTypeReference.create("google.type.Expr"))
- .setProtoResultType(CelTypes.BOOL)
+ .setProtoResultType(CelProtoTypes.BOOL)
.build();
CelValidationResult result =
cel.compile("type.Expr{expression: \"'hello'\"}.expression == condition.expression");
@@ -266,7 +290,7 @@ public void compile_customTypeProvider() {
AttributeContext.getDescriptor(), com.google.type.Expr.getDescriptor()));
Cel cel =
standardCelBuilderWithMacros()
- .setContainer("google")
+ .setContainer(CelContainer.ofName("google"))
.setTypeProvider(celTypeProvider)
.addVar("condition", StructTypeReference.create("google.type.Expr"))
.setResultType(SimpleType.BOOL)
@@ -283,7 +307,8 @@ public void compile_customTypesWithAliasingCombinedProviders() throws Exception
// However, the first type resolution from the alias to the qualified type name won't be
// sufficient as future checks will expect the resolved alias to also be a type.
TypeProvider customTypeProvider =
- aliasingProvider(ImmutableMap.of("Condition", CelTypes.createMessage("google.type.Expr")));
+ aliasingProvider(
+ ImmutableMap.of("Condition", CelProtoTypes.createMessage("google.type.Expr")));
// The registration of the aliasing TypeProvider and the google.type.Expr descriptor
// ensures that once the alias is resolved, the additional details about the Expr type
@@ -315,9 +340,9 @@ public void compile_customTypesWithAliasingSelfContainedProvider() throws Except
aliasingProvider(
ImmutableMap.of(
"Condition",
- CelTypes.createMessage("google.type.Expr"),
+ CelProtoTypes.createMessage("google.type.Expr"),
"google.type.Expr",
- CelTypes.createMessage("google.type.Expr")));
+ CelProtoTypes.createMessage("google.type.Expr")));
// The registration of the aliasing TypeProvider and the google.type.Expr descriptor
// ensures that once the alias is resolved, the additional details about the Expr type
@@ -352,6 +377,7 @@ public void program_setTypeFactoryOnAnyPackedMessage_fieldSelectionSuccess() thr
CelAbstractSyntaxTree ast = celCompiler.compile("input.expression").getAst();
CelRuntime celRuntime =
CelRuntimeFactory.standardCelRuntimeBuilder()
+ // CEL-Internal-2
.setTypeFactory(
(typeName) ->
typeName.equals("google.type.Expr") ? com.google.type.Expr.newBuilder() : null)
@@ -381,6 +407,7 @@ public void program_setTypeFactoryOnAnyPackedMessage_messageConstructionSucceeds
CelRuntime celRuntime =
CelRuntimeFactory.standardCelRuntimeBuilder()
+ // CEL-Internal-2
.setTypeFactory(
(typeName) ->
typeName.equals("google.type.Expr") ? com.google.type.Expr.newBuilder() : null)
@@ -398,6 +425,7 @@ public void program_setTypeFactoryOnAnyPackedMessage_messageConstructionSucceeds
}
@Test
+ @SuppressWarnings("unused") // testRunIndex name retained for test result readability
public void program_concurrentMessageConstruction_succeeds(
@TestParameter(valuesProvider = RepeatedTestProvider.class) int testRunIndex)
throws Exception {
@@ -405,7 +433,7 @@ public void program_concurrentMessageConstruction_succeeds(
int threadCount = 10;
Cel cel =
standardCelBuilderWithMacros()
- .setContainer("google.rpc.context.AttributeContext")
+ .setContainer(CelContainer.ofName("google.rpc.context.AttributeContext"))
.addFileTypes(
Any.getDescriptor().getFile(),
Duration.getDescriptor().getFile(),
@@ -463,7 +491,10 @@ public void compile_typeCheckFailure() {
assertThat(syntaxErrorResult.hasError()).isTrue();
assertThat(syntaxErrorResult.getErrors())
.containsExactly(
- CelIssue.formatError(1, 0, "undeclared reference to 'variable' (in container '')"));
+ CelIssue.formatError(
+ /* exprId= */ 1L,
+ CelSourceLocation.of(1, 0),
+ "undeclared reference to 'variable' (in container '')"));
assertThat(syntaxErrorResult.getErrorString())
.isEqualTo(
"ERROR: map = (Map) args[0];
+ return map.containsKey(args[1]) && map.containsValue(args[2]);
+ }))
+ .build();
+ CelAbstractSyntaxTree ast = cel.compile("{'a': 'b'}.hasStringValue('a', 'b')").getAst();
+
+ boolean result = (boolean) cel.createProgram(ast).eval();
+
+ assertThat(result).isTrue();
+ }
+
+ @Test
+ public void program_nativeTypeUnknownsEnabled_asIdentifiers() throws Exception {
+ Cel cel =
+ CelFactory.standardCelBuilder()
+ .addVar("x", SimpleType.BOOL)
+ .addVar("y", SimpleType.BOOL)
+ .setOptions(CelOptions.current().build())
+ .build();
+ CelAbstractSyntaxTree ast = cel.compile("x || y").getAst();
+
+ CelUnknownSet result = (CelUnknownSet) cel.createProgram(ast).eval();
+
+ assertThat(result.unknownExprIds()).containsExactly(1L, 3L);
+ assertThat(result.attributes()).isEmpty();
+ }
+
+ @Test
+ public void program_nativeTypeUnknownsEnabled_asCallArguments() throws Exception {
+ Cel cel =
+ CelFactory.standardCelBuilder()
+ .addVar("x", SimpleType.BOOL)
+ .addFunctionDeclarations(
+ newFunctionDeclaration(
+ "foo", newGlobalOverload("foo_bool", SimpleType.BOOL, SimpleType.BOOL)))
+ .setOptions(CelOptions.current().build())
+ .build();
+ CelAbstractSyntaxTree ast = cel.compile("foo(x)").getAst();
+
+ CelUnknownSet result = (CelUnknownSet) cel.createProgram(ast).eval();
+
+ assertThat(result.unknownExprIds()).containsExactly(2L);
+ assertThat(result.attributes()).isEmpty();
+ }
+
+ @Test
+ public void program_comprehensionDisabled_throws() throws Exception {
+ Cel cel =
+ standardCelBuilderWithMacros()
+ .setOptions(CelOptions.current().enableComprehension(false).build())
+ .build();
+ CelAbstractSyntaxTree ast = cel.compile("['foo', 'bar'].map(x, x)").getAst();
+
+ CelEvaluationException e =
+ assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval());
+ assertThat(e).hasMessageThat().contains("Iteration budget exceeded: 0");
+ assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.ITERATION_BUDGET_EXCEEDED);
+ }
+
+ @Test
+ public void program_regexProgramSizeUnderLimit_success() throws Exception {
+ Cel cel =
+ standardCelBuilderWithMacros()
+ .setOptions(CelOptions.current().maxRegexProgramSize(7).build())
+ .build();
+ // See
+ // https://github.com/google/re2j/blob/84237cbbd0fbd637c6eb6856717c1e248daae729/javatests/com/google/re2j/PatternTest.java#L175 for program size
+ CelAbstractSyntaxTree ast = cel.compile("'foo'.matches('(a+b)')").getAst();
+
+ assertThat(cel.createProgram(ast).eval()).isEqualTo(false);
+ }
+
+ @Test
+ public void program_regexProgramSizeExceedsLimit_throws() throws Exception {
+ Cel cel =
+ standardCelBuilderWithMacros()
+ .setOptions(CelOptions.current().maxRegexProgramSize(6).build())
+ .build();
+ // See
+ // https://github.com/google/re2j/blob/84237cbbd0fbd637c6eb6856717c1e248daae729/javatests/com/google/re2j/PatternTest.java#L175 for program size
+ CelAbstractSyntaxTree ast = cel.compile("'foo'.matches('(a+b)')").getAst();
+
+ CelEvaluationException e =
+ assertThrows(CelEvaluationException.class, () -> cel.createProgram(ast).eval());
+ assertThat(e)
+ .hasMessageThat()
+ .contains(
+ "evaluation error at expectedNestedMap = new LinkedHashMap<>();
+ expectedNestedMap.put(ByteString.copyFromUtf8("abc"), com.google.protobuf.NullValue.NULL_VALUE);
+
+ List result = (List) cel.createProgram(ast).eval();
+
+ assertThat(result).containsExactly(com.google.protobuf.NullValue.NULL_VALUE, expectedNestedMap);
+ }
+
+ @Test
+ public void program_evaluateCanonicalTypesToNativeTypesDisabled_producesBytesProto()
+ throws Exception {
+ Cel cel =
+ standardCelBuilderWithMacros()
+ .addMessageTypes(TestAllTypes.getDescriptor())
+ .setContainer(CelContainer.ofName("cel.expr.conformance.proto3"))
+ .setOptions(CelOptions.current().evaluateCanonicalTypesToNativeValues(false).build())
+ .build();
+ CelAbstractSyntaxTree ast =
+ cel.compile("TestAllTypes{single_bytes: bytes('abc')}.single_bytes").getAst();
+
+ ByteString result = (ByteString) cel.createProgram(ast).eval();
+
+ assertThat(result).isEqualTo(ByteString.copyFromUtf8("abc"));
+ }
+
+ @Test
+ public void program_fdsContainsWktDependency_descriptorInstancesMatch() throws Exception {
+ // Force serialization of the descriptor to get a unique instance
+ FileDescriptorProto proto = TestAllTypes.getDescriptor().getFile().toProto();
+ FileDescriptorSet fds = FileDescriptorSet.newBuilder().addFile(proto).build();
+ ImmutableSet fileDescriptors =
+ CelDescriptorUtil.getFileDescriptorsFromFileDescriptorSet(fds);
+ ImmutableSet descriptors =
+ CelDescriptorUtil.getAllDescriptorsFromFileDescriptor(fileDescriptors)
+ .messageTypeDescriptors();
+ Descriptor testAllTypesDescriptor =
+ descriptors.stream()
+ .filter(x -> x.getFullName().equals(TestAllTypes.getDescriptor().getFullName()))
+ .findAny()
+ .get();
+
+ // Parse text proto using this fds
+ TypeRegistry typeRegistry = TypeRegistry.newBuilder().add(descriptors).build();
+ TestAllTypes.Builder testAllTypesBuilder = TestAllTypes.newBuilder();
+ TextFormat.Parser textFormatParser =
+ TextFormat.Parser.newBuilder().setTypeRegistry(typeRegistry).build();
+ String textProto =
+ "single_timestamp {\n" //
+ + " seconds: 100\n" //
+ + "}";
+ textFormatParser.merge(textProto, testAllTypesBuilder);
+ TestAllTypes testAllTypesFromTextProto = testAllTypesBuilder.build();
+ DynamicMessage dynamicMessage =
+ DynamicMessage.parseFrom(
+ testAllTypesDescriptor,
+ testAllTypesFromTextProto.toByteArray(),
+ ExtensionRegistry.getEmptyRegistry());
+ // Setup CEL environment with the same descriptors obtained from FDS
+ Cel cel =
+ standardCelBuilderWithMacros()
+ .addMessageTypes(descriptors)
+ // CEL-Internal-2
+ .setContainer(CelContainer.ofName("cel.expr.conformance.proto3"))
+ .build();
+ CelAbstractSyntaxTree ast =
+ cel.compile("TestAllTypes{single_timestamp: timestamp(100)}").getAst();
+
+ DynamicMessage evalResult = (DynamicMessage) cel.createProgram(ast).eval();
+
+ // This should strictly equal regardless of where the descriptors came from for WKTs
+ assertThat(evalResult).isEqualTo(dynamicMessage);
+ }
+
@Test
public void toBuilder_isImmutable() {
CelBuilder celBuilder = CelFactory.standardCelBuilder();
@@ -1837,13 +2144,164 @@ public void toBuilder_isImmutable() {
assertThat(newRuntimeBuilder).isNotEqualTo(celImpl.toRuntimeBuilder());
}
+ @Test
+ public void eval_withJsonFieldName(@TestParameter CelRuntimeFlavor runtimeFlavor)
+ throws Exception {
+ Cel cel = setupEnv(runtimeFlavor.builder());
+ CelAbstractSyntaxTree ast =
+ cel.compile(
+ "file.int32_snake_case_json_name == 1 && "
+ + "file.int64CamelCaseJsonName == 2 && "
+ + "file.uint32DefaultJsonName == 3u && "
+ + "file.`uint64-custom-json-name` == 4u && "
+ + "file.single_string == 'shadows' && "
+ + "file.singleString == 'shadowed'")
+ .getAst();
+
+ boolean result =
+ (boolean)
+ cel.createProgram(ast)
+ .eval(
+ ImmutableMap.of(
+ "file",
+ SingleFile.newBuilder()
+ .setInt32SnakeCaseJsonName(1)
+ .setInt64CamelCaseJsonName(2L)
+ .setUint32DefaultJsonName(3)
+ .setUint64CustomJsonName(4)
+ .setStringJsonNameShadows("shadows")
+ .setSingleString("shadowed")
+ .setExtension(SingleFileExtensionsProto.int64CamelCaseJsonName, 5L)
+ .build()));
+
+ assertThat(result).isTrue();
+ }
+
+ @Test
+ public void eval_withJsonFieldName_fieldsFallBack(@TestParameter CelRuntimeFlavor runtimeFlavor)
+ throws Exception {
+ Cel cel = setupEnv(runtimeFlavor.builder());
+ CelAbstractSyntaxTree ast =
+ cel.compile(
+ "dyn(file).int32_snake_case_json_name == 1 && "
+ + "dyn(file).`uint64-custom-json-name` == 4u && "
+ + "dyn(file).single_string == 'shadows' && "
+ + "dyn(file).string_json_name_shadows == 'shadows' && "
+ + "dyn(file).singleString == 'shadowed'")
+ .getAst();
+
+ boolean result =
+ (boolean)
+ cel.createProgram(ast)
+ .eval(
+ ImmutableMap.of(
+ "file",
+ SingleFile.newBuilder()
+ .setInt32SnakeCaseJsonName(1)
+ .setInt64CamelCaseJsonName(2L)
+ .setUint32DefaultJsonName(3)
+ .setUint64CustomJsonName(4)
+ .setStringJsonNameShadows("shadows")
+ .setSingleString("shadowed")
+ .build()));
+
+ assertThat(result).isTrue();
+ }
+
+ @Test
+ public void eval_withJsonFieldName_extensionFields(@TestParameter CelRuntimeFlavor runtimeFlavor)
+ throws Exception {
+ Cel cel = setupEnv(runtimeFlavor.builder());
+ CelAbstractSyntaxTree ast =
+ cel.compile(
+ "proto.getExt(file, dev.cel.testing.testdata.int64CamelCaseJsonName) == 5 &&"
+ + " proto.getExt(file, dev.cel.testing.testdata.single_string) == 'foo'")
+ .getAst();
+
+ boolean result =
+ (boolean)
+ cel.createProgram(ast)
+ .eval(
+ ImmutableMap.of(
+ "file",
+ SingleFile.newBuilder()
+ .setInt64CamelCaseJsonName(2L)
+ .setExtension(SingleFileExtensionsProto.int64CamelCaseJsonName, 5L)
+ .setSingleString("This should not be used")
+ .setExtension(SingleFileExtensionsProto.singleString, "foo")
+ .build()));
+
+ assertThat(result).isTrue();
+ }
+
+ @Test
+ public void eval_withJsonFieldName_runtimeOptionDisabled_throws() throws Exception {
+ CelCompiler celCompiler =
+ CelCompilerFactory.standardCelCompilerBuilder()
+ .addVar("file", StructTypeReference.create(SingleFile.getDescriptor().getFullName()))
+ .addMessageTypes(SingleFile.getDescriptor())
+ .setOptions(CelOptions.current().enableJsonFieldNames(true).build())
+ .build();
+ CelRuntime celRuntime =
+ CelRuntimeFactory.standardCelRuntimeBuilder()
+ .addMessageTypes(SingleFile.getDescriptor())
+ .setOptions(CelOptions.current().enableJsonFieldNames(false).build())
+ .build();
+ CelAbstractSyntaxTree ast = celCompiler.compile("file.int64CamelCaseJsonName").getAst();
+
+ CelEvaluationException e =
+ assertThrows(
+ CelEvaluationException.class,
+ () ->
+ celRuntime
+ .createProgram(ast)
+ .eval(ImmutableMap.of("file", SingleFile.getDefaultInstance())));
+ assertThat(e)
+ .hasMessageThat()
+ .contains(
+ "field 'int64CamelCaseJsonName' is not declared in message"
+ + " 'dev.cel.testing.testdata.SingleFile");
+ }
+
+ @Test
+ public void compile_withJsonFieldName_astTagged() throws Exception {
+ Cel cel =
+ standardCelBuilderWithMacros()
+ .addVar("file", StructTypeReference.create(SingleFile.getDescriptor().getFullName()))
+ .addMessageTypes(SingleFile.getDescriptor())
+ .setOptions(CelOptions.current().enableJsonFieldNames(true).build())
+ .build();
+ CelAbstractSyntaxTree ast = cel.compile("file.int64CamelCaseJsonName").getAst();
+
+ assertThat(ast.getSource().getExtensions())
+ .contains(
+ Extension.create(
+ "json_name", Extension.Version.of(1L, 1L), Extension.Component.COMPONENT_RUNTIME));
+ }
+
+ @Test
+ public void compile_withJsonFieldName_protoFieldNameComparison_throws() throws Exception {
+ Cel cel =
+ standardCelBuilderWithMacros()
+ .addVar("file", StructTypeReference.create(SingleFile.getDescriptor().getFullName()))
+ .addMessageTypes(SingleFile.getDescriptor())
+ .setOptions(CelOptions.current().enableJsonFieldNames(true).build())
+ .build();
+
+ CelValidationException e =
+ assertThrows(
+ CelValidationException.class,
+ () -> cel.compile("file.camelCased == file.snake_cased").getAst());
+ assertThat(e).hasMessageThat().contains("undefined field 'snake_cased'");
+ }
+
private static TypeProvider aliasingProvider(ImmutableMap typeAliases) {
return new TypeProvider() {
@Override
public @Nullable Type lookupType(String typeName) {
Type alias = typeAliases.get(typeName);
if (alias != null) {
- return CelTypes.create(alias);
+ return CelProtoTypes.create(alias);
}
return null;
}
@@ -1856,10 +2314,28 @@ private static TypeProvider aliasingProvider(ImmutableMap typeAlia
@Override
public TypeProvider.@Nullable FieldType lookupFieldType(Type type, String fieldName) {
if (typeAliases.containsKey(type.getMessageType())) {
- return TypeProvider.FieldType.of(CelTypes.STRING);
+ return TypeProvider.FieldType.of(CelProtoTypes.STRING);
}
return null;
}
};
}
+
+ private static Cel setupEnv(CelBuilder celBuilder) {
+ ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance();
+ SingleFileExtensionsProto.registerAllExtensions(extensionRegistry);
+ return celBuilder
+ .addVar("file", StructTypeReference.create(SingleFile.getDescriptor().getFullName()))
+ .addMessageTypes(SingleFile.getDescriptor())
+ .addFileTypes(SingleFileExtensionsProto.getDescriptor())
+ .addCompilerLibraries(CelExtensions.protos())
+ .setExtensionRegistry(extensionRegistry)
+ .setOptions(
+ CelOptions.current()
+ .enableJsonFieldNames(true)
+ .enableHeterogeneousNumericComparisons(true)
+ .enableQuotedIdentifierSyntax(true)
+ .build())
+ .build();
+ }
}
diff --git a/cel_android_rules.bzl b/cel_android_rules.bzl
new file mode 100644
index 000000000..9bd2fd8bc
--- /dev/null
+++ b/cel_android_rules.bzl
@@ -0,0 +1,63 @@
+# 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.
+"""Macro to create android_library rules with CEL specific options applied."""
+
+load("@rules_android//rules:rules.bzl", "android_library", "android_local_test")
+
+DEFAULT_JAVACOPTS = [
+ "-XDstringConcat=inline", # SDK forces usage of StringConcatFactory (java 9+)
+]
+
+def cel_android_library(name, **kwargs):
+ """
+ Generates android_library target with CEL specific javacopts applied
+
+ Args:
+ name: name of the android_library target
+ **kwargs: rest of the args accepted by android_library
+ """
+
+ javacopts = kwargs.get("javacopts", [])
+ all_javacopts = DEFAULT_JAVACOPTS + javacopts
+
+ # By default, set visibility to android_allow_list, unless if overridden at the call site.
+ provided_visibility_or_default = kwargs.get("visibility", ["//:android_allow_list"])
+ provided_compatible_with_or_default = kwargs.get("compatible_with", [])
+ filtered_kwargs = {k: v for k, v in kwargs.items() if k not in ["visibility", "compatible_with"]}
+
+ android_library(
+ name = name,
+ visibility = provided_visibility_or_default,
+ compatible_with = provided_compatible_with_or_default,
+ javacopts = all_javacopts,
+ **filtered_kwargs
+ )
+
+def cel_android_local_test(name, **kwargs):
+ """
+ Generates android_local_test target with CEL specific javacopts applied
+
+ Args:
+ name: name of the android_local_test target
+ **kwargs: rest of the args accepted by android_local_test
+ """
+
+ javacopts = kwargs.get("javacopts", [])
+ all_javacopts = DEFAULT_JAVACOPTS + javacopts
+
+ android_local_test(
+ name = name,
+ javacopts = all_javacopts,
+ **kwargs
+ )
diff --git a/checker/BUILD.bazel b/checker/BUILD.bazel
index 25fc8d739..5fa3c6c05 100644
--- a/checker/BUILD.bazel
+++ b/checker/BUILD.bazel
@@ -1,3 +1,5 @@
+load("@rules_java//java:defs.bzl", "java_library")
+
package(
default_applicable_licenses = ["//:license"],
default_visibility = ["//visibility:public"],
@@ -26,7 +28,7 @@ java_library(
java_library(
name = "type_provider_legacy_impl",
- visibility = ["//visibility:public"],
+ visibility = ["//:internal"],
exports = ["//checker/src/main/java/dev/cel/checker:type_provider_legacy_impl"],
)
@@ -37,13 +39,13 @@ java_library(
java_library(
name = "checker_legacy_environment",
- visibility = ["//visibility:public"],
+ deprecation = "See go/cel-java-migration-guide. Please use CEL-Java Fluent APIs //compiler instead",
exports = ["//checker/src/main/java/dev/cel/checker:checker_legacy_environment"],
)
java_library(
name = "type_inferencer",
- visibility = ["//visibility:public"], # Planned for use in a new type-checker.
+ visibility = ["//:internal"], # Planned for use in a new type-checker.
exports = ["//checker/src/main/java/dev/cel/checker:type_inferencer"],
)
@@ -51,3 +53,8 @@ java_library(
name = "proto_expr_visitor",
exports = ["//checker/src/main/java/dev/cel/checker:proto_expr_visitor"],
)
+
+java_library(
+ name = "standard_decl",
+ exports = ["//checker/src/main/java/dev/cel/checker:standard_decl"],
+)
diff --git a/checker/src/main/java/dev/cel/checker/BUILD.bazel b/checker/src/main/java/dev/cel/checker/BUILD.bazel
index 0053d9061..99d4da586 100644
--- a/checker/src/main/java/dev/cel/checker/BUILD.bazel
+++ b/checker/src/main/java/dev/cel/checker/BUILD.bazel
@@ -1,3 +1,5 @@
+load("@rules_java//java:defs.bzl", "java_library")
+
package(
default_applicable_licenses = [
"//:license",
@@ -28,7 +30,6 @@ CHECKER_LEGACY_ENV_SOURCES = [
"ExprChecker.java",
"ExprVisitor.java",
"InferenceContext.java",
- "Standard.java",
"TypeFormatter.java",
"TypeProvider.java",
"Types.java",
@@ -48,9 +49,9 @@ java_library(
"//common/annotations",
"//common/internal:file_descriptor_converter",
"//common/types",
- "//common/types:cel_types",
+ "//common/types:cel_proto_types",
"//common/types:type_providers",
- "@cel_spec//proto/cel/expr:expr_java_proto",
+ "@cel_spec//proto/cel/expr:checked_java_proto",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_guava_guava",
"@maven//:com_google_protobuf_protobuf_java",
@@ -68,23 +69,29 @@ java_library(
":checker_builder",
":checker_legacy_environment",
":proto_type_mask",
+ ":standard_decl",
":type_provider_legacy_impl",
"//:auto_value",
- "//common",
+ "//common:cel_ast",
+ "//common:cel_descriptor_util",
+ "//common:cel_source",
"//common:compiler_common",
+ "//common:container",
"//common:options",
+ "//common:source_location",
"//common/annotations",
"//common/ast:expr_converter",
"//common/internal:env_visitor",
"//common/internal:errors",
"//common/types",
- "//common/types:cel_types",
+ "//common/types:cel_proto_types",
"//common/types:message_type_provider",
"//common/types:type_providers",
- "@cel_spec//proto/cel/expr:expr_java_proto",
+ "@cel_spec//proto/cel/expr:checked_java_proto",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_guava_guava",
"@maven//:com_google_protobuf_protobuf_java",
+ "@maven//:org_jspecify_jspecify",
],
)
@@ -96,11 +103,13 @@ java_library(
deps = [
":checker_legacy_environment",
":proto_type_mask",
- "//common",
+ ":standard_decl",
+ "//common:cel_ast",
"//common:compiler_common",
+ "//common:container",
"//common:options",
"//common/types:type_providers",
- "@cel_spec//proto/cel/expr:expr_java_proto",
+ "@cel_spec//proto/cel/expr:checked_java_proto",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_protobuf_protobuf_java",
],
@@ -131,9 +140,9 @@ java_library(
"//common/annotations",
"//common/ast",
"//common/ast:expr_converter",
- "//common/types:cel_types",
+ "//common/types:cel_proto_types",
"//common/types:type_providers",
- "@cel_spec//proto/cel/expr:expr_java_proto",
+ "@cel_spec//proto/cel/expr:checked_java_proto",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_guava_guava",
],
@@ -149,9 +158,9 @@ java_library(
"//:auto_value",
"//common/annotations",
"//common/types",
- "//common/types:cel_types",
+ "//common/types:cel_proto_types",
"//common/types:type_providers",
- "@cel_spec//proto/cel/expr:expr_java_proto",
+ "@cel_spec//proto/cel/expr:checked_java_proto",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_guava_guava",
"@maven//:org_jspecify_jspecify",
@@ -165,22 +174,29 @@ java_library(
],
deps = [
":cel_ident_decl",
+ ":standard_decl",
"//:auto_value",
+ "//common:cel_ast",
+ "//common:cel_source",
"//common:compiler_common",
- "//common:features",
+ "//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",
+ "//common/types:cel_proto_types",
"//common/types:cel_types",
"//common/types:type_providers",
"//parser:macro",
- "//parser:operator",
- "@cel_spec//proto/cel/expr:expr_java_proto",
+ "@cel_spec//proto/cel/expr:checked_java_proto",
+ "@cel_spec//proto/cel/expr:syntax_java_proto",
"@maven//:com_google_errorprone_error_prone_annotations",
"@maven//:com_google_guava_guava",
"@maven//:com_google_protobuf_protobuf_java",
@@ -211,6 +227,26 @@ java_library(
],
deps = [
":checker_legacy_environment",
- "//common",
+ "//common:cel_ast",
+ "//common:proto_ast",
+ ],
+)
+
+java_library(
+ name = "standard_decl",
+ srcs = [
+ "CelStandardDeclarations.java",
+ ],
+ tags = [
+ ],
+ deps = [
+ ":cel_ident_decl",
+ "//common:compiler_common",
+ "//common:operator",
+ "//common/types",
+ "//common/types:cel_types",
+ "//common/types:type_providers",
+ "@maven//:com_google_errorprone_error_prone_annotations",
+ "@maven//:com_google_guava_guava",
],
)
diff --git a/checker/src/main/java/dev/cel/checker/CelChecker.java b/checker/src/main/java/dev/cel/checker/CelChecker.java
index 4022212cb..077850be1 100644
--- a/checker/src/main/java/dev/cel/checker/CelChecker.java
+++ b/checker/src/main/java/dev/cel/checker/CelChecker.java
@@ -17,6 +17,7 @@
import com.google.errorprone.annotations.Immutable;
import dev.cel.common.CelAbstractSyntaxTree;
import dev.cel.common.CelValidationResult;
+import dev.cel.common.types.CelTypeProvider;
/** Public interface for type-checking parsed CEL expressions. */
@Immutable
@@ -29,5 +30,8 @@ public interface CelChecker {
*/
CelValidationResult check(CelAbstractSyntaxTree ast);
+ /** Returns the underlying type provider. */
+ CelTypeProvider getTypeProvider();
+
CelCheckerBuilder toCheckerBuilder();
}
diff --git a/checker/src/main/java/dev/cel/checker/CelCheckerBuilder.java b/checker/src/main/java/dev/cel/checker/CelCheckerBuilder.java
index 53827c387..a7d531f88 100644
--- a/checker/src/main/java/dev/cel/checker/CelCheckerBuilder.java
+++ b/checker/src/main/java/dev/cel/checker/CelCheckerBuilder.java
@@ -21,6 +21,7 @@
import com.google.protobuf.DescriptorProtos.FileDescriptorSet;
import com.google.protobuf.Descriptors.Descriptor;
import com.google.protobuf.Descriptors.FileDescriptor;
+import dev.cel.common.CelContainer;
import dev.cel.common.CelFunctionDecl;
import dev.cel.common.CelOptions;
import dev.cel.common.CelVarDecl;
@@ -34,12 +35,18 @@ public interface CelCheckerBuilder {
@CanIgnoreReturnValue
CelCheckerBuilder setOptions(CelOptions options);
+ /** Retrieves the currently configured {@link CelOptions} in the builder. */
+ CelOptions options();
+
/**
- * Set the {@code container} name to use as the namespace for resolving CEL expression variables
- * and functions.
+ * Set the {@link CelContainer} to use as the namespace for resolving CEL expression variables and
+ * functions.
*/
@CanIgnoreReturnValue
- CelCheckerBuilder setContainer(String container);
+ CelCheckerBuilder setContainer(CelContainer container);
+
+ /** Retrieves the currently configured {@link CelContainer} in the builder. */
+ CelContainer container();
/** Add variable and function {@code declarations} to the CEL environment. */
@CanIgnoreReturnValue
@@ -152,6 +159,14 @@ public interface CelCheckerBuilder {
@CanIgnoreReturnValue
CelCheckerBuilder setStandardEnvironmentEnabled(boolean value);
+ /**
+ * Override the standard declarations for the type-checker. This can be used to subset the
+ * standard environment to only expose the desired declarations to the type-checker. {@link
+ * #setStandardEnvironmentEnabled(boolean)} must be set to false for this to take effect.
+ */
+ @CanIgnoreReturnValue
+ CelCheckerBuilder setStandardDeclarations(CelStandardDeclarations standardDeclarations);
+
/** Adds one or more libraries for parsing and type-checking. */
@CanIgnoreReturnValue
CelCheckerBuilder addLibraries(CelCheckerLibrary... libraries);
diff --git a/checker/src/main/java/dev/cel/checker/CelCheckerLegacyImpl.java b/checker/src/main/java/dev/cel/checker/CelCheckerLegacyImpl.java
index 950c919e3..ceab0fa93 100644
--- a/checker/src/main/java/dev/cel/checker/CelCheckerLegacyImpl.java
+++ b/checker/src/main/java/dev/cel/checker/CelCheckerLegacyImpl.java
@@ -31,6 +31,7 @@
import com.google.protobuf.Descriptors.Descriptor;
import com.google.protobuf.Descriptors.FileDescriptor;
import dev.cel.common.CelAbstractSyntaxTree;
+import dev.cel.common.CelContainer;
import dev.cel.common.CelDescriptorUtil;
import dev.cel.common.CelFunctionDecl;
import dev.cel.common.CelIssue;
@@ -45,15 +46,16 @@
import dev.cel.common.internal.EnvVisitable;
import dev.cel.common.internal.EnvVisitor;
import dev.cel.common.internal.Errors;
+import dev.cel.common.types.CelProtoTypes;
import dev.cel.common.types.CelType;
import dev.cel.common.types.CelTypeProvider;
-import dev.cel.common.types.CelTypes;
import dev.cel.common.types.ProtoMessageTypeProvider;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;
+import org.jspecify.annotations.Nullable;
/**
* {@code CelChecker} implementation which uses the original CEL-Java APIs to provide a simple,
@@ -67,7 +69,7 @@
public final class CelCheckerLegacyImpl implements CelChecker, EnvVisitable {
private final CelOptions celOptions;
- private final String container;
+ private final CelContainer container;
private final ImmutableSet identDeclarations;
private final ImmutableSet functionDeclarations;
private final Optional expectedResultType;
@@ -75,11 +77,17 @@ public final class CelCheckerLegacyImpl implements CelChecker, EnvVisitable {
@SuppressWarnings("Immutable")
private final TypeProvider typeProvider;
+ private final CelTypeProvider celTypeProvider;
private final boolean standardEnvironmentEnabled;
- // Builder is mutable by design. APIs must make defensive copies in and out of this class.
+ private final CelStandardDeclarations overriddenStandardDeclarations;
+
+ // This does not affect the type-checking behavior in any manner.
@SuppressWarnings("Immutable")
- private final Builder checkerBuilder;
+ private final ImmutableSet checkerLibraries;
+
+ private final ImmutableSet fileDescriptors;
+ private final ImmutableSet protoTypeMasks;
@Override
public CelValidationResult check(CelAbstractSyntaxTree ast) {
@@ -98,9 +106,34 @@ public CelValidationResult check(CelAbstractSyntaxTree ast) {
return new CelValidationResult(checkedAst, ImmutableList.of());
}
+ @Override
+ public CelTypeProvider getTypeProvider() {
+ return this.celTypeProvider;
+ }
+
@Override
public CelCheckerBuilder toCheckerBuilder() {
- return new Builder(checkerBuilder);
+ CelCheckerBuilder builder =
+ new Builder()
+ .addIdentDeclarations(identDeclarations)
+ .setOptions(celOptions)
+ .setTypeProvider(celTypeProvider)
+ .setContainer(container)
+ .setStandardEnvironmentEnabled(standardEnvironmentEnabled)
+ .addFunctionDeclarations(functionDeclarations)
+ .addLibraries(checkerLibraries)
+ .addFileTypes(fileDescriptors)
+ .addProtoTypeMasks(protoTypeMasks);
+
+ if (expectedResultType.isPresent()) {
+ builder.setResultType(expectedResultType.get());
+ }
+
+ if (overriddenStandardDeclarations != null) {
+ builder.setStandardDeclarations(overriddenStandardDeclarations);
+ }
+
+ return builder;
}
@Override
@@ -131,6 +164,8 @@ private Env getEnv(Errors errors) {
Env env;
if (standardEnvironmentEnabled) {
env = Env.standard(errors, typeProvider, celOptions);
+ } else if (overriddenStandardDeclarations != null) {
+ env = Env.standard(overriddenStandardDeclarations, errors, typeProvider, celOptions);
} else {
env = Env.unconfigured(errors, typeProvider, celOptions);
}
@@ -153,12 +188,13 @@ public static final class Builder implements CelCheckerBuilder {
private final ImmutableSet.Builder messageTypes;
private final ImmutableSet.Builder fileTypes;
private final ImmutableSet.Builder celCheckerLibraries;
+ private CelContainer container;
private CelOptions celOptions;
- private String container;
private CelType expectedResultType;
private TypeProvider customTypeProvider;
private CelTypeProvider celTypeProvider;
private boolean standardEnvironmentEnabled;
+ private CelStandardDeclarations standardDeclarations;
@Override
public CelCheckerBuilder setOptions(CelOptions celOptions) {
@@ -167,12 +203,22 @@ public CelCheckerBuilder setOptions(CelOptions celOptions) {
}
@Override
- public CelCheckerBuilder setContainer(String container) {
+ public CelOptions options() {
+ return this.celOptions;
+ }
+
+ @Override
+ public CelCheckerBuilder setContainer(CelContainer container) {
checkNotNull(container);
this.container = container;
return this;
}
+ @Override
+ public CelContainer container() {
+ return this.container;
+ }
+
@Override
public CelCheckerBuilder addDeclarations(Decl... declarations) {
checkNotNull(declarations);
@@ -188,7 +234,7 @@ public CelCheckerBuilder addDeclarations(Iterable declarations) {
CelIdentDecl.Builder identBuilder =
CelIdentDecl.newBuilder()
.setName(decl.getName())
- .setType(CelTypes.typeToCelType(decl.getIdent().getType()))
+ .setType(CelProtoTypes.typeToCelType(decl.getIdent().getType()))
// Note: Setting doc and constant value exists for compatibility reason. This
// should not be set by the users.
.setDoc(decl.getIdent().getDoc());
@@ -267,7 +313,7 @@ public CelCheckerBuilder setResultType(CelType resultType) {
@Override
public CelCheckerBuilder setProtoResultType(Type resultType) {
checkNotNull(resultType);
- return setResultType(CelTypes.typeToCelType(resultType));
+ return setResultType(CelProtoTypes.typeToCelType(resultType));
}
@Override
@@ -314,7 +360,13 @@ public CelCheckerBuilder addFileTypes(FileDescriptorSet fileDescriptorSet) {
@Override
public CelCheckerBuilder setStandardEnvironmentEnabled(boolean value) {
- standardEnvironmentEnabled = value;
+ this.standardEnvironmentEnabled = value;
+ return this;
+ }
+
+ @Override
+ public CelCheckerBuilder setStandardDeclarations(CelStandardDeclarations standardDeclarations) {
+ this.standardDeclarations = checkNotNull(standardDeclarations);
return this;
}
@@ -331,43 +383,66 @@ public CelCheckerBuilder addLibraries(Iterable libr
return this;
}
- // The following getters exist for asserting immutability for collections held by this builder,
- // and shouldn't be exposed to the public.
+ @CanIgnoreReturnValue
+ Builder addIdentDeclarations(ImmutableSet identDeclarations) {
+ this.identDeclarations.addAll(identDeclarations);
+ return this;
+ }
+
+ // The following getters marked @VisibleForTesting exist for testing toCheckerBuilder copies
+ // over all properties. Do not expose these to public
@VisibleForTesting
- ImmutableSet.Builder getFunctionDecls() {
+ ImmutableSet.Builder functionDecls() {
return this.functionDeclarations;
}
@VisibleForTesting
- ImmutableSet.Builder getIdentDecls() {
+ ImmutableSet.Builder identDecls() {
return this.identDeclarations;
}
@VisibleForTesting
- ImmutableSet.Builder getProtoTypeMasks() {
+ ImmutableSet.Builder protoTypeMasks() {
return this.protoTypeMasks;
}
@VisibleForTesting
- ImmutableSet.Builder getMessageTypes() {
+ ImmutableSet.Builder messageTypes() {
return this.messageTypes;
}
@VisibleForTesting
- ImmutableSet.Builder getFileTypes() {
+ ImmutableSet.Builder fileTypes() {
return this.fileTypes;
}
@VisibleForTesting
- ImmutableSet.Builder getCheckerLibraries() {
+ ImmutableSet.Builder checkerLibraries() {
return this.celCheckerLibraries;
}
+ @VisibleForTesting
+ CelStandardDeclarations standardDeclarations() {
+ return this.standardDeclarations;
+ }
+
+ @VisibleForTesting
+ CelTypeProvider celTypeProvider() {
+ return this.celTypeProvider;
+ }
+
@Override
@CheckReturnValue
public CelCheckerLegacyImpl build() {
+ if (standardEnvironmentEnabled && standardDeclarations != null) {
+ throw new IllegalArgumentException(
+ "setStandardEnvironmentEnabled must be set to false to override standard"
+ + " declarations.");
+ }
+
// Add libraries, such as extensions
- celCheckerLibraries.build().forEach(celLibrary -> celLibrary.setCheckerOptions(this));
+ ImmutableSet checkerLibraries = celCheckerLibraries.build();
+ checkerLibraries.forEach(celLibrary -> celLibrary.setCheckerOptions(this));
// Configure the type provider.
ImmutableSet fileTypeSet = fileTypes.build();
@@ -381,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) {
@@ -422,8 +500,12 @@ public CelCheckerLegacyImpl build() {
functionDeclarations.build(),
Optional.fromNullable(expectedResultType),
legacyProvider,
+ messageTypeProvider,
standardEnvironmentEnabled,
- this);
+ standardDeclarations,
+ checkerLibraries,
+ fileTypeSet,
+ protoTypeMaskSet);
}
private Builder() {
@@ -434,51 +516,35 @@ private Builder() {
this.messageTypes = ImmutableSet.builder();
this.protoTypeMasks = ImmutableSet.builder();
this.celCheckerLibraries = ImmutableSet.builder();
- this.container = "";
- }
-
- private Builder(Builder builder) {
- // The following properties are either immutable or simple primitives, thus can be assigned
- // directly.
- this.celOptions = builder.celOptions;
- this.celTypeProvider = builder.celTypeProvider;
- this.container = builder.container;
- this.customTypeProvider = builder.customTypeProvider;
- this.expectedResultType = builder.expectedResultType;
- this.standardEnvironmentEnabled = builder.standardEnvironmentEnabled;
- // The following needs to be deep copied as they are collection builders
- this.functionDeclarations = deepCopy(builder.functionDeclarations);
- this.identDeclarations = deepCopy(builder.identDeclarations);
- this.fileTypes = deepCopy(builder.fileTypes);
- this.messageTypes = deepCopy(builder.messageTypes);
- this.protoTypeMasks = deepCopy(builder.protoTypeMasks);
- this.celCheckerLibraries = deepCopy(builder.celCheckerLibraries);
- }
-
- private static ImmutableSet.Builder deepCopy(ImmutableSet.Builder builderToCopy) {
- ImmutableSet.Builder newBuilder = ImmutableSet.builder();
- newBuilder.addAll(builderToCopy.build());
- return newBuilder;
+ this.container = CelContainer.ofName("");
}
}
private CelCheckerLegacyImpl(
CelOptions celOptions,
- String container,
+ CelContainer container,
ImmutableSet identDeclarations,
ImmutableSet functionDeclarations,
Optional expectedResultType,
TypeProvider typeProvider,
+ CelTypeProvider celTypeProvider,
boolean standardEnvironmentEnabled,
- Builder checkerBuilder) {
+ @Nullable CelStandardDeclarations overriddenStandardDeclarations,
+ ImmutableSet checkerLibraries,
+ ImmutableSet fileDescriptors,
+ ImmutableSet protoTypeMasks) {
this.celOptions = celOptions;
this.container = container;
this.identDeclarations = identDeclarations;
this.functionDeclarations = functionDeclarations;
this.expectedResultType = expectedResultType;
this.typeProvider = typeProvider;
+ this.celTypeProvider = celTypeProvider;
this.standardEnvironmentEnabled = standardEnvironmentEnabled;
- this.checkerBuilder = new Builder(checkerBuilder);
+ this.overriddenStandardDeclarations = overriddenStandardDeclarations;
+ this.checkerLibraries = checkerLibraries;
+ this.fileDescriptors = fileDescriptors;
+ this.protoTypeMasks = protoTypeMasks;
}
private static ImmutableList errorsToIssues(Errors errors) {
@@ -489,7 +555,11 @@ private static ImmutableList errorsToIssues(Errors errors) {
e -> {
Errors.SourceLocation loc = errors.getPositionLocation(e.position());
CelSourceLocation newLoc = CelSourceLocation.of(loc.line(), loc.column() - 1);
- return issueBuilder.setMessage(e.rawMessage()).setSourceLocation(newLoc).build();
+ return issueBuilder
+ .setExprId(e.exprId())
+ .setMessage(e.rawMessage())
+ .setSourceLocation(newLoc)
+ .build();
})
.collect(toImmutableList());
}
diff --git a/checker/src/main/java/dev/cel/checker/CelIdentDecl.java b/checker/src/main/java/dev/cel/checker/CelIdentDecl.java
index ac71523fe..60f747b77 100644
--- a/checker/src/main/java/dev/cel/checker/CelIdentDecl.java
+++ b/checker/src/main/java/dev/cel/checker/CelIdentDecl.java
@@ -23,8 +23,8 @@
import dev.cel.common.annotations.Internal;
import dev.cel.common.ast.CelConstant;
import dev.cel.common.ast.CelExprConverter;
+import dev.cel.common.types.CelProtoTypes;
import dev.cel.common.types.CelType;
-import dev.cel.common.types.CelTypes;
import java.util.Optional;
/**
@@ -57,7 +57,7 @@ public static Decl celIdentToDecl(CelIdentDecl identDecl) {
IdentDecl.Builder identBuilder =
IdentDecl.newBuilder()
.setDoc(identDecl.doc())
- .setType(CelTypes.celTypeToType(identDecl.type()));
+ .setType(CelProtoTypes.celTypeToType(identDecl.type()));
if (identDecl.constant().isPresent()) {
identBuilder.setValue(CelExprConverter.celConstantToExprConstant(identDecl.constant().get()));
}
diff --git a/checker/src/main/java/dev/cel/checker/CelProtoExprVisitor.java b/checker/src/main/java/dev/cel/checker/CelProtoExprVisitor.java
index cd5656642..08552d56f 100644
--- a/checker/src/main/java/dev/cel/checker/CelProtoExprVisitor.java
+++ b/checker/src/main/java/dev/cel/checker/CelProtoExprVisitor.java
@@ -18,7 +18,7 @@
import dev.cel.common.CelProtoAbstractSyntaxTree;
/**
- * CEL expression visitor implementation based on the {@link com.google.api.expr.Expr} proto.
+ * CEL expression visitor implementation based on the {@link dev.cel.expr.Expr} proto.
*
* Note: Prefer using {@link dev.cel.common.ast.CelExprVisitor} if protobuf support is not
* needed.
diff --git a/checker/src/main/java/dev/cel/checker/CelStandardDeclarations.java b/checker/src/main/java/dev/cel/checker/CelStandardDeclarations.java
new file mode 100644
index 000000000..53615604f
--- /dev/null
+++ b/checker/src/main/java/dev/cel/checker/CelStandardDeclarations.java
@@ -0,0 +1,1796 @@
+// Copyright 2024 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.checker;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
+import static java.util.Arrays.stream;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+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;
+import dev.cel.common.types.MapType;
+import dev.cel.common.types.SimpleType;
+import dev.cel.common.types.TypeParamType;
+import dev.cel.common.types.TypeType;
+import java.util.Optional;
+
+/**
+ * Standard declarations for CEL.
+ *
+ *
Refer to CEL
+ * Specification for comprehensive listing of functions and identifiers included in the standard
+ * environment.
+ */
+@Immutable
+public final class CelStandardDeclarations {
+ // Some shortcuts we use when building declarations.
+ private static final TypeParamType TYPE_PARAM_A = TypeParamType.create("A");
+ private static final ListType LIST_OF_A = ListType.create(TYPE_PARAM_A);
+ private static final TypeParamType TYPE_PARAM_B = TypeParamType.create("B");
+ private static final MapType MAP_OF_AB = MapType.create(TYPE_PARAM_A, TYPE_PARAM_B);
+
+ private final ImmutableSet celFunctionDecls;
+ private final ImmutableSet celIdentDecls;
+
+ /** Enumeration of Standard Functions. */
+ public enum StandardFunction {
+ // Deprecated - use {@link #IN}
+ OLD_IN(
+ true,
+ Operator.OLD_IN.getFunction(),
+ () ->
+ CelOverloadDecl.newGlobalOverload(
+ "in_list", "list membership", SimpleType.BOOL, TYPE_PARAM_A, LIST_OF_A),
+ () ->
+ CelOverloadDecl.newGlobalOverload(
+ "in_map", "map key membership", SimpleType.BOOL, TYPE_PARAM_A, MAP_OF_AB)),
+
+ // Deprecated - use {@link #NOT_STRICTLY_FALSE}
+ OLD_NOT_STRICTLY_FALSE(
+ true,
+ Operator.OLD_NOT_STRICTLY_FALSE.getFunction(),
+ () ->
+ CelOverloadDecl.newGlobalOverload(
+ "not_strictly_false",
+ "false if argument is false, true otherwise (including errors and unknowns)",
+ SimpleType.BOOL,
+ SimpleType.BOOL)),
+
+ // Internal (rewritten by macro)
+ IN(Operator.IN, Overload.InternalOperator.IN_LIST, Overload.InternalOperator.IN_MAP),
+ NOT_STRICTLY_FALSE(Operator.NOT_STRICTLY_FALSE, Overload.InternalOperator.NOT_STRICTLY_FALSE),
+ TYPE("type", Overload.InternalOperator.TYPE),
+
+ // Booleans
+ CONDITIONAL(Operator.CONDITIONAL, Overload.BooleanOperator.CONDITIONAL),
+ LOGICAL_NOT(Operator.LOGICAL_NOT, Overload.BooleanOperator.LOGICAL_NOT),
+ LOGICAL_OR(Operator.LOGICAL_OR, Overload.BooleanOperator.LOGICAL_OR),
+ LOGICAL_AND(Operator.LOGICAL_AND, Overload.BooleanOperator.LOGICAL_AND),
+
+ // Relations
+ EQUALS(Operator.EQUALS, Overload.Relation.EQUALS),
+ NOT_EQUALS(Operator.NOT_EQUALS, Overload.Relation.NOT_EQUALS),
+
+ // Arithmetic
+ ADD(
+ Operator.ADD,
+ Overload.Arithmetic.ADD_INT64,
+ Overload.Arithmetic.ADD_UINT64,
+ Overload.Arithmetic.ADD_DOUBLE,
+ Overload.Arithmetic.ADD_STRING,
+ Overload.Arithmetic.ADD_BYTES,
+ Overload.Arithmetic.ADD_LIST,
+ Overload.Arithmetic.ADD_TIMESTAMP_DURATION,
+ Overload.Arithmetic.ADD_DURATION_TIMESTAMP,
+ Overload.Arithmetic.ADD_DURATION_DURATION),
+ SUBTRACT(
+ Operator.SUBTRACT,
+ Overload.Arithmetic.SUBTRACT_INT64,
+ Overload.Arithmetic.SUBTRACT_UINT64,
+ Overload.Arithmetic.SUBTRACT_DOUBLE,
+ Overload.Arithmetic.SUBTRACT_TIMESTAMP_TIMESTAMP,
+ Overload.Arithmetic.SUBTRACT_TIMESTAMP_DURATION,
+ Overload.Arithmetic.SUBTRACT_DURATION_DURATION),
+ MULTIPLY(
+ Operator.MULTIPLY,
+ Overload.Arithmetic.MULTIPLY_INT64,
+ Overload.Arithmetic.MULTIPLY_UINT64,
+ Overload.Arithmetic.MULTIPLY_DOUBLE),
+ DIVIDE(
+ Operator.DIVIDE,
+ Overload.Arithmetic.DIVIDE_INT64,
+ Overload.Arithmetic.DIVIDE_UINT64,
+ Overload.Arithmetic.DIVIDE_DOUBLE),
+ MODULO(Operator.MODULO, Overload.Arithmetic.MODULO_INT64, Overload.Arithmetic.MODULO_UINT64),
+
+ NEGATE(Operator.NEGATE, Overload.Arithmetic.NEGATE_INT64, Overload.Arithmetic.NEGATE_DOUBLE),
+
+ // Index
+ INDEX(Operator.INDEX, Overload.Index.INDEX_LIST, Overload.Index.INDEX_MAP),
+
+ // Size
+ SIZE(
+ "size",
+ Overload.Size.SIZE_STRING,
+ Overload.Size.SIZE_BYTES,
+ Overload.Size.SIZE_LIST,
+ Overload.Size.SIZE_MAP,
+ Overload.Size.STRING_SIZE,
+ Overload.Size.BYTES_SIZE,
+ Overload.Size.LIST_SIZE,
+ Overload.Size.MAP_SIZE),
+
+ // Conversions
+ INT(
+ "int",
+ Overload.Conversions.INT64_TO_INT64,
+ Overload.Conversions.UINT64_TO_INT64,
+ Overload.Conversions.DOUBLE_TO_INT64,
+ Overload.Conversions.STRING_TO_INT64,
+ Overload.Conversions.TIMESTAMP_TO_INT64),
+ UINT(
+ "uint",
+ Overload.Conversions.UINT64_TO_UINT64,
+ Overload.Conversions.INT64_TO_UINT64,
+ Overload.Conversions.DOUBLE_TO_UINT64,
+ Overload.Conversions.STRING_TO_UINT64),
+ DOUBLE(
+ "double",
+ Overload.Conversions.DOUBLE_TO_DOUBLE,
+ Overload.Conversions.INT64_TO_DOUBLE,
+ Overload.Conversions.UINT64_TO_DOUBLE,
+ Overload.Conversions.STRING_TO_DOUBLE),
+ STRING(
+ "string",
+ Overload.Conversions.STRING_TO_STRING,
+ Overload.Conversions.INT64_TO_STRING,
+ Overload.Conversions.UINT64_TO_STRING,
+ Overload.Conversions.DOUBLE_TO_STRING,
+ Overload.Conversions.BOOL_TO_STRING,
+ Overload.Conversions.BYTES_TO_STRING,
+ Overload.Conversions.TIMESTAMP_TO_STRING,
+ Overload.Conversions.DURATION_TO_STRING),
+ BYTES("bytes", Overload.Conversions.BYTES_TO_BYTES, Overload.Conversions.STRING_TO_BYTES),
+ DYN("dyn", Overload.Conversions.TO_DYN),
+ DURATION(
+ "duration",
+ Overload.Conversions.DURATION_TO_DURATION,
+ Overload.Conversions.STRING_TO_DURATION),
+ TIMESTAMP(
+ "timestamp",
+ Overload.Conversions.STRING_TO_TIMESTAMP,
+ Overload.Conversions.TIMESTAMP_TO_TIMESTAMP,
+ Overload.Conversions.INT64_TO_TIMESTAMP),
+ BOOL("bool", Overload.Conversions.BOOL_TO_BOOL, Overload.Conversions.STRING_TO_BOOL),
+
+ // String matchers
+ MATCHES("matches", Overload.StringMatchers.MATCHES, Overload.StringMatchers.MATCHES_STRING),
+ CONTAINS("contains", Overload.StringMatchers.CONTAINS_STRING),
+ ENDS_WITH("endsWith", Overload.StringMatchers.ENDS_WITH_STRING),
+ STARTS_WITH("startsWith", Overload.StringMatchers.STARTS_WITH_STRING),
+
+ // Date/time operations
+ GET_FULL_YEAR(
+ "getFullYear",
+ Overload.DateTime.TIMESTAMP_TO_YEAR,
+ Overload.DateTime.TIMESTAMP_TO_YEAR_WITH_TZ),
+ GET_MONTH(
+ "getMonth",
+ Overload.DateTime.TIMESTAMP_TO_MONTH,
+ Overload.DateTime.TIMESTAMP_TO_MONTH_WITH_TZ),
+ GET_DAY_OF_YEAR(
+ "getDayOfYear",
+ Overload.DateTime.TIMESTAMP_TO_DAY_OF_YEAR,
+ Overload.DateTime.TIMESTAMP_TO_DAY_OF_YEAR_WITH_TZ),
+ GET_DAY_OF_MONTH(
+ "getDayOfMonth",
+ Overload.DateTime.TIMESTAMP_TO_DAY_OF_MONTH,
+ Overload.DateTime.TIMESTAMP_TO_DAY_OF_MONTH_WITH_TZ),
+ GET_DATE(
+ "getDate",
+ Overload.DateTime.TIMESTAMP_TO_DAY_OF_MONTH_1_BASED,
+ Overload.DateTime.TIMESTAMP_TO_DAY_OF_MONTH_1_BASED_WITH_TZ),
+ GET_DAY_OF_WEEK(
+ "getDayOfWeek",
+ Overload.DateTime.TIMESTAMP_TO_DAY_OF_WEEK,
+ Overload.DateTime.TIMESTAMP_TO_DAY_OF_WEEK_WITH_TZ),
+ GET_HOURS(
+ "getHours",
+ Overload.DateTime.TIMESTAMP_TO_HOURS,
+ Overload.DateTime.TIMESTAMP_TO_HOURS_WITH_TZ,
+ Overload.DateTime.DURATION_TO_HOURS),
+ GET_MINUTES(
+ "getMinutes",
+ Overload.DateTime.TIMESTAMP_TO_MINUTES,
+ Overload.DateTime.TIMESTAMP_TO_MINUTES_WITH_TZ,
+ Overload.DateTime.DURATION_TO_MINUTES),
+ GET_SECONDS(
+ "getSeconds",
+ Overload.DateTime.TIMESTAMP_TO_SECONDS,
+ Overload.DateTime.TIMESTAMP_TO_SECONDS_WITH_TZ,
+ Overload.DateTime.DURATION_TO_SECONDS),
+ GET_MILLISECONDS(
+ "getMilliseconds",
+ Overload.DateTime.TIMESTAMP_TO_MILLISECONDS,
+ Overload.DateTime.TIMESTAMP_TO_MILLISECONDS_WITH_TZ,
+ Overload.DateTime.DURATION_TO_MILLISECONDS),
+
+ // Comparisons
+ LESS(
+ Operator.LESS,
+ Overload.Comparison.LESS_BOOL,
+ Overload.Comparison.LESS_INT64,
+ Overload.Comparison.LESS_UINT64,
+ Overload.Comparison.LESS_DOUBLE,
+ Overload.Comparison.LESS_STRING,
+ Overload.Comparison.LESS_BYTES,
+ Overload.Comparison.LESS_TIMESTAMP,
+ Overload.Comparison.LESS_DURATION,
+ Overload.Comparison.LESS_INT64_UINT64,
+ Overload.Comparison.LESS_UINT64_INT64,
+ Overload.Comparison.LESS_INT64_DOUBLE,
+ Overload.Comparison.LESS_DOUBLE_INT64,
+ Overload.Comparison.LESS_UINT64_DOUBLE,
+ Overload.Comparison.LESS_DOUBLE_UINT64),
+ LESS_EQUALS(
+ Operator.LESS_EQUALS,
+ Overload.Comparison.LESS_EQUALS_BOOL,
+ Overload.Comparison.LESS_EQUALS_INT64,
+ Overload.Comparison.LESS_EQUALS_UINT64,
+ Overload.Comparison.LESS_EQUALS_DOUBLE,
+ Overload.Comparison.LESS_EQUALS_STRING,
+ Overload.Comparison.LESS_EQUALS_BYTES,
+ Overload.Comparison.LESS_EQUALS_TIMESTAMP,
+ Overload.Comparison.LESS_EQUALS_DURATION,
+ Overload.Comparison.LESS_EQUALS_INT64_UINT64,
+ Overload.Comparison.LESS_EQUALS_UINT64_INT64,
+ Overload.Comparison.LESS_EQUALS_INT64_DOUBLE,
+ Overload.Comparison.LESS_EQUALS_DOUBLE_INT64,
+ Overload.Comparison.LESS_EQUALS_UINT64_DOUBLE,
+ Overload.Comparison.LESS_EQUALS_DOUBLE_UINT64),
+ GREATER(
+ Operator.GREATER,
+ Overload.Comparison.GREATER_BOOL,
+ Overload.Comparison.GREATER_INT64,
+ Overload.Comparison.GREATER_UINT64,
+ Overload.Comparison.GREATER_DOUBLE,
+ Overload.Comparison.GREATER_STRING,
+ Overload.Comparison.GREATER_BYTES,
+ Overload.Comparison.GREATER_TIMESTAMP,
+ Overload.Comparison.GREATER_DURATION,
+ Overload.Comparison.GREATER_INT64_UINT64,
+ Overload.Comparison.GREATER_UINT64_INT64,
+ Overload.Comparison.GREATER_INT64_DOUBLE,
+ Overload.Comparison.GREATER_DOUBLE_INT64,
+ Overload.Comparison.GREATER_UINT64_DOUBLE,
+ Overload.Comparison.GREATER_DOUBLE_UINT64),
+ GREATER_EQUALS(
+ Operator.GREATER_EQUALS,
+ Overload.Comparison.GREATER_EQUALS_BOOL,
+ Overload.Comparison.GREATER_EQUALS_INT64,
+ Overload.Comparison.GREATER_EQUALS_UINT64,
+ Overload.Comparison.GREATER_EQUALS_DOUBLE,
+ Overload.Comparison.GREATER_EQUALS_STRING,
+ Overload.Comparison.GREATER_EQUALS_BYTES,
+ Overload.Comparison.GREATER_EQUALS_TIMESTAMP,
+ Overload.Comparison.GREATER_EQUALS_DURATION,
+ Overload.Comparison.GREATER_EQUALS_INT64_UINT64,
+ Overload.Comparison.GREATER_EQUALS_UINT64_INT64,
+ Overload.Comparison.GREATER_EQUALS_INT64_DOUBLE,
+ Overload.Comparison.GREATER_EQUALS_DOUBLE_INT64,
+ Overload.Comparison.GREATER_EQUALS_UINT64_DOUBLE,
+ Overload.Comparison.GREATER_EQUALS_DOUBLE_UINT64),
+ ;
+
+ private final String functionName;
+ private final CelFunctionDecl celFunctionDecl;
+ private final ImmutableSet