Merge pull request scala#7074 from szeiger/wip/rename-champ

Make CHAMP HashMap and HashSet the default

Author: SethTisue

src/library/scala/collection/Map.scala

@@ -4,7 +4,7 @@ package collection
 import scala.annotation.unchecked.uncheckedVariance
 import scala.collection.generic.DefaultSerializationProxy
 import scala.collection.mutable.StringBuilder
-import scala.language.{higherKinds, implicitConversions}
+import scala.language.higherKinds
 import scala.util.hashing.MurmurHash3
 
 /** Base Map type */

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

@@ -19,17 +19,19 @@ import scala.util.hashing.MurmurHash3
   *
   *  @author  Michael J. Steindorfer
   *  @since   2.13
-  *  @define Coll `immutable.ChampHashMap`
+  *  @define Coll `immutable.HashMap`
   *  @define coll immutable champ hash map
   */
 
-final class ChampHashMap[K, +V] private[immutable] (private val rootNode: MapNode[K, V], private val cachedJavaKeySetHashCode: Int)
+final class HashMap[K, +V] private[immutable] (private val rootNode: MapNode[K, V], private val cachedJavaKeySetHashCode: Int)
   extends AbstractMap[K, V]
-    with MapOps[K, V, ChampHashMap, ChampHashMap[K, V]]
-    with StrictOptimizedIterableOps[(K, V), Iterable, ChampHashMap[K, V]]
-    with StrictOptimizedMapOps[K, V, ChampHashMap, ChampHashMap[K, V]] {
+    with MapOps[K, V, HashMap, HashMap[K, V]]
+    with StrictOptimizedIterableOps[(K, V), Iterable, HashMap[K, V]]
+    with StrictOptimizedMapOps[K, V, HashMap, HashMap[K, V]] {
 
-  override def mapFactory: MapFactory[ChampHashMap] = ChampHashMap
+  def this() = this(MapNode.empty, 0)
+
+  override def mapFactory: MapFactory[HashMap] = HashMap
 
   override def knownSize: Int = rootNode.size
 
@@ -74,7 +76,7 @@ final class ChampHashMap[K, +V] private[immutable] (private val rootNode: MapNod
     rootNode.getOrElse(key, keyUnimprovedHash, keyHash, 0, default)
   }
 
-  def updated[V1 >: V](key: K, value: V1): ChampHashMap[K, V1] = {
+  def updated[V1 >: V](key: K, value: V1): HashMap[K, V1] = {
     val keyUnimprovedHash = key.##
     val keyHash = improve(keyUnimprovedHash)
 
@@ -83,30 +85,30 @@ final class ChampHashMap[K, +V] private[immutable] (private val rootNode: MapNod
     if (newRootNode ne rootNode) {
       val replaced = rootNode.size == newRootNode.size
       val newCachedJavaKeySetHashCode = cachedJavaKeySetHashCode + (if (replaced) 0 else keyHash)
-      ChampHashMap(newRootNode.get, newCachedJavaKeySetHashCode)
+      HashMap(newRootNode.get, newCachedJavaKeySetHashCode)
     } else
       this
   }
 
-  def remove(key: K): ChampHashMap[K, V] = {
+  def remove(key: K): HashMap[K, V] = {
     val keyUnimprovedHash = key.##
     val keyHash = improve(keyUnimprovedHash)
 
     val newRootNode = rootNode.removed(key, keyUnimprovedHash, keyHash, 0)
 
     if (newRootNode ne rootNode)
-      ChampHashMap(newRootNode, cachedJavaKeySetHashCode - keyHash)
+      HashMap(newRootNode, cachedJavaKeySetHashCode - keyHash)
     else this
   }
 
-  override def concat[V1 >: V](that: scala.IterableOnce[(K, V1)]): ChampHashMap[K, V1] = {
-    // TODO PERF We could avoid recomputing entry hash's when `that` is another `ChampHashMap`
+  override def concat[V1 >: V](that: scala.IterableOnce[(K, V1)]): HashMap[K, V1] = {
+    // TODO PERF We could avoid recomputing entry hash's when `that` is another `HashMap`
     super.concat(that)
   }
 
-  override def tail: ChampHashMap[K, V] = this - head._1
+  override def tail: HashMap[K, V] = this - head._1
 
-  override def init: ChampHashMap[K, V] = this - last._1
+  override def init: HashMap[K, V] = this - last._1
 
   override def head: (K, V) = iterator.next()
 
@@ -116,7 +118,7 @@ final class ChampHashMap[K, +V] private[immutable] (private val rootNode: MapNod
 
   override def equals(that: Any): Boolean =
     that match {
-      case map: ChampHashMap[K, V] =>
+      case map: HashMap[K, V] =>
         (this eq map) ||
           (this.size == map.size) &&
             (this.cachedJavaKeySetHashCode == map.cachedJavaKeySetHashCode) &&
@@ -130,7 +132,21 @@ final class ChampHashMap[K, +V] private[immutable] (private val rootNode: MapNod
     // assert(hash == super.hashCode())
     hash
   }
-  override protected[this] def className = "ChampHashMap"
+
+  override protected[this] def className = "HashMap"
+
+  private type MergeFunction[A1, B1] = ((A1, B1), (A1, B1)) => (A1, B1)
+
+  //TODO optimize (https://github.com/scala/bug/issues/11077)
+  def merged[V1 >: V](that: HashMap[K, V1])(mergef: MergeFunction[K, V1]): HashMap[K, V1] = {
+    val thisKeys = this.keySet
+    if(mergef eq null)
+      that.removeAll(thisKeys) ++ this
+    else {
+      val thatKeys = that.keySet
+      that.removeAll(thisKeys) ++ this.removeAll(thatKeys) ++ thisKeys.intersect(thatKeys).map { case k => mergef((k, this(k)), (k, that(k))) }
+    }
+  }
 }
 
 private[immutable] object MapNode {
@@ -726,28 +742,28 @@ private final class MapKeyValueTupleHashIterator[K, V](rootNode: MapNode[K, V])
 /**
   * $factoryInfo
   *
-  * @define Coll `immutable.ChampHashMap`
+  * @define Coll `immutable.HashMap`
   * @define coll immutable champ hash map
   */
 @SerialVersionUID(3L)
-object ChampHashMap extends MapFactory[ChampHashMap] {
+object HashMap extends MapFactory[HashMap] {
 
-  private[ChampHashMap] def apply[K, V](rootNode: MapNode[K, V], cachedJavaHashCode: Int) =
-    new ChampHashMap[K, V](rootNode, cachedJavaHashCode)
+  private[HashMap] def apply[K, V](rootNode: MapNode[K, V], cachedJavaHashCode: Int) =
+    new HashMap[K, V](rootNode, cachedJavaHashCode)
 
-  private final val EmptyMap = new ChampHashMap(MapNode.empty, 0)
+  private final val EmptyMap = new HashMap(MapNode.empty, 0)
 
-  def empty[K, V]: ChampHashMap[K, V] =
-    EmptyMap.asInstanceOf[ChampHashMap[K, V]]
+  def empty[K, V]: HashMap[K, V] =
+    EmptyMap.asInstanceOf[HashMap[K, V]]
 
-  def from[K, V](source: collection.IterableOnce[(K, V)]): ChampHashMap[K, V] =
+  def from[K, V](source: collection.IterableOnce[(K, V)]): HashMap[K, V] =
     source match {
-      case hs: ChampHashMap[K, V] => hs
+      case hs: HashMap[K, V] => hs
       case _ => (newBuilder[K, V] ++= source).result()
     }
 
-  def newBuilder[K, V]: Builder[(K, V), ChampHashMap[K, V]] =
-    new ImmutableBuilder[(K, V), ChampHashMap[K, V]](empty) {
+  def newBuilder[K, V]: Builder[(K, V), HashMap[K, V]] =
+    new ImmutableBuilder[(K, V), HashMap[K, V]](empty) {
       def addOne(element: (K, V)): this.type = {
         elems = elems + element
         this

src/library/scala/collection/immutable/ChampHashSet.scala

@@ -18,15 +18,15 @@ import scala.util.hashing.MurmurHash3
   *
   *  @author  Michael J. Steindorfer
   *  @since   2.13
-  *  @define Coll `immutable.ChampHashSet`
+  *  @define Coll `immutable.HashSet`
   *  @define coll immutable champ hash set
   */
-final class ChampHashSet[A] private[immutable] (val rootNode: SetNode[A], val cachedJavaHashCode: Int)
+final class HashSet[A] private[immutable] (val rootNode: SetNode[A], val cachedJavaHashCode: Int)
   extends AbstractSet[A]
-    with SetOps[A, ChampHashSet, ChampHashSet[A]]
-    with StrictOptimizedIterableOps[A, ChampHashSet, ChampHashSet[A]] {
+    with SetOps[A, HashSet, HashSet[A]]
+    with StrictOptimizedIterableOps[A, HashSet, HashSet[A]] {
 
-  override def iterableFactory: IterableFactory[ChampHashSet] = ChampHashSet
+  override def iterableFactory: IterableFactory[HashSet] = HashSet
 
   override def knownSize: Int = rootNode.size
 
@@ -47,30 +47,30 @@ final class ChampHashSet[A] private[immutable] (val rootNode: SetNode[A], val ca
     rootNode.contains(element, elementUnimprovedHash, elementHash, 0)
   }
 
-  def incl(element: A): ChampHashSet[A] = {
+  def incl(element: A): HashSet[A] = {
     val elementUnimprovedHash = element.##
     val elementHash = improve(elementUnimprovedHash)
     val newRootNode = rootNode.updated(element, elementUnimprovedHash, elementHash, 0)
 
     if (newRootNode ne rootNode) {
       val newCachedJavaHashCode = cachedJavaHashCode + (if (newRootNode.size == rootNode.size) 0 else elementHash)
-      ChampHashSet(newRootNode, newCachedJavaHashCode)
+      HashSet(newRootNode, newCachedJavaHashCode)
     } else this
   }
 
-  def excl(element: A): ChampHashSet[A] = {
+  def excl(element: A): HashSet[A] = {
     val elementUnimprovedHash = element.##
     val elementHash = improve(elementUnimprovedHash)
     val newRootNode = rootNode.removed(element, elementUnimprovedHash, elementHash, 0)
 
     if (rootNode ne newRootNode)
-      ChampHashSet(newRootNode, cachedJavaHashCode - elementHash)
+      HashSet(newRootNode, cachedJavaHashCode - elementHash)
     else this
   }
 
-  override def tail: ChampHashSet[A] = this - head
+  override def tail: HashSet[A] = this - head
 
-  override def init: ChampHashSet[A] = this - last
+  override def init: HashSet[A] = this - last
 
   override def head: A = iterator.next()
 
@@ -79,21 +79,21 @@ final class ChampHashSet[A] private[immutable] (val rootNode: SetNode[A], val ca
   override def foreach[U](f: A => U): Unit = rootNode.foreach(f)
 
   def subsetOf(that: Set[A]): Boolean = if (that.isEmpty) true else that match {
-    case set: ChampHashSet[A] => rootNode.subsetOf(set.rootNode, 0)
+    case set: HashSet[A] => rootNode.subsetOf(set.rootNode, 0)
     case _ => super.subsetOf(that)
   }
 
   override def equals(that: Any): Boolean =
     that match {
-      case set: ChampHashSet[A] =>
+      case set: HashSet[A] =>
         (this eq set) ||
           (this.size == set.size) &&
             (this.cachedJavaHashCode == set.cachedJavaHashCode) &&
             (this.rootNode == set.rootNode)
       case _ => super.equals(that)
     }
 
-  override protected[this] def className = "ChampHashSet"
+  override protected[this] def className = "HashSet"
 
   override def hashCode(): Int = {
     val it = new SetHashIterator(rootNode)
@@ -646,29 +646,29 @@ private final class SetHashIterator[A](rootNode: SetNode[A])
 /**
   * $factoryInfo
   *
-  * @define Coll `immutable.ChampHashSet`
+  * @define Coll `immutable.HashSet`
   * @define coll immutable champ hash set
   */
 @SerialVersionUID(3L)
-object ChampHashSet extends IterableFactory[ChampHashSet] {
+object HashSet extends IterableFactory[HashSet] {
 
-  private[ChampHashSet] def apply[A](rootNode: SetNode[A], cachedJavaHashCode: Int) =
-    new ChampHashSet[A](rootNode, cachedJavaHashCode)
+  private[HashSet] def apply[A](rootNode: SetNode[A], cachedJavaHashCode: Int) =
+    new HashSet[A](rootNode, cachedJavaHashCode)
 
-  private final val EmptySet = new ChampHashSet(SetNode.empty, 0)
+  private final val EmptySet = new HashSet(SetNode.empty, 0)
 
-  def empty[A]: ChampHashSet[A] =
-    EmptySet.asInstanceOf[ChampHashSet[A]]
+  def empty[A]: HashSet[A] =
+    EmptySet.asInstanceOf[HashSet[A]]
 
-  def from[A](source: collection.IterableOnce[A]): ChampHashSet[A] =
+  def from[A](source: collection.IterableOnce[A]): HashSet[A] =
     source match {
-      case hs: ChampHashSet[A] => hs
+      case hs: HashSet[A] => hs
       case _ if source.knownSize == 0 => empty[A]
       case _ => (newBuilder[A] ++= source).result()
     }
 
-  def newBuilder[A]: Builder[A, ChampHashSet[A]] =
-    new ImmutableBuilder[A, ChampHashSet[A]](empty) {
+  def newBuilder[A]: Builder[A, HashSet[A]] =
+    new ImmutableBuilder[A, HashSet[A]](empty) {
       def addOne(element: A): this.type = {
         elems = elems + element
         this

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

@@ -389,7 +389,7 @@ object Map extends MapFactory[Map] {
       else if (key == key2) new Map4(key1, value1, key2, value, key3, value3, key4, value4)
       else if (key == key3) new Map4(key1, value1, key2, value2, key3, value, key4, value4)
       else if (key == key4) new Map4(key1, value1, key2, value2, key3, value3, key4, value)
-      else (if (useBaseline) HashMap.empty[K, V1] else ChampHashMap.empty[K, V1]).updated(key1,value1).updated(key2, value2).updated(key3, value3).updated(key4, value4).updated(key, value)
+      else (if (useBaseline) OldHashMap.empty[K, V1] else HashMap.empty[K, V1]).updated(key1,value1).updated(key2, value2).updated(key3, value3).updated(key4, value4).updated(key, value)
     def remove(key: K): Map[K, V] =
       if (key == key1)      new Map3(key2, value2, key3, value3, key4, value4)
       else if (key == key2) new Map3(key1, value1, key3, value3, key4, value4)