More extensive stats

Author: odersky

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/Types.scala

@@ -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/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 {