From e22ff8587f0faec8a339477b88e63a7c2db8007c Mon Sep 17 00:00:00 2001 From: Sokwhan Huh Date: Tue, 30 Apr 2024 10:59:35 -0700 Subject: [PATCH] Remove modifier create from mutable variants of list, map and struct PiperOrigin-RevId: 629466314 --- .../dev/cel/common/ast/CelMutableExpr.java | 112 +++++++------- .../common/ast/CelMutableExprConverter.java | 39 +++-- .../ast/CelMutableExprConverterTest.java | 30 ++-- .../cel/common/ast/CelMutableExprTest.java | 142 +++++++++--------- .../CelNavigableMutableExprTest.java | 14 +- .../java/dev/cel/optimizer/AstMutator.java | 6 +- .../dev/cel/optimizer/MutableExprVisitor.java | 20 +-- .../optimizers/ConstantFoldingOptimizer.java | 38 +++-- .../dev/cel/optimizer/AstMutatorTest.java | 5 +- 9 files changed, 196 insertions(+), 210 deletions(-) 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 4e7990179..fd4eebaee 100644 --- a/common/src/main/java/dev/cel/common/ast/CelMutableExpr.java +++ b/common/src/main/java/dev/cel/common/ast/CelMutableExpr.java @@ -86,21 +86,21 @@ public CelMutableCall call() { } @Override - public CelMutableCreateList createList() { + public CelMutableList createList() { checkExprKind(Kind.LIST); - return (CelMutableCreateList) exprValue; + return (CelMutableList) exprValue; } @Override - public CelMutableCreateStruct createStruct() { + public CelMutableStruct createStruct() { checkExprKind(Kind.STRUCT); - return (CelMutableCreateStruct) exprValue; + return (CelMutableStruct) exprValue; } @Override - public CelMutableCreateMap createMap() { + public CelMutableMap createMap() { checkExprKind(Kind.MAP); - return (CelMutableCreateMap) exprValue; + return (CelMutableMap) exprValue; } @Override @@ -129,17 +129,17 @@ public void setCall(CelMutableCall call) { this.exprValue = checkNotNull(call); } - public void setCreateList(CelMutableCreateList createList) { + public void setCreateList(CelMutableList createList) { this.exprKind = ExprKind.Kind.LIST; this.exprValue = checkNotNull(createList); } - public void setCreateStruct(CelMutableCreateStruct createStruct) { + public void setCreateStruct(CelMutableStruct createStruct) { this.exprKind = ExprKind.Kind.STRUCT; this.exprValue = checkNotNull(createStruct); } - public void setCreateMap(CelMutableCreateMap createMap) { + public void setCreateMap(CelMutableMap createMap) { this.exprKind = ExprKind.Kind.MAP; this.exprValue = checkNotNull(createMap); } @@ -386,7 +386,7 @@ private CelMutableCall(CelMutableExpr target, String function, List { + public static final class CelMutableList implements Expression.CreateList { private final List elements; private final List optionalIndices; @@ -410,8 +410,8 @@ public boolean equals(Object obj) { if (obj == this) { return true; } - if (obj instanceof CelMutableCreateList) { - CelMutableCreateList that = (CelMutableCreateList) obj; + if (obj instanceof CelMutableList) { + CelMutableList that = (CelMutableList) obj; return this.elements.equals(that.elements()) && this.optionalIndices.equals(that.optionalIndices()); } @@ -430,35 +430,34 @@ public int hashCode() { return h; } - private CelMutableCreateList deepCopy() { + private CelMutableList deepCopy() { return create(deepCopyList(elements), optionalIndices); } - public static CelMutableCreateList create(CelMutableExpr... elements) { + public static CelMutableList create(CelMutableExpr... elements) { return create(Arrays.asList(checkNotNull(elements))); } - public static CelMutableCreateList create(List elements) { + public static CelMutableList create(List elements) { return create(elements, new ArrayList<>()); } - public static CelMutableCreateList create( + public static CelMutableList create( List mutableExprList, List optionalIndices) { - return new CelMutableCreateList(mutableExprList, optionalIndices); + return new CelMutableList(mutableExprList, optionalIndices); } - private CelMutableCreateList( - List mutableExprList, List optionalIndices) { + private CelMutableList(List mutableExprList, List optionalIndices) { this.elements = new ArrayList<>(checkNotNull(mutableExprList)); this.optionalIndices = new ArrayList<>(checkNotNull(optionalIndices)); } } /** A mutable list creation expression. See {@link Expression.CreateStruct} */ - public static final class CelMutableCreateStruct - implements Expression.CreateStruct { + public static final class CelMutableStruct + implements Expression.CreateStruct { private String messageName = ""; - private List entries; + private List entries; @Override public String messageName() { @@ -470,15 +469,15 @@ public void setMessageName(String messageName) { } @Override - public List entries() { + public List entries() { return entries; } - public void setEntries(List entries) { + public void setEntries(List entries) { this.entries = checkNotNull(entries); } - public void setEntry(int index, CelMutableCreateStruct.Entry entry) { + public void setEntry(int index, CelMutableStruct.Entry entry) { checkArgument(index >= 0 && index < entries().size()); entries.set(index, checkNotNull(entry)); } @@ -581,8 +580,8 @@ public boolean equals(Object obj) { if (obj == this) { return true; } - if (obj instanceof CelMutableCreateStruct) { - CelMutableCreateStruct that = (CelMutableCreateStruct) obj; + if (obj instanceof CelMutableStruct) { + CelMutableStruct that = (CelMutableStruct) obj; return this.messageName.equals(that.messageName()) && this.entries.equals(that.entries()); } return false; @@ -598,41 +597,40 @@ public int hashCode() { return h; } - private CelMutableCreateStruct deepCopy() { - ArrayList copiedEntries = new ArrayList<>(); - for (CelMutableCreateStruct.Entry entry : entries) { + private CelMutableStruct deepCopy() { + ArrayList copiedEntries = new ArrayList<>(); + for (CelMutableStruct.Entry entry : entries) { copiedEntries.add(entry.deepCopy()); } return create(messageName, copiedEntries); } - public static CelMutableCreateStruct create( - String messageName, List entries) { - return new CelMutableCreateStruct(messageName, entries); + public static CelMutableStruct create( + String messageName, List entries) { + return new CelMutableStruct(messageName, entries); } - private CelMutableCreateStruct(String messageName, List entries) { + private CelMutableStruct(String messageName, List entries) { this.messageName = checkNotNull(messageName); this.entries = new ArrayList<>(checkNotNull(entries)); } } /** A mutable map creation expression. See {@link Expression.CreateMap} */ - public static final class CelMutableCreateMap - implements Expression.CreateMap { - private List entries; + public static final class CelMutableMap implements Expression.CreateMap { + private List entries; @Override - public List entries() { + public List entries() { return entries; } - public void setEntries(List entries) { + public void setEntries(List entries) { this.entries = checkNotNull(entries); } - public void setEntry(int index, CelMutableCreateMap.Entry entry) { + public void setEntry(int index, CelMutableMap.Entry entry) { checkArgument(index >= 0 && index < entries().size()); entries.set(index, checkNotNull(entry)); } @@ -739,8 +737,8 @@ public boolean equals(Object obj) { if (obj == this) { return true; } - if (obj instanceof CelMutableCreateMap) { - CelMutableCreateMap that = (CelMutableCreateMap) obj; + if (obj instanceof CelMutableMap) { + CelMutableMap that = (CelMutableMap) obj; return this.entries.equals(that.entries()); } return false; @@ -754,20 +752,20 @@ public int hashCode() { return h; } - private CelMutableCreateMap deepCopy() { - ArrayList copiedEntries = new ArrayList<>(); - for (CelMutableCreateMap.Entry entry : entries) { + private CelMutableMap deepCopy() { + ArrayList copiedEntries = new ArrayList<>(); + for (CelMutableMap.Entry entry : entries) { copiedEntries.add(entry.deepCopy()); } return create(copiedEntries); } - public static CelMutableCreateMap create(List entries) { - return new CelMutableCreateMap(new ArrayList<>(entries)); + public static CelMutableMap create(List entries) { + return new CelMutableMap(new ArrayList<>(entries)); } - private CelMutableCreateMap(List entries) { + private CelMutableMap(List entries) { this.entries = checkNotNull(entries); } } @@ -975,27 +973,27 @@ public static CelMutableExpr ofCall(long id, CelMutableCall mutableCall) { return new CelMutableExpr(id, mutableCall); } - public static CelMutableExpr ofCreateList(CelMutableCreateList mutableCreateList) { + public static CelMutableExpr ofCreateList(CelMutableList mutableCreateList) { return ofCreateList(0, mutableCreateList); } - public static CelMutableExpr ofCreateList(long id, CelMutableCreateList mutableCreateList) { + public static CelMutableExpr ofCreateList(long id, CelMutableList mutableCreateList) { return new CelMutableExpr(id, mutableCreateList); } - public static CelMutableExpr ofCreateStruct(CelMutableCreateStruct mutableCreateStruct) { + public static CelMutableExpr ofCreateStruct(CelMutableStruct mutableCreateStruct) { return ofCreateStruct(0, mutableCreateStruct); } - public static CelMutableExpr ofCreateStruct(long id, CelMutableCreateStruct mutableCreateStruct) { + public static CelMutableExpr ofCreateStruct(long id, CelMutableStruct mutableCreateStruct) { return new CelMutableExpr(id, mutableCreateStruct); } - public static CelMutableExpr ofCreateMap(CelMutableCreateMap mutableCreateMap) { + public static CelMutableExpr ofCreateMap(CelMutableMap mutableCreateMap) { return ofCreateMap(0, mutableCreateMap); } - public static CelMutableExpr ofCreateMap(long id, CelMutableCreateMap mutableCreateMap) { + public static CelMutableExpr ofCreateMap(long id, CelMutableMap mutableCreateMap) { return new CelMutableExpr(id, mutableCreateMap); } @@ -1029,17 +1027,17 @@ private CelMutableExpr(long id, CelMutableCall mutableCall) { setCall(mutableCall); } - private CelMutableExpr(long id, CelMutableCreateList mutableCreateList) { + private CelMutableExpr(long id, CelMutableList mutableCreateList) { this.id = id; setCreateList(mutableCreateList); } - private CelMutableExpr(long id, CelMutableCreateStruct mutableCreateStruct) { + private CelMutableExpr(long id, CelMutableStruct mutableCreateStruct) { this.id = id; setCreateStruct(mutableCreateStruct); } - private CelMutableExpr(long id, CelMutableCreateMap mutableCreateMap) { + private CelMutableExpr(long id, CelMutableMap mutableCreateMap) { this.id = id; setCreateMap(mutableCreateMap); } 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 cf5fc6b94..a7c51342d 100644 --- a/common/src/main/java/dev/cel/common/ast/CelMutableExprConverter.java +++ b/common/src/main/java/dev/cel/common/ast/CelMutableExprConverter.java @@ -26,10 +26,10 @@ 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; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateMap; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateStruct; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.ast.CelMutableExpr.CelMutableMap; import dev.cel.common.ast.CelMutableExpr.CelMutableSelect; +import dev.cel.common.ast.CelMutableExpr.CelMutableStruct; import java.util.ArrayList; import java.util.List; import java.util.Optional; @@ -69,7 +69,7 @@ public static CelMutableExpr fromCelExpr(CelExpr celExpr) { CelList createList = celExpr.createList(); return CelMutableExpr.ofCreateList( celExpr.id(), - CelMutableCreateList.create( + CelMutableList.create( fromCelExprList(createList.elements()), createList.optionalIndices())); case STRUCT: return CelMutableExpr.ofCreateStruct( @@ -105,32 +105,32 @@ private static List fromCelExprList(Iterable celExprLis return mutableExprList; } - private static CelMutableCreateStruct fromCelStructToMutableStruct(CelStruct celCreateStruct) { - List entries = new ArrayList<>(); + private static CelMutableStruct fromCelStructToMutableStruct(CelStruct celCreateStruct) { + List entries = new ArrayList<>(); for (CelStruct.Entry celStructExprEntry : celCreateStruct.entries()) { entries.add( - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry.create( celStructExprEntry.id(), celStructExprEntry.fieldKey(), fromCelExpr(celStructExprEntry.value()), celStructExprEntry.optionalEntry())); } - return CelMutableCreateStruct.create(celCreateStruct.messageName(), entries); + return CelMutableStruct.create(celCreateStruct.messageName(), entries); } - private static CelMutableCreateMap fromCelMapToMutableMap(CelMap celCreateMap) { - List entries = new ArrayList<>(); + private static CelMutableMap fromCelMapToMutableMap(CelMap celCreateMap) { + List entries = new ArrayList<>(); for (CelMap.Entry celMapExprEntry : celCreateMap.entries()) { entries.add( - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry.create( celMapExprEntry.id(), fromCelExpr(celMapExprEntry.key()), fromCelExpr(celMapExprEntry.value()), celMapExprEntry.optionalEntry())); } - return CelMutableCreateMap.create(entries); + return CelMutableMap.create(entries); } public static CelExpr fromMutableExpr(CelMutableExpr mutableExpr) { @@ -154,19 +154,19 @@ public static CelExpr fromMutableExpr(CelMutableExpr mutableExpr) { mutableCall.target().map(CelMutableExprConverter::fromMutableExpr); return CelExpr.ofCall(id, targetExpr, mutableCall.function(), args); case LIST: - CelMutableCreateList mutableCreateList = mutableExpr.createList(); + CelMutableList mutableCreateList = mutableExpr.createList(); return CelExpr.ofCreateList( id, fromMutableExprList(mutableCreateList.elements()), ImmutableList.copyOf(mutableCreateList.optionalIndices())); case STRUCT: - CelMutableCreateStruct mutableCreateStruct = mutableExpr.createStruct(); + CelMutableStruct mutableCreateStruct = mutableExpr.createStruct(); return CelExpr.newBuilder() .setId(id) .setCreateStruct(fromMutableStructToCelStruct(mutableCreateStruct)) .build(); case MAP: - CelMutableCreateMap mutableCreateMap = mutableExpr.createMap(); + CelMutableMap mutableCreateMap = mutableExpr.createMap(); return CelExpr.newBuilder() .setId(id) .setCreateMap(fromMutableMapToCelMap(mutableCreateMap)) @@ -198,10 +198,9 @@ private static ImmutableList fromMutableExprList( return celExprList.build(); } - private static CelStruct fromMutableStructToCelStruct( - CelMutableCreateStruct mutableCreateStruct) { + private static CelStruct fromMutableStructToCelStruct(CelMutableStruct mutableCreateStruct) { List entries = new ArrayList<>(); - for (CelMutableCreateStruct.Entry mutableStructEntry : mutableCreateStruct.entries()) { + for (CelMutableStruct.Entry mutableStructEntry : mutableCreateStruct.entries()) { entries.add( CelExpr.ofCreateStructEntry( mutableStructEntry.id(), @@ -216,9 +215,9 @@ private static CelStruct fromMutableStructToCelStruct( .build(); } - private static CelMap fromMutableMapToCelMap(CelMutableCreateMap mutableCreateMap) { + private static CelMap fromMutableMapToCelMap(CelMutableMap mutableCreateMap) { List entries = new ArrayList<>(); - for (CelMutableCreateMap.Entry mutableMapEntry : mutableCreateMap.entries()) { + for (CelMutableMap.Entry mutableMapEntry : mutableCreateMap.entries()) { entries.add( CelExpr.ofCreateMapEntry( mutableMapEntry.id(), 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 2d0419bd4..927c10243 100644 --- a/common/src/test/java/dev/cel/common/ast/CelMutableExprConverterTest.java +++ b/common/src/test/java/dev/cel/common/ast/CelMutableExprConverterTest.java @@ -27,10 +27,10 @@ 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; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateMap; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateStruct; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.ast.CelMutableExpr.CelMutableMap; import dev.cel.common.ast.CelMutableExpr.CelMutableSelect; +import dev.cel.common.ast.CelMutableExpr.CelMutableStruct; import org.junit.Test; import org.junit.runner.RunWith; @@ -203,7 +203,7 @@ public void convertMutableCreateList_toCelList() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateList( 1L, - CelMutableCreateList.create( + CelMutableList.create( ImmutableList.of( CelMutableExpr.ofConstant(2L, CelConstant.ofValue("element1")), CelMutableExpr.ofConstant(3L, CelConstant.ofValue("element2"))), @@ -237,7 +237,7 @@ public void convertCelList_toMutableCreateList() { .isEqualTo( CelMutableExpr.ofCreateList( 1L, - CelMutableCreateList.create( + CelMutableList.create( ImmutableList.of( CelMutableExpr.ofConstant(2L, CelConstant.ofValue("element1")), CelMutableExpr.ofConstant(3L, CelConstant.ofValue("element2"))), @@ -249,10 +249,10 @@ public void convertMutableCreateStruct_toCelStruct() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateStruct( 8L, - CelMutableCreateStruct.create( + CelMutableStruct.create( "message", ImmutableList.of( - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry.create( 9L, "field", CelMutableExpr.ofConstant(10L, CelConstant.ofValue("value")), @@ -294,10 +294,10 @@ public void convertCelStruct_toMutableCreateStruct() { .isEqualTo( CelMutableExpr.ofCreateStruct( 8L, - CelMutableCreateStruct.create( + CelMutableStruct.create( "message", ImmutableList.of( - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry.create( 9L, "field", CelMutableExpr.ofConstant(10L, CelConstant.ofValue("value")), @@ -309,9 +309,9 @@ public void convertMutableCreateMap_toCelMap() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateMap( 9L, - CelMutableCreateMap.create( + CelMutableMap.create( ImmutableList.of( - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry.create( 10L, CelMutableExpr.ofConstant(11L, CelConstant.ofValue("key")), CelMutableExpr.ofConstant(12L, CelConstant.ofValue("value")), @@ -349,9 +349,9 @@ public void convertCelMap_toMutableCreateMap() { .isEqualTo( CelMutableExpr.ofCreateMap( 9L, - CelMutableCreateMap.create( + CelMutableMap.create( ImmutableList.of( - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry.create( 10L, CelMutableExpr.ofConstant(11L, CelConstant.ofValue("key")), CelMutableExpr.ofConstant(12L, CelConstant.ofValue("value")), @@ -367,7 +367,7 @@ public void convertMutableComprehension_toCelComprehension() { "iterVar", CelMutableExpr.ofCreateList( 2L, - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(3L, CelConstant.ofValue(true)))), "accuVar", CelMutableExpr.ofConstant(4L, CelConstant.ofValue(true)), @@ -425,7 +425,7 @@ public void convertCelComprehension_toMutableComprehension() { "iterVar", CelMutableExpr.ofCreateList( 2L, - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(3L, CelConstant.ofValue(true)))), "accuVar", CelMutableExpr.ofConstant(4L, CelConstant.ofValue(true)), 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 22f60fa04..620fe2e8b 100644 --- a/common/src/test/java/dev/cel/common/ast/CelMutableExprTest.java +++ b/common/src/test/java/dev/cel/common/ast/CelMutableExprTest.java @@ -25,11 +25,11 @@ import dev.cel.common.ast.CelExpr.ExprKind.Kind; import dev.cel.common.ast.CelMutableExpr.CelMutableCall; import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateList; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateMap; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateStruct; import dev.cel.common.ast.CelMutableExpr.CelMutableIdent; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.ast.CelMutableExpr.CelMutableMap; import dev.cel.common.ast.CelMutableExpr.CelMutableSelect; +import dev.cel.common.ast.CelMutableExpr.CelMutableStruct; import java.util.ArrayList; import org.junit.Test; import org.junit.runner.RunWith; @@ -317,7 +317,7 @@ public void mutableCall_setFunction() { public void ofCreateList() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateList( - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), CelMutableExpr.ofConstant(CelConstant.ofValue("element2")))); @@ -335,7 +335,7 @@ public void ofCreateList_withId() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateList( 1L, - CelMutableCreateList.create( + CelMutableList.create( ImmutableList.of( CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))), @@ -352,8 +352,8 @@ public void ofCreateList_withId() { @Test public void mutableCreateList_setElementAtIndex() { - CelMutableCreateList createList = - CelMutableCreateList.create(CelMutableExpr.ofConstant(CelConstant.ofValue("element1"))); + CelMutableList createList = + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue("element1"))); createList.setElement(0, CelMutableExpr.ofConstant(CelConstant.ofValue("hello"))); @@ -367,7 +367,7 @@ public void mutableCreateList_setElementAtIndex() { public void mutableCreateList_deepCopy() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateList( - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), CelMutableExpr.ofConstant(CelConstant.ofValue("element2")))); @@ -388,7 +388,7 @@ public void mutableCreateList_deepCopy() { @Test public void ofCreateStruct() { CelMutableExpr mutableExpr = - CelMutableExpr.ofCreateStruct(CelMutableCreateStruct.create("message", ImmutableList.of())); + CelMutableExpr.ofCreateStruct(CelMutableStruct.create("message", ImmutableList.of())); assertThat(mutableExpr.id()).isEqualTo(0L); assertThat(mutableExpr.createStruct().messageName()).isEqualTo("message"); @@ -400,10 +400,10 @@ public void ofCreateStruct_withId() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateStruct( 8L, - CelMutableCreateStruct.create( + CelMutableStruct.create( "message", ImmutableList.of( - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry.create( 9L, "field", CelMutableExpr.ofConstant(CelConstant.ofValue("value")), @@ -413,7 +413,7 @@ public void ofCreateStruct_withId() { assertThat(mutableExpr.createStruct().messageName()).isEqualTo("message"); assertThat(mutableExpr.createStruct().entries()) .containsExactly( - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry.create( 9L, "field", CelMutableExpr.ofConstant(CelConstant.ofValue("value")), @@ -422,14 +422,14 @@ public void ofCreateStruct_withId() { @Test public void mutableCreateStruct_setEntryAtIndex() { - CelMutableCreateStruct createStruct = - CelMutableCreateStruct.create( + CelMutableStruct createStruct = + CelMutableStruct.create( "message", ImmutableList.of( - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry.create( 1L, "field", CelMutableExpr.ofConstant(CelConstant.ofValue("value"))))); - CelMutableCreateStruct.Entry newEntry = - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry newEntry = + CelMutableStruct.Entry.create( 2L, "field2", CelMutableExpr.ofConstant(CelConstant.ofValue("value2")), @@ -442,8 +442,8 @@ public void mutableCreateStruct_setEntryAtIndex() { @Test public void mutableCreateStructEntry_setters() { - CelMutableCreateStruct.Entry createStructEntry = - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry createStructEntry = + CelMutableStruct.Entry.create( 1L, "field", CelMutableExpr.ofConstant(CelConstant.ofValue("value"))); createStructEntry.setId(2L); @@ -453,7 +453,7 @@ public void mutableCreateStructEntry_setters() { assertThat(createStructEntry) .isEqualTo( - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry.create( 2L, "field2", CelMutableExpr.ofConstant(CelConstant.ofValue("value2")), true)); } @@ -463,10 +463,10 @@ public void mutableCreateStruct_deepCopy() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateStruct( 8L, - CelMutableCreateStruct.create( + CelMutableStruct.create( "message", ImmutableList.of( - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry.create( 8L, "field", CelMutableExpr.ofConstant(CelConstant.ofValue("value")), @@ -482,7 +482,7 @@ public void mutableCreateStruct_deepCopy() { .isNotSameInstanceAs(deepCopiedExpr.createStruct().entries()); assertThat(mutableExpr.createStruct().entries()) .comparingElementsUsing( - Correspondence.from( + Correspondence.from( (e1, e2) -> e1 != e2 && e1.equals(e2) @@ -495,7 +495,7 @@ public void mutableCreateStruct_deepCopy() { @Test public void ofCreateMap() { CelMutableExpr mutableExpr = - CelMutableExpr.ofCreateMap(CelMutableCreateMap.create(ImmutableList.of())); + CelMutableExpr.ofCreateMap(CelMutableMap.create(ImmutableList.of())); assertThat(mutableExpr.id()).isEqualTo(0L); assertThat(mutableExpr.createMap().entries()).isEmpty(); @@ -506,9 +506,9 @@ public void ofCreateMap_withId() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateMap( 9L, - CelMutableCreateMap.create( + CelMutableMap.create( ImmutableList.of( - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry.create( 10L, CelMutableExpr.ofConstant(CelConstant.ofValue("key")), CelMutableExpr.ofConstant(CelConstant.ofValue("value")), @@ -517,7 +517,7 @@ public void ofCreateMap_withId() { assertThat(mutableExpr.id()).isEqualTo(9L); assertThat(mutableExpr.createMap().entries()) .containsExactly( - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry.create( 10L, CelMutableExpr.ofConstant(CelConstant.ofValue("key")), CelMutableExpr.ofConstant(CelConstant.ofValue("value")), @@ -526,15 +526,15 @@ public void ofCreateMap_withId() { @Test public void mutableCreateMap_setEntryAtIndex() { - CelMutableCreateMap createMap = - CelMutableCreateMap.create( + CelMutableMap createMap = + CelMutableMap.create( ImmutableList.of( - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry.create( 10L, CelMutableExpr.ofConstant(CelConstant.ofValue("key")), CelMutableExpr.ofConstant(CelConstant.ofValue("value"))))); - CelMutableCreateMap.Entry newEntry = - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry newEntry = + CelMutableMap.Entry.create( 2L, CelMutableExpr.ofConstant(CelConstant.ofValue("key2")), CelMutableExpr.ofConstant(CelConstant.ofValue("value2")), @@ -547,8 +547,8 @@ public void mutableCreateMap_setEntryAtIndex() { @Test public void mutableCreateMapEntry_setters() { - CelMutableCreateMap.Entry createMapEntry = - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry createMapEntry = + CelMutableMap.Entry.create( 1L, CelMutableExpr.ofConstant(CelConstant.ofValue("key")), CelMutableExpr.ofConstant(CelConstant.ofValue("value"))); @@ -560,7 +560,7 @@ public void mutableCreateMapEntry_setters() { assertThat(createMapEntry) .isEqualTo( - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry.create( 2L, CelMutableExpr.ofConstant(CelConstant.ofValue("key2")), CelMutableExpr.ofConstant(CelConstant.ofValue("value2")), @@ -573,9 +573,9 @@ public void mutableCreateMap_deepCopy() { CelMutableExpr mutableExpr = CelMutableExpr.ofCreateMap( 9L, - CelMutableCreateMap.create( + CelMutableMap.create( ImmutableList.of( - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry.create( 10L, CelMutableExpr.ofConstant(CelConstant.ofValue("key")), CelMutableExpr.ofConstant(CelConstant.ofValue("value")), @@ -589,7 +589,7 @@ public void mutableCreateMap_deepCopy() { assertThat(mutableExpr.createMap()).isNotSameInstanceAs(deepCopiedExpr.createMap()); assertThat(mutableExpr.createMap().entries()) .comparingElementsUsing( - Correspondence.from( + Correspondence.from( (e1, e2) -> e1 != e2 && e1.equals(e2) @@ -609,8 +609,7 @@ public void ofComprehension_withId() { CelMutableComprehension.create( "iterVar", CelMutableExpr.ofCreateList( - CelMutableCreateList.create( - CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), "accuVar", CelMutableExpr.ofConstant(CelConstant.ofValue(true)), CelMutableExpr.ofConstant(CelConstant.ofValue(true)), @@ -623,8 +622,7 @@ public void ofComprehension_withId() { CelMutableComprehension.create( "iterVar", CelMutableExpr.ofCreateList( - CelMutableCreateList.create( - CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), "accuVar", CelMutableExpr.ofConstant(CelConstant.ofValue(true)), CelMutableExpr.ofConstant(CelConstant.ofValue(true)), @@ -648,7 +646,7 @@ public void mutableComprehension_setters() { mutableComprehension.setAccuVar("accuVar2"); mutableComprehension.setIterRange( CelMutableExpr.ofCreateList( - CelMutableCreateList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true))))); + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true))))); mutableComprehension.setAccuInit(CelMutableExpr.ofConstant(CelConstant.ofValue(true))); mutableComprehension.setLoopCondition(CelMutableExpr.ofConstant(CelConstant.ofValue(true))); mutableComprehension.setLoopStep(CelMutableExpr.ofConstant(CelConstant.ofValue(true))); @@ -659,8 +657,7 @@ public void mutableComprehension_setters() { CelMutableComprehension.create( "iterVar2", CelMutableExpr.ofCreateList( - CelMutableCreateList.create( - CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), "accuVar2", CelMutableExpr.ofConstant(CelConstant.ofValue(true)), CelMutableExpr.ofConstant(CelConstant.ofValue(true)), @@ -676,8 +673,7 @@ public void mutableComprehension_deepCopy() { CelMutableComprehension.create( "iterVar", CelMutableExpr.ofCreateList( - CelMutableCreateList.create( - CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), "accuVar", CelMutableExpr.ofConstant(CelConstant.ofValue(true)), CelMutableExpr.ofConstant(CelConstant.ofValue(true)), @@ -744,55 +740,53 @@ public void equalityTest() { CelMutableExpr.ofConstant(CelConstant.ofValue("target")), "function", CelMutableExpr.ofConstant(CelConstant.ofValue("arg"))))) - .addEqualityGroup(CelMutableExpr.ofCreateList(CelMutableCreateList.create())) + .addEqualityGroup(CelMutableExpr.ofCreateList(CelMutableList.create())) .addEqualityGroup( CelMutableExpr.ofCreateList( 6L, - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), CelMutableExpr.ofConstant(CelConstant.ofValue("element2")))), CelMutableExpr.ofCreateList( 6L, - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))))) .addEqualityGroup( - CelMutableExpr.ofCreateStruct( - CelMutableCreateStruct.create("message", ImmutableList.of()))) + CelMutableExpr.ofCreateStruct(CelMutableStruct.create("message", ImmutableList.of()))) .addEqualityGroup( CelMutableExpr.ofCreateStruct( 7L, - CelMutableCreateStruct.create( + CelMutableStruct.create( "message", ImmutableList.of( - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry.create( 8L, "field", CelMutableExpr.ofConstant(CelConstant.ofValue("value")), /* optionalEntry= */ true)))), CelMutableExpr.ofCreateStruct( 7L, - CelMutableCreateStruct.create( + CelMutableStruct.create( "message", ImmutableList.of( - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry.create( 8L, "field", CelMutableExpr.ofConstant(CelConstant.ofValue("value")), /* optionalEntry= */ true))))) + .addEqualityGroup(CelMutableExpr.ofCreateMap(CelMutableMap.create(ImmutableList.of()))) .addEqualityGroup( - CelMutableExpr.ofCreateMap(CelMutableCreateMap.create(ImmutableList.of()))) - .addEqualityGroup( - CelMutableCreateMap.create( + CelMutableMap.create( ImmutableList.of( - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry.create( 9L, CelMutableExpr.ofConstant(CelConstant.ofValue("key")), CelMutableExpr.ofConstant(CelConstant.ofValue("value")), /* optionalEntry= */ true))), - CelMutableCreateMap.create( + CelMutableMap.create( ImmutableList.of( - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry.create( 9L, CelMutableExpr.ofConstant(CelConstant.ofValue("key")), CelMutableExpr.ofConstant(CelConstant.ofValue("value")), @@ -814,7 +808,7 @@ public void equalityTest() { CelMutableComprehension.create( "iterVar", CelMutableExpr.ofCreateList( - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), "accuVar", CelMutableExpr.ofConstant(CelConstant.ofValue(true)), @@ -826,7 +820,7 @@ public void equalityTest() { CelMutableComprehension.create( "iterVar", CelMutableExpr.ofCreateList( - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), "accuVar", CelMutableExpr.ofConstant(CelConstant.ofValue(true)), @@ -843,11 +837,10 @@ private enum MutableExprKindTestCase { IDENT(CelMutableExpr.ofIdent("test")), SELECT(CelMutableExpr.ofSelect(CelMutableSelect.create(CelMutableExpr.ofNotSet(), "field"))), CALL(CelMutableExpr.ofCall(CelMutableCall.create("call"))), - CREATE_LIST(CelMutableExpr.ofCreateList(CelMutableCreateList.create())), + CREATE_LIST(CelMutableExpr.ofCreateList(CelMutableList.create())), CREATE_STRUCT( - CelMutableExpr.ofCreateStruct( - CelMutableCreateStruct.create("message", ImmutableList.of()))), - CREATE_MAP(CelMutableExpr.ofCreateMap(CelMutableCreateMap.create(ImmutableList.of()))), + CelMutableExpr.ofCreateStruct(CelMutableStruct.create("message", ImmutableList.of()))), + CREATE_MAP(CelMutableExpr.ofCreateMap(CelMutableMap.create(ImmutableList.of()))), COMPREHENSION( CelMutableExpr.ofComprehension( 10L, @@ -921,17 +914,17 @@ private enum HashCodeTestCase { CREATE_LIST( CelMutableExpr.ofCreateList( 6L, - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), CelMutableExpr.ofConstant(CelConstant.ofValue("element2")))), 165341403), CREATE_STRUCT( CelMutableExpr.ofCreateStruct( 7L, - CelMutableCreateStruct.create( + CelMutableStruct.create( "message", ImmutableList.of( - CelMutableCreateStruct.Entry.create( + CelMutableStruct.Entry.create( 8L, "field", CelMutableExpr.ofConstant(CelConstant.ofValue("value")), @@ -940,9 +933,9 @@ private enum HashCodeTestCase { CREATE_MAP( CelMutableExpr.ofCreateMap( 8L, - CelMutableCreateMap.create( + CelMutableMap.create( ImmutableList.of( - CelMutableCreateMap.Entry.create( + CelMutableMap.Entry.create( 9L, CelMutableExpr.ofConstant(CelConstant.ofValue("key")), CelMutableExpr.ofConstant(CelConstant.ofValue("value")), @@ -954,8 +947,7 @@ private enum HashCodeTestCase { CelMutableComprehension.create( "iterVar", CelMutableExpr.ofCreateList( - CelMutableCreateList.create( - CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(true)))), "accuVar", CelMutableExpr.ofConstant(CelConstant.ofValue(true)), CelMutableExpr.ofConstant(CelConstant.ofValue(true)), diff --git a/common/src/test/java/dev/cel/common/navigation/CelNavigableMutableExprTest.java b/common/src/test/java/dev/cel/common/navigation/CelNavigableMutableExprTest.java index 7d6a9e0f7..a4e8d455a 100644 --- a/common/src/test/java/dev/cel/common/navigation/CelNavigableMutableExprTest.java +++ b/common/src/test/java/dev/cel/common/navigation/CelNavigableMutableExprTest.java @@ -21,7 +21,7 @@ import dev.cel.common.ast.CelConstant; import dev.cel.common.ast.CelExpr.ExprKind.Kind; import dev.cel.common.ast.CelMutableExpr; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateList; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @@ -81,10 +81,10 @@ public void allNodes_filteredConstants_returnsAllConstants() { CelNavigableMutableExpr mutableExpr = CelNavigableMutableExpr.fromExpr( CelMutableExpr.ofCreateList( - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), CelMutableExpr.ofCreateList( - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))))))); ImmutableList allNodes = @@ -106,10 +106,10 @@ public void descendants_filteredConstants_returnsAllConstants() { CelNavigableMutableExpr mutableExpr = CelNavigableMutableExpr.fromExpr( CelMutableExpr.ofCreateList( - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), CelMutableExpr.ofCreateList( - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))))))); ImmutableList allNodes = @@ -131,10 +131,10 @@ public void children_filteredConstants_returnsSingleConstant() { CelNavigableMutableExpr mutableExpr = CelNavigableMutableExpr.fromExpr( CelMutableExpr.ofCreateList( - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue("element1")), CelMutableExpr.ofCreateList( - CelMutableCreateList.create( + CelMutableList.create( CelMutableExpr.ofConstant(CelConstant.ofValue("element2"))))))); ImmutableList allNodes = diff --git a/optimizer/src/main/java/dev/cel/optimizer/AstMutator.java b/optimizer/src/main/java/dev/cel/optimizer/AstMutator.java index 0dfc6a4dd..2159b14a8 100644 --- a/optimizer/src/main/java/dev/cel/optimizer/AstMutator.java +++ b/optimizer/src/main/java/dev/cel/optimizer/AstMutator.java @@ -35,7 +35,7 @@ import dev.cel.common.ast.CelMutableExpr; import dev.cel.common.ast.CelMutableExpr.CelMutableCall; import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateList; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; import dev.cel.common.navigation.CelNavigableMutableAst; import dev.cel.common.navigation.CelNavigableMutableExpr; import dev.cel.common.navigation.TraversalOrder; @@ -90,7 +90,7 @@ public CelMutableAst wrapAstWithNewCelBlock( ++maxId, CelMutableCall.create( celBlockFunction, - CelMutableExpr.ofCreateList(++maxId, CelMutableCreateList.create(subexpressions)), + CelMutableExpr.ofCreateList(++maxId, CelMutableList.create(subexpressions)), ast.expr())); return CelMutableAst.of(blockExpr, ast.source()); @@ -569,7 +569,7 @@ private CelMutableExpr newBindMacroExpr( comprehensionId, CelMutableComprehension.create( "#unused", - CelMutableExpr.ofCreateList(iterRangeId, CelMutableCreateList.create()), + CelMutableExpr.ofCreateList(iterRangeId, CelMutableList.create()), varName, varInit, CelMutableExpr.ofConstant(loopConditionId, CelConstant.ofValue(false)), diff --git a/optimizer/src/main/java/dev/cel/optimizer/MutableExprVisitor.java b/optimizer/src/main/java/dev/cel/optimizer/MutableExprVisitor.java index fd5cf4653..d9ecb70c9 100644 --- a/optimizer/src/main/java/dev/cel/optimizer/MutableExprVisitor.java +++ b/optimizer/src/main/java/dev/cel/optimizer/MutableExprVisitor.java @@ -21,10 +21,10 @@ import dev.cel.common.ast.CelMutableExpr; import dev.cel.common.ast.CelMutableExpr.CelMutableCall; import dev.cel.common.ast.CelMutableExpr.CelMutableComprehension; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateList; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateMap; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateStruct; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.ast.CelMutableExpr.CelMutableMap; import dev.cel.common.ast.CelMutableExpr.CelMutableSelect; +import dev.cel.common.ast.CelMutableExpr.CelMutableStruct; import java.util.List; /** @@ -107,9 +107,9 @@ private CelMutableExpr visit(CelMutableExpr expr, CelMutableCall call) { } @CanIgnoreReturnValue - private CelMutableExpr visit(CelMutableExpr expr, CelMutableCreateStruct createStruct) { - List entries = createStruct.entries(); - for (CelMutableCreateStruct.Entry entry : entries) { + private CelMutableExpr visit(CelMutableExpr expr, CelMutableStruct createStruct) { + List entries = createStruct.entries(); + for (CelMutableStruct.Entry entry : entries) { entry.setId(celExprIdGenerator.generate(entry.id())); entry.setValue(visit(entry.value())); } @@ -118,9 +118,9 @@ private CelMutableExpr visit(CelMutableExpr expr, CelMutableCreateStruct createS } @CanIgnoreReturnValue - private CelMutableExpr visit(CelMutableExpr expr, CelMutableCreateMap createMap) { - List entriesBuilders = createMap.entries(); - for (CelMutableCreateMap.Entry entry : entriesBuilders) { + private CelMutableExpr visit(CelMutableExpr expr, CelMutableMap createMap) { + List entriesBuilders = createMap.entries(); + for (CelMutableMap.Entry entry : entriesBuilders) { entry.setId(celExprIdGenerator.generate(entry.id())); entry.setKey(visit(entry.key())); entry.setValue(visit(entry.value())); @@ -130,7 +130,7 @@ private CelMutableExpr visit(CelMutableExpr expr, CelMutableCreateMap createMap) } @CanIgnoreReturnValue - private CelMutableExpr visit(CelMutableExpr expr, CelMutableCreateList createList) { + private CelMutableExpr visit(CelMutableExpr expr, CelMutableList createList) { List elementsBuilders = createList.elements(); for (int i = 0; i < elementsBuilders.size(); i++) { CelMutableExpr elem = elementsBuilders.get(i); 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 588f77405..bef87765b 100644 --- a/optimizer/src/main/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizer.java +++ b/optimizer/src/main/java/dev/cel/optimizer/optimizers/ConstantFoldingOptimizer.java @@ -27,9 +27,9 @@ import dev.cel.common.ast.CelExprUtil; import dev.cel.common.ast.CelMutableExpr; import dev.cel.common.ast.CelMutableExpr.CelMutableCall; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateList; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateMap; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateStruct; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; +import dev.cel.common.ast.CelMutableExpr.CelMutableMap; +import dev.cel.common.ast.CelMutableExpr.CelMutableStruct; import dev.cel.common.ast.CelMutableExprConverter; import dev.cel.common.navigation.CelNavigableMutableAst; import dev.cel.common.navigation.CelNavigableMutableExpr; @@ -258,10 +258,10 @@ private Optional maybeAdaptEvaluatedResult(Object result) { listElements.add(adaptedExpr); } - return Optional.of(CelMutableExpr.ofCreateList(CelMutableCreateList.create(listElements))); + return Optional.of(CelMutableExpr.ofCreateList(CelMutableList.create(listElements))); } else if (result instanceof Map) { Map map = (Map) result; - List mapEntries = new ArrayList<>(); + List mapEntries = new ArrayList<>(); for (Entry entry : map.entrySet()) { CelMutableExpr adaptedKey = maybeAdaptEvaluatedResult(entry.getKey()).orElse(null); if (adaptedKey == null) { @@ -272,10 +272,10 @@ private Optional maybeAdaptEvaluatedResult(Object result) { return Optional.empty(); } - mapEntries.add(CelMutableCreateMap.Entry.create(adaptedKey, adaptedValue)); + mapEntries.add(CelMutableMap.Entry.create(adaptedKey, adaptedValue)); } - return Optional.of(CelMutableExpr.ofCreateMap(CelMutableCreateMap.create(mapEntries))); + return Optional.of(CelMutableExpr.ofCreateMap(CelMutableMap.create(mapEntries))); } // Evaluated result cannot be folded (e.g: unknowns) @@ -339,7 +339,7 @@ private Optional maybePruneBranches( return Optional.empty(); } - CelMutableCreateList haystack = callArg.createList(); + CelMutableList haystack = callArg.createList(); if (haystack.elements().isEmpty()) { return Optional.of( astMutator.replaceSubtree( @@ -438,7 +438,7 @@ private CelMutableAst pruneOptionalElements(CelMutableAst ast) { } private CelMutableAst pruneOptionalListElements(CelMutableAst mutableAst, CelMutableExpr expr) { - CelMutableCreateList createList = expr.createList(); + CelMutableList createList = expr.createList(); if (createList.optionalIndices().isEmpty()) { return mutableAst; } @@ -478,16 +478,15 @@ private CelMutableAst pruneOptionalListElements(CelMutableAst mutableAst, CelMut return astMutator.replaceSubtree( mutableAst, CelMutableExpr.ofCreateList( - CelMutableCreateList.create(updatedElemBuilder.build(), updatedIndicesBuilder.build())), + CelMutableList.create(updatedElemBuilder.build(), updatedIndicesBuilder.build())), expr.id()); } private CelMutableAst pruneOptionalMapElements(CelMutableAst ast, CelMutableExpr expr) { - CelMutableCreateMap createMap = expr.createMap(); - ImmutableList.Builder updatedEntryBuilder = - new ImmutableList.Builder<>(); + CelMutableMap createMap = expr.createMap(); + ImmutableList.Builder updatedEntryBuilder = new ImmutableList.Builder<>(); boolean modified = false; - for (CelMutableCreateMap.Entry entry : createMap.entries()) { + for (CelMutableMap.Entry entry : createMap.entries()) { CelMutableExpr key = entry.key(); Kind keyKind = key.getKind(); CelMutableExpr value = entry.value(); @@ -521,7 +520,7 @@ private CelMutableAst pruneOptionalMapElements(CelMutableAst ast, CelMutableExpr if (modified) { return astMutator.replaceSubtree( ast, - CelMutableExpr.ofCreateMap(CelMutableCreateMap.create(updatedEntryBuilder.build())), + CelMutableExpr.ofCreateMap(CelMutableMap.create(updatedEntryBuilder.build())), expr.id()); } @@ -529,11 +528,11 @@ private CelMutableAst pruneOptionalMapElements(CelMutableAst ast, CelMutableExpr } private CelMutableAst pruneOptionalStructElements(CelMutableAst ast, CelMutableExpr expr) { - CelMutableCreateStruct createStruct = expr.createStruct(); - ImmutableList.Builder updatedEntryBuilder = + CelMutableStruct createStruct = expr.createStruct(); + ImmutableList.Builder updatedEntryBuilder = new ImmutableList.Builder<>(); boolean modified = false; - for (CelMutableCreateStruct.Entry entry : createStruct.entries()) { + for (CelMutableStruct.Entry entry : createStruct.entries()) { CelMutableExpr value = entry.value(); Kind valueKind = value.getKind(); if (!entry.optionalEntry() || !valueKind.equals(Kind.CALL)) { @@ -565,8 +564,7 @@ private CelMutableAst pruneOptionalStructElements(CelMutableAst ast, CelMutableE return astMutator.replaceSubtree( ast, CelMutableExpr.ofCreateStruct( - CelMutableCreateStruct.create( - createStruct.messageName(), updatedEntryBuilder.build())), + CelMutableStruct.create(createStruct.messageName(), updatedEntryBuilder.build())), expr.id()); } diff --git a/optimizer/src/test/java/dev/cel/optimizer/AstMutatorTest.java b/optimizer/src/test/java/dev/cel/optimizer/AstMutatorTest.java index e199ea6e2..50c0cc388 100644 --- a/optimizer/src/test/java/dev/cel/optimizer/AstMutatorTest.java +++ b/optimizer/src/test/java/dev/cel/optimizer/AstMutatorTest.java @@ -36,7 +36,7 @@ import dev.cel.common.ast.CelExpr.ExprKind.Kind; import dev.cel.common.ast.CelMutableExpr; import dev.cel.common.ast.CelMutableExpr.CelMutableCall; -import dev.cel.common.ast.CelMutableExpr.CelMutableCreateList; +import dev.cel.common.ast.CelMutableExpr.CelMutableList; import dev.cel.common.ast.CelMutableExpr.CelMutableSelect; import dev.cel.common.ast.CelMutableExprConverter; import dev.cel.common.navigation.CelNavigableAst; @@ -491,8 +491,7 @@ public void replaceSubtree_replaceExtraneousListCreatedByMacro_unparseSuccess() .replaceSubtree( mutableAst, CelMutableExpr.ofCreateList( - CelMutableCreateList.create( - CelMutableExpr.ofConstant(CelConstant.ofValue(2L)))), + CelMutableList.create(CelMutableExpr.ofConstant(CelConstant.ofValue(2L)))), 9L) .toParsedAst(); CelAbstractSyntaxTree mutatedAstWithConstant =