Remove Context from TreeMap and TreeAccumulator

Author: nicolasstucki

library/src-bootstrapped/scala/internal/quoted/Matcher.scala

@@ -265,7 +265,7 @@ object Matcher {
             def bodyFn(lambdaArgs: List[Tree]): Tree = {
               val argsMap = args.map(_.symbol).zip(lambdaArgs.asInstanceOf[List[Term]]).toMap
               new TreeMap {
-                override def transformTerm(tree: Term)(using ctx: Context): Term =
+                override def transformTerm(tree: Term): Term =
                   tree match
                     case tree: Ident => summon[Env].get(tree.symbol).flatMap(argsMap.get).getOrElse(tree)
                     case tree => super.transformTerm(tree)
@@ -429,7 +429,7 @@ object Matcher {
       /** Return all free variables of the term defined in the pattern (i.e. defined in `Env`) */
       def freePatternVars(term: Term)(using env: Env): Set[Symbol] =
         val accumulator = new TreeAccumulator[Set[Symbol]] {
-          def foldTree(x: Set[Symbol], tree: Tree)(using ctx: Context): Set[Symbol] =
+          def foldTree(x: Set[Symbol], tree: Tree): Set[Symbol] =
             tree match
               case tree: Ident if env.contains(tree.symbol) => foldOverTree(x + tree.symbol, tree)
               case _ => foldOverTree(x, tree)

library/src-bootstrapped/scala/quoted/unsafe/UnsafeExpr.scala

@@ -61,7 +61,7 @@ object UnsafeExpr {
     import qctx.tasty._
     val map = params.map(_.symbol).zip(args).toMap
     new TreeMap {
-      override def transformTerm(tree: Term)(using ctx: Context): Term =
+      override def transformTerm(tree: Term): Term =
         super.transformTerm(tree) match
           case tree: Ident => map.getOrElse(tree.symbol, tree)
           case tree => tree

library/src/scala/tasty/reflect/TreeAccumulator.scala

@@ -7,23 +7,23 @@ package reflect
  *  ```
  *  class MyTreeAccumulator[R <: scala.tasty.Reflection & Singleton](val reflect: R)
  *      extends scala.tasty.reflect.TreeAccumulator[X] {
- *    import reflect.{given _, _}
- *    def foldTree(x: X, tree: Tree)(using ctx: Context): X = ...
+ *    import reflect._
+ *    def foldTree(x: X, tree: Tree): X = ...
  *  }
  *  ```
  */
 trait TreeAccumulator[X] {
 
   val reflect: Reflection
-  import reflect.{given _, _}
+  import reflect._
 
   // Ties the knot of the traversal: call `foldOver(x, tree))` to dive in the `tree` node.
-  def foldTree(x: X, tree: Tree)(using ctx: Context): X
+  def foldTree(x: X, tree: Tree): X
 
-  def foldTrees(x: X, trees: Iterable[Tree])(using ctx: Context): X = trees.foldLeft(x)(foldTree)
+  def foldTrees(x: X, trees: Iterable[Tree]): X = trees.foldLeft(x)(foldTree)
 
-  def foldOverTree(x: X, tree: Tree)(using ctx: Context): X = {
-    def localCtx(definition: Definition): Context = ctx // definition.symbol.localContext // FIXME
+  def foldOverTree(x: X, tree: Tree): X = {
+    // def localCtx(definition: Definition): Context = ctx // definition.symbol.localContext // FIXME
     tree match {
       case Ident(_) =>
         x
@@ -66,20 +66,20 @@ trait TreeAccumulator[X] {
       case Inlined(call, bindings, expansion) =>
         foldTree(foldTrees(x, bindings), expansion)
       case vdef @ ValDef(_, tpt, rhs) =>
-        val ctx = localCtx(vdef)
-        given Context = ctx
+        // val ctx = localCtx(vdef)
+        // given Context = ctx
         foldTrees(foldTree(x, tpt), rhs)
       case ddef @ DefDef(_, tparams, vparamss, tpt, rhs) =>
-        val ctx = localCtx(ddef)
-        given Context = ctx
+        // val ctx = localCtx(ddef)
+        // given Context = ctx
         foldTrees(foldTree(vparamss.foldLeft(foldTrees(x, tparams))(foldTrees), tpt), rhs)
       case tdef @ TypeDef(_, rhs) =>
-        val ctx = localCtx(tdef)
-        given Context = ctx
+        // val ctx = localCtx(tdef)
+        // given Context = ctx
         foldTree(x, rhs)
       case cdef @ ClassDef(_, constr, parents, derived, self, body) =>
-        val ctx = localCtx(cdef)
-        given Context = ctx
+        // val ctx = localCtx(cdef)
+        // given Context = ctx
         foldTrees(foldTrees(foldTrees(foldTrees(foldTree(x, constr), parents), derived), self), body)
       case Import(expr, _) =>
         foldTree(x, expr)

library/src/scala/tasty/reflect/TreeMap.scala

@@ -7,17 +7,17 @@ package reflect
  *  ```
  *  class MyTreeMap[R <: scala.tasty.Reflection & Singleton](val reflect: R)
  *      extends scala.tasty.reflect.TreeMap {
- *    import reflect.{given _, _}
- *    override def transformTree(tree: Tree)(using ctx: Context): Tree = ...
+ *    import reflect._
+ *    override def transformTree(tree: Tree): Tree = ...
  *  }
  *  ```
  */
 trait TreeMap {
 
   val reflect: Reflection
-  import reflect.{given _, _}
+  import reflect._
 
-  def transformTree(tree: Tree)(using ctx: Context): Tree = {
+  def transformTree(tree: Tree): Tree = {
     tree match {
       case tree: PackageClause =>
         PackageClause.copy(tree)(transformTerm(tree.pid).asInstanceOf[Ref], transformTrees(tree.stats)/*(using tree.symbol.localContext)*/)
@@ -41,24 +41,24 @@ trait TreeMap {
     }
   }
 
-  def transformStatement(tree: Statement)(using ctx: Context): Statement = {
-    def localCtx(definition: Definition): Context = ctx // definition.symbol.localContext
+  def transformStatement(tree: Statement): Statement = {
+    // def localCtx(definition: Definition): Context = ctx // definition.symbol.localContext
     tree match {
       case tree: Term =>
         transformTerm(tree)
       case tree: ValDef =>
-        val ctx = localCtx(tree)
-        given Context = ctx
+        // val ctx = localCtx(tree)
+        // given Context = ctx
         val tpt1 = transformTypeTree(tree.tpt)
         val rhs1 = tree.rhs.map(x => transformTerm(x))
         ValDef.copy(tree)(tree.name, tpt1, rhs1)
       case tree: DefDef =>
-        val ctx = localCtx(tree)
-        given Context = ctx
+        // val ctx = localCtx(tree)
+        // given Context = ctx
         DefDef.copy(tree)(tree.name, transformSubTrees(tree.typeParams), tree.paramss mapConserve (transformSubTrees(_)), transformTypeTree(tree.returnTpt), tree.rhs.map(x => transformTerm(x)))
       case tree: TypeDef =>
-        val ctx = localCtx(tree)
-        given Context = ctx
+        // val ctx = localCtx(tree)
+        // given Context = ctx
         TypeDef.copy(tree)(tree.name, transformTree(tree.rhs))
       case tree: ClassDef =>
         ClassDef.copy(tree)(tree.name, tree.constructor, tree.parents, tree.derived, tree.self, tree.body)
@@ -67,7 +67,7 @@ trait TreeMap {
     }
   }
 
-  def transformTerm(tree: Term)(using ctx: Context): Term = {
+  def transformTerm(tree: Term): Term = {
     tree match {
       case Ident(name) =>
         tree
@@ -112,7 +112,7 @@ trait TreeMap {
     }
   }
 
-  def transformTypeTree(tree: TypeTree)(using ctx: Context): TypeTree = tree match {
+  def transformTypeTree(tree: TypeTree): TypeTree = tree match {
     case Inferred() => tree
     case tree: TypeIdent => tree
     case tree: TypeSelect =>
@@ -139,33 +139,33 @@ trait TreeMap {
       TypeBlock.copy(tree)(tree.aliases, tree.tpt)
   }
 
-  def transformCaseDef(tree: CaseDef)(using ctx: Context): CaseDef = {
+  def transformCaseDef(tree: CaseDef): CaseDef = {
     CaseDef.copy(tree)(transformTree(tree.pattern), tree.guard.map(transformTerm), transformTerm(tree.rhs))
   }
 
-  def transformTypeCaseDef(tree: TypeCaseDef)(using ctx: Context): TypeCaseDef = {
+  def transformTypeCaseDef(tree: TypeCaseDef): TypeCaseDef = {
     TypeCaseDef.copy(tree)(transformTypeTree(tree.pattern), transformTypeTree(tree.rhs))
   }
 
-  def transformStats(trees: List[Statement])(using ctx: Context): List[Statement] =
+  def transformStats(trees: List[Statement]): List[Statement] =
     trees mapConserve (transformStatement(_))
 
-  def transformTrees(trees: List[Tree])(using ctx: Context): List[Tree] =
+  def transformTrees(trees: List[Tree]): List[Tree] =
     trees mapConserve (transformTree(_))
 
-  def transformTerms(trees: List[Term])(using ctx: Context): List[Term] =
+  def transformTerms(trees: List[Term]): List[Term] =
     trees mapConserve (transformTerm(_))
 
-  def transformTypeTrees(trees: List[TypeTree])(using ctx: Context): List[TypeTree] =
+  def transformTypeTrees(trees: List[TypeTree]): List[TypeTree] =
     trees mapConserve (transformTypeTree(_))
 
-  def transformCaseDefs(trees: List[CaseDef])(using ctx: Context): List[CaseDef] =
+  def transformCaseDefs(trees: List[CaseDef]): List[CaseDef] =
     trees mapConserve (transformCaseDef(_))
 
-  def transformTypeCaseDefs(trees: List[TypeCaseDef])(using ctx: Context): List[TypeCaseDef] =
+  def transformTypeCaseDefs(trees: List[TypeCaseDef]): List[TypeCaseDef] =
     trees mapConserve (transformTypeCaseDef(_))
 
-  def transformSubTrees[Tr <: Tree](trees: List[Tr])(using ctx: Context): List[Tr] =
+  def transformSubTrees[Tr <: Tree](trees: List[Tr]): List[Tr] =
     transformTrees(trees).asInstanceOf[List[Tr]]
 
 }

library/src/scala/tasty/reflect/TreeTraverser.scala

@@ -7,19 +7,19 @@ package reflect
  *  ```
  *  class MyTraverser[R <: scala.tasty.Reflection & Singleton](val reflect: R)
  *      extends scala.tasty.reflect.TreeTraverser {
- *    import reflect.{given _, _}
- *    override def traverseTree(tree: Tree)(using ctx: Context): Unit = ...
+ *    import reflect._
+ *    override def traverseTree(tree: Tree): Unit = ...
  *  }
  *  ```
  */
 trait TreeTraverser extends TreeAccumulator[Unit] {
 
   import reflect._
 
-  def traverseTree(tree: Tree)(using ctx: Context): Unit = traverseTreeChildren(tree)
+  def traverseTree(tree: Tree): Unit = traverseTreeChildren(tree)
 
-  def foldTree(x: Unit, tree: Tree)(using ctx: Context): Unit = traverseTree(tree)
+  def foldTree(x: Unit, tree: Tree): Unit = traverseTree(tree)
 
-  protected def traverseTreeChildren(tree: Tree)(using ctx: Context): Unit = foldOverTree((), tree)
+  protected def traverseTreeChildren(tree: Tree): Unit = foldOverTree((), tree)
 
 }

tests/run-custom-args/tasty-inspector/tasty-comment-inspector/Test.scala

@@ -13,7 +13,7 @@ class CommentInspector extends TastyInspector {
     import reflect.{_, given _}
     object Traverser extends TreeTraverser {
 
-      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = tree match {
+      override def traverseTree(tree: Tree): Unit = tree match {
         case tree: Definition =>
           tree.symbol.comment match {
             case Some(com) => println(com.raw)

tests/run-custom-args/tasty-inspector/tasty-inspector/Test.scala

@@ -13,7 +13,7 @@ class DBInspector extends TastyInspector {
     import reflect.{_, given _}
     object Traverser extends TreeTraverser {
 
-      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = tree match {
+      override def traverseTree(tree: Tree): Unit = tree match {
         case tree: Definition =>
           println(tree.showExtractors)
           super.traverseTree(tree)

tests/run-custom-args/tasty-interpreter/interpreter/TastyInterpreter.scala

@@ -9,7 +9,7 @@ class TastyInterpreter extends TastyInspector {
     import reflect.{_, given _}
     object Traverser extends TreeTraverser {
 
-      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = tree match {
+      override def traverseTree(tree: Tree): Unit = tree match {
         // TODO: check the correct sig and object enclosement for main
         case DefDef("main", _, _, _, Some(rhs)) =>
           val interpreter = new jvm.Interpreter(this.reflect)

tests/run-macros/tasty-custom-show/quoted_1.scala

@@ -12,7 +12,7 @@ object Macros {
     val buff = new StringBuilder
 
     val output = new TreeTraverser {
-      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = {
+      override def traverseTree(tree: Tree): Unit = {
         // Use custom Show[_] here
         val printer = dummyShow
         tree match {

tests/run-macros/tasty-extractors-3/quoted_1.scala

@@ -11,7 +11,7 @@ object Macros {
 
     val buff = new StringBuilder
     val traverser = new TreeTraverser {
-      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = tree match {
+      override def traverseTree(tree: Tree): Unit = tree match {
         case tree: TypeBoundsTree =>
           buff.append(tree.tpe.showExtractors)
           buff.append("\n\n")