Minimize the eager resolution of transitive dependencies when upgrading dependency versions.

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 -> {

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));
                         }

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);
                         }

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));
                         }

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 -> {

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;
                         }

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();
                                 }

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<ResolvedDependency> 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;
                     }

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;

rewrite-gradle/src/main/java/org/openrewrite/gradle/marker/GradleDependencyConfiguration.java

@@ -96,7 +96,8 @@ public class GradleDependencyConfiguration implements Serializable, Attributed {
     List<ResolvedDependency> 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<ResolvedDependency> getDirectResolved() {
         if (resolutionContext.isResolveRequired()) {
@@ -106,6 +107,18 @@ public List<ResolvedDependency> 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<ResolvedDependency> 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<MavenRepository> r
         return this;
     }
     private class LazyResolutionContext {
-        private @Getter boolean resolveRequired;
+        private boolean resolveRequired;
+        private boolean transitivesResolved;
         private @Nullable List<MavenRepository> repositories;
         private @Nullable ExecutionContext ctx;
         private @Nullable List<ResolvedDependency> 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<MavenRepository> 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<MavenRepository> 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<ResolvedDependency> 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<ResolvedDependency> getResolved() {
             if (resolved == null) {
+                resolve();
                 List<ResolvedDependency> newResolved = new ArrayList<>(getDirectResolved());
                 Map<GroupArtifact, ResolvedDependency> alreadyResolved = new HashMap<>();
                 Map<String, Version> versionCache = new HashMap<>();

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())) &&