Compute fewer hashes

Before hashing with a non-null binders list, check whether
the type has a stable hash. Hash-stability results are cached in
NamedTypes and AppliedTypes.

Author: odersky

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

@@ -43,7 +43,7 @@ trait Hashable {
     avoidSpecialHashes(hashing.finalizeHash(hashCode, arity))
 
   final def typeHash(bs: Binders, tp: Type) =
-    if (bs == null) tp.hash else tp.computeHash(bs)
+    if (bs == null || tp.stableHash) tp.hash else tp.computeHash(bs)
 
   def identityHash(bs: Binders) = avoidSpecialHashes(System.identityHashCode(this))
 
@@ -100,7 +100,6 @@ trait Hashable {
   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 =
     finishHash(hashing.mix(hashing.mix(hashSeed, x1), x2), 1)
 

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

@@ -1417,6 +1417,9 @@ object Types {
     /** Compute hashcode relative to enclosing binders `bs` */
     def computeHash(bs: Binders): Int
 
+    /** Is the `hash` of this type the same for all possible sequences of enclosing binders? */
+    def stableHash: Boolean = true
+
   } // end Type
 
 // ----- Type categories ----------------------------------------------
@@ -1566,6 +1569,7 @@ object Types {
     private[this] var lastDenotation: Denotation = null
     private[this] var lastSymbol: Symbol = null
     private[this] var checkedPeriod: Period = Nowhere
+    private[this] var myStableHash: Byte = 0
 
     // Invariants:
     // (1) checkedPeriod != Nowhere  =>  lastDenotation != null
@@ -2038,6 +2042,11 @@ object Types {
 
     override def computeHash(bs: Binders) = doHash(bs, designator, prefix)
 
+    override def stableHash = {
+      if (myStableHash == 0) myStableHash = if (prefix.stableHash) 1 else -1
+      myStableHash > 0
+    }
+
     override def eql(that: Type) = this eq that // safe because named types are hash-consed separately
   }
 
@@ -2289,6 +2298,7 @@ object Types {
       else parent
 
     override def computeHash(bs: Binders) = doHash(bs, refinedName, refinedInfo, parent)
+    override def stableHash = refinedInfo.stableHash && parent.stableHash
 
     override def eql(that: Type) = that match {
       case that: RefinedType =>
@@ -2362,6 +2372,11 @@ object Types {
 
     override def computeHash(bs: Binders) = doHash(new Binders(this, bs), parent)
 
+    override def stableHash = false
+      // this is a conservative observation. By construction RecTypes contain at least
+      // one RecThis occurrence. Since `stableHash` does not keep track of enclosing
+      // bound types, it will return "unstable" for this occurrence and this would propagate.
+
     override def eql(that: Type) = that match {
       case that: RecType => parent.eq(that.parent)
       case _ => false
@@ -2414,7 +2429,7 @@ object Types {
 
   // --- AndType/OrType ---------------------------------------------------------------
 
-  trait AndOrType extends ValueType { // todo: check where we can simplify using AndOrType
+  abstract class AndOrType extends CachedGroundType with ValueType {
     def tp1: Type
     def tp2: Type
     def isAnd: Boolean
@@ -2450,9 +2465,22 @@ object Types {
       }
       myBaseClasses
     }
+
+    override def computeHash(bs: Binders) = doHash(bs, tp1, tp2)
+    override def stableHash = tp1.stableHash && tp2.stableHash
+
+    override def eql(that: Type) = that match {
+      case that: AndOrType => isAnd == that.isAnd && tp1.eq(that.tp1) && tp2.eq(that.tp2)
+      case _ => false
+    }
+
+    override def iso(that: Any, bs: BinderPairs) = that match {
+      case that: AndOrType => isAnd == that.isAnd && tp1.equals(that.tp1, bs) && tp2.equals(that.tp2, bs)
+      case _ => false
+    }
   }
 
-  abstract case class AndType(tp1: Type, tp2: Type) extends CachedGroundType with AndOrType {
+  abstract case class AndType(tp1: Type, tp2: Type) extends AndOrType {
 
     def isAnd = true
 
@@ -2466,18 +2494,6 @@ object Types {
 
     def derivedAndOrType(tp1: Type, tp2: Type)(implicit ctx: Context): Type =
       derivedAndType(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)
-      case _ => false
-    }
-
-    override def iso(that: Any, bs: BinderPairs) = that match {
-      case that: AndType => tp1.equals(that.tp1, bs) && tp2.equals(that.tp2, bs)
-      case _ => false
-    }
   }
 
   final class CachedAndType(tp1: Type, tp2: Type) extends AndType(tp1, tp2)
@@ -2506,7 +2522,7 @@ object Types {
         if (checkValid) apply(tp1, tp2) else unchecked(tp1, tp2)
   }
 
-  abstract case class OrType(tp1: Type, tp2: Type) extends CachedGroundType with AndOrType {
+  abstract case class OrType(tp1: Type, tp2: Type) extends AndOrType {
 
     assert(tp1.isInstanceOf[ValueTypeOrWildcard] &&
            tp2.isInstanceOf[ValueTypeOrWildcard], s"$tp1 $tp2")
@@ -2532,18 +2548,6 @@ object Types {
 
     def derivedAndOrType(tp1: Type, tp2: Type)(implicit ctx: Context): Type =
       derivedOrType(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)
-      case _ => false
-    }
-
-    override def iso(that: Any, bs: BinderPairs) = that match {
-      case that: OrType => tp1.equals(that.tp1, bs) && tp2.equals(that.tp2, bs)
-      case _ => false
-    }
   }
 
   final class CachedOrType(tp1: Type, tp2: Type) extends OrType(tp1, tp2)
@@ -2605,6 +2609,7 @@ object Types {
       if (resType eq this.resType) this else ExprType(resType)
 
     override def computeHash(bs: Binders) = doHash(bs, resType)
+    override def stableHash = resType.stableHash
 
     override def eql(that: Type) = that match {
       case that: ExprType => resType.eq(that.resType)
@@ -2693,10 +2698,11 @@ object Types {
   abstract class HKLambda extends CachedProxyType with LambdaType {
     final override def underlying(implicit ctx: Context) = resType
 
-    final override def computeHash(bs: Binders) =
+    override def computeHash(bs: Binders) =
       doHash(new Binders(this, bs), paramNames, resType, paramInfos)
+    override def stableHash = resType.stableHash && paramInfos.stableHash
 
-    final override def eql(that: Type) = that match {
+    override def eql(that: Type) = that match {
       case that: HKLambda =>
         paramNames.equals(that.paramNames) &&
         paramInfos.equals(that.paramInfos) &&
@@ -3128,6 +3134,7 @@ object Types {
 
     private[this] var validSuper: Period = Nowhere
     private[this] var cachedSuper: Type = _
+    private[this] var myStableHash: Byte = 0
 
     override def underlying(implicit ctx: Context): Type = tycon
 
@@ -3173,6 +3180,12 @@ object Types {
       else tycon.appliedTo(args)
 
     override def computeHash(bs: Binders) = doHash(bs, tycon, args)
+
+    override def stableHash = {
+      if (myStableHash == 0) myStableHash = if (tycon.stableHash && args.stableHash) 1 else -1
+      myStableHash > 0
+    }
+
     override def eql(that: Type) = this `eq` that // safe because applied types are hash-consed separately
 
     final override def iso(that: Any, bs: BinderPairs) = that match {
@@ -3198,6 +3211,7 @@ object Types {
     type BT <: Type
     val binder: BT
     def copyBoundType(bt: BT): Type
+    override def stableHash = false
   }
 
   abstract class ParamRef extends BoundType {
@@ -3469,6 +3483,7 @@ object Types {
       else ClassInfo(prefix, cls, classParents, decls, selfInfo)
 
     override def computeHash(bs: Binders) = doHash(bs, cls, prefix)
+    override def stableHash = prefix.stableHash && classParents.stableHash
 
     override def eql(that: Type) = that match {
       case that: ClassInfo =>
@@ -3562,6 +3577,7 @@ object Types {
     }
 
     override def computeHash(bs: Binders) = doHash(bs, lo, hi)
+    override def stableHash = lo.stableHash && hi.stableHash
 
     override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: TypeAlias => false
@@ -3585,6 +3601,7 @@ object Types {
       if (alias eq this.alias) this else TypeAlias(alias)
 
     override def computeHash(bs: Binders) = doHash(bs, alias)
+    override def stableHash = alias.stableHash
 
     override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: TypeAlias => alias.equals(that.alias, bs)
@@ -3649,6 +3666,7 @@ object Types {
       if (elemtp eq this.elemType) this else JavaArrayType(elemtp)
 
     override def computeHash(bs: Binders) = doHash(bs, elemType)
+    override def stableHash = elemType.stableHash
 
     override def eql(that: Type) = that match {
       case that: JavaArrayType => elemType.eq(that.elemType)
@@ -3717,6 +3735,7 @@ object Types {
       else WildcardType(optBounds.asInstanceOf[TypeBounds])
 
     override def computeHash(bs: Binders) = doHash(bs, optBounds)
+    override def stableHash = optBounds.stableHash
 
     override def eql(that: Type) = that match {
       case that: WildcardType => optBounds.eq(that.optBounds)
@@ -4510,7 +4529,9 @@ object Types {
 
   implicit def decorateTypeApplications(tpe: Type): TypeApplications = new TypeApplications(tpe)
 
-  implicit class listEquals(val tps1: List[Type]) extends AnyVal {
+  implicit class typeListDeco(val tps1: List[Type]) extends AnyVal {
+    @tailrec def stableHash: Boolean =
+      tps1.isEmpty || tps1.head.stableHash && tps1.tail.stableHash
     @tailrec def equalElements(tps2: List[Type], bs: BinderPairs): Boolean =
       (tps1 `eq` tps2) || {
         if (tps1.isEmpty) tps2.isEmpty

compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala

@@ -137,6 +137,7 @@ object ProtoTypes {
       val delta = (if (compat eq NoViewsAllowed) 1 else 0) | (if (privateOK) 2 else 0)
       addDelta(doHash(bs, name, memberProto), delta)
     }
+    override def stableHash = memberProto.stableHash
   }
 
   class CachedSelectionProto(name: Name, memberProto: Type, compat: Compatibility, privateOK: Boolean)
@@ -330,6 +331,7 @@ object ProtoTypes {
 
   class CachedViewProto(argType: Type, resultType: Type) extends ViewProto(argType, resultType) {
     override def computeHash(bs: Hashable.Binders) = doHash(bs, argType, resultType)
+    override def stableHash = argType.stableHash && resultType.stableHash
   }
 
   object ViewProto {