Rename TopLevelStatement to Tree

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tasty/TastyImpl.scala

@@ -51,12 +51,9 @@ object TastyImpl extends scala.tasty.Tasty {
 
   // ===== Trees ====================================================
 
+  type Tree = tpd.Tree
 
-  // ----- Top Level Statements -----------------------------------------------
-
-  type TopLevelStatement = tpd.Tree
-
-  implicit def TopLevelStatementDeco(t: TopLevelStatement): AbstractTopLevelStatement = new AbstractTopLevelStatement {
+  implicit def TreeDeco(t: Tree): AbstractTree = new AbstractTree {
     def pos(implicit ctx: Context): Position = new TastyPosition(t.pos)
   }
 
@@ -65,7 +62,7 @@ object TastyImpl extends scala.tasty.Tasty {
   def packageClauseClassTag: ClassTag[PackageClause] = implicitly[ClassTag[PackageClause]]
 
   val PackageClause: PackageClauseExtractor = new PackageClauseExtractor {
-    def unapply(x: PackageClause)(implicit ctx: Context): Option[(Term, List[TopLevelStatement])] = x match {
+    def unapply(x: PackageClause)(implicit ctx: Context): Option[(Term, List[Tree])] = x match {
       case x: tpd.PackageDef @unchecked => Some((x.pid, x.stats))
       case _ => None
     }

library/src/scala/tasty/Tasty.scala

@@ -41,20 +41,18 @@ abstract class Tasty {
 
   // ===== Trees ====================================================
 
-  // ----- Top Level Statements -----------------------------------------------
+  type Tree
 
-  type TopLevelStatement
+  trait AbstractTree extends Positioned
+  implicit def TreeDeco(t: Tree): AbstractTree
 
-  trait AbstractTopLevelStatement extends Positioned
-  implicit def TopLevelStatementDeco(t: TopLevelStatement): AbstractTopLevelStatement
-
-  type PackageClause <: TopLevelStatement
+  type PackageClause <: Tree
 
   implicit def packageClauseClassTag: ClassTag[PackageClause]
 
   val PackageClause: PackageClauseExtractor
   abstract class PackageClauseExtractor {
-    def unapply(x: PackageClause)(implicit ctx: Context): Option[(Term, List[TopLevelStatement])]
+    def unapply(x: PackageClause)(implicit ctx: Context): Option[(Term, List[Tree])]
   }
 
   trait AbstractPackageClause {
@@ -64,7 +62,7 @@ abstract class Tasty {
 
   // ----- Statements -----------------------------------------------
 
-  type Statement <: TopLevelStatement
+  type Statement <: Tree
 
   type Import <: Statement
 

library/src/scala/tasty/util/TastyPrinter.scala

@@ -4,7 +4,7 @@ import scala.tasty.Tasty
 
 object TastyPrinter {
 
-  def stringOfTree(tasty: Tasty)(tree: tasty.TopLevelStatement)(implicit ctx: tasty.Context): String = {
+  def stringOfTree(tasty: Tasty)(tree: tasty.Tree)(implicit ctx: tasty.Context): String = {
     implicit val buff: StringBuilder = new StringBuilder
     visitTree(tasty)(tree)
     buff.toString()
@@ -34,7 +34,7 @@ object TastyPrinter {
     buff.toString()
   }
 
-  private def visitTree(tasty: Tasty)(x: tasty.TopLevelStatement)(implicit buff: StringBuilder, ctx: tasty.Context): Unit = {
+  private def visitTree(tasty: Tasty)(x: tasty.Tree)(implicit buff: StringBuilder, ctx: tasty.Context): Unit = {
     import tasty._
     x match {
       case Ident(name) =>
@@ -274,12 +274,12 @@ object TastyPrinter {
     }
   }
 
-  private def visitTrees(tasty: Tasty)(list: List[tasty.TopLevelStatement])(implicit buff: StringBuilder, ctx: tasty.Context): Unit = {
+  private def visitTrees(tasty: Tasty)(list: List[tasty.Tree])(implicit buff: StringBuilder, ctx: tasty.Context): Unit = {
     list match {
       case x0 :: xs =>
         buff append "List("
         visitTree(tasty)(x0)
-        def visitNext(xs: List[tasty.TopLevelStatement]): Unit = xs match {
+        def visitNext(xs: List[tasty.Tree]): Unit = xs match {
           case y :: ys =>
             buff append ", "
             visitTree(tasty)(y)

library/src/scala/tasty/util/TreeAccumulator.scala

@@ -6,19 +6,19 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
   import tasty._
 
   // Ties the knot of the traversal: call `foldOver(x, tree))` to dive in the `tree` node.
-  def foldTree(x: X, tree: TopLevelStatement)(implicit ctx: Context): X
+  def foldTree(x: X, tree: Tree)(implicit ctx: Context): X
   def foldTypeTree(x: X, tree: MaybeTypeTree)(implicit ctx: Context): X
   def foldCaseDef(x: X, tree: CaseDef)(implicit ctx: Context): X
   def foldPattern(x: X, tree: Pattern)(implicit ctx: Context): X
   def foldParent(x: X, tree: Parent)(implicit ctx: Context): X
 
-  def foldTree(x: X, trees: Traversable[TopLevelStatement])(implicit ctx: Context): X = (x /: trees)(foldTree)
+  def foldTree(x: X, trees: Traversable[Tree])(implicit ctx: Context): X = (x /: trees)(foldTree)
   def foldTypeTree(x: X, trees: Traversable[MaybeTypeTree])(implicit ctx: Context): X = (x /: trees)(foldTypeTree)
   def foldCaseDef(x: X, trees: Traversable[CaseDef])(implicit ctx: Context): X = (x /: trees)(foldCaseDef)
   def foldPattern(x: X, trees: Traversable[Pattern])(implicit ctx: Context): X = (x /: trees)(foldPattern)
   def foldParent(x: X, trees: Traversable[Parent])(implicit ctx: Context): X = (x /: trees)(foldParent)
 
-  def foldOverTree(x: X, tree: TopLevelStatement)(implicit ctx: Context): X = {
+  def foldOverTree(x: X, tree: Tree)(implicit ctx: Context): X = {
     def localCtx(definition: Definition): Context = definition.localContext
     tree match {
       case Ident(_) =>

library/src/scala/tasty/util/TreeTraverser.scala

@@ -5,19 +5,19 @@ import scala.tasty.Tasty
 abstract class TreeTraverser[T <: Tasty with Singleton](tasty0: T) extends TreeAccumulator[Unit, T](tasty0) {
   import tasty._
 
-  def traverseTree(tree: TopLevelStatement)(implicit ctx: Context): Unit = traverseTreeChildren(tree)
+  def traverseTree(tree: Tree)(implicit ctx: Context): Unit = traverseTreeChildren(tree)
   def traverseTypeTree(tree: MaybeTypeTree)(implicit ctx: Context): Unit = traverseTypeTreeChildren(tree)
   def traverseCaseDef(tree: CaseDef)(implicit ctx: Context): Unit = traverseCaseDef(tree)
   def traversePattern(tree: Pattern)(implicit ctx: Context): Unit = traversePatternChildren(tree)
   def traverseParent(tree: Parent)(implicit ctx: Context): Unit = traverseParentChildren(tree)
 
-  def foldTree(x: Unit, tree: TopLevelStatement)(implicit ctx: Context): Unit = traverseTree(tree)
+  def foldTree(x: Unit, tree: Tree)(implicit ctx: Context): Unit = traverseTree(tree)
   def foldTypeTree(x: Unit, tree: MaybeTypeTree)(implicit ctx: Context) = traverseTypeTree(tree)
   def foldCaseDef(x: Unit, tree: CaseDef)(implicit ctx: Context) = traverseCaseDef(tree)
   def foldPattern(x: Unit, tree: Pattern)(implicit ctx: Context) = traversePattern(tree)
   def foldParent(x: Unit, tree: Parent)(implicit ctx: Context) = traverseParent(tree)
 
-  protected def traverseTreeChildren(tree: TopLevelStatement)(implicit ctx: Context): Unit = foldOverTree((), tree)
+  protected def traverseTreeChildren(tree: Tree)(implicit ctx: Context): Unit = foldOverTree((), tree)
   protected def traverseTypeTreeChildren(tree: MaybeTypeTree)(implicit ctx: Context): Unit = foldOverTypeTree((), tree)
   protected def traverseCaseDefChildren(tree: CaseDef)(implicit ctx: Context): Unit = foldOverCaseDef((), tree)
   protected def traversePatternChildren(tree: Pattern)(implicit ctx: Context): Unit = foldOverPattern((), tree)

tests/pos/tasty/definitions.scala

@@ -4,14 +4,13 @@ object definitions {
 
 // ====== Trees ======================================
 
-  trait Tree extends Positioned
+  sealed trait Tree // Top level statement
 
 // ------ Statements ---------------------------------
 
-  sealed trait TopLevelStatement extends Tree
-  sealed trait Statement extends TopLevelStatement
+  sealed trait Statement extends Tree
 
-  case class PackageClause(pkg: Term, body: List[TopLevelStatement]) extends TopLevelStatement
+  case class PackageClause(pkg: Term, body: List[Tree]) extends Tree
 
   case class Import(expr: Term, selector: List[ImportSelector]) extends Statement
 
@@ -82,7 +81,7 @@ object definitions {
   }
 
   /** Trees denoting types */
-  enum TypeTree extends Tree {
+  enum TypeTree extends Positioned {
     def tpe: Type = ???
     case Synthetic()
     case Ident(name: String, override val tpe: Type)
@@ -102,7 +101,7 @@ object definitions {
   }
 
   /** Trees denoting patterns */
-  enum Pattern extends Tree {
+  enum Pattern extends Positioned {
     def tpe: Type = ???
     case Value(v: Term)
     case Bind(name: String, pat: Pattern)

tests/run/tasty-extractors-owners/quoted_1.scala

@@ -18,7 +18,7 @@ object Macros {
 
     val printer = new TreeTraverser(u.tasty) {
       import tasty._
-      override def traverseTree(tree: TopLevelStatement)(implicit ctx: Context): Unit = {
+      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = {
         tree match {
           case tree @ DefDef(name, _, _, _, _) =>
             buff.append(name)