From 9af1bed57ceb21832b630801d0aff04aaae8139a Mon Sep 17 00:00:00 2001 From: Sokwhan Huh Date: Tue, 30 Apr 2024 10:28:19 -0700 Subject: [PATCH] Remove modifier create from CelCreateList, CelCreateMap and CelCreateStruct PiperOrigin-RevId: 629456238 --- .../test/java/dev/cel/bundle/CelImplTest.java | 4 +- .../java/dev/cel/checker/ExprChecker.java | 37 ++- .../main/java/dev/cel/common/ast/CelExpr.java | 225 ++++++++++-------- .../dev/cel/common/ast/CelExprConverter.java | 20 +- .../dev/cel/common/ast/CelExprFactory.java | 32 +-- .../dev/cel/common/ast/CelExprFormatter.java | 34 ++- .../common/ast/CelExprV1Alpha1Converter.java | 20 +- .../dev/cel/common/ast/CelExprVisitor.java | 28 +-- .../dev/cel/common/ast/CelMutableExpr.java | 24 +- .../common/ast/CelMutableExprConverter.java | 41 ++-- .../navigation/CelNavigableExprVisitor.java | 6 +- .../navigation/ExprPropertyCalculator.java | 6 +- .../java/dev/cel/common/ast/CelExprTest.java | 124 +++++----- .../cel/common/ast/CelExprVisitorTest.java | 41 ++-- .../ast/CelMutableExprConverterTest.java | 24 +- .../cel/common/ast/CelMutableExprTest.java | 6 +- .../CelNavigableExprVisitorTest.java | 8 +- .../dev/cel/extensions/CelMathExtensions.java | 8 +- .../java/dev/cel/optimizer/AstMutator.java | 5 +- .../dev/cel/optimizer/MutableExprVisitor.java | 6 +- .../optimizers/ConstantFoldingOptimizer.java | 20 +- .../optimizers/SubexpressionOptimizer.java | 2 +- .../dev/cel/parser/CelMacroExprFactory.java | 26 +- .../dev/cel/parser/CelUnparserVisitor.java | 16 +- .../src/main/java/dev/cel/parser/Parser.java | 33 ++- .../cel/parser/CelMacroExprFactoryTest.java | 14 +- .../dev/cel/parser/CelUnparserImplTest.java | 12 +- .../dev/cel/runtime/DefaultInterpreter.java | 30 ++- .../java/dev/cel/runtime/CelRuntimeTest.java | 4 +- .../HomogeneousLiteralValidator.java | 12 +- 30 files changed, 431 insertions(+), 437 deletions(-) diff --git a/bundle/src/test/java/dev/cel/bundle/CelImplTest.java b/bundle/src/test/java/dev/cel/bundle/CelImplTest.java index 1eded3ce9..de36d93b9 100644 --- a/bundle/src/test/java/dev/cel/bundle/CelImplTest.java +++ b/bundle/src/test/java/dev/cel/bundle/CelImplTest.java @@ -68,7 +68,7 @@ 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.CelType; @@ -486,7 +486,7 @@ public void compile_withOptionalTypes() throws Exception { CelAbstractSyntaxTree ast = cel.compile("[?a]").getAst(); - CelCreateList createList = ast.getExpr().createList(); + CelList createList = ast.getExpr().createList(); assertThat(createList.optionalIndices()).containsExactly(0); assertThat(createList.elements()).containsExactly(CelExpr.ofIdent(2, "a")); } diff --git a/checker/src/main/java/dev/cel/checker/ExprChecker.java b/checker/src/main/java/dev/cel/checker/ExprChecker.java index cbebcd238..777dd8119 100644 --- a/checker/src/main/java/dev/cel/checker/ExprChecker.java +++ b/checker/src/main/java/dev/cel/checker/ExprChecker.java @@ -180,11 +180,11 @@ public CelExpr visit(CelExpr expr) { return visit(expr, expr.select()); case CALL: return visit(expr, expr.call()); - case CREATE_LIST: + case LIST: return visit(expr, expr.createList()); - case CREATE_STRUCT: + case STRUCT: return visit(expr, expr.createStruct()); - case CREATE_MAP: + case MAP: return visit(expr, expr.createMap()); case COMPREHENSION: return visit(expr, expr.comprehension()); @@ -355,7 +355,7 @@ private CelExpr visit(CelExpr expr, CelExpr.CelCall call) { } @CheckReturnValue - private CelExpr visit(CelExpr expr, CelExpr.CelCreateStruct createStruct) { + private CelExpr visit(CelExpr expr, CelExpr.CelStruct createStruct) { // Determine the type of the message. CelType messageType = SimpleType.ERROR; CelIdentDecl decl = env.lookupIdent(getPosition(expr), inContainer, createStruct.messageName()); @@ -383,9 +383,9 @@ private CelExpr visit(CelExpr expr, CelExpr.CelCreateStruct createStruct) { } // Check the field initializers. - ImmutableList entriesList = createStruct.entries(); + ImmutableList entriesList = createStruct.entries(); for (int i = 0; i < entriesList.size(); i++) { - CelExpr.CelCreateStruct.Entry entry = entriesList.get(i); + CelExpr.CelStruct.Entry entry = entriesList.get(i); CelExpr visitedValueExpr = visit(entry.value()); if (namespacedDeclarations && !visitedValueExpr.equals(entry.value())) { // Subtree has been rewritten. Replace the struct value. @@ -414,12 +414,12 @@ private CelExpr visit(CelExpr expr, CelExpr.CelCreateStruct createStruct) { } @CheckReturnValue - private CelExpr visit(CelExpr expr, CelExpr.CelCreateMap createMap) { + private CelExpr visit(CelExpr expr, CelExpr.CelMap createMap) { CelType mapKeyType = null; CelType mapValueType = null; - ImmutableList entriesList = createMap.entries(); + ImmutableList entriesList = createMap.entries(); for (int i = 0; i < entriesList.size(); i++) { - CelExpr.CelCreateMap.Entry entry = entriesList.get(i); + CelExpr.CelMap.Entry entry = entriesList.get(i); CelExpr visitedMapKeyExpr = visit(entry.key()); if (namespacedDeclarations && !visitedMapKeyExpr.equals(entry.key())) { // Subtree has been rewritten. Replace the map key. @@ -455,7 +455,7 @@ private CelExpr visit(CelExpr expr, CelExpr.CelCreateMap createMap) { } @CheckReturnValue - private CelExpr visit(CelExpr expr, CelExpr.CelCreateList createList) { + private CelExpr visit(CelExpr expr, CelExpr.CelList createList) { CelType elemsType = null; ImmutableList elementsList = createList.elements(); HashSet optionalIndices = new HashSet<>(createList.optionalIndices()); @@ -797,7 +797,7 @@ private int getPosition(CelExpr expr) { return pos == null ? 0 : pos; } - private int getPosition(CelExpr.CelCreateStruct.Entry entry) { + private int getPosition(CelExpr.CelStruct.Entry entry) { Integer pos = positionMap.get(entry.id()); return pos == null ? 0 : pos; } @@ -848,30 +848,29 @@ private static CelExpr replaceCallSubtree(CelExpr expr, CelExpr target) { } private static CelExpr replaceListElementSubtree(CelExpr expr, CelExpr element, int index) { - CelExpr.CelCreateList newList = - expr.createList().toBuilder().setElement(index, element).build(); + CelExpr.CelList newList = expr.createList().toBuilder().setElement(index, element).build(); return expr.toBuilder().setCreateList(newList).build(); } private static CelExpr replaceStructEntryValueSubtree(CelExpr expr, CelExpr newValue, int index) { - CelExpr.CelCreateStruct createStruct = expr.createStruct(); - CelExpr.CelCreateStruct.Entry newEntry = + CelExpr.CelStruct createStruct = expr.createStruct(); + CelExpr.CelStruct.Entry newEntry = createStruct.entries().get(index).toBuilder().setValue(newValue).build(); createStruct = createStruct.toBuilder().setEntry(index, newEntry).build(); return expr.toBuilder().setCreateStruct(createStruct).build(); } private static CelExpr replaceMapEntryKeySubtree(CelExpr expr, CelExpr newKey, int index) { - CelExpr.CelCreateMap createMap = expr.createMap(); - CelExpr.CelCreateMap.Entry newEntry = + CelExpr.CelMap createMap = expr.createMap(); + CelExpr.CelMap.Entry newEntry = createMap.entries().get(index).toBuilder().setKey(newKey).build(); createMap = createMap.toBuilder().setEntry(index, newEntry).build(); return expr.toBuilder().setCreateMap(createMap).build(); } private static CelExpr replaceMapEntryValueSubtree(CelExpr expr, CelExpr newValue, int index) { - CelExpr.CelCreateMap createMap = expr.createMap(); - CelExpr.CelCreateMap.Entry newEntry = + CelExpr.CelMap createMap = expr.createMap(); + CelExpr.CelMap.Entry newEntry = createMap.entries().get(index).toBuilder().setValue(newValue).build(); createMap = createMap.toBuilder().setEntry(index, newEntry).build(); return expr.toBuilder().setCreateMap(createMap).build(); diff --git a/common/src/main/java/dev/cel/common/ast/CelExpr.java b/common/src/main/java/dev/cel/common/ast/CelExpr.java index c0651ccb3..d85348175 100644 --- a/common/src/main/java/dev/cel/common/ast/CelExpr.java +++ b/common/src/main/java/dev/cel/common/ast/CelExpr.java @@ -23,7 +23,7 @@ import com.google.errorprone.annotations.CanIgnoreReturnValue; import com.google.errorprone.annotations.CheckReturnValue; import com.google.errorprone.annotations.Immutable; -import dev.cel.common.annotations.Internal; +import com.google.errorprone.annotations.InlineMe; import dev.cel.common.ast.CelExpr.ExprKind.Kind; import java.util.ArrayList; import java.util.Arrays; @@ -36,7 +36,6 @@ *

This is the native type equivalent of Expr message in syntax.proto. */ @AutoValue -@Internal @Immutable @SuppressWarnings("unchecked") // Class ensures only the super type is used public abstract class CelExpr implements Expression { @@ -95,20 +94,20 @@ public CelCall call() { /** * {@inheritDoc} * - * @throws UnsupportedOperationException if expression is not {@link Kind#CREATE_LIST}. + * @throws UnsupportedOperationException if expression is not {@link Kind#LIST}. */ @Override - public CelCreateList createList() { + public CelList createList() { return exprKind().createList(); } /** * {@inheritDoc} * - * @throws UnsupportedOperationException if expression is not {@link Kind#CREATE_STRUCT}. + * @throws UnsupportedOperationException if expression is not {@link Kind#STRUCT}. */ @Override - public CelCreateStruct createStruct() { + public CelStruct createStruct() { return exprKind().createStruct(); } @@ -118,7 +117,7 @@ public CelCreateStruct createStruct() { * @throws UnsupportedOperationException if expression is not {@link Kind#createMap}. */ @Override - public CelCreateMap createMap() { + public CelMap createMap() { return exprKind().createMap(); } @@ -174,32 +173,32 @@ public CelCall callOrDefault() { /** * Gets the underlying createList expression or a default instance of one if expression is not - * {@link Kind#CREATE_LIST}. + * {@link Kind#LIST}. */ - public CelCreateList createListOrDefault() { - return exprKind().getKind().equals(ExprKind.Kind.CREATE_LIST) + public CelList createListOrDefault() { + return exprKind().getKind().equals(ExprKind.Kind.LIST) ? exprKind().createList() - : CelCreateList.newBuilder().build(); + : CelList.newBuilder().build(); } /** * Gets the underlying createStruct expression or a default instance of one if expression is not - * {@link Kind#CREATE_STRUCT}. + * {@link Kind#STRUCT}. */ - public CelCreateStruct createStructOrDefault() { - return exprKind().getKind().equals(ExprKind.Kind.CREATE_STRUCT) + public CelStruct createStructOrDefault() { + return exprKind().getKind().equals(ExprKind.Kind.STRUCT) ? exprKind().createStruct() - : CelCreateStruct.newBuilder().build(); + : CelStruct.newBuilder().build(); } /** * Gets the underlying createMap expression or a default instance of one if expression is not - * {@link Kind#CREATE_MAP}. + * {@link Kind#MAP}. */ - public CelCreateMap createMapOrDefault() { - return exprKind().getKind().equals(ExprKind.Kind.CREATE_MAP) + public CelMap createMapOrDefault() { + return exprKind().getKind().equals(ExprKind.Kind.MAP) ? exprKind().createMap() - : CelCreateMap.newBuilder().build(); + : CelMap.newBuilder().build(); } /** @@ -263,18 +262,18 @@ public CelCall call() { /** * Gets the underlying createList expression. * - * @throws UnsupportedOperationException if expression is not {@link Kind#CREATE_LIST}. + * @throws UnsupportedOperationException if expression is not {@link Kind#LIST}. */ - public CelCreateList createList() { + public CelList createList() { return exprKind().createList(); } /** * Gets the underlying createStruct expression. * - * @throws UnsupportedOperationException if expression is not {@link Kind#CREATE_STRUCT}. + * @throws UnsupportedOperationException if expression is not {@link Kind#STRUCT}. */ - public CelCreateStruct createStruct() { + public CelStruct createStruct() { return exprKind().createStruct(); } @@ -283,7 +282,7 @@ public CelCreateStruct createStruct() { * * @throws UnsupportedOperationException if expression is not {@link Kind#createMap}. */ - public CelCreateMap createMap() { + public CelMap createMap() { return exprKind().createMap(); } @@ -317,18 +316,18 @@ public Builder setSelect(CelSelect select) { } @CanIgnoreReturnValue - public Builder setCreateList(CelCreateList createList) { - return setExprKind(AutoOneOf_CelExpr_ExprKind.createList(createList)); + public Builder setCreateList(CelList createList) { + return setExprKind(AutoOneOf_CelExpr_ExprKind.list(createList)); } @CanIgnoreReturnValue - public Builder setCreateStruct(CelCreateStruct createStruct) { - return setExprKind(AutoOneOf_CelExpr_ExprKind.createStruct(createStruct)); + public Builder setCreateStruct(CelStruct createStruct) { + return setExprKind(AutoOneOf_CelExpr_ExprKind.struct(createStruct)); } @CanIgnoreReturnValue - public Builder setCreateMap(CelCreateMap createMap) { - return setExprKind(AutoOneOf_CelExpr_ExprKind.createMap(createMap)); + public Builder setCreateMap(CelMap createMap) { + return setExprKind(AutoOneOf_CelExpr_ExprKind.map(createMap)); } @CanIgnoreReturnValue @@ -360,9 +359,9 @@ public enum Kind { IDENT, SELECT, CALL, - CREATE_LIST, - CREATE_STRUCT, - CREATE_MAP, + LIST, + STRUCT, + MAP, COMPREHENSION, } @@ -378,11 +377,38 @@ public enum Kind { public abstract CelCall call(); - public abstract CelCreateList createList(); + public abstract CelList list(); - public abstract CelCreateStruct createStruct(); + /** + * @deprecated Use {@link #list()} instead. + */ + @Deprecated + @InlineMe(replacement = "this.list()") + public final CelList createList() { + return list(); + } + + public abstract CelStruct struct(); - public abstract CelCreateMap createMap(); + /** + * @deprecated Use {@link #struct()} instead. + */ + @Deprecated + @InlineMe(replacement = "this.struct()") + public final CelStruct createStruct() { + return struct(); + } + + public abstract CelMap map(); + + /** + * @deprecated Use {@link #map()} instead. + */ + @Deprecated + @InlineMe(replacement = "this.map()") + public final CelMap createMap() { + return map(); + } public abstract CelComprehension comprehension(); } @@ -565,14 +591,14 @@ public static Builder newBuilder() { /** A list creation expression. See {@link Expression.CreateList} */ @AutoValue @Immutable - public abstract static class CelCreateList implements Expression.CreateList { + public abstract static class CelList implements Expression.CreateList { @Override public abstract ImmutableList elements(); @Override public abstract ImmutableList optionalIndices(); - /** Builder for CelCreateList. */ + /** Builder for CelList. */ @AutoValue.Builder public abstract static class Builder { private List mutableElements = new ArrayList<>(); @@ -631,10 +657,10 @@ public Builder addOptionalIndices(Iterable indices) { } // Not public due to overridden build logic. - abstract CelCreateList autoBuild(); + abstract CelList autoBuild(); @CheckReturnValue - public CelCreateList build() { + public CelList build() { setElements(ImmutableList.copyOf(mutableElements)); return autoBuild(); } @@ -650,73 +676,70 @@ public Builder toBuilder() { } public static Builder newBuilder() { - return new AutoValue_CelExpr_CelCreateList.Builder(); + return new AutoValue_CelExpr_CelList.Builder(); } } /** A message creation expression. See {@link Expression.CreateStruct} */ @AutoValue @Immutable - public abstract static class CelCreateStruct - implements Expression.CreateStruct { + public abstract static class CelStruct implements Expression.CreateStruct { @Override public abstract String messageName(); @Override - public abstract ImmutableList entries(); + public abstract ImmutableList entries(); - /** Builder for CelCreateStruct. */ + /** Builder for CelStruct. */ @AutoValue.Builder public abstract static class Builder { - private List mutableEntries = new ArrayList<>(); + private List mutableEntries = new ArrayList<>(); // Not public. This only exists to make AutoValue.Builder work. - abstract ImmutableList entries(); + abstract ImmutableList entries(); @CanIgnoreReturnValue public abstract Builder setMessageName(String value); // Not public. This only exists to make AutoValue.Builder work. @CanIgnoreReturnValue - abstract Builder setEntries(ImmutableList entries); + abstract Builder setEntries(ImmutableList entries); /** Returns an immutable copy of the current mutable entries present in the builder. */ - public ImmutableList getEntries() { + public ImmutableList getEntries() { return ImmutableList.copyOf(mutableEntries); } /** Returns an immutable copy of the builders from the current mutable entries. */ - public ImmutableList getEntriesBuilders() { - return mutableEntries.stream() - .map(CelCreateStruct.Entry::toBuilder) - .collect(toImmutableList()); + public ImmutableList getEntriesBuilders() { + return mutableEntries.stream().map(CelStruct.Entry::toBuilder).collect(toImmutableList()); } @CanIgnoreReturnValue - public Builder setEntry(int index, CelCreateStruct.Entry entry) { + public Builder setEntry(int index, CelStruct.Entry entry) { checkNotNull(entry); mutableEntries.set(index, entry); return this; } @CanIgnoreReturnValue - public Builder addEntries(CelCreateStruct.Entry... entries) { + public Builder addEntries(CelStruct.Entry... entries) { checkNotNull(entries); return addEntries(Arrays.asList(entries)); } @CanIgnoreReturnValue - public Builder addEntries(Iterable entries) { + public Builder addEntries(Iterable entries) { checkNotNull(entries); entries.forEach(mutableEntries::add); return this; } // Not public due to overridden build logic. - abstract CelCreateStruct autoBuild(); + abstract CelStruct autoBuild(); @CheckReturnValue - public CelCreateStruct build() { + public CelStruct build() { setEntries(ImmutableList.copyOf(mutableEntries)); return autoBuild(); } @@ -732,7 +755,7 @@ public Builder toBuilder() { } public static Builder newBuilder() { - return new AutoValue_CelExpr_CelCreateStruct.Builder().setMessageName(""); + return new AutoValue_CelExpr_CelStruct.Builder().setMessageName(""); } /** Represents an entry of the struct */ @@ -752,7 +775,7 @@ public abstract static class Entry implements Expression.CreateStruct.Entry { + public abstract static class CelMap implements Expression.CreateMap { /** The entries in the creation expression. */ @Override - public abstract ImmutableList entries(); + public abstract ImmutableList entries(); - /** Builder for CelCreateMap. */ + /** Builder for CelMap. */ @AutoValue.Builder public abstract static class Builder { - private List mutableEntries = new ArrayList<>(); + private List mutableEntries = new ArrayList<>(); // Not public. This only exists to make AutoValue.Builder work. - abstract ImmutableList entries(); + abstract ImmutableList entries(); // Not public. This only exists to make AutoValue.Builder work. @CanIgnoreReturnValue - abstract Builder setEntries(ImmutableList entries); + abstract Builder setEntries(ImmutableList entries); /** Returns an immutable copy of the current mutable entries present in the builder. */ - public ImmutableList getEntries() { + public ImmutableList getEntries() { return ImmutableList.copyOf(mutableEntries); } /** Returns an immutable copy of the builders from the current mutable entries. */ - public ImmutableList getEntriesBuilders() { - return mutableEntries.stream() - .map(CelCreateMap.Entry::toBuilder) - .collect(toImmutableList()); + public ImmutableList getEntriesBuilders() { + return mutableEntries.stream().map(CelMap.Entry::toBuilder).collect(toImmutableList()); } @CanIgnoreReturnValue - public Builder setEntry(int index, CelCreateMap.Entry entry) { + public Builder setEntry(int index, CelMap.Entry entry) { checkNotNull(entry); mutableEntries.set(index, entry); return this; } @CanIgnoreReturnValue - public Builder addEntries(CelCreateMap.Entry... entries) { + public Builder addEntries(CelMap.Entry... entries) { checkNotNull(entries); return addEntries(Arrays.asList(entries)); } @CanIgnoreReturnValue - public Builder addEntries(Iterable entries) { + public Builder addEntries(Iterable entries) { checkNotNull(entries); entries.forEach(mutableEntries::add); return this; } // Not public due to overridden build logic. - abstract CelCreateMap autoBuild(); + abstract CelMap autoBuild(); @CheckReturnValue - public CelCreateMap build() { + public CelMap build() { setEntries(ImmutableList.copyOf(mutableEntries)); return autoBuild(); } @@ -855,7 +874,7 @@ public Builder toBuilder() { } public static Builder newBuilder() { - return new AutoValue_CelExpr_CelCreateMap.Builder(); + return new AutoValue_CelExpr_CelMap.Builder(); } /** Represents an entry of the map. */ @@ -875,7 +894,7 @@ public abstract static class Entry implements Expression.CreateMap.Entry entries) { + long id, String messageName, ImmutableList entries) { return newBuilder() .setId(id) .setExprKind( - AutoOneOf_CelExpr_ExprKind.createStruct( - CelCreateStruct.newBuilder() - .setMessageName(messageName) - .addEntries(entries) - .build())) + AutoOneOf_CelExpr_ExprKind.struct( + CelStruct.newBuilder().setMessageName(messageName).addEntries(entries).build())) .build(); } - public static CelExpr ofCreateMap(long id, ImmutableList entries) { + public static CelExpr ofCreateMap(long id, ImmutableList entries) { return newBuilder() .setId(id) .setExprKind( - AutoOneOf_CelExpr_ExprKind.createMap( - CelCreateMap.newBuilder().addEntries(entries).build())) + AutoOneOf_CelExpr_ExprKind.map(CelMap.newBuilder().addEntries(entries).build())) .build(); } - public static CelCreateStruct.Entry ofCreateStructEntry( + public static CelStruct.Entry ofCreateStructEntry( long id, String fieldKey, CelExpr value, boolean isOptionalEntry) { - return CelCreateStruct.Entry.newBuilder() + return CelStruct.Entry.newBuilder() .setId(id) .setFieldKey(fieldKey) .setValue(value) @@ -1067,9 +1082,9 @@ public static CelCreateStruct.Entry ofCreateStructEntry( .build(); } - public static CelCreateMap.Entry ofCreateMapEntry( + public static CelMap.Entry ofCreateMapEntry( long id, CelExpr mapKey, CelExpr value, boolean isOptionalEntry) { - return CelCreateMap.Entry.newBuilder() + return CelMap.Entry.newBuilder() .setId(id) .setKey(mapKey) .setValue(value) diff --git a/common/src/main/java/dev/cel/common/ast/CelExprConverter.java b/common/src/main/java/dev/cel/common/ast/CelExprConverter.java index b2d8489a3..cc7942415 100644 --- a/common/src/main/java/dev/cel/common/ast/CelExprConverter.java +++ b/common/src/main/java/dev/cel/common/ast/CelExprConverter.java @@ -68,16 +68,16 @@ public static Expr fromCelExpr(CelExpr celExpr) { .addAllArgs(fromCelExprList(celCall.args())); celCall.target().ifPresent(target -> callBuilder.setTarget(fromCelExpr(target))); return expr.setCallExpr(callBuilder).build(); - case CREATE_LIST: - CelExpr.CelCreateList celCreateList = celExprKind.createList(); + case LIST: + CelExpr.CelList celCreateList = celExprKind.list(); return expr.setListExpr( CreateList.newBuilder() .addAllElements(fromCelExprList(celCreateList.elements())) .addAllOptionalIndices(celCreateList.optionalIndices())) .build(); - case CREATE_STRUCT: + case STRUCT: return expr.setStructExpr(celStructToExprStruct(celExprKind.createStruct())).build(); - case CREATE_MAP: + case MAP: return expr.setStructExpr(celMapToExprStruct(celExprKind.createMap())).build(); case COMPREHENSION: CelExpr.CelComprehension celComprehension = celExprKind.comprehension(); @@ -202,7 +202,7 @@ public static CelConstant exprConstantToCelConstant(Constant constExpr) { private static CelExpr exprStructToCelStruct(long id, CreateStruct structExpr) { if (!structExpr.getMessageName().isEmpty()) { - ImmutableList.Builder entries = ImmutableList.builder(); + ImmutableList.Builder entries = ImmutableList.builder(); for (Entry structExprEntry : structExpr.getEntriesList()) { if (!structExprEntry.getKeyKindCase().equals(KeyKindCase.FIELD_KEY)) { throw new IllegalArgumentException( @@ -218,7 +218,7 @@ private static CelExpr exprStructToCelStruct(long id, CreateStruct structExpr) { return CelExpr.ofCreateStruct(id, structExpr.getMessageName(), entries.build()); } else { - ImmutableList.Builder entries = ImmutableList.builder(); + ImmutableList.Builder entries = ImmutableList.builder(); for (Entry mapExprEntry : structExpr.getEntriesList()) { if (!mapExprEntry.getKeyKindCase().equals(KeyKindCase.MAP_KEY)) { throw new IllegalArgumentException( @@ -270,9 +270,9 @@ public static Constant celConstantToExprConstant(CelConstant celConstant) { throw new IllegalStateException("unsupported constant case: " + celConstant.getKind()); } - private static CreateStruct celStructToExprStruct(CelExpr.CelCreateStruct celCreateStruct) { + private static CreateStruct celStructToExprStruct(CelExpr.CelStruct celCreateStruct) { ImmutableList.Builder entries = ImmutableList.builder(); - for (CelExpr.CelCreateStruct.Entry celStructExprEntry : celCreateStruct.entries()) { + for (CelExpr.CelStruct.Entry celStructExprEntry : celCreateStruct.entries()) { entries.add( CreateStruct.Entry.newBuilder() .setId(celStructExprEntry.id()) @@ -288,9 +288,9 @@ private static CreateStruct celStructToExprStruct(CelExpr.CelCreateStruct celCre .build(); } - private static CreateStruct celMapToExprStruct(CelExpr.CelCreateMap celCreateMap) { + private static CreateStruct celMapToExprStruct(CelExpr.CelMap celCreateMap) { ImmutableList.Builder entries = ImmutableList.builder(); - for (CelExpr.CelCreateMap.Entry celMapEntry : celCreateMap.entries()) { + for (CelExpr.CelMap.Entry celMapEntry : celCreateMap.entries()) { CreateStruct.Entry exprMapEntry = CreateStruct.Entry.newBuilder() .setId(celMapEntry.id()) diff --git a/common/src/main/java/dev/cel/common/ast/CelExprFactory.java b/common/src/main/java/dev/cel/common/ast/CelExprFactory.java index 385e72fee..6e8a08619 100644 --- a/common/src/main/java/dev/cel/common/ast/CelExprFactory.java +++ b/common/src/main/java/dev/cel/common/ast/CelExprFactory.java @@ -96,28 +96,26 @@ public final CelExpr newList(CelExpr... elements) { public final CelExpr newList(Iterable elements) { return CelExpr.newBuilder() .setId(nextExprId()) - .setCreateList(CelExpr.CelCreateList.newBuilder().addElements(elements).build()) + .setCreateList(CelExpr.CelList.newBuilder().addElements(elements).build()) .build(); } /** Creates a new map {@link CelExpr} comprised of the entries. */ - public final CelExpr newMap(CelExpr.CelCreateMap.Entry... entries) { + public final CelExpr newMap(CelExpr.CelMap.Entry... entries) { return newMap(Arrays.asList(entries)); } /** Creates a new map {@link CelExpr} comprised of the entries. */ - public final CelExpr newMap(Iterable entries) { + public final CelExpr newMap(Iterable entries) { return CelExpr.newBuilder() .setId(nextExprId()) - .setCreateMap(CelExpr.CelCreateMap.newBuilder().addEntries(entries).build()) + .setCreateMap(CelExpr.CelMap.newBuilder().addEntries(entries).build()) .build(); } - /** - * Creates a new map {@link CelExpr.CelCreateStruct.Entry} comprised of the given key and value. - */ - public final CelExpr.CelCreateMap.Entry newMapEntry(CelExpr key, CelExpr value) { - return CelExpr.CelCreateMap.Entry.newBuilder() + /** Creates a new map {@link CelExpr.CelStruct.Entry} comprised of the given key and value. */ + public final CelExpr.CelMap.Entry newMapEntry(CelExpr key, CelExpr value) { + return CelExpr.CelMap.Entry.newBuilder() .setId(nextExprId()) .setKey(key) .setValue(value) @@ -125,30 +123,26 @@ public final CelExpr.CelCreateMap.Entry newMapEntry(CelExpr key, CelExpr value) } /** Creates a new message {@link CelExpr} of the given type comprised of the given fields. */ - public final CelExpr newMessage(String typeName, CelExpr.CelCreateStruct.Entry... fields) { + public final CelExpr newMessage(String typeName, CelExpr.CelStruct.Entry... fields) { return newMessage(typeName, Arrays.asList(fields)); } /** Creates a new message {@link CelExpr} of the given type comprised of the given fields. */ - public final CelExpr newMessage(String typeName, Iterable fields) { + public final CelExpr newMessage(String typeName, Iterable fields) { checkArgument(!isNullOrEmpty(typeName)); return CelExpr.newBuilder() .setId(nextExprId()) .setCreateStruct( - CelExpr.CelCreateStruct.newBuilder() - .setMessageName(typeName) - .addEntries(fields) - .build()) + CelExpr.CelStruct.newBuilder().setMessageName(typeName).addEntries(fields).build()) .build(); } /** - * Creates a new message {@link CelExpr.CelCreateStruct.Entry} comprised of the given field and - * value. + * Creates a new message {@link CelExpr.CelStruct.Entry} comprised of the given field and value. */ - public final CelExpr.CelCreateStruct.Entry newMessageField(String field, CelExpr value) { + public final CelExpr.CelStruct.Entry newMessageField(String field, CelExpr value) { checkArgument(!isNullOrEmpty(field)); - return CelExpr.CelCreateStruct.Entry.newBuilder() + return CelExpr.CelStruct.Entry.newBuilder() .setId(nextExprId()) .setFieldKey(field) .setValue(value) diff --git a/common/src/main/java/dev/cel/common/ast/CelExprFormatter.java b/common/src/main/java/dev/cel/common/ast/CelExprFormatter.java index 32e0233d0..e6783e359 100644 --- a/common/src/main/java/dev/cel/common/ast/CelExprFormatter.java +++ b/common/src/main/java/dev/cel/common/ast/CelExprFormatter.java @@ -32,8 +32,24 @@ static String format(CelExpr celExpr) { } private void formatExpr(CelExpr celExpr) { - append(String.format("%s [%d] {", celExpr.exprKind().getKind(), celExpr.id())); CelExpr.ExprKind.Kind exprKind = celExpr.exprKind().getKind(); + String kindFormattedText; + // Temporarily retain existing formatted expr kinds until callers are migrated + switch (exprKind) { + case LIST: + kindFormattedText = "CREATE_LIST"; + break; + case STRUCT: + kindFormattedText = "CREATE_STRUCT"; + break; + case MAP: + kindFormattedText = "CREATE_MAP"; + break; + default: + kindFormattedText = exprKind.toString(); + break; + } + append(String.format("%s [%d] {", kindFormattedText, celExpr.id())); if (!EXCLUDED_NEWLINE_KINDS.contains(exprKind)) { appendNewline(); } @@ -51,13 +67,13 @@ private void formatExpr(CelExpr celExpr) { case CALL: appendCall(celExpr.call()); break; - case CREATE_LIST: + case LIST: appendCreateList(celExpr.createList()); break; - case CREATE_STRUCT: + case STRUCT: appendCreateStruct(celExpr.createStruct()); break; - case CREATE_MAP: + case MAP: appendCreateMap(celExpr.createMap()); break; case COMPREHENSION: @@ -152,7 +168,7 @@ private void appendCall(CelExpr.CelCall celCall) { outdent(); } - private void appendCreateList(CelExpr.CelCreateList celCreateList) { + private void appendCreateList(CelExpr.CelList celCreateList) { indent(); append("elements: {"); indent(); @@ -177,12 +193,12 @@ private void appendCreateList(CelExpr.CelCreateList celCreateList) { outdent(); } - private void appendCreateStruct(CelExpr.CelCreateStruct celCreateStruct) { + private void appendCreateStruct(CelExpr.CelStruct celCreateStruct) { indent(); appendWithNewline("name: " + celCreateStruct.messageName()); append("entries: {"); indent(); - for (CelExpr.CelCreateStruct.Entry entry : celCreateStruct.entries()) { + for (CelExpr.CelStruct.Entry entry : celCreateStruct.entries()) { appendNewline(); appendWithNewline(String.format("ENTRY [%d] {", entry.id())); indent(); @@ -205,10 +221,10 @@ private void appendCreateStruct(CelExpr.CelCreateStruct celCreateStruct) { outdent(); } - private void appendCreateMap(CelExpr.CelCreateMap celCreateMap) { + private void appendCreateMap(CelExpr.CelMap celCreateMap) { indent(); boolean firstLine = true; - for (CelExpr.CelCreateMap.Entry entry : celCreateMap.entries()) { + for (CelExpr.CelMap.Entry entry : celCreateMap.entries()) { if (!firstLine) { appendNewline(); } else { diff --git a/common/src/main/java/dev/cel/common/ast/CelExprV1Alpha1Converter.java b/common/src/main/java/dev/cel/common/ast/CelExprV1Alpha1Converter.java index b22daf514..57b4a46eb 100644 --- a/common/src/main/java/dev/cel/common/ast/CelExprV1Alpha1Converter.java +++ b/common/src/main/java/dev/cel/common/ast/CelExprV1Alpha1Converter.java @@ -68,16 +68,16 @@ public static Expr fromCelExpr(CelExpr celExpr) { .addAllArgs(fromCelExprList(celCall.args())); celCall.target().ifPresent(target -> callBuilder.setTarget(fromCelExpr(target))); return expr.setCallExpr(callBuilder).build(); - case CREATE_LIST: - CelExpr.CelCreateList celCreateList = celExprKind.createList(); + case LIST: + CelExpr.CelList celCreateList = celExprKind.list(); return expr.setListExpr( CreateList.newBuilder() .addAllElements(fromCelExprList(celCreateList.elements())) .addAllOptionalIndices(celCreateList.optionalIndices())) .build(); - case CREATE_STRUCT: + case STRUCT: return expr.setStructExpr(celStructToExprStruct(celExprKind.createStruct())).build(); - case CREATE_MAP: + case MAP: return expr.setStructExpr(celMapToExprStruct(celExprKind.createMap())).build(); case COMPREHENSION: CelExpr.CelComprehension celComprehension = celExprKind.comprehension(); @@ -202,7 +202,7 @@ public static CelConstant exprConstantToCelConstant(Constant constExpr) { private static CelExpr exprStructToCelStruct(long id, CreateStruct structExpr) { if (!structExpr.getMessageName().isEmpty()) { - ImmutableList.Builder entries = ImmutableList.builder(); + ImmutableList.Builder entries = ImmutableList.builder(); for (Entry structExprEntry : structExpr.getEntriesList()) { if (!structExprEntry.getKeyKindCase().equals(KeyKindCase.FIELD_KEY)) { throw new IllegalArgumentException( @@ -218,7 +218,7 @@ private static CelExpr exprStructToCelStruct(long id, CreateStruct structExpr) { return CelExpr.ofCreateStruct(id, structExpr.getMessageName(), entries.build()); } else { - ImmutableList.Builder entries = ImmutableList.builder(); + ImmutableList.Builder entries = ImmutableList.builder(); for (Entry mapExprEntry : structExpr.getEntriesList()) { if (!mapExprEntry.getKeyKindCase().equals(KeyKindCase.MAP_KEY)) { throw new IllegalArgumentException( @@ -270,9 +270,9 @@ public static Constant celConstantToExprConstant(CelConstant celConstant) { throw new IllegalStateException("unsupported constant case: " + celConstant.getKind()); } - private static CreateStruct celStructToExprStruct(CelExpr.CelCreateStruct celCreateStruct) { + private static CreateStruct celStructToExprStruct(CelExpr.CelStruct celCreateStruct) { ImmutableList.Builder entries = ImmutableList.builder(); - for (CelExpr.CelCreateStruct.Entry celStructExprEntry : celCreateStruct.entries()) { + for (CelExpr.CelStruct.Entry celStructExprEntry : celCreateStruct.entries()) { entries.add( CreateStruct.Entry.newBuilder() .setId(celStructExprEntry.id()) @@ -288,9 +288,9 @@ private static CreateStruct celStructToExprStruct(CelExpr.CelCreateStruct celCre .build(); } - private static CreateStruct celMapToExprStruct(CelExpr.CelCreateMap celCreateMap) { + private static CreateStruct celMapToExprStruct(CelExpr.CelMap celCreateMap) { ImmutableList.Builder entries = ImmutableList.builder(); - for (CelExpr.CelCreateMap.Entry celMapEntry : celCreateMap.entries()) { + for (CelExpr.CelMap.Entry celMapEntry : celCreateMap.entries()) { CreateStruct.Entry exprMapEntry = CreateStruct.Entry.newBuilder() .setId(celMapEntry.id()) diff --git a/common/src/main/java/dev/cel/common/ast/CelExprVisitor.java b/common/src/main/java/dev/cel/common/ast/CelExprVisitor.java index ca0911364..e35b19aca 100644 --- a/common/src/main/java/dev/cel/common/ast/CelExprVisitor.java +++ b/common/src/main/java/dev/cel/common/ast/CelExprVisitor.java @@ -17,11 +17,11 @@ import dev.cel.common.CelAbstractSyntaxTree; import dev.cel.common.ast.CelExpr.CelCall; import dev.cel.common.ast.CelExpr.CelComprehension; -import dev.cel.common.ast.CelExpr.CelCreateList; -import dev.cel.common.ast.CelExpr.CelCreateMap; -import dev.cel.common.ast.CelExpr.CelCreateStruct; import dev.cel.common.ast.CelExpr.CelIdent; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; /** CEL expression visitor implementation using Cel native types. */ public class CelExprVisitor { @@ -60,13 +60,13 @@ public void visit(CelExpr expr) { case CALL: visit(expr, expr.call()); break; - case CREATE_LIST: + case LIST: visit(expr, expr.createList()); break; - case CREATE_STRUCT: + case STRUCT: visit(expr, expr.createStruct()); break; - case CREATE_MAP: + case MAP: visit(expr, expr.createMap()); break; case COMPREHENSION: @@ -107,23 +107,23 @@ protected void visit(CelExpr expr, CelCall call) { } } - /** Visit a {@code CelCreateStruct} expression. */ - protected void visit(CelExpr expr, CelCreateStruct createStruct) { - for (CelCreateStruct.Entry entry : createStruct.entries()) { + /** Visit a {@code CelStruct} expression. */ + protected void visit(CelExpr expr, CelStruct createStruct) { + for (CelStruct.Entry entry : createStruct.entries()) { visit(entry.value()); } } - /** Visit a {@code CelCreateMap} expression. */ - protected void visit(CelExpr expr, CelCreateMap createMap) { - for (CelCreateMap.Entry entry : createMap.entries()) { + /** Visit a {@code CelMap} expression. */ + protected void visit(CelExpr expr, CelMap createMap) { + for (CelMap.Entry entry : createMap.entries()) { visit(entry.key()); visit(entry.value()); } } - /** Visit a {@code CelCreateList} expression. */ - protected void visit(CelExpr expr, CelCreateList createList) { + /** Visit a {@code CelList} expression. */ + protected void visit(CelExpr expr, CelList createList) { for (CelExpr elem : createList.elements()) { visit(elem); } diff --git a/common/src/main/java/dev/cel/common/ast/CelMutableExpr.java b/common/src/main/java/dev/cel/common/ast/CelMutableExpr.java index ff2c83285..4e7990179 100644 --- a/common/src/main/java/dev/cel/common/ast/CelMutableExpr.java +++ b/common/src/main/java/dev/cel/common/ast/CelMutableExpr.java @@ -87,19 +87,19 @@ public CelMutableCall call() { @Override public CelMutableCreateList createList() { - checkExprKind(Kind.CREATE_LIST); + checkExprKind(Kind.LIST); return (CelMutableCreateList) exprValue; } @Override public CelMutableCreateStruct createStruct() { - checkExprKind(Kind.CREATE_STRUCT); + checkExprKind(Kind.STRUCT); return (CelMutableCreateStruct) exprValue; } @Override public CelMutableCreateMap createMap() { - checkExprKind(Kind.CREATE_MAP); + checkExprKind(Kind.MAP); return (CelMutableCreateMap) exprValue; } @@ -130,17 +130,17 @@ public void setCall(CelMutableCall call) { } public void setCreateList(CelMutableCreateList createList) { - this.exprKind = ExprKind.Kind.CREATE_LIST; + this.exprKind = ExprKind.Kind.LIST; this.exprValue = checkNotNull(createList); } public void setCreateStruct(CelMutableCreateStruct createStruct) { - this.exprKind = ExprKind.Kind.CREATE_STRUCT; + this.exprKind = ExprKind.Kind.STRUCT; this.exprValue = checkNotNull(createStruct); } public void setCreateMap(CelMutableCreateMap createMap) { - this.exprKind = ExprKind.Kind.CREATE_MAP; + this.exprKind = ExprKind.Kind.MAP; this.exprValue = checkNotNull(createMap); } @@ -1079,13 +1079,13 @@ private CelMutableExpr(CelMutableExpr other) { case CALL: this.exprValue = other.call().deepCopy(); break; - case CREATE_LIST: + case LIST: this.exprValue = other.createList().deepCopy(); break; - case CREATE_STRUCT: + case STRUCT: this.exprValue = other.createStruct().deepCopy(); break; - case CREATE_MAP: + case MAP: this.exprValue = other.createMap().deepCopy(); break; case COMPREHENSION: @@ -1108,11 +1108,11 @@ private Object exprValue() { return select(); case CALL: return call(); - case CREATE_LIST: + case LIST: return createList(); - case CREATE_STRUCT: + case STRUCT: return createStruct(); - case CREATE_MAP: + case MAP: return createMap(); case COMPREHENSION: return comprehension(); diff --git a/common/src/main/java/dev/cel/common/ast/CelMutableExprConverter.java b/common/src/main/java/dev/cel/common/ast/CelMutableExprConverter.java index 1f72f0132..cf5fc6b94 100644 --- a/common/src/main/java/dev/cel/common/ast/CelMutableExprConverter.java +++ b/common/src/main/java/dev/cel/common/ast/CelMutableExprConverter.java @@ -20,10 +20,10 @@ import com.google.common.collect.ImmutableList; import dev.cel.common.ast.CelExpr.CelCall; import dev.cel.common.ast.CelExpr.CelComprehension; -import dev.cel.common.ast.CelExpr.CelCreateList; -import dev.cel.common.ast.CelExpr.CelCreateMap; -import dev.cel.common.ast.CelExpr.CelCreateStruct; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; import dev.cel.common.ast.CelMutableExpr.CelMutableCall; import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; import dev.cel.common.ast.CelMutableExpr.CelMutableCreateList; @@ -65,16 +65,16 @@ public static CelMutableExpr fromCelExpr(CelExpr celExpr) { : CelMutableCall.create(celCall.function(), args); return CelMutableExpr.ofCall(celExpr.id(), mutableCall); - case CREATE_LIST: - CelCreateList createList = celExpr.createList(); + case LIST: + CelList createList = celExpr.createList(); return CelMutableExpr.ofCreateList( celExpr.id(), CelMutableCreateList.create( fromCelExprList(createList.elements()), createList.optionalIndices())); - case CREATE_STRUCT: + case STRUCT: return CelMutableExpr.ofCreateStruct( celExpr.id(), fromCelStructToMutableStruct(celExpr.createStruct())); - case CREATE_MAP: + case MAP: return CelMutableExpr.ofCreateMap( celExpr.id(), fromCelMapToMutableMap(celExpr.createMap())); case COMPREHENSION: @@ -105,10 +105,9 @@ private static List fromCelExprList(Iterable celExprLis return mutableExprList; } - private static CelMutableCreateStruct fromCelStructToMutableStruct( - CelCreateStruct celCreateStruct) { + private static CelMutableCreateStruct fromCelStructToMutableStruct(CelStruct celCreateStruct) { List entries = new ArrayList<>(); - for (CelCreateStruct.Entry celStructExprEntry : celCreateStruct.entries()) { + for (CelStruct.Entry celStructExprEntry : celCreateStruct.entries()) { entries.add( CelMutableCreateStruct.Entry.create( celStructExprEntry.id(), @@ -120,9 +119,9 @@ private static CelMutableCreateStruct fromCelStructToMutableStruct( return CelMutableCreateStruct.create(celCreateStruct.messageName(), entries); } - private static CelMutableCreateMap fromCelMapToMutableMap(CelCreateMap celCreateMap) { + private static CelMutableCreateMap fromCelMapToMutableMap(CelMap celCreateMap) { List entries = new ArrayList<>(); - for (CelCreateMap.Entry celMapExprEntry : celCreateMap.entries()) { + for (CelMap.Entry celMapExprEntry : celCreateMap.entries()) { entries.add( CelMutableCreateMap.Entry.create( celMapExprEntry.id(), @@ -154,19 +153,19 @@ public static CelExpr fromMutableExpr(CelMutableExpr mutableExpr) { Optional targetExpr = mutableCall.target().map(CelMutableExprConverter::fromMutableExpr); return CelExpr.ofCall(id, targetExpr, mutableCall.function(), args); - case CREATE_LIST: + case LIST: CelMutableCreateList mutableCreateList = mutableExpr.createList(); return CelExpr.ofCreateList( id, fromMutableExprList(mutableCreateList.elements()), ImmutableList.copyOf(mutableCreateList.optionalIndices())); - case CREATE_STRUCT: + case STRUCT: CelMutableCreateStruct mutableCreateStruct = mutableExpr.createStruct(); return CelExpr.newBuilder() .setId(id) .setCreateStruct(fromMutableStructToCelStruct(mutableCreateStruct)) .build(); - case CREATE_MAP: + case MAP: CelMutableCreateMap mutableCreateMap = mutableExpr.createMap(); return CelExpr.newBuilder() .setId(id) @@ -199,9 +198,9 @@ private static ImmutableList fromMutableExprList( return celExprList.build(); } - private static CelCreateStruct fromMutableStructToCelStruct( + private static CelStruct fromMutableStructToCelStruct( CelMutableCreateStruct mutableCreateStruct) { - List entries = new ArrayList<>(); + List entries = new ArrayList<>(); for (CelMutableCreateStruct.Entry mutableStructEntry : mutableCreateStruct.entries()) { entries.add( CelExpr.ofCreateStructEntry( @@ -211,14 +210,14 @@ private static CelCreateStruct fromMutableStructToCelStruct( mutableStructEntry.optionalEntry())); } - return CelCreateStruct.newBuilder() + return CelStruct.newBuilder() .setMessageName(mutableCreateStruct.messageName()) .addEntries(entries) .build(); } - private static CelCreateMap fromMutableMapToCelMap(CelMutableCreateMap mutableCreateMap) { - List entries = new ArrayList<>(); + private static CelMap fromMutableMapToCelMap(CelMutableCreateMap mutableCreateMap) { + List entries = new ArrayList<>(); for (CelMutableCreateMap.Entry mutableMapEntry : mutableCreateMap.entries()) { entries.add( CelExpr.ofCreateMapEntry( @@ -228,7 +227,7 @@ private static CelCreateMap fromMutableMapToCelMap(CelMutableCreateMap mutableCr mutableMapEntry.optionalEntry())); } - return CelCreateMap.newBuilder().addEntries(entries).build(); + return CelMap.newBuilder().addEntries(entries).build(); } private CelMutableExprConverter() {} diff --git a/common/src/main/java/dev/cel/common/navigation/CelNavigableExprVisitor.java b/common/src/main/java/dev/cel/common/navigation/CelNavigableExprVisitor.java index 73cfecd0b..06956d425 100644 --- a/common/src/main/java/dev/cel/common/navigation/CelNavigableExprVisitor.java +++ b/common/src/main/java/dev/cel/common/navigation/CelNavigableExprVisitor.java @@ -105,16 +105,16 @@ private void visit(T navigableExpr) { case CALL: visit(navigableExpr, navigableExpr.expr().call()); break; - case CREATE_LIST: + case LIST: visit(navigableExpr, navigableExpr.expr().createList()); break; case SELECT: visit(navigableExpr, navigableExpr.expr().select()); break; - case CREATE_STRUCT: + case STRUCT: visitStruct(navigableExpr, navigableExpr.expr().createStruct()); break; - case CREATE_MAP: + case MAP: visitMap(navigableExpr, navigableExpr.expr().createMap()); break; case COMPREHENSION: diff --git a/common/src/main/java/dev/cel/common/navigation/ExprPropertyCalculator.java b/common/src/main/java/dev/cel/common/navigation/ExprPropertyCalculator.java index 63097a1e3..f939f3b4b 100644 --- a/common/src/main/java/dev/cel/common/navigation/ExprPropertyCalculator.java +++ b/common/src/main/java/dev/cel/common/navigation/ExprPropertyCalculator.java @@ -54,16 +54,16 @@ private ExprProperty visit(E expr) { case CALL: visitedProperty = visit(expr.call()); break; - case CREATE_LIST: + case LIST: visitedProperty = visit(expr.createList()); break; case SELECT: visitedProperty = visit(expr.select()); break; - case CREATE_STRUCT: + case STRUCT: visitedProperty = visitStruct(expr.createStruct()); break; - case CREATE_MAP: + case MAP: visitedProperty = visitMap(expr.createMap()); break; case COMPREHENSION: diff --git a/common/src/test/java/dev/cel/common/ast/CelExprTest.java b/common/src/test/java/dev/cel/common/ast/CelExprTest.java index c9663978c..5df979e41 100644 --- a/common/src/test/java/dev/cel/common/ast/CelExprTest.java +++ b/common/src/test/java/dev/cel/common/ast/CelExprTest.java @@ -21,11 +21,11 @@ import com.google.testing.junit.testparameterinjector.TestParameterInjector; import dev.cel.common.ast.CelExpr.CelCall; import dev.cel.common.ast.CelExpr.CelComprehension; -import dev.cel.common.ast.CelExpr.CelCreateList; -import dev.cel.common.ast.CelExpr.CelCreateMap; -import dev.cel.common.ast.CelExpr.CelCreateStruct; import dev.cel.common.ast.CelExpr.CelIdent; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; import dev.cel.common.ast.CelExpr.ExprKind; import dev.cel.common.ast.CelExpr.ExprKind.Kind; import org.junit.Test; @@ -66,15 +66,11 @@ private enum BuilderExprKindTestCase { .build()) .build(), Kind.SELECT), - CREATE_MAP( - CelExpr.newBuilder().setCreateMap(CelCreateMap.newBuilder().build()).build(), - Kind.CREATE_MAP), + CREATE_MAP(CelExpr.newBuilder().setCreateMap(CelMap.newBuilder().build()).build(), Kind.MAP), CREATE_LIST( - CelExpr.newBuilder().setCreateList(CelCreateList.newBuilder().build()).build(), - Kind.CREATE_LIST), + CelExpr.newBuilder().setCreateList(CelList.newBuilder().build()).build(), Kind.LIST), CREATE_STRUCT( - CelExpr.newBuilder().setCreateStruct(CelCreateStruct.newBuilder().build()).build(), - Kind.CREATE_STRUCT), + CelExpr.newBuilder().setCreateStruct(CelStruct.newBuilder().build()).build(), Kind.STRUCT), COMPREHENSION( CelExpr.newBuilder() .setComprehension( @@ -204,10 +200,8 @@ public void celExprBuilder_setSelect() { @Test public void celExprBuilder_setCreateList() { - CelCreateList celCreateList = - CelCreateList.newBuilder() - .addElements(CelExpr.ofConstant(1, CelConstant.ofValue(2))) - .build(); + CelList celCreateList = + CelList.newBuilder().addElements(CelExpr.ofConstant(1, CelConstant.ofValue(2))).build(); CelExpr celExpr = CelExpr.newBuilder().setCreateList(celCreateList).build(); assertThat(celExpr.createList()).isEqualTo(celCreateList); @@ -216,10 +210,8 @@ public void celExprBuilder_setCreateList() { @Test public void createListBuilder_getArgs() { - CelCreateList celCreateList = - CelCreateList.newBuilder() - .addElements(CelExpr.ofConstant(1, CelConstant.ofValue(2))) - .build(); + CelList celCreateList = + CelList.newBuilder().addElements(CelExpr.ofConstant(1, CelConstant.ofValue(2))).build(); assertThat(celCreateList.toBuilder().getElements()) .containsExactly(CelExpr.ofConstant(1, CelConstant.ofValue(2))); @@ -227,8 +219,8 @@ public void createListBuilder_getArgs() { @Test public void celExprBuilder_setCreateList_setElementByIndex() { - CelCreateList celCreateList = - CelCreateList.newBuilder() + CelList celCreateList = + CelList.newBuilder() .addElements( CelExpr.ofConstant(5, CelConstant.ofValue("hello")), CelExpr.ofConstant(6, CelConstant.ofValue(5))) @@ -244,7 +236,7 @@ public void celExprBuilder_setCreateList_setElementByIndex() { assertThat(celExpr.createList()) .isEqualTo( - CelCreateList.newBuilder() + CelList.newBuilder() .addElements( CelExpr.ofConstant(5, CelConstant.ofValue("hello")), CelExpr.ofConstant(7, CelConstant.ofValue("world"))) @@ -253,10 +245,10 @@ public void celExprBuilder_setCreateList_setElementByIndex() { @Test public void celExprBuilder_setCreateStruct() { - CelCreateStruct celCreateStruct = - CelCreateStruct.newBuilder() + CelStruct celCreateStruct = + CelStruct.newBuilder() .addEntries( - CelCreateStruct.Entry.newBuilder() + CelStruct.Entry.newBuilder() .setId(1) .setValue(CelExpr.newBuilder().build()) .setFieldKey("field_key") @@ -271,10 +263,10 @@ public void celExprBuilder_setCreateStruct() { @Test public void createStructBuilder_getArgs() { - CelCreateStruct celCreateStruct = - CelCreateStruct.newBuilder() + CelStruct celCreateStruct = + CelStruct.newBuilder() .addEntries( - CelCreateStruct.Entry.newBuilder() + CelStruct.Entry.newBuilder() .setId(1) .setValue(CelExpr.newBuilder().build()) .setFieldKey("field_key") @@ -283,7 +275,7 @@ public void createStructBuilder_getArgs() { assertThat(celCreateStruct.toBuilder().getEntries()) .containsExactly( - CelCreateStruct.Entry.newBuilder() + CelStruct.Entry.newBuilder() .setId(1) .setValue(CelExpr.newBuilder().build()) .setFieldKey("field_key") @@ -292,19 +284,18 @@ public void createStructBuilder_getArgs() { @Test public void celExprBuilder_setCreateStruct_setEntryByIndex() { - CelCreateStruct celCreateStruct = - CelCreateStruct.newBuilder() + CelStruct celCreateStruct = + CelStruct.newBuilder() .addEntries( - CelCreateStruct.Entry.newBuilder() + CelStruct.Entry.newBuilder() .setId(2) .setValue( CelExpr.ofConstant(5, CelConstant.ofValue("hello")).toBuilder().build()) .setFieldKey("field_key") .build(), - CelCreateStruct.Entry.newBuilder() + CelStruct.Entry.newBuilder() .setId(3) - .setValue( - CelExpr.ofConstant(6, CelConstant.ofValue(100)).toBuilder().build()) + .setValue(CelExpr.ofConstant(6, CelConstant.ofValue(100)).toBuilder().build()) .setFieldKey("field_key") .build()) .build(); @@ -315,7 +306,7 @@ public void celExprBuilder_setCreateStruct_setEntryByIndex() { celCreateStruct.toBuilder() .setEntry( 1, - CelCreateStruct.Entry.newBuilder() + CelStruct.Entry.newBuilder() .setId(4) .setValue( CelExpr.ofConstant(6, CelConstant.ofValue("world")).toBuilder() @@ -327,20 +318,18 @@ public void celExprBuilder_setCreateStruct_setEntryByIndex() { assertThat(celExpr.createStruct()) .isEqualTo( - CelCreateStruct.newBuilder() + CelStruct.newBuilder() .addEntries( - CelCreateStruct.Entry.newBuilder() + CelStruct.Entry.newBuilder() .setId(2) .setValue( - CelExpr.ofConstant(5, CelConstant.ofValue("hello")).toBuilder() - .build()) + CelExpr.ofConstant(5, CelConstant.ofValue("hello")).toBuilder().build()) .setFieldKey("field_key") .build(), - CelCreateStruct.Entry.newBuilder() + CelStruct.Entry.newBuilder() .setId(4) .setValue( - CelExpr.ofConstant(6, CelConstant.ofValue("world")).toBuilder() - .build()) + CelExpr.ofConstant(6, CelConstant.ofValue("world")).toBuilder().build()) .setFieldKey("field_key") .build()) .build()); @@ -388,17 +377,17 @@ public void getUnderlyingExpression_unmatchedKind_throws( assertThrows(UnsupportedOperationException.class, testCase.expr::call); assertThrows(UnsupportedOperationException.class, () -> testCase.expr.toBuilder().call()); } - if (!testCase.expectedExprKind.equals(Kind.CREATE_LIST)) { + if (!testCase.expectedExprKind.equals(Kind.LIST)) { assertThrows(UnsupportedOperationException.class, testCase.expr::createList); assertThrows( UnsupportedOperationException.class, () -> testCase.expr.toBuilder().createList()); } - if (!testCase.expectedExprKind.equals(Kind.CREATE_STRUCT)) { + if (!testCase.expectedExprKind.equals(Kind.STRUCT)) { assertThrows(UnsupportedOperationException.class, testCase.expr::createStruct); assertThrows( UnsupportedOperationException.class, () -> testCase.expr.toBuilder().createStruct()); } - if (!testCase.expectedExprKind.equals(Kind.CREATE_MAP)) { + if (!testCase.expectedExprKind.equals(Kind.MAP)) { assertThrows(UnsupportedOperationException.class, testCase.expr::createMap); assertThrows( UnsupportedOperationException.class, () -> testCase.expr.toBuilder().createMap()); @@ -425,15 +414,14 @@ public void getDefault_unmatchedKind_returnsDefaultInstance( if (!testCase.expectedExprKind.equals(Kind.CALL)) { assertThat(testCase.expr.callOrDefault()).isEqualTo(CelCall.newBuilder().build()); } - if (!testCase.expectedExprKind.equals(Kind.CREATE_LIST)) { - assertThat(testCase.expr.createListOrDefault()).isEqualTo(CelCreateList.newBuilder().build()); + if (!testCase.expectedExprKind.equals(Kind.LIST)) { + assertThat(testCase.expr.createListOrDefault()).isEqualTo(CelList.newBuilder().build()); } - if (!testCase.expectedExprKind.equals(Kind.CREATE_STRUCT)) { - assertThat(testCase.expr.createStructOrDefault()) - .isEqualTo(CelCreateStruct.newBuilder().build()); + if (!testCase.expectedExprKind.equals(Kind.STRUCT)) { + assertThat(testCase.expr.createStructOrDefault()).isEqualTo(CelStruct.newBuilder().build()); } - if (!testCase.expectedExprKind.equals(Kind.CREATE_MAP)) { - assertThat(testCase.expr.createMapOrDefault()).isEqualTo(CelCreateMap.newBuilder().build()); + if (!testCase.expectedExprKind.equals(Kind.MAP)) { + assertThat(testCase.expr.createMapOrDefault()).isEqualTo(CelMap.newBuilder().build()); } if (!testCase.expectedExprKind.equals(Kind.COMPREHENSION)) { assertThat(testCase.expr.comprehensionOrDefault()) @@ -460,13 +448,13 @@ public void getDefault_matchedKind_returnsUnderlyingExpression( case CALL: assertThat(testCase.expr.callOrDefault()).isEqualTo(testCase.expr.call()); break; - case CREATE_LIST: + case LIST: assertThat(testCase.expr.createListOrDefault()).isEqualTo(testCase.expr.createList()); break; - case CREATE_STRUCT: + case STRUCT: assertThat(testCase.expr.createStructOrDefault()).isEqualTo(testCase.expr.createStruct()); break; - case CREATE_MAP: + case MAP: assertThat(testCase.expr.createMapOrDefault()).isEqualTo(testCase.expr.createMap()); break; case COMPREHENSION: @@ -477,22 +465,19 @@ public void getDefault_matchedKind_returnsUnderlyingExpression( @Test public void celCreateMapEntry_keyOrValueNotSet_throws() { - assertThrows(IllegalStateException.class, () -> CelCreateMap.Entry.newBuilder().build()); + assertThrows(IllegalStateException.class, () -> CelMap.Entry.newBuilder().build()); assertThrows( IllegalStateException.class, - () -> CelCreateMap.Entry.newBuilder().setKey(CelExpr.ofNotSet(1)).build()); + () -> CelMap.Entry.newBuilder().setKey(CelExpr.ofNotSet(1)).build()); assertThrows( IllegalStateException.class, - () -> CelCreateMap.Entry.newBuilder().setValue(CelExpr.ofNotSet(1)).build()); + () -> CelMap.Entry.newBuilder().setValue(CelExpr.ofNotSet(1)).build()); } @Test public void celCreateMapEntry_default() { - CelCreateMap.Entry entry = - CelCreateMap.Entry.newBuilder() - .setKey(CelExpr.ofNotSet(1)) - .setValue(CelExpr.ofNotSet(2)) - .build(); + CelMap.Entry entry = + CelMap.Entry.newBuilder().setKey(CelExpr.ofNotSet(1)).setValue(CelExpr.ofNotSet(2)).build(); assertThat(entry.id()).isEqualTo(0); assertThat(entry.optionalEntry()).isFalse(); @@ -500,22 +485,19 @@ public void celCreateMapEntry_default() { @Test public void celCreateStructEntry_fieldKeyOrValueNotSet_throws() { - assertThrows(IllegalStateException.class, () -> CelCreateStruct.Entry.newBuilder().build()); + assertThrows(IllegalStateException.class, () -> CelStruct.Entry.newBuilder().build()); assertThrows( IllegalStateException.class, - () -> CelCreateStruct.Entry.newBuilder().setFieldKey("fieldKey").build()); + () -> CelStruct.Entry.newBuilder().setFieldKey("fieldKey").build()); assertThrows( IllegalStateException.class, - () -> CelCreateStruct.Entry.newBuilder().setValue(CelExpr.ofNotSet(1)).build()); + () -> CelStruct.Entry.newBuilder().setValue(CelExpr.ofNotSet(1)).build()); } @Test public void celCreateStructEntry_default() { - CelCreateStruct.Entry entry = - CelCreateStruct.Entry.newBuilder() - .setFieldKey("fieldKey") - .setValue(CelExpr.ofNotSet(1)) - .build(); + CelStruct.Entry entry = + CelStruct.Entry.newBuilder().setFieldKey("fieldKey").setValue(CelExpr.ofNotSet(1)).build(); assertThat(entry.id()).isEqualTo(0); assertThat(entry.optionalEntry()).isFalse(); diff --git a/common/src/test/java/dev/cel/common/ast/CelExprVisitorTest.java b/common/src/test/java/dev/cel/common/ast/CelExprVisitorTest.java index 5cfcef44e..cec7fa4fa 100644 --- a/common/src/test/java/dev/cel/common/ast/CelExprVisitorTest.java +++ b/common/src/test/java/dev/cel/common/ast/CelExprVisitorTest.java @@ -22,12 +22,12 @@ import dev.cel.common.CelAbstractSyntaxTree; import dev.cel.common.ast.CelExpr.CelCall; import dev.cel.common.ast.CelExpr.CelComprehension; -import dev.cel.common.ast.CelExpr.CelCreateList; -import dev.cel.common.ast.CelExpr.CelCreateMap; -import dev.cel.common.ast.CelExpr.CelCreateStruct; -import dev.cel.common.ast.CelExpr.CelCreateStruct.Entry; import dev.cel.common.ast.CelExpr.CelIdent; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; +import dev.cel.common.ast.CelExpr.CelStruct.Entry; import dev.cel.common.types.SimpleType; import dev.cel.compiler.CelCompiler; import dev.cel.compiler.CelCompilerFactory; @@ -53,11 +53,11 @@ public abstract static class VisitedReference { public abstract Optional call(); - public abstract Optional createStruct(); + public abstract Optional createStruct(); - public abstract Optional createMap(); + public abstract Optional createMap(); - public abstract Optional createList(); + public abstract Optional createList(); public abstract Optional comprehension(); @@ -73,11 +73,11 @@ public abstract static class Builder { public abstract Builder setCall(CelCall value); - public abstract Builder setCreateStruct(CelCreateStruct value); + public abstract Builder setCreateStruct(CelStruct value); - public abstract Builder setCreateMap(CelCreateMap value); + public abstract Builder setCreateMap(CelMap value); - public abstract Builder setCreateList(CelCreateList value); + public abstract Builder setCreateList(CelList value); public abstract Builder setComprehension(CelComprehension value); @@ -124,19 +124,19 @@ protected void visit(CelExpr expr, CelCall call) { } @Override - protected void visit(CelExpr expr, CelCreateStruct createStruct) { + protected void visit(CelExpr expr, CelStruct createStruct) { visitedReference.setCreateStruct(createStruct); super.visit(expr, createStruct); } @Override - protected void visit(CelExpr expr, CelCreateMap createMap) { + protected void visit(CelExpr expr, CelMap createMap) { visitedReference.setCreateMap(createMap); super.visit(expr, createMap); } @Override - protected void visit(CelExpr expr, CelCreateList createList) { + protected void visit(CelExpr expr, CelList createList) { visitedReference.setCreateList(createList); super.visit(expr, createList); } @@ -204,17 +204,14 @@ public void visitSelect() throws Exception { assertThat(visited) .isEqualTo( VisitedReference.newBuilder() - .setCreateStruct( - CelCreateStruct.newBuilder().setMessageName("TestAllTypes").build()) + .setCreateStruct(CelStruct.newBuilder().setMessageName("TestAllTypes").build()) .setSelect( CelSelect.newBuilder() .setOperand( CelExpr.newBuilder() .setId(1) .setCreateStruct( - CelCreateStruct.newBuilder() - .setMessageName("TestAllTypes") - .build()) + CelStruct.newBuilder().setMessageName("TestAllTypes").build()) .build()) .setField("single_int64") .build()) @@ -262,7 +259,7 @@ public void visitCreateStruct_fieldkey() throws Exception { VisitedReference.newBuilder() .setConstant(longConstant) .setCreateStruct( - CelCreateStruct.newBuilder() + CelStruct.newBuilder() .addEntries( Entry.newBuilder() .setId(2) @@ -287,9 +284,9 @@ public void visitCreateMap() throws Exception { VisitedReference.newBuilder() .setConstant(CelConstant.ofValue("b")) .setCreateMap( - CelCreateMap.newBuilder() + CelMap.newBuilder() .addEntries( - CelCreateMap.Entry.newBuilder() + CelMap.Entry.newBuilder() .setId(2) .setKey(CelExpr.ofConstant(3, CelConstant.ofValue("a"))) .setValue(CelExpr.ofConstant(4, CelConstant.ofValue("b"))) @@ -312,7 +309,7 @@ public void visitCreateList() throws Exception { VisitedReference.newBuilder() .setConstant(integerVal) .setCreateList( - CelCreateList.newBuilder() + CelList.newBuilder() .addElements(CelExpr.newBuilder().setId(2).setConstant(integerVal).build()) .addElements(CelExpr.newBuilder().setId(3).setConstant(integerVal).build()) .build()) diff --git a/common/src/test/java/dev/cel/common/ast/CelMutableExprConverterTest.java b/common/src/test/java/dev/cel/common/ast/CelMutableExprConverterTest.java index 06e8ff41e..2d0419bd4 100644 --- a/common/src/test/java/dev/cel/common/ast/CelMutableExprConverterTest.java +++ b/common/src/test/java/dev/cel/common/ast/CelMutableExprConverterTest.java @@ -23,8 +23,8 @@ import com.google.testing.junit.testparameterinjector.TestParameter; import com.google.testing.junit.testparameterinjector.TestParameterInjector; import dev.cel.common.ast.CelExpr.CelCall; -import dev.cel.common.ast.CelExpr.CelCreateList; -import dev.cel.common.ast.CelExpr.CelCreateStruct; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelStruct; import dev.cel.common.ast.CelMutableExpr.CelMutableCall; import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; import dev.cel.common.ast.CelMutableExpr.CelMutableCreateList; @@ -199,7 +199,7 @@ public void convertCelCall_toMutableCall() { } @Test - public void convertMutableCreateList_toCelCreateList() { + public void convertMutableCreateList_toCelList() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateList( 1L, @@ -222,7 +222,7 @@ public void convertMutableCreateList_toCelCreateList() { } @Test - public void convertCelCreateList_toMutableCreateList() { + public void convertCelList_toMutableCreateList() { CelExpr celExpr = CelExpr.ofCreateList( 1L, @@ -245,7 +245,7 @@ public void convertCelCreateList_toMutableCreateList() { } @Test - public void convertMutableCreateStruct_toCelCreateStruct() { + public void convertMutableCreateStruct_toCelStruct() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateStruct( 8L, @@ -266,7 +266,7 @@ public void convertMutableCreateStruct_toCelCreateStruct() { 8L, "message", ImmutableList.of( - CelCreateStruct.Entry.newBuilder() + CelStruct.Entry.newBuilder() .setId(9L) .setFieldKey("field") .setValue(CelExpr.ofConstant(10L, CelConstant.ofValue("value"))) @@ -275,13 +275,13 @@ public void convertMutableCreateStruct_toCelCreateStruct() { } @Test - public void convertCelCreateStruct_toMutableCreateStruct() { + public void convertCelStruct_toMutableCreateStruct() { CelExpr celExpr = CelExpr.ofCreateStruct( 8L, "message", ImmutableList.of( - CelCreateStruct.Entry.newBuilder() + CelStruct.Entry.newBuilder() .setId(9L) .setFieldKey("field") .setValue(CelExpr.ofConstant(10L, CelConstant.ofValue("value"))) @@ -305,7 +305,7 @@ public void convertCelCreateStruct_toMutableCreateStruct() { } @Test - public void convertMutableCreateMap_toCelCreateMap() { + public void convertMutableCreateMap_toCelMap() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateMap( 9L, @@ -332,7 +332,7 @@ public void convertMutableCreateMap_toCelCreateMap() { } @Test - public void convertCelCreateMap_toMutableCreateMap() { + public void convertCelMap_toMutableCreateMap() { CelExpr celExpr = CelExpr.ofCreateMap( 9L, @@ -385,7 +385,7 @@ public void convertMutableComprehension_toCelComprehension() { CelExpr.newBuilder() .setId(2L) .setCreateList( - CelCreateList.newBuilder() + CelList.newBuilder() .addElements(CelExpr.ofConstant(3L, CelConstant.ofValue(true))) .build()) .build(), @@ -405,7 +405,7 @@ public void convertCelComprehension_toMutableComprehension() { CelExpr.newBuilder() .setId(2L) .setCreateList( - CelCreateList.newBuilder() + CelList.newBuilder() .addElements(CelExpr.ofConstant(3L, CelConstant.ofValue(true))) .build()) .build(), diff --git a/common/src/test/java/dev/cel/common/ast/CelMutableExprTest.java b/common/src/test/java/dev/cel/common/ast/CelMutableExprTest.java index 90901fc05..22f60fa04 100644 --- a/common/src/test/java/dev/cel/common/ast/CelMutableExprTest.java +++ b/common/src/test/java/dev/cel/common/ast/CelMutableExprTest.java @@ -886,13 +886,13 @@ public void getExprValue_invalidKind_throws(@TestParameter MutableExprKindTestCa if (!testCaseKind.equals(Kind.CALL)) { assertThrows(IllegalArgumentException.class, testCase.mutableExpr::call); } - if (!testCaseKind.equals(Kind.CREATE_LIST)) { + if (!testCaseKind.equals(Kind.LIST)) { assertThrows(IllegalArgumentException.class, testCase.mutableExpr::createList); } - if (!testCaseKind.equals(Kind.CREATE_STRUCT)) { + if (!testCaseKind.equals(Kind.STRUCT)) { assertThrows(IllegalArgumentException.class, testCase.mutableExpr::createStruct); } - if (!testCaseKind.equals(Kind.CREATE_MAP)) { + if (!testCaseKind.equals(Kind.MAP)) { assertThrows(IllegalArgumentException.class, testCase.mutableExpr::createMap); } if (!testCaseKind.equals(Kind.COMPREHENSION)) { diff --git a/common/src/test/java/dev/cel/common/navigation/CelNavigableExprVisitorTest.java b/common/src/test/java/dev/cel/common/navigation/CelNavigableExprVisitorTest.java index 18c71cb28..e2429c7db 100644 --- a/common/src/test/java/dev/cel/common/navigation/CelNavigableExprVisitorTest.java +++ b/common/src/test/java/dev/cel/common/navigation/CelNavigableExprVisitorTest.java @@ -446,12 +446,12 @@ public void stringFormatCall_filterList_success() throws Exception { navigableAst .getRoot() .allNodes() - .filter(x -> x.getKind().equals(Kind.CREATE_LIST)) + .filter(x -> x.getKind().equals(Kind.LIST)) .collect(toImmutableList()); assertThat(allConstants).hasSize(1); CelNavigableExpr listExpr = allConstants.get(0); - assertThat(listExpr.getKind()).isEqualTo(Kind.CREATE_LIST); + assertThat(listExpr.getKind()).isEqualTo(Kind.LIST); assertThat(listExpr.parent()).isPresent(); CelNavigableExpr stringFormatExpr = listExpr.parent().get(); assertThat(stringFormatExpr.getKind()).isEqualTo(Kind.CALL); @@ -613,7 +613,7 @@ public void messageConstruction_filterCreateStruct_allNodesReturned() throws Exc navigableAst .getRoot() .allNodes() - .filter(x -> x.getKind().equals(Kind.CREATE_STRUCT)) + .filter(x -> x.getKind().equals(Kind.STRUCT)) .collect(toImmutableList()); assertThat(allNodes).hasSize(1); @@ -718,7 +718,7 @@ public void mapConstruction_filterCreateMap_allNodesReturned() throws Exception navigableAst .getRoot() .allNodes() - .filter(x -> x.getKind().equals(Kind.CREATE_MAP)) + .filter(x -> x.getKind().equals(Kind.MAP)) .collect(toImmutableList()); assertThat(allNodes).hasSize(1); diff --git a/extensions/src/main/java/dev/cel/extensions/CelMathExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelMathExtensions.java index 7326cabf9..59e51e366 100644 --- a/extensions/src/main/java/dev/cel/extensions/CelMathExtensions.java +++ b/extensions/src/main/java/dev/cel/extensions/CelMathExtensions.java @@ -526,7 +526,7 @@ private static Optional checkInvalidArgument( private static Optional checkInvalidArgumentSingleArg( CelMacroExprFactory exprFactory, String functionName, CelExpr argument) { - if (argument.exprKind().getKind() == Kind.CREATE_LIST) { + if (argument.exprKind().getKind() == Kind.LIST) { if (argument.createList().elements().isEmpty()) { return newError( exprFactory, String.format("%s invalid single argument value", functionName), argument); @@ -548,9 +548,9 @@ private static boolean isArgumentValidType(CelExpr argument) { return constant.getKind() == CelConstant.Kind.INT64_VALUE || constant.getKind() == CelConstant.Kind.UINT64_VALUE || constant.getKind() == CelConstant.Kind.DOUBLE_VALUE; - } else if (argument.exprKind().getKind().equals(Kind.CREATE_LIST) - || argument.exprKind().getKind().equals(Kind.CREATE_STRUCT) - || argument.exprKind().getKind().equals(Kind.CREATE_MAP)) { + } else if (argument.exprKind().getKind().equals(Kind.LIST) + || argument.exprKind().getKind().equals(Kind.STRUCT) + || argument.exprKind().getKind().equals(Kind.MAP)) { return false; } diff --git a/optimizer/src/main/java/dev/cel/optimizer/AstMutator.java b/optimizer/src/main/java/dev/cel/optimizer/AstMutator.java index 7a8b636fb..0dfc6a4dd 100644 --- a/optimizer/src/main/java/dev/cel/optimizer/AstMutator.java +++ b/optimizer/src/main/java/dev/cel/optimizer/AstMutator.java @@ -694,7 +694,7 @@ private CelMutableSource normalizeMacroSource( long replacedId = idGenerator.generate(exprIdToReplace); boolean isListExprBeingReplaced = allExprs.containsKey(replacedId) - && allExprs.get(replacedId).getKind().equals(Kind.CREATE_LIST); + && allExprs.get(replacedId).getKind().equals(Kind.LIST); if (isListExprBeingReplaced) { unwrapListArgumentsInMacroCallExpr( allExprs.get(callId).comprehension(), newMacroCallExpr); @@ -758,8 +758,7 @@ private CelMutableSource normalizeMacroSource( private static void unwrapListArgumentsInMacroCallExpr( CelMutableComprehension comprehension, CelMutableExpr newMacroCallExpr) { CelMutableExpr accuInit = comprehension.accuInit(); - if (!accuInit.getKind().equals(Kind.CREATE_LIST) - || !accuInit.createList().elements().isEmpty()) { + if (!accuInit.getKind().equals(Kind.LIST) || !accuInit.createList().elements().isEmpty()) { // Does not contain an extraneous list. return; } diff --git a/optimizer/src/main/java/dev/cel/optimizer/MutableExprVisitor.java b/optimizer/src/main/java/dev/cel/optimizer/MutableExprVisitor.java index e5109eef0..fd5cf4653 100644 --- a/optimizer/src/main/java/dev/cel/optimizer/MutableExprVisitor.java +++ b/optimizer/src/main/java/dev/cel/optimizer/MutableExprVisitor.java @@ -70,11 +70,11 @@ CelMutableExpr visit(CelMutableExpr root) { return visit(root, root.select()); case CALL: return visit(root, root.call()); - case CREATE_LIST: + case LIST: return visit(root, root.createList()); - case CREATE_STRUCT: + case STRUCT: return visit(root, root.createStruct()); - case CREATE_MAP: + case MAP: return visit(root, root.createMap()); case COMPREHENSION: return visit(root, root.comprehension()); diff --git a/optimizer/src/main/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizer.java b/optimizer/src/main/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizer.java index cd7e7fcd0..588f77405 100644 --- a/optimizer/src/main/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizer.java +++ b/optimizer/src/main/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizer.java @@ -199,9 +199,9 @@ private static boolean areChildrenArgConstant(CelNavigableMutableExpr expr) { } if (expr.getKind().equals(Kind.CALL) - || expr.getKind().equals(Kind.CREATE_LIST) - || expr.getKind().equals(Kind.CREATE_MAP) - || expr.getKind().equals(Kind.CREATE_STRUCT)) { + || expr.getKind().equals(Kind.LIST) + || expr.getKind().equals(Kind.MAP) + || expr.getKind().equals(Kind.STRUCT)) { return expr.children().allMatch(ConstantFoldingOptimizer::areChildrenArgConstant); } @@ -335,7 +335,7 @@ private Optional maybePruneBranches( return Optional.of(astMutator.replaceSubtree(mutableAst, result, expr.id())); } else if (function.equals(Operator.IN.getFunction())) { CelMutableExpr callArg = call.args().get(1); - if (!callArg.getKind().equals(Kind.CREATE_LIST)) { + if (!callArg.getKind().equals(Kind.LIST)) { return Optional.empty(); } @@ -412,21 +412,21 @@ private CelMutableAst pruneOptionalElements(CelMutableAst ast) { .allNodes() .filter( node -> - node.getKind().equals(Kind.CREATE_LIST) - || node.getKind().equals(Kind.CREATE_MAP) - || node.getKind().equals(Kind.CREATE_STRUCT)) + node.getKind().equals(Kind.LIST) + || node.getKind().equals(Kind.MAP) + || node.getKind().equals(Kind.STRUCT)) .map(CelNavigableMutableExpr::expr) .collect(toImmutableList()); for (CelMutableExpr expr : aggregateLiterals) { switch (expr.getKind()) { - case CREATE_LIST: + case LIST: ast = pruneOptionalListElements(ast, expr); break; - case CREATE_MAP: + case MAP: ast = pruneOptionalMapElements(ast, expr); break; - case CREATE_STRUCT: + case STRUCT: ast = pruneOptionalStructElements(ast, expr); break; default: diff --git a/optimizer/src/main/java/dev/cel/optimizer/optimizers/SubexpressionOptimizer.java b/optimizer/src/main/java/dev/cel/optimizer/optimizers/SubexpressionOptimizer.java index 7057eb4ba..e60fd47b2 100644 --- a/optimizer/src/main/java/dev/cel/optimizer/optimizers/SubexpressionOptimizer.java +++ b/optimizer/src/main/java/dev/cel/optimizer/optimizers/SubexpressionOptimizer.java @@ -557,7 +557,7 @@ private boolean canEliminate( && !(navigableExpr.getKind().equals(Kind.IDENT) && navigableExpr.expr().ident().name().startsWith(BIND_IDENTIFIER_PREFIX)) // Exclude empty lists (cel.bind sets this for iterRange). - && !(navigableExpr.getKind().equals(Kind.CREATE_LIST) + && !(navigableExpr.getKind().equals(Kind.LIST) && navigableExpr.expr().createList().elements().isEmpty()) && containsEliminableFunctionOnly(navigableExpr) && !ineligibleExprs.contains(navigableExpr.expr()); diff --git a/parser/src/main/java/dev/cel/parser/CelMacroExprFactory.java b/parser/src/main/java/dev/cel/parser/CelMacroExprFactory.java index 531622486..70adbf510 100644 --- a/parser/src/main/java/dev/cel/parser/CelMacroExprFactory.java +++ b/parser/src/main/java/dev/cel/parser/CelMacroExprFactory.java @@ -85,25 +85,23 @@ public final CelExpr copy(CelExpr expr) { builder.setCall(callBuilder.build()); } break; - case CREATE_LIST: + case LIST: { - CelExpr.CelCreateList.Builder listBuilder = - CelExpr.CelCreateList.newBuilder() - .addOptionalIndices(expr.createList().optionalIndices()); + CelExpr.CelList.Builder listBuilder = + CelExpr.CelList.newBuilder().addOptionalIndices(expr.createList().optionalIndices()); for (CelExpr element : expr.createList().elements()) { listBuilder.addElements(copy(element)); } builder.setCreateList(listBuilder.build()); } break; - case CREATE_STRUCT: + case STRUCT: { - CelExpr.CelCreateStruct.Builder structBuilder = - CelExpr.CelCreateStruct.newBuilder() - .setMessageName(expr.createStruct().messageName()); - for (CelExpr.CelCreateStruct.Entry entry : expr.createStruct().entries()) { + CelExpr.CelStruct.Builder structBuilder = + CelExpr.CelStruct.newBuilder().setMessageName(expr.createStruct().messageName()); + for (CelExpr.CelStruct.Entry entry : expr.createStruct().entries()) { structBuilder.addEntries( - CelExpr.CelCreateStruct.Entry.newBuilder() + CelExpr.CelStruct.Entry.newBuilder() .setId(copyExprId(entry.id())) .setFieldKey(entry.fieldKey()) .setValue(copy(entry.value())) @@ -113,12 +111,12 @@ public final CelExpr copy(CelExpr expr) { builder.setCreateStruct(structBuilder.build()); } break; - case CREATE_MAP: + case MAP: { - CelExpr.CelCreateMap.Builder mapBuilder = CelExpr.CelCreateMap.newBuilder(); - for (CelExpr.CelCreateMap.Entry entry : expr.createMap().entries()) { + CelExpr.CelMap.Builder mapBuilder = CelExpr.CelMap.newBuilder(); + for (CelExpr.CelMap.Entry entry : expr.createMap().entries()) { mapBuilder.addEntries( - CelExpr.CelCreateMap.Entry.newBuilder() + CelExpr.CelMap.Entry.newBuilder() .setId(copyExprId(entry.id())) .setKey(copy(entry.key())) .setValue(copy(entry.value())) diff --git a/parser/src/main/java/dev/cel/parser/CelUnparserVisitor.java b/parser/src/main/java/dev/cel/parser/CelUnparserVisitor.java index 6e8d2350a..b43779ffa 100644 --- a/parser/src/main/java/dev/cel/parser/CelUnparserVisitor.java +++ b/parser/src/main/java/dev/cel/parser/CelUnparserVisitor.java @@ -20,11 +20,11 @@ import dev.cel.common.ast.CelExpr; import dev.cel.common.ast.CelExpr.CelCall; import dev.cel.common.ast.CelExpr.CelComprehension; -import dev.cel.common.ast.CelExpr.CelCreateList; -import dev.cel.common.ast.CelExpr.CelCreateMap; -import dev.cel.common.ast.CelExpr.CelCreateStruct; import dev.cel.common.ast.CelExpr.CelIdent; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; import dev.cel.common.ast.CelExpr.ExprKind.Kind; import dev.cel.common.ast.CelExprVisitor; import java.util.HashSet; @@ -163,7 +163,7 @@ protected void visit(CelExpr expr, CelCall call) { } @Override - protected void visit(CelExpr expr, CelCreateList createList) { + protected void visit(CelExpr expr, CelList createList) { stringBuilder.append(LEFT_BRACKET); HashSet optionalIndices = new HashSet<>(createList.optionalIndices()); for (int i = 0; i < createList.elements().size(); i++) { @@ -179,7 +179,7 @@ protected void visit(CelExpr expr, CelCreateList createList) { } @Override - protected void visit(CelExpr expr, CelCreateStruct createStruct) { + protected void visit(CelExpr expr, CelStruct createStruct) { stringBuilder.append(createStruct.messageName()); stringBuilder.append(LEFT_BRACE); for (int i = 0; i < createStruct.entries().size(); i++) { @@ -187,7 +187,7 @@ protected void visit(CelExpr expr, CelCreateStruct createStruct) { stringBuilder.append(COMMA).append(SPACE); } - CelCreateStruct.Entry e = createStruct.entries().get(i); + CelStruct.Entry e = createStruct.entries().get(i); if (e.optionalEntry()) { stringBuilder.append(QUESTION_MARK); } @@ -199,14 +199,14 @@ protected void visit(CelExpr expr, CelCreateStruct createStruct) { } @Override - protected void visit(CelExpr expr, CelCreateMap createMap) { + protected void visit(CelExpr expr, CelMap createMap) { stringBuilder.append(LEFT_BRACE); for (int i = 0; i < createMap.entries().size(); i++) { if (i > 0) { stringBuilder.append(COMMA).append(SPACE); } - CelCreateMap.Entry e = createMap.entries().get(i); + CelMap.Entry e = createMap.entries().get(i); if (e.optionalEntry()) { stringBuilder.append(QUESTION_MARK); } diff --git a/parser/src/main/java/dev/cel/parser/Parser.java b/parser/src/main/java/dev/cel/parser/Parser.java index 95fac0008..c4b3dffb6 100644 --- a/parser/src/main/java/dev/cel/parser/Parser.java +++ b/parser/src/main/java/dev/cel/parser/Parser.java @@ -524,7 +524,7 @@ public CelExpr visitCreateMessage(CreateMessageContext context) { } CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(context.op); - CelExpr.CelCreateStruct.Builder structExpr = visitStructFields(context.entries); + CelExpr.CelStruct.Builder structExpr = visitStructFields(context.entries); return exprBuilder.setCreateStruct(structExpr.setMessageName(messageName).build()).build(); } @@ -564,13 +564,13 @@ public CelExpr visitNested(NestedContext context) { public CelExpr visitCreateList(CreateListContext context) { checkNotNull(context); CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(context.op); - CelExpr.CelCreateList createListExpr = visitListInitElements(context.listInit()); + CelExpr.CelList createListExpr = visitListInitElements(context.listInit()); return exprBuilder.setCreateList(createListExpr).build(); } - private CelExpr.CelCreateList visitListInitElements(ListInitContext context) { - CelExpr.CelCreateList.Builder listExpr = CelExpr.CelCreateList.newBuilder(); + private CelExpr.CelList visitListInitElements(ListInitContext context) { + CelExpr.CelList.Builder listExpr = CelExpr.CelList.newBuilder(); if (context == null) { return listExpr.build(); } @@ -595,8 +595,7 @@ private CelExpr.CelCreateList visitListInitElements(ListInitContext context) { public CelExpr visitCreateMap(CreateMapContext context) { checkNotNull(context); CelExpr.Builder exprBuilder = exprFactory.newExprBuilder(context.op); - CelExpr.CelCreateMap.Builder createMapExpr = visitMapEntries(context.entries); - // CelExpr.CelCreateStruct.Builder structExpr = visitMapEntries(context.entries); + CelExpr.CelMap.Builder createMapExpr = visitMapEntries(context.entries); return exprBuilder.setCreateMap(createMapExpr.build()).build(); } @@ -664,15 +663,15 @@ private Optional visitMacro( return expandedMacro; } - private CelExpr.CelCreateStruct.Builder visitStructFields(FieldInitializerListContext context) { + private CelExpr.CelStruct.Builder visitStructFields(FieldInitializerListContext context) { if (context == null || context.cols == null || context.fields == null || context.values == null) { - return CelExpr.CelCreateStruct.newBuilder(); + return CelExpr.CelStruct.newBuilder(); } int entryCount = min(context.cols.size(), context.fields.size(), context.values.size()); - CelExpr.CelCreateStruct.Builder structExpr = CelExpr.CelCreateStruct.newBuilder(); + CelExpr.CelStruct.Builder structExpr = CelExpr.CelStruct.newBuilder(); for (int index = 0; index < entryCount; index++) { OptFieldContext fieldContext = context.fields.get(index); boolean isOptionalEntry = false; @@ -686,12 +685,12 @@ private CelExpr.CelCreateStruct.Builder visitStructFields(FieldInitializerListCo // The field may be empty due to a prior error. if (fieldContext.IDENTIFIER() == null) { - return CelExpr.CelCreateStruct.newBuilder(); + return CelExpr.CelStruct.newBuilder(); } String fieldName = fieldContext.IDENTIFIER().getText(); - CelExpr.CelCreateStruct.Entry.Builder exprBuilder = - CelExpr.CelCreateStruct.Entry.newBuilder() + CelExpr.CelStruct.Entry.Builder exprBuilder = + CelExpr.CelStruct.Entry.newBuilder() .setId(exprFactory.newExprId(exprFactory.getPosition(context.cols.get(index)))); structExpr.addEntries( exprBuilder @@ -703,12 +702,12 @@ private CelExpr.CelCreateStruct.Builder visitStructFields(FieldInitializerListCo return structExpr; } - private CelExpr.CelCreateMap.Builder visitMapEntries(MapInitializerListContext context) { + private CelExpr.CelMap.Builder visitMapEntries(MapInitializerListContext context) { if (context == null || context.cols == null || context.keys == null || context.values == null) { - return CelExpr.CelCreateMap.newBuilder(); + return CelExpr.CelMap.newBuilder(); } int entryCount = min(context.cols.size(), context.keys.size(), context.values.size()); - CelExpr.CelCreateMap.Builder mapExpr = CelExpr.CelCreateMap.newBuilder(); + CelExpr.CelMap.Builder mapExpr = CelExpr.CelMap.newBuilder(); for (int index = 0; index < entryCount; index++) { OptExprContext keyContext = context.keys.get(index); boolean isOptionalEntry = false; @@ -719,8 +718,8 @@ private CelExpr.CelCreateMap.Builder visitMapEntries(MapInitializerListContext c isOptionalEntry = true; } } - CelExpr.CelCreateMap.Entry.Builder exprBuilder = - CelExpr.CelCreateMap.Entry.newBuilder() + CelExpr.CelMap.Entry.Builder exprBuilder = + CelExpr.CelMap.Entry.newBuilder() .setId(exprFactory.newExprId(exprFactory.getPosition(context.cols.get(index)))); mapExpr.addEntries( exprBuilder diff --git a/parser/src/test/java/dev/cel/parser/CelMacroExprFactoryTest.java b/parser/src/test/java/dev/cel/parser/CelMacroExprFactoryTest.java index eacd5479c..c14d22c6b 100644 --- a/parser/src/test/java/dev/cel/parser/CelMacroExprFactoryTest.java +++ b/parser/src/test/java/dev/cel/parser/CelMacroExprFactoryTest.java @@ -22,8 +22,8 @@ import dev.cel.common.CelSourceLocation; import dev.cel.common.ast.CelConstant; import dev.cel.common.ast.CelExpr; -import dev.cel.common.ast.CelExpr.CelCreateMap; -import dev.cel.common.ast.CelExpr.CelCreateStruct.Entry; +import dev.cel.common.ast.CelExpr.CelMap; +import dev.cel.common.ast.CelExpr.CelStruct.Entry; import dev.cel.common.ast.CelExpr.ExprKind.Kind; import dev.cel.common.internal.Constants; import org.junit.Test; @@ -155,7 +155,7 @@ public void newList_returnsList() { CelExpr element = exprFactory.newStringLiteral("foo"); CelExpr expr = exprFactory.newList(element); assertThat(expr.id()).isEqualTo(2L); - assertThat(expr.exprKind().getKind()).isEqualTo(Kind.CREATE_LIST); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.LIST); assertThat(expr.createList().elements()).hasSize(1); assertThat(expr.createList().elements()).containsExactly(element); } @@ -163,12 +163,12 @@ public void newList_returnsList() { @Test public void newMap_returnsMap() { TestCelExprFactory exprFactory = new TestCelExprFactory(); - CelCreateMap.Entry entry = + CelMap.Entry entry = exprFactory.newMapEntry( exprFactory.newStringLiteral("foo"), exprFactory.newStringLiteral("bar")); CelExpr expr = exprFactory.newMap(entry); assertThat(expr.id()).isEqualTo(4L); - assertThat(expr.exprKind().getKind()).isEqualTo(Kind.CREATE_MAP); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.MAP); assertThat(expr.createMap().entries()).containsExactly(entry); } @@ -177,7 +177,7 @@ public void newMapEntry_returnsMapEntry() { TestCelExprFactory exprFactory = new TestCelExprFactory(); CelExpr key = exprFactory.newStringLiteral("foo"); CelExpr value = exprFactory.newStringLiteral("bar"); - CelCreateMap.Entry entry = exprFactory.newMapEntry(key, value); + CelMap.Entry entry = exprFactory.newMapEntry(key, value); assertThat(entry.id()).isEqualTo(3L); assertThat(entry.value()).isEqualTo(value); } @@ -188,7 +188,7 @@ public void newMessage_returnsMessage() { Entry field = exprFactory.newMessageField("foo", exprFactory.newStringLiteral("bar")); CelExpr expr = exprFactory.newMessage("google.example.Baz", field); assertThat(expr.id()).isEqualTo(3L); - assertThat(expr.exprKind().getKind()).isEqualTo(Kind.CREATE_STRUCT); + assertThat(expr.exprKind().getKind()).isEqualTo(Kind.STRUCT); assertThat(expr.createStruct().messageName()).isEqualTo("google.example.Baz"); assertThat(expr.createStruct().entries()).containsExactly(field); } diff --git a/parser/src/test/java/dev/cel/parser/CelUnparserImplTest.java b/parser/src/test/java/dev/cel/parser/CelUnparserImplTest.java index 86fb279c0..321db78ef 100644 --- a/parser/src/test/java/dev/cel/parser/CelUnparserImplTest.java +++ b/parser/src/test/java/dev/cel/parser/CelUnparserImplTest.java @@ -26,8 +26,8 @@ import dev.cel.common.CelSource; import dev.cel.common.ast.CelExpr; import dev.cel.common.ast.CelExpr.CelCall; -import dev.cel.common.ast.CelExpr.CelCreateMap; -import dev.cel.common.ast.CelExpr.CelCreateStruct; +import dev.cel.common.ast.CelExpr.CelMap; +import dev.cel.common.ast.CelExpr.CelStruct; import dev.cel.extensions.CelOptionalLibrary; import java.util.Arrays; import java.util.List; @@ -197,10 +197,10 @@ public List provideValues(Context context) { .build(), // bad args CelExpr.newBuilder() .setCreateStruct( - CelCreateStruct.newBuilder() + CelStruct.newBuilder() .setMessageName("Msg") .addEntries( - CelCreateStruct.Entry.newBuilder() + CelStruct.Entry.newBuilder() .setId(0) .setValue(CelExpr.newBuilder().build()) .setFieldKey("field") @@ -209,9 +209,9 @@ public List provideValues(Context context) { .build(), // bad struct CelExpr.newBuilder() .setCreateMap( - CelCreateMap.newBuilder() + CelMap.newBuilder() .addEntries( - CelCreateMap.Entry.newBuilder() + CelMap.Entry.newBuilder() .setId(0) .setValue(CelExpr.newBuilder().build()) .setKey(CelExpr.newBuilder().build()) diff --git a/runtime/src/main/java/dev/cel/runtime/DefaultInterpreter.java b/runtime/src/main/java/dev/cel/runtime/DefaultInterpreter.java index 0579887e9..b535028b0 100644 --- a/runtime/src/main/java/dev/cel/runtime/DefaultInterpreter.java +++ b/runtime/src/main/java/dev/cel/runtime/DefaultInterpreter.java @@ -30,10 +30,10 @@ import dev.cel.common.ast.CelExpr; import dev.cel.common.ast.CelExpr.CelCall; import dev.cel.common.ast.CelExpr.CelComprehension; -import dev.cel.common.ast.CelExpr.CelCreateList; -import dev.cel.common.ast.CelExpr.CelCreateMap; -import dev.cel.common.ast.CelExpr.CelCreateStruct; +import dev.cel.common.ast.CelExpr.CelList; +import dev.cel.common.ast.CelExpr.CelMap; import dev.cel.common.ast.CelExpr.CelSelect; +import dev.cel.common.ast.CelExpr.CelStruct; import dev.cel.common.ast.CelExpr.ExprKind; import dev.cel.common.ast.CelReference; import dev.cel.common.types.CelKind; @@ -201,13 +201,13 @@ private IntermediateResult evalInternal(ExecutionFrame frame, CelExpr expr) case CALL: result = evalCall(frame, expr, expr.call()); break; - case CREATE_LIST: + case LIST: result = evalList(frame, expr, expr.createList()); break; - case CREATE_STRUCT: + case STRUCT: result = evalStruct(frame, expr, expr.createStruct()); break; - case CREATE_MAP: + case MAP: result = evalMap(frame, expr.createMap()); break; case COMPREHENSION: @@ -709,8 +709,7 @@ private IntermediateResult evalBooleanNonstrict(ExecutionFrame frame, CelExpr ex return evalBoolean(frame, expr, /* strict= */ false); } - private IntermediateResult evalList( - ExecutionFrame frame, CelExpr unusedExpr, CelCreateList listExpr) + private IntermediateResult evalList(ExecutionFrame frame, CelExpr unusedExpr, CelList listExpr) throws InterpreterException { CallArgumentChecker argChecker = CallArgumentChecker.create(frame.getResolver()); @@ -742,14 +741,14 @@ private IntermediateResult evalList( return IntermediateResult.create(argChecker.maybeUnknowns().orElse(result)); } - private IntermediateResult evalMap(ExecutionFrame frame, CelCreateMap mapExpr) + private IntermediateResult evalMap(ExecutionFrame frame, CelMap mapExpr) throws InterpreterException { CallArgumentChecker argChecker = CallArgumentChecker.create(frame.getResolver()); Map result = new LinkedHashMap<>(); - for (CelCreateMap.Entry entry : mapExpr.entries()) { + for (CelMap.Entry entry : mapExpr.entries()) { IntermediateResult keyResult = evalInternal(frame, entry.key()); argChecker.checkArg(keyResult); @@ -784,21 +783,20 @@ private IntermediateResult evalMap(ExecutionFrame frame, CelCreateMap mapExpr) return IntermediateResult.create(argChecker.maybeUnknowns().orElse(result)); } - private IntermediateResult evalStruct( - ExecutionFrame frame, CelExpr expr, CelCreateStruct structExpr) + private IntermediateResult evalStruct(ExecutionFrame frame, CelExpr expr, CelStruct structExpr) throws InterpreterException { CelReference reference = ast.getReference(expr.id()) .orElseThrow( () -> new IllegalStateException( - "Could not find a reference for CelCreateStruct expresison at ID: " + "Could not find a reference for CelStruct expresison at ID: " + expr.id())); // Message creation. CallArgumentChecker argChecker = CallArgumentChecker.create(frame.getResolver()); Map fields = new HashMap<>(); - for (CelCreateStruct.Entry entry : structExpr.entries()) { + for (CelStruct.Entry entry : structExpr.entries()) { IntermediateResult fieldResult = evalInternal(frame, entry.value()); // TODO: remove support for IncompleteData InterpreterUtil.completeDataOnly( @@ -903,7 +901,7 @@ private IntermediateResult evalComprehension( private IntermediateResult evalCelBlock( ExecutionFrame frame, CelExpr unusedExpr, CelCall blockCall) throws InterpreterException { - CelCreateList exprList = blockCall.args().get(0).createList(); + CelList exprList = blockCall.args().get(0).createList(); Map blockList = new HashMap<>(); for (int index = 0; index < exprList.elements().size(); index++) { // Register the block indices as lazily evaluated expressions stored as unique identifiers. @@ -935,7 +933,7 @@ private static boolean isLazilyEvaluable(CelComprehension comprehension) { .equals(CelConstant.Kind.BOOLEAN_VALUE) && !comprehension.loopCondition().constant().booleanValue() && comprehension.iterVar().equals("#unused") - && comprehension.iterRange().exprKind().getKind().equals(ExprKind.Kind.CREATE_LIST) + && comprehension.iterRange().exprKind().getKind().equals(ExprKind.Kind.LIST) && comprehension.iterRange().createList().elements().isEmpty(); } diff --git a/runtime/src/test/java/dev/cel/runtime/CelRuntimeTest.java b/runtime/src/test/java/dev/cel/runtime/CelRuntimeTest.java index 8e065ea13..f66690912 100644 --- a/runtime/src/test/java/dev/cel/runtime/CelRuntimeTest.java +++ b/runtime/src/test/java/dev/cel/runtime/CelRuntimeTest.java @@ -312,7 +312,7 @@ public void trace_createStruct() throws Exception { public void trace_createList() throws Exception { CelEvaluationListener listener = (expr, res) -> { - if (expr.exprKind().getKind().equals(Kind.CREATE_LIST)) { + if (expr.exprKind().getKind().equals(Kind.LIST)) { assertThat((List) res).containsExactly(1L, 2L, 3L); assertThat(expr.createList().elements()).hasSize(3); } @@ -330,7 +330,7 @@ public void trace_createList() throws Exception { public void trace_createMap() throws Exception { CelEvaluationListener listener = (expr, res) -> { - if (expr.exprKind().getKind().equals(Kind.CREATE_MAP)) { + if (expr.exprKind().getKind().equals(Kind.MAP)) { assertThat((Map) res).containsExactly(1L, "a"); assertThat(expr.createMap().entries()).hasSize(1); } diff --git a/validator/src/main/java/dev/cel/validator/validators/HomogeneousLiteralValidator.java b/validator/src/main/java/dev/cel/validator/validators/HomogeneousLiteralValidator.java index 45ada6ca3..b47251ccf 100644 --- a/validator/src/main/java/dev/cel/validator/validators/HomogeneousLiteralValidator.java +++ b/validator/src/main/java/dev/cel/validator/validators/HomogeneousLiteralValidator.java @@ -19,7 +19,7 @@ import dev.cel.bundle.Cel; import dev.cel.common.CelAbstractSyntaxTree; import dev.cel.common.ast.CelExpr; -import dev.cel.common.ast.CelExpr.CelCreateMap; +import dev.cel.common.ast.CelExpr.CelMap; import dev.cel.common.ast.CelExpr.ExprKind.Kind; import dev.cel.common.navigation.CelNavigableAst; import dev.cel.common.navigation.CelNavigableExpr; @@ -58,16 +58,14 @@ public void validate(CelNavigableAst navigableAst, Cel cel, IssuesFactory issues navigableAst .getRoot() .allNodes() - .filter( - node -> - node.getKind().equals(Kind.CREATE_LIST) || node.getKind().equals(Kind.CREATE_MAP)) + .filter(node -> node.getKind().equals(Kind.LIST) || node.getKind().equals(Kind.MAP)) .filter(node -> !isExemptFunction(node)) .map(CelNavigableExpr::expr) .forEach( expr -> { - if (expr.exprKind().getKind().equals(Kind.CREATE_LIST)) { + if (expr.exprKind().getKind().equals(Kind.LIST)) { validateList(navigableAst.getAst(), issuesFactory, expr); - } else if (expr.exprKind().getKind().equals(Kind.CREATE_MAP)) { + } else if (expr.exprKind().getKind().equals(Kind.MAP)) { validateMap(navigableAst.getAst(), issuesFactory, expr); } }); @@ -96,7 +94,7 @@ private void validateList(CelAbstractSyntaxTree ast, IssuesFactory issuesFactory private void validateMap(CelAbstractSyntaxTree ast, IssuesFactory issuesFactory, CelExpr expr) { CelType previousKeyType = null; CelType previousValueType = null; - for (CelCreateMap.Entry entry : expr.createMap().entries()) { + for (CelMap.Entry entry : expr.createMap().entries()) { CelType currentKeyType = ast.getType(entry.key().id()).get(); CelType currentValueType = ast.getType(entry.value().id()).get(); if (entry.optionalEntry()) {