You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by gn...@apache.org on 2026/09/04 11:37:59 UTC

(maven) branch master updated: Optimize computeLocations() and simplify ModelObjectPool location handling (#13031)

This is an automated email from the ASF dual-hosted git repository.

gnodet pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven.git


The following commit(s) were added to refs/heads/master by this push:
     new cfbbe07b36 Optimize computeLocations() and simplify ModelObjectPool location handling (#13031)
cfbbe07b36 is described below

commit cfbbe07b362c333469cfd712af2c33bb822d5b26
Author: Guillaume Nodet <gn...@gmail.com>
AuthorDate: Fri Sep 4 13:37:52 2026 +0200

    Optimize computeLocations() and simplify ModelObjectPool location handling (#13031)
    
    Two targeted optimizations in the model building pipeline:
    
    1. computeLocations(): replace Stream.concat().collect(toUnmodifiableMap)
       with HashMap.putAll() + Map.copyOf(). Also return oldlocs directly
       when newlocs is empty (avoids unnecessary Map.copyOf since base
       locations are already immutable). Add getLocations() accessor for
       direct map access.
    
    2. ModelObjectPool.PoolKey: the original code used getLocationKeys() +
       getLocation(key) to iterate locations because getLocations() did not
       exist. Add getLocations() to the model and use Objects.equals() on the
       map directly, replacing both the per-key iteration in locationsEqual()
       and the separate locationsHashCode() helper. Remove redundant
       getLocationKeys() equality check (subsumed by map equality).
---
 .../maven/impl/model/DefaultModelObjectPool.java   | 38 ++--------------------
 src/mdo/model.vm                                   | 19 ++++++++---
 2 files changed, 17 insertions(+), 40 deletions(-)

diff --git a/impl/maven-impl/src/main/java/org/apache/maven/impl/model/DefaultModelObjectPool.java b/impl/maven-impl/src/main/java/org/apache/maven/impl/model/DefaultModelObjectPool.java
index 6295ae92f3..a156822065 100644
--- a/impl/maven-impl/src/main/java/org/apache/maven/impl/model/DefaultModelObjectPool.java
+++ b/impl/maven-impl/src/main/java/org/apache/maven/impl/model/DefaultModelObjectPool.java
@@ -253,31 +253,10 @@ private static boolean dependenciesEqual(
                     && Objects.equals(dep1.getSystemPath(), dep2.getSystemPath())
                     && Objects.equals(dep1.getExclusions(), dep2.getExclusions())
                     && Objects.equals(dep1.getOptional(), dep2.getOptional())
-                    && Objects.equals(dep1.getLocationKeys(), dep2.getLocationKeys())
-                    && locationsEqual(dep1, dep2)
+                    && Objects.equals(dep1.getLocations(), dep2.getLocations())
                     && Objects.equals(dep1.getImportedFrom(), dep2.getImportedFrom());
         }
 
-        /**
-         * Compare locations maps for two dependencies.
-         */
-        private static boolean locationsEqual(
-                org.apache.maven.api.model.Dependency dep1, org.apache.maven.api.model.Dependency dep2) {
-            var keys1 = dep1.getLocationKeys();
-            var keys2 = dep2.getLocationKeys();
-
-            if (!Objects.equals(keys1, keys2)) {
-                return false;
-            }
-
-            for (Object key : keys1) {
-                if (!Objects.equals(dep1.getLocation(key), dep2.getLocation(key))) {
-                    return false;
-                }
-            }
-            return true;
-        }
-
         /**
          * Custom hash code computation for different object types.
          */
@@ -303,23 +282,10 @@ private static int dependencyHashCode(org.apache.maven.api.model.Dependency dep)
             h = 31 * h + Objects.hashCode(dep.getSystemPath());
             h = 31 * h + Objects.hashCode(dep.getExclusions());
             h = 31 * h + Objects.hashCode(dep.getOptional());
-            h = 31 * h + Objects.hashCode(dep.getLocationKeys());
-            h = 31 * h + locationsHashCode(dep);
+            h = 31 * h + Objects.hashCode(dep.getLocations());
             h = 31 * h + Objects.hashCode(dep.getImportedFrom());
             return h;
         }
-
-        /**
-         * Compute hash code for locations map.
-         */
-        private static int locationsHashCode(org.apache.maven.api.model.Dependency dep) {
-            int hash = 1;
-            for (Object key : dep.getLocationKeys()) {
-                hash = 31 * hash + Objects.hashCode(key);
-                hash = 31 * hash + Objects.hashCode(dep.getLocation(key));
-            }
-            return hash;
-        }
     }
 
     /**
diff --git a/src/mdo/model.vm b/src/mdo/model.vm
index 481ee0b489..b048860b77 100644
--- a/src/mdo/model.vm
+++ b/src/mdo/model.vm
@@ -264,6 +264,15 @@ public class ${class.name}
         return locations.keySet().stream();
     }
 
+    /**
+     * Gets the locations map directly for bulk comparison and hashing.
+     *
+     * @return an unmodifiable map of locations, never {@code null}
+     */
+    public Map<Object, InputLocation> getLocations() {
+        return locations;
+    }
+
     /**
      * Gets the input location that caused this model to be read.
      */
@@ -518,14 +527,16 @@ public class ${class.name}
             Map<Object, InputLocation> newlocs = locations != null ? locations : Map.of();
             Map<Object, InputLocation> oldlocs = base != null ? base.locations : Map.of();
             if (newlocs.isEmpty()) {
-                return Map.copyOf(oldlocs);
+                return oldlocs;
             }
             if (oldlocs.isEmpty()) {
                 return Map.copyOf(newlocs);
             }
-            return Stream.concat(newlocs.entrySet().stream(), oldlocs.entrySet().stream())
-                    // Keep value from newlocs in case of duplicates
-                    .collect(Collectors.toUnmodifiableMap(Map.Entry::getKey, Map.Entry::getValue, (v1, v2) -> v1));
+            // Use HashMap.putAll instead of Stream.concat().collect() to avoid
+            // Stream allocation and intermediate Map.Entry iteration overhead
+            HashMap<Object, InputLocation> merged = new HashMap<>(oldlocs);
+            merged.putAll(newlocs); // newlocs entries override oldlocs (same semantics as before)
+            return Map.copyOf(merged);
         }
     #end
     }