diff --git a/compiler/src/scala/quoted/internal/impl/Matcher.scala b/compiler/src/scala/quoted/internal/impl/Matcher.scala
index 92b91e0f4496..19f3a74a27ec 100644
--- a/compiler/src/scala/quoted/internal/impl/Matcher.scala
+++ b/compiler/src/scala/quoted/internal/impl/Matcher.scala
@@ -199,7 +199,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)(using owner: Owner): Term =
                   tree match
                     case tree: Ident => summon[Env].get(tree.symbol).flatMap(argsMap.get).getOrElse(tree)
                     case tree => super.transformTerm(tree)
@@ -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(MethodType(names)(_ => argTypes, _ => resType), x => bodyFn(x).adaptOwner)
             matched(res.asExpr)
 
           //
@@ -354,7 +354,7 @@ 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)(using owner: Owner): Set[Symbol] =
             tree match
               case tree: Ident if env.contains(tree.symbol) => foldOverTree(x + tree.symbol, tree)
               case _ => foldOverTree(x, tree)
diff --git a/compiler/src/scala/quoted/internal/impl/QuoteContextImpl.scala b/compiler/src/scala/quoted/internal/impl/QuoteContextImpl.scala
index ad512d056a25..466f470f2893 100644
--- a/compiler/src/scala/quoted/internal/impl/QuoteContextImpl.scala
+++ b/compiler/src/scala/quoted/internal/impl/QuoteContextImpl.scala
@@ -122,7 +122,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
       end extension
 
       extension [ThisTree <: Tree](self: ThisTree):
-        def changeOwner(newOwner: Symbol): ThisTree =
+        def adaptOwner(using newOwner: Symbol): ThisTree =
           tpd.TreeOps(self).changeNonLocalOwners(newOwner).asInstanceOf[ThisTree]
       end extension
 
@@ -278,13 +278,14 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
       def unapply(vdef: ValDef): Option[(String, TypeTree, Option[Term])] =
         Some((vdef.name.toString, vdef.tpt, optional(vdef.rhs)))
 
-      def let(name: String, rhs: Term)(body: Ident => Term): Term =
-        val vdef = tpd.SyntheticValDef(name.toTermName, rhs)
+      def let(name: String, rhs: Term)(body: Ident => Term)(using owner: Owner): Term =
+        val vdef = tpd.SyntheticValDef(name.toTermName, rhs)(using ctx.withOwner(owner))
         val ref = tpd.ref(vdef.symbol).asInstanceOf[Ident]
         Block(List(vdef), body(ref))
 
-      def let(terms: List[Term])(body: List[Ident] => Term): Term =
-        val vdefs = terms.map(term => tpd.SyntheticValDef("x".toTermName, term))
+      def let(terms: List[Term])(body: List[Ident] => Term)(using owner: Owner): Term =
+        val ctx1 = ctx.withOwner(owner)
+        val vdefs = terms.map(term => tpd.SyntheticValDef("x".toTermName, term)(using ctx1))
         val refs = vdefs.map(vdef => tpd.ref(vdef.symbol).asInstanceOf[Ident])
         Block(vdefs, body(refs))
     end ValDef
@@ -365,7 +366,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
         def tpe: TypeRepr = self.tpe
         def underlyingArgument: Term = new tpd.TreeOps(self).underlyingArgument
         def underlying: Term = new tpd.TreeOps(self).underlying
-        def etaExpand(owner: Symbol): Term = self.tpe.widen match {
+        def etaExpand(using owner: Owner): Term = self.tpe.widen match {
           case mtpe: Types.MethodType if !mtpe.isParamDependent =>
             val closureResType = mtpe.resType match {
               case t: Types.MethodType => t.toFunctionType()
@@ -373,7 +374,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
             }
             val closureTpe = Types.MethodType(mtpe.paramNames, mtpe.paramInfos, closureResType)
             val closureMethod = dotc.core.Symbols.newSymbol(owner, nme.ANON_FUN, Synthetic | Method, closureTpe)
-            tpd.Closure(closureMethod, tss => new tpd.TreeOps(self).appliedToArgs(tss.head).etaExpand(closureMethod))
+            tpd.Closure(closureMethod, tss => new tpd.TreeOps(self).appliedToArgs(tss.head).etaExpand(using closureMethod))
           case _ => self
         }
 
@@ -735,9 +736,9 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
     end ClosureMethodsImpl
 
     object Lambda extends LambdaModule:
-      def apply(owner: Symbol, tpe: MethodType, rhsFn: (Symbol, List[Tree]) => Tree): Block =
+      def apply(tpe: MethodType, rhsFn: Owner ?=> List[Tree] => Tree)(using owner: Owner): Block =
         val meth = dotc.core.Symbols.newSymbol(owner, nme.ANON_FUN, Synthetic | Method, tpe)
-        tpd.Closure(meth, tss => yCheckedOwners(rhsFn(meth, tss.head), meth))
+        tpd.Closure(meth, tss => yCheckedOwners(rhsFn(using meth)(tss.head), meth))
 
       def unapply(tree: Block): Option[(List[ValDef], Term)] = tree match {
         case Block((ddef @ DefDef(_, _, params :: Nil, _, Some(body))) :: Nil, Closure(meth, _))
@@ -2200,22 +2201,35 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
           case _ => None
     end AmbiguousImplicitsTypeTest
 
+    type Owner = dotc.core.Symbols.Symbol
+
+    object Owner extends OwnerModule:
+      def apply(sym: Symbol): Owner =
+        assert(sym.exists, "Cannot convert NoSymbol into an Owner")
+        sym
+      def spliceOwner: Owner = ctx.owner
+    end Owner
+
+    object OwnerMethodsImpl extends OwnerMethods:
+      extension (self: Owner):
+        def symbol: Symbol = self
+    end OwnerMethodsImpl
+
     type Symbol = dotc.core.Symbols.Symbol
 
     object Symbol extends SymbolModule:
-      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)
       def requiredMethod(path: String): Symbol = dotc.core.Symbols.requiredMethod(path)
       def classSymbol(fullName: String): Symbol = dotc.core.Symbols.requiredClass(fullName)
-      def newMethod(owner: Symbol, name: String, tpe: TypeRepr): Symbol =
-        newMethod(owner, name, tpe, Flags.EmptyFlags, noSymbol)
-      def newMethod(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
+      def newMethod(name: String, tpe: TypeRepr)(using owner: Owner): Symbol =
+        newMethod(name, tpe, Flags.EmptyFlags, noSymbol)
+      def newMethod(name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol)(using owner: Owner): Symbol =
         dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Method, tpe, privateWithin)
-      def newVal(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
+      def newVal(name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol)(using owner: Owner): Symbol =
         dotc.core.Symbols.newSymbol(owner, name.toTermName, flags, tpe, privateWithin)
-      def newBind(owner: Symbol, name: String, flags: Flags, tpe: TypeRepr): Symbol =
+      def newBind(name: String, flags: Flags, tpe: TypeRepr)(using owner: Owner): Symbol =
         dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | Case, tpe)
       def noSymbol: Symbol = dotc.core.Symbols.NoSymbol
     end Symbol
@@ -2593,6 +2607,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
                    |which has the AST representation
                    |${TreeMethods.showExtractors(tree)}
                    |
+                   |Owners can be adapted using `Tree.adaptOwner`.
                    |""".stripMargin)
             case _ => traverseChildren(t)
       }.traverse(tree)
diff --git a/compiler/src/scala/quoted/internal/impl/printers/SourceCode.scala b/compiler/src/scala/quoted/internal/impl/printers/SourceCode.scala
index 8c903b69312f..3977e9ef7da8 100644
--- a/compiler/src/scala/quoted/internal/impl/printers/SourceCode.scala
+++ b/compiler/src/scala/quoted/internal/impl/printers/SourceCode.scala
@@ -1409,7 +1409,7 @@ object SourceCode {
     private[this] val namesIndex = collection.mutable.Map.empty[String, Int]
 
     private def splicedName(sym: Symbol): Option[String] = {
-      if sym.owner.isClassDef then None
+      if sym.maybeOwner.isClassDef then None
       else names.get(sym).orElse {
         val name0 = sym.name
         val index = namesIndex.getOrElse(name0, 1)
diff --git a/library/src-bootstrapped/scala/quoted/ExprMap.scala b/library/src-bootstrapped/scala/quoted/ExprMap.scala
index fef1ec689375..962ea9330776 100644
--- a/library/src-bootstrapped/scala/quoted/ExprMap.scala
+++ b/library/src-bootstrapped/scala/quoted/ExprMap.scala
@@ -10,8 +10,7 @@ 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)(using owner: Owner): Statement = {
         tree match {
           case tree: Term =>
             transformTerm(tree, TypeRepr.of[Any])
@@ -22,15 +21,14 @@ trait ExprMap:
         }
       }
 
-      def transformDefinition(tree: Definition)(using ctx: Context): Definition = {
-        def localCtx(definition: Definition): Context = definition.symbol.localContext
+      def transformDefinition(tree: Definition)(using owner: Owner): Definition = {
         tree match {
           case tree: ValDef =>
-            given Context = localCtx(tree)
+            given Owner = Owner(tree.symbol)
             val rhs1 = tree.rhs.map(x => transformTerm(x, tree.tpt.tpe))
             ValDef.copy(tree)(tree.name, tree.tpt, rhs1)
           case tree: DefDef =>
-            given Context = localCtx(tree)
+            given Owner = Owner(tree.symbol)
             DefDef.copy(tree)(tree.name, tree.typeParams, tree.paramss, tree.returnTpt, tree.rhs.map(x => transformTerm(x, tree.returnTpt.tpe)))
           case tree: TypeDef =>
             tree
@@ -40,7 +38,7 @@ trait ExprMap:
         }
       }
 
-      def transformTermChildren(tree: Term, tpe: TypeRepr)(using ctx: Context): Term = tree match {
+      def transformTermChildren(tree: Term, tpe: TypeRepr)(using owner: Owner): Term = tree match {
         case Ident(name) =>
           tree
         case Select(qualifier, name) =>
@@ -94,7 +92,7 @@ trait ExprMap:
           Inlined.copy(tree)(call, transformDefinitions(bindings), transformTerm(expansion, tpe)/*()call.symbol.localContext)*/)
       }
 
-      def transformTerm(tree: Term, tpe: TypeRepr)(using ctx: Context): Term =
+      def transformTerm(tree: Term, tpe: TypeRepr)(using owner: Owner): Term =
         tree match
           case _: Closure =>
             tree
@@ -109,22 +107,22 @@ trait ExprMap:
           case _ =>
             transformTermChildren(tree, tpe)
 
-      def transformTypeTree(tree: TypeTree)(using ctx: Context): TypeTree = tree
+      def transformTypeTree(tree: TypeTree)(using owner: Owner): TypeTree = tree
 
-      def transformCaseDef(tree: CaseDef, tpe: TypeRepr)(using ctx: Context): CaseDef =
+      def transformCaseDef(tree: CaseDef, tpe: TypeRepr)(using owner: Owner): CaseDef =
         CaseDef.copy(tree)(tree.pattern, tree.guard.map(x => transformTerm(x, TypeRepr.of[Boolean])), transformTerm(tree.rhs, tpe))
 
-      def transformTypeCaseDef(tree: TypeCaseDef)(using ctx: Context): TypeCaseDef = {
+      def transformTypeCaseDef(tree: TypeCaseDef)(using owner: Owner): 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])(using owner: Owner): List[Statement] =
         trees mapConserve (transformStatement(_))
 
-      def transformDefinitions(trees: List[Definition])(using ctx: Context): List[Definition] =
+      def transformDefinitions(trees: List[Definition])(using owner: Owner): List[Definition] =
         trees mapConserve (transformDefinition(_))
 
-      def transformTerms(trees: List[Term], tpes: List[TypeRepr])(using ctx: Context): List[Term] =
+      def transformTerms(trees: List[Term], tpes: List[TypeRepr])(using owner: Owner): List[Term] =
         var tpes2 = tpes // TODO use proper zipConserve
         trees mapConserve { x =>
           val tpe :: tail = tpes2
@@ -132,16 +130,16 @@ trait ExprMap:
           transformTerm(x, tpe)
         }
 
-      def transformTerms(trees: List[Term], tpe: TypeRepr)(using ctx: Context): List[Term] =
+      def transformTerms(trees: List[Term], tpe: TypeRepr)(using owner: Owner): List[Term] =
         trees.mapConserve(x => transformTerm(x, tpe))
 
-      def transformTypeTrees(trees: List[TypeTree])(using ctx: Context): List[TypeTree] =
+      def transformTypeTrees(trees: List[TypeTree])(using owner: Owner): List[TypeTree] =
         trees mapConserve (transformTypeTree(_))
 
-      def transformCaseDefs(trees: List[CaseDef], tpe: TypeRepr)(using ctx: Context): List[CaseDef] =
+      def transformCaseDefs(trees: List[CaseDef], tpe: TypeRepr)(using owner: Owner): List[CaseDef] =
         trees mapConserve (x => transformCaseDef(x, tpe))
 
-      def transformTypeCaseDefs(trees: List[TypeCaseDef])(using ctx: Context): List[TypeCaseDef] =
+      def transformTypeCaseDefs(trees: List[TypeCaseDef])(using owner: Owner): List[TypeCaseDef] =
         trees mapConserve (transformTypeCaseDef(_))
 
     }
diff --git a/library/src/scala/quoted/QuoteContext.scala b/library/src/scala/quoted/QuoteContext.scala
index a693a4df6545..4f5de2a60fae 100644
--- a/library/src/scala/quoted/QuoteContext.scala
+++ b/library/src/scala/quoted/QuoteContext.scala
@@ -154,6 +154,8 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
    *                     +- RenameSelector
    *                     +- OmitSelector
    *
+   *  +- Owner
+   *
    *  +- Signature
    *
    *  +- Position
@@ -233,7 +235,7 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
 
       extension [ThisTree <: Tree](self: ThisTree):
         /** Changes the owner of the symbols in the tree */
-        def changeOwner(newOwner: Symbol): ThisTree
+        def adaptOwner(using newOwner: Owner): ThisTree
       end extension
 
     }
@@ -386,13 +388,13 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
       def unapply(vdef: ValDef): Option[(String, TypeTree, Option[Term])]
 
       /** Creates a block `{ val <name> = <rhs: Term>; <body(x): Term> }` */
-      def let(name: String, rhs: Term)(body: Ident => Term): Term
+      def let(name: String, rhs: Term)(body: Ident => Term)(using owner: Owner): Term
 
       /** Creates a block `{ val x = <rhs: Term>; <body(x): Term> }` */
-      def let(rhs: Term)(body: Ident => Term): Term = let("x", rhs)(body)
+      def let(rhs: Term)(body: Ident => Term)(using owner: Owner): Term = let("x", rhs)(body)
 
       /** Creates a block `{ val x1 = <terms(0): Term>; ...; val xn = <terms(n-1): Term>; <body(List(x1, ..., xn)): Term> }` */
-      def let(terms: List[Term])(body: List[Ident] => Term): Term
+      def let(terms: List[Term])(body: List[Ident] => Term)(using owner: Owner): Term
     }
 
     given ValDefMethods as ValDefMethods = ValDefMethodsImpl
@@ -475,7 +477,7 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
         def underlying: Term
 
         /** Converts a partally applied term into a lambda expression */
-        def etaExpand(owner: Symbol): Term
+        def etaExpand(using owner: Owner): Term
 
         /** A unary apply node with given argument: `tree(arg)` */
         def appliedTo(arg: Term): Term
@@ -977,7 +979,7 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
        * @param tpe: Type of the definition
        * @param rhsFn: Funtion that recieves the `meth` symbol and the a list of references to the `params`
        */
-      def apply(owner: Symbol, tpe: MethodType, rhsFn: (Symbol, List[Tree]) => Tree): Block
+      def apply(tpe: MethodType, rhsFn: Owner ?=> List[Tree] => Tree)(using owner: Owner): Block
     }
 
     given TypeTest[Tree, If] = IfTypeTest
@@ -2660,6 +2662,38 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
     given TypeTest[ImplicitSearchResult, AmbiguousImplicits] = AmbiguousImplicitsTypeTest
     protected val AmbiguousImplicitsTypeTest: TypeTest[ImplicitSearchResult, AmbiguousImplicits]
 
+    /////////////
+    //  OWNER  //
+    /////////////
+
+    /** Contextual representation of the enclosing definition */
+    type Owner <: AnyRef
+
+    /** Provides contextually `Owner.spliceOwner` as deault `Owner` */
+    given Owner = Owner.spliceOwner
+
+    val Owner: OwnerModule
+
+    trait OwnerModule { this: Owner.type =>
+      /** Returns the current Owner in scope */
+      inline def current(using owner: Owner): owner.type = owner
+
+      /** Owner definition of the symbol */
+      def apply(sym: Symbol): Owner
+
+      /** Owner definition of the current splice */
+      def spliceOwner: Owner
+    }
+
+    given OwnerMethods as OwnerMethods = OwnerMethodsImpl
+    protected val OwnerMethodsImpl: OwnerMethods
+
+    trait OwnerMethods {
+      /** Symbol of the owner */
+      extension (self: Owner)
+        def symbol: Symbol
+    }
+
     /////////////
     // SYMBOLS //
     /////////////
@@ -2673,9 +2707,6 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
 
     trait SymbolModule { this: Symbol.type =>
 
-      /** 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
 
@@ -2700,14 +2731,14 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
       *  @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be
       *        direct or indirect children of the reflection context's owner.
       */
-      def newMethod(parent: Symbol, name: String, tpe: TypeRepr): Symbol
+      def newMethod(name: String, tpe: TypeRepr)(using owner: Owner): Symbol
 
       /** Works as the other newMethod, but with additional parameters.
       *
       *  @param flags extra flags to with which the symbol should be constructed
       *  @param privateWithin the symbol within which this new method symbol should be private. May be noSymbol.
       */
-      def newMethod(parent: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol
+      def newMethod(name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol)(using owner: Owner): Symbol
 
       /** Generates a new val/var/lazy val symbol with the given parent, name and type.
       *
@@ -2722,7 +2753,7 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
       *  @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be
       *        direct or indirect children of the reflection context's owner.
       */
-      def newVal(parent: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol
+      def newVal(name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol)(using owner: Owner): Symbol
 
       /** Generates a pattern bind symbol with the given parent, name and type.
       *
@@ -2734,7 +2765,7 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
       *  @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be
       *        direct or indirect children of the reflection context's owner.
       */
-      def newBind(parent: Symbol, name: String, flags: Flags, tpe: TypeRepr): Symbol
+      def newBind(name: String, flags: Flags, tpe: TypeRepr)(using owner: Owner): Symbol
 
       /** Definition not available */
       def noSymbol: Symbol
@@ -2770,8 +2801,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]
 
@@ -3415,19 +3444,18 @@ 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)(using owner: Owner): 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)(using owner: Owner): X
 
-      def foldTrees(x: X, trees: Iterable[Tree])(using ctx: Context): X = trees.foldLeft(x)(foldTree)
+      def foldTrees(x: X, trees: Iterable[Tree])(using owner: Owner): X = trees.foldLeft(x)(foldTree)
 
-      def foldOverTree(x: X, tree: Tree)(using ctx: Context): X = {
-        def localCtx(definition: Definition): Context = definition.symbol.localContext
+      def foldOverTree(x: X, tree: Tree)(using owner: Owner): X = {
         tree match {
           case Ident(_) =>
             x
@@ -3470,25 +3498,23 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
           case Inlined(call, bindings, expansion) =>
             foldTree(foldTrees(x, bindings), expansion)
           case vdef @ ValDef(_, tpt, rhs) =>
-            val ctx = localCtx(vdef)
-            given Context = ctx
+            given Owner =
+              if vdef.symbol.exists then Owner(vdef.symbol)
+              else owner // self type val
             foldTrees(foldTree(x, tpt), rhs)
           case ddef @ DefDef(_, tparams, vparamss, tpt, rhs) =>
-            val ctx = localCtx(ddef)
-            given Context = ctx
+            given Owner = Owner(ddef.symbol)
             foldTrees(foldTree(vparamss.foldLeft(foldTrees(x, tparams))(foldTrees), tpt), rhs)
           case tdef @ TypeDef(_, rhs) =>
-            val ctx = localCtx(tdef)
-            given Context = ctx
+            given Owner = Owner(tdef.symbol)
             foldTree(x, rhs)
           case cdef @ ClassDef(_, constr, parents, derived, self, body) =>
-            val ctx = localCtx(cdef)
-            given Context = ctx
+            given Owner = Owner(cdef.symbol)
             foldTrees(foldTrees(foldTrees(foldTrees(foldTree(x, constr), parents), derived), self), body)
           case Import(expr, _) =>
             foldTree(x, expr)
           case clause @ PackageClause(pid, stats) =>
-            foldTrees(foldTree(x, pid), stats)(using clause.symbol.localContext)
+            foldTrees(foldTree(x, pid), stats)(using Owner(clause.symbol))
           case Inferred() => x
           case TypeIdent(_) => x
           case TypeSelect(qualifier, _) => foldTree(x, qualifier)
@@ -3522,17 +3548,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)(using owner: Owner): Unit = ...
     *  }
     *  ```
     */
     trait TreeTraverser extends TreeAccumulator[Unit]:
 
-      def traverseTree(tree: Tree)(using ctx: Context): Unit = traverseTreeChildren(tree)
+      def traverseTree(tree: Tree)(using owner: Owner): Unit = traverseTreeChildren(tree)
 
-      def foldTree(x: Unit, tree: Tree)(using ctx: Context): Unit = traverseTree(tree)
+      def foldTree(x: Unit, tree: Tree)(using owner: Owner): Unit = traverseTree(tree)
 
-      protected def traverseTreeChildren(tree: Tree)(using ctx: Context): Unit = foldOverTree((), tree)
+      protected def traverseTreeChildren(tree: Tree)(using owner: Owner): Unit = foldOverTree((), tree)
 
     end TreeTraverser
 
@@ -3542,16 +3568,16 @@ 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)(using owner: Owner): Tree = ...
     *  }
     *  ```
     */
     trait TreeMap:
 
-      def transformTree(tree: Tree)(using ctx: Context): Tree = {
+      def transformTree(tree: Tree)(using owner: Owner): 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)(using Owner(tree.symbol)))
           case tree: Import =>
             Import.copy(tree)(transformTerm(tree.expr), tree.selectors)
           case tree: Statement =>
@@ -3572,24 +3598,20 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
         }
       }
 
-      def transformStatement(tree: Statement)(using ctx: Context): Statement = {
-        def localCtx(definition: Definition): Context = definition.symbol.localContext
+      def transformStatement(tree: Statement)(using owner: Owner): Statement = {
         tree match {
           case tree: Term =>
             transformTerm(tree)
           case tree: ValDef =>
-            val ctx = localCtx(tree)
-            given Context = ctx
+            given Owner = Owner(tree.symbol)
             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
+            given Owner = Owner(tree.symbol)
             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
+            given Owner = Owner(tree.symbol)
             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)
@@ -3598,7 +3620,7 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
         }
       }
 
-      def transformTerm(tree: Term)(using ctx: Context): Term = {
+      def transformTerm(tree: Term)(using owner: Owner): Term = {
         tree match {
           case Ident(name) =>
             tree
@@ -3639,11 +3661,11 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
           case Repeated(elems, elemtpt) =>
             Repeated.copy(tree)(transformTerms(elems), transformTypeTree(elemtpt))
           case Inlined(call, bindings, expansion) =>
-            Inlined.copy(tree)(call, transformSubTrees(bindings), transformTerm(expansion)/*()call.symbol.localContext)*/)
+            Inlined.copy(tree)(call, transformSubTrees(bindings), transformTerm(expansion))
         }
       }
 
-      def transformTypeTree(tree: TypeTree)(using ctx: Context): TypeTree = tree match {
+      def transformTypeTree(tree: TypeTree)(using owner: Owner): TypeTree = tree match {
         case Inferred() => tree
         case tree: TypeIdent => tree
         case tree: TypeSelect =>
@@ -3670,33 +3692,33 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
           TypeBlock.copy(tree)(tree.aliases, tree.tpt)
       }
 
-      def transformCaseDef(tree: CaseDef)(using ctx: Context): CaseDef = {
+      def transformCaseDef(tree: CaseDef)(using owner: Owner): 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)(using owner: Owner): 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])(using owner: Owner): List[Statement] =
         trees mapConserve (transformStatement(_))
 
-      def transformTrees(trees: List[Tree])(using ctx: Context): List[Tree] =
+      def transformTrees(trees: List[Tree])(using owner: Owner): List[Tree] =
         trees mapConserve (transformTree(_))
 
-      def transformTerms(trees: List[Term])(using ctx: Context): List[Term] =
+      def transformTerms(trees: List[Term])(using owner: Owner): List[Term] =
         trees mapConserve (transformTerm(_))
 
-      def transformTypeTrees(trees: List[TypeTree])(using ctx: Context): List[TypeTree] =
+      def transformTypeTrees(trees: List[TypeTree])(using owner: Owner): List[TypeTree] =
         trees mapConserve (transformTypeTree(_))
 
-      def transformCaseDefs(trees: List[CaseDef])(using ctx: Context): List[CaseDef] =
+      def transformCaseDefs(trees: List[CaseDef])(using owner: Owner): List[CaseDef] =
         trees mapConserve (transformCaseDef(_))
 
-      def transformTypeCaseDefs(trees: List[TypeCaseDef])(using ctx: Context): List[TypeCaseDef] =
+      def transformTypeCaseDefs(trees: List[TypeCaseDef])(using owner: Owner): List[TypeCaseDef] =
         trees mapConserve (transformTypeCaseDef(_))
 
-      def transformSubTrees[Tr <: Tree](trees: List[Tr])(using ctx: Context): List[Tr] =
+      def transformSubTrees[Tr <: Tree](trees: List[Tr])(using owner: Owner): List[Tr] =
         transformTrees(trees).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..ec0ab1e7a613 100644
--- a/scala3doc/src/dotty/dokka/tasty/TastyParser.scala
+++ b/scala3doc/src/dotty/dokka/tasty/TastyParser.scala
@@ -188,7 +188,7 @@ 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)(using Owner): Unit =
         seen = tree :: seen
         tree match {
           case pck: PackageClause =>
@@ -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)
     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..d566abf415ee 100644
--- a/tests/pos-macros/i10151/Macro_1.scala
+++ b/tests/pos-macros/i10151/Macro_1.scala
@@ -39,19 +39,19 @@ object X:
                              List(Inferred(a.tpe.widen))
                             ),
                    List(
-                     Lambda(Symbol.currentOwner, mty, (meth, yArgs) =>
+                     Lambda(mty, yArgs =>
                        Apply(
                           TypeApply(Select.unique(transform(z),"map"),
                              List(Inferred(a.tpe.widen))
                           ),
                           List(
-                            Lambda(Symbol.currentOwner, mtz, (_, zArgs) => {
+                            Lambda(mtz, zArgs => {
                               val termYArgs = yArgs.asInstanceOf[List[Term]]
                               val termZArgs = zArgs.asInstanceOf[List[Term]]
                               Apply(x,List(termYArgs.head,termZArgs.head))
                             })
                           )
-                       ).changeOwner(meth)
+                       ).adaptOwner
                      )
                    )
                  )
@@ -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(mt, args => changeArgs(params,args,transform(body)).adaptOwner )
           case Block(stats, last) =>
             Block(stats, shiftLambda(last))
           case _ =>
@@ -82,7 +82,7 @@ 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)(using Owner): Term =
                tree match
                  case ident@Ident(name) => association.getOrElse(ident.symbol, super.transformTerm(tree))
                  case _ => super.transformTerm(tree)
diff --git a/tests/pos-macros/i10211/Macro_1.scala b/tests/pos-macros/i10211/Macro_1.scala
index 156f7f3f941e..de87772a0245 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(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(mt, args => changeArgs(params,args,transform(body)).adaptOwner )
             r
           case _ =>
             throw RuntimeException("lambda expected")
@@ -92,7 +92,7 @@ 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)(using Owner): Term =
                tree match
                  case ident@Ident(name) => association.getOrElse(ident.symbol, super.transformTerm(tree))
                  case _ => super.transformTerm(tree)
diff --git a/tests/pos-macros/i9687/Macro_1.scala b/tests/pos-macros/i9687/Macro_1.scala
index 55262b8fa9e0..1181070312d5 100644
--- a/tests/pos-macros/i9687/Macro_1.scala
+++ b/tests/pos-macros/i9687/Macro_1.scala
@@ -27,7 +27,7 @@ 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)(using Owner):Term = {
         term match
           case Apply(sel@Select(o,m),args) =>
                 if ( o.tpe =:= slowPath.tpe && m=="sum" )
diff --git a/tests/pos-macros/i9894/Macro_1.scala b/tests/pos-macros/i9894/Macro_1.scala
index 8de97f0b53ba..442180a2a709 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(mt, args => changeArgs(params,args,transform(body).adaptOwner))
             r
           case _ =>
             throw RuntimeException("lambda expected")
@@ -57,7 +57,7 @@ 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)(using Owner): Term =
                tree match
                  case ident@Ident(name) => association.getOrElse(ident.symbol, super.transformTerm(tree))
                  case _ => super.transformTerm(tree)
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..51a278a26a26 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
@@ -20,7 +20,7 @@ object Macros {
 
   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)(using Owner): Unit = {
       tree match {
         case tree @ DefDef(name, _, _, _, _) =>
           buff.append(name)
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..14e9261c448b 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,7 +19,7 @@ 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)(using Owner): Unit = tree match {
         case tree: Definition =>
           tree.symbol.documentation match {
             case Some(doc) => println(doc.raw)
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..9e12237162f9 100644
--- a/tests/run-custom-args/tasty-inspector/tasty-inspector/Test.scala
+++ b/tests/run-custom-args/tasty-inspector/tasty-inspector/Test.scala
@@ -19,7 +19,7 @@ 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)(using Owner): Unit = tree match {
         case tree: Definition =>
           println(tree.showExtractors)
           super.traverseTree(tree)
diff --git a/tests/run-custom-args/tasty-interpreter/interpreter/TastyInterpreter.scala b/tests/run-custom-args/tasty-interpreter/interpreter/TastyInterpreter.scala
index 2d3809e0f461..f8a0e9cd21dd 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)(using Owner): Unit = tree match {
         // TODO: check the correct sig and object enclosement for main
         case DefDef("main", _, _, _, Some(rhs)) =>
           val interpreter = new jvm.Interpreter
diff --git a/tests/run-macros/i6988/FirstArg_1.scala b/tests/run-macros/i6988/FirstArg_1.scala
index deb231c7d47b..0e8911e522b7 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 = Owner.current.symbol): 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(Owner.current.symbol)
     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..767803b368fa 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(Owner.current.symbol)
     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..b3e3ff1724e1 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
     (params, body.asExpr.asInstanceOf[Expr[R]])
   }
 
@@ -78,7 +78,7 @@ object UnsafeExpr {
     import qctx.reflect._
     val map = params.map(_.symbol).zip(args).toMap
     new TreeMap {
-      override def transformTerm(tree: Term)(using ctx: Context): Term =
+      override def transformTerm(tree: Term)(using Owner): Term =
         super.transformTerm(tree) match
           case tree: Ident => map.getOrElse(tree.symbol, tree)
           case tree => tree
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..a384c0b8e358 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
     (params, body.asExpr.asInstanceOf[Expr[R]])
   }
 
@@ -90,7 +90,7 @@ object UnsafeExpr {
     import qctx.reflect._
     val map = params.map(_.symbol).zip(args).toMap
     new TreeMap {
-      override def transformTerm(tree: Term)(using ctx: Context): Term =
+      override def transformTerm(tree: Term)(using Owner): Term =
         super.transformTerm(tree) match
           case tree: Ident => map.getOrElse(tree.symbol, tree)
           case tree => tree
diff --git a/tests/run-macros/quote-matching-open/Macro_1.scala b/tests/run-macros/quote-matching-open/Macro_1.scala
index 35b860d3bfdd..81949e7595c5 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
     (params, body.asExpr.asInstanceOf[Expr[R]])
   }
 
@@ -42,7 +42,7 @@ object UnsafeExpr {
     import qctx.reflect._
     val map = params.map(_.symbol).zip(args).toMap
     new TreeMap {
-      override def transformTerm(tree: Term)(using ctx: Context): Term =
+      override def transformTerm(tree: Term)(using Owner): Term =
         super.transformTerm(tree) match
           case tree: Ident => map.getOrElse(tree.symbol, tree)
           case tree => tree
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..5cc991ca49da 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,6 @@ object Macros {
 
     // simple smoke test
     val sym1 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
       "sym1",
       MethodType(List("a","b"))(
         _ => List(TypeRepr.of[Int], TypeRepr.of[Int]),
@@ -27,7 +26,6 @@ object Macros {
 
     // test for no argument list (no Apply node)
     val sym2 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
       "sym2",
       ByNameType(TypeRepr.of[Int]))
     assert(sym2.isDefDef)
@@ -43,7 +41,6 @@ object Macros {
 
    // test for multiple argument lists
    val sym3 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
       "sym3",
       MethodType(List("a"))(
         _ => List(TypeRepr.of[Int]),
@@ -63,7 +60,6 @@ object Macros {
 
     // test for recursive references
     val sym4 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
       "sym4",
       MethodType(List("x"))(
         _ => List(TypeRepr.of[Int]),
@@ -85,7 +81,6 @@ 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,
       "sym5",
       MethodType(List("x"))(
         _ => List(TypeRepr.of[Int]),
@@ -98,11 +93,10 @@ object Macros {
           case List(List(x)) =>
             Some {
               val sym51 : Symbol = Symbol.newMethod(
-                sym5,
                 "sym51",
                 MethodType(List("x"))(
                   _ => List(TypeRepr.of[Int]),
-                  _ => TypeRepr.of[Int]))
+                  _ => TypeRepr.of[Int]))(using Owner(sym5))
               Block(
                 List(
                   DefDef(sym51, {
@@ -119,13 +113,11 @@ object Macros {
 
     // test mutually recursive definitions
     val sym6_1 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
       "sym6_1",
       MethodType(List("x"))(
         _ => List(TypeRepr.of[Int]),
         _ => TypeRepr.of[Int]))
     val sym6_2 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
       "sym6_2",
       MethodType(List("x"))(
         _ => List(TypeRepr.of[Int]),
@@ -166,7 +158,6 @@ object Macros {
 
     // test polymorphic methods by synthesizing an identity method
     val sym7 : Symbol = Symbol.newMethod(
-      Symbol.currentOwner,
       "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..856c0afda98a 100644
--- a/tests/run-macros/tasty-extractors-3/quoted_1.scala
+++ b/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)(using Owner): Unit = tree match {
         case tree: TypeBoundsTree =>
           buff.append(tree.tpe.showExtractors)
           buff.append("\n\n")
diff --git a/tests/run-macros/tasty-location/quoted_1.scala b/tests/run-macros/tasty-location/quoted_1.scala
index d677bac223ab..e6923ee548fa 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(Owner.current.symbol, 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..0f4e99d7585b 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.asExprOf[() => Int]}() })
+              case 1 => Expr.betaReduce('{ ${fn.etaExpand.asExprOf[Int => Int]}(0) })
+              case 2 => Expr.betaReduce('{ ${fn.etaExpand.asExprOf[(Int, Int) => Int]}(0, 0) })
+              case 3 => Expr.betaReduce('{ ${fn.etaExpand.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.asExprOf[() => Any]}() }))
+          case 1 => Term.of(Expr.betaReduce('{ ${pre.etaExpand.asExprOf[Int => Any]}(0) }))
+          case 2 => Term.of(Expr.betaReduce('{ ${pre.etaExpand.asExprOf[(Int, Int) => Any]}(0, 0) }))
+          case 3 => Term.of(Expr.betaReduce('{ ${pre.etaExpand.asExprOf[(Int, Int, Int) => Any]}(0, 0, 0) }))
         }
       case _ => term
     }