Move hashing to separate object

This is a first step of a larger refactoring, where hashing and equality need
to have algorithms that detect that isomorphic BindingTypes are equal.

Without this, there is no good way to deal with recursive higher-kinded types,
as we cannot detect that a type has already been added to a constraint or that
a subtype test was already performed.

Author: odersky

compiler/src/dotty/tools/dotc/core/Hashable.scala renamed to compiler/src/dotty/tools/dotc/core/Hashing.scala

@@ -4,45 +4,24 @@ package core
 import Types._
 import scala.util.hashing.{ MurmurHash3 => hashing }
 
-object Hashable {
+abstract class Hashing {
+  import Hashing._
 
-  /** A hash value indicating that the underlying type is not
-   *  cached in uniques.
-   */
-  final val NotCached = 0
-
-  /** An alternative value returned from `hash` if the
-   *  computed hashCode would be `NotCached`.
-   */
-  private[core] final val NotCachedAlt = Int.MinValue
-
-  /** A value that indicates that the hash code is unknown
-   */
-  private[core] final val HashUnknown = 1234
-
-  /** An alternative value if computeHash would otherwise yield HashUnknown
-   */
-  private[core] final val HashUnknownAlt = 4321
-}
-
-trait Hashable {
-  import Hashable._
-
-  protected def hashSeed: Int = getClass.hashCode
-
-  protected final def finishHash(hashCode: Int, arity: Int): Int =
+  final def finishHash(hashCode: Int, arity: Int): Int =
     avoidSpecialHashes(hashing.finalizeHash(hashCode, arity))
 
-  final def identityHash = avoidSpecialHashes(System.identityHashCode(this))
+  protected def typeHash(tp: Type) = tp.hash
+
+  final def identityHash(tp: Type) = avoidSpecialHashes(System.identityHashCode(tp))
 
   protected def finishHash(seed: Int, arity: Int, tp: Type): Int = {
-    val elemHash = tp.hash
+    val elemHash = typeHash(tp)
     if (elemHash == NotCached) return NotCached
     finishHash(hashing.mix(seed, elemHash), arity + 1)
   }
 
   protected def finishHash(seed: Int, arity: Int, tp1: Type, tp2: Type): Int = {
-    val elemHash = tp1.hash
+    val elemHash = typeHash(tp1)
     if (elemHash == NotCached) return NotCached
     finishHash(hashing.mix(seed, elemHash), arity + 1, tp2)
   }
@@ -52,7 +31,7 @@ trait Hashable {
     var xs = tps
     var len = arity
     while (xs.nonEmpty) {
-      val elemHash = xs.head.hash
+      val elemHash = typeHash(xs.head)
       if (elemHash == NotCached) return NotCached
       h = hashing.mix(h, elemHash)
       xs = xs.tail
@@ -62,37 +41,36 @@ trait Hashable {
   }
 
   protected def finishHash(seed: Int, arity: Int, tp: Type, tps: List[Type]): Int = {
-    val elemHash = tp.hash
+    val elemHash = typeHash(tp)
     if (elemHash == NotCached) return NotCached
     finishHash(hashing.mix(seed, elemHash), arity + 1, tps)
   }
 
-  protected final def doHash(x: Any): Int =
-    finishHash(hashing.mix(hashSeed, x.hashCode), 1)
+  final def doHash(clazz: Class[_], x: Any): Int =
+    finishHash(hashing.mix(clazz.hashCode, x.hashCode), 1)
 
-  protected final def doHash(tp: Type): Int =
-    finishHash(hashSeed, 0, tp)
+  final def doHash(clazz: Class[_], tp: Type): Int =
+    finishHash(clazz.hashCode, 0, tp)
 
-  protected final def doHash(x1: Any, tp2: Type): Int =
-    finishHash(hashing.mix(hashSeed, x1.hashCode), 1, tp2)
+  final def doHash(clazz: Class[_], x1: Any, tp2: Type): Int =
+    finishHash(hashing.mix(clazz.hashCode, x1.hashCode), 1, tp2)
 
-  protected final def doHash(tp1: Type, tp2: Type): Int =
-    finishHash(hashSeed, 0, tp1, tp2)
+  final def doHash(clazz: Class[_], tp1: Type, tp2: Type): Int =
+    finishHash(clazz.hashCode, 0, tp1, tp2)
 
-  protected final def doHash(x1: Any, tp2: Type, tp3: Type): Int =
-    finishHash(hashing.mix(hashSeed, x1.hashCode), 1, tp2, tp3)
+  final def doHash(clazz: Class[_], x1: Any, tp2: Type, tp3: Type): Int =
+    finishHash(hashing.mix(clazz.hashCode, x1.hashCode), 1, tp2, tp3)
 
-  protected final def doHash(tp1: Type, tps2: List[Type]): Int =
-    finishHash(hashSeed, 0, tp1, tps2)
+  final def doHash(clazz: Class[_], tp1: Type, tps2: List[Type]): Int =
+    finishHash(clazz.hashCode, 0, tp1, tps2)
 
-  protected final def doHash(x1: Any, tp2: Type, tps3: List[Type]): Int =
-    finishHash(hashing.mix(hashSeed, x1.hashCode), 1, tp2, tps3)
+  final def doHash(clazz: Class[_], x1: Any, tp2: Type, tps3: List[Type]): Int =
+    finishHash(hashing.mix(clazz.hashCode, x1.hashCode), 1, tp2, tps3)
 
+  final def doHash(clazz: Class[_], x1: Int, x2: Int): Int =
+    finishHash(hashing.mix(hashing.mix(clazz.hashCode, x1), x2), 1)
 
-  protected final def doHash(x1: Int, x2: Int): Int =
-    finishHash(hashing.mix(hashing.mix(hashSeed, x1), x2), 1)
-
-  protected final def addDelta(elemHash: Int, delta: Int) =
+  final def addDelta(elemHash: Int, delta: Int) =
     if (elemHash == NotCached) NotCached
     else avoidSpecialHashes(elemHash + delta)
 
@@ -101,3 +79,25 @@ trait Hashable {
     else if (h == HashUnknown) HashUnknownAlt
     else h
 }
+
+object Hashing extends Hashing {
+
+  /** A hash value indicating that the underlying type is not
+   *  cached in uniques.
+   */
+  final val NotCached = 0
+
+  /** An alternative value returned from `hash` if the
+   *  computed hashCode would be `NotCached`.
+   */
+  private[core] final val NotCachedAlt = Int.MinValue
+
+  /** A value that indicates that the hash code is unknown
+   */
+  private[core] final val HashUnknown = 1234
+
+  /** An alternative value if computeHash would otherwise yield HashUnknown
+   */
+  private[core] final val HashUnknownAlt = 4321
+}
+

compiler/src/dotty/tools/dotc/core/TypeErasure.scala

@@ -78,7 +78,7 @@ object TypeErasure {
    */
   abstract case class ErasedValueType(tycon: TypeRef, erasedUnderlying: Type)
   extends CachedGroundType with ValueType {
-    override def computeHash = doHash(tycon, erasedUnderlying)
+    override def computeHash(h: Hashing) = h.doHash(getClass, tycon, erasedUnderlying)
   }
 
   final class CachedErasedValueType(tycon: TypeRef, erasedUnderlying: Type)