Merge pull request #3217 from dotty-staging/try-optimize-2

Some more optimizations

Author: smarter

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -1114,6 +1114,8 @@ object Trees {
     abstract class TreeMap(val cpy: TreeCopier = inst.cpy) {
 
       def transform(tree: Tree)(implicit ctx: Context): Tree = {
+        Stats.record(s"TreeMap.transform $getClass")
+        Stats.record("TreeMap.transform total")
         def localCtx =
           if (tree.hasType && tree.symbol.exists) ctx.withOwner(tree.symbol) else ctx
 
@@ -1228,6 +1230,8 @@ object Trees {
 
       def apply(x: X, trees: Traversable[Tree])(implicit ctx: Context): X = (x /: trees)(apply)
       def foldOver(x: X, tree: Tree)(implicit ctx: Context): X = {
+        Stats.record(s"TreeAccumulator.foldOver $getClass")
+        Stats.record("TreeAccumulator.foldOver total")
         def localCtx =
           if (tree.hasType && tree.symbol.exists) ctx.withOwner(tree.symbol) else ctx
         tree match {

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

@@ -484,8 +484,6 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       // constructor method should not be semi-erased.
       else if (isConstructor && isDerivedValueClass(sym)) eraseNormalClassRef(tp)
       else this(tp)
-    case RefinedType(parent, _, _) if !(parent isRef defn.ArrayClass) => // @!!!
-      eraseResult(parent)
     case AppliedType(tycon, _) if !(tycon isRef defn.ArrayClass) =>
       eraseResult(tycon)
     case _ =>

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

@@ -1157,7 +1157,7 @@ object Types {
     /** The full parent types, including all type arguments */
     def parents(implicit ctx: Context): List[Type] = this match {
       case tp @ AppliedType(tycon, args) if tycon.typeSymbol.isClass =>
-        tycon.parents.map(_.subst(tycon.typeSymbol.typeParams, args)) // @!!! cache?
+        tycon.parents.map(_.subst(tycon.typeSymbol.typeParams, args))
       case tp: TypeRef =>
         if (tp.info.isInstanceOf[TempClassInfo]) {
           tp.reloadDenot()
@@ -3720,6 +3720,8 @@ object Types {
 
     /** Map this function over given type */
     def mapOver(tp: Type): Type = {
+      record(s"mapOver ${getClass}")
+      record("mapOver total")
       implicit val ctx = this.ctx
       tp match {
         case tp: NamedType =>
@@ -4095,7 +4097,10 @@ object Types {
     protected final def applyToPrefix(x: T, tp: NamedType) =
       atVariance(variance max 0)(this(x, tp.prefix)) // see remark on NamedType case in TypeMap
 
-    def foldOver(x: T, tp: Type): T = tp match {
+    def foldOver(x: T, tp: Type): T = {
+      record(s"foldOver $getClass")
+      record(s"foldOver total")
+      tp match {
       case tp: TypeRef =>
         if (stopAtStatic && tp.symbol.isStatic) x
         else {
@@ -4184,7 +4189,7 @@ object Types {
         tp.fold(x, this)
 
       case _ => x
-    }
+    }}
 
     @tailrec final def foldOver(x: T, ts: List[Type]): T = ts match {
       case t :: ts1 => foldOver(apply(x, t), ts1)

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

@@ -36,7 +36,7 @@ class LinkAll extends MiniPhaseTransform {
     }
 
     if (ctx.settings.XlinkOptimise.value) super.runOn(allUnits(Set.empty, units.toSet, Set.empty))
-    else super.runOn(units)
+    else units
   }
 
   /** Collects all class denotations that may need to be loaded. */

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

@@ -1183,6 +1183,7 @@ object TreeTransforms {
     def transform(tree: Tree, info: TransformerInfo, cur: Int)(implicit ctx: Context): Tree = ctx.traceIndented(s"transforming ${tree.show} at ${ctx.phase}", transforms, show = true) {
       try
         if (cur < info.transformers.length) {
+          util.Stats.record("TreeTransform.transform")
           // if cur > 0 then some of the symbols can be created by already performed transformations
           // this means that their denotations could not exists in previous period
           val pctx = ctx.withPhase(info.transformers(cur).treeTransformPhase)

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1687,6 +1687,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   def typed(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = /*>|>*/ ctx.traceIndented (i"typing $tree", typr, show = true) /*<|<*/ {
+    record(s"typed $getClass")
+    record("typed total")
     assertPositioned(tree)
     try adapt(typedUnadapted(tree, pt), pt)
     catch {