Reorder pattern match based on frequency

foldOver total number of matches when compiling
the dotty bootstrapped compiler

(TypeRef,880390)
(AppliedType,276595)
(BoundType,122879)
(ThisType,117388)
(LambdaType,95690)
(NoPrefix,94493)
(TermRef,88508)
(TypeVar,30322)
(ExprType,16702)
(TypeBounds,16432)
(AndOrType,6234)
(AnnotatedType,5948)
(default,5252)
(ProtoType,4044)
(RefinedType,3270)
(WildcardType,2064)
(ClassInfo,1520)
(JavaArrayType,516)
(SkolemType,210)
(TypeArgRef,98)
(SuperType,77)
(LazyRef,3)

Author: nicolasstucki

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

@@ -4198,13 +4198,6 @@ object Types {
           val tp1 = tp.prefix.lookupRefined(tp.name)
           if (tp1.exists) this(x, tp1) else applyToPrefix(x, tp)
         }
-      case tp: TermRef =>
-        if (stopAtStatic && tp.currentSymbol.isStatic) x
-        else applyToPrefix(x, tp)
-
-      case _: ThisType
-         | _: BoundType
-         | NoPrefix => x
 
       case tp @ AppliedType(tycon, args) =>
         @tailrec def foldArgs(x: T, tparams: List[ParamInfo], args: List[Type]): T =
@@ -4222,8 +4215,25 @@ object Types {
           }
         foldArgs(this(x, tycon), tp.typeParams, args)
 
-      case tp: RefinedType =>
-        this(this(x, tp.parent), tp.refinedInfo)
+      case _: BoundType | _: ThisType => x
+
+      case tp: LambdaType =>
+        variance = -variance
+        val y = foldOver(x, tp.paramInfos)
+        variance = -variance
+        this(y, tp.resultType)
+
+      case NoPrefix => x
+
+      case tp: TermRef =>
+        if (stopAtStatic && tp.currentSymbol.isStatic) x
+        else applyToPrefix(x, tp)
+
+      case tp: TypeVar =>
+        this(x, tp.underlying)
+
+      case ExprType(restpe) =>
+        this(x, restpe)
 
       case bounds @ TypeBounds(lo, hi) =>
         if (lo eq hi) atVariance(0)(this(x, lo))
@@ -4234,50 +4244,41 @@ object Types {
           this(y, hi)
         }
 
-      case tp: RecType =>
-        this(x, tp.parent)
+      case tp: AndOrType =>
+        this(this(x, tp.tp1), tp.tp2)
 
-      case ExprType(restpe) =>
-        this(x, restpe)
+      case AnnotatedType(underlying, annot) =>
+        this(applyToAnnot(x, annot), underlying)
 
-      case tp: TypeVar =>
-        this(x, tp.underlying)
+      case tp: ProtoType =>
+        tp.fold(x, this)
 
-      case SuperType(thistp, supertp) =>
-        this(this(x, thistp), supertp)
+      case tp: RefinedType =>
+        this(this(x, tp.parent), tp.refinedInfo)
+
+      case tp: WildcardType =>
+        this(x, tp.optBounds)
 
       case tp @ ClassInfo(prefix, _, _, _, _) =>
         this(x, prefix)
 
-      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)
+      case tp: JavaArrayType =>
+        this(x, tp.elemType)
 
       case tp: SkolemType =>
         this(x, tp.info)
 
       case tp @ TypeArgRef(prefix, _, _) =>
         atVariance(0)(this(x, prefix))
 
-      case AnnotatedType(underlying, annot) =>
-        this(applyToAnnot(x, annot), underlying)
-
-      case tp: WildcardType =>
-        this(x, tp.optBounds)
-
-      case tp: JavaArrayType =>
-        this(x, tp.elemType)
+      case SuperType(thistp, supertp) =>
+        this(this(x, thistp), supertp)
 
       case tp: LazyRef =>
         this(x, tp.ref)
 
-      case tp: ProtoType =>
-        tp.fold(x, this)
+      case tp: RecType =>
+        this(x, tp.parent)
 
       case _ => x
     }}