Redifine parent as Term | TypeTree

Author: nicolasstucki

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

@@ -213,22 +213,14 @@ object TastyImpl extends scala.tasty.Tasty {
 
   type Parent = tpd.Tree
 
-  def parentClassTag: ClassTag[Parent] = implicitly[ClassTag[Parent]]
-
-  val TermParent: TermParentExtractor = new TermParentExtractor {
-    def unapply(x: Parent)(implicit ctx: Context): Option[Term] =
-      if (x.isTerm) Some(x) else None
-  }
-
-  val TypeParent: TypeParentExtractor = new TypeParentExtractor {
-    def unapply(x: Parent)(implicit ctx: Context): Option[TypeTree] =
-      if (x.isTerm) None else Some(x)
-  }
-
   // ----- Terms ----------------------------------------------------
 
   type Term = tpd.Tree
 
+  val Term: TermCaster = new TermCaster {
+    def unapply(x: Term)(implicit ctx: Context): Boolean = x.isTerm
+  }
+
   implicit def TermDeco(t: Term): AbstractTerm = new AbstractTerm {
     def pos(implicit ctx: Context): Position = new TastyPosition(t.pos)
     def tpe(implicit ctx: Context): Types.Type = t.tpe
@@ -458,6 +450,10 @@ object TastyImpl extends scala.tasty.Tasty {
 
   type TypeTree = tpd.Tree
 
+  val TypeTree: TypeTreeCaster = new TypeTreeCaster {
+    def unapply(x: TypeTree)(implicit ctx: Context): Boolean = x.isType
+  }
+
   def typeTreeClassTag: ClassTag[TypeTree] = implicitly[ClassTag[TypeTree]]
 
   implicit def TypeTreeDeco(x: TypeTree): AbstractTypeTree = new AbstractTypeTree {

library/src/scala/tasty/Tasty.scala

@@ -162,24 +162,17 @@ abstract class Tasty {
 
   // ----- Parents --------------------------------------------------
 
-  type Parent
+  type Parent /* Term | TypeTree */
 
-  implicit def parentClassTag: ClassTag[Parent]
+  // ----- Terms ----------------------------------------------------
 
-  val TermParent: TermParentExtractor
-  abstract class TermParentExtractor {
-    def unapply(x: Parent)(implicit ctx: Context): Option[Term]
-  }
+  type Term <: Statement with Parent
 
-  val TypeParent: TypeParentExtractor
-  abstract class TypeParentExtractor {
-    def unapply(x: Parent)(implicit ctx: Context): Option[TypeTree]
+  val Term: TermCaster
+  abstract class TermCaster {
+    def unapply(x: Term)(implicit ctx: Context): Boolean
   }
 
-  // ----- Terms ----------------------------------------------------
-
-  type Term <: Statement
-
   trait AbstractTerm extends Typed with Positioned
   implicit def TermDeco(t: Term): AbstractTerm
 
@@ -342,7 +335,12 @@ abstract class Tasty {
 
   // ----- TypeTrees ------------------------------------------------
 
-  type TypeTree <: TypeOrBoundsTree
+  type TypeTree <: TypeOrBoundsTree with Parent
+
+  val TypeTree: TypeTreeCaster
+  abstract class TypeTreeCaster {
+    def unapply(x: TypeTree)(implicit ctx: Context): Boolean
+  }
 
   trait AbstractTypeTree extends Typed with Positioned
   implicit def TypeTreeDeco(x: TypeTree): AbstractTypeTree

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

@@ -72,7 +72,12 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
       case TypeDef(name, rhs) =>
         this += "TypeDef(" += name += ", " += rhs += ")"
       case ClassDef(name, constr, parents, self, body) =>
-        this += "ClassDef(" += name += ", " += constr += ", " ++= parents += ", " += self += ", " ++= body += ")"
+        this += "ClassDef(" += name += ", " += constr += ", "
+        visitList[Parent](parents, {
+          case parent @ Term() => this += parent
+          case parent @ TypeTree() => this += parent
+        })
+        this += ", " += self += ", " ++= body += ")"
       case PackageDef(name, members) =>
         this += "PackageDef(" += name += ", " ++= members += ")"
       case Import(expr, selectors) =>
@@ -194,11 +199,6 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
       case Annotation(tree) => this += "Annotation(" += tree += ")"
     }
 
-    def visitParent(x: Parent): Buffer = x match {
-      case TermParent(term) => this += "TermParent(" += term += ")"
-      case TypeParent(typeTree) => this += "TypeParent(" += typeTree += ")"
-    }
-
     def visitId(x: Id): Buffer = {
       val Id(name) = x
       this += "Id(" += name += ")"
@@ -239,11 +239,6 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
       def ++=(x: List[CaseDef]): Buffer = { visitList(x, visitCaseDef); buff }
     }
 
-    private implicit class ParentOps(buff: Buffer) {
-      def +=(x: Parent): Buffer = { visitParent(x); buff }
-      def ++=(x: List[Parent]): Buffer = { visitList(x, visitParent); buff }
-    }
-
     private implicit class PatternOps(buff: Buffer) {
       def +=(x: Pattern): Buffer = { visitPattern(x); buff }
       def ++=(x: List[Pattern]): Buffer = { visitList(x, visitPattern); buff }

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

@@ -10,13 +10,12 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
   def foldTypeTree(x: X, tree: TypeOrBoundsTree)(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 foldTrees(x: X, trees: Iterable[Tree])(implicit ctx: Context): X = (x /: trees)(foldTree)
   def foldTypeTrees(x: X, trees: Iterable[TypeOrBoundsTree])(implicit ctx: Context): X = (x /: trees)(foldTypeTree)
   def foldCaseDefs(x: X, trees: Iterable[CaseDef])(implicit ctx: Context): X = (x /: trees)(foldCaseDef)
   def foldPatterns(x: X, trees: Iterable[Pattern])(implicit ctx: Context): X = (x /: trees)(foldPattern)
-  def foldParents(x: X, trees: Iterable[Parent])(implicit ctx: Context): X = (x /: trees)(foldParent)
+  private def foldParents(x: X, trees: Iterable[Parent])(implicit ctx: Context): X = (x /: trees)(foldOverParent)
 
   def foldOverTree(x: X, tree: Tree)(implicit ctx: Context): X = {
     def localCtx(definition: Definition): Context = definition.localContext
@@ -106,9 +105,9 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
     case TypeTest(tpt) => foldTypeTree(x, tpt)
   }
 
-  def foldOverParent(x: X, tree: Parent)(implicit ctx: Context): X = tree match {
-    case TermParent(term) => foldOverTree(x, term)
-    case TypeParent(typeTree) => foldOverTypeTree(x, typeTree)
+  private def foldOverParent(x: X, tree: Parent)(implicit ctx: Context): X = tree match {
+    case tree @ Term() => foldOverTree(x, tree)
+    case tree @ TypeTree() => foldOverTypeTree(x, tree)
   }
 
 }

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

@@ -9,18 +9,15 @@ abstract class TreeTraverser[T <: Tasty with Singleton](tasty0: T) extends TreeA
   def traverseTypeTree(tree: TypeOrBoundsTree)(implicit ctx: Context): Unit = traverseTypeTreeChildren(tree)
   def traverseCaseDef(tree: CaseDef)(implicit ctx: Context): Unit = traverseCaseDefChildren(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: Tree)(implicit ctx: Context): Unit = traverseTree(tree)
   def foldTypeTree(x: Unit, tree: TypeOrBoundsTree)(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: Tree)(implicit ctx: Context): Unit = foldOverTree((), tree)
   protected def traverseTypeTreeChildren(tree: TypeOrBoundsTree)(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)
-  protected def traverseParentChildren(tree: Parent)(implicit ctx: Context): Unit = foldOverParent((), tree)
 
 }