Remove TermOrTypeTree and use Tree

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala

@@ -51,8 +51,6 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   // TREES
   //
 
-  type TermOrTypeTree = tpd.Tree
-
   type Tree = tpd.Tree
 
   def Tree_pos(self: Tree)(implicit ctx: Context): Position = self.sourcePos
@@ -135,14 +133,14 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   }
 
   def ClassDef_constructor(self: ClassDef)(implicit ctx: Context): DefDef = ClassDef_rhs(self).constr
-  def ClassDef_parents(self: ClassDef)(implicit ctx: Context): List[TermOrTypeTree] = ClassDef_rhs(self).parents
+  def ClassDef_parents(self: ClassDef)(implicit ctx: Context): List[Tree /* Term | TypeTree */] = ClassDef_rhs(self).parents
   def ClassDef_derived(self: ClassDef)(implicit ctx: Context): List[TypeTree] = ClassDef_rhs(self).derived.asInstanceOf[List[TypeTree]]
   def ClassDef_self(self: ClassDef)(implicit ctx: Context): Option[ValDef] = optional(ClassDef_rhs(self).self)
   def ClassDef_body(self: ClassDef)(implicit ctx: Context): List[Statement] = ClassDef_rhs(self).body
   def ClassDef_symbol(self: ClassDef)(implicit ctx: Context): ClassSymbol = self.symbol.asClass
   private def ClassDef_rhs(self: ClassDef) = self.rhs.asInstanceOf[tpd.Template]
 
-  def ClassDef_copy(original: ClassDef)(name: String, constr: DefDef, parents: List[TermOrTypeTree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef = {
+  def ClassDef_copy(original: ClassDef)(name: String, constr: DefDef, parents: List[Tree /* Term | TypeTree */], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef = {
     val Trees.TypeDef(_, originalImpl: tpd.Template) = original
     tpd.cpy.TypeDef(original)(name.toTypeName, tpd.cpy.Template(originalImpl)(constr, parents, derived, selfOpt.getOrElse(tpd.EmptyValDef), body))
   }
@@ -205,10 +203,6 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
     case _ => None
   }
 
-  // TODO move to Kernel and use isTerm directly with a cast
-  def matchTermNotTypeTree(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context): Option[Term] =
-    if (termOrTypeTree.isTerm) Some(termOrTypeTree) else None
-
   def Term_pos(self: Term)(implicit ctx: Context): Position = self.sourcePos
   def Term_tpe(self: Term)(implicit ctx: Context): Type = self.tpe
   def Term_underlyingArgument(self: Term)(implicit ctx: Context): Term = self.underlyingArgument
@@ -453,14 +447,14 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
     case _ => None
   }
 
-  def Inlined_call(self: Inlined)(implicit ctx: Context): Option[TermOrTypeTree] = optional(self.call)
+  def Inlined_call(self: Inlined)(implicit ctx: Context): Option[Tree /* Term | TypeTree */] = optional(self.call)
   def Inlined_bindings(self: Inlined)(implicit ctx: Context): List[Definition] = self.bindings
   def Inlined_body(self: Inlined)(implicit ctx: Context): Term = self.expansion
 
-  def Inlined_apply(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
+  def Inlined_apply(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
     withDefaultPos(ctx => tpd.Inlined(call.getOrElse(tpd.EmptyTree), bindings.map { case b: tpd.MemberDef => b }, expansion)(ctx))
 
-  def Inlined_copy(original: Tree)(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
+  def Inlined_copy(original: Tree)(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
     tpd.cpy.Inlined(original)(call.getOrElse(tpd.EmptyTree), bindings.asInstanceOf[List[tpd.MemberDef]], expansion)
 
   type Lambda = tpd.Closure
@@ -611,12 +605,6 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
     case _ => if (x.isType) Some(x) else None
   }
 
-  // TODO move to Kernel and use isTypeTree directly with a cast
-  def matchTypeTreeNotTerm(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context): Option[TypeTree] = termOrTypeTree match {
-    case _: tpd.TypeBoundsTree => None
-    case _ => if (termOrTypeTree.isType) Some(termOrTypeTree) else None
-  }
-
   def TypeTree_pos(self: TypeTree)(implicit ctx: Context): Position = self.sourcePos
   def TypeTree_symbol(self: TypeTree)(implicit ctx: Context): Symbol = self.symbol
   def TypeTree_tpe(self: TypeTree)(implicit ctx: Context): Type = self.tpe.stripTypeVar

docs/docs/reference/other-new-features/tasty-reflect.md

@@ -186,8 +186,6 @@ TASTy Reflect provides the following types:
             +- BindSymbol
             +- NoSymbol
 
-Aliases:
- # TermOrTypeTree = Term | TypeTree
 ```
 
 ## More Examples

library/src/scala/tasty/reflect/Core.scala

@@ -111,9 +111,6 @@ package scala.tasty.reflect
  *
  *  +- Flags
  *
- *  Aliases:
- *   # TermOrTypeTree = Term | TypeTree
- *
  *  ```
  */
 trait Core {
@@ -126,10 +123,6 @@ trait Core {
   /** Settings */
   type Settings = kernel.Settings
 
-  // TODO: When bootstrapped, remove and use `Term | TypeTree` type directly in other files
-  /** Workaround missing `|` types in Scala 2 to represent `Term | TypeTree` */
-  type TermOrTypeTree /* Term | TypeTree */ = kernel.TermOrTypeTree
-
   /** Tree representing code written in the source */
   type Tree = kernel.Tree
 

library/src/scala/tasty/reflect/Kernel.scala

@@ -110,9 +110,6 @@ package scala.tasty.reflect
  *
  *  +- Flags
  *
- *  Aliases:
- *   # TermOrTypeTree = Term | TypeTree
- *
  *  ```
  */
 trait Kernel {
@@ -161,10 +158,6 @@ trait Kernel {
   // TREES
   //
 
-  // TODO: When bootstrapped, remove and use `Term | TypeTree` type directly in other files
-  /** Workaround missing `|` types in Scala 2 to represent `Term | TypeTree` */
-  type TermOrTypeTree /* Term | TypeTree */ <: AnyRef
-
   /** Tree representing code written in the source */
   type Tree <: AnyRef
 
@@ -223,13 +216,13 @@ trait Kernel {
   def matchClassDef(tree: Tree)(implicit ctx: Context): Option[ClassDef]
 
   def ClassDef_constructor(self: ClassDef)(implicit ctx: Context): DefDef
-  def ClassDef_parents(self: ClassDef)(implicit ctx: Context): List[TermOrTypeTree]
+  def ClassDef_parents(self: ClassDef)(implicit ctx: Context): List[Tree/* Term | TypeTree */]
   def ClassDef_derived(self: ClassDef)(implicit ctx: Context): List[TypeTree]
   def ClassDef_self(self: ClassDef)(implicit ctx: Context): Option[ValDef]
   def ClassDef_body(self: ClassDef)(implicit ctx: Context): List[Statement]
   def ClassDef_symbol(self: ClassDef)(implicit ctx: Context): ClassSymbol
 
-  def ClassDef_copy(original: ClassDef)(name: String, constr: DefDef, parents: List[TermOrTypeTree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef
+  def ClassDef_copy(original: ClassDef)(name: String, constr: DefDef, parents: List[Tree/* Term | TypeTree */], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef
 
   /** Tree representing a type (paramter or member) definition in the source code */
   type TypeDef <: Definition
@@ -273,8 +266,6 @@ trait Kernel {
 
   def matchTerm(tree: Tree)(implicit ctx: Context): Option[Term]
 
-  def matchTermNotTypeTree(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context): Option[Term]
-
   def Term_pos(self: Term)(implicit ctx: Context): Position
   def Term_tpe(self: Term)(implicit ctx: Context): Type
   def Term_underlyingArgument(self: Term)(implicit ctx: Context): Term
@@ -488,12 +479,12 @@ trait Kernel {
 
   def matchInlined(tree: Tree)(implicit ctx: Context): Option[Inlined]
 
-  def Inlined_call(self: Inlined)(implicit ctx: Context): Option[TermOrTypeTree]
+  def Inlined_call(self: Inlined)(implicit ctx: Context): Option[Tree/* Term | TypeTree */]
   def Inlined_bindings(self: Inlined)(implicit ctx: Context): List[Definition]
   def Inlined_body(self: Inlined)(implicit ctx: Context): Term
 
-  def Inlined_apply(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined
-  def Inlined_copy(original: Tree)(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined
+  def Inlined_apply(call: Option[Tree/* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined
+  def Inlined_copy(original: Tree)(call: Option[Tree/* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined
 
   /** Tree representing a selection of definition with a given name on a given prefix and number of nested scopes of inlined trees */
   type SelectOuter <: Term
@@ -527,7 +518,6 @@ trait Kernel {
   type TypeTree <: TypeOrBoundsTree
 
   def matchTypeTree(tree: Tree)(implicit ctx: Context): Option[TypeTree]
-  def matchTypeTreeNotTerm(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context): Option[TypeTree]
 
   def TypeTree_pos(self: TypeTree)(implicit ctx: Context): Position
   def TypeTree_symbol(self: TypeTree)(implicit ctx: Context): Symbol

library/src/scala/tasty/reflect/Printers.scala

@@ -201,7 +201,7 @@ trait Printers
           this += "Term.Repeated(" ++= elems += ", " += elemtpt += ")"
         case Term.Inlined(call, bindings, expansion) =>
           this += "Term.Inlined("
-          visitOption(call, visitTermOrTypeTree)
+          visitOption(call, visitTree)
           this += ", " ++= bindings += ", " += expansion += ")"
         case ValDef(name, tpt, rhs) =>
           this += "ValDef(\"" += name += "\", " += tpt += ", " += rhs += ")"
@@ -211,7 +211,7 @@ trait Printers
           this += "TypeDef(\"" += name += "\", " += rhs += ")"
         case ClassDef(name, constr, parents, derived, self, body) =>
           this += "ClassDef(\"" += name += "\", " += constr += ", "
-          visitList[TermOrTypeTree](parents, visitTermOrTypeTree)
+          visitList[Tree](parents, visitTree)
           this += ", "
           visitList[TypeTree](derived, visitTree)
           this += ", " += self += ", " ++= body += ")"
@@ -276,11 +276,6 @@ trait Printers
           this += "Pattern.TypeTest(" += tpt += ")"
       }
 
-      def visitTermOrTypeTree(x: TermOrTypeTree): Buffer = x match {
-        case IsTerm(termOrTypeTree) => this += termOrTypeTree
-        case IsTypeTree(termOrTypeTree) => this += termOrTypeTree
-      }
-
       def visitConstant(x: Constant): Buffer = x match {
         case Constant.Unit() => this += "Constant.Unit()"
         case Constant.Null() => this += "Constant.Null()"
@@ -618,7 +613,7 @@ trait Printers
           if (parents1.nonEmpty)
             this += highlightKeyword(" extends ", color)
 
-          def printParent(parent: TermOrTypeTree, needEmptyParens: Boolean = false): Unit = parent match {
+          def printParent(parent: Tree /* Term | TypeTree */, needEmptyParens: Boolean = false): Unit = parent match {
             case IsTypeTree(parent) =>
               printTypeTree(parent)
             case IsTerm(Term.TypeApply(fun, targs)) =>
@@ -637,7 +632,7 @@ trait Printers
               throw new MatchError(parent.show)
           }
 
-          def printSeparated(list: List[TermOrTypeTree]): Unit = list match {
+          def printSeparated(list: List[Tree /* Term | TypeTree */]): Unit = list match {
             case Nil =>
             case x :: Nil => printParent(x)
             case x :: xs =>

library/src/scala/tasty/reflect/TreeOps.scala

@@ -3,11 +3,6 @@ package reflect
 
 trait TreeOps extends Core {
 
-  // Decorators
-
-  implicit def termAsTermOrTypeTree(term: Term): TermOrTypeTree = term.asInstanceOf[TermOrTypeTree]
-  implicit def typeTreeAsTermOrTypeTree(term: TypeTree): TermOrTypeTree = term.asInstanceOf[TermOrTypeTree]
-
   // ----- Tree -----------------------------------------------------
 
   implicit class TreeAPI(self: Tree) {
@@ -80,15 +75,15 @@ trait TreeOps extends Core {
 
   object ClassDef {
     // TODO def apply(name: String, constr: DefDef, parents: List[TermOrTypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef
-    def copy(original: ClassDef)(name: String, constr: DefDef, parents: List[TermOrTypeTree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef =
+    def copy(original: ClassDef)(name: String, constr: DefDef, parents: List[Tree /* Term | TypeTree */], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef =
       kernel.ClassDef_copy(original)(name, constr, parents, derived, selfOpt, body)
-    def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[TermOrTypeTree], List[TypeTree], Option[ValDef], List[Statement])] =
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[Tree /* Term | TypeTree */], List[TypeTree], Option[ValDef], List[Statement])] =
       kernel.matchClassDef(tree).map(x => (x.name, x.constructor, x.parents, x.derived, x.self, x.body))
   }
 
   implicit class ClassDefAPI(self: ClassDef) {
     def constructor(implicit ctx: Context): DefDef = kernel.ClassDef_constructor(self)
-    def parents(implicit ctx: Context): List[TermOrTypeTree] = kernel.ClassDef_parents(self)
+    def parents(implicit ctx: Context): List[Tree /* Term | TypeTree */] = kernel.ClassDef_parents(self)
     def derived(implicit ctx: Context): List[TypeTree] = kernel.ClassDef_derived(self)
     def self(implicit ctx: Context): Option[ValDef] = kernel.ClassDef_self(self)
     def body(implicit ctx: Context): List[Statement] = kernel.ClassDef_body(self)
@@ -190,10 +185,6 @@ trait TreeOps extends Core {
     /** Matches any term */
     def unapply(tree: Tree)(implicit ctx: Context): Option[Term] =
       kernel.matchTerm(tree)
-
-    /** Matches any term */
-    def unapply(parent: TermOrTypeTree)(implicit ctx: Context, dummy: DummyImplicit): Option[Term] =
-      kernel.matchTermNotTypeTree(parent)
   }
 
   /** Scala term. Any tree that can go in expression position. */
@@ -587,13 +578,13 @@ trait TreeOps extends Core {
 
     object Inlined {
 
-      def apply(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
+      def apply(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
         kernel.Inlined_apply(call, bindings, expansion)
 
-      def copy(original: Tree)(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
+      def copy(original: Tree)(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
         kernel.Inlined_copy(original)(call, bindings, expansion)
 
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[TermOrTypeTree], List[Definition], Term)] =
+      def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[Tree /* Term | TypeTree */], List[Definition], Term)] =
         kernel.matchInlined(tree).map(x => (x.call, x.bindings, x.body))
 
     }
@@ -726,7 +717,7 @@ trait TreeOps extends Core {
   }
 
   implicit class InlinedAPI(self: Term.Inlined) {
-    def call(implicit ctx: Context): Option[TermOrTypeTree] = kernel.Inlined_call(self)
+    def call(implicit ctx: Context): Option[Tree /* Term | TypeTree */] = kernel.Inlined_call(self)
     def bindings(implicit ctx: Context): List[Definition] = kernel.Inlined_bindings(self)
     def body(implicit ctx: Context): Term = kernel.Inlined_body(self)
   }
@@ -764,8 +755,6 @@ trait TreeOps extends Core {
   object IsTypeTree {
     def unapply(tpt: Tree)(implicit ctx: Context): Option[TypeTree] =
       kernel.matchTypeTree(tpt)
-    def unapply(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context, dummy: DummyImplicit): Option[TypeTree] =
-      kernel.matchTypeTreeNotTerm(termOrTypeTree)
   }
 
   object TypeTree extends TypeTreeCoreModule {

library/src/scala/tasty/reflect/TreeUtils.scala

@@ -21,7 +21,6 @@ trait TreeUtils
     def foldCaseDefs(x: X, trees: Iterable[CaseDef])(implicit ctx: Context): X = (x /: trees)(foldCaseDef)
     def foldTypeCaseDefs(x: X, trees: Iterable[TypeCaseDef])(implicit ctx: Context): X = (x /: trees)(foldTypeCaseDef)
     def foldPatterns(x: X, trees: Iterable[Pattern])(implicit ctx: Context): X = (x /: trees)(foldPattern)
-    private def foldParents(x: X, trees: Iterable[TermOrTypeTree])(implicit ctx: Context): X = (x /: trees)(foldTermOrTypeTree)
 
     def foldOverTree(x: X, tree: Tree)(implicit ctx: Context): X = {
       def localCtx(definition: Definition): Context = definition.symbol.localContext
@@ -76,7 +75,7 @@ trait TreeUtils
           foldTree(x, rhs)
         case IsDefinition(cdef @ ClassDef(_, constr, parents, derived, self, body)) =>
           implicit val ctx = localCtx(cdef)
-          foldTrees(foldTrees(foldTrees(foldParents(foldTree(x, constr), parents), derived), self), body)
+          foldTrees(foldTrees(foldTrees(foldTrees(foldTree(x, constr), parents), derived), self), body)
         case Import(_, expr, _) =>
           foldTree(x, expr)
         case IsPackageClause(clause @ PackageClause(pid, stats)) =>
@@ -116,11 +115,6 @@ trait TreeUtils
       case Pattern.TypeTest(tpt) => foldTree(x, tpt)
     }
 
-    private def foldTermOrTypeTree(x: X, tree: TermOrTypeTree)(implicit ctx: Context): X = tree match {
-      case IsTerm(termOrTypeTree) => foldTree(x, termOrTypeTree)
-      case IsTypeTree(termOrTypeTree) => foldTree(x, termOrTypeTree)
-    }
-
   }
 
   abstract class TreeTraverser extends TreeAccumulator[Unit] {

semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala

@@ -99,18 +99,6 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
         }
       }
 
-      implicit class TermOrTypeTreeExtender(tree: TermOrTypeTree) {
-        def pos: Position = tree match {
-          case IsTerm(t) => t.pos
-          case IsTypeTree(t) => t.pos
-        }
-
-        def symbol: Symbol = tree match {
-          case IsTerm(t) => t.symbol
-          case IsTypeTree(t) => t.symbol
-        }
-      }
-
       implicit class TypeOrBoundsTreeExtender(tree: TypeOrBoundsTree) {
         def typetree: TypeTree = tree match {
           case IsTypeTree(t) => t
@@ -809,10 +797,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
             fittedInitClassRange = None
 
             // we add the parents to the symbol list
-            parents.foreach(_ match {
-              case IsTypeTree(t) => traverseTree(t)
-              case IsTerm(t) => traverseTree(t)
-            })
+            parents.foreach(traverseTree)
 
             selfopt match {
               case Some(vdef @ ValDef(name, type_, _)) => {
@@ -827,7 +812,7 @@ class SemanticdbConsumer(sourceFilePath: java.nio.file.Path) extends TastyConsum
                   // 2) Find the first '{'
                   // 3) Iterate until the character we are seeing is a letter
                   val startPosSearch: Int = parents.foldLeft(tree.pos.end)(
-                    (old: Int, ct: TermOrTypeTree) =>
+                    (old: Int, ct: Tree) =>
                       ct match {
                         case IsTerm(t) if t.pos.end < old => t.pos.end
                         case _                                  => old

tests/pos-special/fatal-warnings/tasty-parent-unapply.scala

@@ -8,7 +8,7 @@ object Macros {
   def impl(reflect: Reflection): Unit = {
     import reflect._
 
-    def foo(tree: Tree, term: Term, typeTree: TypeTree, parent: TermOrTypeTree) = {
+    def foo(tree: Tree, term: Term, typeTree: TypeTree, parent: Tree) = {
 
       tree match {
         case IsTerm(tree) =>