Rename MutableAst to AstMutator

PiperOrigin-RevId: 623249439

Author: l46kok

…n/java/dev/cel/optimizer/MutableAst.java …n/java/dev/cel/optimizer/AstMutator.javaoptimizer/src/main/java/dev/cel/optimizer/MutableAst.java renamed to optimizer/src/main/java/dev/cel/optimizer/AstMutator.java optimizer/src/main/java/dev/cel/optimizer/MutableAst.java renamed to optimizer/src/main/java/dev/cel/optimizer/AstMutator.java

@@ -51,14 +51,14 @@
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
-/** MutableAst contains logic for mutating a {@link CelAbstractSyntaxTree}. */
+/** AstMutator contains logic for mutating a {@link CelAbstractSyntaxTree}. */
 @Immutable
-public final class MutableAst {
+public final class AstMutator {
   private static final ExprIdGenerator NO_OP_ID_GENERATOR = id -> id;
   private final long iterationLimit;
 
   /**
-   * Returns a new instance of a Mutable AST with the iteration limit set.
+   * Returns a new instance of a AST Mutator with the iteration limit set.
    *
    * <p>Mutation is performed by walking the existing AST until the expression node to replace is
    * found, then the new subtree is walked to complete the mutation. Visiting of each node
@@ -67,11 +67,11 @@ public final class MutableAst {
    *
    * @param iterationLimit Must be greater than 0.
    */
-  public static MutableAst newInstance(long iterationLimit) {
-    return new MutableAst(iterationLimit);
+  public static AstMutator newInstance(long iterationLimit) {
+    return new AstMutator(iterationLimit);
   }
 
-  private MutableAst(long iterationLimit) {
+  private AstMutator(long iterationLimit) {
     Preconditions.checkState(iterationLimit > 0L);
     this.iterationLimit = iterationLimit;
   }
@@ -773,15 +773,15 @@ private CelExpr.Builder mutateExpr(
       CelExpr.Builder root,
       CelExpr.Builder newExpr,
       long exprIdToReplace) {
-    MutableExprVisitor mutableAst =
+    MutableExprVisitor astMutator =
         MutableExprVisitor.newInstance(idGenerator, newExpr, exprIdToReplace, iterationLimit);
-    return mutableAst.visit(root);
+    return astMutator.visit(root);
   }
 
   private CelExpr.Builder renumberExprIds(ExprIdGenerator idGenerator, CelExpr.Builder root) {
-    MutableExprVisitor mutableAst =
+    MutableExprVisitor astMutator =
         MutableExprVisitor.newInstance(idGenerator, root, Integer.MIN_VALUE, iterationLimit);
-    return mutableAst.visit(root);
+    return astMutator.visit(root);
   }
 
   private static long getMaxId(CelAbstractSyntaxTree ast) {
@@ -831,7 +831,7 @@ public abstract static class MangledComprehensionAst {
     private static MangledComprehensionAst of(
         CelAbstractSyntaxTree ast,
         ImmutableMap<MangledComprehensionName, MangledComprehensionType> mangledComprehensionMap) {
-      return new AutoValue_MutableAst_MangledComprehensionAst(ast, mangledComprehensionMap);
+      return new AutoValue_AstMutator_MangledComprehensionAst(ast, mangledComprehensionMap);
     }
   }
 
@@ -851,7 +851,7 @@ public abstract static class MangledComprehensionType {
     private static MangledComprehensionType of(
         Optional<CelType> iterVarType, Optional<CelType> resultType) {
       Preconditions.checkArgument(iterVarType.isPresent() || resultType.isPresent());
-      return new AutoValue_MutableAst_MangledComprehensionType(iterVarType, resultType);
+      return new AutoValue_AstMutator_MangledComprehensionType(iterVarType, resultType);
     }
   }
 
@@ -869,7 +869,7 @@ public abstract static class MangledComprehensionName {
     public abstract String resultName();
 
     private static MangledComprehensionName of(String iterVarName, String resultName) {
-      return new AutoValue_MutableAst_MangledComprehensionName(iterVarName, resultName);
+      return new AutoValue_AstMutator_MangledComprehensionName(iterVarName, resultName);
     }
   }
 
@@ -889,7 +889,7 @@ abstract static class BindMacro {
     abstract CelExpr bindMacro();
 
     private static BindMacro of(CelExpr bindExpr, CelExpr bindMacro) {
-      return new AutoValue_MutableAst_BindMacro(bindExpr, bindMacro);
+      return new AutoValue_AstMutator_BindMacro(bindExpr, bindMacro);
     }
   }
 }

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

@@ -79,7 +79,7 @@ java_library(
 java_library(
     name = "mutable_ast",
     srcs = [
-        "MutableAst.java",
+        "AstMutator.java",
         "MutableExprVisitor.java",
     ],
     tags = [

optimizer/src/main/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizer.java

@@ -32,9 +32,9 @@
 import dev.cel.common.navigation.CelNavigableAst;
 import dev.cel.common.navigation.CelNavigableExpr;
 import dev.cel.extensions.CelOptionalLibrary.Function;
+import dev.cel.optimizer.AstMutator;
 import dev.cel.optimizer.CelAstOptimizer;
 import dev.cel.optimizer.CelOptimizationException;
-import dev.cel.optimizer.MutableAst;
 import dev.cel.parser.Operator;
 import dev.cel.runtime.CelEvaluationException;
 import java.util.Collection;
@@ -73,7 +73,7 @@ public static ConstantFoldingOptimizer newInstance(
           0, Optional.empty(), Function.OPTIONAL_NONE.getFunction(), ImmutableList.of());
 
   private final ConstantFoldingOptions constantFoldingOptions;
-  private final MutableAst mutableAst;
+  private final AstMutator astMutator;
 
   @Override
   public OptimizationResult optimize(CelNavigableAst navigableAst, Cel cel)
@@ -117,7 +117,7 @@ public OptimizationResult optimize(CelNavigableAst navigableAst, Cel cel)
     // If the output is a list, map, or struct which contains optional entries, then prune it
     // to make sure that the optionals, if resolved, do not surface in the output literal.
     CelAbstractSyntaxTree newAst = pruneOptionalElements(navigableAst);
-    return OptimizationResult.create(mutableAst.renumberIdsConsecutively(newAst));
+    return OptimizationResult.create(astMutator.renumberIdsConsecutively(newAst));
   }
 
   private static boolean canFold(CelNavigableExpr navigableExpr) {
@@ -236,7 +236,7 @@ private Optional<CelAbstractSyntaxTree> maybeFold(
     }
 
     return maybeAdaptEvaluatedResult(result)
-        .map(celExpr -> mutableAst.replaceSubtree(ast, celExpr, node.id()));
+        .map(celExpr -> astMutator.replaceSubtree(ast, celExpr, node.id()));
   }
 
   private Optional<CelExpr> maybeAdaptEvaluatedResult(Object result) {
@@ -289,7 +289,7 @@ private Optional<CelAbstractSyntaxTree> maybeRewriteOptional(
         // An empty optional value was encountered. Rewrite the tree with optional.none call.
         // This is to account for other optional functions returning an empty optional value
         // e.g: optional.ofNonZeroValue(0)
-        return Optional.of(mutableAst.replaceSubtree(ast, OPTIONAL_NONE_EXPR, expr.id()));
+        return Optional.of(astMutator.replaceSubtree(ast, OPTIONAL_NONE_EXPR, expr.id()));
       }
     } else if (!expr.callOrDefault().function().equals(Function.OPTIONAL_OF.getFunction())) {
       Object unwrappedResult = optResult.get();
@@ -309,7 +309,7 @@ private Optional<CelAbstractSyntaxTree> maybeRewriteOptional(
                               .build())
                       .build())
               .build();
-      return Optional.of(mutableAst.replaceSubtree(ast, newOptionalOfCall, expr.id()));
+      return Optional.of(astMutator.replaceSubtree(ast, newOptionalOfCall, expr.id()));
     }
 
     return Optional.empty();
@@ -338,7 +338,7 @@ private Optional<CelAbstractSyntaxTree> maybePruneBranches(
       }
       CelExpr result = cond.constant().booleanValue() ? truthy : falsy;
 
-      return Optional.of(mutableAst.replaceSubtree(ast, result, expr.id()));
+      return Optional.of(astMutator.replaceSubtree(ast, result, expr.id()));
     } else if (function.equals(Operator.IN.getFunction())) {
       CelExpr callArg = call.args().get(1);
       if (!callArg.exprKind().getKind().equals(Kind.CREATE_LIST)) {
@@ -348,7 +348,7 @@ private Optional<CelAbstractSyntaxTree> maybePruneBranches(
       CelCreateList haystack = callArg.createList();
       if (haystack.elements().isEmpty()) {
         return Optional.of(
-            mutableAst.replaceSubtree(
+            astMutator.replaceSubtree(
                 ast,
                 CelExpr.newBuilder().setConstant(CelConstant.ofValue(false)).build(),
                 expr.id()));
@@ -363,7 +363,7 @@ private Optional<CelAbstractSyntaxTree> maybePruneBranches(
           if (elem.constantOrDefault().equals(needleValue)
               || elem.identOrDefault().equals(needleValue)) {
             return Optional.of(
-                mutableAst.replaceSubtree(
+                astMutator.replaceSubtree(
                     ast,
                     CelExpr.newBuilder().setConstant(CelConstant.ofValue(true)).build(),
                     expr.id()));
@@ -396,16 +396,17 @@ private Optional<CelAbstractSyntaxTree> maybeShortCircuitCall(
       }
 
       if (arg.constant().booleanValue() == shortCircuit) {
-        return Optional.of(mutableAst.replaceSubtree(ast, arg, expr.id()));
+        return Optional.of(astMutator.replaceSubtree(ast, arg, expr.id()));
       }
     }
 
     ImmutableList<CelExpr> newArgs = newArgsBuilder.build();
     if (newArgs.isEmpty()) {
-      return Optional.of(mutableAst.replaceSubtree(ast, call.args().get(0), expr.id()));
+      CelExpr shortCircuitTarget = call.args().get(0); // either args(0) or args(1) would work here
+      return Optional.of(astMutator.replaceSubtree(ast, shortCircuitTarget, expr.id()));
     }
     if (newArgs.size() == 1) {
-      return Optional.of(mutableAst.replaceSubtree(ast, newArgs.get(0), expr.id()));
+      return Optional.of(astMutator.replaceSubtree(ast, newArgs.get(0), expr.id()));
     }
 
     // TODO: Support folding variadic AND/ORs.
@@ -483,7 +484,7 @@ private CelAbstractSyntaxTree pruneOptionalListElements(CelAbstractSyntaxTree as
       updatedIndicesBuilder.add(newOptIndex);
     }
 
-    return mutableAst.replaceSubtree(
+    return astMutator.replaceSubtree(
         ast,
         CelExpr.newBuilder()
             .setCreateList(
@@ -530,7 +531,7 @@ private CelAbstractSyntaxTree pruneOptionalMapElements(CelAbstractSyntaxTree ast
     }
 
     if (modified) {
-      return mutableAst.replaceSubtree(
+      return astMutator.replaceSubtree(
           ast,
           CelExpr.newBuilder()
               .setCreateMap(
@@ -576,7 +577,7 @@ private CelAbstractSyntaxTree pruneOptionalStructElements(
     }
 
     if (modified) {
-      return mutableAst.replaceSubtree(
+      return astMutator.replaceSubtree(
           ast,
           CelExpr.newBuilder()
               .setCreateStruct(
@@ -622,6 +623,6 @@ public static Builder newBuilder() {
 
   private ConstantFoldingOptimizer(ConstantFoldingOptions constantFoldingOptions) {
     this.constantFoldingOptions = constantFoldingOptions;
-    this.mutableAst = MutableAst.newInstance(constantFoldingOptions.maxIterationLimit());
+    this.astMutator = AstMutator.newInstance(constantFoldingOptions.maxIterationLimit());
   }
 }

optimizer/src/main/java/dev/cel/optimizer/optimizers/SubexpressionOptimizer.java

@@ -51,9 +51,9 @@
 import dev.cel.common.types.SimpleType;
 import dev.cel.extensions.CelOptionalLibrary;
 import dev.cel.extensions.CelOptionalLibrary.Function;
+import dev.cel.optimizer.AstMutator;
+import dev.cel.optimizer.AstMutator.MangledComprehensionAst;
 import dev.cel.optimizer.CelAstOptimizer;
-import dev.cel.optimizer.MutableAst;
-import dev.cel.optimizer.MutableAst.MangledComprehensionAst;
 import dev.cel.parser.Operator;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -107,7 +107,7 @@ public class SubexpressionOptimizer implements CelAstOptimizer {
       Extension.create("cel_block", Version.of(1L, 1L), Component.COMPONENT_RUNTIME);
 
   private final SubexpressionOptimizerOptions cseOptions;
-  private final MutableAst mutableAst;
+  private final AstMutator astMutator;
   private final ImmutableSet<String> cseEliminableFunctions;
 
   /**
@@ -140,7 +140,7 @@ public OptimizationResult optimize(CelNavigableAst navigableAst, Cel cel) {
 
   private OptimizationResult optimizeUsingCelBlock(CelNavigableAst navigableAst, Cel cel) {
     MangledComprehensionAst mangledComprehensionAst =
-        mutableAst.mangleComprehensionIdentifierNames(
+        astMutator.mangleComprehensionIdentifierNames(
             navigableAst.getAst(),
             MANGLED_COMPREHENSION_IDENTIFIER_PREFIX,
             MANGLED_COMPREHENSION_RESULT_PREFIX);
@@ -176,7 +176,7 @@ private OptimizationResult optimizeUsingCelBlock(CelNavigableAst navigableAst, C
                             "No value present for expr ID: " + semanticallyEqualNode.id()));
 
         astToModify =
-            mutableAst.replaceSubtree(
+            astMutator.replaceSubtree(
                 astToModify,
                 CelExpr.newBuilder()
                     .setIdent(CelIdent.newBuilder().setName(blockIdentifier).build())
@@ -235,8 +235,8 @@ private OptimizationResult optimizeUsingCelBlock(CelNavigableAst navigableAst, C
 
     // Wrap the optimized expression in cel.block
     astToModify =
-        mutableAst.wrapAstWithNewCelBlock(CEL_BLOCK_FUNCTION, astToModify, subexpressions);
-    astToModify = mutableAst.renumberIdsConsecutively(astToModify);
+        astMutator.wrapAstWithNewCelBlock(CEL_BLOCK_FUNCTION, astToModify, subexpressions);
+    astToModify = astMutator.renumberIdsConsecutively(astToModify);
 
     // Tag the AST with cel.block designated as an extension
     astToModify = tagAstExtension(astToModify);
@@ -359,7 +359,7 @@ private static ImmutableList<CelVarDecl> newBlockIndexVariableDeclarations(
 
   private OptimizationResult optimizeUsingCelBind(CelNavigableAst navigableAst) {
     CelAbstractSyntaxTree astToModify =
-        mutableAst
+        astMutator
             .mangleComprehensionIdentifierNames(
                 navigableAst.getAst(),
                 MANGLED_COMPREHENSION_IDENTIFIER_PREFIX,
@@ -395,7 +395,7 @@ private OptimizationResult optimizeUsingCelBind(CelNavigableAst navigableAst) {
                             "No value present for expr ID: " + semanticallyEqualNode.id()));
 
         astToModify =
-            mutableAst.replaceSubtree(
+            astMutator.replaceSubtree(
                 astToModify,
                 CelExpr.newBuilder()
                     .setIdent(CelIdent.newBuilder().setName(bindIdentifier).build())
@@ -414,7 +414,7 @@ private OptimizationResult optimizeUsingCelBind(CelNavigableAst navigableAst) {
 
       // Insert the new bind call
       astToModify =
-          mutableAst.replaceSubtreeWithNewBindMacro(
+          astMutator.replaceSubtreeWithNewBindMacro(
               astToModify, bindIdentifier, cseCandidate, lca.expr(), lca.id());
 
       // Retain the existing macro calls in case if the bind identifiers are replacing a subtree
@@ -436,7 +436,7 @@ private OptimizationResult optimizeUsingCelBind(CelNavigableAst navigableAst) {
       return OptimizationResult.create(astToModify);
     }
 
-    astToModify = mutableAst.renumberIdsConsecutively(astToModify);
+    astToModify = astMutator.renumberIdsConsecutively(astToModify);
 
     return OptimizationResult.create(astToModify);
   }
@@ -653,14 +653,14 @@ private CelExpr normalizeForEquality(CelExpr celExpr) {
               .setSelect(presenceTestExpr.select().toBuilder().setTestOnly(false).build())
               .build();
 
-      celExpr = mutableAst.replaceSubtree(celExpr, newExpr, newExpr.id());
+      celExpr = astMutator.replaceSubtree(celExpr, newExpr, newExpr.id());
     }
 
     if (iterCount >= cseOptions.iterationLimit()) {
       throw new IllegalStateException("Max iteration count reached.");
     }
 
-    return mutableAst.clearExprIds(celExpr);
+    return astMutator.clearExprIds(celExpr);
   }
 
   @VisibleForTesting
@@ -778,7 +778,7 @@ public static Builder newBuilder() {
 
   private SubexpressionOptimizer(SubexpressionOptimizerOptions cseOptions) {
     this.cseOptions = cseOptions;
-    this.mutableAst = MutableAst.newInstance(cseOptions.iterationLimit());
+    this.astMutator = AstMutator.newInstance(cseOptions.iterationLimit());
     this.cseEliminableFunctions =
         ImmutableSet.<String>builder()
             .addAll(CSE_DEFAULT_ELIMINABLE_FUNCTIONS)