Keep package structure in rootTreeOrProvider

`rootTreeOrProvider` is a property of `ClassSymbol`, and contain the
tree that defines this symbol (or a mean to get that tree).

When the tree came from unpickled TASTY files, we were able to see the
nested packages from which the tree comes, along with the imports.
However, when the symbol has been loaded from source, we were filling
the `rootTreeOrProvider` only with the `TypeDef` that introduced this
symbol.

This commit moves the assignment of `rootTreeOrProvider` out of the
typer and into its own phase. Before assigning, we recreate the package
structure so that the information that we get out of
`rootTreeOrProvider` is the same regardless of whether the symbol has
been loaded from source or unpickled from TASTY.

Author: Duhemm

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

@@ -52,6 +52,7 @@ class Compiler {
     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 ElimPackagePrefixes,    // Eliminate references to package prefixes in Select nodes
+         new SetRootTree,            // Set the `rootTreeOrProvider` on class symbols
          new CookComments) ::        // Cook the comments: expand variables, doc, etc.
     List(new CheckStatic,            // Check restrictions that apply to @static members
          new ElimRepeated,           // Rewrite vararg parameters and arguments

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

@@ -200,7 +200,8 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
   /** Enter top-level definitions of classes and objects contain in Scala source file `file`.
    *  The newly added symbols replace any previously entered symbols.
-   *  If `typeCheck = true`, also run typer on the compilation unit.
+   *  If `typeCheck = true`, also run typer on the compilation unit, and set
+   *  `rootTreeOrProvider`.
    */
   def lateCompile(file: AbstractFile, typeCheck: Boolean)(implicit ctx: Context): Unit =
     if (!files.contains(file) && !lateFiles.contains(file)) {
@@ -211,9 +212,13 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
           if (unit.isJava) new JavaParser(unit.source).parse()
           else new Parser(unit.source).parse()
         ctx.typer.lateEnter(unit.untpdTree)
-        def typeCheckUnit() = unit.tpdTree = ctx.typer.typedExpr(unit.untpdTree)
+        def processUnit() = {
+          unit.tpdTree = ctx.typer.typedExpr(unit.untpdTree)
+          val phase = new transform.SetRootTree()
+          phase.runOn(unit)
+        }
         if (typeCheck)
-          if (compiling) finalizeActions += (() => typeCheckUnit()) else typeCheckUnit()
+          if (compiling) finalizeActions += (() => processUnit()) else processUnit()
       }
       process()(runContext.fresh.setCompilationUnit(unit))
     }

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

@@ -13,6 +13,7 @@ class InteractiveCompiler extends Compiler {
   // after each phase group instead of waiting for the pipeline to finish.
   override def phases: List[List[Phase]] = List(
     List(new FrontEnd),
+    List(new transform.SetRootTree),
     List(new transform.CookComments)
   )
 }

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

@@ -0,0 +1,45 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.CompilationUnit
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+
+/** Set the `rootTreeOrProvider` property of class symbols. */
+class SetRootTree extends MiniPhase {
+
+  override val phaseName: String = SetRootTree.name
+  override def isRunnable(implicit ctx: Context) =
+    super.isRunnable && ctx.settings.YretainTrees.value
+
+  def runOn(unit: CompilationUnit)(implicit ctx: Context) = {
+    val runCtx = ctx.fresh.setCompilationUnit(unit)
+    traverser.traverse(unit.tpdTree)(runCtx)
+  }
+
+  override def transformTypeDef(tree: tpd.TypeDef)(implicit ctx: Context): tpd.Tree = {
+    if (tree.symbol.isClass) {
+      val sym = tree.symbol.asClass
+      tpd.sliceTopLevel(ctx.compilationUnit.tpdTree, sym) match {
+        case (pkg: tpd.PackageDef) :: Nil =>
+          sym.rootTreeOrProvider = pkg
+        case _ =>
+          sym.rootTreeOrProvider = tree
+      }
+    }
+    tree
+  }
+
+  private def traverser = new tpd.TreeTraverser {
+    override def traverse(tree: tpd.Tree)(implicit ctx: Context): Unit = tree match {
+      case typeDef: tpd.TypeDef => transformTypeDef(typeDef)
+      case other => traverseChildren(other)
+    }
+  }
+
+
+}
+
+object SetRootTree {
+  val name: String = "SetRootTree"
+}

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

@@ -1615,8 +1615,6 @@ class Typer extends Namer
       // check value class constraints
       checkDerivedValueClass(cls, body1)
 
-      if (ctx.settings.YretainTrees.value) cls.rootTreeOrProvider = cdef1
-
       cdef1
 
       // todo later: check that