More detailed stats

We now track typemaps, substitutions, context creations,
and typerState creations, among others.

Author: odersky

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

@@ -27,6 +27,7 @@ import reporting.diagnostic.Message
 import collection.mutable
 import collection.immutable.BitSet
 import printing._
+import util.Stats.record
 import config.{Settings, ScalaSettings, Platform, JavaPlatform}
 import language.implicitConversions
 import DenotTransformers.DenotTransformer
@@ -418,7 +419,10 @@ object Contexts {
     }
 
     /** A fresh clone of this context. */
-    def fresh: FreshContext = clone.asInstanceOf[FreshContext].init(this)
+    def fresh: FreshContext = {
+      record("context")
+      clone.asInstanceOf[FreshContext].init(this)
+    }
 
     final def withOwner(owner: Symbol): Context =
       if (owner ne this.owner) fresh.setOwner(owner) else this
@@ -449,32 +453,32 @@ object Contexts {
    *  of its attributes using the with... methods.
    */
   abstract class FreshContext extends Context {
-    def setPeriod(period: Period): this.type = { this.period = period; this }
-    def setMode(mode: Mode): this.type = { this.mode = mode; this }
+    def setPeriod(period: Period): this.type = { record("context-period"); this.period = period; this }
+    def setMode(mode: Mode): this.type = { record("context-mode"); this.mode = mode; this }
     def setCompilerCallback(callback: CompilerCallback): this.type = { this.compilerCallback = callback; this }
     def setSbtCallback(callback: AnalysisCallback): this.type = { this.sbtCallback = callback; this }
-    def setTyperState(typerState: TyperState): this.type = { this.typerState = typerState; this }
+    def setTyperState(typerState: TyperState): this.type = { record("context-typerState"); this.typerState = typerState; this }
     def setReporter(reporter: Reporter): this.type = setTyperState(typerState.withReporter(reporter))
-    def setNewTyperState: this.type = setTyperState(typerState.fresh(isCommittable = true))
-    def setExploreTyperState: this.type = setTyperState(typerState.fresh(isCommittable = false))
+    def setNewTyperState: this.type = { record("new typerState"); setTyperState(typerState.fresh(isCommittable = true)) }
+    def setExploreTyperState: this.type = { record("explore typerState"); setTyperState(typerState.fresh(isCommittable = false)) }
     def setPrinterFn(printer: Context => Printer): this.type = { this.printerFn = printer; this }
-    def setOwner(owner: Symbol): this.type = { assert(owner != NoSymbol); this.owner = owner; this }
+    def setOwner(owner: Symbol): this.type = { record("context-owner"); assert(owner != NoSymbol); this.owner = owner; this }
     def setSettings(sstate: SettingsState): this.type = { this.sstate = sstate; this }
     def setCompilationUnit(compilationUnit: CompilationUnit): this.type = { this.compilationUnit = compilationUnit; this }
-    def setTree(tree: Tree[_ >: Untyped]): this.type = { this.tree = tree; this }
-    def setScope(scope: Scope): this.type = { this.scope = scope; this }
+    def setTree(tree: Tree[_ >: Untyped]): this.type = { record("context-tree"); this.tree = tree; this }
+    def setScope(scope: Scope): this.type = { record("context-scope"); this.scope = scope; this }
     def setNewScope: this.type = { this.scope = newScope; this }
     def setTypeAssigner(typeAssigner: TypeAssigner): this.type = { this.typeAssigner = typeAssigner; this }
     def setTyper(typer: Typer): this.type = { this.scope = typer.scope; setTypeAssigner(typer) }
     def setImportInfo(importInfo: ImportInfo): this.type = { this.importInfo = importInfo; this }
-    def setImplicits(implicits: ContextualImplicits): this.type = { this.implicitsCache = implicits; this }
+    def setImplicits(implicits: ContextualImplicits): this.type = { record("context-implicits"); this.implicitsCache = implicits; this }
     def setRunInfo(runInfo: RunInfo): this.type = { this.runInfo = runInfo; this }
     def setDiagnostics(diagnostics: Option[StringBuilder]): this.type = { this.diagnostics = diagnostics; this }
-    def setGadt(gadt: GADTMap): this.type = { this.gadt = gadt; this }
+    def setGadt(gadt: GADTMap): this.type = { record("context-gadt"); this.gadt = gadt; this }
     def setTypeComparerFn(tcfn: Context => TypeComparer): this.type = { this.typeComparer = tcfn(this); this }
     def setSearchHistory(searchHistory: SearchHistory): this.type = { this.searchHistory = searchHistory; this }
     def setFreshNames(freshNames: FreshNameCreator): this.type = { this.freshNames = freshNames; this }
-    def setMoreProperties(moreProperties: Map[Key[Any], Any]): this.type = { this.moreProperties = moreProperties; this }
+    def setMoreProperties(moreProperties: Map[Key[Any], Any]): this.type = { record("context-moreProps"); this.moreProperties = moreProperties; this }
 
     def setProperty[T](key: Key[T], value: T): this.type =
       setMoreProperties(moreProperties.updated(key, value))

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

@@ -735,7 +735,10 @@ object Types {
      */
     final def asSeenFrom(pre: Type, cls: Symbol)(implicit ctx: Context): Type = track("asSeenFrom") {
       if (!cls.membersNeedAsSeenFrom(pre)) this
-      else ctx.asSeenFrom(this, pre, cls)
+      else {
+        record("asSeenFrom")
+        ctx.asSeenFrom(this, pre, cls)
+      }
     }
 
 // ----- Subtype-related --------------------------------------------
@@ -1260,7 +1263,8 @@ object Types {
     /** Substitute all types that refer in their symbol attribute to
      *  one of the symbols in `from` by the corresponding types in `to`.
      */
-    final def subst(from: List[Symbol], to: List[Type])(implicit ctx: Context): Type =
+    final def subst(from: List[Symbol], to: List[Type])(implicit ctx: Context): Type = {
+      record("substSymsTypes")
       if (from.isEmpty) this
       else {
         val from1 = from.tail
@@ -1271,6 +1275,7 @@ object Types {
           else ctx.subst(this, from, to)
         }
       }
+    }
 
     /** Same as `subst` but follows aliases as a fallback. When faced with a reference
      *  to an alias type, where normal substitution does not yield a new type, the
@@ -1280,39 +1285,53 @@ object Types {
      *  of a class and also wants to substitute any parameter accessors that alias
      *  the type parameters.
      */
-    final def substDealias(from: List[Symbol], to: List[Type])(implicit ctx: Context): Type =
+    final def substDealias(from: List[Symbol], to: List[Type])(implicit ctx: Context): Type = {
+      record("substDealias")
       ctx.substDealias(this, from, to)
+    }
 
     /** Substitute all types of the form `TypeParamRef(from, N)` by
      *  `TypeParamRef(to, N)`.
      */
-    final def subst(from: BindingType, to: BindingType)(implicit ctx: Context): Type =
+    final def subst(from: BindingType, to: BindingType)(implicit ctx: Context): Type = {
+      record("substBindings")
       ctx.subst(this, from, to)
+    }
 
     /** Substitute all occurrences of `This(cls)` by `tp` */
-    final def substThis(cls: ClassSymbol, tp: Type)(implicit ctx: Context): Type =
+    final def substThis(cls: ClassSymbol, tp: Type)(implicit ctx: Context): Type = {
+      record("substThis")
       ctx.substThis(this, cls, tp)
+    }
 
-    /** As substThis, but only is class is a static owner (i.e. a globally accessible object) */
+    /** As substThis, but only is class is not a static owner (i.e. a globally accessible object) */
     final def substThisUnlessStatic(cls: ClassSymbol, tp: Type)(implicit ctx: Context): Type =
-      if (cls.isStaticOwner) this else ctx.substThis(this, cls, tp)
-
+      if (cls.isStaticOwner) this else {
+        record("substThis")
+        ctx.substThis(this, cls, tp)
+      }
     /** Substitute all occurrences of `RecThis(binder)` by `tp` */
     final def substRecThis(binder: RecType, tp: Type)(implicit ctx: Context): Type =
       ctx.substRecThis(this, binder, tp)
 
     /** Substitute a bound type by some other type */
-    final def substParam(from: ParamRef, to: Type)(implicit ctx: Context): Type =
+    final def substParam(from: ParamRef, to: Type)(implicit ctx: Context): Type = {
+      record("substParam")
       ctx.substParam(this, from, to)
+    }
 
     /** Substitute bound types by some other types */
-    final def substParams(from: BindingType, to: List[Type])(implicit ctx: Context): Type =
+    final def substParams(from: BindingType, to: List[Type])(implicit ctx: Context): Type = {
+      record("substParams")
       ctx.substParams(this, from, to)
+    }
 
     /** Substitute all occurrences of symbols in `from` by references to corresponding symbols in `to`
      */
-    final def substSym(from: List[Symbol], to: List[Symbol])(implicit ctx: Context): Type =
+    final def substSym(from: List[Symbol], to: List[Symbol])(implicit ctx: Context): Type = {
+      record("substSym")
       ctx.substSym(this, from, to)
+    }
 
 // ----- misc -----------------------------------------------------------
 
@@ -3769,6 +3788,8 @@ object Types {
   abstract class TypeMap(implicit protected val ctx: Context)
   extends VariantTraversal with (Type => Type) { thisMap =>
 
+    record("all typemaps")
+    record(s"typemap: $getClass")
     protected def stopAtStatic = true
 
     def apply(tp: Type): Type
@@ -3834,6 +3855,7 @@ object Types {
 
     def mapOver2(tp: Type) = tp match {
       case tp: AppliedType =>
+        record(s"mapOver2 AppliedType")
         def mapArgs(args: List[Type], tparams: List[ParamInfo]): List[Type] = args match {
           case arg :: otherArgs =>
             val arg1 = arg match {
@@ -3852,6 +3874,7 @@ object Types {
     }
 
     def mapOver3(tp: Type) = {
+      record(s"mapOver3 ${tp.getClass}")
       implicit val ctx = this.ctx
       tp match {
         case tp: RefinedType =>
@@ -3978,7 +4001,7 @@ object Types {
    */
   abstract class ApproximatingTypeMap(implicit ctx: Context) extends TypeMap { thisMap =>
 
-    protected def range(lo: Type, hi: Type) =
+    def range(lo: Type, hi: Type) =
       if (variance > 0) hi
       else if (variance < 0) lo
       else Range(lower(lo), upper(hi))