Cache all method and polytypes

Author: odersky

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

@@ -2663,6 +2663,7 @@ object Types {
     final def isHigherKinded = isInstanceOf[TypeProxy]
 
     private[this] var myParamRefs: List[ParamRefType] = null
+    private[this] var myStableHash: Byte = 0
 
     def paramRefs: List[ParamRefType] = {
       if (myParamRefs == null) myParamRefs = paramNames.indices.toList.map(newParamRef)
@@ -2695,24 +2696,20 @@ object Types {
           x => paramInfos.mapConserve(_.subst(this, x).asInstanceOf[PInfo]),
           x => resType.subst(this, x))
 
-    protected def prefixString: String
-    final override def toString = s"$prefixString($paramNames, $paramInfos, $resType)"
-  }
-
-  abstract class HKLambda extends CachedProxyType with LambdaType {
-    final override def underlying(implicit ctx: Context) = resType
-
     override def computeHash(bs: Binders) =
       doHash(new Binders(this, bs), paramNames, resType, paramInfos)
 
-    override def stableHash = resType.stableHash && paramInfos.stableHash
+    override def stableHash = {
+      if (myStableHash == 0) myStableHash = if (resType.stableHash && paramInfos.stableHash) 1 else -1
+      myStableHash > 0
+    }
 
     final override def equals(that: Any) = equals(that, null)
 
     // No definition of `eql` --> fall back on equals, which calls iso
 
     final override def iso(that: Any, bs: BinderPairs) = that match {
-      case that: HKLambda =>
+      case that: LambdaType =>
         paramNames.eqElements(that.paramNames) &&
         companion.eq(that.companion) && {
           val bs1 = new BinderPairs(this, that, bs)
@@ -2722,13 +2719,17 @@ object Types {
       case _ =>
         false
     }
+
+    protected def prefixString: String
+    final override def toString = s"$prefixString($paramNames, $paramInfos, $resType)"
   }
 
-  abstract class MethodOrPoly extends UncachedGroundType with LambdaType with MethodicType {
-    final override def hashCode = System.identityHashCode(this)
-    final override def equals(other: Any) = this `eq` other.asInstanceOf[AnyRef]
+  abstract class HKLambda extends CachedProxyType with LambdaType {
+    final override def underlying(implicit ctx: Context) = resType
   }
 
+  abstract class MethodOrPoly extends CachedGroundType with LambdaType with MethodicType
+
   trait TermLambda extends LambdaType { thisLambdaType =>
     import DepStatus._
     type ThisName = TermName

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

@@ -400,14 +400,11 @@ object ProtoTypes {
     /** Ensure that `tl` is not already in constraint, make a copy of necessary */
     def ensureFresh(tl: TypeLambda): TypeLambda =
       if (state.constraint contains tl) {
-      	var paramInfos = tl.paramInfos
-      	if (tl.isInstanceOf[HKLambda]) {
-      	  // HKLambdas care hash-consed, need to create an artificial difference by adding
-      	  // a LazyRef to a bound.
-          val TypeBounds(lo, hi) :: pinfos1 = tl.paramInfos
-          paramInfos = TypeBounds(lo, LazyRef(_ => hi)) :: pinfos1
-        }
-        ensureFresh(tl.newLikeThis(tl.paramNames, paramInfos, tl.resultType))
+      	// Type lambdas are hash-consed, need to create an artificial difference by adding
+      	// a LazyRef to a bound.
+        val TypeBounds(lo, hi) :: pinfos1 = tl.paramInfos
+        val newParamInfos = TypeBounds(lo, LazyRef(_ => hi)) :: pinfos1
+        ensureFresh(tl.newLikeThis(tl.paramNames, newParamInfos, tl.resultType))
       }
       else tl
     val added = ensureFresh(tl)