Structural hashes for dependent types

Make hashes structural for dependent types. Two isomorphic types
should give the same hash even if there are dependencies to BindingTypes.

Author: odersky

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

@@ -12,7 +12,7 @@ abstract class Hashing {
 
   protected def typeHash(tp: Type) = tp.hash
 
-  final def identityHash(tp: Type) = avoidSpecialHashes(System.identityHashCode(tp))
+  def identityHash(tp: Type) = avoidSpecialHashes(System.identityHashCode(tp))
 
   protected def finishHash(seed: Int, arity: Int, tp: Type): Int = {
     val elemHash = typeHash(tp)
@@ -78,6 +78,29 @@ abstract class Hashing {
     if (h == NotCached) NotCachedAlt
     else if (h == HashUnknown) HashUnknownAlt
     else h
+
+  val binders: Array[BindingType] = Array()
+
+  private class WithBinders(override val binders: Array[BindingType]) extends Hashing {
+
+    override def typeHash(tp: Type) = tp.computeHash(this)
+
+    override def identityHash(tp: Type) = {
+      var idx = 0
+      while (idx < binders.length && (binders(idx) `ne` tp))
+        idx += 1
+      avoidSpecialHashes(
+        if (idx < binders.length) idx * 31
+        else System.identityHashCode(binders))
+    }
+  }
+
+  def withBinder(binder: BindingType): Hashing = {
+    val newBinders = new Array[BindingType](binders.length + 1)
+    Array.copy(binders, 0, newBinders, 0, binders.length)
+    newBinders(binders.length) = binder
+    new WithBinders(newBinders)
+  }
 }
 
 object Hashing extends Hashing {

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

@@ -1408,6 +1408,9 @@ object Types {
      */
     def eql(that: Type): Boolean = this.equals(that)
 
+    /** Compute `hash` using given `Hashing` */
+    def computeHash(h: Hashing): Int
+
   } // end Type
 
 // ----- Type categories ----------------------------------------------
@@ -1451,7 +1454,6 @@ object Types {
     }
     override final def hashCode =
       if (hash == Hashing.NotCached) System.identityHashCode(this) else hash
-    def computeHash(h: Hashing): Int
   }
 
   /**  Instances of this class are cached and are proxies. */
@@ -1466,25 +1468,26 @@ object Types {
     }
     override final def hashCode =
       if (hash == Hashing.NotCached) System.identityHashCode(this) else hash
-    def computeHash(h: Hashing): Int
   }
 
   /**  Instances of this class are uncached and are not proxies. */
   abstract class UncachedGroundType extends Type {
-    final def hash = Hashing.NotCached
     if (monitored) {
       record(s"uncachable")
       record(s"uncachable: $getClass")
     }
+    final def hash = Hashing.NotCached
+    final def computeHash(h: Hashing): Int = Hashing.NotCached
   }
 
   /**  Instances of this class are uncached and are proxies. */
   abstract class UncachedProxyType extends TypeProxy {
-    final def hash = Hashing.NotCached
     if (monitored) {
       record(s"uncachable")
       record(s"uncachable: $getClass")
     }
+    final def hash = Hashing.NotCached
+    final def computeHash(h: Hashing): Int = Hashing.NotCached
   }
 
   /** A marker trait for types that apply only to type symbols */