Merge pull request #921 from dotty-staging/polytypes-hashcodes

Add stable hash codes to PolyTypes and PolyParams.

Author: DarkDimius

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

@@ -30,24 +30,24 @@ trait Hashable {
 
   protected def hashSeed: Int = getClass.hashCode
 
-  private def finishHash(hashCode: Int, arity: Int): Int =
+  protected final def finishHash(hashCode: Int, arity: Int): Int =
     avoidNotCached(hashing.finalizeHash(hashCode, arity))
 
   final def identityHash = avoidNotCached(System.identityHashCode(this))
 
-  private def finishHash(seed: Int, arity: Int, tp: Type): Int = {
+  protected def finishHash(seed: Int, arity: Int, tp: Type): Int = {
     val elemHash = tp.hash
     if (elemHash == NotCached) return NotCached
     finishHash(hashing.mix(seed, elemHash), arity + 1)
   }
 
-  private def finishHash(seed: Int, arity: Int, tp1: Type, tp2: Type): Int = {
+  protected def finishHash(seed: Int, arity: Int, tp1: Type, tp2: Type): Int = {
     val elemHash = tp1.hash
     if (elemHash == NotCached) return NotCached
     finishHash(hashing.mix(seed, elemHash), arity + 1, tp2)
   }
 
-  private def finishHash(seed: Int, arity: Int, tps: List[Type]): Int = {
+  protected def finishHash(seed: Int, arity: Int, tps: List[Type]): Int = {
     var h = seed
     var xs = tps
     var len = arity
@@ -61,7 +61,7 @@ trait Hashable {
     finishHash(h, len)
   }
 
-  private def finishHash(seed: Int, arity: Int, tp: Type, tps: List[Type]): Int = {
+  protected def finishHash(seed: Int, arity: Int, tp: Type, tps: List[Type]): Int = {
     val elemHash = tp.hash
     if (elemHash == NotCached) return NotCached
     finishHash(hashing.mix(seed, elemHash), arity + 1, tps)
@@ -88,6 +88,10 @@ trait Hashable {
   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(x1: Int, x2: Int): Int =
+    finishHash(hashing.mix(hashing.mix(hashSeed, x1), x2), 1)
+
   protected final def addDelta(hc: Int, delta: Int) = avoidNotCached(hc + delta)
 
   private def avoidNotCached(h: Int) = if (h == NotCached) NotCachedAlt else h

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

@@ -33,6 +33,7 @@ import annotation.tailrec
 import Flags.FlagSet
 import typer.Mode
 import language.implicitConversions
+import scala.util.hashing.{ MurmurHash3 => hashing }
 
 object Types {
 
@@ -2253,12 +2254,14 @@ object Types {
     }
   }
 
-  case class PolyType(paramNames: List[TypeName])(paramBoundsExp: PolyType => List[TypeBounds], resultTypeExp: PolyType => Type)
+  abstract case class PolyType(paramNames: List[TypeName])(paramBoundsExp: PolyType => List[TypeBounds], resultTypeExp: PolyType => Type)
     extends CachedGroundType with BindingType with TermType with MethodOrPoly {
 
     val paramBounds = paramBoundsExp(this)
     val resType = resultTypeExp(this)
 
+    assert(resType ne null)
+
     override def resultType(implicit ctx: Context) = resType
 
     protected def computeSignature(implicit ctx: Context) = resultSignature
@@ -2280,13 +2283,26 @@ object Types {
 
     // need to override hashCode and equals to be object identity
     // because paramNames by itself is not discriminatory enough
-    override def equals(other: Any) = this eq other.asInstanceOf[AnyRef]
-    override def computeHash = identityHash
+    override def equals(other: Any) = other match {
+      case other: PolyType =>
+        other.paramNames == this.paramNames && other.paramBounds == this.paramBounds && other.resType == this.resType
+      case _ => false
+    }
+    override def computeHash = {
+      doHash(paramNames, resType, paramBounds)
+    }
 
     override def toString = s"PolyType($paramNames, $paramBounds, $resType)"
   }
 
+  class CachedPolyType(paramNames: List[TypeName])(paramBoundsExp: PolyType => List[TypeBounds], resultTypeExp: PolyType => Type)
+    extends PolyType(paramNames)(paramBoundsExp, resultTypeExp)
+
   object PolyType {
+    def apply(paramNames: List[TypeName])(paramBoundsExp: PolyType => List[TypeBounds], resultTypeExp: PolyType => Type)(implicit ctx: Context): PolyType = {
+      unique(new CachedPolyType(paramNames)(paramBoundsExp, resultTypeExp))
+    }
+
     def fromSymbols(tparams: List[Symbol], resultType: Type)(implicit ctx: Context) =
       if (tparams.isEmpty) resultType
       else {
@@ -2362,7 +2378,8 @@ object Types {
     // no customized hashCode/equals needed because cycle is broken in PolyType
     override def toString = s"PolyParam(${binder.paramNames(paramNum)})"
 
-    override def computeHash = doHash(paramNum, binder)
+    override def computeHash = doHash(paramNum, binder.identityHash)
+
     override def equals(that: Any) = that match {
       case that: PolyParam =>
         (this.binder eq that.binder) && this.paramNum == that.paramNum