Fix RemoveDependency.unlessUsing for multi-module Maven projects (#183)

* Fix `RemoveDependency.unlessUsing` for multi-module Maven projects

`RemoveDependency` scans every source file and records whether `unlessUsing`
matched against the file's `JavaProject` marker. In a multi-module Maven
project the parent pom carries its own `JavaProject` distinct from the
children, so the parent module's accumulator entry never reflects type
usages found in child modules. The visitor would then strip the
`<dependency>` from the parent pom even though child modules in the same
reactor still relied on inheriting it.

Now the scanner additionally records the `MavenResolutionResult.id ->
JavaProject` mapping for every pom it visits. When the visitor is about to
remove a `<dependency>` from a pom, it walks that pom's descendant modules
via `MavenResolutionResult.getModules()` and preserves the declaration if
any descendant's `JavaProject` shows the type in use.

* Allow `RemoveDependency` to remove ancestor decl when descendants self-declare

The descendant-aware preservation introduced in the previous commit was
intentionally conservative: any descendant module whose Java sources used
the `unlessUsing` type blocked removal of the dep from an ancestor pom.
That over-preserves when a descendant module also declares the same
dependency directly in its own `<dependencies>` — in that case the
descendant is self-sufficient and the ancestor's declaration is dead
weight.

Refine the check: a descendant only blocks removal if it uses the type AND
does not declare the dependency itself. The self-declaration check looks
at the raw `requested` pom (as-written), not the resolved/inherited
dependency list, so a child that inherits the dep from the ancestor we
might modify still correctly blocks removal.

Author: steve-aom-elliott

src/main/java/org/openrewrite/java/dependencies/RemoveDependency.java

@@ -21,13 +21,18 @@
 import org.openrewrite.*;
 import org.openrewrite.java.marker.JavaProject;
 import org.openrewrite.java.search.UsesType;
+import org.openrewrite.maven.tree.Dependency;
+import org.openrewrite.maven.tree.MavenResolutionResult;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.UUID;
+
+import static org.openrewrite.internal.StringUtils.matchesGlob;
 
 @EqualsAndHashCode(callSuper = false)
 @Value
-public class RemoveDependency extends ScanningRecipe<Map<JavaProject, Boolean>> {
+public class RemoveDependency extends ScanningRecipe<RemoveDependency.Accumulator> {
     @Option(displayName = "Group ID",
             description = "The first part of a dependency coordinate `com.google.guava:guava:VERSION`. This can be a glob expression.",
             example = "com.fasterxml.jackson*")
@@ -68,13 +73,18 @@ public class RemoveDependency extends ScanningRecipe<Map<JavaProject, Boolean>>
     String description = "For Gradle project, removes a single dependency from the dependencies section of the `build.gradle`.\n" +
                "For Maven project, removes a single dependency from the `<dependencies>` section of the pom.xml.";
 
+    public static class Accumulator {
+        final Map<JavaProject, Boolean> projectToInUse = new HashMap<>();
+        final Map<UUID, JavaProject> mavenIdToProject = new HashMap<>();
+    }
+
     @Override
-    public Map<JavaProject, Boolean> getInitialValue(ExecutionContext ctx) {
-        return new HashMap<>();
+    public Accumulator getInitialValue(ExecutionContext ctx) {
+        return new Accumulator();
     }
 
     @Override
-    public TreeVisitor<?, ExecutionContext> getScanner(Map<JavaProject, Boolean> projectToInUse) {
+    public TreeVisitor<?, ExecutionContext> getScanner(Accumulator acc) {
         if (unlessUsing == null) {
             return TreeVisitor.noop();
         }
@@ -83,15 +93,19 @@ public TreeVisitor<?, ExecutionContext> getScanner(Map<JavaProject, Boolean> pro
             @Override
             public Tree preVisit(Tree tree, ExecutionContext ctx) {
                 stopAfterPreVisit();
-                tree.getMarkers().findFirst(JavaProject.class).ifPresent(javaProject ->
-                    projectToInUse.compute(javaProject, (jp, foundSoFar) -> Boolean.TRUE.equals(foundSoFar) || tree != usesType.visit(tree, ctx)));
+                tree.getMarkers().findFirst(JavaProject.class).ifPresent(javaProject -> {
+                    acc.projectToInUse.compute(javaProject, (jp, foundSoFar) ->
+                            Boolean.TRUE.equals(foundSoFar) || tree != usesType.visit(tree, ctx));
+                    tree.getMarkers().findFirst(MavenResolutionResult.class).ifPresent(mrr ->
+                            acc.mavenIdToProject.put(mrr.getId(), javaProject));
+                });
                 return tree;
             }
         };
     }
 
     @Override
-    public TreeVisitor<?, ExecutionContext> getVisitor(Map<JavaProject, Boolean> projectToInUse) {
+    public TreeVisitor<?, ExecutionContext> getVisitor(Accumulator acc) {
         return new TreeVisitor<Tree, ExecutionContext>() {
             final TreeVisitor<?, ExecutionContext> gradleRemoveDep = new org.openrewrite.gradle.RemoveDependency(groupId, artifactId, configuration).getVisitor();
             final TreeVisitor<?, ExecutionContext> mavenRemoveDep = new org.openrewrite.maven.RemoveDependency(groupId, artifactId, scope).getVisitor();
@@ -103,7 +117,11 @@ public TreeVisitor<?, ExecutionContext> getVisitor(Map<JavaProject, Boolean> pro
                 }
                 if (unlessUsing != null) {
                     JavaProject jp = tree.getMarkers().findFirst(JavaProject.class).orElse(null);
-                    if (jp == null || Boolean.TRUE.equals(projectToInUse.get(jp))) {
+                    if (jp == null || Boolean.TRUE.equals(acc.projectToInUse.get(jp))) {
+                        return tree;
+                    }
+                    MavenResolutionResult mrr = tree.getMarkers().findFirst(MavenResolutionResult.class).orElse(null);
+                    if (mrr != null && anyDescendantPreservesDependency(mrr, acc)) {
                         return tree;
                     }
                 }
@@ -118,4 +136,35 @@ public TreeVisitor<?, ExecutionContext> getVisitor(Map<JavaProject, Boolean> pro
             }
         };
     }
+
+    /**
+     * Keep this pom's `<dependency>` declaration if any descendant module in the reactor uses the
+     * `unlessUsing` type AND does not also declare the dependency itself. A descendant that
+     * self-declares the dependency in its own pom is unaffected by removing it from an ancestor,
+     * so it should not block removal.
+     */
+    private boolean anyDescendantPreservesDependency(MavenResolutionResult mrr, Accumulator acc) {
+        for (MavenResolutionResult child : mrr.getModules()) {
+            JavaProject childJp = acc.mavenIdToProject.get(child.getId());
+            if (childJp != null && Boolean.TRUE.equals(acc.projectToInUse.get(childJp)) && !declaresDependency(child)) {
+                return true;
+            }
+            if (anyDescendantPreservesDependency(child, acc)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean declaresDependency(MavenResolutionResult mrr) {
+        // Look at the raw `requested` pom — the as-written `<dependencies>` of this module only,
+        // excluding inheritance from a parent pom. A module that inherits the dep from the parent
+        // we may be modifying should still block removal.
+        for (Dependency d : mrr.getPom().getRequested().getDependencies()) {
+            if (matchesGlob(d.getGroupId(), groupId) && matchesGlob(d.getArtifactId(), artifactId)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }