Add support for importing/exporting common limits to YAML environment configs.

PiperOrigin-RevId: 874676207

Author: jnthntatum

bundle/BUILD.bazel

@@ -27,6 +27,5 @@ java_library(
 
 java_library(
     name = "environment_exporter",
-    visibility = ["//:internal"],
     exports = ["//bundle/src/main/java/dev/cel/bundle:environment_exporter"],
 )

bundle/src/main/java/dev/cel/bundle/BUILD.bazel

@@ -126,13 +126,15 @@ java_library(
         ":environment",
         "//:auto_value",
         "//bundle:cel",
+        "//checker:checker_builder",
         "//checker:standard_decl",
         "//common:compiler_common",
         "//common:options",
         "//common/internal:env_visitor",
         "//common/types:cel_proto_types",
         "//common/types:cel_types",
         "//common/types:type_providers",
+        "//compiler:compiler_builder",
         "//extensions",
         "//extensions:extension_library",
         "//parser:macro",

bundle/src/main/java/dev/cel/bundle/CelEnvironment.java

@@ -48,6 +48,7 @@
 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;
@@ -108,6 +109,12 @@ public abstract class CelEnvironment {
   /** Standard library subset (which macros, functions to include/exclude) */
   public abstract Optional<LibrarySubset> standardLibrarySubset();
 
+  /** Feature flags to enable in the environment. */
+  public abstract ImmutableSet<FeatureFlag> features();
+
+  /** Limits to set in the environment. */
+  public abstract ImmutableSet<Limit> limits();
+
   /** Builder for {@link CelEnvironment}. */
   @AutoValue.Builder
   public abstract static class Builder {
@@ -159,6 +166,20 @@ public Builder setFunctions(FunctionDecl... functions) {
 
     public abstract Builder setStandardLibrarySubset(LibrarySubset stdLibrarySubset);
 
+    @CanIgnoreReturnValue
+    public Builder setFeatures(FeatureFlag... featureFlags) {
+      return setFeatures(ImmutableSet.copyOf(featureFlags));
+    }
+
+    public abstract Builder setFeatures(ImmutableSet<FeatureFlag> featureFlags);
+
+    @CanIgnoreReturnValue
+    public Builder setLimits(Limit... limits) {
+      return setLimits(ImmutableSet.copyOf(limits));
+    }
+
+    public abstract Builder setLimits(ImmutableSet<Limit> limits);
+
     abstract CelEnvironment autoBuild();
 
     @CheckReturnValue
@@ -188,18 +209,22 @@ public static Builder newBuilder() {
         .setDescription("")
         .setContainer(CelContainer.ofName(""))
         .setVariables(ImmutableSet.of())
-        .setFunctions(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()
               .setContainer(container())
+              .setOptions(celOptions)
               .setTypeProvider(celTypeProvider)
               .addVarDeclarations(
                   variables().stream()
@@ -222,19 +247,46 @@ public CelCompiler extend(CelCompiler celCompiler, CelOptions celOptions)
 
   /** 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);
 
-      CelRuntimeBuilder celRuntimeBuilder = cel.toRuntimeBuilder();
-      addAllRuntimeExtensions(celRuntimeBuilder, celOptions);
+      CelRuntime celRuntime = extendRuntime(cel, celOptions);
 
-      return CelFactory.combine(celCompiler, celRuntimeBuilder.build());
+      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()) {
+      if (featureFlag.name().equals("cel.feature.macro_call_tracking")) {
+        optionsBuilder.populateMacroCalls(featureFlag.enabled());
+      } else if (featureFlag.name().equals("cel.feature.backtick_escape_syntax")) {
+        optionsBuilder.enableQuotedIdentifierSyntax(featureFlag.enabled());
+      } else if (featureFlag.name().equals("cel.feature.cross_type_numeric_comparisons")) {
+        optionsBuilder.enableHeterogeneousNumericComparisons(featureFlag.enabled());
+      } else {
+        throw new IllegalArgumentException("Unknown feature flag: " + featureFlag.name());
+      }
+    }
+    for (Limit limit : limits()) {
+      if (limit.name().equals("cel.limit.expression_code_points")) {
+        optionsBuilder.maxExpressionCodePointSize(limit.value());
+      } else if (limit.name().equals("cel.limit.parse_error_recovery")) {
+        optionsBuilder.maxParseErrorRecoveryLimit(limit.value());
+      } else if (limit.name().equals("cel.limit.parse_recursion_depth")) {
+        optionsBuilder.maxParseRecursionDepth(limit.value());
+      } else {
+        throw new IllegalArgumentException("Unknown limit: " + limit.name());
+      }
+    }
+    return optionsBuilder.build();
+  }
+
   private void addAllCompilerExtensions(
       CelCompilerBuilder celCompilerBuilder, CelOptions celOptions) {
     // TODO: Add capability to accept user defined exceptions
@@ -250,7 +302,9 @@ private void addAllCompilerExtensions(
     }
   }
 
-  private void addAllRuntimeExtensions(CelRuntimeBuilder celRuntimeBuilder, CelOptions celOptions) {
+  private CelRuntime extendRuntime(CelRuntime celRuntime, CelOptions celOptions) {
+    CelRuntimeBuilder celRuntimeBuilder = celRuntime.toRuntimeBuilder();
+    celRuntimeBuilder.setOptions(celOptions);
     // TODO: Add capability to accept user defined exceptions
     for (ExtensionConfig extensionConfig : extensions()) {
       CanonicalCelExtension extension = getExtensionOrThrow(extensionConfig.name());
@@ -262,6 +316,7 @@ private void addAllRuntimeExtensions(CelRuntimeBuilder celRuntimeBuilder, CelOpt
         celRuntimeBuilder.addLibraries(celRuntimeLibrary);
       }
     }
+    return celRuntimeBuilder.build();
   }
 
   private void applyStandardLibrarySubset(CelCompilerBuilder compilerBuilder) {
@@ -625,6 +680,39 @@ public CelType toCelType(CelTypeProvider celTypeProvider) {
     }
   }
 
+  /** Represents a feature flag that can be enabled in the environment. */
+  @AutoValue
+  public abstract static class FeatureFlag {
+    /** Normalized name of the feature flag. */
+    public abstract String name();
+
+    /** Whether the feature is enabled or disabled. */
+    public abstract boolean enabled();
+
+    public static FeatureFlag create(String name, boolean enabled) {
+      return new AutoValue_CelEnvironment_FeatureFlag(name, enabled);
+    }
+  }
+
+  /**
+   * Represents a configurable limit in the environment.
+   *
+   * <p>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.

bundle/src/main/java/dev/cel/bundle/CelEnvironmentExporter.java

@@ -22,6 +22,7 @@
 import dev.cel.expr.Decl.FunctionDecl;
 import dev.cel.expr.Decl.FunctionDecl.Overload;
 import com.google.auto.value.AutoValue;
+import com.google.common.base.Preconditions;
 import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ListMultimap;
@@ -30,6 +31,7 @@
 import dev.cel.bundle.CelEnvironment.LibrarySubset;
 import dev.cel.bundle.CelEnvironment.LibrarySubset.FunctionSelector;
 import dev.cel.bundle.CelEnvironment.OverloadDecl;
+import dev.cel.checker.CelCheckerBuilder;
 import dev.cel.checker.CelStandardDeclarations.StandardFunction;
 import dev.cel.checker.CelStandardDeclarations.StandardIdentifier;
 import dev.cel.common.CelFunctionDecl;
@@ -41,6 +43,7 @@
 import dev.cel.common.types.CelProtoTypes;
 import dev.cel.common.types.CelType;
 import dev.cel.common.types.CelTypes;
+import dev.cel.compiler.CelCompiler;
 import dev.cel.extensions.CelExtensionLibrary;
 import dev.cel.extensions.CelExtensions;
 import dev.cel.parser.CelMacro;
@@ -161,9 +164,24 @@ public static CelEnvironmentExporter.Builder newBuilder() {
    * </ul>
    */
   public CelEnvironment export(Cel cel) {
-    CelEnvironment.Builder envBuilder =
-        CelEnvironment.newBuilder().setContainer(cel.toCheckerBuilder().container());
+    return export((CelCompiler) cel);
+  }
 
+  /**
+   * Exports a {@link CelEnvironment} that describes the configuration of the given {@link
+   * CelCompiler} instance.
+   *
+   * <p>The exported environment includes:
+   *
+   * <ul>
+   *   <li>Standard library subset: functions and their overloads that are either included or
+   *       excluded from the standard library.
+   *   <li>Extension libraries: names and versions of the extension libraries that are used.
+   *   <li>Custom declarations: functions and variables that are not part of the standard library or
+   *       any of the extension libraries.
+   * </ul>
+   */
+  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.
     //
@@ -172,6 +190,14 @@ public CelEnvironment export(Cel cel) {
     //
     // Whatever is left will be included in the Environment as custom declarations.
 
+    // Checker builder is used to access some parts of the config not exposed in the EnvVisitable
+    // interface.
+    CelCheckerBuilder checkerBuilder = cel.toCheckerBuilder();
+
+    CelEnvironment.Builder envBuilder =
+        CelEnvironment.newBuilder().setContainer(checkerBuilder.container());
+    addOptions(envBuilder, checkerBuilder.options());
+
     Set<Object> inventory = new HashSet<>();
     collectInventory(inventory, cel);
     addExtensionConfigsAndRemoveFromInventory(envBuilder, inventory);
@@ -180,11 +206,46 @@ public CelEnvironment export(Cel cel) {
     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<CelEnvironment.FeatureFlag> 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<CelEnvironment.Limit> 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<Object> inventory, Cel cel) {
+  private void collectInventory(Set<Object> inventory, CelCompiler cel) {
+    Preconditions.checkArgument(cel instanceof EnvVisitable);
     ((EnvVisitable) cel)
         .accept(
             new EnvVisitor() {