bugfix for MMap with List value usage.(also performance related)

fix the bug about using MMap when value be collection, but the old codes didn't copy the collection, thus may cause appending to a list value in a DoneMMap, thus makes infinity long value, thus makes the run slow in super multi module project.

Author: XenoAmess

maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/AbstractDependencyManager.java

@@ -151,23 +151,23 @@ public DependencyManager deriveChildManager(DependencyCollectionContext context)
             String version = artifact.getVersion();
             if (!version.isEmpty() && !managedVersions.containsKey(key)) {
                 if (managedVersions == this.managedVersions) {
-                    managedVersions = MMap.copy(this.managedVersions);
+                    managedVersions = MMap.append(this.managedVersions);
                 }
                 managedVersions.put(key, new Holder<>(depth, version));
             }
 
             String scope = managedDependency.getScope();
             if (!scope.isEmpty() && !managedScopes.containsKey(key)) {
                 if (managedScopes == this.managedScopes) {
-                    managedScopes = MMap.copy(this.managedScopes);
+                    managedScopes = MMap.append(this.managedScopes);
                 }
                 managedScopes.put(key, new Holder<>(depth, scope));
             }
 
             Boolean optional = managedDependency.getOptional();
             if (optional != null && !managedOptionals.containsKey(key)) {
                 if (managedOptionals == this.managedOptionals) {
-                    managedOptionals = MMap.copy(this.managedOptionals);
+                    managedOptionals = MMap.append(this.managedOptionals);
                 }
                 managedOptionals.put(key, new Holder<>(depth, optional));
             }
@@ -177,15 +177,15 @@ public DependencyManager deriveChildManager(DependencyCollectionContext context)
                     : systemDependencyScope.getSystemPath(managedDependency.getArtifact());
             if (localPath != null && !managedLocalPaths.containsKey(key)) {
                 if (managedLocalPaths == this.managedLocalPaths) {
-                    managedLocalPaths = MMap.copy(this.managedLocalPaths);
+                    managedLocalPaths = MMap.append(this.managedLocalPaths);
                 }
                 managedLocalPaths.put(key, new Holder<>(depth, localPath));
             }
 
             Collection<Exclusion> exclusions = managedDependency.getExclusions();
             if (!exclusions.isEmpty()) {
                 if (managedExclusions == this.managedExclusions) {
-                    managedExclusions = MMap.copy(this.managedExclusions);
+                    managedExclusions = MMap.copyWithListValue(this.managedExclusions);
                 }
                 Collection<Holder<Collection<Exclusion>>> managed = managedExclusions.get(key);
                 if (managed == null) {

maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/MMap.java

@@ -18,7 +18,11 @@
  */
 package org.eclipse.aether.util.graph.manager;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
 
 /**
  * Warning: this is a special map-like construct that suits only and should be used only in this package!
@@ -47,6 +51,18 @@ public static <K, V> MMap<K, V> copy(MMap<K, V> orig) {
         return new MMap<>(new HashMap<>(orig.delegate));
     }
 
+    public static <K, V> MMap<K, Collection<V>> copyWithListValue(MMap<K, Collection<V>> orig) {
+        HashMap<K, Collection<V>> newMap = new HashMap<>((int) Math.ceil(orig.size() / 0.75D));
+        for (Map.Entry<K, Collection<V>> entry : orig.delegate.entrySet()) {
+            newMap.put(entry.getKey(), entry.getValue() == null ? null : new ArrayList<>(entry.getValue()));
+        }
+        return new MMap<>(newMap);
+    }
+
+    public static <K, V> MMap<K, V> append(MMap<K, V> orig) {
+        return new AppendMMap<>(orig);
+    }
+
     protected final HashMap<K, V> delegate;
 
     private MMap(HashMap<K, V> delegate) {
@@ -69,6 +85,10 @@ public MMap<K, V> done() {
         return new DoneMMap<>(delegate);
     }
 
+    public MMap<K, V> append() {
+        return new AppendMMap<>(this);
+    }
+
     @Override
     public int hashCode() {
         throw new IllegalStateException("MMap is not done yet");
@@ -79,12 +99,20 @@ public boolean equals(Object o) {
         throw new IllegalStateException("MMap is not done yet");
     }
 
+    public int size() {
+        return delegate.size();
+    }
+
     private static class DoneMMap<K, V> extends MMap<K, V> {
-        private final int hashCode;
+        volatile long hashCode = Long.MAX_VALUE;
 
         private DoneMMap(HashMap<K, V> delegate) {
             super(delegate);
-            this.hashCode = delegate.hashCode();
+        }
+
+        private DoneMMap(HashMap<K, V> delegate, long hashCode) {
+            super(delegate);
+            this.hashCode = hashCode;
         }
 
         @Override
@@ -99,7 +127,12 @@ public MMap<K, V> done() {
 
         @Override
         public int hashCode() {
-            return hashCode;
+            if (this.hashCode != Long.MAX_VALUE) {
+                return (int) hashCode;
+            }
+            int result = delegate.hashCode();
+            this.hashCode = result;
+            return result;
         }
 
         @Override
@@ -111,4 +144,35 @@ public boolean equals(Object o) {
             return delegate.equals(other.delegate);
         }
     }
+
+    private static class AppendMMap<K, V> extends DoneMMap<K, V> {
+
+        AppendMMap(MMap<K, V> orig) {
+            super(new HashMap<>(orig.delegate));
+            if (orig instanceof DoneMMap) {
+                this.hashCode = ((DoneMMap<K, V>) orig).hashCode;
+            } else {
+                this.hashCode = Long.MAX_VALUE;
+            }
+        }
+
+        @Override
+        public V put(K key, V value) {
+            boolean ifPresent = delegate.containsKey(key);
+            V originalValue = delegate.put(key, value);
+            if (hashCode != Long.MAX_VALUE) {
+                int keyHash = Objects.hashCode(key);
+                if (ifPresent) {
+                    hashCode -= keyHash ^ Objects.hashCode(originalValue);
+                }
+                hashCode += keyHash ^ Objects.hashCode(value);
+            }
+            return originalValue;
+        }
+
+        @Override
+        public MMap<K, V> done() {
+            return new DoneMMap<>(delegate, hashCode);
+        }
+    }
 }