WIP

Author: odersky

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

@@ -117,13 +117,8 @@ class Compiler {
     runId += 1; runId
   }
 
-  def reset()(implicit ctx: Context): Unit = {
-    ctx.base.reset()
-    ctx.runInfo.clear()
-  }
-
   def newRun(implicit ctx: Context): Run = {
-    reset()
+    ctx.base.reset()
     new Run(this, ctx)
   }
 }

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

@@ -44,7 +44,7 @@ object FromTasty extends Driver {
     }
 
     override def newRun(implicit ctx: Context): Run = {
-      reset()
+      ctx.base.reset()
       new TASTYRun(this, ctx)
     }
   }

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

@@ -60,6 +60,13 @@ class Run(comp: Compiler, ictx: Context) {
   protected[this] implicit val ctx: Context = rootContext(ictx)
   assert(ctx.runId <= Periods.MaxPossibleRunId)
 
+  if (ctx.runId > 3) {
+    // we are in resident mode; invalidate caches to reduce memory presssure
+    println("invalidating caches...")
+    defn.RootClass.invalidateCaches()
+    println("done")
+  }
+
   def getSource(fileName: String): SourceFile = {
     val f = new PlainFile(fileName)
     if (f.isDirectory) {
@@ -177,9 +184,10 @@ class Run(comp: Compiler, ictx: Context) {
   /** The context created for this run */
   def runContext = ctx
 
-  /** Print summary; return # of errors encountered */
+  /** Print summary ; return reporter */
   def printSummary(): Reporter = {
     ctx.runInfo.printMaxConstraint()
+    ctx.runInfo.clear()
     val r = ctx.reporter
     r.printSummary
     r

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

@@ -14,4 +14,6 @@ trait ConstraintRunInfo { self: RunInfo =>
     }
   def printMaxConstraint()(implicit ctx: Context) =
     if (maxSize > 0) typr.println(s"max constraint = ${maxConstraint.show}")
+  def clearMaxConstraint() =
+    maxConstraint = null
 }

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

@@ -591,6 +591,12 @@ object Contexts {
     def squashed(p: Phase): Phase = {
       allPhases.find(_.period.containsPhaseId(p.id)).getOrElse(NoPhase)
     }
+
+    def reset() = {
+      for ((_, set) <- uniqueSets) set.clear()
+      cleanPhaseCache()
+      errorTypeMsg.clear()
+    }
   }
 
   /** The essential mutable state of a context base, collected into a common class */
@@ -615,7 +621,7 @@ object Contexts {
     /** A table for hash consing unique named types */
     private[core] val uniqueNamedTypes = new NamedTypeUniques
 
-    private def uniqueSets = Map(
+    protected def uniqueSets = Map(
         "uniques" -> uniques,
         "uniqueAppliedTypes" -> uniqueAppliedTypes,
         "uniqueNamedTypes" -> uniqueNamedTypes)
@@ -662,11 +668,6 @@ object Contexts {
 
     protected[dotc] val indentTab = "  "
 
-    def reset() = {
-      for ((_, set) <- uniqueSets) set.clear()
-      errorTypeMsg.clear()
-    }
-
     // Test that access is single threaded
 
     /** The thread on which `checkSingleThreaded was invoked last */
@@ -692,6 +693,11 @@ object Contexts {
   /** Info that changes on each compiler run */
   class RunInfo(initctx: Context) extends ImplicitRunInfo with ConstraintRunInfo {
     implicit val ctx: Context = initctx
+
+    def clear() = {
+      clearImplicits()
+      clearMaxConstraint()
+    }
   }
 
   class GADTMap(initBounds: SimpleMap[Symbol, TypeBounds]) extends util.DotClass {

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

@@ -685,7 +685,7 @@ object Denotations {
      *  2) the union of all validity periods is a contiguous
      *     interval.
      */
-    protected var nextInRun: SingleDenotation = this
+    private[core] var nextInRun: SingleDenotation = this
 
     /** The version of this SingleDenotation that was valid in the first phase
      *  of this run.

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

@@ -214,7 +214,7 @@ object Phases {
     def phaseOfClass(pclass: Class[_]) = phases.find(pclass.isInstance).getOrElse(NoPhase)
 
     private val cachedPhases = collection.mutable.Set[PhaseCache]()
-    private def cleanPhaseCache = cachedPhases.foreach(_.myPhase = NoPhase)
+    protected def cleanPhaseCache() = cachedPhases.foreach(_.myPhase = NoPhase)
 
     /** A cache to compute the phase with given name, which
      *  stores the phase as soon as phaseNamed returns something

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

@@ -35,7 +35,9 @@ trait SymDenotations { this: Context =>
     val result =
       if (symbol.isClass)
         if (initFlags is Package) new PackageClassDenotation(symbol, owner, name, initFlags, initInfo, initPrivateWithin, ctx.runId)
-        else if (name.toString == "AndType") new ClassXDenotation(symbol, owner, name, initFlags, initInfo, initPrivateWithin, ctx.runId)
+        else if (name.toString == "AndType" && ctx.runId == 3) {
+          new ClassXDenotation(symbol, owner, name, initFlags, initInfo, initPrivateWithin, ctx.runId)
+        }
         else new ClassDenotation(symbol, owner, name, initFlags, initInfo, initPrivateWithin, ctx.runId)
       else new SymDenotation(symbol, owner, name, initFlags, initInfo, initPrivateWithin)
     result.validFor = stablePeriod
@@ -1207,6 +1209,8 @@ object SymDenotations {
      */
     def copyCaches(from: SymDenotation, phase: Phase)(implicit ctx: Context): this.type = this
 
+    private[core] def invalidateCaches()(implicit ctx: Context): Unit = ()
+
     /** Are `info1` and `info2` ClassInfo types with different parents?
      *  @param completersMatter  if `true`, consider parents changed if `info1` or `info2 `is a type completer
      */
@@ -1323,6 +1327,24 @@ object SymDenotations {
       this
     }
 
+    override private[core] def invalidateCaches()(implicit ctx: Context): Unit = {
+      println(i"invalidate: $name")
+      invalidateBaseDataCache()
+      invalidateMemberNamesCache()
+      invalidateBaseTypeCache()
+      myMemberCache = null
+      myMemberCachePeriod = Nowhere
+      fullNameCache = SimpleMap.Empty
+      myTypeParams = null
+      val invalidated = new java.util.IdentityHashMap[Symbol, Symbol]
+      info.decls.foreach { sym =>
+        if (invalidated.get(sym) == null) {
+          invalidated.put(sym, sym)
+          sym.invalidateCaches()
+        }
+      }
+    }
+
     // ----- denotation fields and accessors ------------------------------
 
     if (initFlags is (Module, butNot = Package))

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

@@ -578,6 +578,17 @@ object Symbols {
     def showFullName(implicit ctx: Context): String = ctx.fullNameString(this)
 
     override def hashCode() = id // for debugging.
+
+    def invalidateCaches()(implicit ctx: Context): Unit = {
+      val cur = lastDenot
+      if (cur != null) {
+        var d = cur
+        do {
+          d.invalidateCaches()
+          d = d.nextInRun.asInstanceOf[SymDenotation]
+        } while (d ne cur)
+      }
+    }
   }
 
   type TermSymbol = Symbol { type ThisName = TermName }

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

@@ -491,7 +491,7 @@ trait ImplicitRunInfo { self: RunInfo =>
     override def default(key: TermRef) = 0
   }
 
-  def clear() = {
+  protected def clearImplicits() = {
     implicitScopeCache.clear()
     useCount.clear()
   }