Statistics reorganization

Statistics were broken since the move to reflect.internal. They are now
re-organized, made more robost and modular.

10 files changed, 234 insertions, 325 deletions

diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 787c9c7f57..954e98742a 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -12,7 +12,7 @@ import scala.tools.util.PathResolver
 import scala.collection.{ mutable, immutable }
 import io.{ SourceReader, AbstractFile, Path }
 import reporters.{ Reporter, ConsoleReporter }
-import util.{ Exceptional, ClassPath, MergedClassPath, Statistics, StatisticsInfo, ScalaClassLoader, returning }
+import util.{ Exceptional, ClassPath, MergedClassPath, StatisticsInfo, ScalaClassLoader, returning }
 import scala.reflect.internal.util.{ NoPosition, SourceFile, NoSourceFile, BatchSourceFile, ScriptSourceFile }
 import scala.reflect.internal.pickling.{ PickleBuffer, PickleFormat }
 import settings.{ AestheticSettings }
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index 04acba06e8..9b223a13ba 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -160,7 +160,7 @@ trait ScalaSettings extends AbsScalaSettings
   val Ygenjavap       = StringSetting     ("-Ygen-javap", "dir", "Generate a parallel output directory of .javap files.", "")
   val Ydumpclasses    = StringSetting     ("-Ydump-classes", "dir", "Dump the generated bytecode to .class files (useful for reflective compilation that utilizes in-memory classloaders).", "")
   val Ynosqueeze      = BooleanSetting    ("-Yno-squeeze", "Disable creation of compact code in matching.")
-  val Ystatistics     = BooleanSetting    ("-Ystatistics", "Print compiler statistics.") andThen (util.Statistics.enabled = _)
+  val Ystatistics     = BooleanSetting    ("-Ystatistics", "Print compiler statistics.") andThen (scala.reflect.internal.util.Statistics.enabled = _)
   val stopAfter       = PhasesSetting     ("-Ystop-after", "Stop after") withAbbreviation ("-stop") // backward compat
   val stopBefore      = PhasesSetting     ("-Ystop-before", "Stop before")
   val refinementMethodDispatch
diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
index 15edac16d5..0c988ceae4 100644
--- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
+++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
@@ -12,7 +12,7 @@ import scala.tools.nsc.util.{ ClassPath }
 import classfile.ClassfileParser
 import reflect.internal.Flags._
 import reflect.internal.MissingRequirementError
-import util.Statistics._
+import reflect.internal.util.Statistics
 import scala.tools.nsc.io.{ AbstractFile, MsilFile }
 
 /** This class ...
@@ -23,6 +23,7 @@ import scala.tools.nsc.io.{ AbstractFile, MsilFile }
 abstract class SymbolLoaders {
   val global: Global
   import global._
+  import SymbolLoadersStats._
 
   protected def enterIfNew(owner: Symbol, member: Symbol, completer: SymbolLoader): Symbol = {
     assert(owner.info.decls.lookup(member.name) == NoSymbol, owner.fullName + "." + member.name)
@@ -236,7 +237,7 @@ abstract class SymbolLoaders {
     protected def description = "class file "+ classfile.toString
 
     protected def doComplete(root: Symbol) {
-      val start = startTimer(classReadNanos)
+      val start = Statistics.startTimer(classReadNanos)
       classfileParser.parse(classfile, root)
       if (root.associatedFile eq null) {
         root match {
@@ -248,7 +249,7 @@ abstract class SymbolLoaders {
             debuglog("Not setting associatedFile to %s because %s is a %s".format(classfile, root.name, root.shortSymbolClass))
         }
       }
-      stopTimer(classReadNanos, start)
+      Statistics.stopTimer(classReadNanos, start)
     }
     override def sourcefile: Option[AbstractFile] = classfileParser.srcfile
   }
@@ -284,3 +285,8 @@ abstract class SymbolLoaders {
   var parentsLevel = 0
   var pendingLoadActions: List[() => Unit] = Nil
 }
+
+object SymbolLoadersStats {
+  import reflect.internal.TypesStats.typerNanos
+  val classReadNanos = Statistics.newSubTimer  ("time classfilereading", typerNanos)
+}
diff --git a/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala b/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala
index a77df71312..2077ab0997 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala
@@ -6,7 +6,7 @@
 package scala.tools.nsc
 package typechecker
 
-import util.Statistics._
+import reflect.internal.util.Statistics
 
 /** The main attribution phase.
  */
@@ -72,6 +72,7 @@ trait Analyzer extends AnyRef
   }
 
   object typerFactory extends SubComponent {
+    import reflect.internal.TypesStats.typerNanos
     val global: Analyzer.this.global.type = Analyzer.this.global
     val phaseName = "typer"
     val runsAfter = List[String]()
@@ -84,13 +85,13 @@ trait Analyzer extends AnyRef
       // compiler run). This is good enough for the resident compiler, which was the most affected.
       undoLog.clear()
       override def run() {
-        val start = startTimer(typerNanos)
+        val start = Statistics.startTimer(typerNanos)
         global.echoPhaseSummary(this)
         currentRun.units foreach applyPhase
         undoLog.clear()
         // need to clear it after as well or 10K+ accumulated entries are
         // uncollectable the rest of the way.
-        stopTimer(typerNanos, start)
+        Statistics.stopTimer(typerNanos, start)
       }
       def apply(unit: CompilationUnit) {
         try {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 37380fd5c0..f7e00109ae 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -16,7 +16,7 @@ import scala.collection.{ mutable, immutable }
 import mutable.{ LinkedHashMap, ListBuffer }
 import scala.util.matching.Regex
 import symtab.Flags._
-import util.Statistics._
+import scala.reflect.internal.util.Statistics
 import language.implicitConversions
 
 /** This trait provides methods to find various kinds of implicits.
@@ -29,6 +29,7 @@ trait Implicits {
 
   import global._
   import definitions._
+  import ImplicitsStats._
   import typeDebug.{ ptTree, ptBlock, ptLine }
   import global.typer.{ printTyping, deindentTyping, indentTyping, printInference }
 
@@ -71,10 +72,10 @@ trait Implicits {
     )
     indentTyping()
 
-    val rawTypeStart    = startCounter(rawTypeImpl)
-    val findMemberStart = startCounter(findMemberImpl)
-    val subtypeStart    = startCounter(subtypeImpl)
-    val start = startTimer(implicitNanos)
+    val rawTypeStart    = Statistics.startCounter(rawTypeImpl)
+    val findMemberStart = Statistics.startCounter(findMemberImpl)
+    val subtypeStart    = Statistics.startCounter(subtypeImpl)
+    val start           = Statistics.startTimer(implicitNanos)
     if (printInfers && !tree.isEmpty && !context.undetparams.isEmpty)
       printTyping("typing implicit: %s %s".format(tree, context.undetparamsString))
     val implicitSearchContext = context.makeImplicit(reportAmbiguous)
@@ -86,10 +87,10 @@ trait Implicits {
     printInference("[infer implicit] inferred " + result)
     context.undetparams = context.undetparams filterNot result.subst.from.contains
 
-    stopTimer(implicitNanos, start)
-    stopCounter(rawTypeImpl, rawTypeStart)
-    stopCounter(findMemberImpl, findMemberStart)
-    stopCounter(subtypeImpl, subtypeStart)
+    Statistics.stopTimer(implicitNanos, start)
+    Statistics.stopCounter(rawTypeImpl, rawTypeStart)
+    Statistics.stopCounter(findMemberImpl, findMemberStart)
+    Statistics.stopCounter(subtypeImpl, subtypeStart)
     deindentTyping()
     printTyping("Implicit search yielded: "+ result)
     result
@@ -307,12 +308,12 @@ trait Implicits {
     /** Is implicit info `info1` better than implicit info `info2`?
      */
     def improves(info1: ImplicitInfo, info2: ImplicitInfo) = {
-      incCounter(improvesCount)
+      Statistics.incCounter(improvesCount)
       (info2 == NoImplicitInfo) ||
       (info1 != NoImplicitInfo) && {
         if (info1.sym.isStatic && info2.sym.isStatic) {
           improvesCache get (info1, info2) match {
-            case Some(b) => incCounter(improvesCachedCount); b
+            case Some(b) => Statistics.incCounter(improvesCachedCount); b
             case None =>
               val result = isStrictlyMoreSpecific(info1.tpe, info2.tpe, info1.sym, info2.sym)
               improvesCache((info1, info2)) = result
@@ -376,7 +377,7 @@ trait Implicits {
       overlaps(dtor1, dted1) && (dtor1 =:= dted1 || complexity(dtor1) > complexity(dted1))
     }
 
-    incCounter(implicitSearchCount)
+    Statistics.incCounter(implicitSearchCount)
 
     /** The type parameters to instantiate */
     val undetParams = if (isView) List() else context.outer.undetparams
@@ -428,7 +429,7 @@ trait Implicits {
      *  This method is performance critical: 5-8% of typechecking time.
      */
     private def matchesPt(tp: Type, pt: Type, undet: List[Symbol]): Boolean = {
-      val start = startTimer(matchesPtNanos)
+      val start = Statistics.startTimer(matchesPtNanos)
       val result = normSubType(tp, pt) || isView && {
         pt match {
           case TypeRef(_, Function1.Sym, args) =>
@@ -437,7 +438,7 @@ trait Implicits {
             false
         }
       }
-      stopTimer(matchesPtNanos, start)
+      Statistics.stopTimer(matchesPtNanos, start)
       result
     }
     private def matchesPt(info: ImplicitInfo): Boolean = (
@@ -536,7 +537,7 @@ trait Implicits {
     }
 
     private def typedImplicit0(info: ImplicitInfo, ptChecked: Boolean, isLocal: Boolean): SearchResult = {
-      incCounter(plausiblyCompatibleImplicits)
+      Statistics.incCounter(plausiblyCompatibleImplicits)
       printTyping (
         ptBlock("typedImplicit0",
           "info.name" -> info.name,
@@ -556,7 +557,7 @@ trait Implicits {
     }
 
     private def typedImplicit1(info: ImplicitInfo, isLocal: Boolean): SearchResult = {
-      incCounter(matchingImplicits)
+      Statistics.incCounter(matchingImplicits)
 
       val itree = atPos(pos.focus) {
         // workaround for deficient context provided by ModelFactoryImplicitSupport#makeImplicitConstraints
@@ -594,7 +595,7 @@ trait Implicits {
         if (context.hasErrors)
           return fail("typed implicit %s has errors".format(info.sym.fullLocationString))
 
-        incCounter(typedImplicits)
+        Statistics.incCounter(typedImplicits)
 
         printTyping("typed implicit %s:%s, pt=%s".format(itree1, itree1.tpe, wildPt))
         val itree2 = if (isView) (itree1: @unchecked) match { case Apply(fun, _) => fun }
@@ -677,7 +678,7 @@ trait Implicits {
               fail("typing TypeApply reported errors for the implicit tree")
             else {
               val result = new SearchResult(itree2, subst)
-              incCounter(foundImplicits)
+              Statistics.incCounter(foundImplicits)
               printInference("[success] found %s for pt %s".format(result, ptInstantiated))
               result
             }
@@ -904,11 +905,11 @@ trait Implicits {
      *  @return               map from infos to search results
      */
     def applicableInfos(iss: Infoss, isLocal: Boolean): Map[ImplicitInfo, SearchResult] = {
-      val start       = startCounter(subtypeAppInfos)
+      val start       = Statistics.startCounter(subtypeAppInfos)
       val computation = new ImplicitComputation(iss, isLocal) { }
       val applicable  = computation.findAll()
 
-      stopCounter(subtypeAppInfos, start)
+      Statistics.stopCounter(subtypeAppInfos, start)
       applicable
     }
 
@@ -1123,26 +1124,28 @@ trait Implicits {
      *  These are all implicits found in companion objects of classes C
      *  such that some part of `tp` has C as one of its superclasses.
      */
-    private def implicitsOfExpectedType: Infoss = implicitsCache get pt match {
-      case Some(implicitInfoss) =>
-        incCounter(implicitCacheHits)
-        implicitInfoss
-      case None                 =>
-        incCounter(implicitCacheMisses)
-        val start = startTimer(subtypeETNanos)
-//        val implicitInfoss = companionImplicits(pt)
-        val implicitInfoss1 = companionImplicitMap(pt).valuesIterator.toList
-//        val is1 = implicitInfoss.flatten.toSet
-//        val is2 = implicitInfoss1.flatten.toSet
-//        for (i <- is1)
-//          if (!(is2 contains i)) println("!!! implicit infos of "+pt+" differ, new does not contain "+i+",\nold: "+implicitInfoss+",\nnew: "+implicitInfoss1)
-//        for (i <- is2)
-//          if (!(is1 contains i)) println("!!! implicit infos of "+pt+" differ, old does not contain "+i+",\nold: "+implicitInfoss+",\nnew: "+implicitInfoss1)
-        stopTimer(subtypeETNanos, start)
-        implicitsCache(pt) = implicitInfoss1
-        if (implicitsCache.size >= sizeLimit)
-          implicitsCache -= implicitsCache.keysIterator.next
-        implicitInfoss1
+    private def implicitsOfExpectedType: Infoss = {
+      Statistics.incCounter(implicitCacheHits)
+      implicitsCache get pt match {
+        case Some(implicitInfoss) =>
+          Statistics.incCounter(implicitCacheHits)
+          implicitInfoss
+        case None =>
+          val start = Statistics.startTimer(subtypeETNanos)
+          //        val implicitInfoss = companionImplicits(pt)
+          val implicitInfoss1 = companionImplicitMap(pt).valuesIterator.toList
+          //        val is1 = implicitInfoss.flatten.toSet
+          //        val is2 = implicitInfoss1.flatten.toSet
+          //        for (i <- is1)
+          //          if (!(is2 contains i)) println("!!! implicit infos of "+pt+" differ, new does not contain "+i+",\nold: "+implicitInfoss+",\nnew: "+implicitInfoss1)
+          //        for (i <- is2)
+          //          if (!(is1 contains i)) println("!!! implicit infos of "+pt+" differ, old does not contain "+i+",\nold: "+implicitInfoss+",\nnew: "+implicitInfoss1)
+          Statistics.stopTimer(subtypeETNanos, start)
+          implicitsCache(pt) = implicitInfoss1
+          if (implicitsCache.size >= sizeLimit)
+            implicitsCache -= implicitsCache.keysIterator.next
+          implicitInfoss1
+      }
     }
 
     private def TagSymbols =  TagMaterializers.keySet
@@ -1368,30 +1371,30 @@ trait Implicits {
      *  If all fails return SearchFailure
      */
     def bestImplicit: SearchResult = {
-      val failstart = startTimer(inscopeFailNanos)
-      val succstart = startTimer(inscopeSucceedNanos)
+      val failstart = Statistics.startTimer(inscopeFailNanos)
+      val succstart = Statistics.startTimer(inscopeSucceedNanos)
 
       var result = searchImplicit(context.implicitss, true)
 
       if (result == SearchFailure) {
-        stopTimer(inscopeFailNanos, failstart)
+        Statistics.stopTimer(inscopeFailNanos, failstart)
       } else {
-        stopTimer(inscopeSucceedNanos, succstart)
-        incCounter(inscopeImplicitHits)
+        Statistics.stopTimer(inscopeSucceedNanos, succstart)
+        Statistics.incCounter(inscopeImplicitHits)
       }
       if (result == SearchFailure) {
         val previousErrs = context.flushAndReturnBuffer()
-        val failstart = startTimer(oftypeFailNanos)
-        val succstart = startTimer(oftypeSucceedNanos)
+        val failstart = Statistics.startTimer(oftypeFailNanos)
+        val succstart = Statistics.startTimer(oftypeSucceedNanos)
 
         result = implicitTagOrOfExpectedType(pt)
 
         if (result == SearchFailure) {
           context.updateBuffer(previousErrs)
-          stopTimer(oftypeFailNanos, failstart)
+          Statistics.stopTimer(oftypeFailNanos, failstart)
         } else {
-          stopTimer(oftypeSucceedNanos, succstart)
-          incCounter(oftypeImplicitHits)
+          Statistics.stopTimer(oftypeSucceedNanos, succstart)
+          Statistics.incCounter(oftypeImplicitHits)
         }
       }
 
@@ -1415,19 +1418,19 @@ trait Implicits {
         val eligible = new ImplicitComputation(iss, isLocal).eligible
         eligible.toList.flatMap {
           (ii: ImplicitInfo) =>
-            // each ImplicitInfo contributes a distinct set of constraints (generated indirectly by typedImplicit)
-            // thus, start each type var off with a fresh for every typedImplicit
-            resetTVars()
-            // any previous errors should not affect us now
-            context.flushBuffer()
+        // each ImplicitInfo contributes a distinct set of constraints (generated indirectly by typedImplicit)
+        // thus, start each type var off with a fresh for every typedImplicit
+        resetTVars()
+        // any previous errors should not affect us now
+        context.flushBuffer()
 
             val res = typedImplicit(ii, ptChecked = false, isLocal)
-            if (res.tree ne EmptyTree) List((res, tvars map (_.constr)))
-            else Nil
-        }
+        if (res.tree ne EmptyTree) List((res, tvars map (_.constr)))
+        else Nil
       }
-      eligibleInfos(context.implicitss, isLocal = true) ++ eligibleInfos(implicitsOfExpectedType, isLocal = false)
     }
+      eligibleInfos(context.implicitss, isLocal = true) ++ eligibleInfos(implicitsOfExpectedType, isLocal = false)
+  }
   }
 
   object ImplicitNotFoundMsg {
@@ -1472,5 +1475,37 @@ trait Implicits {
     }
   }
 }
+
+object ImplicitsStats {
+
+  import reflect.internal.TypesStats._
+
+  val rawTypeImpl         = Statistics.newSubCounter ("  of which in implicits", rawTypeCount)
+  val subtypeImpl         = Statistics.newSubCounter("  of which in implicit", subtypeCount)
+  val findMemberImpl      = Statistics.newSubCounter("  of which in implicit", findMemberCount)
+  val subtypeAppInfos     = Statistics.newSubCounter("  of which in app impl", subtypeCount)
+  val subtypeImprovCount  = Statistics.newSubCounter("  of which in improves", subtypeCount)
+  val implicitSearchCount = Statistics.newCounter   ("#implicit searches", "typer")
+  val triedImplicits      = Statistics.newSubCounter("  #tried", implicitSearchCount)
+  val plausiblyCompatibleImplicits
+                                  = Statistics.newSubCounter("  #plausibly compatible", implicitSearchCount)
+  val matchingImplicits   = Statistics.newSubCounter("  #matching", implicitSearchCount)
+  val typedImplicits      = Statistics.newSubCounter("  #typed", implicitSearchCount)
+  val foundImplicits      = Statistics.newSubCounter("  #found", implicitSearchCount)
+  val improvesCount       = Statistics.newSubCounter("implicit improves tests", implicitSearchCount)
+  val improvesCachedCount = Statistics.newSubCounter("#implicit improves cached ", implicitSearchCount)
+  val inscopeImplicitHits = Statistics.newSubCounter("#implicit inscope hits", implicitSearchCount)
+  val oftypeImplicitHits  = Statistics.newSubCounter("#implicit oftype hits ", implicitSearchCount)
+  val implicitNanos       = Statistics.newSubTimer  ("time spent in implicits", typerNanos)
+  val inscopeSucceedNanos = Statistics.newSubTimer  ("  successful in scope", typerNanos)
+  val inscopeFailNanos    = Statistics.newSubTimer  ("  failed in scope", typerNanos)
+  val oftypeSucceedNanos  = Statistics.newSubTimer  ("  successful of type", typerNanos)
+  val oftypeFailNanos     = Statistics.newSubTimer  ("  failed of type", typerNanos)
+  val subtypeETNanos      = Statistics.newSubTimer  ("  assembling parts", typerNanos)
+  val matchesPtNanos      = Statistics.newSubTimer  ("  matchesPT", typerNanos)
+  val implicitCacheAccs   = Statistics.newCounter   ("implicit cache accesses", "typer")
+  val implicitCacheHits   = Statistics.newSubCounter("implicit cache hits", implicitCacheAccs)
+}
+
 class DivergentImplicit extends Exception
 object DivergentImplicit extends DivergentImplicit
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index ec14476d1a..d157666e47 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -7,7 +7,7 @@ import scala.tools.nsc.util.ClassPath._
 import scala.reflect.runtime.ReflectionUtils
 import scala.collection.mutable.ListBuffer
 import scala.compat.Platform.EOL
-import util.Statistics._
+import reflect.internal.util.Statistics
 import scala.reflect.makro.util._
 import java.lang.{Class => jClass}
 import java.lang.reflect.{Array => jArray, Method => jMethod}
@@ -42,6 +42,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
 
   import global._
   import definitions._
+  import MacrosStats._
   def globalSettings = global.settings
 
   val globalMacroCache = collection.mutable.Map[Any, Any]()
@@ -945,8 +946,8 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
       this.fail(typer, tree, err.errPos, "failed to %s: %s".format(what, err.errMsg))
       return expandee
     }
-    val start = startTimer(macroExpandNanos)
-    incCounter(macroExpandCount)
+    val start = Statistics.startTimer(macroExpandNanos)
+    Statistics.incCounter(macroExpandCount)
     try {
       macroExpand1(typer, expandee) match {
         case Success(expanded0) =>
@@ -993,7 +994,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
           result
       }
     } finally {
-      stopTimer(macroExpandNanos, start)
+      Statistics.stopTimer(macroExpandNanos, start)
     }
   }
 
@@ -1292,3 +1293,9 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
       })
     }.transform(expandee)
 }
+
+object MacrosStats {
+  import reflect.internal.TypesStats.typerNanos
+  val macroExpandCount    = Statistics.newCounter ("#macro expansions", "typer")
+  val macroExpandNanos    = Statistics.newSubTimer("time spent in macroExpand", typerNanos)
+}
diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
index 4e8f416b16..9b8ddffb49 100644
--- a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
@@ -14,7 +14,7 @@ import scala.tools.nsc.transform.TypingTransformers
 import scala.tools.nsc.transform.Transform
 import scala.collection.mutable.HashSet
 import scala.collection.mutable.HashMap
-import scala.tools.nsc.util.Statistics
+import reflect.internal.util.Statistics
 
 /** Translate pattern matching.
   *
@@ -38,6 +38,7 @@ import scala.tools.nsc.util.Statistics
   */
 trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL {   // self: Analyzer =>
   import Statistics._
+  import PatternMatchingStats._
 
   val global: Global               // need to repeat here because otherwise last mixin defines global as
                                    // SymbolTable. If we had DOT this would not be an issue
@@ -183,7 +184,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
         case _                                          => tp
       }
 
-      val start = startTimer(patmatNanos)
+      val start = Statistics.startTimer(patmatNanos)
 
       val selectorTp = repeatedToSeq(elimAnonymousClass(selector.tpe.widen.withoutAnnotations))
 
@@ -210,7 +211,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
       // pt = Any* occurs when compiling test/files/pos/annotDepMethType.scala  with -Xexperimental
       val combined = combineCases(selector, selectorSym, cases map translateCase(selectorSym, pt), pt, matchOwner, matchFailGenOverride)
 
-      stopTimer(patmatNanos, start)
+      Statistics.stopTimer(patmatNanos, start)
       combined
     }
 
@@ -1694,7 +1695,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
     // TODO: for V1 representing x1 and V2 standing for x1.head, encode that
     //       V1 = Nil implies -(V2 = Ci) for all Ci in V2's domain (i.e., it is unassignable)
     def removeVarEq(props: List[Prop], considerNull: Boolean = false): (Prop, List[Prop]) = {
-      val start = startTimer(patmatAnaVarEq)
+      val start = Statistics.startTimer(patmatAnaVarEq)
 
       val vars = new collection.mutable.HashSet[Var]
 
@@ -1766,7 +1767,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
       // patmatDebug("eqAxioms:\n"+ cnfString(eqFreePropToSolvable(eqAxioms)))
       // patmatDebug("pure:\n"+ cnfString(eqFreePropToSolvable(pure)))
 
-      stopTimer(patmatAnaVarEq, start)
+      Statistics.stopTimer(patmatAnaVarEq, start)
 
       (eqAxioms, pure)
     }
@@ -1865,10 +1866,10 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
         }
       }
 
-      val start = startTimer(patmatCNF)
+      val start = Statistics.startTimer(patmatCNF)
       val res = conjunctiveNormalForm(negationNormalForm(p))
-      stopTimer(patmatCNF, start)
-      patmatCNFSizes(res.size) += 1
+      Statistics.stopTimer(patmatCNF, start)
+      patmatCNFSizes(res.size).value += 1
 
 //      patmatDebug("cnf for\n"+ p +"\nis:\n"+cnfString(res))
       res
@@ -1945,7 +1946,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
 
       // patmatDebug("dpll\n"+ cnfString(f))
 
-      val start = startTimer(patmatAnaDPLL)
+      val start = Statistics.startTimer(patmatAnaDPLL)
 
       val satisfiableWithModel: Model =
         if (f isEmpty) EmptyModel
@@ -1983,7 +1984,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
             }
         }
 
-        stopTimer(patmatAnaDPLL, start)
+        Statistics.stopTimer(patmatAnaDPLL, start)
 
         satisfiableWithModel
     }
@@ -2291,7 +2292,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
         def makeCondPessimistic(tm: TreeMaker)(recurse: TreeMaker => Cond): Cond = makeCond(tm)(recurse)
       }
 
-      val start = startTimer(patmatAnaReach)
+      val start = Statistics.startTimer(patmatAnaReach)
 
       // use the same approximator so we share variables,
       // but need different conditions depending on whether we're conservatively looking for failure or success
@@ -2340,7 +2341,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
           }
         }
 
-        stopTimer(patmatAnaReach, start)
+        Statistics.stopTimer(patmatAnaReach, start)
 
         if (reachable) None else Some(caseIndex)
       } catch {
@@ -2428,7 +2429,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
       // - back off (to avoid crying exhaustive too often) when:
       //    - there are guards -->
       //    - there are extractor calls (that we can't secretly/soundly) rewrite
-      val start = startTimer(patmatAnaExhaust)
+      val start = Statistics.startTimer(patmatAnaExhaust)
       var backoff = false
       object exhaustivityApproximation extends TreeMakersToConds(prevBinder) {
         def makeCondExhaustivity(tm: TreeMaker)(recurse: TreeMaker => Cond): Cond = tm match {
@@ -2503,7 +2504,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
 
           val pruned = CounterExample.prune(counterExamples).map(_.toString).sorted
 
-          stopTimer(patmatAnaExhaust, start)
+          Statistics.stopTimer(patmatAnaExhaust, start)
           pruned
         } catch {
           case e : CNFBudgetExceeded =>
@@ -3186,3 +3187,13 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
     }
   }
 }
+
+object PatternMatchingStats {
+  val patmatNanos         = Statistics.newTimer     ("time spent in patmat", "patmat")
+  val patmatAnaDPLL       = Statistics.newSubTimer  ("  of which DPLL", patmatNanos)
+  val patmatCNF           = Statistics.newSubTimer  ("  of which in CNF conversion", patmatNanos)
+  val patmatCNFSizes      = Statistics.newQuantMap[Int, Statistics.Counter]("  CNF size counts", "patmat")(Statistics.newCounter(""))
+  val patmatAnaVarEq      = Statistics.newSubTimer  ("  of which variable equality", patmatNanos)
+  val patmatAnaExhaust    = Statistics.newSubTimer  ("  of which in exhaustivity", patmatNanos)
+  val patmatAnaReach      = Statistics.newSubTimer  ("  of which in unreachability", patmatNanos)
+}
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 1193d3013a..6bd1117689 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -16,8 +16,7 @@ import scala.collection.mutable
 import scala.reflect.internal.util.BatchSourceFile
 import mutable.ListBuffer
 import symtab.Flags._
-import util.Statistics
-import util.Statistics._
+import reflect.internal.util.Statistics
 
 // Suggestion check whether we can do without priming scopes with symbols of outer scopes,
 // like the IDE does.
@@ -31,6 +30,7 @@ trait Typers extends Modes with Adaptations with Tags {
 
   import global._
   import definitions._
+  import TypersStats._
   import patmat.DefaultOverrideMatchAttachment
 
   final def forArgMode(fun: Tree, mode: Int) =
@@ -707,10 +707,16 @@ trait Typers extends Modes with Adaptations with Tags {
     def silent[T](op: Typer => T,
                   reportAmbiguousErrors: Boolean = context.ambiguousErrors,
                   newtree: Tree = context.tree): SilentResult[T] = {
-      val rawTypeStart = startCounter(rawTypeFailed)
-      val findMemberStart = startCounter(findMemberFailed)
-      val subtypeStart = startCounter(subtypeFailed)
-      val failedSilentStart = startTimer(failedSilentNanos)
+      val rawTypeStart = Statistics.startCounter(rawTypeFailed)
+      val findMemberStart = Statistics.startCounter(findMemberFailed)
+      val subtypeStart = Statistics.startCounter(subtypeFailed)
+      val failedSilentStart = Statistics.startTimer(failedSilentNanos)
+      def stopStats() = {
+        Statistics.stopCounter(rawTypeFailed, rawTypeStart)
+        Statistics.stopCounter(findMemberFailed, findMemberStart)
+        Statistics.stopCounter(subtypeFailed, subtypeStart)
+        Statistics.stopTimer(failedSilentNanos, failedSilentStart)
+      }
       try {
         if (context.reportErrors ||
             reportAmbiguousErrors != context.ambiguousErrors ||
@@ -724,8 +730,10 @@ trait Typers extends Modes with Adaptations with Tags {
           context.undetparams = context1.undetparams
           context.savedTypeBounds = context1.savedTypeBounds
           context.namedApplyBlockInfo = context1.namedApplyBlockInfo
-          if (context1.hasErrors) SilentTypeError(context1.errBuffer.head)
-          else SilentResultValue(result)
+          if (context1.hasErrors) {
+            stopStats()
+            SilentTypeError(context1.errBuffer.head)
+          } else SilentResultValue(result)
         } else {
           assert(context.bufferErrors || isPastTyper, "silent mode is not available past typer")
           withSavedContext(context){
@@ -739,10 +747,7 @@ trait Typers extends Modes with Adaptations with Tags {
         case ex: TypeError =>
           // fallback in case TypeError is still thrown
           // @H this happens for example in cps annotation checker
-          stopCounter(rawTypeFailed, rawTypeStart)
-          stopCounter(findMemberFailed, findMemberStart)
-          stopCounter(subtypeFailed, subtypeStart)
-          stopTimer(failedSilentNanos, failedSilentStart)
+          stopStats()
           SilentTypeError(TypeErrorWrapper(ex))
       }
     }
@@ -3481,9 +3486,9 @@ trait Typers extends Modes with Adaptations with Tags {
 
     def isCapturedExistential(sym: Symbol) =
       (sym hasAllFlags (EXISTENTIAL | CAPTURED)) && {
-      val start = startTimer(isReferencedNanos)
+      val start = Statistics.startTimer(isReferencedNanos)
       try !isReferencedFrom(context, sym)
-      finally stopTimer(isReferencedNanos, start)
+      finally Statistics.stopTimer(isReferencedNanos, start)
     }
 
     def packCaptured(tpe: Type): Type = {
@@ -4110,10 +4115,10 @@ trait Typers extends Modes with Adaptations with Tags {
        *  insert an implicit conversion.
        */
       def tryTypedApply(fun: Tree, args: List[Tree]): Tree = {
-        val start = startTimer(failedApplyNanos)
+        val start = Statistics.startTimer(failedApplyNanos)
 
         def onError(typeError: AbsTypeError): Tree = {
-            stopTimer(failedApplyNanos, start)
+            Statistics.stopTimer(failedApplyNanos, start)
 
             // If the problem is with raw types, copnvert to existentials and try again.
             // See #4712 for a case where this situation arises,
@@ -4176,8 +4181,8 @@ trait Typers extends Modes with Adaptations with Tags {
           typed1(tree, mode & ~PATTERNmode | EXPRmode, pt)
         } else {
           val funpt = if (isPatternMode) pt else WildcardType
-          val appStart = startTimer(failedApplyNanos)
-          val opeqStart = startTimer(failedOpEqNanos)
+          val appStart = Statistics.startTimer(failedApplyNanos)
+          val opeqStart = Statistics.startTimer(failedOpEqNanos)
 
           def onError(reportError: => Tree): Tree = {
               fun match {
@@ -4185,14 +4190,14 @@ trait Typers extends Modes with Adaptations with Tags {
                 if !isPatternMode && nme.isOpAssignmentName(newTermName(name.decode)) =>
                   val qual1 = typedQualifier(qual)
                   if (treeInfo.isVariableOrGetter(qual1)) {
-                    stopTimer(failedOpEqNanos, opeqStart)
+                    Statistics.stopTimer(failedOpEqNanos, opeqStart)
                     convertToAssignment(fun, qual1, name, args)
                   } else {
-                    stopTimer(failedApplyNanos, appStart)
+                    Statistics.stopTimer(failedApplyNanos, appStart)
                       reportError
                   }
                 case _ =>
-                  stopTimer(failedApplyNanos, appStart)
+                  Statistics.stopTimer(failedApplyNanos, appStart)
                   reportError
               }
           }
@@ -4201,7 +4206,7 @@ trait Typers extends Modes with Adaptations with Tags {
                  if ((mode & EXPRmode) != 0) tree else context.tree) match {
             case SilentResultValue(fun1) =>
               val fun2 = if (stableApplication) stabilizeFun(fun1, mode, pt) else fun1
-              incCounter(typedApplyCount)
+              Statistics.incCounter(typedApplyCount)
               def isImplicitMethod(tpe: Type) = tpe match {
                 case mt: MethodType => mt.isImplicit
                 case _ => false
@@ -4977,7 +4982,7 @@ trait Typers extends Modes with Adaptations with Tags {
           typedSelect(qual1, nme.CONSTRUCTOR)
 
         case Select(qual, name) =>
-          incCounter(typedSelectCount)
+          Statistics.incCounter(typedSelectCount)
           var qual1 = checkDead(typedQualifier(qual, mode))
           if (name.isTypeName) qual1 = checkStable(qual1)
 
@@ -5009,7 +5014,7 @@ trait Typers extends Modes with Adaptations with Tags {
           else tree1
 
         case Ident(name) =>
-          incCounter(typedIdentCount)
+          Statistics.incCounter(typedIdentCount)
           if ((name == nme.WILDCARD && (mode & (PATTERNmode | FUNmode)) == PATTERNmode) ||
               (name == tpnme.WILDCARD && (mode & TYPEmode) != 0))
             tree setType makeFullyDefined(pt)
@@ -5084,15 +5089,9 @@ trait Typers extends Modes with Adaptations with Tags {
       indentTyping()
 
       var alreadyTyped = false
+      val startByType = Statistics.pushTimerClass(byTypeNanos, tree.getClass)
+      Statistics.incCounter(visitsByType, tree.getClass)
       try {
-        if (Statistics.enabled) {
-          val t = currentTime()
-          if (pendingTreeTypes.nonEmpty) {
-            microsByType(pendingTreeTypes.head) += ((t - typerTime) / 1000).toInt
-          }
-          typerTime = t
-          pendingTreeTypes = tree.getClass :: pendingTreeTypes
-        }
         if (context.retyping &&
             (tree.tpe ne null) && (tree.tpe.isErroneous || !(tree.tpe <:< pt))) {
           tree.tpe = null
@@ -5146,14 +5145,7 @@ trait Typers extends Modes with Adaptations with Tags {
       }
       finally {
         deindentTyping()
-
-        if (Statistics.enabled) {
-          val t = currentTime()
-          microsByType(pendingTreeTypes.head) += ((t - typerTime) / 1000).toInt
-          visitsByType(pendingTreeTypes.head) += 1
-          typerTime = t
-          pendingTreeTypes = pendingTreeTypes.tail
-        }
+        Statistics.popTimerClass(byTypeNanos, startByType)
       }
     }
 
@@ -5329,3 +5321,22 @@ trait Typers extends Modes with Adaptations with Tags {
   }
 }
 
+object TypersStats {
+  import reflect.internal.TypesStats._
+  import reflect.internal.BaseTypeSeqsStats._
+  val typedIdentCount     = Statistics.newCounter("#typechecked identifiers")
+  val typedSelectCount    = Statistics.newCounter("#typechecked selections")
+  val typedApplyCount     = Statistics.newCounter("#typechecked applications")
+  val rawTypeFailed       = Statistics.newSubCounter ("  of which in failed", rawTypeCount)
+  val subtypeFailed       = Statistics.newSubCounter("  of which in failed", subtypeCount)
+  val findMemberFailed    = Statistics.newSubCounter("  of which in failed", findMemberCount)
+  val compoundBaseTypeSeqCount = Statistics.newSubCounter("  of which for compound types", baseTypeSeqCount)
+  val typerefBaseTypeSeqCount = Statistics.newSubCounter("  of which for typerefs", baseTypeSeqCount)
+  val singletonBaseTypeSeqCount = Statistics.newSubCounter("  of which for singletons", baseTypeSeqCount)
+  val failedSilentNanos   = Statistics.newSubTimer  ("time spent in failed", typerNanos)
+  val failedApplyNanos    = Statistics.newSubTimer  ("  failed apply", typerNanos)
+  val failedOpEqNanos     = Statistics.newSubTimer  ("  failed op=", typerNanos)
+  val isReferencedNanos   = Statistics.newSubTimer  ("time spent ref scanning", typerNanos)
+  val visitsByType        = Statistics.newByClass   ("#visits by tree node", "typer")(Statistics.newCounter(""))
+  val byTypeNanos         = Statistics.newByClassTimerStack("time spent by tree node", typerNanos)
+}
diff --git a/src/compiler/scala/tools/nsc/util/Statistics.scala b/src/compiler/scala/tools/nsc/util/Statistics.scala
deleted file mode 100644
index 087111a7ba..0000000000
--- a/src/compiler/scala/tools/nsc/util/Statistics.scala
+++ /dev/null
@@ -1,200 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2011 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package util
-
-class Statistics extends scala.reflect.internal.util.Statistics {
-
- var nodeByType = new ClassCounts
-
-  var microsByType = new ClassCounts
-  var visitsByType = new ClassCounts
-  var pendingTreeTypes: List[Class[_]] = List()
-  var typerTime: Long = 0L
-
-  val typedApplyCount = new Counter
-  val typedIdentCount = new Counter
-  val typedSelectCount = new Counter
-  val typerNanos = new Timer
-  val classReadNanos = new Timer
-
-  val failedApplyNanos = new Timer
-  val failedOpEqNanos = new Timer
-  val failedSilentNanos = new Timer
-
-  val implicitSearchCount = new Counter
-  val implicitNanos = new Timer
-  val oftypeImplicitHits = new Counter
-  val inscopeImplicitHits = new Counter
-
-  val triedImplicits = new Counter
-  val plausiblyCompatibleImplicits = new Counter
-  val matchingImplicits = new Counter
-  val typedImplicits = new Counter
-  val foundImplicits = new Counter
-
-  val inscopeSucceedNanos = new Timer
-  val inscopeFailNanos = new Timer
-  val oftypeSucceedNanos = new Timer
-  val oftypeFailNanos = new Timer
-  val implicitCacheHits = new Counter
-  val implicitCacheMisses = new Counter
-  val improvesCount = new Counter
-  val improvesCachedCount = new Counter
-  val subtypeAppInfos = new SubCounter(subtypeCount)
-  val subtypeImprovCount = new SubCounter(subtypeCount)
-  val subtypeETNanos = new Timer
-  val matchesPtNanos = new Timer
-  val isReferencedNanos = new Timer
-  val ctr1 = new Counter
-  val ctr2 = new Counter
-  val ctr3 = new Counter
-  val ctr4 = new Counter
-  val counter1: SubCounter = new SubCounter(subtypeCount)
-  val counter2: SubCounter = new SubCounter(subtypeCount)
-  val timer1: Timer = new Timer
-  val timer2: Timer = new Timer
-
-  val macroExpandCount = new Counter
-  val macroExpandNanos = new Timer
-
-  val patmatNanos      = new Timer
-  val patmatAnaDPLL    = new Timer
-  val patmatAnaVarEq   = new Timer
-  val patmatCNF        = new Timer
-  val patmatAnaExhaust = new Timer
-  val patmatAnaReach   = new Timer
-  val patmatCNFSizes   = new collection.mutable.HashMap[Int, Int] withDefaultValue 0
-}
-
-object Statistics extends Statistics
-
-abstract class StatisticsInfo {
-
-  import Statistics._
-
-  val global: Global
-  import global._
-
-  var phasesShown = List("parser", "typer", "patmat", "erasure", "cleanup")
-
-  def countNodes(tree: Tree, counts: ClassCounts) {
-    for (t <- tree) counts(t.getClass) += 1
-  }
-
-  def showRelative(base: Long)(value: Long) =
-    value+showPercent(value, base)
-
-  def showRelTyper(timer: Timer) =
-    timer+showPercent(timer.nanos, typerNanos.nanos)
-
-  def showRelPatmat(timer: Timer) =
-    timer+showPercent(timer.nanos, patmatNanos.nanos)
-
-  def showCounts[T](counts: scala.collection.mutable.Map[T, Int]) =
-    counts.toSeq.sortWith(_._2 > _._2).map {
-      case (cls: Class[_], cnt) =>
-        cls.toString.substring(cls.toString.lastIndexOf("$") + 1)+": "+cnt
-      case (o, cnt) =>
-        o.toString +": "+cnt
-    }
-
-  def print(phase: Phase) = if (phasesShown contains phase.name) {
-    inform("*** Cumulative statistics at phase " + phase)
-    inform("#created tree nodes  : " + nodeCount)
-    inform("#created tree nodes by type: "+showCounts(nodeByType))
-    if (phase.name != "parser") {
-      val counts = new ClassCounts
-      for (u <- currentRun.units; t <- u.body) counts(t.getClass) += 1
-      inform("#retained nodes          : " + counts.values.sum)
-      inform("#retained nodes by type  : " + showCounts(counts))
-      inform("#typechecked identifiers : " + typedIdentCount)
-      inform("#typechecked selections  : " + typedSelectCount)
-      inform("#typechecked applications: " + typedApplyCount)
-      inform("#raw type creations      : " + rawTypeCount)
-      inform("  of which in failed     : " + rawTypeFailed)
-      inform("  of which in implicits  : " + rawTypeImpl)
-      inform("#unique types            : " + uniqueTypeCount)
-      inform("#symbols                 : " + symbolCount)
-      inform("  of which type symbols  : " + typeSymbolCount)
-      inform("  of which class symbols : " + classSymbolCount)
-      inform("#base type seqs          : " + baseTypeSeqCount)
-      inform("avg base type seq length : " + baseTypeSeqLenTotal.value.toFloat / baseTypeSeqCount.value)
-      inform("#singleton base type seqs: " + singletonBaseTypeSeqCount)
-      inform("#compound base type seqs : " + compoundBaseTypeSeqCount)
-      inform("#typeref base type seqs  : " + typerefBaseTypeSeqCount)
-      inform("#findMember ops          : " + findMemberCount)
-      inform("  of which in failed     : " + findMemberFailed)
-      inform("  of which in implicits  : " + findMemberImpl)
-      inform("#notfound member         : " + noMemberCount)
-      inform("#multiple member         : " + multMemberCount)
-      inform("#asSeenFrom ops          : " + asSeenFromCount)
-      inform("#subtype                 : " + subtypeCount)
-      inform("  of which in failed     : " + subtypeFailed)
-      inform("  of which in implicits  : " + subtypeImpl)
-      inform("  of which in app impl   : " + subtypeAppInfos)
-      inform("  of which in improv     : " + subtypeImprovCount)
-      inform("#sametype                : " + sametypeCount)
-      inform("#toplevel lub            : " + lubCount)
-      inform("#all lub                 : " + nestedLubCount)
-      inform("ms type-flow-analysis: " + analysis.timer.millis)
-
-      if (phase.name == "typer") {
-        inform("time spent typechecking    : " + showRelTyper(typerNanos))
-        inform("time classfilereading      : " + showRelTyper(classReadNanos))
-        inform("time spent in implicits    : " + showRelTyper(implicitNanos))
-        inform("    successful in scope    : " + showRelTyper(inscopeSucceedNanos))
-        inform("        failed in scope    : " + showRelTyper(inscopeFailNanos))
-        inform("     successful of type    : " + showRelTyper(oftypeSucceedNanos))
-        inform("         failed of type    : " + showRelTyper(oftypeFailNanos))
-        inform("       assembling parts    : " + showRelTyper(subtypeETNanos))
-        inform("              matchesPT    : " + showRelTyper(matchesPtNanos))
-        inform("implicit cache hits        : " + showRelative(implicitCacheHits.value + implicitCacheMisses.value)(implicitCacheHits.value))
-        inform("time spent in failed       : " + showRelTyper(failedSilentNanos))
-        inform("       failed apply        : " + showRelTyper(failedApplyNanos))
-        inform("       failed op=          : " + showRelTyper(failedOpEqNanos))
-        inform("time spent ref scanning    : " + showRelTyper(isReferencedNanos))
-        inform("time spent in lubs         : " + showRelTyper(lubNanos))
-        inform("micros by tree node        : " + showCounts(microsByType))
-        inform("#visits by tree node       : " + showCounts(visitsByType))
-        val average = new ClassCounts
-        for (c <- microsByType.keysIterator) average(c) = microsByType(c)/visitsByType(c)
-        inform("avg micros by tree node    : " + showCounts(average))
-        inform("time spent in <:<          : " + showRelTyper(subtypeNanos))
-        inform("time spent in findmember   : " + showRelTyper(findMemberNanos))
-        inform("time spent in asSeenFrom   : " + showRelTyper(asSeenFromNanos))
-        inform("#implicit searches         : " + implicitSearchCount)
-        inform("#tried, plausible, matching, typed, found implicits: "+triedImplicits+", "+plausiblyCompatibleImplicits+", "+matchingImplicits+", "+typedImplicits+", "+foundImplicits)
-        inform("#implicit improves tests   : " + improvesCount)
-        inform("#implicit improves cached  : " + improvesCachedCount)
-        inform("#implicit inscope hits     : " + inscopeImplicitHits)
-        inform("#implicit oftype hits      : " + oftypeImplicitHits)
-        inform("#macro expansions          : " + macroExpandCount)
-        inform("#time spent in macroExpand : " + showRelTyper(macroExpandNanos))
-      }
-
-      if (ctr1 != null)     inform("#ctr1                    : " + ctr1)
-      if (ctr2 != null)     inform("#ctr2                    : " + ctr2)
-      if (ctr3 != null)     inform("#ctr3                    : " + ctr3)
-      if (ctr4 != null)     inform("#ctr4                    : " + ctr4)
-      if (counter1 != null) inform("#counter1                : " + counter1)
-      if (counter2 != null) inform("#counter2                : " + counter2)
-      if (timer1   != null) inform("#timer1                  : " + timer1)
-      if (timer2   != null) inform("#timer2                  : " + timer2)
-      //for (t <- uniques.iterator) println("unique: "+t)
-
-      if (phase.name == "patmat") {
-        inform("time spent in patmat       : " + patmatNanos                   )
-        inform("             of which DPLL : " + showRelPatmat(patmatAnaDPLL   ))
-        inform("of which in CNF conversion : " + showRelPatmat(patmatCNF       ))
-        inform("           CNF size counts : " + showCounts(patmatCNFSizes     ))
-        inform("of which variable equality : " + showRelPatmat(patmatAnaVarEq  ))
-        inform("  of which in exhaustivity : " + showRelPatmat(patmatAnaExhaust))
-        inform("of which in unreachability : " + showRelPatmat(patmatAnaReach  ))
-      }
-    }
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/util/StatisticsInfo.scala b/src/compiler/scala/tools/nsc/util/StatisticsInfo.scala
new file mode 100644
index 0000000000..f6a1ae1414
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/util/StatisticsInfo.scala
@@ -0,0 +1,38 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2011 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package scala.tools.nsc
+package util
+
+import reflect.internal.util.Statistics
+
+abstract class StatisticsInfo {
+
+  val global: Global
+  import global._
+  import reflect.internal.TreesStats.nodeByType
+
+  val phasesShown = List("parser", "typer", "patmat", "erasure", "cleanup")
+
+  val retainedCount  = Statistics.newCounter("#retained tree nodes")
+  val retainedByType = Statistics.newByClass("#retained tree nodes by type")(Statistics.newCounter(""))
+
+  def print(phase: Phase) = if (phasesShown contains phase.name) {
+    inform("*** Cumulative statistics at phase " + phase)
+    retainedCount.value = 0
+    for (c <- retainedByType.keys)
+      retainedByType(c).value = 0
+    for (u <- currentRun.units; t <- u.body) {
+      retainedCount.value += 1
+      retainedByType(t.getClass).value += 1
+    }
+
+    val quants =
+      if (phase.name == "parser") Seq(treeNodeCount, nodeByType, retainedCount, retainedByType)
+      else Statistics.allQuantities
+
+    for (q <- quants if q.showAt(phase.name)) inform(q.line)
+  }
+}
\ No newline at end of file