diff --git a/community-build/community-projects/sourcecode b/community-build/community-projects/sourcecode
index 48a4427210af..10375294d6de 160000
--- a/community-build/community-projects/sourcecode
+++ b/community-build/community-projects/sourcecode
@@ -1 +1 @@
-Subproject commit 48a4427210af622c00dfecf3e2ce327846eeffb3
+Subproject commit 10375294d6de6b49485dd2b7bacac3e007095c89
diff --git a/community-build/community-projects/utest b/community-build/community-projects/utest
index 88d174371483..7662ed1dd428 160000
--- a/community-build/community-projects/utest
+++ b/community-build/community-projects/utest
@@ -1 +1 @@
-Subproject commit 88d1743714835b8243cac332b3e76b363fa836b3
+Subproject commit 7662ed1dd428e641fdc3323a3521cecca28c388a
diff --git a/compiler/src/scala/quoted/internal/impl/Matcher.scala b/compiler/src/scala/quoted/internal/impl/Matcher.scala
index 92b91e0f4496..ba004a4794bf 100644
--- a/compiler/src/scala/quoted/internal/impl/Matcher.scala
+++ b/compiler/src/scala/quoted/internal/impl/Matcher.scala
@@ -199,11 +199,11 @@ 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)(owner: Symbol): Term =
                   tree match
                     case tree: Ident => summon[Env].get(tree.symbol).flatMap(argsMap.get).getOrElse(tree)
-                    case tree => super.transformTerm(tree)
-              }.transformTree(scrutinee)
+                    case tree => super.transformTerm(tree)(owner)
+              }.transformTree(scrutinee)(Symbol.spliceOwner)
             }
             val names = args.map {
               case Block(List(DefDef("$anonfun", _, _, _, Some(Apply(Ident(name), _)))), _) => name
@@ -211,7 +211,7 @@ object Matcher {
             }
             val argTypes = args.map(x => x.tpe.widenTermRefExpr)
             val resType = pattern.tpe
-            val res = Lambda(Symbol.currentOwner, MethodType(names)(_ => argTypes, _ => resType), (meth, x) => bodyFn(x).changeOwner(meth))
+            val res = Lambda(Symbol.spliceOwner, MethodType(names)(_ => argTypes, _ => resType), (meth, x) => bodyFn(x).changeOwner(meth))
             matched(res.asExpr)
 
           //
@@ -354,12 +354,12 @@ object Matcher {
       /** Return all free variables of the term defined in the pattern (i.e. defined in `Env`) */
       def freePatternVars(term: Term)(using ctx: Context, 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)(owner: Symbol): Set[Symbol] =
             tree match
-              case tree: Ident if env.contains(tree.symbol) => foldOverTree(x + tree.symbol, tree)
-              case _ => foldOverTree(x, tree)
+              case tree: Ident if env.contains(tree.symbol) => foldOverTree(x + tree.symbol, tree)(owner)
+              case _ => foldOverTree(x, tree)(owner)
         }
-        accumulator.foldTree(Set.empty, term)
+        accumulator.foldTree(Set.empty, term)(Symbol.spliceOwner)
     }
 
     private object IdentArgs {
diff --git a/compiler/src/scala/quoted/internal/impl/QuoteContextImpl.scala b/compiler/src/scala/quoted/internal/impl/QuoteContextImpl.scala
index 6557e15c859e..31822596bce8 100644
--- a/compiler/src/scala/quoted/internal/impl/QuoteContextImpl.scala
+++ b/compiler/src/scala/quoted/internal/impl/QuoteContextImpl.scala
@@ -2205,7 +2205,6 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
 
     object Symbol extends SymbolModule:
       def spliceOwner: Symbol = ctx.owner
-      def currentOwner(using ctx: Context): Symbol = ctx.owner
       def requiredPackage(path: String): Symbol = dotc.core.Symbols.requiredPackage(path)
       def requiredClass(path: String): Symbol = dotc.core.Symbols.requiredClass(path)
       def requiredModule(path: String): Symbol = dotc.core.Symbols.requiredModule(path)
@@ -2244,8 +2243,6 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
         def fullName: String = self.denot.fullName.toString
         def pos: Position = self.sourcePos
 
-        def localContext: Context =
-          if self.exists then ctx.withOwner(self) else ctx
         def documentation: Option[Documentation] =
           import dotc.core.Comments.CommentsContext
           val docCtx = ctx.docCtx.getOrElse {
diff --git a/library/src-bootstrapped/scala/quoted/ExprMap.scala b/library/src-bootstrapped/scala/quoted/ExprMap.scala
index fef1ec689375..f045309a959a 100644
--- a/library/src-bootstrapped/scala/quoted/ExprMap.scala
+++ b/library/src-bootstrapped/scala/quoted/ExprMap.scala
@@ -10,96 +10,94 @@ trait ExprMap:
     import qctx.reflect._
     final class MapChildren() {
 
-      def transformStatement(tree: Statement)(using ctx: Context): Statement = {
-        def localCtx(definition: Definition): Context = definition.symbol.localContext
+      def transformStatement(tree: Statement)(owner: Symbol): Statement = {
         tree match {
           case tree: Term =>
-            transformTerm(tree, TypeRepr.of[Any])
+            transformTerm(tree, TypeRepr.of[Any])(owner)
           case tree: Definition =>
-            transformDefinition(tree)
+            transformDefinition(tree)(owner)
           case tree: Import =>
             tree
         }
       }
 
-      def transformDefinition(tree: Definition)(using ctx: Context): Definition = {
-        def localCtx(definition: Definition): Context = definition.symbol.localContext
+      def transformDefinition(tree: Definition)(owner: Symbol): Definition = {
         tree match {
           case tree: ValDef =>
-            given Context = localCtx(tree)
-            val rhs1 = tree.rhs.map(x => transformTerm(x, tree.tpt.tpe))
+            val owner = tree.symbol
+            val rhs1 = tree.rhs.map(x => transformTerm(x, tree.tpt.tpe)(owner))
             ValDef.copy(tree)(tree.name, tree.tpt, rhs1)
           case tree: DefDef =>
-            given Context = localCtx(tree)
-            DefDef.copy(tree)(tree.name, tree.typeParams, tree.paramss, tree.returnTpt, tree.rhs.map(x => transformTerm(x, tree.returnTpt.tpe)))
+            val owner = tree.symbol
+            DefDef.copy(tree)(tree.name, tree.typeParams, tree.paramss, tree.returnTpt, tree.rhs.map(x => transformTerm(x, tree.returnTpt.tpe)(owner)))
           case tree: TypeDef =>
             tree
           case tree: ClassDef =>
-            val newBody = transformStats(tree.body)
+            val newBody = transformStats(tree.body)(owner)
             ClassDef.copy(tree)(tree.name, tree.constructor, tree.parents, tree.derived, tree.self, newBody)
         }
       }
 
-      def transformTermChildren(tree: Term, tpe: TypeRepr)(using ctx: Context): Term = tree match {
+      def transformTermChildren(tree: Term, tpe: TypeRepr)(owner: Symbol): Term = tree match {
         case Ident(name) =>
           tree
         case Select(qualifier, name) =>
-          Select.copy(tree)(transformTerm(qualifier, qualifier.tpe), name)
+          Select.copy(tree)(transformTerm(qualifier, qualifier.tpe)(owner), name)
         case This(qual) =>
           tree
         case Super(qual, mix) =>
           tree
         case tree as Apply(fun, args) =>
           val MethodType(_, tpes, _) = fun.tpe.widen
-          Apply.copy(tree)(transformTerm(fun, TypeRepr.of[Any]), transformTerms(args, tpes))
+          Apply.copy(tree)(transformTerm(fun, TypeRepr.of[Any])(owner), transformTerms(args, tpes)(owner))
         case TypeApply(fun, args) =>
-          TypeApply.copy(tree)(transformTerm(fun, TypeRepr.of[Any]), args)
+          TypeApply.copy(tree)(transformTerm(fun, TypeRepr.of[Any])(owner), args)
         case _: Literal =>
           tree
         case New(tpt) =>
-          New.copy(tree)(transformTypeTree(tpt))
+          New.copy(tree)(transformTypeTree(tpt)(owner))
         case Typed(expr, tpt) =>
           val tp = tpt.tpe match
             case AppliedType(TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "<repeated>"), List(tp0: TypeRepr)) =>
               TypeRepr.of[Seq].appliedTo(tp0)
             case tp => tp
-          Typed.copy(tree)(transformTerm(expr, tp), transformTypeTree(tpt))
+          Typed.copy(tree)(transformTerm(expr, tp)(owner), transformTypeTree(tpt)(owner))
         case tree: NamedArg =>
-          NamedArg.copy(tree)(tree.name, transformTerm(tree.value, tpe))
+          NamedArg.copy(tree)(tree.name, transformTerm(tree.value, tpe)(owner))
         case Assign(lhs, rhs) =>
-          Assign.copy(tree)(lhs, transformTerm(rhs, lhs.tpe.widen))
+          Assign.copy(tree)(lhs, transformTerm(rhs, lhs.tpe.widen)(owner))
         case Block(stats, expr) =>
-          Block.copy(tree)(transformStats(stats), transformTerm(expr, tpe))
+          Block.copy(tree)(transformStats(stats)(owner), transformTerm(expr, tpe)(owner))
         case If(cond, thenp, elsep) =>
           If.copy(tree)(
-            transformTerm(cond, TypeRepr.of[Boolean]),
-            transformTerm(thenp, tpe),
-            transformTerm(elsep, tpe))
+            transformTerm(cond, TypeRepr.of[Boolean])(owner),
+            transformTerm(thenp, tpe)(owner),
+            transformTerm(elsep, tpe)(owner))
         case _: Closure =>
           tree
         case Match(selector, cases) =>
-          Match.copy(tree)(transformTerm(selector, selector.tpe), transformCaseDefs(cases, tpe))
+          Match.copy(tree)(transformTerm(selector, selector.tpe)(owner), transformCaseDefs(cases, tpe)(owner))
         case Return(expr) =>
           // FIXME
           // ctx.owner seems to be set to the wrong symbol
           // Return.copy(tree)(transformTerm(expr, expr.tpe))
           tree
         case While(cond, body) =>
-          While.copy(tree)(transformTerm(cond, TypeRepr.of[Boolean]), transformTerm(body, TypeRepr.of[Any]))
+          While.copy(tree)(transformTerm(cond, TypeRepr.of[Boolean])(owner), transformTerm(body, TypeRepr.of[Any])(owner))
         case Try(block, cases, finalizer) =>
-          Try.copy(tree)(transformTerm(block, tpe), transformCaseDefs(cases, TypeRepr.of[Any]), finalizer.map(x => transformTerm(x, TypeRepr.of[Any])))
+          Try.copy(tree)(transformTerm(block, tpe)(owner), transformCaseDefs(cases, TypeRepr.of[Any])(owner), finalizer.map(x => transformTerm(x, TypeRepr.of[Any])(owner)))
         case Repeated(elems, elemtpt) =>
-          Repeated.copy(tree)(transformTerms(elems, elemtpt.tpe), elemtpt)
+          Repeated.copy(tree)(transformTerms(elems, elemtpt.tpe)(owner), elemtpt)
         case Inlined(call, bindings, expansion) =>
-          Inlined.copy(tree)(call, transformDefinitions(bindings), transformTerm(expansion, tpe)/*()call.symbol.localContext)*/)
+          Inlined.copy(tree)(call, transformDefinitions(bindings)(owner), transformTerm(expansion, tpe)(owner))
       }
 
-      def transformTerm(tree: Term, tpe: TypeRepr)(using ctx: Context): Term =
+      def transformTerm(tree: Term, tpe: TypeRepr)(owner: Symbol): Term =
         tree match
           case _: Closure =>
             tree
           case _: Inlined =>
-            transformTermChildren(tree, tpe)
+            transformTermChildren(tree, tpe)(owner)
           case _ if tree.isExpr =>
             type X
             val expr = tree.asExpr.asInstanceOf[Expr[X]]
@@ -107,45 +105,44 @@ trait ExprMap:
             val transformedExpr = transform(expr)(using qctx, t)
             Term.of(transformedExpr)
           case _ =>
-            transformTermChildren(tree, tpe)
+            transformTermChildren(tree, tpe)(owner)
 
-      def transformTypeTree(tree: TypeTree)(using ctx: Context): TypeTree = tree
+      def transformTypeTree(tree: TypeTree)(owner: Symbol): TypeTree = tree
 
-      def transformCaseDef(tree: CaseDef, tpe: TypeRepr)(using ctx: Context): CaseDef =
-        CaseDef.copy(tree)(tree.pattern, tree.guard.map(x => transformTerm(x, TypeRepr.of[Boolean])), transformTerm(tree.rhs, tpe))
+      def transformCaseDef(tree: CaseDef, tpe: TypeRepr)(owner: Symbol): CaseDef =
+        CaseDef.copy(tree)(tree.pattern, tree.guard.map(x => transformTerm(x, TypeRepr.of[Boolean])(owner)), transformTerm(tree.rhs, tpe)(owner))
 
-      def transformTypeCaseDef(tree: TypeCaseDef)(using ctx: Context): TypeCaseDef = {
-        TypeCaseDef.copy(tree)(transformTypeTree(tree.pattern), transformTypeTree(tree.rhs))
-      }
+      def transformTypeCaseDef(tree: TypeCaseDef)(owner: Symbol): TypeCaseDef =
+        TypeCaseDef.copy(tree)(transformTypeTree(tree.pattern)(owner), transformTypeTree(tree.rhs)(owner))
 
-      def transformStats(trees: List[Statement])(using ctx: Context): List[Statement] =
-        trees mapConserve (transformStatement(_))
+      def transformStats(trees: List[Statement])(owner: Symbol): List[Statement] =
+        trees.mapConserve(x => transformStatement(x)(owner))
 
-      def transformDefinitions(trees: List[Definition])(using ctx: Context): List[Definition] =
-        trees mapConserve (transformDefinition(_))
+      def transformDefinitions(trees: List[Definition])(owner: Symbol): List[Definition] =
+        trees.mapConserve(x => transformDefinition(x)(owner))
 
-      def transformTerms(trees: List[Term], tpes: List[TypeRepr])(using ctx: Context): List[Term] =
+      def transformTerms(trees: List[Term], tpes: List[TypeRepr])(owner: Symbol): List[Term] =
         var tpes2 = tpes // TODO use proper zipConserve
-        trees mapConserve { x =>
+        trees.mapConserve{ x =>
           val tpe :: tail = tpes2
           tpes2 = tail
-          transformTerm(x, tpe)
+          transformTerm(x, tpe)(owner)
         }
 
-      def transformTerms(trees: List[Term], tpe: TypeRepr)(using ctx: Context): List[Term] =
-        trees.mapConserve(x => transformTerm(x, tpe))
+      def transformTerms(trees: List[Term], tpe: TypeRepr)(owner: Symbol): List[Term] =
+        trees.mapConserve(x => transformTerm(x, tpe)(owner))
 
-      def transformTypeTrees(trees: List[TypeTree])(using ctx: Context): List[TypeTree] =
-        trees mapConserve (transformTypeTree(_))
+      def transformTypeTrees(trees: List[TypeTree])(owner: Symbol): List[TypeTree] =
+        trees.mapConserve(x => transformTypeTree(x)(owner))
 
-      def transformCaseDefs(trees: List[CaseDef], tpe: TypeRepr)(using ctx: Context): List[CaseDef] =
-        trees mapConserve (x => transformCaseDef(x, tpe))
+      def transformCaseDefs(trees: List[CaseDef], tpe: TypeRepr)(owner: Symbol): List[CaseDef] =
+        trees.mapConserve(x => transformCaseDef(x, tpe)(owner))
 
-      def transformTypeCaseDefs(trees: List[TypeCaseDef])(using ctx: Context): List[TypeCaseDef] =
-        trees mapConserve (transformTypeCaseDef(_))
+      def transformTypeCaseDefs(trees: List[TypeCaseDef])(owner: Symbol): List[TypeCaseDef] =
+        trees.mapConserve(x => transformTypeCaseDef(x)(owner))
 
     }
-    new MapChildren().transformTermChildren(Term.of(e), TypeRepr.of[T]).asExprOf[T]
+    new MapChildren().transformTermChildren(Term.of(e), TypeRepr.of[T])(Symbol.spliceOwner).asExprOf[T]
   }
 
 end ExprMap
diff --git a/library/src/scala/quoted/QuoteContext.scala b/library/src/scala/quoted/QuoteContext.scala
index 277b5a8d7132..3397b388bb3e 100644
--- a/library/src/scala/quoted/QuoteContext.scala
+++ b/library/src/scala/quoted/QuoteContext.scala
@@ -2685,9 +2685,6 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
        */
       def spliceOwner: Symbol
 
-      /** Returns the symbol of the current enclosing definition */
-      def currentOwner(using ctx: Context): Symbol
-
       /** Get package symbol if package is either defined in current compilation run or present on classpath. */
       def requiredPackage(path: String): Symbol
 
@@ -2782,8 +2779,6 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
         /** The position of this symbol */
         def pos: Position
 
-        def localContext: Context
-
         /** The documentation for this symbol, if any */
         def documentation: Option[Documentation]
 
@@ -3427,101 +3422,96 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
     *  class MyTreeAccumulator[R <: scala.tasty.Reflection & Singleton](val reflect: R)
     *      extends scala.tasty.reflect.TreeAccumulator[X] {
     *    import reflect._
-    *    def foldTree(x: X, tree: Tree)(using ctx: Context): X = ...
+    *    def foldTree(x: X, tree: Tree)(owner: Symbol): X = ...
     *  }
     *  ```
     */
     trait TreeAccumulator[X]:
 
       // 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)(owner: Symbol): X
 
-      def foldTrees(x: X, trees: Iterable[Tree])(using ctx: Context): X = trees.foldLeft(x)(foldTree)
+      def foldTrees(x: X, trees: Iterable[Tree])(owner: Symbol): X = trees.foldLeft(x)((acc, y) => foldTree(acc, y)(owner))
 
-      def foldOverTree(x: X, tree: Tree)(using ctx: Context): X = {
-        def localCtx(definition: Definition): Context = definition.symbol.localContext
+      def foldOverTree(x: X, tree: Tree)(owner: Symbol): X = {
         tree match {
           case Ident(_) =>
             x
           case Select(qualifier, _) =>
-            foldTree(x, qualifier)
+            foldTree(x, qualifier)(owner)
           case This(qual) =>
             x
           case Super(qual, _) =>
-            foldTree(x, qual)
+            foldTree(x, qual)(owner)
           case Apply(fun, args) =>
-            foldTrees(foldTree(x, fun), args)
+            foldTrees(foldTree(x, fun)(owner), args)(owner)
           case TypeApply(fun, args) =>
-            foldTrees(foldTree(x, fun), args)
+            foldTrees(foldTree(x, fun)(owner), args)(owner)
           case Literal(const) =>
             x
           case New(tpt) =>
-            foldTree(x, tpt)
+            foldTree(x, tpt)(owner)
           case Typed(expr, tpt) =>
-            foldTree(foldTree(x, expr), tpt)
+            foldTree(foldTree(x, expr)(owner), tpt)(owner)
           case NamedArg(_, arg) =>
-            foldTree(x, arg)
+            foldTree(x, arg)(owner)
           case Assign(lhs, rhs) =>
-            foldTree(foldTree(x, lhs), rhs)
+            foldTree(foldTree(x, lhs)(owner), rhs)(owner)
           case Block(stats, expr) =>
-            foldTree(foldTrees(x, stats), expr)
+            foldTree(foldTrees(x, stats)(owner), expr)(owner)
           case If(cond, thenp, elsep) =>
-            foldTree(foldTree(foldTree(x, cond), thenp), elsep)
+            foldTree(foldTree(foldTree(x, cond)(owner), thenp)(owner), elsep)(owner)
           case While(cond, body) =>
-            foldTree(foldTree(x, cond), body)
+            foldTree(foldTree(x, cond)(owner), body)(owner)
           case Closure(meth, tpt) =>
-            foldTree(x, meth)
+            foldTree(x, meth)(owner)
           case Match(selector, cases) =>
-            foldTrees(foldTree(x, selector), cases)
+            foldTrees(foldTree(x, selector)(owner), cases)(owner)
           case Return(expr, _) =>
-            foldTree(x, expr)
+            foldTree(x, expr)(owner)
           case Try(block, handler, finalizer) =>
-            foldTrees(foldTrees(foldTree(x, block), handler), finalizer)
+            foldTrees(foldTrees(foldTree(x, block)(owner), handler)(owner), finalizer)(owner)
           case Repeated(elems, elemtpt) =>
-            foldTrees(foldTree(x, elemtpt), elems)
+            foldTrees(foldTree(x, elemtpt)(owner), elems)(owner)
           case Inlined(call, bindings, expansion) =>
-            foldTree(foldTrees(x, bindings), expansion)
+            foldTree(foldTrees(x, bindings)(owner), expansion)(owner)
           case vdef @ ValDef(_, tpt, rhs) =>
-            val ctx = localCtx(vdef)
-            given Context = ctx
-            foldTrees(foldTree(x, tpt), rhs)
+            val owner = vdef.symbol
+            foldTrees(foldTree(x, tpt)(owner), rhs)(owner)
           case ddef @ DefDef(_, tparams, vparamss, tpt, rhs) =>
-            val ctx = localCtx(ddef)
-            given Context = ctx
-            foldTrees(foldTree(vparamss.foldLeft(foldTrees(x, tparams))(foldTrees), tpt), rhs)
+            val owner = ddef.symbol
+            foldTrees(foldTree(vparamss.foldLeft(foldTrees(x, tparams)(owner))((acc, y) => foldTrees(acc, y)(owner)), tpt)(owner), rhs)(owner)
           case tdef @ TypeDef(_, rhs) =>
-            val ctx = localCtx(tdef)
-            given Context = ctx
-            foldTree(x, rhs)
+            val owner = tdef.symbol
+            foldTree(x, rhs)(owner)
           case cdef @ ClassDef(_, constr, parents, derived, self, body) =>
-            val ctx = localCtx(cdef)
-            given Context = ctx
-            foldTrees(foldTrees(foldTrees(foldTrees(foldTree(x, constr), parents), derived), self), body)
+            val owner = cdef.symbol
+            foldTrees(foldTrees(foldTrees(foldTrees(foldTree(x, constr)(owner), parents)(owner), derived)(owner), self)(owner), body)(owner)
           case Import(expr, _) =>
-            foldTree(x, expr)
+            foldTree(x, expr)(owner)
           case clause @ PackageClause(pid, stats) =>
-            foldTrees(foldTree(x, pid), stats)(using clause.symbol.localContext)
+            foldTrees(foldTree(x, pid)(owner), stats)(clause.symbol)
           case Inferred() => x
           case TypeIdent(_) => x
-          case TypeSelect(qualifier, _) => foldTree(x, qualifier)
-          case Projection(qualifier, _) => foldTree(x, qualifier)
-          case Singleton(ref) => foldTree(x, ref)
-          case Refined(tpt, refinements) => foldTrees(foldTree(x, tpt), refinements)
-          case Applied(tpt, args) => foldTrees(foldTree(x, tpt), args)
-          case ByName(result) => foldTree(x, result)
-          case Annotated(arg, annot) => foldTree(foldTree(x, arg), annot)
-          case LambdaTypeTree(typedefs, arg) => foldTree(foldTrees(x, typedefs), arg)
-          case TypeBind(_, tbt) => foldTree(x, tbt)
-          case TypeBlock(typedefs, tpt) => foldTree(foldTrees(x, typedefs), tpt)
+          case TypeSelect(qualifier, _) => foldTree(x, qualifier)(owner)
+          case Projection(qualifier, _) => foldTree(x, qualifier)(owner)
+          case Singleton(ref) => foldTree(x, ref)(owner)
+          case Refined(tpt, refinements) => foldTrees(foldTree(x, tpt)(owner), refinements)(owner)
+          case Applied(tpt, args) => foldTrees(foldTree(x, tpt)(owner), args)(owner)
+          case ByName(result) => foldTree(x, result)(owner)
+          case Annotated(arg, annot) => foldTree(foldTree(x, arg)(owner), annot)(owner)
+          case LambdaTypeTree(typedefs, arg) => foldTree(foldTrees(x, typedefs)(owner), arg)(owner)
+          case TypeBind(_, tbt) => foldTree(x, tbt)(owner)
+          case TypeBlock(typedefs, tpt) => foldTree(foldTrees(x, typedefs)(owner), tpt)(owner)
           case MatchTypeTree(boundopt, selector, cases) =>
-            foldTrees(foldTree(boundopt.fold(x)(foldTree(x, _)), selector), cases)
+            foldTrees(foldTree(boundopt.fold(x)(y => foldTree(x, y)(owner)), selector)(owner), cases)(owner)
           case WildcardTypeTree() => x
-          case TypeBoundsTree(lo, hi) => foldTree(foldTree(x, lo), hi)
-          case CaseDef(pat, guard, body) => foldTree(foldTrees(foldTree(x, pat), guard), body)
-          case TypeCaseDef(pat, body) => foldTree(foldTree(x, pat), body)
-          case Bind(_, body) => foldTree(x, body)
-          case Unapply(fun, implicits, patterns) => foldTrees(foldTrees(foldTree(x, fun), implicits), patterns)
-          case Alternatives(patterns) => foldTrees(x, patterns)
+          case TypeBoundsTree(lo, hi) => foldTree(foldTree(x, lo)(owner), hi)(owner)
+          case CaseDef(pat, guard, body) => foldTree(foldTrees(foldTree(x, pat)(owner), guard)(owner), body)(owner)
+          case TypeCaseDef(pat, body) => foldTree(foldTree(x, pat)(owner), body)(owner)
+          case Bind(_, body) => foldTree(x, body)(owner)
+          case Unapply(fun, implicits, patterns) => foldTrees(foldTrees(foldTree(x, fun)(owner), implicits)(owner), patterns)(owner)
+          case Alternatives(patterns) => foldTrees(x, patterns)(owner)
         }
       }
     end TreeAccumulator
@@ -3534,17 +3524,17 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
     *  class MyTraverser[R <: scala.tasty.Reflection & Singleton](val reflect: R)
     *      extends scala.tasty.reflect.TreeTraverser {
     *    import reflect._
-    *    override def traverseTree(tree: Tree)(using ctx: Context): Unit = ...
+    *    override def traverseTree(tree: Tree)(owner: Symbol): Unit = ...
     *  }
     *  ```
     */
     trait TreeTraverser extends TreeAccumulator[Unit]:
 
-      def traverseTree(tree: Tree)(using ctx: Context): Unit = traverseTreeChildren(tree)
+      def traverseTree(tree: Tree)(owner: Symbol): Unit = traverseTreeChildren(tree)(owner)
 
-      def foldTree(x: Unit, tree: Tree)(using ctx: Context): Unit = traverseTree(tree)
+      def foldTree(x: Unit, tree: Tree)(owner: Symbol): Unit = traverseTree(tree)(owner)
 
-      protected def traverseTreeChildren(tree: Tree)(using ctx: Context): Unit = foldOverTree((), tree)
+      protected def traverseTreeChildren(tree: Tree)(owner: Symbol): Unit = foldOverTree((), tree)(owner)
 
     end TreeTraverser
 
@@ -3554,108 +3544,104 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
     *  ```
     *  import qctx.reflect._
     *  class MyTreeMap extends TreeMap {
-    *    override def transformTree(tree: Tree)(using ctx: Context): Tree = ...
+    *    override def transformTree(tree: Tree)(owner: Symbol): Tree = ...
     *  }
     *  ```
     */
     trait TreeMap:
 
-      def transformTree(tree: Tree)(using ctx: Context): Tree = {
+      def transformTree(tree: Tree)(owner: Symbol): Tree = {
         tree match {
           case tree: PackageClause =>
-            PackageClause.copy(tree)(transformTerm(tree.pid).asInstanceOf[Ref], transformTrees(tree.stats)(using tree.symbol.localContext))
+            PackageClause.copy(tree)(transformTerm(tree.pid).asInstanceOf[Ref], transformTrees(tree.stats)(tree.symbol))
           case tree: Import =>
-            Import.copy(tree)(transformTerm(tree.expr), tree.selectors)
+            Import.copy(tree)(transformTerm(tree.expr)(owner), tree.selectors)
           case tree: Statement =>
-            transformStatement(tree)
-          case tree: TypeTree => transformTypeTree(tree)
+            transformStatement(tree)(owner)
+          case tree: TypeTree => transformTypeTree(tree)(owner)
           case tree: TypeBoundsTree => tree // TODO traverse tree
           case tree: WildcardTypeTree => tree // TODO traverse tree
           case tree: CaseDef =>
-            transformCaseDef(tree)
+            transformCaseDef(tree)(owner)
           case tree: TypeCaseDef =>
-            transformTypeCaseDef(tree)
+            transformTypeCaseDef(tree)(owner)
           case pattern: Bind =>
             Bind.copy(pattern)(pattern.name, pattern.pattern)
           case pattern: Unapply =>
-            Unapply.copy(pattern)(transformTerm(pattern.fun), transformSubTrees(pattern.implicits), transformTrees(pattern.patterns))
+            Unapply.copy(pattern)(transformTerm(pattern.fun)(owner), transformSubTrees(pattern.implicits)(owner), transformTrees(pattern.patterns)(owner))
           case pattern: Alternatives =>
-            Alternatives.copy(pattern)(transformTrees(pattern.patterns))
+            Alternatives.copy(pattern)(transformTrees(pattern.patterns)(owner))
         }
       }
 
-      def transformStatement(tree: Statement)(using ctx: Context): Statement = {
-        def localCtx(definition: Definition): Context = definition.symbol.localContext
+      def transformStatement(tree: Statement)(owner: Symbol): Statement = {
         tree match {
           case tree: Term =>
-            transformTerm(tree)
+            transformTerm(tree)(owner)
           case tree: ValDef =>
-            val ctx = localCtx(tree)
-            given Context = ctx
-            val tpt1 = transformTypeTree(tree.tpt)
-            val rhs1 = tree.rhs.map(x => transformTerm(x))
+            val owner = tree.symbol
+            val tpt1 = transformTypeTree(tree.tpt)(owner)
+            val rhs1 = tree.rhs.map(x => transformTerm(x)(owner))
             ValDef.copy(tree)(tree.name, tpt1, rhs1)
           case tree: DefDef =>
-            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)))
+            val owner = tree.symbol
+            DefDef.copy(tree)(tree.name, transformSubTrees(tree.typeParams)(owner), tree.paramss mapConserve (x => transformSubTrees(x)(owner)), transformTypeTree(tree.returnTpt)(owner), tree.rhs.map(x => transformTerm(x)(owner)))
           case tree: TypeDef =>
-            val ctx = localCtx(tree)
-            given Context = ctx
-            TypeDef.copy(tree)(tree.name, transformTree(tree.rhs))
+            val owner = tree.symbol
+            TypeDef.copy(tree)(tree.name, transformTree(tree.rhs)(owner))
           case tree: ClassDef =>
             ClassDef.copy(tree)(tree.name, tree.constructor, tree.parents, tree.derived, tree.self, tree.body)
           case tree: Import =>
-            Import.copy(tree)(transformTerm(tree.expr), tree.selectors)
+            Import.copy(tree)(transformTerm(tree.expr)(owner), tree.selectors)
         }
       }
 
-      def transformTerm(tree: Term)(using ctx: Context): Term = {
+      def transformTerm(tree: Term)(owner: Symbol): Term = {
         tree match {
           case Ident(name) =>
             tree
           case Select(qualifier, name) =>
-            Select.copy(tree)(transformTerm(qualifier), name)
+            Select.copy(tree)(transformTerm(qualifier)(owner), name)
           case This(qual) =>
             tree
           case Super(qual, mix) =>
-            Super.copy(tree)(transformTerm(qual), mix)
+            Super.copy(tree)(transformTerm(qual)(owner), mix)
           case Apply(fun, args) =>
-            Apply.copy(tree)(transformTerm(fun), transformTerms(args))
+            Apply.copy(tree)(transformTerm(fun)(owner), transformTerms(args)(owner))
           case TypeApply(fun, args) =>
-            TypeApply.copy(tree)(transformTerm(fun), transformTypeTrees(args))
+            TypeApply.copy(tree)(transformTerm(fun)(owner), transformTypeTrees(args)(owner))
           case Literal(const) =>
             tree
           case New(tpt) =>
-            New.copy(tree)(transformTypeTree(tpt))
+            New.copy(tree)(transformTypeTree(tpt)(owner))
           case Typed(expr, tpt) =>
-            Typed.copy(tree)(transformTerm(expr), transformTypeTree(tpt))
+            Typed.copy(tree)(transformTerm(expr)(owner), transformTypeTree(tpt)(owner))
           case tree: NamedArg =>
-            NamedArg.copy(tree)(tree.name, transformTerm(tree.value))
+            NamedArg.copy(tree)(tree.name, transformTerm(tree.value)(owner))
           case Assign(lhs, rhs) =>
-            Assign.copy(tree)(transformTerm(lhs), transformTerm(rhs))
+            Assign.copy(tree)(transformTerm(lhs)(owner), transformTerm(rhs)(owner))
           case Block(stats, expr) =>
-            Block.copy(tree)(transformStats(stats), transformTerm(expr))
+            Block.copy(tree)(transformStats(stats)(owner), transformTerm(expr)(owner))
           case If(cond, thenp, elsep) =>
-            If.copy(tree)(transformTerm(cond), transformTerm(thenp), transformTerm(elsep))
+            If.copy(tree)(transformTerm(cond)(owner), transformTerm(thenp)(owner), transformTerm(elsep)(owner))
           case Closure(meth, tpt) =>
-            Closure.copy(tree)(transformTerm(meth), tpt)
+            Closure.copy(tree)(transformTerm(meth)(owner), tpt)
           case Match(selector, cases) =>
-            Match.copy(tree)(transformTerm(selector), transformCaseDefs(cases))
+            Match.copy(tree)(transformTerm(selector)(owner), transformCaseDefs(cases)(owner))
           case Return(expr, from) =>
-            Return.copy(tree)(transformTerm(expr), from)
+            Return.copy(tree)(transformTerm(expr)(owner), from)
           case While(cond, body) =>
-            While.copy(tree)(transformTerm(cond), transformTerm(body))
+            While.copy(tree)(transformTerm(cond)(owner), transformTerm(body)(owner))
           case Try(block, cases, finalizer) =>
-            Try.copy(tree)(transformTerm(block), transformCaseDefs(cases), finalizer.map(x => transformTerm(x)))
+            Try.copy(tree)(transformTerm(block)(owner), transformCaseDefs(cases)(owner), finalizer.map(x => transformTerm(x)(owner)))
           case Repeated(elems, elemtpt) =>
-            Repeated.copy(tree)(transformTerms(elems), transformTypeTree(elemtpt))
+            Repeated.copy(tree)(transformTerms(elems)(owner), transformTypeTree(elemtpt)(owner))
           case Inlined(call, bindings, expansion) =>
-            Inlined.copy(tree)(call, transformSubTrees(bindings), transformTerm(expansion)/*()call.symbol.localContext)*/)
+            Inlined.copy(tree)(call, transformSubTrees(bindings)(owner), transformTerm(expansion)(owner))
         }
       }
 
-      def transformTypeTree(tree: TypeTree)(using ctx: Context): TypeTree = tree match {
+      def transformTypeTree(tree: TypeTree)(owner: Symbol): TypeTree = tree match {
         case Inferred() => tree
         case tree: TypeIdent => tree
         case tree: TypeSelect =>
@@ -3665,51 +3651,51 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
         case tree: Annotated =>
           Annotated.copy(tree)(tree.arg, tree.annotation)
         case tree: Singleton =>
-          Singleton.copy(tree)(transformTerm(tree.ref))
+          Singleton.copy(tree)(transformTerm(tree.ref)(owner))
         case tree: Refined =>
-          Refined.copy(tree)(transformTypeTree(tree.tpt), transformTrees(tree.refinements).asInstanceOf[List[Definition]])
+          Refined.copy(tree)(transformTypeTree(tree.tpt)(owner), transformTrees(tree.refinements)(owner).asInstanceOf[List[Definition]])
         case tree: Applied =>
-          Applied.copy(tree)(transformTypeTree(tree.tpt), transformTrees(tree.args))
+          Applied.copy(tree)(transformTypeTree(tree.tpt)(owner), transformTrees(tree.args)(owner))
         case tree: MatchTypeTree =>
-          MatchTypeTree.copy(tree)(tree.bound.map(b => transformTypeTree(b)), transformTypeTree(tree.selector), transformTypeCaseDefs(tree.cases))
+          MatchTypeTree.copy(tree)(tree.bound.map(b => transformTypeTree(b)(owner)), transformTypeTree(tree.selector)(owner), transformTypeCaseDefs(tree.cases)(owner))
         case tree: ByName =>
-          ByName.copy(tree)(transformTypeTree(tree.result))
+          ByName.copy(tree)(transformTypeTree(tree.result)(owner))
         case tree: LambdaTypeTree =>
-          LambdaTypeTree.copy(tree)(transformSubTrees(tree.tparams), transformTree(tree.body))
+          LambdaTypeTree.copy(tree)(transformSubTrees(tree.tparams)(owner), transformTree(tree.body)(owner))
         case tree: TypeBind =>
           TypeBind.copy(tree)(tree.name, tree.body)
         case tree: TypeBlock =>
           TypeBlock.copy(tree)(tree.aliases, tree.tpt)
       }
 
-      def transformCaseDef(tree: CaseDef)(using ctx: Context): CaseDef = {
-        CaseDef.copy(tree)(transformTree(tree.pattern), tree.guard.map(transformTerm), transformTerm(tree.rhs))
+      def transformCaseDef(tree: CaseDef)(owner: Symbol): CaseDef = {
+        CaseDef.copy(tree)(transformTree(tree.pattern)(owner), tree.guard.map(x => transformTerm(x)(owner)), transformTerm(tree.rhs)(owner))
       }
 
-      def transformTypeCaseDef(tree: TypeCaseDef)(using ctx: Context): TypeCaseDef = {
-        TypeCaseDef.copy(tree)(transformTypeTree(tree.pattern), transformTypeTree(tree.rhs))
+      def transformTypeCaseDef(tree: TypeCaseDef)(owner: Symbol): TypeCaseDef = {
+        TypeCaseDef.copy(tree)(transformTypeTree(tree.pattern)(owner), transformTypeTree(tree.rhs)(owner))
       }
 
-      def transformStats(trees: List[Statement])(using ctx: Context): List[Statement] =
-        trees mapConserve (transformStatement(_))
+      def transformStats(trees: List[Statement])(owner: Symbol): List[Statement] =
+        trees mapConserve (x => transformStatement(x)(owner))
 
-      def transformTrees(trees: List[Tree])(using ctx: Context): List[Tree] =
-        trees mapConserve (transformTree(_))
+      def transformTrees(trees: List[Tree])(owner: Symbol): List[Tree] =
+        trees mapConserve (x => transformTree(x)(owner))
 
-      def transformTerms(trees: List[Term])(using ctx: Context): List[Term] =
-        trees mapConserve (transformTerm(_))
+      def transformTerms(trees: List[Term])(owner: Symbol): List[Term] =
+        trees mapConserve (x => transformTerm(x)(owner))
 
-      def transformTypeTrees(trees: List[TypeTree])(using ctx: Context): List[TypeTree] =
-        trees mapConserve (transformTypeTree(_))
+      def transformTypeTrees(trees: List[TypeTree])(owner: Symbol): List[TypeTree] =
+        trees mapConserve (x => transformTypeTree(x)(owner))
 
-      def transformCaseDefs(trees: List[CaseDef])(using ctx: Context): List[CaseDef] =
-        trees mapConserve (transformCaseDef(_))
+      def transformCaseDefs(trees: List[CaseDef])(owner: Symbol): List[CaseDef] =
+        trees mapConserve (x => transformCaseDef(x)(owner))
 
-      def transformTypeCaseDefs(trees: List[TypeCaseDef])(using ctx: Context): List[TypeCaseDef] =
-        trees mapConserve (transformTypeCaseDef(_))
+      def transformTypeCaseDefs(trees: List[TypeCaseDef])(owner: Symbol): List[TypeCaseDef] =
+        trees mapConserve (x => transformTypeCaseDef(x)(owner))
 
-      def transformSubTrees[Tr <: Tree](trees: List[Tr])(using ctx: Context): List[Tr] =
-        transformTrees(trees).asInstanceOf[List[Tr]]
+      def transformSubTrees[Tr <: Tree](trees: List[Tr])(owner: Symbol): List[Tr] =
+        transformTrees(trees)(owner).asInstanceOf[List[Tr]]
 
     end TreeMap
 
diff --git a/scala3doc/src/dotty/dokka/tasty/TastyParser.scala b/scala3doc/src/dotty/dokka/tasty/TastyParser.scala
index 4d88ed152470..656adda4218a 100644
--- a/scala3doc/src/dotty/dokka/tasty/TastyParser.scala
+++ b/scala3doc/src/dotty/dokka/tasty/TastyParser.scala
@@ -188,12 +188,12 @@ case class TastyParser(qctx: QuoteContext, inspector: DokkaBaseTastyInspector, c
     object Traverser extends TreeTraverser:
       var seen: List[Tree] = Nil
 
-      override def traverseTree(tree: Tree)(using ctx: Context): Unit =
+      override def traverseTree(tree: Tree)(owner: Symbol): Unit =
         seen = tree :: seen
         tree match {
           case pck: PackageClause =>
             docs += parsePackage(pck)
-            super.traverseTree(tree)
+            super.traverseTree(tree)(owner)
           case packageObject: ClassDef if(packageObject.symbol.name.contains("package$")) =>
             docs += parsePackageObject(packageObject)
           case clazz: ClassDef if clazz.symbol.shouldDocumentClasslike =>
@@ -202,7 +202,7 @@ case class TastyParser(qctx: QuoteContext, inspector: DokkaBaseTastyInspector, c
         }
         seen = seen.tail
 
-    try Traverser.traverseTree(root)(using qctx.reflect.rootContext)
+    try Traverser.traverseTree(root)(Symbol.spliceOwner)
     catch case e: Throwable =>
       println(s"Problem parsing ${root.pos}, documentation may not be generated.")
       e.printStackTrace()
diff --git a/tests/pos-macros/i10151/Macro_1.scala b/tests/pos-macros/i10151/Macro_1.scala
index 1c0b3b2383a6..02aae2ed8091 100644
--- a/tests/pos-macros/i10151/Macro_1.scala
+++ b/tests/pos-macros/i10151/Macro_1.scala
@@ -39,13 +39,13 @@ object X:
                              List(Inferred(a.tpe.widen))
                             ),
                    List(
-                     Lambda(Symbol.currentOwner, mty, (meth, yArgs) =>
+                     Lambda(Symbol.spliceOwner, mty, (meth, yArgs) =>
                        Apply(
                           TypeApply(Select.unique(transform(z),"map"),
                              List(Inferred(a.tpe.widen))
                           ),
                           List(
-                            Lambda(Symbol.currentOwner, mtz, (_, zArgs) => {
+                            Lambda(Symbol.spliceOwner, mtz, (_, zArgs) => {
                               val termYArgs = yArgs.asInstanceOf[List[Term]]
                               val termZArgs = zArgs.asInstanceOf[List[Term]]
                               Apply(x,List(termYArgs.head,termZArgs.head))
@@ -70,7 +70,7 @@ object X:
             val paramTypes = params.map(_.tpt.tpe)
             val paramNames = params.map(_.name)
             val mt = MethodType(paramNames)(_ => paramTypes, _ => TypeRepr.of[CB].appliedTo(body.tpe.widen) )
-            Lambda(Symbol.currentOwner, mt, (meth, args) => changeArgs(params,args,transform(body)).changeOwner(meth) )
+            Lambda(Symbol.spliceOwner, mt, (meth, args) => changeArgs(params,args,transform(body)).changeOwner(meth) )
           case Block(stats, last) =>
             Block(stats, shiftLambda(last))
           case _ =>
@@ -82,12 +82,12 @@ object X:
              case (m, (oldParam, newParam: Tree)) => throw RuntimeException("Term expected")
          }
          val changes = new TreeMap() {
-             override def transformTerm(tree:Term)(using Context): Term =
+             override def transformTerm(tree:Term)(owner: Symbol): Term =
                tree match
-                 case ident@Ident(name) => association.getOrElse(ident.symbol, super.transformTerm(tree))
-                 case _ => super.transformTerm(tree)
+                 case ident@Ident(name) => association.getOrElse(ident.symbol, super.transformTerm(tree)(owner))
+                 case _ => super.transformTerm(tree)(owner)
          }
-         changes.transformTerm(body)
+         changes.transformTerm(body)(Symbol.spliceOwner)
 
    val r = transform(Term.of(f)).asExprOf[CB[T]]
    r
diff --git a/tests/pos-macros/i10211/Macro_1.scala b/tests/pos-macros/i10211/Macro_1.scala
index 156f7f3f941e..9f5ff9e4008a 100644
--- a/tests/pos-macros/i10211/Macro_1.scala
+++ b/tests/pos-macros/i10211/Macro_1.scala
@@ -66,7 +66,7 @@ object X:
         case Apply(Select(obj,"=="),List(b)) =>
              val tb = transform(b).asExprOf[CB[Int]]
              val mt = MethodType(List("p"))(_ => List(b.tpe.widen), _ => TypeRepr.of[Boolean])
-             val mapLambda = Lambda(Symbol.currentOwner, mt, (_, x) => Select.overloaded(obj,"==",List(),List(x.head.asInstanceOf[Term]))).asExprOf[Int=>Boolean]
+             val mapLambda = Lambda(Symbol.spliceOwner, mt, (_, x) => Select.overloaded(obj,"==",List(),List(x.head.asInstanceOf[Term]))).asExprOf[Int=>Boolean]
              Term.of('{ CBM.map($tb)($mapLambda) })
         case Block(stats, last) => Block(stats, transform(last))
         case Inlined(x,List(),body) => transform(body)
@@ -81,7 +81,7 @@ object X:
             val paramTypes = params.map(_.tpt.tpe)
             val paramNames = params.map(_.name)
             val mt = MethodType(paramNames)(_ => paramTypes, _ => TypeRepr.of[CB].appliedTo(body.tpe.widen) )
-            val r = Lambda(Symbol.currentOwner, mt, (meth, args) => changeArgs(params,args,transform(body)).changeOwner(meth) )
+            val r = Lambda(Symbol.spliceOwner, mt, (meth, args) => changeArgs(params,args,transform(body)).changeOwner(meth) )
             r
           case _ =>
             throw RuntimeException("lambda expected")
@@ -92,11 +92,11 @@ object X:
              case (m, (oldParam, newParam: Tree)) => throw RuntimeException("Term expected")
          }
          val changes = new TreeMap() {
-             override def transformTerm(tree:Term)(using Context): Term =
+             override def transformTerm(tree:Term)(owner: Symbol): Term =
                tree match
-                 case ident@Ident(name) => association.getOrElse(ident.symbol, super.transformTerm(tree))
-                 case _ => super.transformTerm(tree)
+                 case ident@Ident(name) => association.getOrElse(ident.symbol, super.transformTerm(tree)(owner))
+                 case _ => super.transformTerm(tree)(owner)
          }
-         changes.transformTerm(body)
+         changes.transformTerm(body)(Symbol.spliceOwner)
 
    transform(Term.of(f)).asExprOf[CB[T]]
diff --git a/tests/pos-macros/i6535/Macro_1.scala b/tests/pos-macros/i6535/Macro_1.scala
index de0c7a887289..ec4b6addaff2 100644
--- a/tests/pos-macros/i6535/Macro_1.scala
+++ b/tests/pos-macros/i6535/Macro_1.scala
@@ -11,10 +11,10 @@ object scalatest {
 
     Term.of(cond).underlyingArgument match {
       case t @ Apply(Select(lhs, op), rhs :: Nil) =>
-        let(Symbol.currentOwner, lhs) { left =>
-          let(Symbol.currentOwner, rhs) { right =>
+        let(Symbol.spliceOwner, lhs) { left =>
+          let(Symbol.spliceOwner, rhs) { right =>
             val app = Select.overloaded(left, op, Nil, right :: Nil)
-            let(Symbol.currentOwner, app) { result =>
+            let(Symbol.spliceOwner, app) { result =>
               val l = left.asExpr
               val r = right.asExpr
               val b = result.asExprOf[Boolean]
diff --git a/tests/pos-macros/i8866/Macro_1.scala b/tests/pos-macros/i8866/Macro_1.scala
index d56111015026..356b2fa73ccb 100644
--- a/tests/pos-macros/i8866/Macro_1.scala
+++ b/tests/pos-macros/i8866/Macro_1.scala
@@ -15,7 +15,7 @@ object Macro {
     import qctx.reflect._
 
     ValDef.let(
-      Symbol.currentOwner,
+      Symbol.spliceOwner,
       Select.unique(
         Term.of('{ OtherMacro }),
         "apply"
diff --git a/tests/pos-macros/i9687/Macro_1.scala b/tests/pos-macros/i9687/Macro_1.scala
index 55262b8fa9e0..5fe76171fc34 100644
--- a/tests/pos-macros/i9687/Macro_1.scala
+++ b/tests/pos-macros/i9687/Macro_1.scala
@@ -27,17 +27,17 @@ object X {
     val slowPath = Term.of('{ SlowPath })
     val fastPath = Term.of('{ FastPath })
     val transformer = new TreeMap() {
-      override def transformTerm(term:Term)(using ctx:Context):Term = {
+      override def transformTerm(term:Term)(owner: Symbol):Term = {
         term match
           case Apply(sel@Select(o,m),args) =>
                 if ( o.tpe =:= slowPath.tpe && m=="sum" )
                    Apply(Select.unique(fastPath,"sum"), args)
                 else
-                   super.transformTerm(term)
-          case _ => super.transformTerm(term)
+                   super.transformTerm(term)(owner)
+          case _ => super.transformTerm(term)(owner)
       }
     }
-    val r = transformer.transformTerm(Term.of(x)).asExprOf[A]
+    val r = transformer.transformTerm(Term.of(x))(Symbol.spliceOwner).asExprOf[A]
     s"result: ${r.show}"
     r
  }
diff --git a/tests/pos-macros/i9894/Macro_1.scala b/tests/pos-macros/i9894/Macro_1.scala
index 8de97f0b53ba..56c8102d926a 100644
--- a/tests/pos-macros/i9894/Macro_1.scala
+++ b/tests/pos-macros/i9894/Macro_1.scala
@@ -46,7 +46,7 @@ object X:
             val paramTypes = params.map(_.tpt.tpe)
             val paramNames = params.map(_.name)
             val mt = MethodType(paramNames)(_ => paramTypes, _ => TypeRepr.of[CB].appliedTo(body.tpe.widen) )
-            val r = Lambda(Symbol.currentOwner, mt, (newMeth, args) => changeArgs(params,args,transform(body).changeOwner(newMeth)) )
+            val r = Lambda(Symbol.spliceOwner, mt, (newMeth, args) => changeArgs(params,args,transform(body).changeOwner(newMeth)) )
             r
           case _ =>
             throw RuntimeException("lambda expected")
@@ -57,11 +57,11 @@ object X:
              case (m, (oldParam, newParam: Tree)) => throw RuntimeException("Term expected")
          }
          val changes = new TreeMap() {
-             override def transformTerm(tree:Term)(using Context): Term =
+             override def transformTerm(tree:Term)(owner: Symbol): Term =
                tree match
-                 case ident@Ident(name) => association.getOrElse(ident.symbol, super.transformTerm(tree))
-                 case _ => super.transformTerm(tree)
+                 case ident@Ident(name) => association.getOrElse(ident.symbol, super.transformTerm(tree)(owner))
+                 case _ => super.transformTerm(tree)(owner)
          }
-         changes.transformTerm(body)
+         changes.transformTerm(body)(Symbol.spliceOwner)
 
    transform(Term.of(f)).asExprOf[CB[T]]
diff --git a/tests/pos-macros/treemap-unapply/Macro.scala b/tests/pos-macros/treemap-unapply/Macro.scala
index ff6e5ac45d05..78f62774fbca 100644
--- a/tests/pos-macros/treemap-unapply/Macro.scala
+++ b/tests/pos-macros/treemap-unapply/Macro.scala
@@ -5,4 +5,4 @@ def mcrImpl(x: Expr[Unit])(using QuoteContext) : Expr[Unit] =
   import qctx.reflect._
   val tr: Term = Term.of(x)
   object m extends TreeMap
-  m.transformTerm(tr).asExprOf[Unit]
+  m.transformTerm(tr)(Symbol.spliceOwner).asExprOf[Unit]
diff --git a/tests/run-custom-args/Yretain-trees/tasty-extractors-owners/quoted_1.scala b/tests/run-custom-args/Yretain-trees/tasty-extractors-owners/quoted_1.scala
index 02323ee90b99..d753e3bb9c7c 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-extractors-owners/quoted_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-extractors-owners/quoted_1.scala
@@ -13,14 +13,14 @@ object Macros {
     val output = myTraverser(buff)
 
     val tree = Term.of(x)
-    output.traverseTree(tree)
+    output.traverseTree(tree)(Symbol.spliceOwner)
     '{print(${Expr(buff.result())})}
   }
 
 
   def myTraverser(using qctx: QuoteContext)(buff: StringBuilder): qctx.reflect.TreeTraverser = new {
     import qctx.reflect._
-    override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = {
+    override def traverseTree(tree: Tree)(owner: Symbol): Unit = {
       tree match {
         case tree @ DefDef(name, _, _, _, _) =>
           buff.append(name)
@@ -34,7 +34,7 @@ object Macros {
           buff.append("\n\n")
         case _ =>
       }
-      traverseTreeChildren(tree)
+      traverseTreeChildren(tree)(owner)
     }
   }
 
diff --git a/tests/run-custom-args/tasty-inspector/tasty-documentation-inspector/Test.scala b/tests/run-custom-args/tasty-inspector/tasty-documentation-inspector/Test.scala
index 8074e11480c3..7d0837dbcf12 100644
--- a/tests/run-custom-args/tasty-inspector/tasty-documentation-inspector/Test.scala
+++ b/tests/run-custom-args/tasty-inspector/tasty-documentation-inspector/Test.scala
@@ -19,15 +19,15 @@ class DocumentationInspector extends TastyInspector {
     import qctx.reflect._
     object Traverser extends TreeTraverser {
 
-      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = tree match {
+      override def traverseTree(tree: Tree)(owner: Symbol): Unit = tree match {
         case tree: Definition =>
           tree.symbol.documentation match {
             case Some(doc) => println(doc.raw)
             case None => println()
           }
-          super.traverseTree(tree)
+          super.traverseTree(tree)(owner)
         case tree =>
-          super.traverseTree(tree)
+          super.traverseTree(tree)(owner)
       }
 
     }
diff --git a/tests/run-custom-args/tasty-inspector/tasty-inspector/Test.scala b/tests/run-custom-args/tasty-inspector/tasty-inspector/Test.scala
index b3c608b9241d..f92bf4be4c3b 100644
--- a/tests/run-custom-args/tasty-inspector/tasty-inspector/Test.scala
+++ b/tests/run-custom-args/tasty-inspector/tasty-inspector/Test.scala
@@ -19,12 +19,12 @@ class DBInspector extends TastyInspector {
     import qctx.reflect._
     object Traverser extends TreeTraverser {
 
-      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = tree match {
+      override def traverseTree(tree: Tree)(owner: Symbol): Unit = tree match {
         case tree: Definition =>
           println(tree.showExtractors)
-          super.traverseTree(tree)
+          super.traverseTree(tree)(owner)
         case tree =>
-          super.traverseTree(tree)
+          super.traverseTree(tree)(owner)
       }
 
     }
diff --git a/tests/run-custom-args/tasty-interpreter/interpreter/TastyInterpreter.scala b/tests/run-custom-args/tasty-interpreter/interpreter/TastyInterpreter.scala
index 2d3809e0f461..36a860e71fb2 100644
--- a/tests/run-custom-args/tasty-interpreter/interpreter/TastyInterpreter.scala
+++ b/tests/run-custom-args/tasty-interpreter/interpreter/TastyInterpreter.scala
@@ -9,7 +9,7 @@ class TastyInterpreter extends TastyInspector {
     import qctx.reflect._
     object Traverser extends TreeTraverser {
 
-      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = tree match {
+      override def traverseTree(tree: Tree)(owner: Symbol): Unit = tree match {
         // TODO: check the correct sig and object enclosement for main
         case DefDef("main", _, _, _, Some(rhs)) =>
           val interpreter = new jvm.Interpreter
@@ -17,9 +17,9 @@ class TastyInterpreter extends TastyInspector {
           interpreter.eval(rhs)(using Map.empty)
         // TODO: recurse only for PackageDef, ClassDef
         case tree =>
-          super.traverseTree(tree)
+          super.traverseTree(tree)(owner)
       }
     }
-    Traverser.traverseTree(root)
+    Traverser.traverseTree(root)(Symbol.spliceOwner)
   }
 }
diff --git a/tests/run-macros/i6988/FirstArg_1.scala b/tests/run-macros/i6988/FirstArg_1.scala
index deb231c7d47b..da4186a93785 100644
--- a/tests/run-macros/i6988/FirstArg_1.scala
+++ b/tests/run-macros/i6988/FirstArg_1.scala
@@ -11,7 +11,7 @@ object Macros {
   def argsImpl(using qctx: QuoteContext) : Expr[FirstArg] = {
     import qctx.reflect._
 
-    def enclosingClass(cur: Symbol = Symbol.currentOwner): Symbol =
+    def enclosingClass(cur: Symbol = Symbol.spliceOwner): Symbol =
       if (cur.isClassDef) cur
       else enclosingClass(cur.owner)
 
@@ -24,7 +24,7 @@ object Macros {
 
     def literal(value: String): Expr[String] =
       Literal(Constant.String(value)).asExpr.asInstanceOf[Expr[String]]
-    val paramss = enclosingParamList(Symbol.currentOwner)
+    val paramss = enclosingParamList(Symbol.spliceOwner)
     val firstArg = paramss.flatten.head
     val ref = Select.unique(This(enclosingClass()), firstArg.name)
     '{ FirstArg(${ref.asExpr}, ${Expr(firstArg.name)}) }
diff --git a/tests/run-macros/i7025/Macros_1.scala b/tests/run-macros/i7025/Macros_1.scala
index e46982917e3c..8092128f0e9b 100644
--- a/tests/run-macros/i7025/Macros_1.scala
+++ b/tests/run-macros/i7025/Macros_1.scala
@@ -10,7 +10,7 @@ object Macros {
       if owner.isClassDef then owner
       else nearestEnclosingDef(owner.owner)
 
-    val x = nearestEnclosingDef(Symbol.currentOwner)
+    val x = nearestEnclosingDef(Symbol.spliceOwner)
     if x.isDefDef then
       val code = x.signature.toString
       '{ println(${Expr(code)}) }
diff --git a/tests/run-macros/quote-matcher-symantics-2/quoted_1.scala b/tests/run-macros/quote-matcher-symantics-2/quoted_1.scala
index 3eaab424b6e4..b11cae0fb4fd 100644
--- a/tests/run-macros/quote-matcher-symantics-2/quoted_1.scala
+++ b/tests/run-macros/quote-matcher-symantics-2/quoted_1.scala
@@ -70,7 +70,7 @@ object UnsafeExpr {
   }
   private def paramsAndBody[R](using qctx: QuoteContext)(f: Expr[Any]): (List[qctx.reflect.ValDef], Expr[R]) = {
     import qctx.reflect._
-    val Block(List(DefDef("$anonfun", Nil, List(params), _, Some(body))), Closure(Ident("$anonfun"), None)) = Term.of(f).etaExpand(Symbol.currentOwner)
+    val Block(List(DefDef("$anonfun", Nil, List(params), _, Some(body))), Closure(Ident("$anonfun"), None)) = Term.of(f).etaExpand(Symbol.spliceOwner)
     (params, body.asExpr.asInstanceOf[Expr[R]])
   }
 
@@ -78,11 +78,11 @@ object UnsafeExpr {
     import qctx.reflect._
     val map = params.map(_.symbol).zip(args).toMap
     new TreeMap {
-      override def transformTerm(tree: Term)(using ctx: Context): Term =
-        super.transformTerm(tree) match
+      override def transformTerm(tree: Term)(owner: Symbol): Term =
+        super.transformTerm(tree)(owner) match
           case tree: Ident => map.getOrElse(tree.symbol, tree)
           case tree => tree
-    }.transformTerm(e)
+    }.transformTerm(e)(Symbol.spliceOwner)
   }
 }
 
diff --git a/tests/run-macros/quote-matcher-symantics-3/quoted_1.scala b/tests/run-macros/quote-matcher-symantics-3/quoted_1.scala
index a9e787b8cb1e..c025334b52c0 100644
--- a/tests/run-macros/quote-matcher-symantics-3/quoted_1.scala
+++ b/tests/run-macros/quote-matcher-symantics-3/quoted_1.scala
@@ -82,7 +82,7 @@ object UnsafeExpr {
   }
   private def paramsAndBody[R](using qctx: QuoteContext)(f: Expr[Any]): (List[qctx.reflect.ValDef], Expr[R]) = {
     import qctx.reflect._
-    val Block(List(DefDef("$anonfun", Nil, List(params), _, Some(body))), Closure(Ident("$anonfun"), None)) = Term.of(f).etaExpand(Symbol.currentOwner)
+    val Block(List(DefDef("$anonfun", Nil, List(params), _, Some(body))), Closure(Ident("$anonfun"), None)) = Term.of(f).etaExpand(Symbol.spliceOwner)
     (params, body.asExpr.asInstanceOf[Expr[R]])
   }
 
@@ -90,11 +90,11 @@ object UnsafeExpr {
     import qctx.reflect._
     val map = params.map(_.symbol).zip(args).toMap
     new TreeMap {
-      override def transformTerm(tree: Term)(using ctx: Context): Term =
-        super.transformTerm(tree) match
+      override def transformTerm(tree: Term)(owner: Symbol): Term =
+        super.transformTerm(tree)(owner) match
           case tree: Ident => map.getOrElse(tree.symbol, tree)
           case tree => tree
-    }.transformTerm(e)
+    }.transformTerm(e)(Symbol.spliceOwner)
   }
 }
 
diff --git a/tests/run-macros/quote-matching-open/Macro_1.scala b/tests/run-macros/quote-matching-open/Macro_1.scala
index 35b860d3bfdd..0288acb1c5e8 100644
--- a/tests/run-macros/quote-matching-open/Macro_1.scala
+++ b/tests/run-macros/quote-matching-open/Macro_1.scala
@@ -34,7 +34,7 @@ object UnsafeExpr {
   }
   private def paramsAndBody[R](using qctx: QuoteContext)(f: Expr[Any]): (List[qctx.reflect.ValDef], Expr[R]) = {
     import qctx.reflect._
-    val Block(List(DefDef("$anonfun", Nil, List(params), _, Some(body))), Closure(Ident("$anonfun"), None)) = Term.of(f).etaExpand(Symbol.currentOwner)
+    val Block(List(DefDef("$anonfun", Nil, List(params), _, Some(body))), Closure(Ident("$anonfun"), None)) = Term.of(f).etaExpand(Symbol.spliceOwner)
     (params, body.asExpr.asInstanceOf[Expr[R]])
   }
 
@@ -42,10 +42,10 @@ object UnsafeExpr {
     import qctx.reflect._
     val map = params.map(_.symbol).zip(args).toMap
     new TreeMap {
-      override def transformTerm(tree: Term)(using ctx: Context): Term =
-        super.transformTerm(tree) match
+      override def transformTerm(tree: Term)(owner: Symbol): Term =
+        super.transformTerm(tree)(owner) match
           case tree: Ident => map.getOrElse(tree.symbol, tree)
           case tree => tree
-    }.transformTerm(e)
+    }.transformTerm(e)(Symbol.spliceOwner)
   }
 }
\ No newline at end of file
diff --git a/tests/run-macros/tasty-create-method-symbol/Macro_1.scala b/tests/run-macros/tasty-create-method-symbol/Macro_1.scala
index 00fe681403cb..fa5cafbceaaa 100644
--- a/tests/run-macros/tasty-create-method-symbol/Macro_1.scala
+++ b/tests/run-macros/tasty-create-method-symbol/Macro_1.scala
@@ -9,7 +9,7 @@ object Macros {
 
     // simple smoke test
     val sym1 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
+      Symbol.spliceOwner,
       "sym1",
       MethodType(List("a","b"))(
         _ => List(TypeRepr.of[Int], TypeRepr.of[Int]),
@@ -27,7 +27,7 @@ object Macros {
 
     // test for no argument list (no Apply node)
     val sym2 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
+      Symbol.spliceOwner,
       "sym2",
       ByNameType(TypeRepr.of[Int]))
     assert(sym2.isDefDef)
@@ -43,7 +43,7 @@ object Macros {
 
    // test for multiple argument lists
    val sym3 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
+      Symbol.spliceOwner,
       "sym3",
       MethodType(List("a"))(
         _ => List(TypeRepr.of[Int]),
@@ -63,7 +63,7 @@ object Macros {
 
     // test for recursive references
     val sym4 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
+      Symbol.spliceOwner,
       "sym4",
       MethodType(List("x"))(
         _ => List(TypeRepr.of[Int]),
@@ -85,7 +85,7 @@ object Macros {
 
     // test for nested functions (one symbol is the other's parent, and we use a Closure)
     val sym5 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
+      Symbol.spliceOwner,
       "sym5",
       MethodType(List("x"))(
         _ => List(TypeRepr.of[Int]),
@@ -119,13 +119,13 @@ object Macros {
 
     // test mutually recursive definitions
     val sym6_1 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
+      Symbol.spliceOwner,
       "sym6_1",
       MethodType(List("x"))(
         _ => List(TypeRepr.of[Int]),
         _ => TypeRepr.of[Int]))
     val sym6_2 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
+      Symbol.spliceOwner,
       "sym6_2",
       MethodType(List("x"))(
         _ => List(TypeRepr.of[Int]),
@@ -166,7 +166,7 @@ object Macros {
 
     // test polymorphic methods by synthesizing an identity method
     val sym7 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
+      Symbol.spliceOwner,
       "sym7",
       PolyType(List("T"))(
         tp => List(TypeBounds(TypeRepr.of[Nothing], TypeRepr.of[Any])),
diff --git a/tests/run-macros/tasty-extractors-3/quoted_1.scala b/tests/run-macros/tasty-extractors-3/quoted_1.scala
index b7d442067e23..a641c8583db1 100644
--- a/tests/run-macros/tasty-extractors-3/quoted_1.scala
+++ b/tests/run-macros/tasty-extractors-3/quoted_1.scala
@@ -11,22 +11,22 @@ 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)(owner: Symbol): Unit = tree match {
         case tree: TypeBoundsTree =>
           buff.append(tree.tpe.showExtractors)
           buff.append("\n\n")
-          traverseTreeChildren(tree)
+          traverseTreeChildren(tree)(owner)
         case tree: TypeTree =>
           buff.append(tree.tpe.showExtractors)
           buff.append("\n\n")
-          traverseTreeChildren(tree)
+          traverseTreeChildren(tree)(owner)
         case _ =>
-          super.traverseTree(tree)
+          super.traverseTree(tree)(owner)
       }
     }
 
     val tree = Term.of(x)
-    traverser.traverseTree(tree)
+    traverser.traverseTree(tree)(Symbol.spliceOwner)
     '{print(${Expr(buff.result())})}
   }
 }
diff --git a/tests/run-macros/tasty-location/quoted_1.scala b/tests/run-macros/tasty-location/quoted_1.scala
index d677bac223ab..2ed4d11eab8a 100644
--- a/tests/run-macros/tasty-location/quoted_1.scala
+++ b/tests/run-macros/tasty-location/quoted_1.scala
@@ -13,7 +13,7 @@ object Location {
       if (sym == defn.RootClass || sym == defn.EmptyPackageClass) acc
       else listOwnerNames(sym.owner, sym.name :: acc)
 
-    val list = listOwnerNames(Symbol.currentOwner, Nil)
+    val list = listOwnerNames(Symbol.spliceOwner, Nil)
     '{new Location(${Expr(list)})}
   }
 
diff --git a/tests/run-macros/tasty-seal-method/quoted_1.scala b/tests/run-macros/tasty-seal-method/quoted_1.scala
index 078a47dc6628..e9e10920b756 100644
--- a/tests/run-macros/tasty-seal-method/quoted_1.scala
+++ b/tests/run-macros/tasty-seal-method/quoted_1.scala
@@ -14,10 +14,10 @@ object Asserts {
         fn.tpe.widen match {
           case _: MethodType =>
             args.size match {
-              case 0 => Expr.betaReduce('{ ${fn.etaExpand(Symbol.currentOwner).asExprOf[() => Int]}() })
-              case 1 => Expr.betaReduce('{ ${fn.etaExpand(Symbol.currentOwner).asExprOf[Int => Int]}(0) })
-              case 2 => Expr.betaReduce('{ ${fn.etaExpand(Symbol.currentOwner).asExprOf[(Int, Int) => Int]}(0, 0) })
-              case 3 => Expr.betaReduce('{ ${fn.etaExpand(Symbol.currentOwner).asExprOf[(Int, Int, Int) => Int]}(0, 0, 0) })
+              case 0 => Expr.betaReduce('{ ${fn.etaExpand(Symbol.spliceOwner).asExprOf[() => Int]}() })
+              case 1 => Expr.betaReduce('{ ${fn.etaExpand(Symbol.spliceOwner).asExprOf[Int => Int]}(0) })
+              case 2 => Expr.betaReduce('{ ${fn.etaExpand(Symbol.spliceOwner).asExprOf[(Int, Int) => Int]}(0, 0) })
+              case 3 => Expr.betaReduce('{ ${fn.etaExpand(Symbol.spliceOwner).asExprOf[(Int, Int, Int) => Int]}(0, 0, 0) })
             }
         }
       case _ => x
@@ -35,10 +35,10 @@ object Asserts {
       case Apply(fn, args) =>
         val pre = rec(fn)
         args.size match {
-          case 0 => Term.of(Expr.betaReduce('{ ${pre.etaExpand(Symbol.currentOwner).asExprOf[() => Any]}() }))
-          case 1 => Term.of(Expr.betaReduce('{ ${pre.etaExpand(Symbol.currentOwner).asExprOf[Int => Any]}(0) }))
-          case 2 => Term.of(Expr.betaReduce('{ ${pre.etaExpand(Symbol.currentOwner).asExprOf[(Int, Int) => Any]}(0, 0) }))
-          case 3 => Term.of(Expr.betaReduce('{ ${pre.etaExpand(Symbol.currentOwner).asExprOf[(Int, Int, Int) => Any]}(0, 0, 0) }))
+          case 0 => Term.of(Expr.betaReduce('{ ${pre.etaExpand(Symbol.spliceOwner).asExprOf[() => Any]}() }))
+          case 1 => Term.of(Expr.betaReduce('{ ${pre.etaExpand(Symbol.spliceOwner).asExprOf[Int => Any]}(0) }))
+          case 2 => Term.of(Expr.betaReduce('{ ${pre.etaExpand(Symbol.spliceOwner).asExprOf[(Int, Int) => Any]}(0, 0) }))
+          case 3 => Term.of(Expr.betaReduce('{ ${pre.etaExpand(Symbol.spliceOwner).asExprOf[(Int, Int, Int) => Any]}(0, 0, 0) }))
         }
       case _ => term
     }
diff --git a/tests/run-macros/tasty-tree-map/quoted_1.scala b/tests/run-macros/tasty-tree-map/quoted_1.scala
index d3b28ae562b6..b4484fd983d4 100644
--- a/tests/run-macros/tasty-tree-map/quoted_1.scala
+++ b/tests/run-macros/tasty-tree-map/quoted_1.scala
@@ -7,6 +7,6 @@ object MacrosImpl:
   def impl[T: Type](x: Expr[T])(using qctx: QuoteContext) : Expr[T] = {
     import qctx.reflect._
     val identityMap = new TreeMap { }
-    val transformed = identityMap.transformTerm(Term.of(x)).asExprOf[T]
+    val transformed = identityMap.transformTerm(Term.of(x))(Symbol.spliceOwner).asExprOf[T]
     transformed
   }