Reorder pattern match based on frequency

transformUnnamed total number of matches when compiling
the dotty bootstrapped compiler
(Apply,988737)
(TypeTree,938211)
(Thicket,314168)
(This,258670)
(Literal,207556)
(Block,200439)
(TypeApply,142962)
(If,86724)
(New,51117)
(Typed,43350)
(CaseDef,41226)
(Closure,31121)
(Assign,29101)
(SeqLiteral,24646)
(Super,19849)
(Template,18180)
(Match,11466)
(default,10334)
(UnApply,9327)
(PackageDef,6392)
(Try,1655)
(Inlined,1528)
(Return,1255)
(Alternative,659)

Author: nicolasstucki

compiler/src/dotty/tools/dotc/transform/TreeTransform.scala

@@ -974,13 +974,6 @@ object TreeTransforms {
             val qual = transform(tree.qualifier, mutatedInfo, cur)
             goSelect(cpy.Select(tree)(qual, tree.name), mutatedInfo.nx.nxTransSelect(cur))
           }
-        case tree: Bind =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForBind, info.nx.nxPrepBind, tree, cur)
-          if (mutatedInfo eq null) tree
-          else {
-            val body = transform(tree.body, mutatedInfo, cur)
-            goBind(cpy.Bind(tree)(tree.name, body), mutatedInfo.nx.nxTransBind(cur))
-          }
         case tree: ValDef if !tree.isEmpty => // As a result of discussing with Martin: emptyValDefs shouldn't be copied // NAME
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForValDef, info.nx.nxPrepValDef, tree, cur)
           if (mutatedInfo eq null) tree
@@ -1008,23 +1001,19 @@ object TreeTransforms {
             val rhs = transform(tree.rhs, mutatedInfo, cur)(localContext(tree.symbol))
             goTypeDef(cpy.TypeDef(tree)(tree.name, rhs), mutatedInfo.nx.nxTransTypeDef(cur))
           }
+        case tree: Bind =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForBind, info.nx.nxPrepBind, tree, cur)
+          if (mutatedInfo eq null) tree
+          else {
+            val body = transform(tree.body, mutatedInfo, cur)
+            goBind(cpy.Bind(tree)(tree.name, body), mutatedInfo.nx.nxTransBind(cur))
+          }
         case _ =>
           tree
       }
 
     final private[TreeTransforms] def transformUnnamed(tree: Tree, info: TransformerInfo, cur: Int)(implicit ctx: Context): Tree =
       tree match {
-        case tree: This =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForThis, info.nx.nxPrepThis, tree, cur)
-          if (mutatedInfo eq null) tree
-          else goThis(tree, mutatedInfo.nx.nxTransThis(cur))
-        case tree: Super =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForSuper, info.nx.nxPrepSuper, tree, cur)
-          if (mutatedInfo eq null) tree
-          else {
-            val qual = transform(tree.qual, mutatedInfo, cur)
-            goSuper(cpy.Super(tree)(qual, tree.mix), mutatedInfo.nx.nxTransSuper(cur))
-          }
         case tree: Apply =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForApply, info.nx.nxPrepApply, tree, cur)
           if (mutatedInfo eq null) tree
@@ -1033,6 +1022,28 @@ object TreeTransforms {
             val args = transformSubTrees(tree.args, mutatedInfo, cur)
             goApply(cpy.Apply(tree)(fun, args), mutatedInfo.nx.nxTransApply(cur))
           }
+        case tree: TypeTree =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTypeTree, info.nx.nxPrepTypeTree, tree, cur)
+          if (mutatedInfo eq null) tree
+          else goTypeTree(tree, mutatedInfo.nx.nxTransTypeTree(cur))
+        case Thicket(trees) =>
+          cpy.Thicket(tree)(transformTrees(trees, info, cur))
+        case tree: This =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForThis, info.nx.nxPrepThis, tree, cur)
+          if (mutatedInfo eq null) tree
+          else goThis(tree, mutatedInfo.nx.nxTransThis(cur))
+        case tree: Literal =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForLiteral, info.nx.nxPrepLiteral, tree, cur)
+          if (mutatedInfo eq null) tree
+          else goLiteral(tree, mutatedInfo.nx.nxTransLiteral(cur))
+        case tree: Block =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForBlock, info.nx.nxPrepBlock, tree, cur)
+          if (mutatedInfo eq null) tree
+          else {
+            val stats = transformStats(tree.stats, ctx.owner, mutatedInfo, cur)
+            val expr = transform(tree.expr, mutatedInfo, cur)
+            goBlock(cpy.Block(tree)(stats, expr), mutatedInfo.nx.nxTransBlock(cur))
+          }
         case tree: TypeApply =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTypeApply, info.nx.nxPrepTypeApply, tree, cur)
           if (mutatedInfo eq null) tree
@@ -1041,10 +1052,15 @@ object TreeTransforms {
             val args = transformTrees(tree.args, mutatedInfo, cur)
             goTypeApply(cpy.TypeApply(tree)(fun, args), mutatedInfo.nx.nxTransTypeApply(cur))
           }
-        case tree: Literal =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForLiteral, info.nx.nxPrepLiteral, tree, cur)
+        case tree: If =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForIf, info.nx.nxPrepIf, tree, cur)
           if (mutatedInfo eq null) tree
-          else goLiteral(tree, mutatedInfo.nx.nxTransLiteral(cur))
+          else {
+            val cond = transform(tree.cond, mutatedInfo, cur)
+            val thenp = transform(tree.thenp, mutatedInfo, cur)
+            val elsep = transform(tree.elsep, mutatedInfo, cur)
+            goIf(cpy.If(tree)(cond, thenp, elsep), mutatedInfo.nx.nxTransIf(cur))
+          }
         case tree: New =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForNew, info.nx.nxPrepNew, tree, cur)
           if (mutatedInfo eq null) tree
@@ -1060,6 +1076,24 @@ object TreeTransforms {
             val tpt = transform(tree.tpt, mutatedInfo, cur)
             goTyped(cpy.Typed(tree)(expr, tpt), mutatedInfo.nx.nxTransTyped(cur))
           }
+        case tree: CaseDef =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForCaseDef, info.nx.nxPrepCaseDef, tree, cur)
+          if (mutatedInfo eq null) tree
+          else {
+            val pat = transform(tree.pat, mutatedInfo, cur)(ctx.addMode(Mode.Pattern))
+            val guard = transform(tree.guard, mutatedInfo, cur)
+            val body = transform(tree.body, mutatedInfo, cur)
+            goCaseDef(cpy.CaseDef(tree)(pat, guard, body), mutatedInfo.nx.nxTransCaseDef(cur))
+          }
+        case tree: Closure =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForClosure, info.nx.nxPrepClosure, tree, cur)
+          if (mutatedInfo eq null) tree
+          else {
+            val env = transformTrees(tree.env, mutatedInfo, cur)
+            val meth = transform(tree.meth, mutatedInfo, cur)
+            val tpt = transform(tree.tpt, mutatedInfo, cur)
+            goClosure(cpy.Closure(tree)(env, meth, tpt), mutatedInfo.nx.nxTransClosure(cur))
+          }
         case tree: Assign =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForAssign, info.nx.nxPrepAssign, tree, cur)
           if (mutatedInfo eq null) tree
@@ -1068,31 +1102,30 @@ object TreeTransforms {
             val rhs = transform(tree.rhs, mutatedInfo, cur)
             goAssign(cpy.Assign(tree)(lhs, rhs), mutatedInfo.nx.nxTransAssign(cur))
           }
-        case tree: Block =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForBlock, info.nx.nxPrepBlock, tree, cur)
+        case tree: SeqLiteral =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForSeqLiteral, info.nx.nxPrepSeqLiteral, tree, cur)
           if (mutatedInfo eq null) tree
           else {
-            val stats = transformStats(tree.stats, ctx.owner, mutatedInfo, cur)
-            val expr = transform(tree.expr, mutatedInfo, cur)
-            goBlock(cpy.Block(tree)(stats, expr), mutatedInfo.nx.nxTransBlock(cur))
+            val elems = transformTrees(tree.elems, mutatedInfo, cur)
+            val elemtpt = transform(tree.elemtpt, mutatedInfo, cur)
+            goSeqLiteral(cpy.SeqLiteral(tree)(elems, elemtpt), mutatedInfo.nx.nxTransSeqLiteral(cur))
           }
-        case tree: If =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForIf, info.nx.nxPrepIf, tree, cur)
+        case tree: Super =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForSuper, info.nx.nxPrepSuper, tree, cur)
           if (mutatedInfo eq null) tree
           else {
-            val cond = transform(tree.cond, mutatedInfo, cur)
-            val thenp = transform(tree.thenp, mutatedInfo, cur)
-            val elsep = transform(tree.elsep, mutatedInfo, cur)
-            goIf(cpy.If(tree)(cond, thenp, elsep), mutatedInfo.nx.nxTransIf(cur))
+            val qual = transform(tree.qual, mutatedInfo, cur)
+            goSuper(cpy.Super(tree)(qual, tree.mix), mutatedInfo.nx.nxTransSuper(cur))
           }
-        case tree: Closure =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForClosure, info.nx.nxPrepClosure, tree, cur)
+        case tree: Template =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTemplate, info.nx.nxPrepTemplate, tree, cur)
           if (mutatedInfo eq null) tree
           else {
-            val env = transformTrees(tree.env, mutatedInfo, cur)
-            val meth = transform(tree.meth, mutatedInfo, cur)
-            val tpt = transform(tree.tpt, mutatedInfo, cur)
-            goClosure(cpy.Closure(tree)(env, meth, tpt), mutatedInfo.nx.nxTransClosure(cur))
+            val constr = transformSub(tree.constr, mutatedInfo, cur)
+            val parents = transformTrees(tree.parents, mutatedInfo, cur)(ctx.superCallContext)
+            val self = transformSub(tree.self, mutatedInfo, cur)
+            val body = transformStats(tree.body, tree.symbol, mutatedInfo, cur)
+            goTemplate(cpy.Template(tree)(constr, parents, self, body), mutatedInfo.nx.nxTransTemplate(cur))
           }
         case tree: Match =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForMatch, info.nx.nxPrepMatch, tree, cur)
@@ -1102,26 +1135,23 @@ object TreeTransforms {
             val cases = transformSubTrees(tree.cases, mutatedInfo, cur)
             goMatch(cpy.Match(tree)(selector, cases), mutatedInfo.nx.nxTransMatch(cur))
           }
-        case tree: CaseDef =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForCaseDef, info.nx.nxPrepCaseDef, tree, cur)
+        case tree: UnApply =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForUnApply, info.nx.nxPrepUnApply, tree, cur)
           if (mutatedInfo eq null) tree
           else {
-            val pat = transform(tree.pat, mutatedInfo, cur)(ctx.addMode(Mode.Pattern))
-            val guard = transform(tree.guard, mutatedInfo, cur)
-            val body = transform(tree.body, mutatedInfo, cur)
-            goCaseDef(cpy.CaseDef(tree)(pat, guard, body), mutatedInfo.nx.nxTransCaseDef(cur))
+            val fun = transform(tree.fun, mutatedInfo, cur)
+            val implicits = transformTrees(tree.implicits, mutatedInfo, cur)
+            val patterns = transformTrees(tree.patterns, mutatedInfo, cur)
+            goUnApply(cpy.UnApply(tree)(fun, implicits, patterns), mutatedInfo.nx.nxTransUnApply(cur))
           }
-        case tree: Return =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForReturn, info.nx.nxPrepReturn, tree, cur)
+        case tree: PackageDef =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForPackageDef, info.nx.nxPrepPackageDef, tree, cur)
           if (mutatedInfo eq null) tree
           else {
-            val expr = transform(tree.expr, mutatedInfo, cur)
-            val from = tree.from
-              // don't transform the `from` part, as this is not a normal ident, but
-              // a pointer to the enclosing method. Transforming this as a normal ident
-              // can go wrong easily. If a transformation is needed, it should be
-              // the responsibility of the transformReturn method to handle this also.
-            goReturn(cpy.Return(tree)(expr, from), mutatedInfo.nx.nxTransReturn(cur))
+            val nestedCtx = localContext(tree.symbol)
+            val pid = transformSub(tree.pid, mutatedInfo, cur)
+            val stats = transformStats(tree.stats, tree.symbol, mutatedInfo, cur)(nestedCtx)
+            goPackageDef(cpy.PackageDef(tree)(pid, stats), mutatedInfo.nx.nxTransPackageDef(cur))
           }
         case tree: Try =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTry, info.nx.nxPrepTry, tree, cur)
@@ -1132,14 +1162,6 @@ object TreeTransforms {
             val finalizer = transform(tree.finalizer, mutatedInfo, cur)
             goTry(cpy.Try(tree)(block, cases1, finalizer), mutatedInfo.nx.nxTransTry(cur))
           }
-        case tree: SeqLiteral =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForSeqLiteral, info.nx.nxPrepSeqLiteral, tree, cur)
-          if (mutatedInfo eq null) tree
-          else {
-            val elems = transformTrees(tree.elems, mutatedInfo, cur)
-            val elemtpt = transform(tree.elemtpt, mutatedInfo, cur)
-            goSeqLiteral(cpy.SeqLiteral(tree)(elems, elemtpt), mutatedInfo.nx.nxTransSeqLiteral(cur))
-          }
         case tree: Inlined =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForInlined, info.nx.nxPrepInlined, tree, cur)
           if (mutatedInfo eq null) tree
@@ -1148,47 +1170,25 @@ object TreeTransforms {
             val expansion = transform(tree.expansion, mutatedInfo, cur)(inlineContext(tree))
             goInlined(cpy.Inlined(tree)(tree.call, bindings, expansion), mutatedInfo.nx.nxTransInlined(cur))
           }
-        case tree: TypeTree =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTypeTree, info.nx.nxPrepTypeTree, tree, cur)
+        case tree: Return =>
+          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForReturn, info.nx.nxPrepReturn, tree, cur)
           if (mutatedInfo eq null) tree
-          else goTypeTree(tree, mutatedInfo.nx.nxTransTypeTree(cur))
+          else {
+            val expr = transform(tree.expr, mutatedInfo, cur)
+            val from = tree.from
+              // don't transform the `from` part, as this is not a normal ident, but
+              // a pointer to the enclosing method. Transforming this as a normal ident
+              // can go wrong easily. If a transformation is needed, it should be
+              // the responsibility of the transformReturn method to handle this also.
+            goReturn(cpy.Return(tree)(expr, from), mutatedInfo.nx.nxTransReturn(cur))
+          }
         case tree: Alternative =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForAlternative, info.nx.nxPrepAlternative, tree, cur)
           if (mutatedInfo eq null) tree
           else {
             val trees = transformTrees(tree.trees, mutatedInfo, cur)
             goAlternative(cpy.Alternative(tree)(trees), mutatedInfo.nx.nxTransAlternative(cur))
           }
-        case tree: UnApply =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForUnApply, info.nx.nxPrepUnApply, tree, cur)
-          if (mutatedInfo eq null) tree
-          else {
-            val fun = transform(tree.fun, mutatedInfo, cur)
-            val implicits = transformTrees(tree.implicits, mutatedInfo, cur)
-            val patterns = transformTrees(tree.patterns, mutatedInfo, cur)
-            goUnApply(cpy.UnApply(tree)(fun, implicits, patterns), mutatedInfo.nx.nxTransUnApply(cur))
-          }
-        case tree: Template =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTemplate, info.nx.nxPrepTemplate, tree, cur)
-          if (mutatedInfo eq null) tree
-          else {
-            val constr = transformSub(tree.constr, mutatedInfo, cur)
-            val parents = transformTrees(tree.parents, mutatedInfo, cur)(ctx.superCallContext)
-            val self = transformSub(tree.self, mutatedInfo, cur)
-            val body = transformStats(tree.body, tree.symbol, mutatedInfo, cur)
-            goTemplate(cpy.Template(tree)(constr, parents, self, body), mutatedInfo.nx.nxTransTemplate(cur))
-          }
-        case tree: PackageDef =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForPackageDef, info.nx.nxPrepPackageDef, tree, cur)
-          if (mutatedInfo eq null) tree
-          else {
-            val nestedCtx = localContext(tree.symbol)
-            val pid = transformSub(tree.pid, mutatedInfo, cur)
-            val stats = transformStats(tree.stats, tree.symbol, mutatedInfo, cur)(nestedCtx)
-            goPackageDef(cpy.PackageDef(tree)(pid, stats), mutatedInfo.nx.nxTransPackageDef(cur))
-          }
-        case Thicket(trees) =>
-          cpy.Thicket(tree)(transformTrees(trees, info, cur))
         case tree =>
           implicit val originalInfo: TransformerInfo = info
           goOther(tree, info.nx.nxTransOther(cur))