Dont create tuples when generating hashcodes for immutable maps

  - add allocation tests for immutable maps
  - add pre-calculated values for empty maps, with test

For immutable maps the max allocation is 32 bytes

Author: mkeskells

src/library/mima-filters/2.12.0.forwards.excludes

@@ -45,4 +45,15 @@ ProblemFilters.exclude[MissingFieldProblem]("scala.collection.immutable.Map#Map1
 ProblemFilters.exclude[MissingFieldProblem]("scala.collection.immutable.Map#Map2.serialVersionUID")
 ProblemFilters.exclude[MissingFieldProblem]("scala.collection.immutable.Map#Map3.serialVersionUID")
 ProblemFilters.exclude[MissingFieldProblem]("scala.collection.immutable.Map#Map4.serialVersionUID")
-ProblemFilters.exclude[DirectAbstractMethodProblem]("scala.collection.GenTraversableOnce.toList")
+ProblemFilters.exclude[DirectAbstractMethodProblem]("scala.collection.GenTraversableOnce.toList")
+
+
+ProblemFilters.exclude[DirectMissingMethodProblem]("scala.collection.immutable.HashMap.foreachEntry")
+ProblemFilters.exclude[MissingClassProblem]("scala.collection.immutable.Map$HashCodeAccumulator")
+ProblemFilters.exclude[DirectMissingMethodProblem]("scala.collection.immutable.RedBlackTree.foreachEntry")
+ProblemFilters.exclude[DirectMissingMethodProblem]("scala.collection.immutable.HashMap#HashTrieMap.foreachEntry")
+ProblemFilters.exclude[DirectMissingMethodProblem]("scala.collection.immutable.ListMap.foreachEntry")
+ProblemFilters.exclude[DirectMissingMethodProblem]("scala.collection.immutable.HashMap#HashMap1.foreachEntry")
+ProblemFilters.exclude[DirectMissingMethodProblem]("scala.collection.immutable.HashMap#HashMapCollision1.foreachEntry")
+ProblemFilters.exclude[DirectMissingMethodProblem]("scala.util.hashing.MurmurHash3.product2Hash")
+ProblemFilters.exclude[DirectMissingMethodProblem]("scala.util.hashing.MurmurHash3.emptyMapHash")

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

@@ -15,8 +15,9 @@ package collection
 package immutable
 
 import generic._
-import scala.annotation.unchecked.{ uncheckedVariance=> uV }
+import scala.annotation.unchecked.{uncheckedVariance => uV}
 import parallel.immutable.ParHashMap
+import scala.util.hashing.MurmurHash3
 
 /** This class implements immutable maps using a hash trie.
  *
@@ -51,6 +52,15 @@ sealed class HashMap[A, +B] extends AbstractMap[A, B]
   def iterator: Iterator[(A,B)] = Iterator.empty
 
   override def foreach[U](f: ((A, B)) => U): Unit = ()
+  private[immutable] def foreachEntry[U](f: (A, B) => U): Unit = ()
+  override def hashCode(): Int = {
+    if (isEmpty) MurmurHash3.emptyMapHash
+    else {
+      val hasher = new Map.HashCodeAccumulator()
+      foreachEntry(hasher)
+      hasher.finalizeHash
+    }
+  }
 
   def get(key: A): Option[B] =
     get0(key, computeHash(key), 0)
@@ -232,6 +242,7 @@ object HashMap extends ImmutableMapFactory[HashMap] with BitOperations.Int {
 
     override def iterator: Iterator[(A,B)] = Iterator(ensurePair)
     override def foreach[U](f: ((A, B)) => U): Unit = f(ensurePair)
+    override private[immutable] def foreachEntry[U](f: (A, B) => U): Unit = f(key, value)
     // this method may be called multiple times in a multithreaded environment, but that's ok
     private[HashMap] def ensurePair: (A,B) = if (kv ne null) kv else { kv = (key, value); kv }
     protected override def merge0[B1 >: B](that: HashMap[A, B1], level: Int, merger: Merger[A, B1]): HashMap[A, B1] = {
@@ -293,6 +304,7 @@ object HashMap extends ImmutableMapFactory[HashMap] with BitOperations.Int {
 
     override def iterator: Iterator[(A,B)] = kvs.iterator
     override def foreach[U](f: ((A, B)) => U): Unit = kvs.foreach(f)
+    override private[immutable] def foreachEntry[U](f: (A, B) => U): Unit = kvs.foreachEntry(f)
     override def split: Seq[HashMap[A, B]] = {
       val (x, y) = kvs.splitAt(kvs.size / 2)
       def newhm(lm: ListMap[A, B @uV]) = {
@@ -469,6 +481,13 @@ object HashMap extends ImmutableMapFactory[HashMap] with BitOperations.Int {
         i += 1
       }
     }
+    override private[immutable] def foreachEntry[U](f: (A, B) => U): Unit = {
+      var i = 0
+      while (i < elems.length) {
+        elems(i).foreachEntry(f)
+        i += 1
+      }
+    }
 
     private def posOf(n: Int, bm: Int) = {
       var left = n

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

@@ -16,6 +16,7 @@ package immutable
 
 import generic._
 import scala.annotation.tailrec
+import scala.util.hashing.MurmurHash3
 
 /**
   * $factoryInfo
@@ -80,6 +81,24 @@ sealed class ListMap[A, +B] extends AbstractMap[A, B]
 
   def get(key: A): Option[B] = None
 
+  private[immutable] def foreachEntry[U](f: (A, B) => U): Unit = {
+    var current = this
+    while (!current.isEmpty) {
+      f(current.key, current.value)
+      current = current.next
+    }
+  }
+
+  override def hashCode(): Int = {
+    if (isEmpty) {
+      MurmurHash3.emptyMapHash
+    } else {
+      val hasher = new Map.HashCodeAccumulator()
+      foreachEntry(hasher)
+      hasher.finalizeHash
+    }
+  }
+
   override def updated[B1 >: B](key: A, value: B1): ListMap[A, B1] = new Node[B1](key, value)
 
   def +[B1 >: B](kv: (A, B1)): ListMap[A, B1] = new Node[B1](kv._1, kv._2)

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

@@ -15,6 +15,7 @@ package collection
 package immutable
 
 import generic._
+import scala.util.hashing.MurmurHash3
 
 /**
  * A generic trait for immutable maps. Concrete classes have to provide
@@ -106,6 +107,7 @@ object Map extends ImmutableMapFactory[Map] {
     override def updated [V1] (key: Any, value: V1): Map[Any, V1] = new Map1(key, value)
     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
   }
 
   @SerialVersionUID(-9131943191104946031L)
@@ -127,6 +129,23 @@ object Map extends ImmutableMapFactory[Map] {
     override def foreach[U](f: ((K, V)) => U): Unit = {
       f((key1, value1))
     }
+    override def hashCode(): Int = {
+      import scala.util.hashing.MurmurHash3
+      var a, b = 0
+      val N = 1
+      var c = 1
+
+      var h = MurmurHash3.product2Hash(key1, value1)
+      a += h
+      b ^= h
+      if (h != 0) c *= h
+
+      h = MurmurHash3.mapSeed
+      h = MurmurHash3.mix(h, a)
+      h = MurmurHash3.mix(h, b)
+      h = MurmurHash3.mixLast(h, c)
+      MurmurHash3.finalizeHash(h, N)
+    }
   }
 
   @SerialVersionUID(-85684685400398742L)
@@ -158,6 +177,28 @@ object Map extends ImmutableMapFactory[Map] {
     override def foreach[U](f: ((K, V)) => U): Unit = {
       f((key1, value1)); f((key2, value2))
     }
+    override def hashCode(): Int = {
+      import scala.util.hashing.MurmurHash3
+      var a, b = 0
+      val N = 2
+      var c = 1
+
+      var h = MurmurHash3.product2Hash(key1, value1)
+      a += h
+      b ^= h
+      if (h != 0) c *= h
+
+      h = MurmurHash3.product2Hash(key2, value2)
+      a += h
+      b ^= h
+      if (h != 0) c *= h
+
+      h = MurmurHash3.mapSeed
+      h = MurmurHash3.mix(h, a)
+      h = MurmurHash3.mix(h, b)
+      h = MurmurHash3.mixLast(h, c)
+      MurmurHash3.finalizeHash(h, N)
+    }
   }
 
   @SerialVersionUID(-6400718707310517135L)
@@ -194,6 +235,33 @@ object Map extends ImmutableMapFactory[Map] {
     override def foreach[U](f: ((K, V)) => U): Unit = {
       f((key1, value1)); f((key2, value2)); f((key3, value3))
     }
+    override def hashCode(): Int = {
+      import scala.util.hashing.MurmurHash3
+      var a, b = 0
+      val N = 3
+      var c = 1
+
+      var h = MurmurHash3.product2Hash(key1, value1)
+      a += h
+      b ^= h
+      if (h != 0) c *= h
+
+      h = MurmurHash3.product2Hash(key2, value2)
+      a += h
+      b ^= h
+      if (h != 0) c *= h
+
+      h = MurmurHash3.product2Hash(key3, value3)
+      a += h
+      b ^= h
+      if (h != 0) c *= h
+
+      h = MurmurHash3.mapSeed
+      h = MurmurHash3.mix(h, a)
+      h = MurmurHash3.mix(h, b)
+      h = MurmurHash3.mixLast(h, c)
+      MurmurHash3.finalizeHash(h, N)
+    }
   }
 
   @SerialVersionUID(-7992135791595275193L)
@@ -235,6 +303,58 @@ object Map extends ImmutableMapFactory[Map] {
     override def foreach[U](f: ((K, V)) => U): Unit = {
       f((key1, value1)); f((key2, value2)); f((key3, value3)); f((key4, value4))
     }
+    override def hashCode(): Int = {
+      import scala.util.hashing.MurmurHash3
+      var a, b = 0
+      val N = 4
+      var c = 1
+
+      var h = MurmurHash3.product2Hash(key1, value1)
+      a += h
+      b ^= h
+      if (h != 0) c *= h
+
+      h = MurmurHash3.product2Hash(key2, value2)
+      a += h
+      b ^= h
+      if (h != 0) c *= h
+
+      h = MurmurHash3.product2Hash(key3, value3)
+      a += h
+      b ^= h
+      if (h != 0) c *= h
+
+      h = MurmurHash3.product2Hash(key4, value4)
+      a += h
+      b ^= h
+      if (h != 0) c *= h
+
+      h = MurmurHash3.mapSeed
+      h = MurmurHash3.mix(h, a)
+      h = MurmurHash3.mix(h, b)
+      h = MurmurHash3.mixLast(h, c)
+      MurmurHash3.finalizeHash(h, N)
+    }
+  }
+  private [immutable] final class HashCodeAccumulator extends scala.runtime.AbstractFunction2[Any, Any, Unit] {
+    import scala.util.hashing.MurmurHash3
+    private var a, b, n = 0
+    private var c = 1
+    def apply(key: Any, value: Any): Unit = {
+      val h = MurmurHash3.product2Hash(key, value)
+      a += h
+      b ^= h
+      if (h != 0) c *= h
+      n += 1
+    }
+
+    def finalizeHash: Int = {
+      var h = MurmurHash3.mapSeed
+      h = MurmurHash3.mix(h, a)
+      h = MurmurHash3.mix(h, b)
+      h = MurmurHash3.mixLast(h, c)
+      MurmurHash3.finalizeHash(h, n)
+    }
   }
 }
 

src/library/scala/collection/immutable/RedBlackTree.scala

@@ -95,14 +95,19 @@ object RedBlackTree {
     result
   }
 
-
   def foreach[A,B,U](tree:Tree[A,B], f:((A,B)) => U):Unit = if (tree ne null) _foreach(tree,f)
+  def foreachEntry[A,B,U](tree:Tree[A,B], f:(A,B) => U):Unit = if (tree ne null) _foreachEntry(tree,f)
 
   private[this] def _foreach[A, B, U](tree: Tree[A, B], f: ((A, B)) => U) {
     if (tree.left ne null) _foreach(tree.left, f)
     f((tree.key, tree.value))
     if (tree.right ne null) _foreach(tree.right, f)
   }
+  private[this] def _foreachEntry[A, B, U](tree: Tree[A, B], f: (A, B) => U): Unit = {
+    if (tree.left ne null) _foreachEntry(tree.left, f)
+    f(tree.key, tree.value)
+    if (tree.right ne null) _foreachEntry(tree.right, f)
+  }
 
   def foreachKey[A, U](tree:Tree[A,_], f: A => U):Unit = if (tree ne null) _foreachKey(tree,f)
 

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

@@ -17,6 +17,7 @@ package immutable
 import generic._
 import immutable.{RedBlackTree => RB}
 import mutable.Builder
+import scala.util.hashing.MurmurHash3
 
 /** $factoryInfo
  *  @define Coll immutable.TreeMap
@@ -203,4 +204,15 @@ final class TreeMap[A, +B] private (tree: RB.Tree[A, B])(implicit val ordering:
   override def isDefinedAt(key: A): Boolean = RB.contains(tree, key)
 
   override def foreach[U](f : ((A,B)) => U) = RB.foreach(tree, f)
+
+  override def hashCode(): Int = {
+    if (isEmpty) {
+      MurmurHash3.emptyMapHash
+    } else {
+      val hasher = new Map.HashCodeAccumulator()
+      RB.foreachEntry(tree, hasher)
+      hasher.finalizeHash
+    }
+  }
+
 }

src/library/scala/util/hashing/MurmurHash3.scala

@@ -52,6 +52,12 @@ private[hashing] class MurmurHash3 {
     h
   }
 
+  private[scala] def product2Hash(x: Any, y: Any, seed: Int): Int = {
+    var h = seed
+    h = mix(h, x.##)
+    h = mix(h, y.##)
+    finalizeHash(h, 2)
+  }
   /** Compute the hash of a product */
   final def productHash(x: Product, seed: Int): Int = {
     val arr = x.productArity
@@ -212,6 +218,7 @@ object MurmurHash3 extends MurmurHash3 {
   def arrayHash[@specialized T](a: Array[T]): Int  = arrayHash(a, arraySeed)
   def bytesHash(data: Array[Byte]): Int            = arrayHash(data, arraySeed)
   def orderedHash(xs: TraversableOnce[Any]): Int   = orderedHash(xs, symmetricSeed)
+  private [scala] def product2Hash(x: Any, y: Any): Int = product2Hash(x, y, productSeed)
   def productHash(x: Product): Int                 = productHash(x, productSeed)
   def stringHash(x: String): Int                   = stringHash(x, stringSeed)
   def unorderedHash(xs: TraversableOnce[Any]): Int = unorderedHash(xs, traversableSeed)
@@ -228,6 +235,7 @@ object MurmurHash3 extends MurmurHash3 {
 
   def mapHash(xs: scala.collection.Map[_, _]): Int = unorderedHash(xs, mapSeed)
   def setHash(xs: scala.collection.Set[_]): Int    = unorderedHash(xs, setSeed)
+  private[scala] val emptyMapHash = unorderedHash(Nil, mapSeed)
 
   class ArrayHashing[@specialized T] extends Hashing[Array[T]] {
     def hash(a: Array[T]) = arrayHash(a)