Add -Yprofile option

Add -Yprofile and -Yprofile-sorted-by option.

This prints for each source file

 - the number of code lines
 - the number of tokens
 - the size of serialized tasty trees (just the trees, not the name table, nor the positions)
 - the complexity per line, computed by the formula (tasty-size/lines/50). That is, we
   assume a 50 tasy bytes/line as standard.

Using -Yprofile-sorted-by one can sort by a column name.

Author: odersky

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

@@ -15,7 +15,7 @@ import io.AbstractFile
 import Phases.unfusedPhases
 
 import util._
-import reporting.{Suppression, Action}
+import reporting.{Suppression, Action, Profile, ActiveProfile, NoProfile}
 import reporting.Diagnostic
 import reporting.Diagnostic.Warning
 import rewrites.Rewrites
@@ -197,12 +197,19 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     compileUnits()(using ctx)
   }
 
+  var profile: Profile = NoProfile
+
   private def compileUnits()(using Context) = Stats.maybeMonitored {
     if (!ctx.mode.is(Mode.Interactive)) // IDEs might have multi-threaded access, accesses are synchronized
       ctx.base.checkSingleThreaded()
 
     compiling = true
 
+    profile =
+      if ctx.settings.Yprofile.value || !ctx.settings.YprofileSortedBy.value.isEmpty
+      then ActiveProfile()
+      else NoProfile
+
     // If testing pickler, make sure to stop after pickling phase:
     val stopAfter =
       if (ctx.settings.YtestPickler.value) List("pickler")
@@ -321,8 +328,10 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   def printSummary(): Unit = {
     printMaxConstraint()
     val r = runContext.reporter
-    r.summarizeUnreportedWarnings
-    r.printSummary
+    if !r.errorsReported then
+      profile.printSummary()
+    r.summarizeUnreportedWarnings()
+    r.printSummary()
   }
 
   override def reset(): Unit = {

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

@@ -333,4 +333,8 @@ private sealed trait YSettings:
   val YinstrumentDefs: Setting[Boolean] = BooleanSetting("-Yinstrument-defs", "Add instrumentation code that counts method calls; needs -Yinstrument to be set, too.")
 
   val YforceInlineWhileTyping: Setting[Boolean] = BooleanSetting("-Yforce-inline-while-typing", "Make non-transparent inline methods inline when typing. Emulates the old inlining behavior of 3.0.0-M3.")
+
+  val Yprofile: Setting[Boolean] = BooleanSetting("-Yprofile", "Show information about sizes and compiletime complexity.")
+  val YprofileSortedBy = ChoiceSetting("-Yprofile-sorted-by", "key", "Show information about sizes and compiletime complexity sorted by given column name", List("name", "path", "lines", "tokens", "tasty", "complexity"), "")
 end YSettings
+

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -19,6 +19,7 @@ import rewrites.Rewrites.patch
 import config.Feature
 import config.Feature.migrateTo3
 import config.SourceVersion.`3.0`
+import reporting.{NoProfile, Profile}
 
 object Scanners {
 
@@ -189,6 +190,8 @@ object Scanners {
         case _ => true
       }
 
+    private val profile = if this.isInstanceOf[LookaheadScanner] then NoProfile else Profile.current
+
     if (rewrite) {
       val s = ctx.settings
       val rewriteTargets = List(s.newSyntax, s.oldSyntax, s.indent, s.noindent)
@@ -399,6 +402,7 @@ object Scanners {
       getNextToken(lastToken)
       if isAfterLineEnd then handleNewLine(lastToken)
       postProcessToken(lastToken, lastName)
+      profile.recordNewToken()
       printState()
 
     final def printState() =
@@ -639,6 +643,8 @@ object Scanners {
           errorButContinue(spaceTabMismatchMsg(lastWidth, nextWidth))
       if token != OUTDENT then
         handleNewIndentWidth(currentRegion, _.otherIndentWidths += nextWidth)
+      if next.token == EMPTY then
+        profile.recordNewLine()
     end handleNewLine
 
     def spaceTabMismatchMsg(lastWidth: IndentWidth, nextWidth: IndentWidth) =

compiler/src/dotty/tools/dotc/reporting/Profile.scala

@@ -0,0 +1,95 @@
+package dotty.tools
+package dotc
+package reporting
+
+import core.*
+import Contexts.{Context, ctx}
+import collection.mutable
+import util.{EqHashMap, NoSourcePosition}
+
+abstract class Profile:
+  def unitProfile(unit: CompilationUnit): Profile.Info
+  def recordNewLine()(using Context): Unit
+  def recordNewToken()(using Context): Unit
+  def recordTasty(size: Int)(using Context): Unit
+  def printSummary()(using Context): Unit
+
+object Profile:
+  def current(using Context): Profile =
+    if ctx.run == null then NoProfile else ctx.run.profile
+
+  private val TastyFactor = 40
+
+  class Info:
+    var lineCount: Int = 0
+    var tokenCount: Int = 0
+    var tastySize: Int = 0
+    def complexity: Float = tastySize.toFloat/lineCount/TastyFactor
+end Profile
+
+class ActiveProfile extends Profile:
+
+  private val pinfo = new EqHashMap[CompilationUnit, Profile.Info]
+
+  private val junkInfo = new Profile.Info
+
+  private def curInfo(using Context): Profile.Info =
+    val unit = ctx.compilationUnit
+    if unit == null then junkInfo else unitProfile(unit)
+
+  def unitProfile(unit: CompilationUnit): Profile.Info =
+    pinfo.getOrElseUpdate(unit, new Profile.Info)
+
+  def recordNewLine()(using Context): Unit =
+    curInfo.lineCount += 1
+  def recordNewToken()(using Context): Unit =
+    curInfo.tokenCount += 1
+  def recordTasty(size: Int)(using Context): Unit =
+    curInfo.tastySize += size
+
+  def printSummary()(using Context): Unit =
+    val units =
+      val rawUnits = pinfo.keysIterator.toArray
+      ctx.settings.YprofileSortedBy.value match
+        case "name"       => rawUnits.sortBy(_.source.file.name)
+        case "path"       => rawUnits.sortBy(_.source.file.path)
+        case "lines"      => rawUnits.sortBy(unitProfile(_).lineCount)
+        case "tokens"     => rawUnits.sortBy(unitProfile(_).tokenCount)
+        case "complexity" => rawUnits.sortBy(unitProfile(_).complexity)
+        case _            => rawUnits.sortBy(unitProfile(_).tastySize)
+
+    val nameWidth = units.map(_.source.file.name.length).max.max(10).min(50)
+    val layout = s"%-${nameWidth}s %6s %8s %8s %s     %s"
+    report.echo(layout.format("Source file", "Lines", "Tokens", "Tasty", " Complexity/Line", "Directory"))
+
+    def printInfo(name: String, info: Profile.Info, path: String) =
+      val complexity = info.complexity
+      val explanation =
+        if complexity < 1       then "low     "
+        else if complexity < 5  then "moderate"
+        else if complexity < 25 then "high    "
+        else                         "extreme "
+      val complexityStr = s"${"%6.2f".format(info.complexity)}  $explanation"
+      report.echo(layout.format(
+        name, info.lineCount, info.tokenCount, info.tastySize, complexityStr, path))
+
+    val agg = new Profile.Info
+    for unit <- units do
+      val info = unitProfile(unit)
+      val file = unit.source.file
+      printInfo(file.name, info, file.container.path)
+      agg.lineCount += info.lineCount
+      agg.tokenCount += info.tokenCount
+      agg.tastySize += info.tastySize
+    if units.length > 1 then
+      report.echo(s"${"-"*nameWidth}------------------------------------------")
+      printInfo("Total", agg, "")
+  end printSummary
+end ActiveProfile
+
+object NoProfile extends Profile:
+  def unitProfile(unit: CompilationUnit) = unsupported("NoProfile.info")
+  def recordNewLine()(using Context): Unit = ()
+  def recordNewToken()(using Context): Unit = ()
+  def recordTasty(size: Int)(using Context): Unit = ()
+  def printSummary()(using Context): Unit = ()

compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -214,14 +214,14 @@ abstract class Reporter extends interfaces.ReporterResult {
     b.mkString("\n")
   }
 
-  def summarizeUnreportedWarnings(using Context): Unit =
+  def summarizeUnreportedWarnings()(using Context): Unit =
     for (settingName, count) <- unreportedWarnings do
       val were = if count == 1 then "was" else "were"
       val msg = s"there $were ${countString(count, settingName.tail + " warning")}; re-run with $settingName for details"
       report(Warning(msg, NoSourcePosition))
 
   /** Print the summary of warnings and errors */
-  def printSummary(using Context): Unit = {
+  def printSummary()(using Context): Unit = {
     val s = summary
     if (s != "") report(new Info(s, NoSourcePosition))
   }

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

@@ -11,7 +11,7 @@ import Periods._
 import Phases._
 import Symbols._
 import Flags.Module
-import reporting.ThrowingReporter
+import reporting.{ThrowingReporter, Profile}
 import collection.mutable
 import scala.concurrent.{Future, Await, ExecutionContext}
 import scala.concurrent.duration.Duration
@@ -70,6 +70,7 @@ class Pickler extends Phase {
         picklers(cls) = pickler
       val treePkl = new TreePickler(pickler)
       treePkl.pickle(tree :: Nil)
+      Profile.current.recordTasty(treePkl.buf.length)
       val positionWarnings = new mutable.ListBuffer[String]()
       val pickledF = inContext(ctx.fresh) {
         Future {

tests/pos/profile-test.scala

@@ -0,0 +1,29 @@
+// When compiling this with -Yprofile, this should output
+//
+// Source file         Lines   Tokens    Tasty  Complexity/Line     Directory
+// profile-test.scala     16       50      316   0.49  low          tests/pos
+object ProfileTest:
+
+  def test = ???
+
+  def bar: Boolean = ??? ;
+  def baz = ???
+
+  /** doc comment
+   */
+  def bam = ???
+
+  if bar then
+    // comment
+    baz
+  else
+    bam
+
+  if bar then {
+    baz
+  }
+  else {
+    // comment
+    bam
+  }
+