From 138c3fa2c345add404fc6b9290c6ace9bc926848 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Tue, 5 Nov 2024 15:36:49 +0100 Subject: [PATCH 01/23] Apply SourceFileWithTypeReference to ChangePackage and ChangeType --- .../org/openrewrite/trait/TypeReference.java | 12 +++- .../openrewrite/java/ChangePackageTest.java | 23 +++++++ .../org/openrewrite/java/ChangeTypeTest.java | 53 +++++++++++----- .../org/openrewrite/java/ChangePackage.java | 61 +++++++++++++++++-- .../java/org/openrewrite/java/ChangeType.java | 49 +++++++++++++-- .../xml/trait/SpringTypeReference.java | 25 +++++++- 6 files changed, 194 insertions(+), 29 deletions(-) diff --git a/rewrite-core/src/main/java/org/openrewrite/trait/TypeReference.java b/rewrite-core/src/main/java/org/openrewrite/trait/TypeReference.java index 8d2e89140e6..af2897f1e6e 100644 --- a/rewrite-core/src/main/java/org/openrewrite/trait/TypeReference.java +++ b/rewrite-core/src/main/java/org/openrewrite/trait/TypeReference.java @@ -15,9 +15,7 @@ */ package org.openrewrite.trait; -import org.openrewrite.Incubating; -import org.openrewrite.SourceFile; -import org.openrewrite.Tree; +import org.openrewrite.*; import java.util.Set; @@ -26,6 +24,14 @@ public interface TypeReference extends Trait { String getName(); + default boolean supportsRename() { + return false; + } + + default TreeVisitor renameTo(String name) { + throw new UnsupportedOperationException(); + } + default boolean matches(Matcher matcher) { return matcher.matchesName(getName()); } diff --git a/rewrite-java-test/src/test/java/org/openrewrite/java/ChangePackageTest.java b/rewrite-java-test/src/test/java/org/openrewrite/java/ChangePackageTest.java index f21841e0a08..c307f330f27 100644 --- a/rewrite-java-test/src/test/java/org/openrewrite/java/ChangePackageTest.java +++ b/rewrite-java-test/src/test/java/org/openrewrite/java/ChangePackageTest.java @@ -30,6 +30,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.openrewrite.java.Assertions.java; +import static org.openrewrite.xml.Assertions.xml; @SuppressWarnings("ConstantConditions") class ChangePackageTest implements RewriteTest { @@ -1702,4 +1703,26 @@ public enum MyEnum { ) ); } + + @Test + void changePackageInSpringXml() { + rewriteRun( + spec -> spec.recipe(new ChangePackage("test.type", "test.test.type", true)), + xml( + """ + + + + + """, + """ + + + + + """ + ) + ); + + } } diff --git a/rewrite-java-test/src/test/java/org/openrewrite/java/ChangeTypeTest.java b/rewrite-java-test/src/test/java/org/openrewrite/java/ChangeTypeTest.java index b2234b43a47..7ebc390003e 100644 --- a/rewrite-java-test/src/test/java/org/openrewrite/java/ChangeTypeTest.java +++ b/rewrite-java-test/src/test/java/org/openrewrite/java/ChangeTypeTest.java @@ -29,6 +29,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.openrewrite.java.Assertions.java; +import static org.openrewrite.xml.Assertions.xml; @SuppressWarnings("ConstantConditions") class ChangeTypeTest implements RewriteTest { @@ -1981,27 +1982,27 @@ void shouldNotFullyQualifyWhenNewTypeIsAlreadyUsed() { true)), java( """ - package org.a; - - public class A { - public static String A = "A"; - } - """), + package org.a; + + public class A { + public static String A = "A"; + } + """), java( """ - package org.ab; - - public class AB { - public static String A = "A"; - public static String B = "B"; - } - """), + package org.ab; + + public class AB { + public static String A = "A"; + public static String B = "B"; + } + """), // language=java java( """ import org.a.A; import org.ab.AB; - + class Letters { String a = A.A; String b = AB.B; @@ -2009,7 +2010,7 @@ class Letters { """, """ import org.ab.AB; - + class Letters { String a = AB.A; String b = AB.B; @@ -2019,4 +2020,26 @@ class Letters { ); } + @Test + void changeTypeInSpringXml() { + rewriteRun( + spec -> spec.recipe(new ChangeType("test.type.A", "test.type.B", true)), + xml( + """ + + + + + """, + """ + + + + + """ + ) + ); + + } + } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 7d28b412ca0..584ad4ef6da 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -23,10 +23,13 @@ import org.openrewrite.internal.ListUtils; import org.openrewrite.java.tree.*; import org.openrewrite.marker.SearchResult; +import org.openrewrite.trait.TypeReference; import java.nio.file.Paths; +import java.util.HashSet; import java.util.IdentityHashMap; import java.util.Map; +import java.util.Set; import static java.util.Objects.requireNonNull; @@ -83,9 +86,9 @@ public Validated validate() { @Override public TreeVisitor getVisitor() { - JavaIsoVisitor condition = new JavaIsoVisitor() { + TreeVisitor condition = new TreeVisitor() { @Override - public @Nullable J preVisit(J tree, ExecutionContext ctx) { + public @Nullable Tree preVisit(Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { JavaSourceFile cu = (JavaSourceFile) requireNonNull(tree); if (cu.getPackageDeclaration() != null) { @@ -113,14 +116,44 @@ public TreeVisitor getVisitor() { } stopAfterPreVisit(); } + if (tree instanceof SourceFileWithTypeReferences) { + SourceFileWithTypeReferences cu = (SourceFileWithTypeReferences) requireNonNull(tree); + for (TypeReference ref : cu.getTypeReferences().getTypeReferences()) { + if (ref.getName().startsWith(oldPackageName)) { + return SearchResult.found(cu); + } + } + } return super.preVisit(tree, ctx); } }; - return Preconditions.check(condition, new ChangePackageVisitor()); + return Preconditions.check(condition, new TreeVisitor() { + @Override + public boolean isAcceptable(SourceFile sourceFile, ExecutionContext executionContext) { + return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithTypeReferences; + } + + public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { + if (tree instanceof JavaSourceFile) { + return new JavaChangePackageVisitor().visit(tree, ctx); + } else if (tree instanceof SourceFileWithTypeReferences) { + SourceFileWithTypeReferences sourceFile = (SourceFileWithTypeReferences) tree; + SourceFileWithTypeReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); + Set matches = new HashSet<>(); + for (TypeReference ref : typeReferences.getTypeReferences()) { + if (ref.getName().startsWith(oldPackageName)) { + matches.add(ref); + } + } + return new TypeReferenceVisitor(matches, oldPackageName, newPackageName).visit(tree, ctx); + } + return tree; + } + }); } - private class ChangePackageVisitor extends JavaVisitor { + private class JavaChangePackageVisitor extends JavaVisitor { private static final String RENAME_TO_KEY = "renameTo"; private static final String RENAME_FROM_KEY = "renameFrom"; @@ -349,4 +382,24 @@ private boolean isTargetRecursivePackageName(String packageName) { } } + + @Value + @EqualsAndHashCode(callSuper = false) + private static class TypeReferenceVisitor extends TreeVisitor { + Set matches; + String oldPackageName; + String newPackageName; + + @Override + public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { + Tree tree1 = super.visit(tree, ctx); + for (TypeReference ref : matches) { + if (ref.getTree().equals(tree)) { + return ref.renameTo(ref.getName().replace(oldPackageName, newPackageName)).visit(tree, ctx); + } + } + return tree1; + } + } + } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index b3ce211b049..5d22046a221 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -24,6 +24,7 @@ import org.openrewrite.java.tree.*; import org.openrewrite.marker.Markers; import org.openrewrite.marker.SearchResult; +import org.openrewrite.trait.TypeReference; import java.nio.file.Path; import java.nio.file.Paths; @@ -89,14 +90,36 @@ public TreeVisitor getVisitor() { } return new UsesType<>(oldFullyQualifiedTypeName, true).visitNonNull(cu, ctx); } + if (tree instanceof SourceFileWithTypeReferences) { + SourceFileWithTypeReferences cu = (SourceFileWithTypeReferences) requireNonNull(tree); + return new UsesType<>(oldFullyQualifiedTypeName, true).visitNonNull(cu, ctx); + } return tree; } }; - return Preconditions.check(condition, new ChangeTypeVisitor(oldFullyQualifiedTypeName, newFullyQualifiedTypeName, ignoreDefinition)); + return Preconditions.check(condition, new TreeVisitor() { + @Override + public boolean isAcceptable(SourceFile sourceFile, ExecutionContext executionContext) { + return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithTypeReferences; + } + + public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { + if (tree instanceof JavaSourceFile) { + return new JavaChangeTypeVisitor(oldFullyQualifiedTypeName, newFullyQualifiedTypeName, ignoreDefinition).visit(tree, ctx); + } else if (tree instanceof SourceFileWithTypeReferences) { + SourceFileWithTypeReferences sourceFile = (SourceFileWithTypeReferences) tree; + SourceFileWithTypeReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); + TypeMatcher matcher = new TypeMatcher(oldFullyQualifiedTypeName); + Set matches = new HashSet<>(typeReferences.findMatches(matcher)); + return new TypeReferenceVisitor(matches, newFullyQualifiedTypeName).visit(tree, ctx); + } + return tree; + } + }); } - private static class ChangeTypeVisitor extends JavaVisitor { + private static class JavaChangeTypeVisitor extends JavaVisitor { private final JavaType.Class originalType; private final JavaType targetType; @@ -109,7 +132,7 @@ private static class ChangeTypeVisitor extends JavaVisitor { private final Map oldNameToChangedType = new IdentityHashMap<>(); private final Set topLevelClassnames = new HashSet<>(); - private ChangeTypeVisitor(String oldFullyQualifiedTypeName, String newFullyQualifiedTypeName, @Nullable Boolean ignoreDefinition) { + private JavaChangeTypeVisitor(String oldFullyQualifiedTypeName, String newFullyQualifiedTypeName, @Nullable Boolean ignoreDefinition) { this.originalType = JavaType.ShallowClass.build(oldFullyQualifiedTypeName); this.targetType = JavaType.buildType(newFullyQualifiedTypeName); this.ignoreDefinition = ignoreDefinition; @@ -527,6 +550,24 @@ private boolean hasNoConflictingImport(@Nullable JavaSourceFile sf) { } } + @Value + @EqualsAndHashCode(callSuper = false) + private static class TypeReferenceVisitor extends TreeVisitor { + Set matches; + String newFullyQualifiedName; + + @Override + public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { + Tree tree1 = super.visit(tree, ctx); + for (TypeReference ref : matches) { + if (ref.getTree().equals(tree)) { + return ref.renameTo(newFullyQualifiedName).visit(tree, ctx); + } + } + return tree1; + } + } + private static class ChangeClassDefinition extends JavaIsoVisitor { private final JavaType.Class originalType; private final JavaType.Class targetType; @@ -579,7 +620,7 @@ private boolean updatePath(JavaSourceFile sf, String oldPath, String newPath) { } @Override - public J.@Nullable Package visitPackage(J.Package pkg, ExecutionContext ctx) { + public J.@Nullable Package visitPackage(J.Package pkg, ExecutionContext ctx) { Boolean updatePackage = getCursor().pollNearestMessage("UPDATE_PACKAGE"); if (updatePackage != null && updatePackage) { String original = pkg.getExpression().printTrimmed(getCursor()).replaceAll("\\s", ""); diff --git a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java index edc9bdc6e83..6a747f6cac8 100644 --- a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java +++ b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java @@ -17,9 +17,7 @@ import lombok.Value; import org.jspecify.annotations.Nullable; -import org.openrewrite.Cursor; -import org.openrewrite.SourceFile; -import org.openrewrite.Tree; +import org.openrewrite.*; import org.openrewrite.trait.SimpleTraitMatcher; import org.openrewrite.trait.TypeReference; import org.openrewrite.xml.XPathMatcher; @@ -52,6 +50,27 @@ public String getName() { throw new IllegalArgumentException("getTree() must be an Xml.Attribute or Xml.Tag: " + getTree().getClass()); } + @Override + public boolean supportsRename() { + return true; + } + + @Override + public TreeVisitor renameTo(String name) { + return new TreeVisitor() { + @Override + public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext executionContext) { + if (tree instanceof Xml.Attribute) { + return ((Xml.Attribute) tree).withValue(((Xml.Attribute) tree).getValue().withValue(name)); + } + if (tree instanceof Xml.Tag) { + return ((Xml.Tag) tree).withValue(name); + } + return super.visit(tree, executionContext); + } + }; + } + static class Matcher extends SimpleTraitMatcher { private final Pattern typeReference = Pattern.compile("(?:[a-zA-Z_][a-zA-Z0-9_]*\\.)+[A-Z*][a-zA-Z0-9_]*(?:<[a-zA-Z0-9_,?<> ]*>)?"); private final XPathMatcher classXPath = new XPathMatcher("//@class"); From a2d9983f4822576cef759d93b3bcef904c722e73 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Tue, 5 Nov 2024 15:41:36 +0100 Subject: [PATCH 02/23] Revert indent changes --- .../org/openrewrite/java/ChangeTypeTest.java | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/rewrite-java-test/src/test/java/org/openrewrite/java/ChangeTypeTest.java b/rewrite-java-test/src/test/java/org/openrewrite/java/ChangeTypeTest.java index 7ebc390003e..752814a7d40 100644 --- a/rewrite-java-test/src/test/java/org/openrewrite/java/ChangeTypeTest.java +++ b/rewrite-java-test/src/test/java/org/openrewrite/java/ChangeTypeTest.java @@ -1982,27 +1982,27 @@ void shouldNotFullyQualifyWhenNewTypeIsAlreadyUsed() { true)), java( """ - package org.a; - - public class A { - public static String A = "A"; - } - """), + package org.a; + + public class A { + public static String A = "A"; + } + """), java( """ - package org.ab; - - public class AB { - public static String A = "A"; - public static String B = "B"; - } - """), + package org.ab; + + public class AB { + public static String A = "A"; + public static String B = "B"; + } + """), // language=java java( """ import org.a.A; import org.ab.AB; - + class Letters { String a = A.A; String b = AB.B; @@ -2010,7 +2010,7 @@ class Letters { """, """ import org.ab.AB; - + class Letters { String a = AB.A; String b = AB.B; From 6ec8490a52d882b766b85d122b33507fd61ab022 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Tue, 5 Nov 2024 15:46:51 +0100 Subject: [PATCH 03/23] Renaming and applying `supportsRename` --- .../src/main/java/org/openrewrite/java/ChangePackage.java | 6 +++--- .../src/main/java/org/openrewrite/java/ChangeType.java | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 584ad4ef6da..a1073f12691 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -146,7 +146,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext executionCon matches.add(ref); } } - return new TypeReferenceVisitor(matches, oldPackageName, newPackageName).visit(tree, ctx); + return new TypeReferenceChangePackageVisitor(matches, oldPackageName, newPackageName).visit(tree, ctx); } return tree; } @@ -385,7 +385,7 @@ private boolean isTargetRecursivePackageName(String packageName) { @Value @EqualsAndHashCode(callSuper = false) - private static class TypeReferenceVisitor extends TreeVisitor { + private static class TypeReferenceChangePackageVisitor extends TreeVisitor { Set matches; String oldPackageName; String newPackageName; @@ -394,7 +394,7 @@ private static class TypeReferenceVisitor extends TreeVisitor matches = new HashSet<>(typeReferences.findMatches(matcher)); - return new TypeReferenceVisitor(matches, newFullyQualifiedTypeName).visit(tree, ctx); + return new TypeReferenceChangeTypeVisitor(matches, newFullyQualifiedTypeName).visit(tree, ctx); } return tree; } @@ -552,7 +552,7 @@ private boolean hasNoConflictingImport(@Nullable JavaSourceFile sf) { @Value @EqualsAndHashCode(callSuper = false) - private static class TypeReferenceVisitor extends TreeVisitor { + private static class TypeReferenceChangeTypeVisitor extends TreeVisitor { Set matches; String newFullyQualifiedName; @@ -560,7 +560,7 @@ private static class TypeReferenceVisitor extends TreeVisitor Date: Tue, 5 Nov 2024 15:48:30 +0100 Subject: [PATCH 04/23] Apply bot feedback --- .../src/main/java/org/openrewrite/java/ChangePackage.java | 2 +- rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index a1073f12691..ed7709d177f 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -130,7 +130,7 @@ public TreeVisitor getVisitor() { return Preconditions.check(condition, new TreeVisitor() { @Override - public boolean isAcceptable(SourceFile sourceFile, ExecutionContext executionContext) { + public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithTypeReferences; } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index 2d3e921f75c..ccbc9c07677 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -100,7 +100,7 @@ public TreeVisitor getVisitor() { return Preconditions.check(condition, new TreeVisitor() { @Override - public boolean isAcceptable(SourceFile sourceFile, ExecutionContext executionContext) { + public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithTypeReferences; } From 1085bdef07e74ade5bd78ed25542b297faa3d893 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Tue, 5 Nov 2024 15:54:18 +0100 Subject: [PATCH 05/23] Apply bot feedback --- .../src/main/java/org/openrewrite/java/ChangePackage.java | 1 + rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java | 1 + 2 files changed, 2 insertions(+) diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index ed7709d177f..66368a5a273 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -134,6 +134,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithTypeReferences; } + @Override public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { return new JavaChangePackageVisitor().visit(tree, ctx); diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index ccbc9c07677..bfaeb5db57c 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -104,6 +104,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithTypeReferences; } + @Override public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { return new JavaChangeTypeVisitor(oldFullyQualifiedTypeName, newFullyQualifiedTypeName, ignoreDefinition).visit(tree, ctx); From 122438e09e8c2980a1d44f8e74d28d846f89cffd Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Tue, 5 Nov 2024 17:12:08 +0100 Subject: [PATCH 06/23] Apply review feedback --- .../main/java/org/openrewrite/java/ChangePackage.java | 9 ++++++--- .../src/main/java/org/openrewrite/java/ChangeType.java | 4 ++-- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 66368a5a273..3e411816eee 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -90,7 +90,7 @@ public TreeVisitor getVisitor() { @Override public @Nullable Tree preVisit(Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { - JavaSourceFile cu = (JavaSourceFile) requireNonNull(tree); + JavaSourceFile cu = (JavaSourceFile) tree; if (cu.getPackageDeclaration() != null) { String original = cu.getPackageDeclaration().getExpression() .printTrimmed(getCursor()).replaceAll("\\s", ""); @@ -117,12 +117,15 @@ public TreeVisitor getVisitor() { stopAfterPreVisit(); } if (tree instanceof SourceFileWithTypeReferences) { - SourceFileWithTypeReferences cu = (SourceFileWithTypeReferences) requireNonNull(tree); + SourceFileWithTypeReferences cu = (SourceFileWithTypeReferences) tree; + boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); + String recursivePackageNamePrefix = oldPackageName + "."; for (TypeReference ref : cu.getTypeReferences().getTypeReferences()) { - if (ref.getName().startsWith(oldPackageName)) { + if (ref.getName().equals(oldPackageName) || recursive && ref.getName().startsWith(recursivePackageNamePrefix)) { return SearchResult.found(cu); } } + stopAfterPreVisit(); } return super.preVisit(tree, ctx); } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index bfaeb5db57c..4029be14a91 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -84,14 +84,14 @@ public TreeVisitor getVisitor() { @Override public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { - JavaSourceFile cu = (JavaSourceFile) requireNonNull(tree); + JavaSourceFile cu = (JavaSourceFile) tree; if (!Boolean.TRUE.equals(ignoreDefinition) && containsClassDefinition(cu, oldFullyQualifiedTypeName)) { return SearchResult.found(cu); } return new UsesType<>(oldFullyQualifiedTypeName, true).visitNonNull(cu, ctx); } if (tree instanceof SourceFileWithTypeReferences) { - SourceFileWithTypeReferences cu = (SourceFileWithTypeReferences) requireNonNull(tree); + SourceFileWithTypeReferences cu = (SourceFileWithTypeReferences) tree; return new UsesType<>(oldFullyQualifiedTypeName, true).visitNonNull(cu, ctx); } return tree; From 12432ce2928b016b46af1cf4627eaeceeb9ffcd0 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Wed, 6 Nov 2024 15:53:46 +0100 Subject: [PATCH 07/23] First batch of improvements --- .../org/openrewrite/java/ChangePackage.java | 28 +++++++++---------- .../java/org/openrewrite/java/ChangeType.java | 10 +++---- .../xml/trait/SpringTypeReference.java | 4 +-- 3 files changed, 21 insertions(+), 21 deletions(-) diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 3e411816eee..1410a00995b 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -26,12 +26,9 @@ import org.openrewrite.trait.TypeReference; import java.nio.file.Paths; -import java.util.HashSet; +import java.util.HashMap; import java.util.IdentityHashMap; import java.util.Map; -import java.util.Set; - -import static java.util.Objects.requireNonNull; /** * A recipe that will rename a package name in package statements, imports, and fully-qualified types (see: NOTE). @@ -138,19 +135,23 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } @Override - public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { + public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { return new JavaChangePackageVisitor().visit(tree, ctx); } else if (tree instanceof SourceFileWithTypeReferences) { SourceFileWithTypeReferences sourceFile = (SourceFileWithTypeReferences) tree; SourceFileWithTypeReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); - Set matches = new HashSet<>(); + boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); + String recursivePackageNamePrefix = oldPackageName + "."; + Map matches = new HashMap<>(); for (TypeReference ref : typeReferences.getTypeReferences()) { - if (ref.getName().startsWith(oldPackageName)) { - matches.add(ref); + if (ref.supportsRename()) { + if (ref.getName().equals(oldPackageName) || recursive && ref.getName().startsWith(recursivePackageNamePrefix)) { + matches.put(tree, ref); + } } } - return new TypeReferenceChangePackageVisitor(matches, oldPackageName, newPackageName).visit(tree, ctx); + return new TypeReferenceChangePackageVisitor(matches, oldPackageName, newPackageName).visit(tree, ctx, getCursor().getParent()); } return tree; } @@ -390,17 +391,16 @@ private boolean isTargetRecursivePackageName(String packageName) { @Value @EqualsAndHashCode(callSuper = false) private static class TypeReferenceChangePackageVisitor extends TreeVisitor { - Set matches; + Map matches; String oldPackageName; String newPackageName; @Override public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { Tree tree1 = super.visit(tree, ctx); - for (TypeReference ref : matches) { - if (ref.getTree().equals(tree) && ref.supportsRename()) { - return ref.renameTo(ref.getName().replace(oldPackageName, newPackageName)).visit(tree, ctx); - } + TypeReference ref = matches.get(tree); + if (ref != null) { + return ref.renameTo(ref.getName().replace(oldPackageName, newPackageName)).visit(tree, ctx, getCursor().getParent()); } return tree1; } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index 4029be14a91..30d8e0dd874 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -82,7 +82,7 @@ public String getDescription() { public TreeVisitor getVisitor() { TreeVisitor condition = new TreeVisitor() { @Override - public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { + public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { JavaSourceFile cu = (JavaSourceFile) tree; if (!Boolean.TRUE.equals(ignoreDefinition) && containsClassDefinition(cu, oldFullyQualifiedTypeName)) { @@ -105,7 +105,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } @Override - public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { + public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { return new JavaChangeTypeVisitor(oldFullyQualifiedTypeName, newFullyQualifiedTypeName, ignoreDefinition).visit(tree, ctx); } else if (tree instanceof SourceFileWithTypeReferences) { @@ -113,7 +113,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { SourceFileWithTypeReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); TypeMatcher matcher = new TypeMatcher(oldFullyQualifiedTypeName); Set matches = new HashSet<>(typeReferences.findMatches(matcher)); - return new TypeReferenceChangeTypeVisitor(matches, newFullyQualifiedTypeName).visit(tree, ctx); + return new TypeReferenceChangeTypeVisitor(matches, newFullyQualifiedTypeName).visit(tree, ctx, getCursor().getParent()); } return tree; } @@ -558,11 +558,11 @@ private static class TypeReferenceChangeTypeVisitor extends TreeVisitor renameTo(String name) { return new TreeVisitor() { @Override - public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext executionContext) { + public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { if (tree instanceof Xml.Attribute) { return ((Xml.Attribute) tree).withValue(((Xml.Attribute) tree).getValue().withValue(name)); } if (tree instanceof Xml.Tag) { return ((Xml.Tag) tree).withValue(name); } - return super.visit(tree, executionContext); + return super.visit(tree, ctx); } }; } From 4675e654133969911b16bb28eeab0bb019a54a70 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Mon, 11 Nov 2024 14:18:36 +0100 Subject: [PATCH 08/23] Another batch of improvements --- .../src/main/java/org/openrewrite/java/ChangePackage.java | 7 +++++-- .../src/main/java/org/openrewrite/java/ChangeType.java | 4 ++-- .../org/openrewrite/xml/trait/SpringTypeReference.java | 2 +- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 1410a00995b..b3f9364258f 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -29,6 +29,9 @@ import java.util.HashMap; import java.util.IdentityHashMap; import java.util.Map; +import java.util.Objects; + +import static java.util.Objects.requireNonNull; /** * A recipe that will rename a package name in package statements, imports, and fully-qualified types (see: NOTE). @@ -137,7 +140,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { @Override public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { - return new JavaChangePackageVisitor().visit(tree, ctx); + return new JavaChangePackageVisitor().visit(tree, ctx, requireNonNull(getCursor().getParent())); } else if (tree instanceof SourceFileWithTypeReferences) { SourceFileWithTypeReferences sourceFile = (SourceFileWithTypeReferences) tree; SourceFileWithTypeReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); @@ -151,7 +154,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } } } - return new TypeReferenceChangePackageVisitor(matches, oldPackageName, newPackageName).visit(tree, ctx, getCursor().getParent()); + return new TypeReferenceChangePackageVisitor(matches, oldPackageName, newPackageName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index 30d8e0dd874..d4520a8b348 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -107,13 +107,13 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { @Override public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { - return new JavaChangeTypeVisitor(oldFullyQualifiedTypeName, newFullyQualifiedTypeName, ignoreDefinition).visit(tree, ctx); + return new JavaChangeTypeVisitor(oldFullyQualifiedTypeName, newFullyQualifiedTypeName, ignoreDefinition).visit(tree, ctx, requireNonNull(getCursor().getParent())); } else if (tree instanceof SourceFileWithTypeReferences) { SourceFileWithTypeReferences sourceFile = (SourceFileWithTypeReferences) tree; SourceFileWithTypeReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); TypeMatcher matcher = new TypeMatcher(oldFullyQualifiedTypeName); Set matches = new HashSet<>(typeReferences.findMatches(matcher)); - return new TypeReferenceChangeTypeVisitor(matches, newFullyQualifiedTypeName).visit(tree, ctx, getCursor().getParent()); + return new TypeReferenceChangeTypeVisitor(matches, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; } diff --git a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java index 8f2189bee77..d6218bb29a5 100644 --- a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java +++ b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java @@ -72,7 +72,7 @@ public TreeVisitor renameTo(String name) { } static class Matcher extends SimpleTraitMatcher { - private final Pattern typeReference = Pattern.compile("(?:[a-zA-Z_][a-zA-Z0-9_]*\\.)+[A-Z*][a-zA-Z0-9_]*(?:<[a-zA-Z0-9_,?<> ]*>)?"); + private final Pattern typeReference = Pattern.compile("\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(?:\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*"); private final XPathMatcher classXPath = new XPathMatcher("//@class"); private final XPathMatcher typeXPath = new XPathMatcher("//@type"); private final XPathMatcher tags = new XPathMatcher("//value"); From 9e6eafd9d2c987c6f4835e4627d389e9750ef9f3 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Tue, 12 Nov 2024 11:20:17 +0100 Subject: [PATCH 09/23] Another batch of improvements --- ...ces.java => SourceFileWithReferences.java} | 20 +++--- .../openrewrite/TypeReferenceProvider.java | 4 +- .../Reference.java} | 22 +++++-- .../org/openrewrite/java/ChangePackage.java | 34 +++++----- .../java/org/openrewrite/java/ChangeType.java | 25 ++++---- .../org/openrewrite/java/TypeMatcher.java | 7 +- .../openrewrite/java/search/FindTypes.java | 8 +-- .../org/openrewrite/java/search/UsesType.java | 14 ++-- .../xml/trait/SpringTypeReference.java | 64 +++++++++++++------ .../java/org/openrewrite/xml/tree/Xml.java | 4 +- .../org/openrewrite/xml/XmlParserTest.java | 8 ++- .../xml/trait/SpringTypeReferenceTest.java | 8 ++- 12 files changed, 134 insertions(+), 84 deletions(-) rename rewrite-core/src/main/java/org/openrewrite/{SourceFileWithTypeReferences.java => SourceFileWithReferences.java} (65%) rename rewrite-core/src/main/java/org/openrewrite/trait/{TypeReference.java => reference/Reference.java} (66%) diff --git a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithTypeReferences.java b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java similarity index 65% rename from rewrite-core/src/main/java/org/openrewrite/SourceFileWithTypeReferences.java rename to rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java index e4f8974a02b..6563da14cc7 100644 --- a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithTypeReferences.java +++ b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java @@ -18,12 +18,12 @@ import lombok.AccessLevel; import lombok.Getter; import lombok.RequiredArgsConstructor; -import org.openrewrite.trait.TypeReference; +import org.openrewrite.trait.reference.Reference; import java.util.*; @Incubating(since = "8.39.0") -public interface SourceFileWithTypeReferences extends SourceFile { +public interface SourceFileWithReferences extends SourceFile { TypeReferences getTypeReferences(); @@ -31,11 +31,11 @@ public interface SourceFileWithTypeReferences extends SourceFile { @Getter class TypeReferences { private final SourceFile sourceFile; - private final Set typeReferences; + private final Set references; - public Collection findMatches(TypeReference.Matcher matcher) { - List list = new ArrayList<>(); - for (TypeReference ref : typeReferences) { + public Collection findMatches(Reference.Matcher matcher) { + List list = new ArrayList<>(); + for (Reference ref : references) { if (ref.matches(matcher)) { list.add(ref); } @@ -44,14 +44,14 @@ public Collection findMatches(TypeReference.Matcher matcher) { } public static TypeReferences build(SourceFile sourceFile) { - Set typeReferences = new HashSet<>(); - ServiceLoader loader = ServiceLoader.load(TypeReference.Provider.class); + Set references = new HashSet<>(); + ServiceLoader loader = ServiceLoader.load(Reference.Provider.class); loader.forEach(provider -> { if (provider.isAcceptable(sourceFile)) { - typeReferences.addAll(provider.getTypeReferences(sourceFile)); + references.addAll(provider.getTypeReferences(sourceFile)); } }); - return new TypeReferences(sourceFile, typeReferences); + return new TypeReferences(sourceFile, references); } } } diff --git a/rewrite-core/src/main/java/org/openrewrite/TypeReferenceProvider.java b/rewrite-core/src/main/java/org/openrewrite/TypeReferenceProvider.java index b89ea2c767e..db2967ecff4 100644 --- a/rewrite-core/src/main/java/org/openrewrite/TypeReferenceProvider.java +++ b/rewrite-core/src/main/java/org/openrewrite/TypeReferenceProvider.java @@ -15,13 +15,13 @@ */ package org.openrewrite; -import org.openrewrite.trait.TypeReference; +import org.openrewrite.trait.reference.Reference; import java.util.Set; public interface TypeReferenceProvider { - Set getTypeReferences(SourceFile sourceFile); + Set getTypeReferences(SourceFile sourceFile); boolean isAcceptable(SourceFile sourceFile); } diff --git a/rewrite-core/src/main/java/org/openrewrite/trait/TypeReference.java b/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java similarity index 66% rename from rewrite-core/src/main/java/org/openrewrite/trait/TypeReference.java rename to rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java index af2897f1e6e..e6530948915 100644 --- a/rewrite-core/src/main/java/org/openrewrite/trait/TypeReference.java +++ b/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java @@ -13,37 +13,45 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.openrewrite.trait; +package org.openrewrite.trait.reference; import org.openrewrite.*; +import org.openrewrite.trait.Trait; import java.util.Set; @Incubating(since = "8.39.0") -public interface TypeReference extends Trait { +public interface Reference extends Trait { - String getName(); + enum Kind { + TYPE, + PACKAGE + } + + Kind getKind(); + + String getValue(); default boolean supportsRename() { return false; } - default TreeVisitor renameTo(String name) { + default TreeVisitor rename(String oldValue, String newValue, boolean recursive) { throw new UnsupportedOperationException(); } default boolean matches(Matcher matcher) { - return matcher.matchesName(getName()); + return matcher.matchesReference(getValue()); } interface Provider { - Set getTypeReferences(SourceFile sourceFile); + Set getTypeReferences(SourceFile sourceFile); boolean isAcceptable(SourceFile sourceFile); } interface Matcher { - boolean matchesName(String name); + boolean matchesReference(String value); } } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index b3f9364258f..75004bb678d 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -23,13 +23,12 @@ import org.openrewrite.internal.ListUtils; import org.openrewrite.java.tree.*; import org.openrewrite.marker.SearchResult; -import org.openrewrite.trait.TypeReference; +import org.openrewrite.trait.reference.Reference; import java.nio.file.Paths; import java.util.HashMap; import java.util.IdentityHashMap; import java.util.Map; -import java.util.Objects; import static java.util.Objects.requireNonNull; @@ -116,12 +115,12 @@ public TreeVisitor getVisitor() { } stopAfterPreVisit(); } - if (tree instanceof SourceFileWithTypeReferences) { - SourceFileWithTypeReferences cu = (SourceFileWithTypeReferences) tree; + if (tree instanceof SourceFileWithReferences) { + SourceFileWithReferences cu = (SourceFileWithReferences) tree; boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); String recursivePackageNamePrefix = oldPackageName + "."; - for (TypeReference ref : cu.getTypeReferences().getTypeReferences()) { - if (ref.getName().equals(oldPackageName) || recursive && ref.getName().startsWith(recursivePackageNamePrefix)) { + for (Reference ref : cu.getTypeReferences().getReferences()) { + if (ref.getValue().equals(oldPackageName) || recursive && ref.getValue().startsWith(recursivePackageNamePrefix)) { return SearchResult.found(cu); } } @@ -134,27 +133,27 @@ public TreeVisitor getVisitor() { return Preconditions.check(condition, new TreeVisitor() { @Override public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { - return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithTypeReferences; + return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithReferences; } @Override public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { return new JavaChangePackageVisitor().visit(tree, ctx, requireNonNull(getCursor().getParent())); - } else if (tree instanceof SourceFileWithTypeReferences) { - SourceFileWithTypeReferences sourceFile = (SourceFileWithTypeReferences) tree; - SourceFileWithTypeReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); + } else if (tree instanceof SourceFileWithReferences) { + SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; + SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); String recursivePackageNamePrefix = oldPackageName + "."; - Map matches = new HashMap<>(); - for (TypeReference ref : typeReferences.getTypeReferences()) { + Map matches = new HashMap<>(); + for (Reference ref : typeReferences.getReferences()) { if (ref.supportsRename()) { - if (ref.getName().equals(oldPackageName) || recursive && ref.getName().startsWith(recursivePackageNamePrefix)) { + if (ref.getValue().equals(oldPackageName) || recursive && ref.getValue().startsWith(recursivePackageNamePrefix)) { matches.put(tree, ref); } } } - return new TypeReferenceChangePackageVisitor(matches, oldPackageName, newPackageName).visit(tree, ctx, requireNonNull(getCursor().getParent())); + return new TypeReferenceChangePackageVisitor(matches, oldPackageName, newPackageName, recursive).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; } @@ -394,16 +393,17 @@ private boolean isTargetRecursivePackageName(String packageName) { @Value @EqualsAndHashCode(callSuper = false) private static class TypeReferenceChangePackageVisitor extends TreeVisitor { - Map matches; + Map matches; String oldPackageName; String newPackageName; + Boolean recursive; @Override public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { Tree tree1 = super.visit(tree, ctx); - TypeReference ref = matches.get(tree); + Reference ref = matches.get(tree); if (ref != null) { - return ref.renameTo(ref.getName().replace(oldPackageName, newPackageName)).visit(tree, ctx, getCursor().getParent()); + return ref.rename(oldPackageName, newPackageName, recursive).visit(tree, ctx, getCursor().getParent()); } return tree1; } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index d4520a8b348..0467ad31ebe 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -24,7 +24,7 @@ import org.openrewrite.java.tree.*; import org.openrewrite.marker.Markers; import org.openrewrite.marker.SearchResult; -import org.openrewrite.trait.TypeReference; +import org.openrewrite.trait.reference.Reference; import java.nio.file.Path; import java.nio.file.Paths; @@ -90,8 +90,8 @@ public TreeVisitor getVisitor() { } return new UsesType<>(oldFullyQualifiedTypeName, true).visitNonNull(cu, ctx); } - if (tree instanceof SourceFileWithTypeReferences) { - SourceFileWithTypeReferences cu = (SourceFileWithTypeReferences) tree; + if (tree instanceof SourceFileWithReferences) { + SourceFileWithReferences cu = (SourceFileWithReferences) tree; return new UsesType<>(oldFullyQualifiedTypeName, true).visitNonNull(cu, ctx); } return tree; @@ -101,19 +101,19 @@ public TreeVisitor getVisitor() { return Preconditions.check(condition, new TreeVisitor() { @Override public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { - return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithTypeReferences; + return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithReferences; } @Override public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { return new JavaChangeTypeVisitor(oldFullyQualifiedTypeName, newFullyQualifiedTypeName, ignoreDefinition).visit(tree, ctx, requireNonNull(getCursor().getParent())); - } else if (tree instanceof SourceFileWithTypeReferences) { - SourceFileWithTypeReferences sourceFile = (SourceFileWithTypeReferences) tree; - SourceFileWithTypeReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); + } else if (tree instanceof SourceFileWithReferences) { + SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; + SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); TypeMatcher matcher = new TypeMatcher(oldFullyQualifiedTypeName); - Set matches = new HashSet<>(typeReferences.findMatches(matcher)); - return new TypeReferenceChangeTypeVisitor(matches, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); + Set matches = new HashSet<>(typeReferences.findMatches(matcher)); + return new TypeReferenceChangeTypeVisitor(matches, oldFullyQualifiedTypeName, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; } @@ -554,15 +554,16 @@ private boolean hasNoConflictingImport(@Nullable JavaSourceFile sf) { @Value @EqualsAndHashCode(callSuper = false) private static class TypeReferenceChangeTypeVisitor extends TreeVisitor { - Set matches; + Set matches; + String oldFullyQualifiedName; String newFullyQualifiedName; @Override public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { Tree tree1 = super.visit(tree, ctx); - for (TypeReference ref : matches) { + for (Reference ref : matches) { if (ref.getTree().equals(tree) && ref.supportsRename()) { - return ref.renameTo(newFullyQualifiedName).visit(tree, ctx, getCursor().getParent()); + return ref.rename(oldFullyQualifiedName, newFullyQualifiedName, false).visit(tree, ctx, getCursor().getParent()); } } return tree1; diff --git a/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java b/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java index 66149adb535..ab8e878372f 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java @@ -26,14 +26,14 @@ import org.openrewrite.java.tree.JavaType; import org.openrewrite.java.tree.TypeTree; import org.openrewrite.java.tree.TypeUtils; -import org.openrewrite.trait.TypeReference; +import org.openrewrite.trait.reference.Reference; import java.util.regex.Pattern; import static org.openrewrite.java.tree.TypeUtils.fullyQualifiedNamesAreEqual; @Getter -public class TypeMatcher implements TypeReference.Matcher { +public class TypeMatcher implements Reference.Matcher { private static final String ASPECTJ_DOT_PATTERN = StringUtils.aspectjNameToPattern("."); @SuppressWarnings("NotNullFieldNotInitialized") @@ -112,7 +112,8 @@ private static boolean isPlainIdentifier(MethodSignatureParser.TargetTypePattern } @Override - public boolean matchesName(String name) { + public boolean matchesReference(String name) { return matchesTargetTypeName(name); } + } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java b/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java index 97a468dbffa..e28527ad367 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java @@ -68,16 +68,16 @@ public TreeVisitor getVisitor() { return Preconditions.check(new UsesType<>(fullyQualifiedTypeName, false), new TreeVisitor() { @Override public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { - return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithTypeReferences; + return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithReferences; } @Override public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { return new JavaSourceFileVisitor(fullyQualifiedType).visit(tree, ctx); - } else if (tree instanceof SourceFileWithTypeReferences) { - SourceFileWithTypeReferences sourceFile = (SourceFileWithTypeReferences) tree; - SourceFileWithTypeReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); + } else if (tree instanceof SourceFileWithReferences) { + SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; + SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); TypeMatcher matcher = new TypeMatcher(fullyQualifiedTypeName); Set matches = typeReferences.findMatches(matcher).stream().map(Trait::getTree).collect(Collectors.toSet()); return new TypeReferenceVisitor(matches).visit(tree, ctx); diff --git a/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java b/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java index 3d348fc8cbe..ccfbb47f01f 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java @@ -18,7 +18,7 @@ import lombok.Getter; import org.jspecify.annotations.Nullable; import org.openrewrite.SourceFile; -import org.openrewrite.SourceFileWithTypeReferences; +import org.openrewrite.SourceFileWithReferences; import org.openrewrite.Tree; import org.openrewrite.TreeVisitor; import org.openrewrite.internal.StringUtils; @@ -28,7 +28,7 @@ import org.openrewrite.java.tree.JavaType; import org.openrewrite.java.tree.TypeUtils; import org.openrewrite.marker.SearchResult; -import org.openrewrite.trait.TypeReference; +import org.openrewrite.trait.reference.Reference; import java.util.function.Predicate; import java.util.regex.Pattern; @@ -77,7 +77,7 @@ public UsesType(String fullyQualifiedType, @Nullable Boolean includeImplicit) { @Override public boolean isAcceptable(SourceFile sourceFile, P p) { - return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithTypeReferences; + return sourceFile instanceof JavaSourceFile || sourceFile instanceof SourceFileWithReferences; } @Override @@ -119,11 +119,11 @@ public boolean isAcceptable(SourceFile sourceFile, P p) { } } } - } else if (tree instanceof SourceFileWithTypeReferences) { - SourceFileWithTypeReferences sourceFile = (SourceFileWithTypeReferences) tree; - SourceFileWithTypeReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); + } else if (tree instanceof SourceFileWithReferences) { + SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; + SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); TypeMatcher matcher = typeMatcher != null ? typeMatcher : new TypeMatcher(fullyQualifiedType); - for (TypeReference ignored : typeReferences.findMatches(matcher)) { + for (Reference ignored : typeReferences.findMatches(matcher)) { return SearchResult.found(sourceFile); } } diff --git a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java index d6218bb29a5..bbc9ab4621e 100644 --- a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java +++ b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java @@ -18,8 +18,9 @@ import lombok.Value; import org.jspecify.annotations.Nullable; import org.openrewrite.*; +import org.openrewrite.internal.StringUtils; import org.openrewrite.trait.SimpleTraitMatcher; -import org.openrewrite.trait.TypeReference; +import org.openrewrite.trait.reference.Reference; import org.openrewrite.xml.XPathMatcher; import org.openrewrite.xml.tree.Xml; @@ -28,16 +29,22 @@ import java.util.regex.Pattern; @Value -class SpringTypeReference implements TypeReference { +class SpringTypeReference implements Reference { Cursor cursor; + Kind kind; @Override public Tree getTree() { - return TypeReference.super.getTree(); + return Reference.super.getTree(); } @Override - public String getName() { + public Kind getKind() { + return kind; + } + + @Override + public String getValue() { if (getTree() instanceof Xml.Attribute) { Xml.Attribute attribute = (Xml.Attribute) getTree(); return attribute.getValueAsString(); @@ -56,15 +63,30 @@ public boolean supportsRename() { } @Override - public TreeVisitor renameTo(String name) { + public TreeVisitor rename(String oldValue, String newValue, boolean recursive) { return new TreeVisitor() { @Override public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { - if (tree instanceof Xml.Attribute) { - return ((Xml.Attribute) tree).withValue(((Xml.Attribute) tree).getValue().withValue(name)); + String replacement = ""; + switch(getKind()) { + case TYPE: + replacement = newValue; + break; + case PACKAGE: + if (recursive) { + replacement = getValue().replace(oldValue, newValue); + } else if (getValue().startsWith(oldValue) && Character.isUpperCase(getValue().charAt(oldValue.length()+1))) { + replacement = getValue().replace(oldValue, newValue); + } + break; } - if (tree instanceof Xml.Tag) { - return ((Xml.Tag) tree).withValue(name); + if (StringUtils.isNotEmpty(replacement)) { + if (tree instanceof Xml.Attribute) { + return ((Xml.Attribute) tree).withValue(((Xml.Attribute) tree).getValue().withValue(replacement)); + } + if (tree instanceof Xml.Tag) { + return ((Xml.Tag) tree).withValue(replacement); + } } return super.visit(tree, ctx); } @@ -83,33 +105,39 @@ static class Matcher extends SimpleTraitMatcher { if (value instanceof Xml.Attribute) { Xml.Attribute attrib = (Xml.Attribute) value; if (classXPath.matches(cursor) || typeXPath.matches(cursor)) { - if (typeReference.matcher(attrib.getValueAsString()).matches()) { - return new SpringTypeReference(cursor); + String stringVal = attrib.getValueAsString(); + if (typeReference.matcher(stringVal).matches()) { + return new SpringTypeReference(cursor, determineKind(stringVal)); } } } else if (value instanceof Xml.Tag) { Xml.Tag tag = (Xml.Tag) value; if (tags.matches(cursor)) { - if (tag.getValue().isPresent() && typeReference.matcher(tag.getValue().get()).matches()) { - return new SpringTypeReference(cursor); + String stringVal = tag.getValue().get(); + if (tag.getValue().isPresent() && typeReference.matcher(stringVal).matches()) { + return new SpringTypeReference(cursor, determineKind(stringVal)); } } } return null; } + + Kind determineKind(String value) { + return Character.isUpperCase(value.charAt(value.lastIndexOf('.')+1)) ? Kind.TYPE : Kind.PACKAGE; + } } @SuppressWarnings("unused") - public static class Provider implements TypeReference.Provider { + public static class Provider implements Reference.Provider { @Override - public Set getTypeReferences(SourceFile sourceFile) { - Set typeReferences = new HashSet<>(); + public Set getTypeReferences(SourceFile sourceFile) { + Set references = new HashSet<>(); new Matcher().asVisitor(reference -> { - typeReferences.add(reference); + references.add(reference); return reference.getTree(); }).visit(sourceFile, 0); - return typeReferences; + return references; } @Override diff --git a/rewrite-xml/src/main/java/org/openrewrite/xml/tree/Xml.java b/rewrite-xml/src/main/java/org/openrewrite/xml/tree/Xml.java index 4e0eb50db4d..5dda6d005ce 100755 --- a/rewrite-xml/src/main/java/org/openrewrite/xml/tree/Xml.java +++ b/rewrite-xml/src/main/java/org/openrewrite/xml/tree/Xml.java @@ -83,7 +83,7 @@ default

boolean isAcceptable(TreeVisitor v, P p) { @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @RequiredArgsConstructor @AllArgsConstructor(access = AccessLevel.PRIVATE) - class Document implements Xml, SourceFileWithTypeReferences { + class Document implements Xml, SourceFileWithReferences { @With @EqualsAndHashCode.Include UUID id; @@ -164,7 +164,7 @@ public T service(Class service) { if (WhitespaceValidationService.class.getName().equals(service.getName())) { return (T) new XmlWhitespaceValidationService(); } - return SourceFileWithTypeReferences.super.service(service); + return SourceFileWithReferences.super.service(service); } @Nullable diff --git a/rewrite-xml/src/test/java/org/openrewrite/xml/XmlParserTest.java b/rewrite-xml/src/test/java/org/openrewrite/xml/XmlParserTest.java index 7eda3abcda9..346b8aa00b3 100755 --- a/rewrite-xml/src/test/java/org/openrewrite/xml/XmlParserTest.java +++ b/rewrite-xml/src/test/java/org/openrewrite/xml/XmlParserTest.java @@ -24,6 +24,7 @@ import org.openrewrite.Issue; import org.openrewrite.test.RecipeSpec; import org.openrewrite.test.RewriteTest; +import org.openrewrite.trait.reference.Reference; import org.openrewrite.xml.tree.Xml; import java.nio.file.Paths; @@ -135,13 +136,18 @@ void javaTypeReferenceDocument() { java.lang.String + + java.lang + """, spec -> spec.afterRecipe(doc -> { - assertThat(doc.getTypeReferences().getTypeReferences().stream().anyMatch(typeRef -> typeRef.getName().equals("java.lang.String"))); + assertThat(doc.getTypeReferences().getReferences().stream().anyMatch(typeRef -> typeRef.getValue().equals("java.lang.String"))); + assertThat(doc.getTypeReferences().getReferences().stream().anyMatch(typeRef -> typeRef.getKind().equals(Reference.Kind.TYPE))); + assertThat(doc.getTypeReferences().getReferences().stream().anyMatch(typeRef -> typeRef.getKind().equals(Reference.Kind.PACKAGE))); }) ) ); diff --git a/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeReferenceTest.java b/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeReferenceTest.java index 5259faf3cf5..60d72c26008 100644 --- a/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeReferenceTest.java +++ b/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeReferenceTest.java @@ -28,7 +28,7 @@ class SpringTypeReferenceTest implements RewriteTest { @Override public void defaults(RecipeSpec spec) { spec.recipe(RewriteTest.toRecipe(() -> new SpringTypeReference.Matcher() - .asVisitor(springJavaTypeReference -> SearchResult.found(springJavaTypeReference.getTree(), springJavaTypeReference.getName())))); + .asVisitor(springJavaTypeReference -> SearchResult.found(springJavaTypeReference.getTree(), springJavaTypeReference.getValue())))); } @SuppressWarnings("SpringXmlModelInspection") @@ -50,6 +50,9 @@ void xmlConfiguration() { java.lang.String + + java.lang + @@ -68,6 +71,9 @@ void xmlConfiguration() { java.lang.String + + java.lang + From 112cc2bd855095afc63d8866c6e91d6285ce92d8 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Tue, 12 Nov 2024 11:25:45 +0100 Subject: [PATCH 10/23] Another batch of improvements --- .../src/main/java/org/openrewrite/java/ChangePackage.java | 4 ++-- .../src/main/java/org/openrewrite/java/ChangeType.java | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 75004bb678d..8ae5bb30286 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -153,7 +153,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } } } - return new TypeReferenceChangePackageVisitor(matches, oldPackageName, newPackageName, recursive).visit(tree, ctx, requireNonNull(getCursor().getParent())); + return new ReferenceChangePackageVisitor(matches, oldPackageName, newPackageName, recursive).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; } @@ -392,7 +392,7 @@ private boolean isTargetRecursivePackageName(String packageName) { @Value @EqualsAndHashCode(callSuper = false) - private static class TypeReferenceChangePackageVisitor extends TreeVisitor { + private static class ReferenceChangePackageVisitor extends TreeVisitor { Map matches; String oldPackageName; String newPackageName; diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index 0467ad31ebe..d12c76252c0 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -113,7 +113,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); TypeMatcher matcher = new TypeMatcher(oldFullyQualifiedTypeName); Set matches = new HashSet<>(typeReferences.findMatches(matcher)); - return new TypeReferenceChangeTypeVisitor(matches, oldFullyQualifiedTypeName, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); + return new ReferenceChangeTypeVisitor(matches, oldFullyQualifiedTypeName, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; } @@ -553,7 +553,7 @@ private boolean hasNoConflictingImport(@Nullable JavaSourceFile sf) { @Value @EqualsAndHashCode(callSuper = false) - private static class TypeReferenceChangeTypeVisitor extends TreeVisitor { + private static class ReferenceChangeTypeVisitor extends TreeVisitor { Set matches; String oldFullyQualifiedName; String newFullyQualifiedName; From a388a03ea82500333bd7c048bac365892e971b98 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Tue, 12 Nov 2024 13:09:57 +0100 Subject: [PATCH 11/23] Another batch of improvements --- .../openrewrite/SourceFileWithReferences.java | 4 +- .../trait/reference/Reference.java | 23 +++-- .../org/openrewrite/java/ChangePackage.java | 29 +++---- .../java/org/openrewrite/java/ChangeType.java | 10 +-- .../org/openrewrite/java/PackageMatcher.java | 83 +++++++++++++++++++ .../org/openrewrite/java/TypeMatcher.java | 28 ++++++- .../xml/trait/SpringTypeReference.java | 31 ------- 7 files changed, 143 insertions(+), 65 deletions(-) create mode 100644 rewrite-java/src/main/java/org/openrewrite/java/PackageMatcher.java diff --git a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java index 6563da14cc7..e4893737a5d 100644 --- a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java +++ b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java @@ -33,10 +33,10 @@ class TypeReferences { private final SourceFile sourceFile; private final Set references; - public Collection findMatches(Reference.Matcher matcher) { + public Collection findMatches(Reference.MatcherMutator matcherMutator) { List list = new ArrayList<>(); for (Reference ref : references) { - if (ref.matches(matcher)) { + if (ref.matches(matcherMutator)) { list.add(ref); } } diff --git a/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java b/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java index e6530948915..0705c383a90 100644 --- a/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java +++ b/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java @@ -36,12 +36,12 @@ default boolean supportsRename() { return false; } - default TreeVisitor rename(String oldValue, String newValue, boolean recursive) { - throw new UnsupportedOperationException(); + default boolean matches(MatcherMutator matcher) { + return matcher.matchesReference(this); } - default boolean matches(Matcher matcher) { - return matcher.matchesReference(getValue()); + default TreeVisitor rename(MatcherMutator renamer, String replacement) { + return renamer.rename(replacement); } interface Provider { @@ -51,7 +51,20 @@ interface Provider { boolean isAcceptable(SourceFile sourceFile); } + interface MatcherMutator extends Matcher, Renamer { + } + interface Matcher { - boolean matchesReference(String value); + boolean matchesReference(Reference value); + } + + interface Renamer { + default TreeVisitor rename(String replacement) { + return rename(replacement, false); + } + + default TreeVisitor rename(String replacement, boolean recursive) { + throw new UnsupportedOperationException(); + } } } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 8ae5bb30286..8eb41e7b69b 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -26,9 +26,7 @@ import org.openrewrite.trait.reference.Reference; import java.nio.file.Paths; -import java.util.HashMap; -import java.util.IdentityHashMap; -import java.util.Map; +import java.util.*; import static java.util.Objects.requireNonNull; @@ -144,16 +142,9 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); - String recursivePackageNamePrefix = oldPackageName + "."; - Map matches = new HashMap<>(); - for (Reference ref : typeReferences.getReferences()) { - if (ref.supportsRename()) { - if (ref.getValue().equals(oldPackageName) || recursive && ref.getValue().startsWith(recursivePackageNamePrefix)) { - matches.put(tree, ref); - } - } - } - return new ReferenceChangePackageVisitor(matches, oldPackageName, newPackageName, recursive).visit(tree, ctx, requireNonNull(getCursor().getParent())); + Reference.MatcherMutator matcherMutator = new PackageMatcher(oldPackageName, recursive); + Set matches = new HashSet<>(typeReferences.findMatches(matcherMutator)); + return new ReferenceChangePackageVisitor(matches, matcherMutator, newPackageName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; } @@ -393,17 +384,17 @@ private boolean isTargetRecursivePackageName(String packageName) { @Value @EqualsAndHashCode(callSuper = false) private static class ReferenceChangePackageVisitor extends TreeVisitor { - Map matches; - String oldPackageName; + Set matches; + Reference.MatcherMutator matcherMutator; String newPackageName; - Boolean recursive; @Override public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { Tree tree1 = super.visit(tree, ctx); - Reference ref = matches.get(tree); - if (ref != null) { - return ref.rename(oldPackageName, newPackageName, recursive).visit(tree, ctx, getCursor().getParent()); + for (Reference ref : matches) { + if (ref.getTree().equals(tree) && ref.supportsRename()) { + return ref.rename(matcherMutator, newPackageName).visit(tree, ctx, getCursor().getParent()); + } } return tree1; } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index d12c76252c0..e46f61c3be3 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -111,9 +111,9 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } else if (tree instanceof SourceFileWithReferences) { SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); - TypeMatcher matcher = new TypeMatcher(oldFullyQualifiedTypeName); - Set matches = new HashSet<>(typeReferences.findMatches(matcher)); - return new ReferenceChangeTypeVisitor(matches, oldFullyQualifiedTypeName, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); + Reference.MatcherMutator matcherMutator = new TypeMatcher(oldFullyQualifiedTypeName); + Set matches = new HashSet<>(typeReferences.findMatches(matcherMutator)); + return new ReferenceChangeTypeVisitor(matches, matcherMutator, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; } @@ -555,7 +555,7 @@ private boolean hasNoConflictingImport(@Nullable JavaSourceFile sf) { @EqualsAndHashCode(callSuper = false) private static class ReferenceChangeTypeVisitor extends TreeVisitor { Set matches; - String oldFullyQualifiedName; + Reference.MatcherMutator matcherMutator; String newFullyQualifiedName; @Override @@ -563,7 +563,7 @@ private static class ReferenceChangeTypeVisitor extends TreeVisitor + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + *

+ * https://www.apache.org/licenses/LICENSE-2.0 + *

+ * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.openrewrite.java; + +import lombok.Getter; +import org.jspecify.annotations.Nullable; +import org.openrewrite.ExecutionContext; +import org.openrewrite.Tree; +import org.openrewrite.TreeVisitor; +import org.openrewrite.internal.StringUtils; +import org.openrewrite.trait.reference.Reference; +import org.openrewrite.xml.tree.Xml; + +@Getter +public class PackageMatcher implements Reference.MatcherMutator { + + @Nullable + private String targetPackage; + + @Getter + private final Boolean recursive; + + public PackageMatcher(@Nullable String fieldType) { + this(fieldType, false); + } + + public PackageMatcher(@Nullable String fieldType, @Nullable boolean recursive) { + this.targetPackage = fieldType; + this.recursive = recursive; + } + + @Override + public boolean matchesReference(Reference reference) { + String recursivePackageNamePrefix = targetPackage + "."; + if (reference.getValue().equals(targetPackage) || recursive && reference.getValue().startsWith(recursivePackageNamePrefix)) { + return true; + } + return false; + } + + @Override + public TreeVisitor rename(String newValue, boolean recursive) { + return new TreeVisitor() { + @Override + public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { + if (StringUtils.isNotEmpty(newValue)) { + if (tree instanceof Xml.Attribute) { + return ((Xml.Attribute) tree).withValue(((Xml.Attribute) tree).getValue().withValue(getReplacement(((Xml.Attribute) tree).getValueAsString(), targetPackage, newValue))); + } + if (tree instanceof Xml.Tag) { + if (((Xml.Tag) tree).getValue().isPresent()) { + return ((Xml.Tag) tree).withValue(getReplacement(((Xml.Tag) tree).getValue().get(), targetPackage, newValue)); + } + } + } + return super.visit(tree, ctx); + } + }; + } + + String getReplacement(String value, String oldValue, String newValue) { + if (recursive) { + return value.replace(oldValue, newValue); + } else if (value.startsWith(oldValue) && Character.isUpperCase(value.charAt(oldValue.length() + 1))) { + return value.replace(oldValue, newValue); + } + return value; + } + +} diff --git a/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java b/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java index ab8e878372f..24e1f2499e6 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java @@ -19,6 +19,9 @@ import org.antlr.v4.runtime.CharStreams; import org.antlr.v4.runtime.CommonTokenStream; import org.jspecify.annotations.Nullable; +import org.openrewrite.ExecutionContext; +import org.openrewrite.Tree; +import org.openrewrite.TreeVisitor; import org.openrewrite.internal.StringUtils; import org.openrewrite.java.internal.grammar.MethodSignatureLexer; import org.openrewrite.java.internal.grammar.MethodSignatureParser; @@ -27,13 +30,14 @@ import org.openrewrite.java.tree.TypeTree; import org.openrewrite.java.tree.TypeUtils; import org.openrewrite.trait.reference.Reference; +import org.openrewrite.xml.tree.Xml; import java.util.regex.Pattern; import static org.openrewrite.java.tree.TypeUtils.fullyQualifiedNamesAreEqual; @Getter -public class TypeMatcher implements Reference.Matcher { +public class TypeMatcher implements Reference.MatcherMutator { private static final String ASPECTJ_DOT_PATTERN = StringUtils.aspectjNameToPattern("."); @SuppressWarnings("NotNullFieldNotInitialized") @@ -112,8 +116,26 @@ private static boolean isPlainIdentifier(MethodSignatureParser.TargetTypePattern } @Override - public boolean matchesReference(String name) { - return matchesTargetTypeName(name); + public boolean matchesReference(Reference reference) { + return matchesTargetTypeName(reference.getValue()); + } + + @Override + public TreeVisitor rename(String newValue, boolean recursive) { + return new TreeVisitor() { + @Override + public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { + if (StringUtils.isNotEmpty(newValue)) { + if (tree instanceof Xml.Attribute) { + return ((Xml.Attribute) tree).withValue(((Xml.Attribute) tree).getValue().withValue(newValue)); + } + if (tree instanceof Xml.Tag) { + return ((Xml.Tag) tree).withValue(newValue); + } + } + return super.visit(tree, ctx); + } + }; } } diff --git a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java index bbc9ab4621e..b2af3f7f9ee 100644 --- a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java +++ b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java @@ -62,37 +62,6 @@ public boolean supportsRename() { return true; } - @Override - public TreeVisitor rename(String oldValue, String newValue, boolean recursive) { - return new TreeVisitor() { - @Override - public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { - String replacement = ""; - switch(getKind()) { - case TYPE: - replacement = newValue; - break; - case PACKAGE: - if (recursive) { - replacement = getValue().replace(oldValue, newValue); - } else if (getValue().startsWith(oldValue) && Character.isUpperCase(getValue().charAt(oldValue.length()+1))) { - replacement = getValue().replace(oldValue, newValue); - } - break; - } - if (StringUtils.isNotEmpty(replacement)) { - if (tree instanceof Xml.Attribute) { - return ((Xml.Attribute) tree).withValue(((Xml.Attribute) tree).getValue().withValue(replacement)); - } - if (tree instanceof Xml.Tag) { - return ((Xml.Tag) tree).withValue(replacement); - } - } - return super.visit(tree, ctx); - } - }; - } - static class Matcher extends SimpleTraitMatcher { private final Pattern typeReference = Pattern.compile("\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(?:\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*"); private final XPathMatcher classXPath = new XPathMatcher("//@class"); From dbcae713e18c1f8151f71499ee719e4608a7e6dd Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Tue, 12 Nov 2024 13:15:02 +0100 Subject: [PATCH 12/23] Another batch of improvements --- .../main/java/org/openrewrite/SourceFileWithReferences.java | 4 ++-- .../main/java/org/openrewrite/trait/reference/Reference.java | 4 ++-- .../src/main/java/org/openrewrite/java/ChangePackage.java | 4 ++-- .../src/main/java/org/openrewrite/java/ChangeType.java | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java index e4893737a5d..6563da14cc7 100644 --- a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java +++ b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java @@ -33,10 +33,10 @@ class TypeReferences { private final SourceFile sourceFile; private final Set references; - public Collection findMatches(Reference.MatcherMutator matcherMutator) { + public Collection findMatches(Reference.Matcher matcher) { List list = new ArrayList<>(); for (Reference ref : references) { - if (ref.matches(matcherMutator)) { + if (ref.matches(matcher)) { list.add(ref); } } diff --git a/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java b/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java index 0705c383a90..a3e7e472522 100644 --- a/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java +++ b/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java @@ -36,11 +36,11 @@ default boolean supportsRename() { return false; } - default boolean matches(MatcherMutator matcher) { + default boolean matches(Matcher matcher) { return matcher.matchesReference(this); } - default TreeVisitor rename(MatcherMutator renamer, String replacement) { + default TreeVisitor rename(Renamer renamer, String replacement) { return renamer.rename(replacement); } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 8eb41e7b69b..72ed6874fa2 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -385,7 +385,7 @@ private boolean isTargetRecursivePackageName(String packageName) { @EqualsAndHashCode(callSuper = false) private static class ReferenceChangePackageVisitor extends TreeVisitor { Set matches; - Reference.MatcherMutator matcherMutator; + Reference.Renamer renamer; String newPackageName; @Override @@ -393,7 +393,7 @@ private static class ReferenceChangePackageVisitor extends TreeVisitor { Set matches; - Reference.MatcherMutator matcherMutator; + Reference.Renamer renamer; String newFullyQualifiedName; @Override @@ -563,7 +563,7 @@ private static class ReferenceChangeTypeVisitor extends TreeVisitor Date: Tue, 12 Nov 2024 13:24:26 +0100 Subject: [PATCH 13/23] Another batch of improvements --- .../java/org/openrewrite/SourceFileWithReferences.java | 5 +++++ .../main/java/org/openrewrite/java/ChangePackage.java | 9 ++++++--- .../src/main/java/org/openrewrite/java/ChangeType.java | 2 +- .../main/java/org/openrewrite/java/search/FindTypes.java | 3 ++- .../main/java/org/openrewrite/java/search/UsesType.java | 2 +- 5 files changed, 15 insertions(+), 6 deletions(-) diff --git a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java index 6563da14cc7..87bd0e36ca7 100644 --- a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java +++ b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java @@ -21,6 +21,7 @@ import org.openrewrite.trait.reference.Reference; import java.util.*; +import java.util.stream.Collectors; @Incubating(since = "8.39.0") public interface SourceFileWithReferences extends SourceFile { @@ -43,6 +44,10 @@ public Collection findMatches(Reference.Matcher matcher) { return list; } + public Collection findMatches(Reference.Matcher matcher, Reference.Kind kind) { + return findMatches(matcher).stream().filter(ref -> ref.getKind().equals(kind)).collect(Collectors.toList()); + } + public static TypeReferences build(SourceFile sourceFile) { Set references = new HashSet<>(); ServiceLoader loader = ServiceLoader.load(Reference.Provider.class); diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 72ed6874fa2..a1577b8f88f 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -26,7 +26,10 @@ import org.openrewrite.trait.reference.Reference; import java.nio.file.Paths; -import java.util.*; +import java.util.HashSet; +import java.util.IdentityHashMap; +import java.util.Map; +import java.util.Set; import static java.util.Objects.requireNonNull; @@ -118,7 +121,7 @@ public TreeVisitor getVisitor() { boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); String recursivePackageNamePrefix = oldPackageName + "."; for (Reference ref : cu.getTypeReferences().getReferences()) { - if (ref.getValue().equals(oldPackageName) || recursive && ref.getValue().startsWith(recursivePackageNamePrefix)) { + if (ref.getKind().equals(Reference.Kind.PACKAGE) && ref.getValue().equals(oldPackageName) || recursive && ref.getValue().startsWith(recursivePackageNamePrefix)) { return SearchResult.found(cu); } } @@ -143,7 +146,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); Reference.MatcherMutator matcherMutator = new PackageMatcher(oldPackageName, recursive); - Set matches = new HashSet<>(typeReferences.findMatches(matcherMutator)); + Set matches = new HashSet<>(typeReferences.findMatches(matcherMutator, Reference.Kind.PACKAGE)); return new ReferenceChangePackageVisitor(matches, matcherMutator, newPackageName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index 428543a4834..3b58bf201fe 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -112,7 +112,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); Reference.MatcherMutator matcherMutator = new TypeMatcher(oldFullyQualifiedTypeName); - Set matches = new HashSet<>(typeReferences.findMatches(matcherMutator)); + Set matches = new HashSet<>(typeReferences.findMatches(matcherMutator, Reference.Kind.TYPE)); return new ReferenceChangeTypeVisitor(matches, matcherMutator, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; diff --git a/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java b/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java index e28527ad367..b6b4c859fc4 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java @@ -28,6 +28,7 @@ import org.openrewrite.java.tree.*; import org.openrewrite.marker.SearchResult; import org.openrewrite.trait.Trait; +import org.openrewrite.trait.reference.Reference; import java.util.HashSet; import java.util.Set; @@ -79,7 +80,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); TypeMatcher matcher = new TypeMatcher(fullyQualifiedTypeName); - Set matches = typeReferences.findMatches(matcher).stream().map(Trait::getTree).collect(Collectors.toSet()); + Set matches = typeReferences.findMatches(matcher, Reference.Kind.TYPE).stream().map(Trait::getTree).collect(Collectors.toSet()); return new TypeReferenceVisitor(matches).visit(tree, ctx); } return tree; diff --git a/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java b/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java index ccfbb47f01f..5c7ce478217 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java @@ -123,7 +123,7 @@ public boolean isAcceptable(SourceFile sourceFile, P p) { SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); TypeMatcher matcher = typeMatcher != null ? typeMatcher : new TypeMatcher(fullyQualifiedType); - for (Reference ignored : typeReferences.findMatches(matcher)) { + for (Reference ignored : typeReferences.findMatches(matcher, Reference.Kind.TYPE)) { return SearchResult.found(sourceFile); } } From da2a719f933c7393f5de31311cfb12fa4728de55 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Tue, 12 Nov 2024 18:05:04 +0100 Subject: [PATCH 14/23] Another batch of improvements --- .../openrewrite/SourceFileWithReferences.java | 10 +++---- .../openrewrite/TypeReferenceProvider.java | 27 ------------------- .../trait/reference/Reference.java | 2 +- .../org/openrewrite/java/ChangePackage.java | 6 ++--- .../java/org/openrewrite/java/ChangeType.java | 4 +-- .../openrewrite/java/search/FindTypes.java | 8 +++--- .../org/openrewrite/java/search/UsesType.java | 4 +-- ...java => SpringTypeOrPackageReference.java} | 13 +++++---- .../java/org/openrewrite/xml/tree/Xml.java | 18 ++++++------- .../org/openrewrite/xml/XmlParserTest.java | 8 +++--- ... => SpringTypeOrPackageReferenceTest.java} | 4 +-- 11 files changed, 38 insertions(+), 66 deletions(-) delete mode 100644 rewrite-core/src/main/java/org/openrewrite/TypeReferenceProvider.java rename rewrite-xml/src/main/java/org/openrewrite/xml/trait/{SpringTypeReference.java => SpringTypeOrPackageReference.java} (89%) rename rewrite-xml/src/test/java/org/openrewrite/xml/trait/{SpringTypeReferenceTest.java => SpringTypeOrPackageReferenceTest.java} (95%) diff --git a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java index 87bd0e36ca7..984563d548e 100644 --- a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java +++ b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java @@ -26,11 +26,11 @@ @Incubating(since = "8.39.0") public interface SourceFileWithReferences extends SourceFile { - TypeReferences getTypeReferences(); + References getReferences(); @RequiredArgsConstructor(access = AccessLevel.PRIVATE) @Getter - class TypeReferences { + class References { private final SourceFile sourceFile; private final Set references; @@ -48,15 +48,15 @@ public Collection findMatches(Reference.Matcher matcher, Reference.Ki return findMatches(matcher).stream().filter(ref -> ref.getKind().equals(kind)).collect(Collectors.toList()); } - public static TypeReferences build(SourceFile sourceFile) { + public static References build(SourceFile sourceFile) { Set references = new HashSet<>(); ServiceLoader loader = ServiceLoader.load(Reference.Provider.class); loader.forEach(provider -> { if (provider.isAcceptable(sourceFile)) { - references.addAll(provider.getTypeReferences(sourceFile)); + references.addAll(provider.getReferences(sourceFile)); } }); - return new TypeReferences(sourceFile, references); + return new References(sourceFile, references); } } } diff --git a/rewrite-core/src/main/java/org/openrewrite/TypeReferenceProvider.java b/rewrite-core/src/main/java/org/openrewrite/TypeReferenceProvider.java deleted file mode 100644 index db2967ecff4..00000000000 --- a/rewrite-core/src/main/java/org/openrewrite/TypeReferenceProvider.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright 2024 the original author or authors. - *

- * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - *

- * https://www.apache.org/licenses/LICENSE-2.0 - *

- * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.openrewrite; - -import org.openrewrite.trait.reference.Reference; - -import java.util.Set; - -public interface TypeReferenceProvider { - - Set getTypeReferences(SourceFile sourceFile); - - boolean isAcceptable(SourceFile sourceFile); -} diff --git a/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java b/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java index a3e7e472522..6aca3c728d0 100644 --- a/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java +++ b/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java @@ -46,7 +46,7 @@ default TreeVisitor rename(Renamer renamer, String repl interface Provider { - Set getTypeReferences(SourceFile sourceFile); + Set getReferences(SourceFile sourceFile); boolean isAcceptable(SourceFile sourceFile); } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index a1577b8f88f..dbc303b5c51 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -120,7 +120,7 @@ public TreeVisitor getVisitor() { SourceFileWithReferences cu = (SourceFileWithReferences) tree; boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); String recursivePackageNamePrefix = oldPackageName + "."; - for (Reference ref : cu.getTypeReferences().getReferences()) { + for (Reference ref : cu.getReferences().getReferences()) { if (ref.getKind().equals(Reference.Kind.PACKAGE) && ref.getValue().equals(oldPackageName) || recursive && ref.getValue().startsWith(recursivePackageNamePrefix)) { return SearchResult.found(cu); } @@ -143,10 +143,10 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { return new JavaChangePackageVisitor().visit(tree, ctx, requireNonNull(getCursor().getParent())); } else if (tree instanceof SourceFileWithReferences) { SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; - SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); + SourceFileWithReferences.References references = sourceFile.getReferences(); boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); Reference.MatcherMutator matcherMutator = new PackageMatcher(oldPackageName, recursive); - Set matches = new HashSet<>(typeReferences.findMatches(matcherMutator, Reference.Kind.PACKAGE)); + Set matches = new HashSet<>(references.findMatches(matcherMutator, Reference.Kind.PACKAGE)); return new ReferenceChangePackageVisitor(matches, matcherMutator, newPackageName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index 3b58bf201fe..8582e223231 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -110,9 +110,9 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { return new JavaChangeTypeVisitor(oldFullyQualifiedTypeName, newFullyQualifiedTypeName, ignoreDefinition).visit(tree, ctx, requireNonNull(getCursor().getParent())); } else if (tree instanceof SourceFileWithReferences) { SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; - SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); + SourceFileWithReferences.References references = sourceFile.getReferences(); Reference.MatcherMutator matcherMutator = new TypeMatcher(oldFullyQualifiedTypeName); - Set matches = new HashSet<>(typeReferences.findMatches(matcherMutator, Reference.Kind.TYPE)); + Set matches = new HashSet<>(references.findMatches(matcherMutator, Reference.Kind.TYPE)); return new ReferenceChangeTypeVisitor(matches, matcherMutator, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; diff --git a/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java b/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java index b6b4c859fc4..e28a4fa649c 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java @@ -78,10 +78,10 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { return new JavaSourceFileVisitor(fullyQualifiedType).visit(tree, ctx); } else if (tree instanceof SourceFileWithReferences) { SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; - SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); + SourceFileWithReferences.References references = sourceFile.getReferences(); TypeMatcher matcher = new TypeMatcher(fullyQualifiedTypeName); - Set matches = typeReferences.findMatches(matcher, Reference.Kind.TYPE).stream().map(Trait::getTree).collect(Collectors.toSet()); - return new TypeReferenceVisitor(matches).visit(tree, ctx); + Set matches = references.findMatches(matcher, Reference.Kind.TYPE).stream().map(Trait::getTree).collect(Collectors.toSet()); + return new ReferenceVisitor(matches).visit(tree, ctx); } return tree; } @@ -150,7 +150,7 @@ private static boolean typeMatches(boolean checkAssignability, Pattern pattern, @Value @EqualsAndHashCode(callSuper = false) - private static class TypeReferenceVisitor extends TreeVisitor { + private static class ReferenceVisitor extends TreeVisitor { Set matches; @Override diff --git a/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java b/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java index 5c7ce478217..4afd2b287e7 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java @@ -121,9 +121,9 @@ public boolean isAcceptable(SourceFile sourceFile, P p) { } } else if (tree instanceof SourceFileWithReferences) { SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; - SourceFileWithReferences.TypeReferences typeReferences = sourceFile.getTypeReferences(); + SourceFileWithReferences.References references = sourceFile.getReferences(); TypeMatcher matcher = typeMatcher != null ? typeMatcher : new TypeMatcher(fullyQualifiedType); - for (Reference ignored : typeReferences.findMatches(matcher, Reference.Kind.TYPE)) { + for (Reference ignored : references.findMatches(matcher, Reference.Kind.TYPE)) { return SearchResult.found(sourceFile); } } diff --git a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeOrPackageReference.java similarity index 89% rename from rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java rename to rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeOrPackageReference.java index b2af3f7f9ee..51d2ad21379 100644 --- a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeReference.java +++ b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeOrPackageReference.java @@ -18,7 +18,6 @@ import lombok.Value; import org.jspecify.annotations.Nullable; import org.openrewrite.*; -import org.openrewrite.internal.StringUtils; import org.openrewrite.trait.SimpleTraitMatcher; import org.openrewrite.trait.reference.Reference; import org.openrewrite.xml.XPathMatcher; @@ -29,7 +28,7 @@ import java.util.regex.Pattern; @Value -class SpringTypeReference implements Reference { +class SpringTypeOrPackageReference implements Reference { Cursor cursor; Kind kind; @@ -62,21 +61,21 @@ public boolean supportsRename() { return true; } - static class Matcher extends SimpleTraitMatcher { + static class Matcher extends SimpleTraitMatcher { private final Pattern typeReference = Pattern.compile("\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(?:\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*"); private final XPathMatcher classXPath = new XPathMatcher("//@class"); private final XPathMatcher typeXPath = new XPathMatcher("//@type"); private final XPathMatcher tags = new XPathMatcher("//value"); @Override - protected @Nullable SpringTypeReference test(Cursor cursor) { + protected @Nullable SpringTypeOrPackageReference test(Cursor cursor) { Object value = cursor.getValue(); if (value instanceof Xml.Attribute) { Xml.Attribute attrib = (Xml.Attribute) value; if (classXPath.matches(cursor) || typeXPath.matches(cursor)) { String stringVal = attrib.getValueAsString(); if (typeReference.matcher(stringVal).matches()) { - return new SpringTypeReference(cursor, determineKind(stringVal)); + return new SpringTypeOrPackageReference(cursor, determineKind(stringVal)); } } } else if (value instanceof Xml.Tag) { @@ -84,7 +83,7 @@ static class Matcher extends SimpleTraitMatcher { if (tags.matches(cursor)) { String stringVal = tag.getValue().get(); if (tag.getValue().isPresent() && typeReference.matcher(stringVal).matches()) { - return new SpringTypeReference(cursor, determineKind(stringVal)); + return new SpringTypeOrPackageReference(cursor, determineKind(stringVal)); } } } @@ -100,7 +99,7 @@ Kind determineKind(String value) { public static class Provider implements Reference.Provider { @Override - public Set getTypeReferences(SourceFile sourceFile) { + public Set getReferences(SourceFile sourceFile) { Set references = new HashSet<>(); new Matcher().asVisitor(reference -> { references.add(reference); diff --git a/rewrite-xml/src/main/java/org/openrewrite/xml/tree/Xml.java b/rewrite-xml/src/main/java/org/openrewrite/xml/tree/Xml.java index 5dda6d005ce..1fabf24388c 100755 --- a/rewrite-xml/src/main/java/org/openrewrite/xml/tree/Xml.java +++ b/rewrite-xml/src/main/java/org/openrewrite/xml/tree/Xml.java @@ -169,20 +169,20 @@ public T service(Class service) { @Nullable @NonFinal - transient SoftReference typeReferences; + transient SoftReference references; @Transient @Override - public TypeReferences getTypeReferences() { - TypeReferences cache; - if (this.typeReferences == null) { - cache = TypeReferences.build(this); - this.typeReferences = new SoftReference<>(cache); + public References getReferences() { + References cache; + if (this.references == null) { + cache = References.build(this); + this.references = new SoftReference<>(cache); } else { - cache = this.typeReferences.get(); + cache = this.references.get(); if (cache == null || cache.getSourceFile() != this) { - cache = TypeReferences.build(this); - this.typeReferences = new SoftReference<>(cache); + cache = References.build(this); + this.references = new SoftReference<>(cache); } } return cache; diff --git a/rewrite-xml/src/test/java/org/openrewrite/xml/XmlParserTest.java b/rewrite-xml/src/test/java/org/openrewrite/xml/XmlParserTest.java index 346b8aa00b3..56bb6d0eda8 100755 --- a/rewrite-xml/src/test/java/org/openrewrite/xml/XmlParserTest.java +++ b/rewrite-xml/src/test/java/org/openrewrite/xml/XmlParserTest.java @@ -121,7 +121,7 @@ void parseXmlDocument() { } @Test - void javaTypeReferenceDocument() { + void javaReferenceDocument() { rewriteRun( xml( """ @@ -145,9 +145,9 @@ void javaTypeReferenceDocument() { """, spec -> spec.afterRecipe(doc -> { - assertThat(doc.getTypeReferences().getReferences().stream().anyMatch(typeRef -> typeRef.getValue().equals("java.lang.String"))); - assertThat(doc.getTypeReferences().getReferences().stream().anyMatch(typeRef -> typeRef.getKind().equals(Reference.Kind.TYPE))); - assertThat(doc.getTypeReferences().getReferences().stream().anyMatch(typeRef -> typeRef.getKind().equals(Reference.Kind.PACKAGE))); + assertThat(doc.getReferences().getReferences().stream().anyMatch(typeRef -> typeRef.getValue().equals("java.lang.String"))); + assertThat(doc.getReferences().getReferences().stream().anyMatch(typeRef -> typeRef.getKind().equals(Reference.Kind.TYPE))); + assertThat(doc.getReferences().getReferences().stream().anyMatch(typeRef -> typeRef.getKind().equals(Reference.Kind.PACKAGE))); }) ) ); diff --git a/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeReferenceTest.java b/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeOrPackageReferenceTest.java similarity index 95% rename from rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeReferenceTest.java rename to rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeOrPackageReferenceTest.java index 60d72c26008..599c3aa1744 100644 --- a/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeReferenceTest.java +++ b/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeOrPackageReferenceTest.java @@ -23,11 +23,11 @@ import static org.openrewrite.xml.Assertions.xml; -class SpringTypeReferenceTest implements RewriteTest { +class SpringTypeOrPackageReferenceTest implements RewriteTest { @Override public void defaults(RecipeSpec spec) { - spec.recipe(RewriteTest.toRecipe(() -> new SpringTypeReference.Matcher() + spec.recipe(RewriteTest.toRecipe(() -> new SpringTypeOrPackageReference.Matcher() .asVisitor(springJavaTypeReference -> SearchResult.found(springJavaTypeReference.getTree(), springJavaTypeReference.getValue())))); } From 53226cd9696dd74c0896b5b2f33506e9623ca1a9 Mon Sep 17 00:00:00 2001 From: Tim te Beek Date: Wed, 13 Nov 2024 00:46:21 +0100 Subject: [PATCH 15/23] Do not use streams to filter matches --- .../openrewrite/SourceFileWithReferences.java | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java index 984563d548e..e9d9ccefa7b 100644 --- a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java +++ b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java @@ -18,10 +18,10 @@ import lombok.AccessLevel; import lombok.Getter; import lombok.RequiredArgsConstructor; +import org.jspecify.annotations.Nullable; import org.openrewrite.trait.reference.Reference; import java.util.*; -import java.util.stream.Collectors; @Incubating(since = "8.39.0") public interface SourceFileWithReferences extends SourceFile { @@ -35,19 +35,23 @@ class References { private final Set references; public Collection findMatches(Reference.Matcher matcher) { + return findMatchesInternal(matcher, null); + } + + public Collection findMatches(Reference.Matcher matcher, Reference.Kind kind) { + return findMatchesInternal(matcher, kind); + } + + private List findMatchesInternal(Reference.Matcher matcher, Reference.@Nullable Kind kind) { List list = new ArrayList<>(); for (Reference ref : references) { - if (ref.matches(matcher)) { + if (ref.matches(matcher) && (kind == null || ref.getKind().equals(kind))) { list.add(ref); } } return list; } - public Collection findMatches(Reference.Matcher matcher, Reference.Kind kind) { - return findMatches(matcher).stream().filter(ref -> ref.getKind().equals(kind)).collect(Collectors.toList()); - } - public static References build(SourceFile sourceFile) { Set references = new HashSet<>(); ServiceLoader loader = ServiceLoader.load(Reference.Provider.class); From 830d915dcfb465effd6df5ab78cbe5fc6706a62a Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Wed, 13 Nov 2024 10:39:21 +0100 Subject: [PATCH 16/23] Another batch of improvements --- .../org/openrewrite/SourceFileWithReferences.java | 2 +- .../openrewrite/trait/{reference => }/Reference.java | 3 +-- .../java/org/openrewrite/java/ChangePackage.java | 2 +- .../main/java/org/openrewrite/java/ChangeType.java | 2 +- .../java/org/openrewrite/java/PackageMatcher.java | 2 +- .../main/java/org/openrewrite/java/TypeMatcher.java | 2 +- .../java/org/openrewrite/java/search/FindTypes.java | 2 +- .../java/org/openrewrite/java/search/UsesType.java | 2 +- ...eOrPackageReference.java => SpringReference.java} | 12 ++++++------ .../org.openrewrite.trait.Reference$Provider | 1 + .../org.openrewrite.trait.TypeReference$Provider | 1 - .../test/java/org/openrewrite/xml/XmlParserTest.java | 2 +- ...geReferenceTest.java => SpringReferenceTest.java} | 4 ++-- 13 files changed, 18 insertions(+), 19 deletions(-) rename rewrite-core/src/main/java/org/openrewrite/trait/{reference => }/Reference.java (95%) rename rewrite-xml/src/main/java/org/openrewrite/xml/trait/{SpringTypeOrPackageReference.java => SpringReference.java} (89%) create mode 100644 rewrite-xml/src/main/resources/META-INF/services/org.openrewrite.trait.Reference$Provider delete mode 100644 rewrite-xml/src/main/resources/META-INF/services/org.openrewrite.trait.TypeReference$Provider rename rewrite-xml/src/test/java/org/openrewrite/xml/trait/{SpringTypeOrPackageReferenceTest.java => SpringReferenceTest.java} (95%) diff --git a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java index e9d9ccefa7b..24a7653e0a4 100644 --- a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java +++ b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java @@ -19,7 +19,7 @@ import lombok.Getter; import lombok.RequiredArgsConstructor; import org.jspecify.annotations.Nullable; -import org.openrewrite.trait.reference.Reference; +import org.openrewrite.trait.Reference; import java.util.*; diff --git a/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java b/rewrite-core/src/main/java/org/openrewrite/trait/Reference.java similarity index 95% rename from rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java rename to rewrite-core/src/main/java/org/openrewrite/trait/Reference.java index 6aca3c728d0..ca1760b0f41 100644 --- a/rewrite-core/src/main/java/org/openrewrite/trait/reference/Reference.java +++ b/rewrite-core/src/main/java/org/openrewrite/trait/Reference.java @@ -13,10 +13,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.openrewrite.trait.reference; +package org.openrewrite.trait; import org.openrewrite.*; -import org.openrewrite.trait.Trait; import java.util.Set; diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index dbc303b5c51..593b3fdc7a4 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -23,7 +23,7 @@ import org.openrewrite.internal.ListUtils; import org.openrewrite.java.tree.*; import org.openrewrite.marker.SearchResult; -import org.openrewrite.trait.reference.Reference; +import org.openrewrite.trait.Reference; import java.nio.file.Paths; import java.util.HashSet; diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index 8582e223231..ec6f30beda4 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -24,7 +24,7 @@ import org.openrewrite.java.tree.*; import org.openrewrite.marker.Markers; import org.openrewrite.marker.SearchResult; -import org.openrewrite.trait.reference.Reference; +import org.openrewrite.trait.Reference; import java.nio.file.Path; import java.nio.file.Paths; diff --git a/rewrite-java/src/main/java/org/openrewrite/java/PackageMatcher.java b/rewrite-java/src/main/java/org/openrewrite/java/PackageMatcher.java index 005ba06cbee..a26a91ee12c 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/PackageMatcher.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/PackageMatcher.java @@ -21,7 +21,7 @@ import org.openrewrite.Tree; import org.openrewrite.TreeVisitor; import org.openrewrite.internal.StringUtils; -import org.openrewrite.trait.reference.Reference; +import org.openrewrite.trait.Reference; import org.openrewrite.xml.tree.Xml; @Getter diff --git a/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java b/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java index 24e1f2499e6..073cdba980b 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java @@ -29,7 +29,7 @@ import org.openrewrite.java.tree.JavaType; import org.openrewrite.java.tree.TypeTree; import org.openrewrite.java.tree.TypeUtils; -import org.openrewrite.trait.reference.Reference; +import org.openrewrite.trait.Reference; import org.openrewrite.xml.tree.Xml; import java.util.regex.Pattern; diff --git a/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java b/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java index e28a4fa649c..9c936327614 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/search/FindTypes.java @@ -28,7 +28,7 @@ import org.openrewrite.java.tree.*; import org.openrewrite.marker.SearchResult; import org.openrewrite.trait.Trait; -import org.openrewrite.trait.reference.Reference; +import org.openrewrite.trait.Reference; import java.util.HashSet; import java.util.Set; diff --git a/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java b/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java index 4afd2b287e7..2e701f37491 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/search/UsesType.java @@ -28,7 +28,7 @@ import org.openrewrite.java.tree.JavaType; import org.openrewrite.java.tree.TypeUtils; import org.openrewrite.marker.SearchResult; -import org.openrewrite.trait.reference.Reference; +import org.openrewrite.trait.Reference; import java.util.function.Predicate; import java.util.regex.Pattern; diff --git a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeOrPackageReference.java b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringReference.java similarity index 89% rename from rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeOrPackageReference.java rename to rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringReference.java index 51d2ad21379..19015920185 100644 --- a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringTypeOrPackageReference.java +++ b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringReference.java @@ -19,7 +19,7 @@ import org.jspecify.annotations.Nullable; import org.openrewrite.*; import org.openrewrite.trait.SimpleTraitMatcher; -import org.openrewrite.trait.reference.Reference; +import org.openrewrite.trait.Reference; import org.openrewrite.xml.XPathMatcher; import org.openrewrite.xml.tree.Xml; @@ -28,7 +28,7 @@ import java.util.regex.Pattern; @Value -class SpringTypeOrPackageReference implements Reference { +class SpringReference implements Reference { Cursor cursor; Kind kind; @@ -61,21 +61,21 @@ public boolean supportsRename() { return true; } - static class Matcher extends SimpleTraitMatcher { + static class Matcher extends SimpleTraitMatcher { private final Pattern typeReference = Pattern.compile("\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(?:\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*"); private final XPathMatcher classXPath = new XPathMatcher("//@class"); private final XPathMatcher typeXPath = new XPathMatcher("//@type"); private final XPathMatcher tags = new XPathMatcher("//value"); @Override - protected @Nullable SpringTypeOrPackageReference test(Cursor cursor) { + protected @Nullable SpringReference test(Cursor cursor) { Object value = cursor.getValue(); if (value instanceof Xml.Attribute) { Xml.Attribute attrib = (Xml.Attribute) value; if (classXPath.matches(cursor) || typeXPath.matches(cursor)) { String stringVal = attrib.getValueAsString(); if (typeReference.matcher(stringVal).matches()) { - return new SpringTypeOrPackageReference(cursor, determineKind(stringVal)); + return new SpringReference(cursor, determineKind(stringVal)); } } } else if (value instanceof Xml.Tag) { @@ -83,7 +83,7 @@ static class Matcher extends SimpleTraitMatcher { if (tags.matches(cursor)) { String stringVal = tag.getValue().get(); if (tag.getValue().isPresent() && typeReference.matcher(stringVal).matches()) { - return new SpringTypeOrPackageReference(cursor, determineKind(stringVal)); + return new SpringReference(cursor, determineKind(stringVal)); } } } diff --git a/rewrite-xml/src/main/resources/META-INF/services/org.openrewrite.trait.Reference$Provider b/rewrite-xml/src/main/resources/META-INF/services/org.openrewrite.trait.Reference$Provider new file mode 100644 index 00000000000..72d76d75ee4 --- /dev/null +++ b/rewrite-xml/src/main/resources/META-INF/services/org.openrewrite.trait.Reference$Provider @@ -0,0 +1 @@ +org.openrewrite.xml.trait.SpringReference$Provider \ No newline at end of file diff --git a/rewrite-xml/src/main/resources/META-INF/services/org.openrewrite.trait.TypeReference$Provider b/rewrite-xml/src/main/resources/META-INF/services/org.openrewrite.trait.TypeReference$Provider deleted file mode 100644 index 6f58258f8bc..00000000000 --- a/rewrite-xml/src/main/resources/META-INF/services/org.openrewrite.trait.TypeReference$Provider +++ /dev/null @@ -1 +0,0 @@ -org.openrewrite.xml.trait.SpringTypeReference$Provider \ No newline at end of file diff --git a/rewrite-xml/src/test/java/org/openrewrite/xml/XmlParserTest.java b/rewrite-xml/src/test/java/org/openrewrite/xml/XmlParserTest.java index 56bb6d0eda8..90bb94ff45f 100755 --- a/rewrite-xml/src/test/java/org/openrewrite/xml/XmlParserTest.java +++ b/rewrite-xml/src/test/java/org/openrewrite/xml/XmlParserTest.java @@ -24,7 +24,7 @@ import org.openrewrite.Issue; import org.openrewrite.test.RecipeSpec; import org.openrewrite.test.RewriteTest; -import org.openrewrite.trait.reference.Reference; +import org.openrewrite.trait.Reference; import org.openrewrite.xml.tree.Xml; import java.nio.file.Paths; diff --git a/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeOrPackageReferenceTest.java b/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringReferenceTest.java similarity index 95% rename from rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeOrPackageReferenceTest.java rename to rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringReferenceTest.java index 599c3aa1744..cde9add97f0 100644 --- a/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringTypeOrPackageReferenceTest.java +++ b/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringReferenceTest.java @@ -23,11 +23,11 @@ import static org.openrewrite.xml.Assertions.xml; -class SpringTypeOrPackageReferenceTest implements RewriteTest { +class SpringReferenceTest implements RewriteTest { @Override public void defaults(RecipeSpec spec) { - spec.recipe(RewriteTest.toRecipe(() -> new SpringTypeOrPackageReference.Matcher() + spec.recipe(RewriteTest.toRecipe(() -> new SpringReference.Matcher() .asVisitor(springJavaTypeReference -> SearchResult.found(springJavaTypeReference.getTree(), springJavaTypeReference.getValue())))); } From b36375b9bb22641e69734b7e88edb186e88347e1 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Wed, 13 Nov 2024 11:01:05 +0100 Subject: [PATCH 17/23] Fix tests --- .../src/main/java/org/openrewrite/trait/Reference.java | 3 --- .../main/java/org/openrewrite/java/ChangePackage.java | 10 +++++----- .../src/main/java/org/openrewrite/java/ChangeType.java | 8 ++++---- .../main/java/org/openrewrite/java/PackageMatcher.java | 2 +- .../main/java/org/openrewrite/java/TypeMatcher.java | 2 +- 5 files changed, 11 insertions(+), 14 deletions(-) diff --git a/rewrite-core/src/main/java/org/openrewrite/trait/Reference.java b/rewrite-core/src/main/java/org/openrewrite/trait/Reference.java index ca1760b0f41..3819b30ad95 100644 --- a/rewrite-core/src/main/java/org/openrewrite/trait/Reference.java +++ b/rewrite-core/src/main/java/org/openrewrite/trait/Reference.java @@ -50,9 +50,6 @@ interface Provider { boolean isAcceptable(SourceFile sourceFile); } - interface MatcherMutator extends Matcher, Renamer { - } - interface Matcher { boolean matchesReference(Reference value); } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 593b3fdc7a4..85a559f60a5 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -145,9 +145,9 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; SourceFileWithReferences.References references = sourceFile.getReferences(); boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); - Reference.MatcherMutator matcherMutator = new PackageMatcher(oldPackageName, recursive); - Set matches = new HashSet<>(references.findMatches(matcherMutator, Reference.Kind.PACKAGE)); - return new ReferenceChangePackageVisitor(matches, matcherMutator, newPackageName).visit(tree, ctx, requireNonNull(getCursor().getParent())); + PackageMatcher matcher = new PackageMatcher(oldPackageName, recursive); + Set matches = new HashSet<>(references.findMatches(matcher)); + return new ReferenceChangePackageVisitor(matches, matcher, newPackageName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; } @@ -392,8 +392,8 @@ private static class ReferenceChangePackageVisitor extends TreeVisitor matches = new HashSet<>(references.findMatches(matcherMutator, Reference.Kind.TYPE)); - return new ReferenceChangeTypeVisitor(matches, matcherMutator, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); + TypeMatcher matcher = new TypeMatcher(oldFullyQualifiedTypeName); + Set matches = new HashSet<>(references.findMatches(matcher, Reference.Kind.TYPE)); + return new ReferenceChangeTypeVisitor(matches, matcher, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; } @@ -560,7 +560,7 @@ private static class ReferenceChangeTypeVisitor extends TreeVisitor Date: Wed, 13 Nov 2024 14:23:42 +0100 Subject: [PATCH 18/23] Another batch of improvements --- .../openrewrite/SourceFileWithReferences.java | 2 +- .../java/org/openrewrite/trait/Reference.java | 6 +--- .../org/openrewrite/java/ChangePackage.java | 25 +++++++------- .../java/org/openrewrite/java/ChangeType.java | 20 +++++------ .../org/openrewrite/java/PackageMatcher.java | 33 ++++++++++--------- .../org/openrewrite/java/TypeMatcher.java | 4 +-- .../xml/trait/SpringReference.java | 17 ++++++---- .../xml/trait/SpringReferenceTest.java | 10 ++++-- 8 files changed, 62 insertions(+), 55 deletions(-) diff --git a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java index 24a7653e0a4..d53fa550e7a 100644 --- a/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java +++ b/rewrite-core/src/main/java/org/openrewrite/SourceFileWithReferences.java @@ -45,7 +45,7 @@ public Collection findMatches(Reference.Matcher matcher, Reference.Ki private List findMatchesInternal(Reference.Matcher matcher, Reference.@Nullable Kind kind) { List list = new ArrayList<>(); for (Reference ref : references) { - if (ref.matches(matcher) && (kind == null || ref.getKind().equals(kind))) { + if ((kind == null || ref.getKind().equals(kind)) && ref.matches(matcher) ) { list.add(ref); } } diff --git a/rewrite-core/src/main/java/org/openrewrite/trait/Reference.java b/rewrite-core/src/main/java/org/openrewrite/trait/Reference.java index 3819b30ad95..dbaea758e6f 100644 --- a/rewrite-core/src/main/java/org/openrewrite/trait/Reference.java +++ b/rewrite-core/src/main/java/org/openrewrite/trait/Reference.java @@ -39,7 +39,7 @@ default boolean matches(Matcher matcher) { return matcher.matchesReference(this); } - default TreeVisitor rename(Renamer renamer, String replacement) { + default TreeVisitor rename(Renamer renamer, String replacement) { return renamer.rename(replacement); } @@ -56,10 +56,6 @@ interface Matcher { interface Renamer { default TreeVisitor rename(String replacement) { - return rename(replacement, false); - } - - default TreeVisitor rename(String replacement, boolean recursive) { throw new UnsupportedOperationException(); } } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 85a559f60a5..1b4def40dfd 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -26,10 +26,9 @@ import org.openrewrite.trait.Reference; import java.nio.file.Paths; -import java.util.HashSet; +import java.util.HashMap; import java.util.IdentityHashMap; import java.util.Map; -import java.util.Set; import static java.util.Objects.requireNonNull; @@ -115,13 +114,12 @@ public TreeVisitor getVisitor() { } } stopAfterPreVisit(); - } - if (tree instanceof SourceFileWithReferences) { + } else if (tree instanceof SourceFileWithReferences) { SourceFileWithReferences cu = (SourceFileWithReferences) tree; boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); String recursivePackageNamePrefix = oldPackageName + "."; for (Reference ref : cu.getReferences().getReferences()) { - if (ref.getKind().equals(Reference.Kind.PACKAGE) && ref.getValue().equals(oldPackageName) || recursive && ref.getValue().startsWith(recursivePackageNamePrefix)) { + if (ref.getValue().equals(oldPackageName) || recursive && ref.getValue().startsWith(recursivePackageNamePrefix)) { return SearchResult.found(cu); } } @@ -146,7 +144,10 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { SourceFileWithReferences.References references = sourceFile.getReferences(); boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); PackageMatcher matcher = new PackageMatcher(oldPackageName, recursive); - Set matches = new HashSet<>(references.findMatches(matcher)); + Map matches = new HashMap<>(); + for (Reference ref : references.findMatches(matcher)) { + matches.put(ref.getTree(), ref); + } return new ReferenceChangePackageVisitor(matches, matcher, newPackageName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; @@ -387,19 +388,17 @@ private boolean isTargetRecursivePackageName(String packageName) { @Value @EqualsAndHashCode(callSuper = false) private static class ReferenceChangePackageVisitor extends TreeVisitor { - Set matches; + Map matches; Reference.Renamer renamer; String newPackageName; @Override public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { - Tree tree1 = super.preVisit(tree, ctx); - for (Reference ref : matches) { - if (ref.getTree().equals(tree) && ref.supportsRename()) { - return ref.rename(renamer, newPackageName).visit(tree, ctx, getCursor().getParent()); - } + Reference reference = matches.get(tree); + if (reference != null && reference.supportsRename()) { + return reference.rename(renamer, newPackageName).visit(tree, ctx, getCursor().getParent()); } - return tree1; + return tree; } } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index 4c2c44cb6fd..1374f52417c 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -89,8 +89,7 @@ public TreeVisitor getVisitor() { return SearchResult.found(cu); } return new UsesType<>(oldFullyQualifiedTypeName, true).visitNonNull(cu, ctx); - } - if (tree instanceof SourceFileWithReferences) { + } else if (tree instanceof SourceFileWithReferences) { SourceFileWithReferences cu = (SourceFileWithReferences) tree; return new UsesType<>(oldFullyQualifiedTypeName, true).visitNonNull(cu, ctx); } @@ -112,7 +111,10 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { SourceFileWithReferences sourceFile = (SourceFileWithReferences) tree; SourceFileWithReferences.References references = sourceFile.getReferences(); TypeMatcher matcher = new TypeMatcher(oldFullyQualifiedTypeName); - Set matches = new HashSet<>(references.findMatches(matcher, Reference.Kind.TYPE)); + Map matches = new HashMap<>(); + for (Reference ref : references.findMatches(matcher, Reference.Kind.TYPE)) { + matches.put(ref.getTree(), ref); + } return new ReferenceChangeTypeVisitor(matches, matcher, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } return tree; @@ -554,19 +556,17 @@ private boolean hasNoConflictingImport(@Nullable JavaSourceFile sf) { @Value @EqualsAndHashCode(callSuper = false) private static class ReferenceChangeTypeVisitor extends TreeVisitor { - Set matches; + Map matches; Reference.Renamer renamer; String newFullyQualifiedName; @Override public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { - Tree tree1 = super.preVisit(tree, ctx); - for (Reference ref : matches) { - if (ref.getTree().equals(tree) && ref.supportsRename()) { - return ref.rename(renamer, newFullyQualifiedName).visit(tree, ctx, getCursor().getParent()); - } + Reference reference = matches.get(tree); + if (reference != null && reference.supportsRename()) { + return reference.rename(renamer, newFullyQualifiedName).visit(tree, ctx, getCursor().getParent()); } - return tree1; + return tree; } } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/PackageMatcher.java b/rewrite-java/src/main/java/org/openrewrite/java/PackageMatcher.java index c9c36bbb00a..c6a88019001 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/PackageMatcher.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/PackageMatcher.java @@ -27,32 +27,33 @@ @Getter public class PackageMatcher implements Reference.Renamer, Reference.Matcher { - @Nullable - private String targetPackage; + private final @Nullable String targetPackage; @Getter private final Boolean recursive; - public PackageMatcher(@Nullable String fieldType) { - this(fieldType, false); + public PackageMatcher(@Nullable String targetPackage) { + this(targetPackage, false); } - public PackageMatcher(@Nullable String fieldType, @Nullable boolean recursive) { - this.targetPackage = fieldType; + public PackageMatcher(@Nullable String targetPackage, boolean recursive) { + this.targetPackage = targetPackage; this.recursive = recursive; } @Override public boolean matchesReference(Reference reference) { - String recursivePackageNamePrefix = targetPackage + "."; - if (reference.getValue().equals(targetPackage) || recursive && reference.getValue().startsWith(recursivePackageNamePrefix)) { - return true; + if (reference.getKind().equals(Reference.Kind.TYPE) || reference.getKind().equals(Reference.Kind.PACKAGE)) { + String recursivePackageNamePrefix = targetPackage + "."; + if (reference.getValue().equals(targetPackage) || recursive && reference.getValue().startsWith(recursivePackageNamePrefix)) { + return true; + } } return false; } @Override - public TreeVisitor rename(String newValue, boolean recursive) { + public TreeVisitor rename(String newValue) { return new TreeVisitor() { @Override public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { @@ -71,11 +72,13 @@ public TreeVisitor rename(String newValue, boolean recur }; } - String getReplacement(String value, String oldValue, String newValue) { - if (recursive) { - return value.replace(oldValue, newValue); - } else if (value.startsWith(oldValue) && Character.isUpperCase(value.charAt(oldValue.length() + 1))) { - return value.replace(oldValue, newValue); + String getReplacement(String value, @Nullable String oldValue, String newValue) { + if (oldValue != null) { + if (recursive) { + return value.replace(oldValue, newValue); + } else if (value.startsWith(oldValue) && Character.isUpperCase(value.charAt(oldValue.length() + 1))) { + return value.replace(oldValue, newValue); + } } return value; } diff --git a/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java b/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java index f8001eb9b6b..fe5a8cdea9f 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/TypeMatcher.java @@ -117,11 +117,11 @@ private static boolean isPlainIdentifier(MethodSignatureParser.TargetTypePattern @Override public boolean matchesReference(Reference reference) { - return matchesTargetTypeName(reference.getValue()); + return reference.getKind().equals(Reference.Kind.TYPE) && matchesTargetTypeName(reference.getValue()); } @Override - public TreeVisitor rename(String newValue, boolean recursive) { + public TreeVisitor rename(String newValue) { return new TreeVisitor() { @Override public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) { diff --git a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringReference.java b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringReference.java index 19015920185..9b52ae44d42 100644 --- a/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringReference.java +++ b/rewrite-xml/src/main/java/org/openrewrite/xml/trait/SpringReference.java @@ -24,6 +24,7 @@ import org.openrewrite.xml.tree.Xml; import java.util.HashSet; +import java.util.Optional; import java.util.Set; import java.util.regex.Pattern; @@ -62,9 +63,11 @@ public boolean supportsRename() { } static class Matcher extends SimpleTraitMatcher { - private final Pattern typeReference = Pattern.compile("\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(?:\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*"); + private final Pattern referencePattern = Pattern.compile("\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(?:\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*"); private final XPathMatcher classXPath = new XPathMatcher("//@class"); private final XPathMatcher typeXPath = new XPathMatcher("//@type"); + private final XPathMatcher keyTypeXPath = new XPathMatcher("//@key-type"); + private final XPathMatcher valueTypeXPath = new XPathMatcher("//@value-type"); private final XPathMatcher tags = new XPathMatcher("//value"); @Override @@ -72,18 +75,18 @@ static class Matcher extends SimpleTraitMatcher { Object value = cursor.getValue(); if (value instanceof Xml.Attribute) { Xml.Attribute attrib = (Xml.Attribute) value; - if (classXPath.matches(cursor) || typeXPath.matches(cursor)) { + if (classXPath.matches(cursor) || typeXPath.matches(cursor) || keyTypeXPath.matches(cursor) || valueTypeXPath.matches(cursor)) { String stringVal = attrib.getValueAsString(); - if (typeReference.matcher(stringVal).matches()) { + if (referencePattern.matcher(stringVal).matches()) { return new SpringReference(cursor, determineKind(stringVal)); } } } else if (value instanceof Xml.Tag) { Xml.Tag tag = (Xml.Tag) value; if (tags.matches(cursor)) { - String stringVal = tag.getValue().get(); - if (tag.getValue().isPresent() && typeReference.matcher(stringVal).matches()) { - return new SpringReference(cursor, determineKind(stringVal)); + Optional stringVal = tag.getValue(); + if (stringVal.isPresent() && referencePattern.matcher(stringVal.get()).matches()) { + return new SpringReference(cursor, determineKind(stringVal.get())); } } } @@ -91,7 +94,7 @@ static class Matcher extends SimpleTraitMatcher { } Kind determineKind(String value) { - return Character.isUpperCase(value.charAt(value.lastIndexOf('.')+1)) ? Kind.TYPE : Kind.PACKAGE; + return Character.isUpperCase(value.charAt(value.lastIndexOf('.') + 1)) ? Kind.TYPE : Kind.PACKAGE; } } diff --git a/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringReferenceTest.java b/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringReferenceTest.java index cde9add97f0..30855b16348 100644 --- a/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringReferenceTest.java +++ b/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringReferenceTest.java @@ -46,13 +46,16 @@ void xmlConfiguration() { - + java.lang.String java.lang + + + @@ -67,13 +70,16 @@ void xmlConfiguration() { -->class="org.springframework.beans.TestBean"> - -->class="java.lang.Integer"/> + -->class="java.lang.int"/> java.lang.String java.lang + + -->key-type="java.lang.String" value-type="java.lang.String"/> + From 8a13c4923b71c250401164184930574214d7e5c2 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Wed, 13 Nov 2024 14:36:26 +0100 Subject: [PATCH 19/23] Revert primitive --- .../java/org/openrewrite/xml/trait/SpringReferenceTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringReferenceTest.java b/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringReferenceTest.java index 30855b16348..d60f5a2e8a9 100644 --- a/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringReferenceTest.java +++ b/rewrite-xml/src/test/java/org/openrewrite/xml/trait/SpringReferenceTest.java @@ -46,7 +46,7 @@ void xmlConfiguration() { - + java.lang.String @@ -70,7 +70,7 @@ void xmlConfiguration() { -->class="org.springframework.beans.TestBean"> - -->class="java.lang.int"/> + -->class="java.lang.Integer"/> java.lang.String From b84950e8ce63d8af008c56c70667951a3e1cf815 Mon Sep 17 00:00:00 2001 From: Laurens Westerlaken Date: Wed, 13 Nov 2024 17:13:40 +0100 Subject: [PATCH 20/23] Update `preVisit`'s --- .../java/org/openrewrite/java/ChangePackage.java | 13 +++++++------ .../java/org/openrewrite/java/ChangeType.java | 15 +++++++++------ 2 files changed, 16 insertions(+), 12 deletions(-) diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 1b4def40dfd..8631627172a 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -88,6 +88,7 @@ public TreeVisitor getVisitor() { TreeVisitor condition = new TreeVisitor() { @Override public @Nullable Tree preVisit(Tree tree, ExecutionContext ctx) { + stopAfterPreVisit(); if (tree instanceof JavaSourceFile) { JavaSourceFile cu = (JavaSourceFile) tree; if (cu.getPackageDeclaration() != null) { @@ -113,7 +114,6 @@ public TreeVisitor getVisitor() { } } } - stopAfterPreVisit(); } else if (tree instanceof SourceFileWithReferences) { SourceFileWithReferences cu = (SourceFileWithReferences) tree; boolean recursive = Boolean.TRUE.equals(ChangePackage.this.recursive); @@ -123,7 +123,6 @@ public TreeVisitor getVisitor() { return SearchResult.found(cu); } } - stopAfterPreVisit(); } return super.preVisit(tree, ctx); } @@ -136,7 +135,8 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } @Override - public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { + public @Nullable Tree preVisit(Tree tree, ExecutionContext ctx) { + stopAfterPreVisit(); if (tree instanceof JavaSourceFile) { return new JavaChangePackageVisitor().visit(tree, ctx, requireNonNull(getCursor().getParent())); } else if (tree instanceof SourceFileWithReferences) { @@ -150,7 +150,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } return new ReferenceChangePackageVisitor(matches, matcher, newPackageName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } - return tree; + return super.preVisit(tree, ctx); } }); } @@ -393,12 +393,13 @@ private static class ReferenceChangePackageVisitor extends TreeVisitor getVisitor() { TreeVisitor condition = new TreeVisitor() { @Override - public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { + public @Nullable Tree preVisit(Tree tree, ExecutionContext ctx) { + stopAfterPreVisit(); if (tree instanceof JavaSourceFile) { JavaSourceFile cu = (JavaSourceFile) tree; if (!Boolean.TRUE.equals(ignoreDefinition) && containsClassDefinition(cu, oldFullyQualifiedTypeName)) { @@ -93,7 +94,7 @@ public TreeVisitor getVisitor() { SourceFileWithReferences cu = (SourceFileWithReferences) tree; return new UsesType<>(oldFullyQualifiedTypeName, true).visitNonNull(cu, ctx); } - return tree; + return super.preVisit(tree, ctx); } }; @@ -104,7 +105,8 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } @Override - public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { + public @Nullable Tree preVisit(Tree tree, ExecutionContext ctx) { + stopAfterPreVisit(); if (tree instanceof JavaSourceFile) { return new JavaChangeTypeVisitor(oldFullyQualifiedTypeName, newFullyQualifiedTypeName, ignoreDefinition).visit(tree, ctx, requireNonNull(getCursor().getParent())); } else if (tree instanceof SourceFileWithReferences) { @@ -117,7 +119,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } return new ReferenceChangeTypeVisitor(matches, matcher, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } - return tree; + return super.preVisit(tree, ctx); } }); } @@ -561,12 +563,13 @@ private static class ReferenceChangeTypeVisitor extends TreeVisitor Date: Wed, 13 Nov 2024 17:15:13 +0100 Subject: [PATCH 21/23] Update `preVisit`'s --- .../java/org/openrewrite/java/ChangePackage.java | 12 ++++++------ .../main/java/org/openrewrite/java/ChangeType.java | 12 ++++++------ 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 8631627172a..898b8586a92 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -87,7 +87,7 @@ public Validated validate() { public TreeVisitor getVisitor() { TreeVisitor condition = new TreeVisitor() { @Override - public @Nullable Tree preVisit(Tree tree, ExecutionContext ctx) { + public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { stopAfterPreVisit(); if (tree instanceof JavaSourceFile) { JavaSourceFile cu = (JavaSourceFile) tree; @@ -124,7 +124,7 @@ public TreeVisitor getVisitor() { } } } - return super.preVisit(tree, ctx); + return tree; } }; @@ -135,7 +135,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } @Override - public @Nullable Tree preVisit(Tree tree, ExecutionContext ctx) { + public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { stopAfterPreVisit(); if (tree instanceof JavaSourceFile) { return new JavaChangePackageVisitor().visit(tree, ctx, requireNonNull(getCursor().getParent())); @@ -150,7 +150,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } return new ReferenceChangePackageVisitor(matches, matcher, newPackageName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } - return super.preVisit(tree, ctx); + return tree; } }); } @@ -393,13 +393,13 @@ private static class ReferenceChangePackageVisitor extends TreeVisitor getVisitor() { TreeVisitor condition = new TreeVisitor() { @Override - public @Nullable Tree preVisit(Tree tree, ExecutionContext ctx) { + public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { stopAfterPreVisit(); if (tree instanceof JavaSourceFile) { JavaSourceFile cu = (JavaSourceFile) tree; @@ -94,7 +94,7 @@ public TreeVisitor getVisitor() { SourceFileWithReferences cu = (SourceFileWithReferences) tree; return new UsesType<>(oldFullyQualifiedTypeName, true).visitNonNull(cu, ctx); } - return super.preVisit(tree, ctx); + return tree; } }; @@ -105,7 +105,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } @Override - public @Nullable Tree preVisit(Tree tree, ExecutionContext ctx) { + public @Nullable Tree preVisit(@Nullable Tree tree, ExecutionContext ctx) { stopAfterPreVisit(); if (tree instanceof JavaSourceFile) { return new JavaChangeTypeVisitor(oldFullyQualifiedTypeName, newFullyQualifiedTypeName, ignoreDefinition).visit(tree, ctx, requireNonNull(getCursor().getParent())); @@ -119,7 +119,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { } return new ReferenceChangeTypeVisitor(matches, matcher, newFullyQualifiedTypeName).visit(tree, ctx, requireNonNull(getCursor().getParent())); } - return super.preVisit(tree, ctx); + return tree; } }); } @@ -563,13 +563,13 @@ private static class ReferenceChangeTypeVisitor extends TreeVisitor Date: Wed, 13 Nov 2024 17:29:29 +0100 Subject: [PATCH 22/23] Update `preVisit` --- rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java | 1 - 1 file changed, 1 deletion(-) diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java index 702c934cad5..04dd93a0c99 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java @@ -564,7 +564,6 @@ private static class ReferenceChangeTypeVisitor extends TreeVisitor Date: Wed, 13 Nov 2024 17:51:14 +0100 Subject: [PATCH 23/23] Update `preVisit` --- .../src/main/java/org/openrewrite/java/ChangePackage.java | 1 - 1 file changed, 1 deletion(-) diff --git a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java index 898b8586a92..876410cc5cf 100644 --- a/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java +++ b/rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java @@ -394,7 +394,6 @@ private static class ReferenceChangePackageVisitor extends TreeVisitor