Add closure count instrumentation

Add a miniphase, enabled by -Yinstrument-closures that counts
closure allocation by invoking Stats.doRecord.

Todo: Find a generally shippable way to use this. Right now it depends
on the compiler-internal utility class Stats.

Author: odersky

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -97,6 +97,7 @@ class Compiler {
     List(new Constructors,           // Collect initialization code in primary constructors
                                         // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
          new FunctionalInterfaces,   // Rewrites closures to implement @specialized types of Functions.
+         new InstrumentClosures,     // Count closure allocations under -Yinstrument-closures
          new GetClass) ::            // Rewrites getClass calls on primitive types.
     List(new LinkScala2Impls,        // Redirect calls to trait methods defined by Scala 2.x, so that they now go to their implementations
          new LambdaLift,             // Lifts out nested functions to class scope, storing free variables in environments

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -149,6 +149,8 @@ class ScalaSettings extends Settings.SettingGroup {
 
   val YnoDecodeStacktraces: Setting[Boolean] = BooleanSetting("-Yno-decode-stacktraces", "Show raw StackOverflow stacktraces, instead of decoding them into triggering operations.")
 
+  val YinstrumentClosures: Setting[Boolean] = BooleanSetting("-Yinstrument-closures", "Add instrumentation code that counts closure creations.")
+
   /** Dottydoc specific settings */
   val siteRoot: Setting[String] = StringSetting(
     "-siteroot",

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

@@ -719,6 +719,9 @@ class Definitions {
   lazy val ValueOfType: TypeRef = ctx.requiredClassRef("scala.ValueOf")
   def ValueOfClass(implicit ctx: Context): ClassSymbol = ValueOfType.symbol.asClass
 
+  lazy val StatsModule = ctx.requiredModule("dotty.tools.dotc.util.Stats")
+    def Stats_doRecord(implicit ctx: Context): TermSymbol = StatsModule.requiredMethod("doRecord")
+
   lazy val XMLTopScopeModuleRef: TermRef = ctx.requiredModuleRef("scala.xml.TopScope")
 
   lazy val TupleTypeRef: TypeRef = ctx.requiredClassRef("scala.Tuple")

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

@@ -79,16 +79,25 @@ object Phases {
       * whereas a combined TreeTransformer gets period equal to union of periods of it's TreeTransforms
       */
     final def squashPhases(phasess: List[List[Phase]],
-                             phasesToSkip: List[String], stopBeforePhases: List[String], stopAfterPhases: List[String], YCheckAfter: List[String]): List[Phase] = {
+                           phasesToSkip: List[String],
+                           stopBeforePhases: List[String],
+                           stopAfterPhases: List[String],
+                           YCheckAfter: List[String])(implicit ctx: Context): List[Phase] = {
       val squashedPhases = ListBuffer[Phase]()
       var prevPhases: Set[String] = Set.empty
       val YCheckAll = YCheckAfter.contains("all")
 
       var stop = false
+
+      def isEnabled(p: Phase): Boolean =
+        !stop &&
+        !stopBeforePhases.contains(p.phaseName) &&
+        !phasesToSkip.contains(p.phaseName) &&
+        p.isEnabled
+
       val filteredPhases = phasess.map(_.filter { p =>
-        val pstop = stop
-        stop = stop | stopBeforePhases.contains(p.phaseName) | stopAfterPhases.contains(p.phaseName)
-        !(pstop || stopBeforePhases.contains(p.phaseName) || phasesToSkip.contains(p.phaseName))
+        try isEnabled(p)
+        finally stop |= stopBeforePhases.contains(p.phaseName) | stopAfterPhases.contains(p.phaseName)
       })
 
       var i = 0
@@ -323,6 +332,8 @@ object Phases {
     /** Can this transform change the base types of a type? */
     def changesBaseTypes: Boolean = changesParents
 
+    def isEnabled(implicit ctx: Context): Boolean = true
+
     def exists: Boolean = true
 
     def initContext(ctx: FreshContext): Unit = ()

compiler/src/dotty/tools/dotc/util/Stats.scala

@@ -26,7 +26,7 @@ import collection.mutable
   def record(fn: => String, n: => Int = 1): Unit =
     if (enabled) doRecord(fn, n)
 
-  private def doRecord(fn: String, n: Int) =
+  def doRecord(fn: String, n: Int) =
     if (monitored) {
       val name = if (fn.startsWith("member-")) "member" else fn
       hits(name) += n