Merge pull request scala/scala#10235 from liang3zy22/2ndoptimizationlhslhm

continuous optimization for LinkedHashMap/LinkedHashSet related codes

Author: lrytz

library/src/scala/collection/immutable/HashMap.scala

@@ -190,6 +190,27 @@ final class HashMap[K, +V] private[immutable] (private[immutable] val rootNode:
         }
       }
       this
+    case lhm: mutable.LinkedHashMap[K @unchecked, V @unchecked] =>
+      val iter = lhm.entryIterator
+      var current = rootNode
+      while (iter.hasNext) {
+        val next = iter.next()
+        val originalHash = lhm.unimproveHash(next.hash)
+        val improved = improve(originalHash)
+        current = current.updated(next.key, next.value, originalHash, improved, 0, replaceValue = true)
+
+        if (current ne rootNode) {
+          var shallowlyMutableNodeMap = Node.bitposFrom(Node.maskFrom(improved, 0))
+
+          while (iter.hasNext) {
+            val next = iter.next()
+            val originalHash = lhm.unimproveHash(next.hash)
+            shallowlyMutableNodeMap = current.updateWithShallowMutations(next.key, next.value, originalHash, improve(originalHash), 0, shallowlyMutableNodeMap)
+          }
+          return new HashMap(current)
+        }
+      }
+      this
     case _ =>
       class accum extends AbstractFunction2[K, V1, Unit] with Function1[(K, V1), Unit] {
         var changed = false
@@ -397,6 +418,24 @@ final class HashMap[K, +V] private[immutable] (private[immutable] val rootNode:
             }
             newHashMapOrThis(curr)
           }
+        case lhashSet: collection.mutable.LinkedHashSet[K] =>
+          if (lhashSet.isEmpty) {
+            this
+          } else {
+            val iter = lhashSet.entryIterator
+            var curr = rootNode
+
+            while (iter.hasNext) {
+              val next = iter.next()
+              val originalHash = lhashSet.unimproveHash(next.hash)
+              val improved = improve(originalHash)
+              curr = curr.removed(next.key, originalHash, improved, 0)
+              if (curr.size == 0) {
+                return HashMap.empty
+              }
+            }
+            newHashMapOrThis(curr)
+          }
         case _ =>
           val iter = keys.iterator
           var curr = rootNode
@@ -2353,6 +2392,14 @@ private[immutable] final class HashMapBuilder[K, V] extends ReusableBuilder[(K,
           val hash = improve(originalHash)
           update(rootNode, next.key, next.value, originalHash, hash, 0)
         }
+      case lhm: collection.mutable.LinkedHashMap[K, V] =>
+        val iter = lhm.entryIterator
+        while (iter.hasNext) {
+          val next = iter.next()
+          val originalHash = lhm.unimproveHash(next.hash)
+          val hash = improve(originalHash)
+          update(rootNode, next.key, next.value, originalHash, hash, 0)
+        }
       case thatMap: Map[K, V] =>
         thatMap.foreachEntry((key, value) => addOne(key, value))
       case other =>

library/src/scala/collection/immutable/HashSet.scala

@@ -121,6 +121,27 @@ final class HashSet[A] private[immutable](private[immutable] val rootNode: Bitma
           }
         }
         this
+      case lhs: collection.mutable.LinkedHashSet[A] =>
+        val iter = lhs.entryIterator
+        var current = rootNode
+        while (iter.hasNext) {
+          val next = iter.next()
+          val originalHash = lhs.unimproveHash(next.hash)
+          val improved = improve(originalHash)
+          current = current.updated(next.key, originalHash, improved, 0)
+
+          if (current ne rootNode) {
+            var shallowlyMutableNodeMap = Node.bitposFrom(Node.maskFrom(improved, 0))
+            while (iter.hasNext) {
+              val next = iter.next()
+              val originalHash = lhs.unimproveHash(next.hash)
+              val improved = improve(originalHash)
+              shallowlyMutableNodeMap = current.updateWithShallowMutations(next.key, originalHash, improved, 0, shallowlyMutableNodeMap)
+            }
+            return new HashSet(current)
+          }
+        }
+        this
       case _ =>
         val iter = that.iterator
         var current = rootNode

library/src/scala/collection/mutable/HashMap.scala

@@ -108,6 +108,13 @@ class HashMap[K, V](initialCapacity: Int, loadFactor: Double)
           put0(next.key, next.value, next.hash, getOld = false)
         }
         this
+      case lhm: mutable.LinkedHashMap[K, V] =>
+        val iter = lhm.entryIterator
+        while (iter.hasNext) {
+          val entry = iter.next()
+          put0(entry.key, entry.value, entry.hash, getOld = false)
+        }
+        this
       case thatMap: Map[K, V] =>
         thatMap.foreachEntry { (key: K, value: V) =>
           put0(key, value, improveHash(key.##), getOld = false)
@@ -195,6 +202,14 @@ class HashMap[K, V](initialCapacity: Int, loadFactor: Double)
           if (size == 0) return this
         }
         this
+      case lhs: mutable.LinkedHashSet[K] =>
+        val iter = lhs.entryIterator
+        while (iter.hasNext) {
+          val next = iter.next()
+          remove0(next.key, next.hash)
+          if (size == 0) return this
+        }
+        this
       case _ => super.subtractAll(xs)
     }
   }

library/src/scala/collection/mutable/HashSet.scala

@@ -93,11 +93,18 @@ final class HashSet[A](initialCapacity: Int, loadFactor: Double)
   override def addAll(xs: IterableOnce[A]): this.type = {
     sizeHint(xs.knownSize)
     xs match {
-      case hm: immutable.HashSet[A] =>
-        hm.foreachWithHash((k, h) => addElem(k, improveHash(h)))
+      case hs: immutable.HashSet[A] =>
+        hs.foreachWithHash((k, h) => addElem(k, improveHash(h)))
+        this
+      case hs: mutable.HashSet[A] =>
+        val iter = hs.nodeIterator
+        while (iter.hasNext) {
+          val next = iter.next()
+          addElem(next.key, next.hash)
+        }
         this
-      case hm: mutable.HashSet[A] =>
-        val iter = hm.nodeIterator
+      case lhs: mutable.LinkedHashSet[A] =>
+        val iter = lhs.entryIterator
         while (iter.hasNext) {
           val next = iter.next()
           addElem(next.key, next.hash)
@@ -127,6 +134,14 @@ final class HashSet[A](initialCapacity: Int, loadFactor: Double)
           if (size == 0) return this
         }
         this
+      case lhs: mutable.LinkedHashSet[A] =>
+        val iter = lhs.entryIterator
+        while (iter.hasNext) {
+          val next = iter.next()
+          remove(next.key, next.hash)
+          if (size == 0) return this
+        }
+        this
       case _ => super.subtractAll(xs)
     }
   }