Add documentation and improve code

Author: nicolasstucki

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

@@ -47,7 +47,7 @@ class Compiler {
       List(new PostTyper),          // Additional checks and cleanups after type checking
       List(new sbt.ExtractAPI),     // Sends a representation of the API of classes to sbt via callbacks
       List(new Pickler),            // Generate TASTY info
-      List(new LinkAll),            // Link all
+      List(new LinkAll),            // Reload compilation units from TASTY for library code (if needed)
       List(new FirstTransform,      // Some transformations to put trees into a canonical form
            new CheckReentrant,      // Internal use only: Check that compiled program has no data races involving global vars
            new ElimJavaPackages),   // Eliminate syntactic references to Java packages

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

@@ -114,7 +114,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val YoptPhases = PhasesSetting("-Yopt-phases", "Restrict the optimisation phases to execute under -optimise.")
   val YoptFuel = IntSetting("-Yopt-fuel", "Maximum number of optimisations performed under -optimise.", -1)
   val optimise = BooleanSetting("-optimise", "Generates faster bytecode by applying local optimisations to the .program") withAbbreviation "-optimize"
-  val XlinkOptimise = BooleanSetting("-Xlink-optimise", "Link class files.").withAbbreviation("-Xlink-optimize")
+  val XlinkOptimise = BooleanSetting("-Xlink-optimise", "Recompile library code with the application.").withAbbreviation("-Xlink-optimize")
 
   /** Dottydoc specific settings */
   val siteRoot = StringSetting(

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

@@ -555,8 +555,10 @@ object Symbols {
 
     type ThisName = TypeName
 
-    /** If this is a top-level class, and if `-Yretain-trees` or `-Xlink-optimise` is set,
-      * return the TypeDef tree (possibly wrapped inside PackageDefs) for this class, otherwise EmptyTree.
+    /** If this is either:
+      *   - a top-level class and `-Yretain-trees` is set
+     *    - a top-level class loaded from TASTY and `-Xlink-optimise` is set
+      * then return the TypeDef tree (possibly wrapped inside PackageDefs) for this class, otherwise EmptyTree.
       * This will force the info of the class.
       */
     def tree(implicit ctx: Context): tpd.Tree /* tpd.PackageDef | tpd.TypeDef | tpd.EmptyTree */ = {
@@ -570,7 +572,7 @@ object Symbols {
       }
       myTree
     }
-    private var myTree: tpd.Tree /* tpd.PackageDef | tpd.TypeDef | tpd.EmptyTree */ = tpd.EmptyTree
+    private[this] var myTree: tpd.Tree /* tpd.PackageDef | tpd.TypeDef | tpd.EmptyTree */ = tpd.EmptyTree
     private[dotc] var unpickler: tasty.DottyUnpickler = _
 
     private[dotc] def registerTree(tree: tpd.TypeDef)(implicit ctx: Context): Unit = {

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

@@ -44,14 +44,14 @@ object SourceTree {
       None
     else {
       import ast.Trees._
-      def findTree(tree: tpd.Tree): Option[SourceTree] = tree match {
-        case PackageDef(_, stats) => stats.flatMap(findTree).headOption
+      def sourceTreeOfClass(tree: tpd.Tree): Option[SourceTree] = tree match {
+        case PackageDef(_, stats) => stats.flatMap(sourceTreeOfClass).headOption
         case tree: tpd.TypeDef if tree.symbol == sym =>
           val sourceFile = new SourceFile(sym.sourceFile, Codec.UTF8)
           Some(SourceTree(tree, sourceFile))
         case _ => None
       }
-      findTree(sym.tree)
+      sourceTreeOfClass(sym.tree)
     }
   }
 }

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

@@ -154,8 +154,9 @@ class FirstTransform extends MiniPhaseTransform with InfoTransformer with Annota
     cpy.Template(impl)(self = EmptyValDef)
   }
 
+  /** Eliminate empty package definitions that may have been stored in the TASTY trees */
   override def transformPackageDef(tree: PackageDef)(implicit ctx: Context, info: TransformerInfo): Tree =
-    if (tree.stats.isEmpty) theEmptyTree else tree
+    if (tree.stats.isEmpty) EmptyTree else tree
 
   override def transformDefDef(ddef: DefDef)(implicit ctx: Context, info: TransformerInfo) = {
     if (ddef.symbol.hasAnnotation(defn.NativeAnnot)) {

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

@@ -22,19 +22,21 @@ class LinkAll extends MiniPhaseTransform {
 
   override def prepareForUnit(tree: tpd.Tree)(implicit ctx: Context): TreeTransform = NoTransform
 
-  override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] =
-    if (ctx.settings.XlinkOptimise.value) super.runOn(allUnits(Set.empty, units.toSet, Set.empty))
-    else super.runOn(units)
+  override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
+    /** Loads and processes new compilation units, possibly loading more units. */
+    def allUnits(processed: Set[CompilationUnit], unprocessed: Set[CompilationUnit], loadedClasses: Set[ClassDenotation])(implicit ctx: Context): List[CompilationUnit] = {
+      if (unprocessed.isEmpty) processed.toList
+      else {
+        val accum = new ClassesToLoadAccumulator
+        val classesToLoad = unprocessed.foldLeft(Set.empty[ClassDenotation])((acc, unit) => accum.apply(acc, unit.tpdTree)) -- loadedClasses
+        val loadedUnits = classesToLoad.flatMap(cls => loadCompilationUnit(cls))
+        allUnits(processed ++ unprocessed, loadedUnits, loadedClasses ++ classesToLoad)
 
-  /** Loads and processes new compilation units, possibly loading more units. */
-  private def allUnits(processed: Set[CompilationUnit], unprocessed: Set[CompilationUnit], loadedClasses: Set[ClassDenotation])(implicit ctx: Context): List[CompilationUnit] = {
-    if (unprocessed.isEmpty) processed.toList
-    else {
-      val accum = new ClassesToLoadAccumulator
-      val classesToLoad = unprocessed.foldLeft(Set.empty[ClassDenotation])((acc, unit) => accum.apply(acc, unit.tpdTree)) -- loadedClasses
-      val loadedUnits = classesToLoad.flatMap(cls => loadCompilationUnit(cls))
-      allUnits(processed ++ unprocessed, loadedUnits, loadedClasses ++ classesToLoad)
+      }
     }
+
+    if (ctx.settings.XlinkOptimise.value) super.runOn(allUnits(Set.empty, units.toSet, Set.empty))
+    else super.runOn(units)
   }
 
   /** Collects all class denotations that may need to be loaded. */