WIP

Author: nicolasstucki

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

@@ -21,10 +21,10 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
   }
 
   object PackageClause extends PackageClauseModule {
-    def apply(pid: Ref, stats: List[Tree])(implicit ctx: Context): PackageClause =
+    def apply(pid: Term.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 {
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term.Ref, List[Tree])] = tree match {
       case x: tpd.PackageDef => Some((x.pid, x.stats))
       case _ => None
     }
@@ -34,8 +34,6 @@ 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)
@@ -51,6 +49,15 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     def selector(implicit ctx: Context): List[ImportSelector] = imp.selectors
   }
 
+  object IsStatement extends IsStatementModule {
+    /** Matches any Statement and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Statement] = tree match {
+      case IsDefinition(tree) => Some(tree)
+      case tree if tree.isTerm => Some(tree)
+      case _ => None
+    }
+  }
+
   // ----- Definitions ----------------------------------------------
 
   object IsDefinition extends IsDefinitionModule {
@@ -737,10 +744,9 @@ 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 apply(qualifier: Term, levels: Int, tpe: Type)(implicit ctx: Context): SelectOuter = ???
 
-      def copy(original: Tree)(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined = ???
+      def copy(original: Tree)(qualifier: Term, levels: Int, tpe: Type)(implicit ctx: Context): SelectOuter = ???
 
       def unapply(x: Term)(implicit ctx: Context): Option[(Term, Int, Type)] = x match {
         case x: tpd.Select =>

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

@@ -18,17 +18,15 @@ trait TreeOps extends Core {
 
   val PackageClause: PackageClauseModule
   abstract class PackageClauseModule {
-    def apply(pid: Ref, stats: List[Tree])(implicit ctx: Context): PackageClause
-    def unapply(tree: Tree)(implicit ctx: Context): Option[(Ref, List[Tree])]
+    def apply(pid: Term.Ref, stats: List[Tree])(implicit ctx: Context): PackageClause
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Term.Ref, List[Tree])]
   }
 
   trait PackageClauseAPI {
 
   }
   implicit def PackageClauseDeco(pack: PackageClause): PackageClauseAPI
 
-  // ----- Statements -----------------------------------------------
-
   val Import: ImportModule
   abstract class ImportModule {
     def apply(expr: Term, selectors: List[ImportSelector])(implicit ctx: Context): Import
@@ -41,6 +39,13 @@ trait TreeOps extends Core {
   }
   implicit def ImportDeco(imp: Import): ImportAPI
 
+
+  val IsStatement: IsStatementModule
+  abstract class IsStatementModule {
+    /** Matches any Statement and returns it */
+    def unapply(tree: Tree)(implicit ctx: Context): Option[Statement]
+  }
+
   // ----- Definitions ----------------------------------------------
 
   val IsDefinition: IsDefinitionModule

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

@@ -158,15 +158,20 @@ trait TreeUtils
     def transformTree(tree: Tree)(implicit ctx: Context): Tree = {
       def localCtx(definition: Definition): Context = definition.symbol.localContext
       tree match {
-        case IsTerm(tree) => transformTerm(tree)
+        case IsStatement(tree) => transformStatement(tree)
       }
     }
 
+    def transformStatement(tree: Statement)(implicit ctx: Context): Statement = tree match {
+        case IsTerm(tree) => transformTerm(tree)
+
+    }
+
     def transformTerm(tree: Term)(implicit ctx: Context): Term = {
       tree match {
         case Term.Ident(name) =>
           tree
-        case Term.Select(qualifier, name, sig) =>
+        case Term.Select(qualifier, name) =>
           Term.Select.copy(tree)(transformTerm(qualifier), name)
         case Term.This(qual) =>
           tree
@@ -186,8 +191,8 @@ trait TreeUtils
 //          NamedArg.copy(tree)(name, transform(arg))
 //        case Assign(lhs, rhs) =>
 //          Assign.copy(tree)(transform(lhs), transform(rhs))
-//        case Block(stats, expr) =>
-//          Block.copy(tree)(transformStats(stats), transform(expr))
+        case Term.Block(stats, expr) =>
+          Term.Block.copy(tree)(transformStats(stats), transformTerm(expr))
 //        case If(cond, thenp, elsep) =>
 //          If.copy(tree)(transform(cond), transform(thenp), transform(elsep))
 //        case Closure(env, meth, tpt) =>
@@ -269,6 +274,9 @@ trait TreeUtils
       ???
     }
 
+    def transformStats(trees: List[Statement])(implicit ctx: Context): List[Statement] =
+      trees mapConserve (transformStatement(_))
+
     def transformTrees(trees: List[Tree])(implicit ctx: Context): List[Tree] =
       trees mapConserve (transformTree(_))
 

tests/run-separate-compilation/tasty-tree-map.check renamed to tests/run/tasty-tree-map.check

@@ -1,14 +1,11 @@
 import scala.quoted._
 
-import scala.tasty._
-
-
 object Macros {
 
   implicit inline def identityMaped(x: => Unit): Unit = ~impl('(x))
 
-  def impl(x: Expr[Unit])(implicit staging: Staging): Expr[Unit] = {
-    import staging.reflection._
+  def impl(x: Expr[Unit])(implicit st: StagingContext): Expr[Unit] = {
+    import st.reflection._
     val identityMap = new TreeMap { }
     val transformed = identityMap.transformTerm(x.reflect).reify[Unit]
     '(println(~transformed))