Use the same virtual file for parsing and compiling in REPL

Author: nicolasstucki

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

@@ -25,7 +25,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
    */
   abstract case class TypedSplice(splice: tpd.Tree)(val owner: Symbol)(implicit @transientParam src: SourceFile) extends ProxyTree {
     def forwardTo: tpd.Tree = splice
-    span = splice.span
   }
 
   object TypedSplice {

compiler/src/dotty/tools/repl/ParseResult.scala

@@ -7,15 +7,15 @@ import dotc.parsing.Parsers.Parser
 import dotc.parsing.Tokens
 import dotc.util.SourceFile
 import dotc.ast.untpd
-
+import dotty.tools.dotc.core.StdNames.str
 
 import scala.annotation.internal.sharable
 
 /** A parsing result from string input */
 sealed trait ParseResult
 
 /** An error free parsing resulting in a list of untyped trees */
-case class Parsed(sourceCode: String, trees: List[untpd.Tree]) extends ParseResult
+case class Parsed(source: SourceFile, trees: List[untpd.Tree]) extends ParseResult
 
 /** A parsing result containing syntax `errors` */
 case class SyntaxErrors(sourceCode: String,
@@ -109,13 +109,14 @@ object ParseResult {
   @sharable private[this] val CommandExtract = """(:[\S]+)\s*(.*)""".r
 
   private def parseStats(sourceCode: String)(implicit ctx: Context): List[untpd.Tree] = {
-    val source = SourceFile.virtual("<console>", sourceCode)
-    val parser = new Parser(source)(ctx.withSource(source))
+    val parser = new Parser(ctx.source)
     val stats = parser.blockStatSeq()
     parser.accept(Tokens.EOF)
     stats
   }
 
+  private[this] var replSessionNumber = 0
+
   /** Extract a `ParseResult` from the string `sourceCode` */
   def apply(sourceCode: String)(implicit ctx: Context): ParseResult =
     sourceCode match {
@@ -131,16 +132,19 @@ object ParseResult {
         case _ => UnknownCommand(cmd)
       }
       case _ =>
+        replSessionNumber += 1
+        val source = SourceFile.virtual(str.REPL_SESSION_LINE + replSessionNumber, sourceCode)
+
         val reporter = newStoreReporter
-        val stats = parseStats(sourceCode)(ctx.fresh.setReporter(reporter))
+        val stats = parseStats(sourceCode)(ctx.fresh.setReporter(reporter).withSource(source))
 
         if (reporter.hasErrors)
           SyntaxErrors(
             sourceCode,
             reporter.removeBufferedMessages,
             stats)
         else
-          Parsed(sourceCode, stats)
+          Parsed(source, stats)
     }
 
   /** Check if the input is incomplete

compiler/src/dotty/tools/repl/ReplCompiler.scala

@@ -64,9 +64,6 @@ class ReplCompiler extends Compiler {
   }
 
   private[this] val objectNames = mutable.Map.empty[Int, TermName]
-  private def objectName(state: State) =
-    objectNames.getOrElseUpdate(state.objectIndex,
-      (str.REPL_SESSION_LINE + state.objectIndex).toTermName)
 
   private case class Definitions(stats: List[untpd.Tree], state: State)
 
@@ -126,23 +123,28 @@ class ReplCompiler extends Compiler {
    *  }
    *  ```
    */
-  private def wrapped(defs: Definitions): untpd.PackageDef = {
+  private def wrapped(defs: Definitions, objectTermName: TermName): untpd.PackageDef = {
     import untpd._
 
     assert(defs.stats.nonEmpty)
 
     implicit val ctx: Context = defs.state.context
 
     val tmpl = Template(emptyConstructor, Nil, EmptyValDef, defs.stats)
-    val module = ModuleDef(objectName(defs.state), tmpl)
+    val module = ModuleDef(objectTermName, tmpl)
       .withSpan(Span(0, defs.stats.last.span.end))
 
     PackageDef(Ident(nme.EMPTY_PACKAGE), List(module))
   }
 
-  private def createUnit(defs: Definitions, sourceCode: String)(implicit ctx: Context): CompilationUnit = {
-    val unit = CompilationUnit(SourceFile.virtual(objectName(defs.state).toString, sourceCode))
-    unit.untpdTree = wrapped(defs)
+  private def createUnit(defs: Definitions)(implicit ctx: Context): CompilationUnit = {
+    val objectName = ctx.source.file.toString
+    assert(objectName.startsWith(str.REPL_SESSION_LINE))
+    val objectTermName = ctx.source.file.toString.toTermName
+    objectNames.update(defs.state.objectIndex, objectTermName)
+
+    val unit = CompilationUnit(ctx.source)
+    unit.untpdTree = wrapped(defs, objectTermName)
     unit
   }
 
@@ -156,7 +158,7 @@ class ReplCompiler extends Compiler {
 
   final def compile(parsed: Parsed)(implicit state: State): Result[(CompilationUnit, State)] = {
     val defs = definitions(parsed.trees, state)
-    val unit = createUnit(defs, parsed.sourceCode)(state.context)
+    val unit = createUnit(defs)(state.context)
     runCompilationUnit(unit, defs.state)
   }
 

compiler/src/dotty/tools/repl/ReplDriver.scala

@@ -208,7 +208,10 @@ class ReplDriver(settings: Array[String],
     def extractTopLevelImports(ctx: Context): List[tpd.Import] =
       ctx.phases.collectFirst { case phase: CollectTopLevelImports => phase.imports }.get
 
-    implicit val state = newRun(istate)
+    implicit val state = {
+      val state0 = newRun(istate)
+      state0.copy(context = state0.context.withSource(parsed.source))
+    }
     compiler
       .compile(parsed)
       .fold(