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 {
@@ -537,7 +544,8 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
       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 copy(original: Tree)(stats: List[Statement], expr: Term)(implicit ctx: Context): Block =
+        tpd.cpy.Block(original)(stats, expr)
 
       def unapply(x: Term)(implicit ctx: Context): Option[(List[Statement], Term)] = x match {
         case IsBlock(x) => Some((x.stats, x.expr))
@@ -562,7 +570,8 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
       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 copy(original: Tree)(call: Option[TermOrTypeTree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined =
+        tpd.cpy.Inlined(original)(call.getOrElse(tpd.EmptyTree), bindings.asInstanceOf[List[tpd.MemberDef]], expansion)
 
       def unapply(x: Term)(implicit ctx: Context): Option[(Option[TermOrTypeTree], List[Statement], Term)] = x match {
         case x: tpd.Inlined =>
@@ -737,10 +746,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

@@ -0,0 +1,2 @@
+32
+33

tests/run-separate-compilation/tasty-tree-map/quoted_1.scala

@@ -0,0 +1,15 @@
+import scala.quoted._
+import scala.tasty._
+
+object Macros {
+
+  implicit inline def identityMaped[T](x: => T): T = ~impl('(x))
+
+  def impl[T: Type](x: Expr[T])(implicit reflection: Reflection): Expr[T] = {
+    import reflection._
+    val identityMap = new TreeMap { }
+    val transformed = identityMap.transformTerm(x.unseal).seal[T]
+    transformed
+  }
+
+}

tests/run/tasty-tree-map.check

@@ -6,5 +6,6 @@ object Test {
   def main(args: Array[String]): Unit = {
     println(identityMaped(32))
     println(identityMaped(32 + 1))
+    // TODO add more tests
   }
 }