Skip to content

Commit

Permalink
Remove invalidation from Global.scala
Browse files Browse the repository at this point in the history 
The invalidation has been introduced in these commits:

scala@167309a
scala@ace051f
scala@e156d4a

It's safe to remove this functionality. It was added originally to support an experiment with resident compilation. The experiment was performed in sbt and dropped in  sbt/sbt@6def08e

Since then Scala team concluded to not work on resident compilation so it's safe to delete unused code.
  • Loading branch information
@mpociecha
mpociecha committed Jul 17, 2014
1 parent 87bba94 commit 41507ba
Show file tree
Hide file tree
Showing 2 changed files with 0 additions and 238 deletions.
237 changes: 0 additions & 237 deletions src/compiler/scala/tools/nsc/Global.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -831,198 +831,11 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
} reverse
}

// ------------ Invalidations ---------------------------------

/** Is given package class a system package class that cannot be invalidated?
*/
private def isSystemPackageClass(pkg: Symbol) =
pkg == RootClass ||
pkg == definitions.ScalaPackageClass || {
val pkgname = pkg.fullName
(pkgname startsWith "scala.") && !(pkgname startsWith "scala.tools")
}

/** Invalidates packages that contain classes defined in a classpath entry, and
* rescans that entry.
* @param paths Fully qualified names that refer to directories or jar files that are
* a entries on the classpath.
* First, causes the classpath entry referred to by `path` to be rescanned, so that
* any new files or deleted files or changes in subpackages are picked up.
* Second, invalidates any packages for which one of the following considitions is met:
* - the classpath entry contained during the last compilation run classfiles
* that represent a member in the package
* - the classpath entry now contains classfiles
* that represent a member in the package
* - the set of subpackages has changed.
*
* The invalidated packages are reset in their entirety; all member classes and member packages
* are re-accessed using the new classpath.
* Not invalidated are system packages that the compiler needs to access as parts
* of standard definitions. The criterion what is a system package is currently:
* any package rooted in "scala", with the exception of packages rooted in "scala.tools".
* This can be refined later.
* @return A pair consisting of
* - a list of invalidated packages
* - a list of of packages that should have been invalidated but were not because
* they are system packages.
*/
def invalidateClassPathEntries(paths: String*): (List[ClassSymbol], List[ClassSymbol]) = {
val invalidated, failed = new mutable.ListBuffer[ClassSymbol]
classPath match {
case cp: MergedClassPath[_] =>
def assoc(path: String): List[(PlatformClassPath, PlatformClassPath)] = {
val dir = AbstractFile getDirectory path
val canonical = dir.canonicalPath
def matchesCanonical(e: ClassPath[_]) = e.origin match {
case Some(opath) =>
(AbstractFile getDirectory opath).canonicalPath == canonical
case None =>
false
}
cp.entries find matchesCanonical match {
case Some(oldEntry) =>
List(oldEntry -> cp.context.newClassPath(dir))
case None =>
println(s"canonical = $canonical, origins = ${cp.entries map (_.origin)}")
error(s"cannot invalidate: no entry named $path in classpath $classPath")
List()
}
}
val subst = Map(paths flatMap assoc: _*)
if (subst.nonEmpty) {
platform updateClassPath subst
informProgress(s"classpath updated on entries [${subst.keys mkString ","}]")
def mkClassPath(elems: Iterable[PlatformClassPath]): PlatformClassPath =
if (elems.size == 1) elems.head
else new MergedClassPath(elems, classPath.context)
val oldEntries = mkClassPath(subst.keys)
val newEntries = mkClassPath(subst.values)
reSync(RootClass, Some(classPath), Some(oldEntries), Some(newEntries), invalidated, failed)
}
}
def show(msg: String, syms: scala.collection.Traversable[Symbol]) =
if (syms.nonEmpty)
informProgress(s"$msg: ${syms map (_.fullName) mkString ","}")
show("invalidated packages", invalidated)
show("could not invalidate system packages", failed)
(invalidated.toList, failed.toList)
}

/** Re-syncs symbol table with classpath
* @param root The root symbol to be resynced (a package class)
* @param allEntries Optionally, the corresponding package in the complete current classPath
* @param oldEntries Optionally, the corresponding package in the old classPath entries
* @param newEntries Optionally, the corresponding package in the new classPath entries
* @param invalidated A listbuffer collecting the invalidated package classes
* @param failed A listbuffer collecting system package classes which could not be invalidated
* The resyncing strategy is determined by the absence or presence of classes and packages.
* If either oldEntries or newEntries contains classes, root is invalidated, provided a corresponding package
* exists in allEntries, or otherwise is removed.
* Otherwise, the action is determined by the following matrix, with columns:
*
* old new all sym action
* + + + + recurse into all child packages of old ++ new
* + - + + invalidate root
* + - - + remove root from its scope
* - + + + invalidate root
* - + + - create and enter root
* - - * * no action
*
* Here, old, new, all mean classpaths and sym means symboltable. + is presence of an
* entry in its column, - is absence, * is don't care.
*
* Note that new <= all and old <= sym, so the matrix above covers all possibilities.
*/
private def reSync(root: ClassSymbol,
allEntries: OptClassPath, oldEntries: OptClassPath, newEntries: OptClassPath,
invalidated: mutable.ListBuffer[ClassSymbol], failed: mutable.ListBuffer[ClassSymbol]) {
ifDebug(informProgress(s"syncing $root, $oldEntries -> $newEntries"))

val getName: ClassPath[AbstractFile] => String = (_.name)
def hasClasses(cp: OptClassPath) = cp.isDefined && cp.get.classes.nonEmpty
def invalidateOrRemove(root: ClassSymbol) = {
allEntries match {
case Some(cp) => root setInfo new loaders.PackageLoader(cp)
case None => root.owner.info.decls unlink root.sourceModule
}
invalidated += root
}
def packageNames(cp: PlatformClassPath): Set[String] = cp.packages.toSet map getName
def subPackage(cp: PlatformClassPath, name: String): OptClassPath =
cp.packages find (cp1 => getName(cp1) == name)

val classesFound = hasClasses(oldEntries) || hasClasses(newEntries)
if (classesFound && !isSystemPackageClass(root)) {
invalidateOrRemove(root)
} else {
if (classesFound) {
if (root.isRoot) invalidateOrRemove(EmptyPackageClass)
else failed += root
}
(oldEntries, newEntries) match {
case (Some(oldcp) , Some(newcp)) =>
for (pstr <- packageNames(oldcp) ++ packageNames(newcp)) {
val pname = newTermName(pstr)
val pkg = (root.info decl pname) orElse {
// package was created by external agent, create symbol to track it
assert(!subPackage(oldcp, pstr).isDefined)
loaders.enterPackage(root, pstr, new loaders.PackageLoader(allEntries.get))
}
reSync(
pkg.moduleClass.asInstanceOf[ClassSymbol],
subPackage(allEntries.get, pstr), subPackage(oldcp, pstr), subPackage(newcp, pstr),
invalidated, failed)
}
case (Some(oldcp), None) =>
invalidateOrRemove(root)
case (None, Some(newcp)) =>
invalidateOrRemove(root)
case (None, None) =>
}
}
}

/** Invalidate contents of setting -Yinvalidate */
def doInvalidation() = settings.Yinvalidate.value match {
case "" =>
case entry => invalidateClassPathEntries(entry)
}

// ----------- Runs ---------------------------------------

private var curRun: Run = null
private var curRunId = 0

/** A hook that lets subclasses of `Global` define whether a package or class should be kept loaded for the
* next compiler run. If the parameter `sym` is a class or object, and `clearOnNextRun(sym)` returns `true`,
* then the symbol is unloaded and reset to its state before the last compiler run. If the parameter `sym` is
* a package, and clearOnNextRun(sym)` returns `true`, the package is recursively searched for
* classes to drop.
*
* Example: Let's say I want a compiler that drops all classes corresponding to the current project
* between runs. Then `keepForNextRun` of a toplevel class or object should return `true` if the
* class or object does not form part of the current project, `false` otherwise. For a package,
* clearOnNextRun should return `true` if no class in that package forms part of the current project,
* `false` otherwise.
*
* @param sym A class symbol, object symbol, package, or package class.
*/
@deprecated("use invalidateClassPathEntries instead", "2.10.0")
def clearOnNextRun(sym: Symbol) = false
/* To try out clearOnNext run on the scala.tools.nsc project itself
* replace `false` above with the following code
settings.Xexperimental.value && { sym.isRoot || {
sym.fullName match {
case "scala" | "scala.tools" | "scala.tools.nsc" => true
case _ => sym.owner.fullName.startsWith("scala.tools.nsc")
}
}}
* Then, fsc -Xexperimental clears the nsc project between successive runs of `fsc`.
*/

object typeDeconstruct extends {
val global: Global.this.type = Global.this
} with typechecker.StructuredTypeStrings
Expand Down Expand Up @@ -1292,47 +1105,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
first
}

/** Reset all classes contained in current project, as determined by
* the clearOnNextRun hook
*/
@deprecated("use invalidateClassPathEntries instead", "2.10.0")
def resetProjectClasses(root: Symbol): Unit = try {
def unlink(sym: Symbol) =
if (sym != NoSymbol) root.info.decls.unlink(sym)
if (settings.verbose) inform("[reset] recursing in "+root)
val toReload = mutable.Set[String]()
for (sym <- root.info.decls) {
if (sym.isInitialized && clearOnNextRun(sym))
if (sym.hasPackageFlag) {
resetProjectClasses(sym.moduleClass)
openPackageModule(sym.moduleClass)
} else {
unlink(sym)
unlink(root.info.decls.lookup(
if (sym.isTerm) sym.name.toTypeName else sym.name.toTermName))
toReload += sym.fullName
// note: toReload could be set twice with the same name
// but reinit must happen only once per name. That's why
// the following classPath.findClass { ... } code cannot be moved here.
}
}
for (fullname <- toReload)
classPath.findClass(fullname) match {
case Some(classRep) =>
if (settings.verbose) inform("[reset] reinit "+fullname)
loaders.initializeFromClassPath(root, classRep)
case _ =>
}
} catch {
case ex: Throwable =>
// this handler should not be nessasary, but it seems that `fsc`
// eats exceptions if they appear here. Need to find out the cause for
// this and fix it.
inform("[reset] exception happened: "+ex)
ex.printStackTrace()
throw ex
}

// --------------- Miscellania -------------------------------

/** Progress tracking. Measured in "progress units" which are 1 per
Expand Down Expand Up @@ -1542,8 +1314,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
compileUnitsInternal(units, fromPhase)

private def compileUnitsInternal(units: List[CompilationUnit], fromPhase: Phase) {
doInvalidation()

units foreach addUnit
val startTime = currentTime

Expand Down Expand Up @@ -1619,13 +1389,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)

// Clear any sets or maps created via perRunCaches.
perRunCaches.clearAll()

// Reset project
if (!stopPhase("namer")) {
enteringPhase(namerPhase) {
resetProjectClasses(RootClass)
}
}
}

/** Compile list of abstract files. */
Expand Down
1 change: 0 additions & 1 deletion src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -185,7 +185,6 @@ trait ScalaSettings extends AbsScalaSettings
val YmethodInfer = BooleanSetting ("-Yinfer-argument-types", "Infer types for arguments of overriden methods.")
val etaExpandKeepsStar = BooleanSetting ("-Yeta-expand-keeps-star", "Eta-expand varargs methods to T* rather than Seq[T]. This is a temporary option to ease transition.").withDeprecationMessage(removalIn212)
val inferByName = BooleanSetting ("-Yinfer-by-name", "Allow inference of by-name types. This is a temporary option to ease transition. See SI-7899.").withDeprecationMessage(removalIn212)
val Yinvalidate = StringSetting ("-Yinvalidate", "classpath-entry", "Invalidate classpath entry before run", "")
val YvirtClasses = false // too embryonic to even expose as a -Y //BooleanSetting ("-Yvirtual-classes", "Support virtual classes")
val YdisableUnreachablePrevention = BooleanSetting("-Ydisable-unreachable-prevention", "Disable the prevention of unreachable blocks in code generation.")
val YnoLoadImplClass = BooleanSetting ("-Yno-load-impl-class", "Do not load $class.class files.")
Expand Down

0 comments on commit 41507ba

Please sign in to comment.