Add shorthand type specifier syntax for policy configs

PiperOrigin-RevId: 963769585

Author: l46kok

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

@@ -97,6 +97,7 @@ java_library(
     name = "environment",
     srcs = [
         "CelEnvironment.java",
+        "TypeSpecifierParser.java",
     ],
     tags = [
     ],
@@ -111,6 +112,7 @@ java_library(
         "//common:container",
         "//common:options",
         "//common:source",
+        "//common/formats:parser_context",
         "//common/types",
         "//common/types:type_providers",
         "//compiler:compiler_builder",

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

@@ -692,6 +692,19 @@ public static TypeDecl create(String name) {
       return newBuilder().setName(name).build();
     }
 
+    /**
+     * Parses a type specifier shorthand string (e.g. {@code "list<int>"}, {@code "map<string,
+     * dyn>"}, {@code "list<~T>"}) into a {@link TypeDecl}.
+     */
+    public static TypeDecl parse(String typeSpecifier) {
+      return TypeSpecifierParser.parse(typeSpecifier);
+    }
+
+    /** Creates a new {@link TypeDecl} representing a type parameter with the provided name. */
+    public static TypeDecl ofTypeParam(String typeParamName) {
+      return newBuilder().setName(typeParamName).setIsTypeParam(true).build();
+    }
+
     public static TypeDecl.Builder newBuilder() {
       return new AutoValue_CelEnvironment_TypeDecl.Builder().setIsTypeParam(false);
     }
@@ -747,6 +760,35 @@ public CelType toCelType(CelTypeProvider celTypeProvider) {
               .orElseThrow(() -> new IllegalArgumentException("Undefined type name: " + name()));
       }
     }
+
+    /**
+     * Formats this type declaration into its shorthand type specifier string representation (e.g.
+     * {@code "map<string, int>"}, {@code "list<~T>"}).
+     */
+    public String toSpecifierString() {
+      StringBuilder sb = new StringBuilder();
+      formatSpecifier(this, sb);
+      return sb.toString();
+    }
+
+    private static void formatSpecifier(TypeDecl td, StringBuilder sb) {
+      if (td.isTypeParam()) {
+        sb.append('~').append(td.name());
+        return;
+      }
+      sb.append(td.name());
+      if (td.params().isEmpty()) {
+        return;
+      }
+      sb.append('<');
+      for (int i = 0; i < td.params().size(); i++) {
+        if (i > 0) {
+          sb.append(", ");
+        }
+        formatSpecifier(td.params().get(i), sb);
+      }
+      sb.append('>');
+    }
   }
 
   /** Represents a feature flag that can be enabled in the environment. */

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

@@ -22,11 +22,11 @@
 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 com.google.errorprone.annotations.CheckReturnValue;
 import dev.cel.bundle.CelEnvironment.Alias;
 import dev.cel.bundle.CelEnvironment.ContextVariable;
 import dev.cel.bundle.CelEnvironment.ExtensionConfig;
@@ -60,7 +60,7 @@
  */
 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);
+  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 =
@@ -71,9 +71,44 @@ public final class CelEnvironmentYamlParser {
   private static final Alias ERROR_ALIAS =
       Alias.newBuilder().setAlias(ERROR).setQualifiedName(ERROR).build();
 
-  /** Generates a new instance of {@code CelEnvironmentYamlParser}. */
+  private final boolean enableTypeSpecifiers;
+
+  /** Generates a new instance of {@code CelEnvironmentYamlParser} with default options. */
   public static CelEnvironmentYamlParser newInstance() {
-    return new CelEnvironmentYamlParser();
+    return newBuilder().build();
+  }
+
+  /** Creates a new builder to configure and construct a {@link CelEnvironmentYamlParser}. */
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  /** Builder for {@link CelEnvironmentYamlParser}. */
+  public static final class Builder {
+    private boolean enableTypeSpecifiers = false;
+
+    /**
+     * Configures the parser to allow for shorthand type specifiers (e.g. {@code "list<int>"},
+     * {@code "map<string, dyn>"}, {@code "list<~T>"}) in addition to structured mapping
+     * declarations.
+     */
+    @CanIgnoreReturnValue
+    public Builder enableTypeSpecifiers(boolean enable) {
+      this.enableTypeSpecifiers = enable;
+      return this;
+    }
+
+    /** Builds a new instance of {@link CelEnvironmentYamlParser}. */
+    @CheckReturnValue
+    public CelEnvironmentYamlParser build() {
+      return new CelEnvironmentYamlParser(enableTypeSpecifiers);
+    }
+
+    private Builder() {}
+  }
+
+  private CelEnvironmentYamlParser(boolean enableTypeSpecifiers) {
+    this.enableTypeSpecifiers = enableTypeSpecifiers;
   }
 
   /** Parsers the input {@code environmentYamlSource} and returns a {@link CelEnvironment}. */
@@ -335,6 +370,7 @@ private ContextVariable parseContextVariable(ParserContext<Node> ctx, Node node)
       Node valueNode = nodeTuple.getValueNode();
       String keyName = ((ScalarNode) keyNode).getValue();
       switch (keyName) {
+        case "type":
         case "type_name":
           typeName = newString(ctx, valueNode);
           break;
@@ -478,7 +514,7 @@ private FunctionDecl parseFunction(ParserContext<Node> ctx, Node node) {
     return builder.build();
   }
 
-  private static ImmutableSet<OverloadDecl> parseOverloads(ParserContext<Node> ctx, Node node) {
+  private ImmutableSet<OverloadDecl> parseOverloads(ParserContext<Node> ctx, Node node) {
     long listId = ctx.collectMetadata(node);
     ImmutableSet.Builder<OverloadDecl> overloadSetBuilder = ImmutableSet.builder();
     if (!assertYamlType(ctx, listId, node, YamlNodeType.LIST)) {
@@ -553,8 +589,7 @@ private static ImmutableList<String> parseOverloadExamples(ParserContext<Node> c
     return builder.build();
   }
 
-  private static ImmutableList<TypeDecl> parseOverloadArguments(
-      ParserContext<Node> ctx, Node node) {
+  private ImmutableList<TypeDecl> parseOverloadArguments(ParserContext<Node> ctx, Node node) {
     long listValueId = ctx.collectMetadata(node);
     if (!assertYamlType(ctx, listValueId, node, YamlNodeType.LIST)) {
       return ImmutableList.of();
@@ -791,7 +826,7 @@ private static ImmutableSet<OverloadSelector> parseFunctionOverloadsSelector(
   }
 
   @CanIgnoreReturnValue
-  private static TypeDecl.Builder parseInlinedTypeDecl(
+  private TypeDecl.Builder parseInlinedTypeDecl(
       ParserContext<Node> ctx, long keyId, Node keyNode, Node valueNode, TypeDecl.Builder builder) {
     if (!assertYamlType(ctx, keyId, keyNode, YamlNodeType.STRING, YamlNodeType.TEXT)) {
       return builder;
@@ -800,24 +835,38 @@ private static TypeDecl.Builder parseInlinedTypeDecl(
     // 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);
+            Tag.MAP,
+            /* value= */ ImmutableList.of(new NodeTuple(keyNode, valueNode)),
+            FlowStyle.AUTO);
 
     return parseTypeDeclFields(ctx, mapNode, builder);
   }
 
-  private static TypeDecl parseTypeDecl(ParserContext<Node> ctx, Node node) {
-    TypeDecl.Builder builder = TypeDecl.newBuilder();
+  private TypeDecl parseTypeDecl(ParserContext<Node> ctx, Node node) {
     long id = ctx.collectMetadata(node);
+    if (enableTypeSpecifiers) {
+      if (validateYamlType(node, YamlNodeType.STRING, YamlNodeType.TEXT)) {
+        return TypeSpecifierParser.parse(ctx, id, newString(ctx, node));
+      }
+      if (validateYamlType(node, YamlNodeType.MAP)) {
+        TypeDecl.Builder builder = TypeDecl.newBuilder();
+        return parseTypeDeclFields(ctx, (MappingNode) node, builder).build();
+      }
+      assertYamlType(ctx, id, node, YamlNodeType.STRING, YamlNodeType.TEXT, YamlNodeType.MAP);
+      return ERROR_TYPE_DECL;
+    }
+
     if (!assertYamlType(ctx, id, node, YamlNodeType.MAP)) {
       return ERROR_TYPE_DECL;
     }
 
+    TypeDecl.Builder builder = TypeDecl.newBuilder();
     MappingNode mapNode = (MappingNode) node;
     return parseTypeDeclFields(ctx, mapNode, builder).build();
   }
 
   @CanIgnoreReturnValue
-  private static TypeDecl.Builder parseTypeDeclFields(
+  private TypeDecl.Builder parseTypeDeclFields(
       ParserContext<Node> ctx, MappingNode mapNode, TypeDecl.Builder builder) {
     for (NodeTuple nodeTuple : mapNode.getValue()) {
       Node keyNode = nodeTuple.getKeyNode();
@@ -943,6 +992,4 @@ private CelEnvironment.Builder parseConfig(ParserContext<Node> ctx, Node node) {
       return builder;
     }
   }
-
-  private CelEnvironmentYamlParser() {}
 }