adds internal.changeOwner

As per Jason’s and Mark’s request, this commit introduces `changeOwner`,
a facility to fixup symbol owner chains to prevent owner chain corruption
in macro expansions leading to crashes in LambdaLift and GenICode.

This is quite a low-level API that should only be used by expert users
to get their job done.

In the meanwhile we’ll be working on fixing the macro engine to
automatically prevent owner chain corruption in the first place:
https://groups.google.com/forum/#!topic/scala-internals/TtCTPlj_qcQ.

2 files changed, 30 insertions, 0 deletions

diff --git a/src/reflect/scala/reflect/internal/Internals.scala b/src/reflect/scala/reflect/internal/Internals.scala
index 9f503f66c3..cd2017e693 100644
--- a/src/reflect/scala/reflect/internal/Internals.scala
+++ b/src/reflect/scala/reflect/internal/Internals.scala
@@ -58,6 +58,20 @@ trait Internals extends api.Internals {
     def typeDef(sym: Symbol): TypeDef = self.TypeDef(sym)
     def labelDef(sym: Symbol, params: List[Symbol], rhs: Tree): LabelDef = self.LabelDef(sym, params, rhs)
 
+    def changeOwner(tree: Tree, prev: Symbol, next: Symbol): tree.type = {
+      object changeOwnerAndModuleClassTraverser extends ChangeOwnerTraverser(prev, next) {
+        override def traverse(tree: Tree) {
+          tree match {
+            case _: DefTree => change(tree.symbol.moduleClass)
+            case _          => // do nothing
+          }
+          super.traverse(tree)
+        }
+      }
+      changeOwnerAndModuleClassTraverser.traverse(tree)
+      tree
+    }
+
     lazy val gen = self.treeBuild
 
     def isFreeTerm(symbol: Symbol): Boolean = symbol.isFreeTerm
diff --git a/src/reflect/scala/reflect/macros/Universe.scala b/src/reflect/scala/reflect/macros/Universe.scala
index 9840295c95..15fd6bad99 100644
--- a/src/reflect/scala/reflect/macros/Universe.scala
+++ b/src/reflect/scala/reflect/macros/Universe.scala
@@ -25,6 +25,22 @@ abstract class Universe extends scala.reflect.api.Universe {
   /** @inheritdoc */
   trait MacroInternalApi extends InternalApi {
 
+    /** Collects all the symbols defined by subtrees of `tree` that are owned by `prev`,
+     *  and then changes their owner to point to `next`.
+     *
+     *  This is an essential tool to battle owner chain corruption when moving trees
+     *  from one lexical context to another. Whenever you take an attributed tree that
+     *  has been typechecked under the Context owned by some symbol (let's call it `x`)
+     *  and splice it elsewhere, into the Context owned by another symbol (let's call it `y`),
+     *  it is imperative that you either call `untypecheck` or do `changeOwner(tree, x, y)`.
+     *
+     *  Since at the moment `untypecheck` has fundamental problem that can sometimes lead to tree corruption,
+     *  `changeOwner` becomes an indispensible tool in building 100% robust macros.
+     *  Future versions of the reflection API might obviate the need in taking care of
+     *  these low-level details, but at the moment this is what we've got.
+     */
+    def changeOwner(tree: Tree, prev: Symbol, next: Symbol): tree.type
+
     /** Advanced tree factories */
     val gen: TreeGen