Tasty reflect renames

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

@@ -9,7 +9,7 @@ trait TastyCoreImpl extends scala.tasty.reflect.TastyCore {
 
   type Context = core.Contexts.Context
 
-  type Parent = tpd.Tree
+  type TermOrTypeTree = tpd.Tree
 
   type Tree = tpd.Tree
     type PackageClause = tpd.PackageDef

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

@@ -71,7 +71,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
   }
 
   object ClassDef extends ClassDefExtractor {
-    def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[Parent],  Option[ValDef], List[Statement])] = tree match {
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[TermOrTypeTree],  Option[ValDef], List[Statement])] = tree match {
       case Trees.TypeDef(name, impl: tpd.Template) =>
         Some((name.toString, impl.constr, impl.parents, optional(impl.self), impl.body))
       case _ => None
@@ -193,8 +193,8 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
   object IsTerm extends IsTermExtractor {
     def unapply(tree: Tree)(implicit ctx: Context): Option[Term] =
       if (tree.isTerm) Some(tree) else None
-    def unapply(parent: Parent)(implicit ctx: Context, dummy: DummyImplicit): Option[Term] =
-      if (parent.isTerm) Some(parent) else None
+    def unapply(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context, dummy: DummyImplicit): Option[Term] =
+      if (termOrTypeTree.isTerm) Some(termOrTypeTree) else None
   }
 
   object Term extends TermModule {
@@ -316,7 +316,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
     }
 
     object Inlined extends InlinedExtractor {
-      def unapply(x: Term)(implicit ctx: Context): Option[(Option[Parent], List[Statement], Term)] = x match {
+      def unapply(x: Term)(implicit ctx: Context): Option[(Option[TermOrTypeTree], List[Statement], Term)] = x match {
         case x: tpd.Inlined =>
           Some((optional(x.call), x.bindings, x.expansion))
         case _ => None
@@ -384,5 +384,5 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
     }
   }
 
-  def termAsParent(term: Term): Parent = term
+  def termAsTermOrTypeTree(term: Term): TermOrTypeTree = term
 }

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

@@ -25,8 +25,8 @@ trait TypeOrBoundsTreesOpsImpl extends scala.tasty.reflect.TypeOrBoundsTreeOps w
   object IsTypeTree extends IsTypeTreeExtractor {
     def unapply(x: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree] =
       if (x.isType) Some(x) else None
-    def unapply(x: Parent)(implicit ctx: Context, dummy: DummyImplicit): Option[TypeTree] =
-      if (x.isType) Some(x) else None
+    def unapply(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context, dummy: DummyImplicit): Option[TypeTree] =
+      if (termOrTypeTree.isType) Some(termOrTypeTree) else None
   }
 
   object TypeTree extends TypeTreeModule {
@@ -38,21 +38,21 @@ trait TypeOrBoundsTreesOpsImpl extends scala.tasty.reflect.TypeOrBoundsTreeOps w
       }
     }
 
-    object TypeIdent extends TypeIdentExtractor {
+    object Ident extends IdentExtractor {
       def unapply(x: TypeTree)(implicit ctx: Context): Option[String] = x match {
         case x: tpd.Ident if x.isType => Some(x.name.toString)
         case _ => None
       }
     }
 
-    object TermSelect extends TermSelectExtractor {
+    object Select extends SelectExtractor {
       def unapply(x: TypeTree)(implicit ctx: Context): Option[(Term, String)] = x match {
         case x: tpd.Select if x.isType && x.qualifier.isTerm => Some(x.qualifier, x.name.toString)
         case _ => None
       }
     }
 
-    object TypeSelect extends TypeSelectExtractor {
+    object Project extends ProjectExtractor {
       def unapply(x: TypeTree)(implicit ctx: Context): Option[(TypeTree, String)] = x match {
         case x: tpd.Select if x.isType && x.qualifier.isType => Some(x.qualifier, x.name.toString)
         case _ => None
@@ -153,5 +153,5 @@ trait TypeOrBoundsTreesOpsImpl extends scala.tasty.reflect.TypeOrBoundsTreeOps w
     }
   }
 
-  def typeTreeAsParent(typeTree: TypeTree): Parent = typeTree
+  def typeTreeAsParent(typeTree: TypeTree): TermOrTypeTree = typeTree
 }

library/src/scala/tasty/reflect/TastyCore.scala

@@ -37,9 +37,9 @@ package scala.tasty.reflect
  *
  *
  *                         +- TypeTree ----+- Synthetic
- *                         |               +- TypeIdent
- *                         |               +- TermSelect
- *                         |               +- TypeSelect
+ *                         |               +- Ident
+ *                         |               +- Select
+ *                         |               +- Project
  *                         |               +- Singleton
  *  +- TypeOrBoundsTree ---+               +- Refined
  *                         |               +- Applied
@@ -99,7 +99,7 @@ package scala.tasty.reflect
  *  +- Symbol
  *
  *  Aliases:
- *   # Parent = Term | TypeTree
+ *   # TermOrTypeTree = Term | TypeTree
  *
  *  ```
  */
@@ -110,7 +110,7 @@ trait TastyCore {
 
   // TODO: When bootstrapped, remove and use `Term | TypeTree` type directly in other files
   /** Workaround missing `|` types in Scala 2 to represent `Term | TypeTree` */
-  type Parent /* Term | TypeTree */
+  type TermOrTypeTree /* Term | TypeTree */
 
   /** Tree representing executable code written in the source */
   type Tree

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

@@ -58,12 +58,12 @@ trait TreeOps extends TastyCore {
 
   val ClassDef: ClassDefExtractor
   abstract class ClassDefExtractor {
-    def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[Parent], Option[ValDef], List[Statement])]
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[TermOrTypeTree], Option[ValDef], List[Statement])]
   }
 
   trait ClassDefAPI {
     def constructor(implicit ctx: Context): DefDef
-    def parents(implicit ctx: Context): List[Parent]
+    def parents(implicit ctx: Context): List[TermOrTypeTree]
     def self(implicit ctx: Context): Option[ValDef]
     def body(implicit ctx: Context): List[Statement]
   }
@@ -156,7 +156,7 @@ trait TreeOps extends TastyCore {
     /** Matches any term */
     def unapply(tree: Tree)(implicit ctx: Context): Option[Term]
     /** Matches any term */
-    def unapply(parent: Parent)(implicit ctx: Context, dummy: DummyImplicit): Option[Term]
+    def unapply(parent: TermOrTypeTree)(implicit ctx: Context, dummy: DummyImplicit): Option[Term]
   }
 
   /** Scala term. Any tree that can go in expression position. */
@@ -286,7 +286,7 @@ trait TreeOps extends TastyCore {
 
     val Inlined: InlinedExtractor
     abstract class InlinedExtractor {
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[Parent], List[Definition], Term)]
+      def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[TermOrTypeTree], List[Definition], Term)]
     }
 
     val SelectOuter: SelectOuterExtractor
@@ -301,5 +301,5 @@ trait TreeOps extends TastyCore {
     }
   }
 
-  implicit def termAsParent(term: Term): Parent
+  implicit def termAsTermOrTypeTree(term: Term): TermOrTypeTree
 }

library/src/scala/tasty/reflect/TypeOrBoundsTreeOps.scala

@@ -19,7 +19,7 @@ trait TypeOrBoundsTreeOps extends TastyCore {
   val IsTypeTree: IsTypeTreeExtractor
   abstract class IsTypeTreeExtractor {
     def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree]
-    def unapply(parent: Parent)(implicit ctx: Context, dummy: DummyImplicit): Option[TypeTree]
+    def unapply(parent: TermOrTypeTree)(implicit ctx: Context, dummy: DummyImplicit): Option[TypeTree]
   }
 
   val TypeTree: TypeTreeModule
@@ -32,18 +32,18 @@ trait TypeOrBoundsTreeOps extends TastyCore {
       def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Boolean
     }
 
-    val TypeIdent: TypeIdentExtractor
-    abstract class TypeIdentExtractor {
+    val Ident: IdentExtractor
+    abstract class IdentExtractor {
       def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[String]
     }
 
-    val TermSelect: TermSelectExtractor
-    abstract class TermSelectExtractor {
+    val Select: SelectExtractor
+    abstract class SelectExtractor {
       def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(Term, String)]
     }
 
-    val TypeSelect: TypeSelectExtractor
-    abstract class TypeSelectExtractor {
+    val Project: ProjectExtractor
+    abstract class ProjectExtractor {
       def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(TypeTree, String)]
     }
 
@@ -119,5 +119,5 @@ trait TypeOrBoundsTreeOps extends TastyCore {
     def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Boolean
   }
 
-  implicit def typeTreeAsParent(term: TypeTree): Parent
+  implicit def typeTreeAsParent(term: TypeTree): TermOrTypeTree
 }

library/src/scala/tasty/util/ShowExtractors.scala

@@ -70,7 +70,7 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         this += "Term.Repeated(" ++= elems += ")"
       case Term.Inlined(call, bindings, expansion) =>
         this += "Term.Inlined("
-        visitOption(call, visitParent)
+        visitOption(call, visitTermOrTypeTree)
         this += ", " ++= bindings += ", " += expansion += ")"
       case ValDef(name, tpt, rhs) =>
         this += "ValDef(\"" += name += "\", " += tpt += ", " += rhs += ")"
@@ -80,7 +80,7 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         this += "TypeDef(\"" += name += "\", " += rhs += ")"
       case ClassDef(name, constr, parents, self, body) =>
         this += "ClassDef(\"" += name += "\", " += constr += ", "
-        visitList[Parent](parents, visitParent)
+        visitList[TermOrTypeTree](parents, visitTermOrTypeTree)
         this += ", " += self += ", " ++= body += ")"
       case PackageDef(name, owner) =>
         this += "PackageDef(\"" += name += "\", " += owner += ")"
@@ -93,12 +93,12 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
     def visitTypeTree(x: TypeOrBoundsTree): Buffer = x match {
       case TypeTree.Synthetic() =>
         this += "TypeTree.Synthetic()"
-      case TypeTree.TypeIdent(name) =>
-        this += "TypeTree.TypeIdent(\"" += name += "\")"
-      case TypeTree.TermSelect(qualifier, name) =>
-        this += "TypeTree.TermSelect(" += qualifier += ", \"" += name += "\")"
-      case TypeTree.TypeSelect(qualifier, name) =>
-        this += "TypeTree.TypeSelect(" += qualifier += ", \"" += name += "\")"
+      case TypeTree.Ident(name) =>
+        this += "TypeTree.Ident(\"" += name += "\")"
+      case TypeTree.Select(qualifier, name) =>
+        this += "TypeTree.Select(" += qualifier += ", \"" += name += "\")"
+      case TypeTree.Project(qualifier, name) =>
+        this += "TypeTree.Project(" += qualifier += ", \"" += name += "\")"
       case TypeTree.Singleton(ref) =>
         this += "TypeTree.Singleton(" += ref += ")"
       case TypeTree.And(left, right) =>
@@ -141,9 +141,9 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         this += "Pattern.TypeTest(" += tpt += ")"
     }
 
-    def visitParent(x: Parent): Buffer = x match {
-      case IsTerm(parent) => this += parent
-      case IsTypeTree(parent) => this += parent
+    def visitTermOrTypeTree(x: TermOrTypeTree): Buffer = x match {
+      case IsTerm(termOrTypeTree) => this += termOrTypeTree
+      case IsTypeTree(termOrTypeTree) => this += termOrTypeTree
     }
 
     def visitConstant(x: Constant): Buffer = x match {

library/src/scala/tasty/util/ShowSourceCode.scala

@@ -116,13 +116,13 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
 
         val parents1 = parents.filter {
           case IsTerm(Term.Apply(Term.Select(Term.New(tpt), _, _), _)) => !Types.JavaLangObject.unapply(tpt.tpe)
-          case IsTypeTree(TypeTree.TermSelect(Term.Select(Term.Ident("_root_"), "scala", _), "Product")) => false
+          case IsTypeTree(TypeTree.Select(Term.Select(Term.Ident("_root_"), "scala", _), "Product")) => false
           case _ => true
         }
         if (parents1.nonEmpty)
           this += " extends "
 
-        def printParent(parent: Parent): Unit = parent match {
+        def printParent(parent: TermOrTypeTree): Unit = parent match {
           case IsTypeTree(parent) =>
             printTypeTree(parent)
           case IsTerm(Term.TypeApply(fun, targs)) =>
@@ -137,7 +137,7 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
             throw new MatchError(parent.show)
         }
 
-        def printSeparated(list: List[Parent]): Unit = list match {
+        def printSeparated(list: List[TermOrTypeTree]): Unit = list match {
           case Nil =>
           case x :: Nil => printParent(x)
           case x :: xs =>
@@ -755,13 +755,13 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         }
         printTypeAndAnnots(tree.tpe)
 
-      case TypeTree.TypeIdent(name) =>
+      case TypeTree.Ident(name) =>
         printType(tree.tpe)
 
-      case TypeTree.TermSelect(qual, name) =>
+      case TypeTree.Select(qual, name) =>
         printTree(qual) += "." += name
 
-      case TypeTree.TypeSelect(qual, name) =>
+      case TypeTree.Project(qual, name) =>
         printTypeTree(qual) += "#" += name
 
       case TypeTree.Singleton(ref) =>

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

@@ -15,7 +15,7 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
   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)
-  private def foldParents(x: X, trees: Iterable[Parent])(implicit ctx: Context): X = (x /: trees)(foldOverParent)
+  private def foldParents(x: X, trees: Iterable[TermOrTypeTree])(implicit ctx: Context): X = (x /: trees)(foldOverTermOrTypeTree)
 
   def foldOverTree(x: X, tree: Tree)(implicit ctx: Context): X = {
     def localCtx(definition: Definition): Context = definition.symbol.localContext
@@ -80,9 +80,9 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
 
   def foldOverTypeTree(x: X, tree: TypeOrBoundsTree)(implicit ctx: Context): X = tree match {
     case TypeTree.Synthetic() => x
-    case TypeTree.TypeIdent(_) => x
-    case TypeTree.TermSelect(qualifier, _) => foldTree(x, qualifier)
-    case TypeTree.TypeSelect(qualifier, _) => foldTypeTree(x, qualifier)
+    case TypeTree.Ident(_) => x
+    case TypeTree.Select(qualifier, _) => foldTree(x, qualifier)
+    case TypeTree.Project(qualifier, _) => foldTypeTree(x, qualifier)
     case TypeTree.Singleton(ref) => foldTree(x, ref)
     case TypeTree.And(left, right) => foldTypeTree(foldTypeTree(x, left), right)
     case TypeTree.Or(left, right) => foldTypeTree(foldTypeTree(x, left), right)
@@ -105,9 +105,9 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
     case Pattern.TypeTest(tpt) => foldTypeTree(x, tpt)
   }
 
-  private def foldOverParent(x: X, tree: Parent)(implicit ctx: Context): X = tree match {
-    case IsTerm(tree) => foldOverTree(x, tree)
-    case IsTypeTree(tree) => foldOverTypeTree(x, tree)
+  private def foldOverTermOrTypeTree(x: X, tree: TermOrTypeTree)(implicit ctx: Context): X = tree match {
+    case IsTerm(termOrTypeTree) => foldOverTree(x, termOrTypeTree)
+    case IsTypeTree(termOrTypeTree) => foldOverTypeTree(x, termOrTypeTree)
   }
 
 }

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

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

tests/run-custom-args/Yretain-trees/tasty-definitions-2.check

@@ -1,2 +1,2 @@
-DefDef("foo", Nil, Nil, TypeTree.TypeIdent("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(1)), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Literal(Constant.Int(2))))))
-ValDef("bar", TypeTree.TypeIdent("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(2)), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Literal(Constant.Int(3))))))
+DefDef("foo", Nil, Nil, TypeTree.Ident("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(1)), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Literal(Constant.Int(2))))))
+ValDef("bar", TypeTree.Ident("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(2)), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Literal(Constant.Int(3))))))

tests/run-custom-args/Yretain-trees/tasty-definitions-3.check

@@ -1,2 +1,2 @@
-DefDef("foo", Nil, Nil, TypeTree.TypeIdent("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(1)), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Literal(Constant.Int(2))))))
-ValDef("bar", TypeTree.TypeIdent("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(2)), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Literal(Constant.Int(3))))))
+DefDef("foo", Nil, Nil, TypeTree.Ident("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(1)), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Literal(Constant.Int(2))))))
+ValDef("bar", TypeTree.Ident("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(2)), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Literal(Constant.Int(3))))))