Hash-cons all lambda types

Author: odersky

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

@@ -0,0 +1,36 @@
+package dotty.tools.dotc
+package core
+
+import annotation.tailrec
+import Types._
+
+class StructEquality(binders1: Array[BindingType], binders2: Array[BindingType]) {
+
+  def equals(tp1: Type, tp2: Any): Boolean = (tp1 `eq` tp2.asInstanceOf[AnyRef]) || tp1.iso(tp2, this)
+
+  @tailrec final def equals(tps1: List[Type], tps2: List[Type]): Boolean =
+    (tps1 `eq` tps2) || {
+      if (tps1.isEmpty) tps2.isEmpty
+      else tps2.nonEmpty && equals(tps1.head, tps2.head) && equals(tps1.tail, tps2.tail)
+    }
+
+  final def equalBinders(tp1: BindingType, tp2: BindingType): Boolean =
+    (tp1 `eq` tp2) || {
+      var idx = 0
+      while (idx < binders1.length && (tp1 `ne` binders1(idx)))
+        idx += 1
+      idx < binders2.length && (tp2 `eq` binders2(idx))
+    }
+
+  final def withBinders(binder1: BindingType, binder2: BindingType): StructEquality = {
+    val newBinders1 = new Array[BindingType](binders1.length + 1)
+    val newBinders2 = new Array[BindingType](binders2.length + 1)
+    Array.copy(binders1, 0, newBinders1, 0, binders1.length)
+    Array.copy(binders2, 0, newBinders2, 0, binders2.length)
+    newBinders1(binders1.length) = binder1
+    newBinders2(binders1.length) = binder2
+    new StructEquality(newBinders1, newBinders2)
+  }
+}
+
+object StructEquality extends StructEquality(Array(), Array())

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"
   }