Merge pull request scala/scala#8707 from rorygraves/mike/2.12.x_quick_hasForEachEntry

Add HasForeachEntry to support optimizations to avoid `Tuple2` allocations.

Author: retronym

library/src/scala/collection/immutable/HasForeachEntry.scala

@@ -0,0 +1,17 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.collection.immutable
+
+private[immutable] trait HasForeachEntry[A, +B] {
+  private[immutable] def foreachEntry[U](f: (A, B) => U): Unit
+}

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

@@ -44,6 +44,7 @@ sealed class HashMap[A, +B] extends AbstractMap[A, B]
                         with MapLike[A, B, HashMap[A, B]]
                         with Serializable
                         with CustomParallelizable[(A, B), ParHashMap[A, B]]
+                        with HasForeachEntry[A, B]
 {
   import HashMap.{nullToEmpty, bufferSize}
 

library/src/scala/collection/immutable/ListMap.scala

@@ -73,7 +73,8 @@ object ListMap extends ImmutableMapFactory[ListMap] {
 sealed class ListMap[A, +B] extends AbstractMap[A, B]
   with Map[A, B]
   with MapLike[A, B, ListMap[A, B]]
-  with Serializable {
+  with Serializable
+  with HasForeachEntry[A,B] {
 
   override def empty = ListMap.empty
 

library/src/scala/collection/immutable/Map.scala

@@ -99,7 +99,7 @@ object Map extends ImmutableMapFactory[Map] {
   }
 
   @SerialVersionUID(-5626373049574850357L)
-  private object EmptyMap extends AbstractMap[Any, Nothing] with Map[Any, Nothing] with Serializable {
+  private object EmptyMap extends AbstractMap[Any, Nothing] with Map[Any, Nothing] with Serializable with HasForeachEntry[Any, Nothing]{
     override def size: Int = 0
     override def apply(key: Any) = throw new NoSuchElementException("key not found: " + key)
     override def contains(key: Any) = false
@@ -110,10 +110,11 @@ object Map extends ImmutableMapFactory[Map] {
     def + [V1](kv: (Any, V1)): Map[Any, V1] = updated(kv._1, kv._2)
     def - (key: Any): Map[Any, Nothing] = this
     override def hashCode: Int = MurmurHash3.emptyMapHash
+    override private[immutable] def foreachEntry[U](f: (Any, Nothing) => U): Unit = ()
   }
 
   @SerialVersionUID(-9131943191104946031L)
-  class Map1[K, +V](key1: K, value1: V) extends AbstractMap[K, V] with Map[K, V] with Serializable {
+  class Map1[K, +V](key1: K, value1: V) extends AbstractMap[K, V] with Map[K, V] with Serializable with HasForeachEntry[K, V] {
     override def size = 1
     override def apply(key: K) = if (key == key1) value1 else throw new NoSuchElementException("key not found: " + key)
     override def contains(key: K) = key == key1
@@ -148,10 +149,13 @@ object Map extends ImmutableMapFactory[Map] {
       h = MurmurHash3.mixLast(h, c)
       MurmurHash3.finalizeHash(h, N)
     }
+    override private[immutable] def foreachEntry[U](f: (K, V) => U): Unit = {
+      f(key1, value1)
+    }
   }
 
   @SerialVersionUID(-85684685400398742L)
-  class Map2[K, +V](key1: K, value1: V, key2: K, value2: V) extends AbstractMap[K, V] with Map[K, V] with Serializable {
+  class Map2[K, +V](key1: K, value1: V, key2: K, value2: V) extends AbstractMap[K, V] with Map[K, V] with Serializable with HasForeachEntry[K, V] {
     override def size = 2
     override def apply(key: K) =
       if (key == key1) value1
@@ -201,10 +205,14 @@ object Map extends ImmutableMapFactory[Map] {
       h = MurmurHash3.mixLast(h, c)
       MurmurHash3.finalizeHash(h, N)
     }
+    override private[immutable] def foreachEntry[U](f: (K, V) => U): Unit = {
+      f(key1, value1)
+      f(key2, value2)
+    }
   }
 
   @SerialVersionUID(-6400718707310517135L)
-  class Map3[K, +V](key1: K, value1: V, key2: K, value2: V, key3: K, value3: V) extends AbstractMap[K, V] with Map[K, V] with Serializable {
+  class Map3[K, +V](key1: K, value1: V, key2: K, value2: V, key3: K, value3: V) extends AbstractMap[K, V] with Map[K, V] with Serializable with HasForeachEntry[K, V] {
     override def size = 3
     override def apply(key: K) =
       if (key == key1) value1
@@ -264,10 +272,15 @@ object Map extends ImmutableMapFactory[Map] {
       h = MurmurHash3.mixLast(h, c)
       MurmurHash3.finalizeHash(h, N)
     }
+    override private[immutable] def foreachEntry[U](f: (K, V) => U): Unit = {
+      f(key1, value1)
+      f(key2, value2)
+      f(key3, value3)
+    }
   }
 
   @SerialVersionUID(-7992135791595275193L)
-  class Map4[K, +V](key1: K, value1: V, key2: K, value2: V, key3: K, value3: V, key4: K, value4: V) extends AbstractMap[K, V] with Map[K, V] with Serializable {
+  class Map4[K, +V](key1: K, value1: V, key2: K, value2: V, key3: K, value3: V, key4: K, value4: V) extends AbstractMap[K, V] with Map[K, V] with Serializable with HasForeachEntry[K, V] {
     override def size = 4
     override def apply(key: K) =
       if (key == key1) value1
@@ -337,6 +350,12 @@ object Map extends ImmutableMapFactory[Map] {
       h = MurmurHash3.mixLast(h, c)
       MurmurHash3.finalizeHash(h, N)
     }
+    override private[immutable] def foreachEntry[U](f: (K, V) => U): Unit = {
+      f(key1, value1)
+      f(key2, value2)
+      f(key3, value3)
+      f(key4, value4)
+    }
   }
   private [immutable] final class HashCodeAccumulator extends scala.runtime.AbstractFunction2[Any, Any, Unit] {
     import scala.util.hashing.MurmurHash3

library/src/scala/collection/immutable/TreeMap.scala

@@ -52,7 +52,8 @@ final class TreeMap[A, +B] private (tree: RB.Tree[A, B])(implicit val ordering:
   extends SortedMap[A, B]
      with SortedMapLike[A, B, TreeMap[A, B]]
      with MapLike[A, B, TreeMap[A, B]]
-     with Serializable {
+     with Serializable
+     with HasForeachEntry[A, B] {
 
   override protected[this] def newBuilder : Builder[(A, B), TreeMap[A, B]] =
     TreeMap.newBuilder[A, B]
@@ -205,6 +206,8 @@ final class TreeMap[A, +B] private (tree: RB.Tree[A, B])(implicit val ordering:
 
   override def foreach[U](f : ((A,B)) => U) = RB.foreach(tree, f)
 
+  override private[immutable] def foreachEntry[U](f: (A, B) => U): Unit = RB.foreachEntry(tree, f)
+
   override def hashCode(): Int = {
     if (isEmpty) {
       MurmurHash3.emptyMapHash