fixed changeOwner to work for case, when tree is assembeled from parts of trees with different owners.

Author: rssh

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -799,13 +799,29 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
      *  owner to `to`, and continue until a non-weak owner is reached.
      */
     def changeOwner(from: Symbol, to: Symbol)(using Context): ThisTree = {
-      @tailrec def loop(from: Symbol, froms: List[Symbol], tos: List[Symbol]): ThisTree =
-        if (from.isWeakOwner && !from.owner.isClass)
-          loop(from.owner, from :: froms, to :: tos)
-        else
-          //println(i"change owner ${from :: froms}%, % ==> $tos of $tree")
-          TreeTypeMap(oldOwners = from :: froms, newOwners = tos).apply(tree)
-      if (from == to) tree else loop(from, Nil, to :: Nil)
+       changeOwners(List(from),to)
+    }
+
+    /** Change owner from all `froms` to `to`. If `from` is a weak owner, also change its
+     *  owner to `to`, and continue until a non-weak owner is reached.
+     */
+    def changeOwners(froms: List[Symbol], to: Symbol)(using Context): ThisTree = {
+      @tailrec def loop(froms: List[Symbol], processedFroms: List[Symbol], tos: List[Symbol]): ThisTree =
+        froms match
+          case from::rest =>
+            if (from == to)
+               loop(rest, processedFroms, tos)
+            else
+               if (from.isWeakOwner && !from.owner.isClass)
+                  loop(from.owner::rest, from :: processedFroms, to :: tos)
+               else
+                  loop(rest, from::processedFroms, to :: tos)
+          case Nil =>
+               if (processedFroms.isEmpty)
+                  tree
+               else
+                  TreeTypeMap(oldOwners = processedFroms, newOwners = tos).apply(tree)
+      loop(froms, Nil, Nil)
     }
 
     /**

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

@@ -2,6 +2,7 @@ package dotty.tools.dotc.quoted
 
 import dotty.tools.dotc
 import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.tpd.TreeOps
 import dotty.tools.dotc.ast.untpd
 import dotty.tools.dotc.core.Annotations
 import dotty.tools.dotc.core.Contexts._
@@ -742,6 +743,8 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
       def unapply(tree: Block): Option[(List[ValDef], Term)] = tree match {
         case Block((ddef @ DefDef(_, _, params :: Nil, _, Some(body))) :: Nil, Closure(meth, _))
         if ddef.symbol == meth.symbol =>
+          //val cleanParams = params.map(_.changeOwner(meth.symbol,ctx.owner))
+          //val cleanBody = body.changeOwner(meth.symbol,ctx.owner)
           Some((params, body))
         case _ => None
       }

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

@@ -9,24 +9,30 @@ import dotty.tools.dotc.core.Symbols._
 object QuoteUtils:
   import tpd._
 
-  /** Get the owner of a tree if it has one */
-  def treeOwner(tree: Tree)(using Context): Option[Symbol] = {
-    val getCurrentOwner = new TreeAccumulator[Option[Symbol]] {
-      def apply(x: Option[Symbol], tree: tpd.Tree)(using Context): Option[Symbol] =
-        if (x.isDefined) x
-        else tree match {
-          case tree: DefTree => Some(tree.symbol.owner)
-          case _ => foldOver(x, tree)
+  /** Get the list of owners of a tree if it has one */
+  def treeOwners(tree: Tree)(using Context): List[Symbol] = {
+    val getOwners = new TreeAccumulator[Map[Int,Symbol]] {
+      def apply(x: Map[Int,Symbol], tree: tpd.Tree)(using Context): Map[Int,Symbol] =
+        tree match {
+          case tree: DefTree => val owner = tree.symbol.owner
+                                x.updated(owner.id, owner)
+          case _ => foldOver(x,tree)
         }
     }
-    getCurrentOwner(None, tree)
+    getOwners(Map.empty,tree).values.toList
   }
 
+
   /** Changes the owner of the tree based on the current owner of the tree */
   def changeOwnerOfTree(tree: Tree, owner: Symbol)(using Context): Tree = {
+    tree.changeOwners(treeOwners(tree), owner)
+    /*
     treeOwner(tree) match
       case Some(oldOwner) if oldOwner != owner => tree.changeOwner(oldOwner, owner)
-      case _ => tree
+      case _ => 
+           println(s"tree without owner: $tree")
+           tree
+    */
   }
 
 end QuoteUtils