Hash-cons all lambda types

Author: odersky

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

@@ -2356,11 +2356,6 @@ object Types {
 
     override def computeHash(h: Hashing) = h.withBinder(this).doHash(getClass, parent)
 
-    override def eql(that: Type) = that match {
-      case that: RecType => parent.eq(that.parent)
-      case _ => false
-    }
-
     override def iso(that: Any, e: StructEquality) = that match {
       case that: RecType =>
         e.withBinders(this, that).equals(parent, that.parent)
@@ -2684,37 +2679,51 @@ object Types {
     final override def toString = s"$prefixString($paramNames, $paramInfos, $resType)"
   }
 
+  /** Base class of HKTypeLambda. In the future could be base class of HKTermLambda
+   *  (aka typelevel function type) if that is added.
+   */
   abstract class HKLambda extends CachedProxyType with LambdaType {
     final override def underlying(implicit ctx: Context) = resType
 
     final override def computeHash(h: Hashing) =
       h.withBinder(this).doHash(getClass, paramNames, resType, paramInfos)
 
-    final override def eql(that: Type) = that match {
+    final override def iso(that: Any, e: StructEquality) = that match {
       case that: HKLambda =>
-        paramNames.equals(that.paramNames) &&
-        paramInfos.equals(that.paramInfos) &&
-        resType.equals(that.resType) &&
-        companion.eq(that.companion)
+        paramNames.eqElements(that.paramNames) &&
+        companion.eq(that.companion) && {
+          val e1 = e.withBinders(this, that)
+          e1.equals(paramInfos, that.paramInfos) &&
+          e1.equals(resType, that.resType)
+        }
       case _ =>
         false
     }
+  }
+
+  /** Common base class of MethodType and PolyType. It's methods are duplicated
+   *  from HKLambda for efficiency. Joining the two methods in the common supertrait
+   *  LambdaType could be slower because of trait dispatch and because the type test
+   *  in `iso` would be to a trait instead of a class
+   */
+  abstract class MethodOrPoly extends CachedGroundType with LambdaType with MethodicType {
+
+    final override def computeHash(h: Hashing) =
+      h.withBinder(this).doHash(getClass, paramNames, resType, paramInfos)
 
     final override def iso(that: Any, e: StructEquality) = that match {
-      case that: HKLambda =>
+      case that: MethodOrPoly =>
         paramNames.eqElements(that.paramNames) &&
         companion.eq(that.companion) && {
           val e1 = e.withBinders(this, that)
           e1.equals(paramInfos, that.paramInfos) &&
           e1.equals(resType, that.resType)
         }
-      case _ =>
+     case _ =>
         false
     }
   }
 
-  trait MethodOrPoly extends LambdaType with MethodicType // TODO: Make PolyTypes cached
-
   trait TermLambda extends LambdaType { thisLambdaType =>
     import DepStatus._
     type ThisName = TermName
@@ -2830,7 +2839,7 @@ object Types {
   abstract case class MethodType(paramNames: List[TermName])(
       paramInfosExp: MethodType => List[Type],
       resultTypeExp: MethodType => Type)
-    extends CachedGroundType with MethodOrPoly with TermLambda with NarrowCached { thisMethodType =>
+    extends MethodOrPoly with TermLambda with NarrowCached { thisMethodType =>
     import MethodType._
 
     type This = MethodType
@@ -2847,29 +2856,6 @@ object Types {
     def computeSignature(implicit ctx: Context): Signature =
       resultSignature.prepend(paramInfos, isJavaMethod)
 
-    final override def computeHash(h: Hashing) = h.doHash(getClass, paramNames, resType, paramInfos)
-
-    final override def eql(that: Type) = that match {
-      case that: MethodType =>
-        paramNames.eqElements(that.paramNames) &&
-        paramInfos.eqElements(that.paramInfos) &&
-        resType.eq(that.resType) &&
-        companion.eq(that.companion)
-      case _ =>
-        false
-    }
-
-    final override def iso(that: Any, e: StructEquality) = that match {
-      case that: MethodType =>
-        paramNames.eqElements(that.paramNames) &&
-        companion.eq(that.companion) && {
-          val e1 = e.withBinders(this, that)
-          e1.equals(paramInfos, that.paramInfos) &&
-          e1.equals(resType, that.resType)
-        }
-     case _ =>
-        false
-    }
 
     protected def prefixString = "MethodType"
   }
@@ -3028,7 +3014,7 @@ object Types {
    */
   class PolyType(val paramNames: List[TypeName])(
       paramInfosExp: PolyType => List[TypeBounds], resultTypeExp: PolyType => Type)
-  extends UncachedGroundType with MethodOrPoly with TypeLambda {
+  extends MethodOrPoly with TypeLambda {
 
     type This = PolyType
     def companion = PolyType
@@ -3059,18 +3045,6 @@ object Types {
       case _ => this
     }
 
-    final override def iso(that: Any, e: StructEquality) = that match { // TODO: Move up to MethodOrPoly
-      case that: PolyType =>
-        paramNames.eqElements(that.paramNames) &&
-        companion.eq(that.companion) && {
-          val e1 = e.withBinders(this, that)
-          e1.equals(paramInfos, that.paramInfos) &&
-          e1.equals(resType, that.resType)
-        }
-      case _ =>
-        false
-    }
-
     protected def prefixString = "PolyType"
   }