Refactorings for efficiency

 - split LambdaType.equals into two equals so that tests
   are more specific (also avoids type testing against
   a trait)
 - re-order cases in some pattern matches with the aim to
   (1) move common cases earlier, (2) move more expensive
   trait type tests later.

Author: odersky

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

@@ -1141,13 +1141,13 @@ object SymDenotations {
       case tp: NamedType => hasSkolems(tp.prefix)
       case tp: RefinedType => hasSkolems(tp.parent) || hasSkolems(tp.refinedInfo)
       case tp: RecType => hasSkolems(tp.parent)
-      case tp: LambdaType => tp.paramInfos.exists(hasSkolems) || hasSkolems(tp.resType)
+      case tp: TypeBounds => hasSkolems(tp.lo) || hasSkolems(tp.hi)
+      case tp: TypeVar => hasSkolems(tp.inst)
       case tp: ExprType => hasSkolems(tp.resType)
       case tp: HKApply => hasSkolems(tp.tycon) || tp.args.exists(hasSkolems)
+      case tp: LambdaType => tp.paramInfos.exists(hasSkolems) || hasSkolems(tp.resType)
       case tp: AndOrType => hasSkolems(tp.tp1) || hasSkolems(tp.tp2)
-      case tp: TypeBounds => hasSkolems(tp.lo) || hasSkolems(tp.hi)
       case tp: AnnotatedType => hasSkolems(tp.tpe)
-      case tp: TypeVar => hasSkolems(tp.inst)
       case _ => false
     }
 

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

@@ -2389,27 +2389,40 @@ 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
+
+    final override def computeHash = doHash(paramNames, resType, paramInfos)
+
+    // Defined here instead of in LambdaType for efficiency
     final override def equals(that: Any) = that match {
-      case that: LambdaType =>
+      case that: HKLambda =>
         this.paramNames == that.paramNames &&
         this.paramInfos == that.paramInfos &&
         this.resType == that.resType &&
         (this.companion eq that.companion)
       case _ =>
         false
     }
-
-    protected def prefixString: String
-    final override def toString = s"$prefixString($paramNames, $paramInfos, $resType)"
-  }
-
-  abstract class HKLambda extends CachedProxyType with LambdaType {
-    final override def computeHash = doHash(paramNames, resType, paramInfos)
-    final override def underlying(implicit ctx: Context) = resType
   }
 
   abstract class MethodOrPoly extends CachedGroundType with LambdaType with TermType {
     final override def computeHash = doHash(paramNames, resType, paramInfos)
+
+    // Defined here instead of in LambdaType for efficiency
+    final override def equals(that: Any) = that match {
+      case that: MethodOrPoly =>
+        this.paramNames == that.paramNames &&
+        this.paramInfos == that.paramInfos &&
+        this.resType == that.resType &&
+        (this.companion eq that.companion)
+      case _ =>
+        false
+    }
   }
 
   trait TermLambda extends LambdaType { thisLambdaType =>
@@ -3539,6 +3552,26 @@ object Types {
           variance = -variance
           derivedTypeBounds(tp, lo1, this(tp.hi))
 
+        case tp: RecType =>
+          derivedRecType(tp, this(tp.parent))
+
+        case tp: TypeVar =>
+          val inst = tp.instanceOpt
+          if (inst.exists) apply(inst) else tp
+
+        case tp: HKApply =>
+          def mapArg(arg: Type, tparam: ParamInfo): Type = {
+            val saved = variance
+            variance *= tparam.paramVariance
+            try this(arg)
+            finally variance = saved
+          }
+          derivedAppliedType(tp, this(tp.tycon),
+              tp.args.zipWithConserve(tp.typeParams)(mapArg))
+
+        case tp: ExprType =>
+          derivedExprType(tp, this(tp.resultType))
+
         case tp: LambdaType =>
           def mapOverLambda = {
             variance = -variance
@@ -3548,12 +3581,6 @@ object Types {
           }
           mapOverLambda
 
-        case tp: ExprType =>
-          derivedExprType(tp, this(tp.resultType))
-
-        case tp: RecType =>
-          derivedRecType(tp, this(tp.parent))
-
         case tp @ SuperType(thistp, supertp) =>
           derivedSuperType(tp, this(thistp), this(supertp))
 
@@ -3563,21 +3590,7 @@ object Types {
         case tp: ClassInfo =>
           mapClassInfo(tp)
 
-        case tp: TypeVar =>
-          val inst = tp.instanceOpt
-          if (inst.exists) apply(inst) else tp
-
-        case tp: HKApply =>
-          def mapArg(arg: Type, tparam: ParamInfo): Type = {
-            val saved = variance
-            variance *= tparam.paramVariance
-            try this(arg)
-            finally variance = saved
-          }
-          derivedAppliedType(tp, this(tp.tycon),
-              tp.args.zipWithConserve(tp.typeParams)(mapArg))
-
-        case tp: AndOrType =>
+         case tp: AndOrType =>
           derivedAndOrType(tp, this(tp.tp1), this(tp.tp2))
 
         case tp: SkolemType =>
@@ -3758,17 +3771,14 @@ object Types {
           this(y, hi)
         }
 
-      case tp: LambdaType =>
-        variance = -variance
-        val y = foldOver(x, tp.paramInfos)
-        variance = -variance
-        this(y, tp.resultType)
+      case tp: RecType =>
+        this(x, tp.parent)
 
       case ExprType(restpe) =>
         this(x, restpe)
 
-      case tp: RecType =>
-        this(x, tp.parent)
+      case tp: TypeVar =>
+        this(x, tp.underlying)
 
       case SuperType(thistp, supertp) =>
         this(this(x, thistp), supertp)
@@ -3793,6 +3803,12 @@ object Types {
           }
         foldArgs(this(x, tycon), tp.typeParams, args)
 
+      case tp: LambdaType =>
+        variance = -variance
+        val y = foldOver(x, tp.paramInfos)
+        variance = -variance
+        this(y, tp.resultType)
+
       case tp: AndOrType =>
         this(this(x, tp.tp1), tp.tp2)
 
@@ -3802,9 +3818,6 @@ object Types {
       case AnnotatedType(underlying, annot) =>
         this(applyToAnnot(x, annot), underlying)
 
-      case tp: TypeVar =>
-        this(x, tp.underlying)
-
       case tp: WildcardType =>
         this(x, tp.optBounds)