Avoid allocating new BitmapIndexedMapNodes in HashMap#transform if possible

Author: joshlemer

library/src/scala/collection/immutable/ChampHashMap.scala

@@ -154,7 +154,11 @@ final class HashMap[K, +V] private[immutable] (private[immutable] val rootNode:
     }
   }
 
-  override def transform[W](f: (K, V) => W) = new HashMap(rootNode.transform(f), cachedJavaKeySetHashCode)
+  override def transform[W](f: (K, V) => W) = {
+    val transformed = rootNode.transform(f)
+    if (transformed eq rootNode) this.asInstanceOf[HashMap[K, W]]
+    else new HashMap(transformed, cachedJavaKeySetHashCode)
+  }
 
   override def filterImpl(pred: ((K, V)) => Boolean, flipped: Boolean): HashMap[K, V] = {
     // This method has been preemptively overridden in order to ensure that an optimizing implementation may be included
@@ -652,23 +656,41 @@ private final class BitmapIndexedMapNode[K, +V](
   }
 
   override def transform[W](f: (K, V) => W): BitmapIndexedMapNode[K, W] = {
-    val newContent = content.clone()
+    var newContent: Array[Any] = null
     val _payloadArity = payloadArity
     val _nodeArity = nodeArity
-    val newContentLength = newContent.length
+    val newContentLength = content.length
     var i = 0
     while (i < _payloadArity) {
-      newContent(TupleLength * i + 1) = f(getKey(i), getValue(i))
+      val key = getKey(i)
+      val value = getValue(i)
+      val newValue = f(key, value)
+      if (newContent eq null) {
+        if (newValue.asInstanceOf[AnyRef] ne value.asInstanceOf[AnyRef]) {
+          newContent = content.clone()
+          newContent(TupleLength * i + 1) = newValue
+        }
+      } else {
+        newContent(TupleLength * i + 1) = newValue
+      }
       i += 1
     }
 
     var j = 0
     while (j < _nodeArity) {
-      newContent(newContentLength - j - 1) = getNode(j).transform(f)
+      val node = getNode(j)
+      val newNode = node.transform(f)
+      if (newContent eq null) {
+        if (newNode ne node) {
+          newContent = content.clone()
+          newContent(newContentLength - j - 1) = newNode
+        }
+      } else
+        newContent(newContentLength - j - 1) = newNode
       j += 1
     }
-
-    new BitmapIndexedMapNode[K, W](dataMap, nodeMap, newContent, originalHashes, size)
+    if (newContent eq null) this.asInstanceOf[BitmapIndexedMapNode[K, W]]
+    else new BitmapIndexedMapNode[K, W](dataMap, nodeMap, newContent, originalHashes, size)
   }
 
   override def equals(that: Any): Boolean =
@@ -818,13 +840,18 @@ private final class HashCollisionMapNode[K, +V ](
   def foreach[U](f: ((K, V)) => U): Unit = content.foreach(f)
 
   override def transform[W](f: (K, V) => W): HashCollisionMapNode[K, W] = {
-    val newContent = Vector.newBuilder[(K, W)]
+    var newContent = Vector.newBuilder[(K, W)]
     val contentIter = content.iterator
+    // true if any values have been transformed to a different value via `f`
+    var anyChanges = false
     while(contentIter.hasNext) {
       val (k, v) = contentIter.next()
-      newContent.addOne((k, f(k, v)))
+      val newValue = f(k, v)
+      newContent.addOne((k, newValue))
+      anyChanges ||= (v.asInstanceOf[AnyRef] ne newValue.asInstanceOf[AnyRef])
     }
-    new HashCollisionMapNode(originalHash, hash, newContent.result())
+    if (anyChanges) new HashCollisionMapNode(originalHash, hash, newContent.result())
+    else this.asInstanceOf[HashCollisionMapNode[K, W]]
   }
 
   override def equals(that: Any): Boolean =