Merge Run and RunInfo

With late source loading we need to access the current run from the
current context anyway, so there's no need to separate Run and RunInfo.

Author: odersky

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

@@ -119,7 +119,7 @@ class Compiler {
 
   def reset()(implicit ctx: Context): Unit = {
     ctx.base.reset()
-    ctx.runInfo.clear()
+    if (ctx.run != null) ctx.run.reset()
   }
 
   def newRun(implicit ctx: Context): Run = {

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

@@ -25,8 +25,7 @@ import dotty.tools.io.VirtualFile
 import scala.util.control.NonFatal
 
 /** A compiler run. Exports various methods to compile source files */
-class Run(comp: Compiler, ictx: Context) {
-  import Run._
+class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with ConstraintRunInfo {
 
   /** Produces the following contexts, from outermost to innermost
    *
@@ -53,13 +52,42 @@ class Run(comp: Compiler, ictx: Context) {
     ctx.initialize()(start) // re-initialize the base context with start
     def addImport(ctx: Context, refFn: () => TermRef) =
       ctx.fresh.setImportInfo(ImportInfo.rootImport(refFn)(ctx))
-    (start.setRunInfo(new RunInfo(start)) /: defn.RootImportFns)(addImport)
+    (start.setRun(this) /: defn.RootImportFns)(addImport)
   }
 
-  protected[this] implicit val ctx: Context = rootContext(ictx)
+  private[this] var myCtx = rootContext(ictx)
+
+  /** The context created for this run */
+  def runContext = myCtx
+
+  protected[this] implicit def ctx: Context = myCtx
   assert(ctx.runId <= Periods.MaxPossibleRunId)
 
-  def getSource(fileName: String): SourceFile = {
+  private[this] var myUnits: List[CompilationUnit] = _
+  private[this] var myUnitsCached: List[CompilationUnit] = _
+  private[this] var myFiles: Set[AbstractFile] = _
+
+  /** The compilation units currently being compiled, this may return different
+    *  results over time.
+    */
+  def units: List[CompilationUnit] = myUnits
+
+  private def units_=(us: List[CompilationUnit]): Unit =
+    myUnits = us
+
+  /** The files currently being compiled, this may return different results over time.
+    *  These files do not have to be source files since it's possible to compile
+    *  from TASTY.
+    */
+  def files: Set[AbstractFile] = {
+    if (myUnits ne myUnitsCached) {
+      myUnitsCached = myUnits
+      myFiles = myUnits.map(_.source.file).toSet
+    }
+    myFiles
+  }
+
+  private def getSource(fileName: String): SourceFile = {
     val f = new PlainFile(io.Path(fileName))
     if (f.isDirectory) {
       ctx.error(s"expected file, received directory '$fileName'")
@@ -78,7 +106,7 @@ class Run(comp: Compiler, ictx: Context) {
     compileSources(sources)
   } catch {
     case NonFatal(ex) =>
-      ctx.echo(i"exception occurred while compiling ${ctx.runInfo.units}%, %")
+      ctx.echo(i"exception occurred while compiling $units%, %")
       throw ex
   }
 
@@ -90,17 +118,17 @@ class Run(comp: Compiler, ictx: Context) {
    */
   def compileSources(sources: List[SourceFile]) =
     if (sources forall (_.exists)) {
-      ctx.runInfo.units = sources map (new CompilationUnit(_))
+      units = sources map (new CompilationUnit(_))
       compileUnits()
     }
 
   def compileUnits(us: List[CompilationUnit]): Unit = {
-    ctx.runInfo.units = us
+    units = us
     compileUnits()
   }
 
   def compileUnits(us: List[CompilationUnit], ctx: Context): Unit = {
-    ctx.runInfo.units = us
+    units = us
     compileUnits()(ctx)
   }
 
@@ -122,16 +150,16 @@ class Run(comp: Compiler, ictx: Context) {
         if (phase.isRunnable)
           Stats.trackTime(s"$phase ms ") {
             val start = System.currentTimeMillis
-            ctx.runInfo.units = phase.runOn(ctx.runInfo.units)
+            units = phase.runOn(units)
             if (ctx.settings.Xprint.value.containsPhase(phase)) {
-              for (unit <- ctx.runInfo.units) {
+              for (unit <- units) {
                 lastPrintedTree =
                   printTree(lastPrintedTree)(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
               }
             }
             ctx.informTime(s"$phase ", start)
             Stats.record(s"total trees at end of $phase", ast.Trees.ntrees)
-            for (unit <- ctx.runInfo.units)
+            for (unit <- units)
               Stats.record(s"retained typed trees at end of $phase", unit.tpdTree.treeSize)
           }
     }
@@ -180,46 +208,19 @@ class Run(comp: Compiler, ictx: Context) {
     compileSources(List(new SourceFile(virtualFile, Codec.UTF8)))
   }
 
-  /** The context created for this run */
-  def runContext = ctx
-
   /** Print summary; return # of errors encountered */
   def printSummary(): Reporter = {
-    ctx.runInfo.printMaxConstraint()
+    printMaxConstraint()
     val r = ctx.reporter
     r.printSummary
     r
   }
-}
-
-object Run {
-  /** Info that changes on each compiler run */
-  class RunInfo(initctx: Context) extends ImplicitRunInfo with ConstraintRunInfo {
-    implicit val ctx: Context = initctx
-
-    private[this] var myUnits: List[CompilationUnit] = _
-    private[this] var myUnitsCached: List[CompilationUnit] = _
-    private[this] var myFiles: Set[AbstractFile] = _
-
-    /** The compilation units currently being compiled, this may return different
-     *  results over time.
-     */
-    def units: List[CompilationUnit] = myUnits
-
-    private[Run] def units_=(us: List[CompilationUnit]): Unit =
-      myUnits = us
-
-
-    /** The files currently being compiled, this may return different results over time.
-     *  These files do not have to be source files since it's possible to compile
-     *  from TASTY.
-     */
-    def files: Set[AbstractFile] = {
-      if (myUnits ne myUnitsCached) {
-        myUnitsCached = myUnits
-        myFiles = myUnits.map(_.source.file).toSet
-      }
-      myFiles
-    }
+
+  override def reset() = {
+    super[ImplicitRunInfo].reset()
+    super[ConstraintRunInfo].reset()
+    myCtx = null
+    myUnits = null
+    myUnitsCached = null
   }
-}
+}

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

@@ -2,10 +2,9 @@ package dotty.tools.dotc
 package core
 
 import Contexts._
-import Run.RunInfo
 import config.Printers.typr
 
-trait ConstraintRunInfo { self: RunInfo =>
+trait ConstraintRunInfo { self: Run =>
   private[this] var maxSize = 0
   private[this] var maxConstraint: Constraint = _
   def recordConstraintSize(c: Constraint, size: Int) =
@@ -15,4 +14,6 @@ trait ConstraintRunInfo { self: RunInfo =>
     }
   def printMaxConstraint()(implicit ctx: Context) =
     if (maxSize > 0) typr.println(s"max constraint = ${maxConstraint.show}")
+
+  protected def reset() = maxConstraint = null
 }

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

@@ -14,7 +14,6 @@ import NameOps._
 import Uniques._
 import SymDenotations._
 import Comments._
-import Run.RunInfo
 import util.Positions._
 import ast.Trees._
 import ast.untpd
@@ -43,7 +42,7 @@ object Contexts {
   private val (settingsStateLoc,    store4) = store3.newLocation[SettingsState]()
   private val (freshNamesLoc,       store5) = store4.newLocation[FreshNameCreator](new FreshNameCreator.Default)
   private val (compilationUnitLoc,  store6) = store5.newLocation[CompilationUnit]()
-  private val (runInfoLoc,          store7) = store6.newLocation[RunInfo]()
+  private val (runLoc,              store7) = store6.newLocation[Run]()
   private val initialStore = store7
 
   /** A context is passed basically everywhere in dotc.
@@ -194,8 +193,8 @@ object Contexts {
     /** The current compilation unit */
     def compilationUnit: CompilationUnit = store(compilationUnitLoc)
 
-    /** The current compiler-run specific Info */
-    def runInfo: RunInfo = store(runInfoLoc)
+    /** The current compiler-run */
+    def run: Run = store(runLoc)
 
     /** The new implicit references that are introduced by this scope */
     protected var implicitsCache: ContextualImplicits = null
@@ -446,7 +445,7 @@ object Contexts {
     def setPrinterFn(printer: Context => Printer): this.type = updateStore(printerFnLoc, printer)
     def setSettings(settingsState: SettingsState): this.type = updateStore(settingsStateLoc, settingsState)
     def setCompilationUnit(compilationUnit: CompilationUnit): this.type = updateStore(compilationUnitLoc, compilationUnit)
-    def setRunInfo(runInfo: RunInfo): this.type = updateStore(runInfoLoc, runInfo)
+    def setRun(run: Run): this.type = updateStore(runLoc, run)
     def setFreshNames(freshNames: FreshNameCreator): this.type = updateStore(freshNamesLoc, freshNames)
 
     def setProperty[T](key: Key[T], value: T): this.type =
@@ -506,9 +505,7 @@ object Contexts {
     tree = untpd.EmptyTree
     typeAssigner = TypeAssigner
     moreProperties = Map.empty
-    store = initialStore
-              .updated(settingsStateLoc, settings.defaultState)
-              .updated(runInfoLoc, new RunInfo(this))
+    store = initialStore.updated(settingsStateLoc, settings.defaultState)
     typeComparer = new TypeComparer(this)
     searchHistory = new SearchHistory(0, Map())
     gadt = EmptyGADTMap

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

@@ -26,7 +26,7 @@ object OrderingConstraint {
   private def newConstraint(boundsMap: ParamBounds, lowerMap: ParamOrdering, upperMap: ParamOrdering)(implicit ctx: Context) : OrderingConstraint = {
     val result = new OrderingConstraint(boundsMap, lowerMap, upperMap)
     if (Config.checkConstraintsNonCyclic) result.checkNonCyclic()
-    ctx.runInfo.recordConstraintSize(result, result.boundsMap.size)
+    ctx.run.recordConstraintSize(result, result.boundsMap.size)
     result
   }
 

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

@@ -446,7 +446,7 @@ object Symbols {
     final def isDefinedInCurrentRun(implicit ctx: Context): Boolean =
       pos.exists && defRunId == ctx.runId && {
         val file = associatedFile
-        file != null && ctx.runInfo.files.contains(file)
+        file != null && ctx.run.files.contains(file)
       }
 
     /** Is symbol valid in current run? */

compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala

@@ -191,8 +191,8 @@ class InteractiveDriver(settings: List[String]) extends Driver {
           if (!t.symbol.isCompleted) t.symbol.info = UnspecifiedErrorType
           t.symbol.annotations.foreach { annot =>
             /* In some cases annotations are are used on themself (possibly larger cycles).
-            *  This is the case with the java.lang.annotation.Target annotation, would end 
-            *  in an infinite loop while cleaning. The `seen` is added to ensure that those 
+            *  This is the case with the java.lang.annotation.Target annotation, would end
+            *  in an infinite loop while cleaning. The `seen` is added to ensure that those
             *  trees are not cleand twice.
             *  TODO: Find a less expensive way to check for those cycles.
             */
@@ -226,7 +226,7 @@ class InteractiveDriver(settings: List[String]) extends Driver {
 
       run.compileSources(List(source))
       run.printSummary()
-      val t = ctx.runInfo.units.head.tpdTree
+      val t = ctx.run.units.head.tpdTree
       cleanup(t)
       myOpenedTrees(uri) = topLevelClassTrees(t, source)
 

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -9,7 +9,6 @@ import util.Stats.{track, record, monitored}
 import printing.{Showable, Printer}
 import printing.Texts._
 import Contexts._
-import Run.RunInfo
 import Types._
 import Flags._
 import TypeErasure.{erasure, hasStableErasure}
@@ -372,7 +371,7 @@ object Implicits {
 import Implicits._
 
 /** Info relating to implicits that is kept for one run */
-trait ImplicitRunInfo { self: RunInfo =>
+trait ImplicitRunInfo { self: Run =>
 
   private val implicitScopeCache = mutable.AnyRefMap[Type, OfTypeImplicits]()
 
@@ -502,7 +501,7 @@ trait ImplicitRunInfo { self: RunInfo =>
     iscope(rootTp)
   }
 
-  def clear() = {
+  protected def reset() = {
     implicitScopeCache.clear()
   }
 }
@@ -1055,7 +1054,7 @@ trait Implicits { self: Typer =>
       }
     }
 
-    def implicitScope(tp: Type): OfTypeImplicits = ctx.runInfo.implicitScope(tp, ctx)
+    def implicitScope(tp: Type): OfTypeImplicits = ctx.run.implicitScope(tp, ctx)
   }
 }