From 5445c63f46a0db3e58f11d3e9adb5cd02d8e2a76 Mon Sep 17 00:00:00 2001 From: Sam Snyder Date: Fri, 17 Apr 2026 18:03:20 -0700 Subject: [PATCH 1/2] Minimize the eager resolution of transitive dependencies when upgrading dependency versions. --- .../gradle/UpgradeDependencyVersion.java | 8 +- .../gradle/internal/AddDependencyVisitor.java | 2 +- .../marker/GradleDependencyConfiguration.java | 67 +++++++- .../gradle/trait/GradleDependency.java | 4 +- .../gradle/UpgradeDependencyVersionTest.java | 143 ++++++++++++++++++ .../openrewrite/maven/tree/ResolvedPom.java | 24 ++- 6 files changed, 229 insertions(+), 19 deletions(-) diff --git a/rewrite-gradle/src/main/java/org/openrewrite/gradle/UpgradeDependencyVersion.java b/rewrite-gradle/src/main/java/org/openrewrite/gradle/UpgradeDependencyVersion.java index 5fc72a28239..401b0a132bb 100644 --- a/rewrite-gradle/src/main/java/org/openrewrite/gradle/UpgradeDependencyVersion.java +++ b/rewrite-gradle/src/main/java/org/openrewrite/gradle/UpgradeDependencyVersion.java @@ -168,7 +168,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { DependencyMatcher depMatcher = new DependencyMatcher(groupId, artifactId, null); Set matched = new HashSet<>(); for (GradleDependencyConfiguration config : gradleProject.getConfigurations()) { - for (ResolvedDependency resolved : config.getDirectResolved()) { + for (ResolvedDependency resolved : config.getDirectResolvedShallow()) { if (depMatcher.matches(resolved.getGroupId(), resolved.getArtifactId())) { matched.add(resolved); } @@ -524,11 +524,7 @@ private JavaSourceFile applyPluginProvidedDependencies(JavaSourceFile sourceFile continue; } - for (ResolvedDependency resolved : configuration.getResolved()) { - if (!resolved.isDirect()) { - continue; - } - + for (ResolvedDependency resolved : configuration.getDirectResolvedShallow()) { if (!dependencyMatcher.matches(resolved.getGroupId(), resolved.getArtifactId())) { continue; } diff --git a/rewrite-gradle/src/main/java/org/openrewrite/gradle/internal/AddDependencyVisitor.java b/rewrite-gradle/src/main/java/org/openrewrite/gradle/internal/AddDependencyVisitor.java index 55a9c1f78ca..6c984c20604 100644 --- a/rewrite-gradle/src/main/java/org/openrewrite/gradle/internal/AddDependencyVisitor.java +++ b/rewrite-gradle/src/main/java/org/openrewrite/gradle/internal/AddDependencyVisitor.java @@ -275,7 +275,7 @@ public static JavaSourceFile addDependency( newRequested)); if (newGdc.isCanBeResolved() && resolvedGav != null) { newGdc = newGdc.withDirectResolved(ListUtils.concat( - ListUtils.map(gdc.getDirectResolved(), resolved -> { + ListUtils.map(gdc.getDirectResolvedShallow(), resolved -> { // Remove any existing dependency with the same group and artifact id if (Objects.equals(resolved.getGroupId(), resolvedGav.getGroupId()) && Objects.equals(resolved.getArtifactId(), resolvedGav.getArtifactId())) { return null; diff --git a/rewrite-gradle/src/main/java/org/openrewrite/gradle/marker/GradleDependencyConfiguration.java b/rewrite-gradle/src/main/java/org/openrewrite/gradle/marker/GradleDependencyConfiguration.java index fcafd4221fa..b944ebbc832 100644 --- a/rewrite-gradle/src/main/java/org/openrewrite/gradle/marker/GradleDependencyConfiguration.java +++ b/rewrite-gradle/src/main/java/org/openrewrite/gradle/marker/GradleDependencyConfiguration.java @@ -96,7 +96,8 @@ public class GradleDependencyConfiguration implements Serializable, Attributed { List directResolved; /** - * The list of direct dependencies resolved for this configuration. + * The list of direct dependencies resolved for this configuration. Each returned dependency has its full + * transitive tree populated under {@link ResolvedDependency#getDependencies()}. */ public List getDirectResolved() { if (resolutionContext.isResolveRequired()) { @@ -106,6 +107,18 @@ public List getDirectResolved() { return directResolved == null ? emptyList() : directResolved; } + /** + * Like {@link #getDirectResolved()}, but avoids downloading the transitive closure of each direct dependency. + * Each returned dependency has an empty {@link ResolvedDependency#getDependencies()} list unless a full + * resolution has already been performed previously. Use this when you only need the declared coordinates of + * direct dependencies and do not intend to walk into their transitives. + */ + public List getDirectResolvedShallow() { + resolutionContext.resolveDirect(); + //noinspection ConstantValue + return directResolved == null ? emptyList() : directResolved; + } + /** * The list of all dependencies resolved for this configuration, including transitive dependencies. */ @@ -180,19 +193,29 @@ public GradleDependencyConfiguration markForReResolution(List r return this; } private class LazyResolutionContext { - private @Getter boolean resolveRequired; + private boolean resolveRequired; + private boolean transitivesResolved; private @Nullable List repositories; private @Nullable ExecutionContext ctx; private @Nullable List resolved; + public boolean isResolveRequired() { + // Resolution (or upgrade-to-deep) is still possible as long as we retain repositories + ctx. + return (resolveRequired || !transitivesResolved) && repositories != null && ctx != null; + } + public void markForReResolution(List repositories, ExecutionContext ctx) { this.repositories = repositories; this.resolveRequired = true; + this.transitivesResolved = false; this.ctx = ctx; } /** - * Attempt to download the maven poms of the direct dependencies to produce an updated set of resolved dependencies. + * Ensure {@code directResolved} is populated with the complete transitive dependency tree under each + * direct dependency. If only a shallow resolution has been done previously within this run, this will + * upgrade the state to a full resolution. After deep resolution succeeds, the captured repositories and + * execution context are released. * It is expected that some dependencies may both be valid and beyond our ability to resolve. * Anything coming from an ivy repository, flat directory, gcp artifact service, etc., OpenRewrite does not support. * This method has not been tested in a Gradle composite build. @@ -202,7 +225,34 @@ public void markForReResolution(List repositories, ExecutionCon * It is the responsibility of recipes to report this to the user, typically via GradleProject.maybeWarn() */ public void resolve() { - if (!resolveRequired || repositories == null || ctx == null) { + if (transitivesResolved || repositories == null || ctx == null) { + return; + } + doResolve(true); + transitivesResolved = true; + repositories = null; + ctx = null; + } + + /** + * Populate {@code directResolved} with direct dependencies only, skipping the download of their transitive + * closure. If a full resolution has already happened this is a no-op. Repositories + ctx are retained so + * that a later call to {@link #resolve()} can upgrade the state to a full resolution if a caller that walks + * transitive dependencies needs it. + */ + public void resolveDirect() { + if (!resolveRequired) { + return; + } + if (repositories == null || ctx == null) { + return; + } + doResolve(false); + resolveRequired = false; + } + + private void doResolve(boolean resolveTransitives) { + if (repositories == null || ctx == null) { return; } if (isCanBeResolved) { @@ -222,8 +272,10 @@ public void resolve() { } else { Pom singlePom = singleDependencyPom(dep, requested, repositories, ctx); ResolvedPom singleDependencyResolved = singlePom.resolve(emptyList(), mpd, ctx); - ResolvedDependency resolved = singleDependencyResolved.resolveDependencies(Scope.Compile, mpd, ctx).get(0); - newResolved.add(resolved); + List resolvedList = resolveTransitives + ? singleDependencyResolved.resolveDependencies(Scope.Compile, mpd, ctx) + : singleDependencyResolved.resolveDirectDependencies(Scope.Compile, mpd, ctx); + newResolved.add(resolvedList.get(0)); } } catch (MavenDownloadingException | MavenDownloadingExceptions e) { MavenDownloadingException m; @@ -253,12 +305,11 @@ public void resolve() { resolved = null; } resolveRequired = false; - repositories = null; - ctx = null; } public List getResolved() { if (resolved == null) { + resolve(); List newResolved = new ArrayList<>(getDirectResolved()); Map alreadyResolved = new HashMap<>(); Map versionCache = new HashMap<>(); diff --git a/rewrite-gradle/src/main/java/org/openrewrite/gradle/trait/GradleDependency.java b/rewrite-gradle/src/main/java/org/openrewrite/gradle/trait/GradleDependency.java index 518a21a3f5e..31e2492a285 100644 --- a/rewrite-gradle/src/main/java/org/openrewrite/gradle/trait/GradleDependency.java +++ b/rewrite-gradle/src/main/java/org/openrewrite/gradle/trait/GradleDependency.java @@ -1495,7 +1495,7 @@ public J visitMethodInvocation(J.MethodInvocation method, P p) { if (gdc != null) { if (gdc.isCanBeResolved()) { - for (ResolvedDependency resolvedDependency : gdc.getDirectResolved()) { + for (ResolvedDependency resolvedDependency : gdc.getDirectResolvedShallow()) { if (matcher == null || matcher.matches(resolvedDependency.getGroupId(), resolvedDependency.getArtifactId())) { Dependency req = resolvedDependency.getRequested(); if ((req.getGroupId() == null || req.getGroupId().equals(dependency.getGroupId())) && @@ -1507,7 +1507,7 @@ public J visitMethodInvocation(J.MethodInvocation method, P p) { } else { for (GradleDependencyConfiguration transitiveConfiguration : gradleProject.configurationsExtendingFrom(gdc, true)) { if (transitiveConfiguration.isCanBeResolved()) { - for (ResolvedDependency resolvedDependency : transitiveConfiguration.getDirectResolved()) { + for (ResolvedDependency resolvedDependency : transitiveConfiguration.getDirectResolvedShallow()) { if (matcher == null || matcher.matches(resolvedDependency.getGroupId(), resolvedDependency.getArtifactId())) { Dependency req = resolvedDependency.getRequested(); if ((req.getGroupId() == null || req.getGroupId().equals(dependency.getGroupId())) && diff --git a/rewrite-gradle/src/test/java/org/openrewrite/gradle/UpgradeDependencyVersionTest.java b/rewrite-gradle/src/test/java/org/openrewrite/gradle/UpgradeDependencyVersionTest.java index db2e02859c0..44ebaf2dc40 100644 --- a/rewrite-gradle/src/test/java/org/openrewrite/gradle/UpgradeDependencyVersionTest.java +++ b/rewrite-gradle/src/test/java/org/openrewrite/gradle/UpgradeDependencyVersionTest.java @@ -15,18 +15,30 @@ */ package org.openrewrite.gradle; +import org.jspecify.annotations.Nullable; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; import org.openrewrite.*; import org.openrewrite.gradle.marker.GradleDependencyConfiguration; import org.openrewrite.gradle.marker.GradleProject; +import org.openrewrite.maven.MavenDownloadingException; +import org.openrewrite.maven.MavenExecutionContextView; +import org.openrewrite.maven.cache.InMemoryMavenPomCache; +import org.openrewrite.maven.cache.MavenPomCache; +import org.openrewrite.maven.tree.GroupArtifactVersion; +import org.openrewrite.maven.tree.MavenMetadata; +import org.openrewrite.maven.tree.MavenRepository; +import org.openrewrite.maven.tree.Pom; import org.openrewrite.maven.tree.ResolvedDependency; +import org.openrewrite.maven.tree.ResolvedGroupArtifactVersion; +import org.openrewrite.maven.tree.ResolvedPom; import org.openrewrite.properties.PropertiesParser; import org.openrewrite.test.RecipeSpec; import org.openrewrite.test.RewriteTest; import org.openrewrite.text.PlainTextParser; +import java.net.URI; import java.nio.file.Path; import java.util.Optional; import java.util.regex.Matcher; @@ -104,6 +116,137 @@ void guavaCompileOnly() { ); } + @Test + void doesNotResolveTransitiveDependencies() { + MavenPomCache delegate = new InMemoryMavenPomCache(); + MavenPomCache failOnFailureAccess = new MavenPomCache() { + private void assertNotFailureAccess(String groupId, String artifactId) { + if ("com.google.guava".equals(groupId) && "failureaccess".equals(artifactId)) { + throw new AssertionError("UpgradeDependencyVersion should not resolve the transitive dependency " + + "com.google.guava:failureaccess"); + } + } + + @Override + public @Nullable ResolvedPom getResolvedDependencyPom(ResolvedGroupArtifactVersion dependency) { + assertNotFailureAccess(dependency.getGroupId(), dependency.getArtifactId()); + return delegate.getResolvedDependencyPom(dependency); + } + + @Override + public void putResolvedDependencyPom(ResolvedGroupArtifactVersion dependency, ResolvedPom resolved) { + assertNotFailureAccess(dependency.getGroupId(), dependency.getArtifactId()); + delegate.putResolvedDependencyPom(dependency, resolved); + } + + @Override + public @Nullable Optional getMavenMetadata(URI repo, GroupArtifactVersion gav) { + assertNotFailureAccess(gav.getGroupId(), gav.getArtifactId()); + return delegate.getMavenMetadata(repo, gav); + } + + @Override + public void putMavenMetadata(URI repo, GroupArtifactVersion gav, @Nullable MavenMetadata metadata) { + assertNotFailureAccess(gav.getGroupId(), gav.getArtifactId()); + delegate.putMavenMetadata(repo, gav, metadata); + } + + @Override + public @Nullable Optional getPom(ResolvedGroupArtifactVersion gav) throws MavenDownloadingException { + assertNotFailureAccess(gav.getGroupId(), gav.getArtifactId()); + return delegate.getPom(gav); + } + + @Override + public void putPom(ResolvedGroupArtifactVersion gav, @Nullable Pom pom) { + assertNotFailureAccess(gav.getGroupId(), gav.getArtifactId()); + delegate.putPom(gav, pom); + } + + @Override + public @Nullable Optional getNormalizedRepository(MavenRepository repository) { + return delegate.getNormalizedRepository(repository); + } + + @Override + public void putNormalizedRepository(MavenRepository repository, MavenRepository normalized) { + delegate.putNormalizedRepository(repository, normalized); + } + }; + rewriteRun( + spec -> spec.recipeExecutionContext( + MavenExecutionContextView.view(new InMemoryExecutionContext()).setPomCache(failOnFailureAccess)), + buildGradle( + """ + plugins { + id 'java-library' + } + + repositories { + mavenCentral() + } + + dependencies { + compileOnly 'com.google.guava:guava:29.0-jre' + runtimeOnly ('com.google.guava:guava:29.0-jre') + } + """, + """ + plugins { + id 'java-library' + } + + repositories { + mavenCentral() + } + + dependencies { + compileOnly 'com.google.guava:guava:30.1.1-jre' + runtimeOnly ('com.google.guava:guava:30.1.1-jre') + } + """ + ) + ); + } + + @Test + void dependencyInsightFindsUpdatedTransitiveAfterUpgrade() { + rewriteRun( + spec -> spec.recipes( + new UpgradeDependencyVersion("com.google.guava", "guava", "30.x", "-jre"), + new org.openrewrite.gradle.search.DependencyInsight("org.checkerframework", "checker-qual", null, null) + ), + buildGradle( + """ + plugins { + id 'java-library' + } + + repositories { + mavenCentral() + } + + dependencies { + implementation 'com.google.guava:guava:29.0-jre' + } + """, + """ + plugins { + id 'java-library' + } + + repositories { + mavenCentral() + } + + dependencies { + /*~~(org.checkerframework:checker-qual:3.8.0)~~>*/implementation 'com.google.guava:guava:30.1.1-jre' + } + """ + ) + ); + } + @Test void fromMilestoneToLatestPatch() { rewriteRun( diff --git a/rewrite-maven/src/main/java/org/openrewrite/maven/tree/ResolvedPom.java b/rewrite-maven/src/main/java/org/openrewrite/maven/tree/ResolvedPom.java index 3359dc74c53..5aef22cc805 100644 --- a/rewrite-maven/src/main/java/org/openrewrite/maven/tree/ResolvedPom.java +++ b/rewrite-maven/src/main/java/org/openrewrite/maven/tree/ResolvedPom.java @@ -996,11 +996,27 @@ private boolean isAlreadyResolved(GroupArtifactVersion groupArtifactVersion, Lis } public List resolveDependencies(Scope scope, MavenPomDownloader downloader, ExecutionContext ctx) throws MavenDownloadingExceptions { - return resolveDependencies(scope, new HashMap<>(), downloader, ctx); + return doResolveDependencies(scope, new HashMap<>(), true, downloader, ctx); } public List resolveDependencies(Scope scope, Map requirements, MavenPomDownloader downloader, ExecutionContext ctx) throws MavenDownloadingExceptions { + return doResolveDependencies(scope, requirements, true, downloader, ctx); + } + + /** + * Resolves the requested dependencies in the given scope without downloading their transitive closure. + * Each returned {@link ResolvedDependency} has an empty {@code dependencies} list. This allows callers who only + * need the direct coordinates (for example to re-resolve after a version mutation) to avoid the cost of + * transitive POM downloads. + */ + public List resolveDirectDependencies(Scope scope, MavenPomDownloader downloader, ExecutionContext ctx) throws MavenDownloadingExceptions { + return doResolveDependencies(scope, new HashMap<>(), false, downloader, ctx); + } + + private List doResolveDependencies(Scope scope, Map requirements, + boolean resolveTransitives, + MavenPomDownloader downloader, ExecutionContext ctx) throws MavenDownloadingExceptions { List dependencies = new ArrayList<>(); Map rootDependencies = new LinkedHashMap<>(); @@ -1066,7 +1082,7 @@ public List resolveDependencies(Scope scope, Map resolveDependencies(Scope scope, Map Date: Fri, 17 Apr 2026 18:50:46 -0700 Subject: [PATCH 2/2] Minimize the eager resolution of transitive dependencies when upgrading dependency versions. --- .../main/java/org/openrewrite/gradle/ChangeDependency.java | 4 ++-- .../org/openrewrite/gradle/ChangeDependencyArtifactId.java | 2 +- .../org/openrewrite/gradle/ChangeDependencyClassifier.java | 2 +- .../java/org/openrewrite/gradle/ChangeDependencyGroupId.java | 2 +- .../java/org/openrewrite/gradle/ChangeManagedDependency.java | 2 +- .../main/java/org/openrewrite/gradle/RemoveDependency.java | 2 +- .../openrewrite/gradle/RemoveRedundantDependencyVersions.java | 2 +- 7 files changed, 8 insertions(+), 8 deletions(-) diff --git a/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependency.java b/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependency.java index e57e25cccb6..fafdd0312a9 100644 --- a/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependency.java +++ b/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependency.java @@ -207,7 +207,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) { if (maybeJp.isPresent() && !acc.modulesWithOldDependency.containsKey(maybeJp.get())) { outer: for (GradleDependencyConfiguration config : gradleProject.getConfigurations()) { - for (ResolvedDependency resolved : config.getDirectResolved()) { + for (ResolvedDependency resolved : config.getDirectResolvedShallow()) { if (StringUtils.matchesGlob(resolved.getGroupId(), oldGroupId) && StringUtils.matchesGlob(resolved.getArtifactId(), oldArtifactId)) { acc.modulesWithOldDependency.put(maybeJp.get(), resolved); @@ -459,7 +459,7 @@ private GradleProject updateGradleModel(GradleProject gp, ExecutionContext ctx) } return requested; })); - newGdc = newGdc.withDirectResolved(ListUtils.map(gdc.getDirectResolved(), resolved -> { + newGdc = newGdc.withDirectResolved(ListUtils.map(gdc.getDirectResolvedShallow(), resolved -> { assert resolved != null; if (depMatcher.matches(resolved.getGroupId(), resolved.getArtifactId())) { resolved = updatedResolved.computeIfAbsent(resolved, r -> { diff --git a/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependencyArtifactId.java b/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependencyArtifactId.java index 9d7499d3fe3..35d7292689f 100755 --- a/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependencyArtifactId.java +++ b/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependencyArtifactId.java @@ -129,7 +129,7 @@ private GradleProject updateGradleModel(GradleProject gp) { } return requested; })); - newGdc = newGdc.withDirectResolved(ListUtils.map(gdc.getDirectResolved(), resolved -> { + newGdc = newGdc.withDirectResolved(ListUtils.map(gdc.getDirectResolvedShallow(), resolved -> { if (depMatcher.matches(resolved.getGroupId(), resolved.getArtifactId())) { return resolved.withGav(resolved.getGav().withArtifactId(newArtifactId)); } diff --git a/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependencyClassifier.java b/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependencyClassifier.java index 519b56351ea..c8fdb345796 100644 --- a/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependencyClassifier.java +++ b/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependencyClassifier.java @@ -295,7 +295,7 @@ private GradleProject updateGradleModel(GradleProject gp) { } return requested; })); - newGdc = newGdc.withDirectResolved(ListUtils.map(gdc.getDirectResolved(), resolved -> { + newGdc = newGdc.withDirectResolved(ListUtils.map(gdc.getDirectResolvedShallow(), resolved -> { if (depMatcher.matches(resolved.getGroupId(), resolved.getArtifactId()) && !Objects.equals(resolved.getClassifier(), newClassifier)) { return resolved.withClassifier(newClassifier); } diff --git a/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependencyGroupId.java b/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependencyGroupId.java index a846307bbbe..d05a93c5f01 100755 --- a/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependencyGroupId.java +++ b/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeDependencyGroupId.java @@ -129,7 +129,7 @@ private GradleProject updateGradleModel(GradleProject gp) { } return requested; })); - newGdc = newGdc.withDirectResolved(ListUtils.map(gdc.getDirectResolved(), resolved -> { + newGdc = newGdc.withDirectResolved(ListUtils.map(gdc.getDirectResolvedShallow(), resolved -> { if (depMatcher.matches(resolved.getGroupId(), resolved.getArtifactId())) { return resolved.withGav(resolved.getGav().withGroupId(newGroupId)); } diff --git a/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeManagedDependency.java b/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeManagedDependency.java index efbdbb67c55..9135a66a8a9 100644 --- a/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeManagedDependency.java +++ b/rewrite-gradle/src/main/java/org/openrewrite/gradle/ChangeManagedDependency.java @@ -189,7 +189,7 @@ private GradleProject updateGradleModel(GradleProject gp) { } return requested; })); - newGdc = newGdc.withDirectResolved(ListUtils.map(gdc.getDirectResolved(), resolved -> { + newGdc = newGdc.withDirectResolved(ListUtils.map(gdc.getDirectResolvedShallow(), resolved -> { assert resolved != null; if (depMatcher.matches(resolved.getGroupId(), resolved.getArtifactId())) { resolved = updatedResolved.computeIfAbsent(resolved, r -> { diff --git a/rewrite-gradle/src/main/java/org/openrewrite/gradle/RemoveDependency.java b/rewrite-gradle/src/main/java/org/openrewrite/gradle/RemoveDependency.java index 2e8634d514a..489a7ffaa1e 100644 --- a/rewrite-gradle/src/main/java/org/openrewrite/gradle/RemoveDependency.java +++ b/rewrite-gradle/src/main/java/org/openrewrite/gradle/RemoveDependency.java @@ -143,7 +143,7 @@ private GradleProject updateGradleModel(GradleProject gp) { } return requested; })); - newGdc = newGdc.withDirectResolved(ListUtils.map(gdc.getDirectResolved(), resolved -> { + newGdc = newGdc.withDirectResolved(ListUtils.map(gdc.getDirectResolvedShallow(), resolved -> { if (depMatcher.matches(resolved.getGroupId(), resolved.getArtifactId())) { return null; } diff --git a/rewrite-gradle/src/main/java/org/openrewrite/gradle/RemoveRedundantDependencyVersions.java b/rewrite-gradle/src/main/java/org/openrewrite/gradle/RemoveRedundantDependencyVersions.java index 96472e0ab9a..7c86f0ecbae 100644 --- a/rewrite-gradle/src/main/java/org/openrewrite/gradle/RemoveRedundantDependencyVersions.java +++ b/rewrite-gradle/src/main/java/org/openrewrite/gradle/RemoveRedundantDependencyVersions.java @@ -438,7 +438,7 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Execu private @Nullable String getSpringBootVersionFromPlugin() { GradleDependencyConfiguration gdc = gp.getBuildscript().getConfiguration("classpath"); if (gdc != null) { - for (ResolvedDependency dependency : gdc.getDirectResolved()) { + for (ResolvedDependency dependency : gdc.getDirectResolvedShallow()) { if ("org.springframework.boot.gradle.plugin".equals(dependency.getArtifactId())) { return dependency.getVersion(); }