Implement fresh injection of trees into ReplSession object

Author: felixmulder

repl/src/dotty/tools/repl/InjectableTree.scala

@@ -6,7 +6,8 @@ import dotc.core.Decorators.PreNamedString
 import dotc.ast.tpd.{ ModuleDef, Thicket, cpy }
 import dotc.core.Flags.EmptyFlags
 import dotc.core.Scopes
-import dotc.ast.Trees.Template
+import dotc.ast.Trees._
+import dotc.ast.tpd
 import dotc.core.StdNames._
 
 import results.Result
@@ -30,8 +31,16 @@ object InjectableTree {
            (implicit ctx: Context): Result[InjectableTree] = {
 
     val changedTrees =
-      res.trees.map(t => t.changeOwner(t.symbol, tree.obj.symbol)).toList
+      res.trees.map(t => t.changeOwner(t.symbol, tree.obj.trees(1).symbol)).toList
 
-    new InjectableTree(cpy.Thicket(tree.obj)(changedTrees), tree.nextId)
+    val statsReplacer = new tpd.TreeMap {
+      override def transformStats(trees: List[tpd.Tree])(implicit ctx: Context) =
+        changedTrees
+    }
+
+    new InjectableTree(
+      statsReplacer.transform(tree.obj).asInstanceOf[tpd.Thicket],
+      tree.nextId
+    )
   }
 }

repl/src/dotty/tools/repl/Repl.scala

@@ -27,7 +27,7 @@ class Repl(settings: Array[String]) extends Driver {
     ictx
   }
 
-  protected[this] var myCtx    = initializeCtx
+  protected[this] var myCtx    = initializeCtx: Context
   protected[this] var typer    = new ReplTyper(myCtx)
   protected[this] var compiler = new ReplCompiler(myCtx)
 
@@ -56,17 +56,20 @@ class Repl(settings: Array[String]) extends Driver {
   def compile(parsed: Parsed, tree: InjectableTree)(implicit ctx: Context): InjectableTree = {
     val res = for {
       typed    <- typer.typeCheck(parsed, tree.nextId)
-      injected <- InjectableTree.patch(tree, typed)
-      _        <- compiler.compile(injected.obj)
-    } yield injected
+      injected <- InjectableTree.patch(tree, typed)(typed.newCtx)
+      _        <- compiler.compile(injected.obj)(typed.newCtx)
+    } yield (injected, typed.newCtx)
 
     // Fold over result, on failure - report errors and return old `tree`:
     res.fold(
       errors => {
         displayErrors(errors.msgs)
         tree
       },
-      id
+      (injected, newCtx) => {
+        myCtx = newCtx
+        injected
+      }
     )
   }
 

repl/src/dotty/tools/repl/ReplTyper.scala

@@ -18,7 +18,7 @@ import io._
 
 import results._
 
-case class TypedTrees(nextId: Int, trees: Seq[tpd.Tree])
+case class TypedTrees(nextId: Int, trees: Seq[tpd.Tree], newCtx: Context)
 
 class ReplTyper(ictx: Context) extends Compiler {
 
@@ -84,7 +84,7 @@ class ReplTyper(ictx: Context) extends Compiler {
     run.compileUnits(unit :: Nil)
 
     val errs = reporter.removeBufferedMessages
-    if (errs.isEmpty) TypedTrees(newRes, extractStats(unit.tpdTree))
+    if (errs.isEmpty) TypedTrees(newRes, extractStats(unit.tpdTree), run.runContext)
     else Errors(errs)
   }
 }

repl/test/dotty/tools/repl/InjectableTreeTests.scala

@@ -4,8 +4,18 @@ package repl
 import org.junit.Assert._
 import org.junit.Test
 import dotc.ast.tpd
+import dotc.core.Contexts.Context
 
 class InjectableTreeTests extends ReplTest {
+
+  def extractMembers(obj: tpd.TypeDef)(implicit ctx: Context): List[tpd.MemberDef] =
+    obj.rhs match {
+      case tmpl: tpd.Template =>
+        tmpl.body.collect { case tree: tpd.MemberDef => tree }
+      case _ => Nil
+    }
+
+
   @Test def crashCheck = {
     implicit val ctx = myCtx
     val injTree = InjectableTree()
@@ -21,9 +31,17 @@ class InjectableTreeTests extends ReplTest {
     val parsed @ Parsed(_,_) = ParseResult("def foo: 1 = 1")
     val typer = new ReplTyper(myCtx)
 
-    val tt @ TypedTrees(_,_) = typer.typeCheck(parsed, 0)
-    val newInjTree @ InjectableTree(_,_) = InjectableTree.patch(injTree, tt)
+    val tt @ TypedTrees(_,_, newCtx) = typer.typeCheck(parsed, 0)
+    val InjectableTree(tpd.Thicket(List(_, obj: tpd.TypeDef)), 0) =
+      InjectableTree.patch(injTree, tt)(newCtx)
+
+    val members = extractMembers(obj)
+
+    assert(members.length == 1, s"Wrong amount of members in object: $members")
 
-    // assert( newInjTree has 1 method == "def foo: 1 = 1" )
+    members.head match {
+      case tpd.DefDef(name, _, _, _, _) => assert(name.show == "foo")
+      case _ => assert(false, "incorrect shit yo")
+    }
   }
 }