[MNG-8696] Hide the cache from DefaultDependencyResolverResult constructor

impl/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultProjectBuilder.java

@@ -189,8 +189,7 @@ public Severity getSeverity() {
                 public Optional<DependencyResolverResult> getDependencyResolverResult() {
                     return Optional.ofNullable(res.getDependencyResolutionResult())
                             .map(r -> new DefaultDependencyResolverResult(
-                                    // TODO: this should not be null
-                                    null, null, r.getCollectionErrors(), session.getNode(r.getDependencyGraph()), 0));
+                                    null, r.getCollectionErrors(), session.getNode(r.getDependencyGraph()), 0));
                 }
             };
         } catch (ProjectBuildingException e) {

impl/maven-impl/src/main/java/org/apache/maven/impl/DefaultDependencyResolver.java

@@ -67,6 +67,21 @@
 @Named
 @Singleton
 public class DefaultDependencyResolver implements DependencyResolver {
+    /**
+     * Cache of information about the modules contained in a path element.
+     * This cache is created when first needed. It may be never created.
+     *
+     * <p><b>TODO:</b> This field should not be in this class, because the cache should be global to the session.
+     * This field exists here only temporarily, until we clarified where to store session-wide caches.</p>
+     *
+     * @see moduleCache()
+     */
+    private PathModularizationCache moduleCache;
+
+    /**
+     * Creates an initially empty resolver.
+     */
+    public DefaultDependencyResolver() {}
 
     @Nonnull
     @Override
@@ -126,7 +141,11 @@ public DependencyResolverResult collect(@Nonnull DependencyResolverRequest reque
                 final CollectResult result =
                         session.getRepositorySystem().collectDependencies(systemSession, collectRequest);
                 return new DefaultDependencyResolverResult(
-                        null, null, result.getExceptions(), session.getNode(result.getRoot(), request.getVerbose()), 0);
+                        null,
+                        moduleCache(),
+                        result.getExceptions(),
+                        session.getNode(result.getRoot(), request.getVerbose()),
+                        0);
             } catch (DependencyCollectionException e) {
                 throw new DependencyResolverException("Unable to collect dependencies", e);
             }
@@ -191,18 +210,14 @@ public DependencyResolverResult resolve(DependencyResolverRequest request)
                         .map(Artifact::toCoordinates)
                         .collect(Collectors.toList());
                 Predicate<PathType> filter = request.getPathTypeFilter();
+                DefaultDependencyResolverResult resolverResult = new DefaultDependencyResolverResult(
+                        null, moduleCache(), collectorResult.getExceptions(), collectorResult.getRoot(), nodes.size());
                 if (request.getRequestType() == DependencyResolverRequest.RequestType.FLATTEN) {
-                    DefaultDependencyResolverResult flattenResult = new DefaultDependencyResolverResult(
-                            null, null, collectorResult.getExceptions(), collectorResult.getRoot(), nodes.size());
                     for (Node node : nodes) {
-                        flattenResult.addNode(node);
+                        resolverResult.addNode(node);
                     }
-                    result = flattenResult;
+                    result = resolverResult;
                 } else {
-                    PathModularizationCache cache =
-                            new PathModularizationCache(); // TODO: should be project-wide cache.
-                    DefaultDependencyResolverResult resolverResult = new DefaultDependencyResolverResult(
-                            null, cache, collectorResult.getExceptions(), collectorResult.getRoot(), nodes.size());
                     ArtifactResolverResult artifactResolverResult =
                             session.getService(ArtifactResolver.class).resolve(session, coordinates, repositories);
                     for (Node node : nodes) {
@@ -226,6 +241,19 @@ public DependencyResolverResult resolve(DependencyResolverRequest request)
         }
     }
 
+    /**
+     * {@return the cache of information about the modules contained in a path element}.
+     *
+     * <p><b>TODO:</b> This method should not be in this class, because the cache should be global to the session.
+     * This method exists here only temporarily, until we clarified where to store session-wide caches.</p>
+     */
+    private PathModularizationCache moduleCache() {
+        if (moduleCache == null) {
+            moduleCache = new PathModularizationCache();
+        }
+        return moduleCache;
+    }
+
     private static DependencyResolverException cannotReadModuleInfo(final Path path, final IOException cause) {
         return new DependencyResolverException("Cannot read module information of " + path, cause);
     }

impl/maven-impl/src/main/java/org/apache/maven/impl/DefaultDependencyResolverResult.java

@@ -27,6 +27,7 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Predicate;
@@ -56,6 +57,7 @@ public class DefaultDependencyResolverResult implements DependencyResolverResult
      * The corresponding request.
      */
     private final DependencyResolverRequest request;
+
     /**
      * The exceptions that occurred while building the dependency graph.
      */
@@ -97,6 +99,24 @@ public class DefaultDependencyResolverResult implements DependencyResolverResult
      */
     private final PathModularizationCache cache;
 
+    /**
+     * Creates an initially empty result with a temporary cache.
+     * Callers should add path elements by calls to {@link #addDependency(Node, Dependency, Predicate, Path)}.
+     *
+     * <p><b>WARNING: this constructor may be removed in a future Maven release.</b>
+     * The reason is because {@code DefaultDependencyResolverResult} needs a cache, which should
+     * preferably by session-wide. But we have not yet clarified how such caches should be managed.</p>
+     *
+     * @param request the corresponding request
+     * @param exceptions the exceptions that occurred while building the dependency graph
+     * @param root the root node of the dependency graph
+     * @param count estimated number of dependencies
+     */
+    public DefaultDependencyResolverResult(
+            DependencyResolverRequest request, List<Exception> exceptions, Node root, int count) {
+        this(request, new PathModularizationCache(), exceptions, root, count);
+    }
+
     /**
      * Creates an initially empty result. Callers should add path elements by calls
      * to {@link #addDependency(Node, Dependency, Predicate, Path)}.
@@ -107,14 +127,14 @@ public class DefaultDependencyResolverResult implements DependencyResolverResult
      * @param root the root node of the dependency graph
      * @param count estimated number of dependencies
      */
-    public DefaultDependencyResolverResult(
+    DefaultDependencyResolverResult(
             DependencyResolverRequest request,
             PathModularizationCache cache,
             List<Exception> exceptions,
             Node root,
             int count) {
         this.request = request;
-        this.cache = cache;
+        this.cache = Objects.requireNonNull(cache);
         this.exceptions = exceptions;
         this.root = root;
         nodes = new ArrayList<>(count);