Rename tree -> rootTree

Rename `tree`, `trees` and associated methods in `ClassSymbol` to `rootTree`, `rootTrees`.

We want to add another tree field to symbols that points directly to the symbol's definition tree.
So we should be more specific about `rootTree`.

Author: odersky

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -942,20 +942,20 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   /** A trait for loaders that compute trees. Currently implemented just by DottyUnpickler. */
   trait TreeProvider {
-    protected def computeTrees(implicit ctx: Context): List[Tree]
+    protected def computeRootTrees(implicit ctx: Context): List[Tree]
 
     private[this] var myTrees: List[Tree] = null
 
     /** Get trees defined by this provider. Cache them if -Yretain-trees is set. */
-    def trees(implicit ctx: Context): List[Tree] =
+    def rootTrees(implicit ctx: Context): List[Tree] =
       if (ctx.settings.YretainTrees.value) {
-        if (myTrees == null) myTrees = computeTrees
+        if (myTrees == null) myTrees = computeRootTrees
         myTrees
-      } else computeTrees
+      } else computeRootTrees
 
     /** Get first tree defined by this provider, or EmptyTree if none exists */
     def tree(implicit ctx: Context): Tree =
-      trees.headOption.getOrElse(EmptyTree)
+      rootTrees.headOption.getOrElse(EmptyTree)
 
     /** Is it possible that the tree to load contains a definition of or reference to `id`? */
     def mightContain(id: String)(implicit ctx: Context) = true

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

@@ -382,8 +382,8 @@ class ClassfileLoader(val classfile: AbstractFile) extends SymbolLoader {
     if (mayLoadTreesFromTasty) {
       result match {
         case Some(unpickler: tasty.DottyUnpickler) =>
-          classRoot.classSymbol.treeOrProvider = unpickler
-          moduleRoot.classSymbol.treeOrProvider = unpickler
+          classRoot.classSymbol.rootTreeOrProvider = unpickler
+          moduleRoot.classSymbol.rootTreeOrProvider = unpickler
         case _ =>
       }
     }

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

@@ -672,13 +672,13 @@ object Symbols {
       * Returns 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): Tree = treeContaining("")
+    def rootTree(implicit ctx: Context): Tree = rootTreeContaining("")
 
     /** Same as `tree` but load tree only if `id == ""` or the tree might contain `id`.
      *  For Tasty trees this means consulting whether the name table defines `id`.
      *  For already loaded trees, we maintain the referenced ids in an attachment.
      */
-    def treeContaining(id: String)(implicit ctx: Context): Tree = {
+    def rootTreeContaining(id: String)(implicit ctx: Context): Tree = {
       denot.infoOrCompleter match {
         case _: NoCompleter =>
         case _ => denot.ensureCompleted()
@@ -696,9 +696,9 @@ object Symbols {
       }
     }
 
-    def treeOrProvider: TreeOrProvider = myTree
+    def rootTreeOrProvider: TreeOrProvider = myTree
 
-    private[dotc] def treeOrProvider_=(t: TreeOrProvider)(implicit ctx: Context): Unit =
+    private[dotc] def rootTreeOrProvider_=(t: TreeOrProvider)(implicit ctx: Context): Unit =
       myTree = t
 
     private def mightContain(tree: Tree, id: String)(implicit ctx: Context): Boolean = {

compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala

@@ -61,7 +61,7 @@ class DottyUnpickler(bytes: Array[Byte], mode: UnpickleMode = UnpickleMode.TopLe
     new TreeSectionUnpickler(posUnpicklerOpt, commentUnpicklerOpt)
   }
 
-  protected def computeTrees(implicit ctx: Context) = treeUnpickler.unpickle(mode)
+  protected def computeRootTrees(implicit ctx: Context) = treeUnpickler.unpickle(mode)
 
   private[this] var ids: Array[String] = null
 

compiler/src/dotty/tools/dotc/fromtasty/ReadTastyTreesFromClasses.scala

@@ -39,11 +39,11 @@ class ReadTastyTreesFromClasses extends FrontEnd {
 
       def compilationUnit(cls: Symbol): Option[CompilationUnit] = cls match {
         case cls: ClassSymbol =>
-          (cls.treeOrProvider: @unchecked) match {
+          (cls.rootTreeOrProvider: @unchecked) match {
             case unpickler: tasty.DottyUnpickler =>
-              if (cls.tree.isEmpty) None
+              if (cls.rootTree.isEmpty) None
               else {
-                val unit = mkCompilationUnit(cls, cls.tree, forceTrees = true)
+                val unit = mkCompilationUnit(cls, cls.rootTree, forceTrees = true)
                 unit.pickled += (cls -> unpickler.unpickler.bytes)
                 Some(unit)
               }
@@ -64,7 +64,7 @@ class ReadTastyTreesFromClasses extends FrontEnd {
         case clsd: ClassDenotation =>
           clsd.infoOrCompleter match {
             case info: ClassfileLoader =>
-              info.load(clsd) // sets cls.treeOrProvider and cls.moduleClass.treeProvider as a side-effect
+              info.load(clsd) // sets cls.rootTreeOrProvider and cls.moduleClass.treeProvider as a side-effect
             case _ =>
           }
           def moduleClass = clsd.owner.info.member(className.moduleClassName).symbol

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

@@ -53,7 +53,7 @@ object SourceTree {
           Some(SourceTree(tree, sourceFile))
         case _ => None
       }
-      sourceTreeOfClass(sym.treeContaining(id))
+      sourceTreeOfClass(sym.rootTreeContaining(id))
     }
   }
 }

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

@@ -103,7 +103,7 @@ class Pickler extends Phase {
       }
     pickling.println("************* entered toplevel ***********")
     for ((cls, unpickler) <- unpicklers) {
-      val unpickled = unpickler.trees
+      val unpickled = unpickler.rootTrees
       testSame(i"$unpickled%\n%", beforePickling(cls), cls)
     }
   }

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

@@ -1616,7 +1616,7 @@ class Typer extends Namer
       // check value class constraints
       checkDerivedValueClass(cls, body1)
 
-      if (ctx.settings.YretainTrees.value) cls.treeOrProvider = cdef1
+      if (ctx.settings.YretainTrees.value) cls.rootTreeOrProvider = cdef1
 
       cdef1