Add binders parameter to all hashcode computations

Author: odersky

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

@@ -6,6 +6,8 @@ import scala.util.hashing.{ MurmurHash3 => hashing }
 
 object Hashable {
 
+  type Binders = Array[BindingType]
+
   /** A hash value indicating that the underlying type is not
    *  cached in uniques.
    */
@@ -33,26 +35,29 @@ trait Hashable {
   protected final def finishHash(hashCode: Int, arity: Int): Int =
     avoidSpecialHashes(hashing.finalizeHash(hashCode, arity))
 
-  final def identityHash = avoidSpecialHashes(System.identityHashCode(this))
+  final def typeHash(bs: Binders, tp: Type) =
+    if (bs == null) tp.hash else tp.computeHash(bs)
+
+  def identityHash(bs: Binders) = avoidSpecialHashes(System.identityHashCode(this))
 
-  protected def finishHash(seed: Int, arity: Int, tp: Type): Int = {
-    val elemHash = tp.hash
+  protected def finishHash(bs: Binders, seed: Int, arity: Int, tp: Type): Int = {
+    val elemHash = typeHash(bs, 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
+  protected def finishHash(bs: Binders, seed: Int, arity: Int, tp1: Type, tp2: Type): Int = {
+    val elemHash = typeHash(bs, tp1)
     if (elemHash == NotCached) return NotCached
-    finishHash(hashing.mix(seed, elemHash), arity + 1, tp2)
+    finishHash(bs, hashing.mix(seed, elemHash), arity + 1, tp2)
   }
 
-  protected def finishHash(seed: Int, arity: Int, tps: List[Type]): Int = {
+  protected def finishHash(bs: Binders, seed: Int, arity: Int, tps: List[Type]): Int = {
     var h = seed
     var xs = tps
     var len = arity
     while (xs.nonEmpty) {
-      val elemHash = xs.head.hash
+      val elemHash = typeHash(bs, xs.head)
       if (elemHash == NotCached) return NotCached
       h = hashing.mix(h, elemHash)
       xs = xs.tail
@@ -61,35 +66,35 @@ trait Hashable {
     finishHash(h, len)
   }
 
-  protected def finishHash(seed: Int, arity: Int, tp: Type, tps: List[Type]): Int = {
-    val elemHash = tp.hash
+  protected def finishHash(bs: Binders, seed: Int, arity: Int, tp: Type, tps: List[Type]): Int = {
+    val elemHash = typeHash(bs, tp)
     if (elemHash == NotCached) return NotCached
-    finishHash(hashing.mix(seed, elemHash), arity + 1, tps)
+    finishHash(bs, hashing.mix(seed, elemHash), arity + 1, tps)
   }
 
   protected final def doHash(x: Any): Int =
     finishHash(hashing.mix(hashSeed, x.hashCode), 1)
 
-  protected final def doHash(tp: Type): Int =
-    finishHash(hashSeed, 0, tp)
+  protected final def doHash(bs: Binders, tp: Type): Int =
+    finishHash(bs, hashSeed, 0, tp)
 
-  protected final def doHash(x1: Any, tp2: Type): Int =
-    finishHash(hashing.mix(hashSeed, x1.hashCode), 1, tp2)
+  protected final def doHash(bs: Binders, x1: Any, tp2: Type): Int =
+    finishHash(bs, hashing.mix(hashSeed, x1.hashCode), 1, tp2)
 
-  protected final def doHash(tp1: Type, tp2: Type): Int =
-    finishHash(hashSeed, 0, tp1, tp2)
+  protected final def doHash(bs: Binders, tp1: Type, tp2: Type): Int =
+    finishHash(bs, hashSeed, 0, tp1, tp2)
 
-  protected final def doHash(x1: Any, tp2: Type, tp3: Type): Int =
-    finishHash(hashing.mix(hashSeed, x1.hashCode), 1, tp2, tp3)
+  protected final def doHash(bs: Binders, x1: Any, tp2: Type, tp3: Type): Int =
+    finishHash(bs, hashing.mix(hashSeed, x1.hashCode), 1, tp2, tp3)
 
-  protected final def doHash(tp1: Type, tps2: List[Type]): Int =
-    finishHash(hashSeed, 0, tp1, tps2)
+  protected final def doHash(bs: Binders, tp1: Type, tps2: List[Type]): Int =
+    finishHash(bs, hashSeed, 0, tp1, tps2)
 
-  protected final def doHash(x1: Any, tp2: Type, tps3: List[Type]): Int =
-    finishHash(hashing.mix(hashSeed, x1.hashCode), 1, tp2, tps3)
+  protected final def doHash(bs: Binders, x1: Any, tp2: Type, tps3: List[Type]): Int =
+    finishHash(bs, hashing.mix(hashSeed, x1.hashCode), 1, tp2, tps3)
 
 
-  protected final def doHash(x1: Int, x2: Int): Int =
+  protected final def doHash(bs: Binders, x1: Int, x2: Int): Int =
     finishHash(hashing.mix(hashing.mix(hashSeed, x1), x2), 1)
 
   protected final def addDelta(elemHash: Int, delta: Int) =

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(bs: Hashable.Binders) = doHash(bs, tycon, erasedUnderlying)
   }
 
   final class CachedErasedValueType(tycon: TypeRef, erasedUnderlying: Type)

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

@@ -1399,15 +1399,18 @@ object Types {
      */
     def simplified(implicit ctx: Context) = ctx.simplify(this, null)
 
+    /** Equality used for hash-consing; uses `eq` on all recursive invocations.
+     */
+    def eql(that: Type): Boolean = this.equals(that)
+
     /** customized hash code of this type.
      *  NotCached for uncached types. Cached types
      *  compute hash and use it as the type's hashCode.
      */
     def hash: Int
 
-    /** Equality used for hash-consing; uses `eq` on all recursive invocations.
-     */
-    def eql(that: Type): Boolean = this.equals(that)
+    /** Compute hashcode relative to enclosing binders `bs` */
+    def computeHash(bs: Binders): Int
 
   } // end Type
 
@@ -1445,34 +1448,33 @@ object Types {
     private[this] var myHash = HashUnknown
     final def hash = {
       if (myHash == HashUnknown) {
-        myHash = computeHash
+        myHash = computeHash(null)
         assert(myHash != HashUnknown)
       }
       myHash
     }
     override final def hashCode =
       if (hash == NotCached) System.identityHashCode(this) else hash
-    def computeHash: Int
   }
 
   /**  Instances of this class are cached and are proxies. */
   abstract class CachedProxyType extends TypeProxy with CachedType {
     protected[this] var myHash = HashUnknown
     final def hash = {
       if (myHash == HashUnknown) {
-        myHash = computeHash
+        myHash = computeHash(null)
         assert(myHash != HashUnknown)
       }
       myHash
     }
     override final def hashCode =
       if (hash == NotCached) System.identityHashCode(this) else hash
-    def computeHash: Int
   }
 
   /**  Instances of this class are uncached and are not proxies. */
   abstract class UncachedGroundType extends Type {
     final def hash = NotCached
+    final def computeHash(bs: Binders) = NotCached
     if (monitored) {
       record(s"uncachable")
       record(s"uncachable: $getClass")
@@ -1482,6 +1484,7 @@ object Types {
   /**  Instances of this class are uncached and are proxies. */
   abstract class UncachedProxyType extends TypeProxy {
     final def hash = NotCached
+    final def computeHash(bs: Binders) = NotCached
     if (monitored) {
       record(s"uncachable")
       record(s"uncachable: $getClass")
@@ -2025,7 +2028,7 @@ object Types {
         false
     }
 
-    override def computeHash = unsupported("computeHash")
+    override def computeHash(bs: Binders) = doHash(bs, designator, prefix)
 
     override def eql(that: Type) = this eq that // safe because named types are hash-consed separately
   }
@@ -2149,7 +2152,7 @@ object Types {
           // can happen in IDE if `cls` is stale
       }
 
-    override def computeHash = doHash(tref)
+    override def computeHash(bs: Binders) = doHash(bs, tref)
 
     override def eql(that: Type) = that match {
       case that: ThisType => tref.eq(that.tref)
@@ -2177,7 +2180,7 @@ object Types {
       if ((thistpe eq this.thistpe) && (supertpe eq this.supertpe)) this
       else SuperType(thistpe, supertpe)
 
-    override def computeHash = doHash(thistpe, supertpe)
+    override def computeHash(bs: Binders) = doHash(bs, thistpe, supertpe)
 
     override def eql(that: Type) = that match {
       case that: SuperType => thistpe.eq(that.thistpe) && supertpe.eq(that.supertpe)
@@ -2198,7 +2201,7 @@ object Types {
   abstract case class ConstantType(value: Constant) extends CachedProxyType with SingletonType {
     override def underlying(implicit ctx: Context) = value.tpe
 
-    override def computeHash = doHash(value)
+    override def computeHash(bs: Binders) = doHash(value)
   }
 
   final class CachedConstantType(value: Constant) extends ConstantType(value)
@@ -2262,7 +2265,7 @@ object Types {
       if (parent.member(refinedName).exists) derivedRefinedType(parent, refinedName, refinedInfo)
       else parent
 
-    override def computeHash = doHash(refinedName, refinedInfo, parent)
+    override def computeHash(bs: Binders) = doHash(bs, refinedName, refinedInfo, parent)
 
     override def eql(that: Type) = that match {
       case that: RefinedType =>
@@ -2326,7 +2329,7 @@ object Types {
       refacc.apply(false, tp)
     }
 
-    override def computeHash = doHash(parent)
+    override def computeHash(bs: Binders) = doHash(bs, parent)
 
     override def equals(that: Any) = that match {
       case that: RecType => parent == that.parent
@@ -2432,7 +2435,7 @@ object Types {
     def derivedAndOrType(tp1: Type, tp2: Type)(implicit ctx: Context): Type =
       derivedAndType(tp1, tp2)
 
-    override def computeHash = doHash(tp1, tp2)
+    override def computeHash(bs: Binders) = doHash(bs, tp1, tp2)
 
     override def eql(that: Type) = that match {
       case that: AndType => tp1.eq(that.tp1) && tp2.eq(that.tp2)
@@ -2493,7 +2496,7 @@ object Types {
     def derivedAndOrType(tp1: Type, tp2: Type)(implicit ctx: Context): Type =
       derivedOrType(tp1, tp2)
 
-    override def computeHash = doHash(tp1, tp2)
+    override def computeHash(bs: Binders) = doHash(bs, tp1, tp2)
 
     override def eql(that: Type) = that match {
       case that: OrType => tp1.eq(that.tp1) && tp2.eq(that.tp2)
@@ -2559,7 +2562,7 @@ object Types {
     def derivedExprType(resType: Type)(implicit ctx: Context) =
       if (resType eq this.resType) this else ExprType(resType)
 
-    override def computeHash = doHash(resType)
+    override def computeHash(bs: Binders) = doHash(bs, resType)
 
     override def eql(that: Type) = that match {
       case that: ExprType => resType.eq(that.resType)
@@ -2643,7 +2646,7 @@ object Types {
   abstract class HKLambda extends CachedProxyType with LambdaType {
     final override def underlying(implicit ctx: Context) = resType
 
-    final override def computeHash = doHash(paramNames, resType, paramInfos)
+    final override def computeHash(bs: Binders) = doHash(bs, paramNames, resType, paramInfos)
 
     final override def equals(that: Any) = that match {
       case that: HKLambda =>
@@ -3119,12 +3122,13 @@ object Types {
     def derivedAppliedType(tycon: Type, args: List[Type])(implicit ctx: Context): Type =
       if ((tycon eq this.tycon) && (args eq this.args)) this
       else tycon.appliedTo(args)
+
+    override def computeHash(bs: Binders) = doHash(bs, tycon, args)
+    override def eql(that: Type) = this `eq` that // safe because applied types are hash-consed separately
   }
 
   final class CachedAppliedType(tycon: Type, args: List[Type], hc: Int) extends AppliedType(tycon, args) {
     myHash = hc
-    override def computeHash = unsupported("computeHash")
-    override def eql(that: Type) = this eq that // safe because applied types are hash-consed separately
   }
 
   object AppliedType {
@@ -3140,6 +3144,8 @@ object Types {
     type BT <: Type
     val binder: BT
     def copyBoundType(bt: BT): Type
+    override def identityHash(bs: Binders) =
+      if (bs == null) super.identityHash(bs) else ???
   }
 
   abstract class ParamRef extends BoundType {
@@ -3153,7 +3159,7 @@ object Types {
       else infos(paramNum)
     }
 
-    override def computeHash = doHash(paramNum, binder.identityHash)
+    override def computeHash(bs: Binders) = doHash(bs, paramNum, binder.identityHash(bs))
 
     override def equals(that: Any) = that match {
       case that: ParamRef => binder.eq(that.binder) && paramNum == that.paramNum
@@ -3210,7 +3216,7 @@ object Types {
 
     // need to customize hashCode and equals to prevent infinite recursion
     // between RecTypes and RecRefs.
-    override def computeHash = addDelta(binder.identityHash, 41)
+    override def computeHash(bs: Binders) = addDelta(binder.identityHash(bs), 41)
 
     override def equals(that: Any) = that match {
       case that: RecThis => binder.eq(that.binder)
@@ -3231,7 +3237,7 @@ object Types {
     override def underlying(implicit ctx: Context) = info
     def derivedSkolemType(info: Type)(implicit ctx: Context) =
       if (info eq this.info) this else SkolemType(info)
-    override def hashCode: Int = identityHash
+    override def hashCode: Int = System.identityHashCode(this)
     override def equals(that: Any) = this.eq(that.asInstanceOf[AnyRef])
 
     def withName(name: Name): this.type = { myRepr = name; this }
@@ -3337,7 +3343,7 @@ object Types {
       }
     }
 
-    override def computeHash: Int = identityHash
+    override def computeHash(bs: Binders): Int = identityHash(bs)
     override def equals(that: Any) = this.eq(that.asInstanceOf[AnyRef])
 
     override def toString = {
@@ -3412,7 +3418,7 @@ object Types {
       if ((prefix eq this.prefix) && (classParents eq this.classParents) && (decls eq this.decls) && (selfInfo eq this.selfInfo)) this
       else ClassInfo(prefix, cls, classParents, decls, selfInfo)
 
-    override def computeHash = doHash(cls, prefix)
+    override def computeHash(bs: Binders) = doHash(bs, cls, prefix)
 
     override def eql(that: Type) = that match {
       case that: ClassInfo =>
@@ -3495,7 +3501,7 @@ object Types {
       case _ => super.| (that)
     }
 
-    override def computeHash = doHash(lo, hi)
+    override def computeHash(bs: Binders) = doHash(bs, lo, hi)
 
     override def equals(that: Any): Boolean = that match {
       case that: TypeAlias => false
@@ -3518,7 +3524,7 @@ object Types {
     def derivedTypeAlias(alias: Type)(implicit ctx: Context) =
       if (alias eq this.alias) this else TypeAlias(alias)
 
-    override def computeHash = doHash(alias)
+    override def computeHash(bs: Binders) = doHash(bs, alias)
 
     override def equals(that: Any): Boolean = that match {
       case that: TypeAlias => alias == that.alias
@@ -3577,7 +3583,7 @@ object Types {
     def derivedJavaArrayType(elemtp: Type)(implicit ctx: Context) =
       if (elemtp eq this.elemType) this else JavaArrayType(elemtp)
 
-    override def computeHash = doHash(elemType)
+    override def computeHash(bs: Binders) = doHash(bs, elemType)
 
     override def eql(that: Type) = that match {
       case that: JavaArrayType => elemType.eq(that.elemType)
@@ -3595,12 +3601,12 @@ object Types {
   /** Sentinel for "missing type" */
   @sharable case object NoType extends CachedGroundType {
     override def exists = false
-    override def computeHash = hashSeed
+    override def computeHash(bs: Binders) = hashSeed
   }
 
   /** Missing prefix */
   @sharable case object NoPrefix extends CachedGroundType {
-    override def computeHash = hashSeed
+    override def computeHash(bs: Binders) = hashSeed
   }
 
   /** A common superclass of `ErrorType` and `TryDynamicCallSite`. Instances of this
@@ -3640,7 +3646,7 @@ object Types {
       else if (!optBounds.exists) WildcardType
       else WildcardType(optBounds.asInstanceOf[TypeBounds])
 
-    override def computeHash = doHash(optBounds)
+    override def computeHash(bs: Binders) = doHash(bs, optBounds)
 
     override def eql(that: Type) = that match {
       case that: WildcardType => optBounds.eq(that.optBounds)