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,9 @@ trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with CoreImpl with H
   }
 
   object CaseDef extends CaseDefModule {
+    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

@@ -21,7 +21,10 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
   }
 
   object PackageClause extends PackageClauseModule {
-    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[Tree])] = tree match {
+    def apply(pid: Ref, stats: List[Tree])(implicit ctx: Context): PackageClause =
+      tpd.PackageDef(pid.asInstanceOf[tpd.RefTree], stats)
+
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Ref, List[Tree])] = tree match {
       case x: tpd.PackageDef => Some((x.pid, x.stats))
       case _ => None
     }
@@ -34,6 +37,9 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
   // ----- Statements -----------------------------------------------
 
   object Import extends ImportModule {
+    def apply(expr: Term, selectors: List[ImportSelector])(implicit ctx: Context): Import =
+      tpd.Import(expr, selectors)
+
     def unapply(x: Tree)(implicit ctx: Context): Option[(Term, List[ImportSelector])] = x match {
       case x: tpd.Import => Some((x.expr, x.selectors))
       case _ => None
@@ -69,6 +75,10 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
   }
 
   object ClassDef extends ClassDefModule {
+    def apply(name: String, constr: DefDef, parents: List[TermOrTypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef = {
+      ???
+    }
+
     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))
@@ -95,6 +105,9 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
   }
 
   object DefDef extends DefDefModule {
+    def apply(symbol: DefSymbol, rhsFn: List[Type] => List[List[Term]] => Option[Term])(implicit ctx: Context): DefDef =
+      tpd.polyDefDef(symbol, tparams => vparamss => rhsFn(tparams)(vparamss).getOrElse(tpd.EmptyTree))
+
     def unapply(tree: Tree)(implicit ctx: Context): Option[(String, List[TypeDef],  List[List[ValDef]], TypeTree, Option[Term])] = tree match {
       case x: tpd.DefDef =>
         Some((x.name.toString, x.tparams, x.vparamss, x.tpt, optional(x.rhs)))
@@ -120,6 +133,9 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
   }
 
   object ValDef extends ValDefModule {
+    def apply(symbol: ValSymbol, rhs: Option[Term])(implicit ctx: Context): ValDef =
+      tpd.ValDef(symbol, rhs.getOrElse(tpd.EmptyTree))
+
     def unapply(tree: Tree)(implicit ctx: Context): Option[(String, TypeTree, Option[Term])] = tree match {
       case x: tpd.ValDef =>
         Some((x.name.toString, x.tpt, optional(x.rhs)))
@@ -143,6 +159,8 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
   }
 
   object TypeDef extends TypeDefModule {
+    def apply(symbol: TypeSymbol)(implicit ctx: Context): TypeDef = tpd.TypeDef(symbol)
+
     def unapply(tree: Tree)(implicit ctx: Context): Option[(String, TypeOrBoundsTree /* TypeTree | TypeBoundsTree */)] = tree match {
       case x: tpd.TypeDef if !x.symbol.isClass => Some((x.name.toString, x.rhs))
       case _ => None
@@ -213,7 +231,16 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
       def name(implicit ctx: Context): String = x.name.show
     }
 
+    object Ref extends RefModule {
+      def apply(sym: Symbol)(implicit ctx: Context): Ref = tpd.ref(sym).asInstanceOf[tpd.RefTree]
+      def copy(original: Tree)(name: String)(implicit ctx: Context): Ref = ???
+    }
+
     object Ident extends IdentModule {
+      def apply(name: String)(implicit ctx: Context): Ident = ???
+
+      def copy(original: Tree)(name: String)(implicit ctx: Context): Ident = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[String] = x match {
         case x: tpd.Ident if x.isTerm => Some(x.name.show)
         case _ => None
@@ -236,6 +263,10 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Select extends SelectModule {
+      def apply(qualifier: Term, name: String, signature: Option[Signature])(implicit ctx: Context): Select = ???
+
+      def copy(original: Tree)(qualifier: Term, name: String)(implicit ctx: Context): Select = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, String)] = x match {
         case x: tpd.Select if x.isTerm => Some((x.qualifier, x.name.toString))
         case _ => None
@@ -255,6 +286,12 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Literal extends LiteralModule {
+
+      def apply(constant: Constant)(implicit ctx: Context): Literal =
+        tpd.Literal(constant)
+
+      def copy(original: Tree)(constant: Constant)(implicit ctx: Context): Literal = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[Constant] = x match {
         case Trees.Literal(const) => Some(const)
         case _ => None
@@ -273,6 +310,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object This extends ThisModule {
+
+      def apply(cls: ClassSymbol)(implicit ctx: Context): This = tpd.This(cls)
+
+      def copy(original: Tree)(qual: Option[Id]): This = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[Option[Id]] = x match {
         case Trees.This(qual) => Some(optional(qual))
         case _ => None
@@ -292,6 +334,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object New extends NewModule {
+
+      def apply(tpt: TypeTree)(implicit ctx: Context): New = tpd.New(tpt)
+
+      def copy(original: Tree)(tpt: TypeTree)(implicit ctx: Context): New = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[TypeTree] = x match {
         case x: tpd.New => Some(x.tpt)
         case _ => None
@@ -311,6 +358,12 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object NamedArg extends NamedArgModule {
+
+      def apply(name: String, arg: Term)(implicit ctx: Context): NamedArg =
+        tpd.NamedArg(name.toTermName, arg)
+
+      def copy(tree: NamedArg)(name: String, arg: Term)(implicit ctx: Context): NamedArg = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(String, Term)] = x match {
         case x: tpd.NamedArg if x.name.isInstanceOf[Names.TermName] => Some((x.name.toString, x.arg))
         case _ => None
@@ -330,6 +383,12 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Apply extends ApplyModule {
+
+      def apply(fn: Term, args: List[Term])(implicit ctx: Context): Apply =
+        tpd.Apply(fn, args)
+
+      def copy(original: Tree)(fun: Term, args: List[Term])(implicit ctx: Context): Apply = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, List[Term])] = x match {
         case x: tpd.Apply => Some((x.fun, x.args))
         case _ => None
@@ -349,6 +408,12 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object TypeApply extends TypeApplyModule {
+
+      def apply(fn: Term, args: List[TypeTree])(implicit ctx: Context): TypeApply =
+        tpd.TypeApply(fn, args)
+
+      def copy(original: Tree)(fun: Term, args: List[TypeTree])(implicit ctx: Context): TypeApply = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, List[TypeTree])] = x match {
         case x: tpd.TypeApply => Some((x.fun, x.args))
         case _ => None
@@ -368,6 +433,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Super extends SuperModule {
+      def apply(qual: Term, mix: Option[Id])(implicit ctx: Context): Super =
+        tpd.Super(qual, mix.getOrElse(untpd.EmptyTypeIdent), ???, ???)
+
+      def copy(original: Tree)(qual: Term, mix: Option[Id]): Super = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, Option[Id])] = x match {
         case x: tpd.Super => Some((x.qual, if (x.mix.isEmpty) None else Some(x.mix)))
         case _ => None
@@ -387,6 +457,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Typed extends TypedModule {
+      def apply(expr: Term, tpt: TypeTree)(implicit ctx: Context): Typed =
+        tpd.Typed(expr, tpt)
+
+      def copy(original: Tree)(expr: Term, tpt: TypeTree)(implicit ctx: Context): Typed = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, TypeTree)] = x match {
         case x: tpd.Typed => Some((x.expr, x.tpt))
         case _ => None
@@ -406,6 +481,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Assign extends AssignModule {
+      def apply(lhs: Term, rhs: Term)(implicit ctx: Context): Assign =
+        tpd.Assign(lhs, rhs)
+
+      def copy(original: Tree)(lhs: Term, rhs: Term)(implicit ctx: Context): Assign = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, Term)] = x match {
         case x: tpd.Assign => Some((x.lhs, x.rhs))
         case _ => None
@@ -454,6 +534,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Block extends BlockModule {
+      def apply(stats: List[Statement], expr: Term)(implicit ctx: Context): Block =
+        tpd.Block(stats, expr)
+
+      def copy(original: Tree)(stats: List[Statement], expr: Term)(implicit ctx: Context): Block = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(List[Statement], Term)] = x match {
         case IsBlock(x) => Some((x.stats, x.expr))
         case _ => None
@@ -474,6 +559,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Inlined extends InlinedModule {
+      def apply(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
+        tpd.Inlined(call.getOrElse(tpd.EmptyTree), bindings.map { case b: tpd.MemberDef => b }, expansion)
+
+      def copy(original: Tree)(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined = ???
+
       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))
@@ -494,6 +584,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Lambda extends LambdaModule {
+      def apply(meth: Term, tpt: Option[TypeTree])(implicit ctx: Context): Lambda =
+        tpd.Closure(Nil, meth, tpt.getOrElse(tpd.EmptyTree))
+
+      def copy(original: Tree)(meth: Tree, tpt: Tree)(implicit ctx: Context): Lambda = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, Option[TypeTree])] = x match {
         case x: tpd.Closure => Some((x.meth, optional(x.tpt)))
         case _ => None
@@ -514,6 +609,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object If extends IfModule {
+      def apply(cond: Term, thenp: Term, elsep: Term)(implicit ctx: Context): If =
+        tpd.If(cond, thenp, elsep)
+
+      def copy(original: Tree)(cond: Term, thenp: Term, elsep: Term)(implicit ctx: Context): If = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, Term, Term)] = x match {
         case x: tpd.If => Some((x.cond, x.thenp, x.elsep))
         case _ => None
@@ -533,6 +633,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Match extends MatchModule {
+      def apply(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match =
+        tpd.Match(selector, cases)
+
+      def copy(original: Tree)(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, List[CaseDef])] = x match {
         case x: tpd.Match => Some((x.selector, x.cases))
         case _ => None
@@ -553,6 +658,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Try extends TryModule {
+      def apply(expr: Term, cases: List[CaseDef], finalizer: Option[Term])(implicit ctx: Context): Try =
+        tpd.Try(expr, cases, finalizer.getOrElse(tpd.EmptyTree))
+
+      def copy(original: Tree)(expr: Term, cases: List[CaseDef], finalizer: Option[Term])(implicit ctx: Context): Try = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, List[CaseDef], Option[Term])] = x match {
         case x: tpd.Try => Some((x.expr, x.cases, optional(x.finalizer)))
         case _ => None
@@ -571,6 +681,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Return extends ReturnModule {
+      def apply(expr: Term)(implicit ctx: Context): Return =
+        tpd.Return(expr, ctx.owner)
+
+      def copy(original: Tree)(expr: Term)(implicit ctx: Context): Return = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[Term] = x match {
         case x: tpd.Return => Some(x.expr)
         case _ => None
@@ -589,6 +704,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Repeated extends RepeatedModule {
+      def apply(elems: List[Term])(implicit ctx: Context): Repeated =
+        tpd.SeqLiteral(elems, ???)
+
+      def copy(original: Tree)(elems: List[Term])(implicit ctx: Context): Repeated = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[List[Term]] = x match {
         case x: tpd.SeqLiteral => Some(x.elems)
         case _ => None
@@ -616,6 +736,12 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object SelectOuter extends SelectOuterModule {
+
+      def apply(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
+        tpd.Inlined(call.getOrElse(tpd.EmptyTree), bindings.map { case b: tpd.MemberDef => b }, expansion)
+
+      def copy(original: Tree)(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, Int, Type)] = x match {
         case x: tpd.Select =>
           x.name match {
@@ -639,6 +765,11 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object While extends WhileModule {
+      def apply(cond: Term, body: Term)(implicit ctx: Context): While =
+        tpd.WhileDo(cond, body)
+
+      def copy(original: Tree)(cond: Term, body: Term)(implicit ctx: Context): While = ???
+
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, Term)] = x match {
         case x: tpd.WhileDo => Some((x.cond, x.body))
         case _ => None

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

@@ -13,6 +13,11 @@ trait CaseDefOps extends Core {
 
   val CaseDef: CaseDefModule
   abstract class CaseDefModule {
+
+    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)]
   }