Implement TASTy reflect constructors

Author: nicolasstucki

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

@@ -974,13 +974,13 @@ object Trees {
      * so that they selectively retype themselves. Retyping needs a context.
      */
     abstract class TreeCopier {
-      def postProcess(tree: Tree, copied: untpd.Tree): copied.ThisTree[T]
-      def postProcess(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T]
+      protected def postProcess(tree: Tree, copied: untpd.Tree): copied.ThisTree[T]
+      protected def postProcess(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T]
 
-      def finalize(tree: Tree, copied: untpd.Tree): copied.ThisTree[T] =
+      protected def finalize(tree: Tree, copied: untpd.Tree): copied.ThisTree[T] =
         postProcess(tree, copied.withPos(tree.pos).withAttachmentsFrom(tree))
 
-      def finalize(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T] =
+      protected def finalize(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T] =
         postProcess(tree, copied.withPos(tree.pos).withAttachmentsFrom(tree))
 
       def Ident(tree: Tree)(name: Name): Ident = tree match {

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

@@ -10,6 +10,10 @@ trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with CoreImpl with H
   }
 
   object CaseDef extends CaseDefExtractor {
+    def apply(pat: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef = ???
+
+    def copy(original: CaseDef)(pat: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef = ???
+
     def unapply(x: CaseDef): Some[(Pattern, Option[Term], Term)] = Some(x.pat, optional(x.guard), x.body)
   }
 

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

@@ -26,8 +26,9 @@ trait CoreImpl extends scala.tasty.reflect.Core {
       type Term = tpd.Tree
       val Term: TermCoreModuleImpl
       trait TermCoreModuleImpl extends TermCoreModule {
-        type Ident = tpd.Ident
-        type Select = tpd.Select
+        type Ref = tpd.RefTree
+          type Ident = tpd.Ident
+          type Select = tpd.Select
         type Literal = tpd.Literal
         type This = tpd.This
         type New = tpd.New

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

@@ -13,7 +13,13 @@ trait CaseDefOps extends Core {
 
   val CaseDef: CaseDefExtractor
   abstract class CaseDefExtractor {
+
+    def apply(pat: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef
+
+    def copy(original: CaseDef)(pat: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef
+
     def unapply(x: CaseDef): Option[(Pattern, Option[Term], Term)]
+
   }
 
 

library/src/scala/tasty/reflect/CaseDefOps.scala

@@ -13,8 +13,9 @@ package scala.tasty.reflect
  *                         |               +- DefDef
  *                         |               +- ValDef
  *                         |
- *                         +- Term --------+- Ident
- *                                         +- Select
+ *                         +- Term --------+- Ref -+- Ident
+ *                                         |       +- Select
+ *                                         |
  *                                         +- Literal
  *                                         +- This
  *                                         +- New
@@ -164,11 +165,14 @@ trait Core {
       /** Trees representing an expression in the source code */
       trait TermCoreModule {
 
-        /** Tree representing a reference to definition with a given name */
-        type Ident <: Term
+        /** Tree representing a reference to definition */
+        type Ref <: Term
 
-        /** Tree representing a selection of definition with a given name on a given prefix */
-        type Select <: Term
+          /** Tree representing a reference to definition with a given name */
+          type Ident <: Ref
+
+          /** Tree representing a selection of definition with a given name on a given prefix */
+          type Select <: Ref
 
         /** Tree representing a literal value in the source code */
         type Literal <: Term
@@ -316,7 +320,7 @@ trait Core {
     type TypeBoundsTree <: TypeOrBoundsTree
 
     /** Type tree representing wildcard type bounds written in the source.
-     *  The wildcard type `_` (for example in in `List[_]`) will be a type tree that 
+     *  The wildcard type `_` (for example in in `List[_]`) will be a type tree that
      *  represents a type but has `TypeBound`a inside.
      */
     type WildcardType <: TypeOrBoundsTree