Replace Reflect Context with Owner

compiler/src/dotty/tools/dotc/quoted/QuoteContextImpl.scala

@@ -19,10 +19,10 @@ object QuoteContextImpl {
     val syntaxHighlight =
       if (ctx.settings.color.value == "always") SyntaxHighlight.ANSI
       else SyntaxHighlight.plain
-    show(using qctx)(tree.asInstanceOf[qctx.tasty.Tree], syntaxHighlight)(using ctx.asInstanceOf[qctx.tasty.Context])
+    show(using qctx)(tree.asInstanceOf[qctx.tasty.Tree], syntaxHighlight)
   }
 
-  private def show(using qctx: QuoteContext)(tree: qctx.tasty.Tree, syntaxHighlight: SyntaxHighlight)(using qctx.tasty.Context) =
+  private def show(using qctx: QuoteContext)(tree: qctx.tasty.Tree, syntaxHighlight: SyntaxHighlight) =
     tree.showWith(syntaxHighlight)
 
   private[dotty] def checkScopeId(id: ScopeId)(using Context): Unit =

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

@@ -203,7 +203,7 @@ object Matcher {
 
     extension (scrutinees: List[Tree]):
       /** Check that all trees match with =?= and concatenate the results with &&& */
-      private def =?= (patterns: List[Tree])(using Context, Env): Matching =
+      private def =?= (patterns: List[Tree])(using Owner, Env): Matching =
         matchLists(scrutinees, patterns)(_ =?= _)
 
     extension (scrutinee0: Tree):
@@ -215,7 +215,7 @@ object Matcher {
        *  @param `summon[Env]` Set of tuples containing pairs of symbols (s, p) where s defines a symbol in `scrutinee` which corresponds to symbol p in `pattern`.
        *  @return `None` if it did not match or `Some(tup: Tuple)` if it matched where `tup` contains the contents of the holes.
        */
-      private def =?= (pattern0: Tree)(using Context, Env): Matching = {
+      private def =?= (pattern0: Tree)(using Owner, Env): Matching = {
 
         /* Match block flattening */ // TODO move to cases
         /** Normalize the tree */
@@ -265,7 +265,7 @@ object Matcher {
             def bodyFn(lambdaArgs: List[Tree]): Tree = {
               val argsMap = args.map(_.symbol).zip(lambdaArgs.asInstanceOf[List[Term]]).toMap
               new TreeMap {
-                override def transformTerm(tree: Term)(using ctx: Context): Term =
+                override def transformTerm(tree: Term)(using Owner): Term =
                   tree match
                     case tree: Ident => summon[Env].get(tree.symbol).flatMap(argsMap.get).getOrElse(tree)
                     case tree => super.transformTerm(tree)
@@ -374,7 +374,7 @@ object Matcher {
           /* Match val */
           case (ValDef(_, tpt1, rhs1), ValDef(_, tpt2, rhs2)) if checkValFlags() =>
             def rhsEnv = summon[Env] + (scrutinee.symbol -> pattern.symbol)
-            tpt1 =?= tpt2 &&& treeOptMatches(rhs1, rhs2)(using summon[Context], rhsEnv)
+            tpt1 =?= tpt2 &&& treeOptMatches(rhs1, rhs2)(using summon[Owner], rhsEnv)
 
           /* Match def */
           case (DefDef(_, typeParams1, paramss1, tpt1, Some(rhs1)), DefDef(_, typeParams2, paramss2, tpt2, Some(rhs2))) =>
@@ -423,13 +423,13 @@ object Matcher {
 
     private object ClosedPatternTerm {
       /** Matches a term that does not contain free variables defined in the pattern (i.e. not defined in `Env`) */
-      def unapply(term: Term)(using Context, Env): Option[term.type] =
+      def unapply(term: Term)(using Owner, Env): Option[term.type] =
         if freePatternVars(term).isEmpty then Some(term) else None
 
       /** 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] =
+      def freePatternVars(term: Term)(using owner: Owner, 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): Set[Symbol] =
             tree match
               case tree: Ident if env.contains(tree.symbol) => foldOverTree(x + tree.symbol, tree)
               case _ => foldOverTree(x, tree)
@@ -438,7 +438,7 @@ object Matcher {
     }
 
     private object IdentArgs {
-      def unapply(args: List[Term])(using Context): Option[List[Ident]] =
+      def unapply(args: List[Term])(using Owner): Option[List[Ident]] =
         args.foldRight(Option(List.empty[Ident])) {
           case (id: Ident, Some(acc)) => Some(id :: acc)
           case (Block(List(DefDef("$anonfun", Nil, List(params), Inferred(), Some(Apply(id: Ident, args)))), Closure(Ident("$anonfun"), None)), Some(acc))
@@ -448,7 +448,7 @@ object Matcher {
         }
     }
 
-    private def treeOptMatches(scrutinee: Option[Tree], pattern: Option[Tree])(using Context, Env): Matching = {
+    private def treeOptMatches(scrutinee: Option[Tree], pattern: Option[Tree])(using Owner, Env): Matching = {
       (scrutinee, pattern) match {
         case (Some(x), Some(y)) => x =?= y
         case (None, None) => matched

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

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

library/src-bootstrapped/scala/quoted/util/ExprMap.scala

@@ -12,8 +12,7 @@ trait ExprMap {
     import qctx.tasty._
     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): Statement = {
         tree match {
           case tree: Term =>
             transformTerm(tree, defn.AnyType)
@@ -24,15 +23,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): Definition = {
         tree match {
           case tree: ValDef =>
-            given Context = localCtx(tree)
+            given Owner = Owner.fromSymbol(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.fromSymbol(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
@@ -42,7 +40,7 @@ trait ExprMap {
         }
       }
 
-      def transformTermChildren(tree: Term, tpe: Type)(using ctx: Context): Term = tree match {
+      def transformTermChildren(tree: Term, tpe: Type)(using Owner): Term = tree match {
         case Ident(name) =>
           tree
         case Select(qualifier, name) =>
@@ -96,7 +94,7 @@ trait ExprMap {
           Inlined.copy(tree)(call, transformDefinitions(bindings), transformTerm(expansion, tpe)/*()call.symbol.localContext)*/)
       }
 
-      def transformTerm(tree: Term, tpe: Type)(using ctx: Context): Term =
+      def transformTerm(tree: Term, tpe: Type)(using Owner): Term =
         tree match
           case _: Closure =>
             tree
@@ -110,39 +108,39 @@ trait ExprMap {
           case _ =>
             transformTermChildren(tree, tpe)
 
-      def transformTypeTree(tree: TypeTree)(using ctx: Context): TypeTree = tree
+      def transformTypeTree(tree: TypeTree)(using Owner): TypeTree = tree
 
-      def transformCaseDef(tree: CaseDef, tpe: Type)(using ctx: Context): CaseDef =
+      def transformCaseDef(tree: CaseDef, tpe: Type)(using Owner): CaseDef =
         CaseDef.copy(tree)(tree.pattern, tree.guard.map(x => transformTerm(x, defn.BooleanType)), transformTerm(tree.rhs, tpe))
 
-      def transformTypeCaseDef(tree: TypeCaseDef)(using ctx: Context): TypeCaseDef = {
+      def transformTypeCaseDef(tree: TypeCaseDef)(using 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): List[Statement] =
         trees mapConserve (transformStatement(_))
 
-      def transformDefinitions(trees: List[Definition])(using ctx: Context): List[Definition] =
+      def transformDefinitions(trees: List[Definition])(using Owner): List[Definition] =
         trees mapConserve (transformDefinition(_))
 
-      def transformTerms(trees: List[Term], tpes: List[Type])(using ctx: Context): List[Term] =
+      def transformTerms(trees: List[Term], tpes: List[Type])(using Owner): List[Term] =
         var tpes2 = tpes // TODO use proper zipConserve
         trees mapConserve { x =>
           val tpe :: tail = tpes2
           tpes2 = tail
           transformTerm(x, tpe)
         }
 
-      def transformTerms(trees: List[Term], tpe: Type)(using ctx: Context): List[Term] =
+      def transformTerms(trees: List[Term], tpe: Type)(using 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): List[TypeTree] =
         trees mapConserve (transformTypeTree(_))
 
-      def transformCaseDefs(trees: List[CaseDef], tpe: Type)(using ctx: Context): List[CaseDef] =
+      def transformCaseDefs(trees: List[CaseDef], tpe: Type)(using 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): List[TypeCaseDef] =
         trees mapConserve (transformTypeCaseDef(_))
 
     }