Merge pull request #4564 from som-snytt/issue/promptv2.11.7

SI-9206 Fix REPL code indentation 

30 files changed, 315 insertions, 268 deletions

diff --git a/src/compiler/scala/tools/nsc/Properties.scala b/src/compiler/scala/tools/nsc/Properties.scala
index 9f160e2485..ca7d8776d4 100644
--- a/src/compiler/scala/tools/nsc/Properties.scala
+++ b/src/compiler/scala/tools/nsc/Properties.scala
@@ -13,7 +13,7 @@ object Properties extends scala.util.PropertiesTrait {
 
   // settings based on jar properties, falling back to System prefixed by "scala."
   def residentPromptString = scalaPropOrElse("resident.prompt", "\nnsc> ")
-  def shellPromptString    = scalaPropOrElse("shell.prompt", "\nscala> ")
+  def shellPromptString    = scalaPropOrElse("shell.prompt", "%nscala> ")
   // message to display at EOF (which by default ends with
   // a newline so as not to break the user's terminal)
   def shellInterruptedString = scalaPropOrElse("shell.interrupted", f":quit$lineSeparator")
diff --git a/src/library/scala/sys/BooleanProp.scala b/src/library/scala/sys/BooleanProp.scala
index 74b0a9077b..e5e4668edb 100644
--- a/src/library/scala/sys/BooleanProp.scala
+++ b/src/library/scala/sys/BooleanProp.scala
@@ -63,12 +63,13 @@ object BooleanProp {
   def valueIsTrue[T](key: String): BooleanProp = new BooleanPropImpl(key, _.toLowerCase == "true")
 
   /** As an alternative, this method creates a BooleanProp which is true
-   *  if the key exists in the map.  This way -Dfoo.bar is enough to be
-   *  considered true.
+   *  if the key exists in the map and is not assigned a value other than "true",
+   *  compared case-insensitively, or the empty string.  This way -Dmy.property
+   *  results in a true-valued property, but -Dmy.property=false does not.
    *
    *  @return   A BooleanProp with a liberal truth policy
    */
-  def keyExists[T](key: String): BooleanProp = new BooleanPropImpl(key, _ => true)
+  def keyExists[T](key: String): BooleanProp = new BooleanPropImpl(key, s => s == "" || s.equalsIgnoreCase("true"))
 
   /** A constant true or false property which ignores all method calls.
    */
diff --git a/src/partest-extras/scala/tools/partest/ReplTest.scala b/src/partest-extras/scala/tools/partest/ReplTest.scala
index 5b65d6ab9b..1fde2370d3 100644
--- a/src/partest-extras/scala/tools/partest/ReplTest.scala
+++ b/src/partest-extras/scala/tools/partest/ReplTest.scala
@@ -75,18 +75,20 @@ abstract class SessionTest extends ReplTest  {
    *  Retain user input: prompt lines and continuations, without the prefix; or pasted text plus ctl-D.
    */
   import SessionTest._
-  override final def code = input findAllMatchIn (expected mkString ("", "\n", "\n")) map {
-    case input(null, null, prompted) =>
+  lazy val pasted = input(prompt)
+  override final def code = pasted findAllMatchIn (expected mkString ("", "\n", "\n")) map {
+    case pasted(null, null, prompted) =>
       def continued(m: Match): Option[String] = m match {
         case margin(text) => Some(text)
         case _            => None
       }
       margin.replaceSomeIn(prompted, continued)
-    case input(cmd, pasted, null) =>
+    case pasted(cmd, pasted, null) =>
       cmd + pasted + "\u0004"
   } mkString
 
-  final def prompt = "scala> "
+  // Just the last line of the interactive prompt
+  def prompt = "scala> "
 
   /** Default test is to compare expected and actual output and emit the diff on a failed comparison. */
   override def show() = {
@@ -98,7 +100,7 @@ abstract class SessionTest extends ReplTest  {
 }
 object SessionTest {
   // \R for line break is Java 8, \v for vertical space might suffice
-  val input = """(?m)^scala> (:pa.*\u000A)// Entering paste mode.*\u000A\u000A((?:.*\u000A)*)\u000A// Exiting paste mode.*\u000A|^scala> (.*\u000A(?:\s*\| .*\u000A)*)""".r
+  def input(prompt: String) = s"""(?m)^$prompt(:pa.*\u000A)// Entering paste mode.*\u000A\u000A((?:.*\u000A)*)\u000A// Exiting paste mode.*\u000A|^scala> (.*\u000A(?:\\s*\\| .*\u000A)*)""".r
 
   val margin = """(?m)^\s*\| (.*)$""".r
 }
diff --git a/src/repl/scala/tools/nsc/interpreter/Formatting.scala b/src/repl/scala/tools/nsc/interpreter/Formatting.scala
index 43e653edfd..844997429c 100644
--- a/src/repl/scala/tools/nsc/interpreter/Formatting.scala
+++ b/src/repl/scala/tools/nsc/interpreter/Formatting.scala
@@ -8,28 +8,25 @@ package interpreter
 
 import util.stringFromWriter
 
-trait Formatting {
-  def prompt: String
+class Formatting(indent: Int) {
 
-  def spaces(code: String): String = {
+  private val indentation = " " * indent
+
+  private def indenting(code: String): Boolean = {
     /** Heuristic to avoid indenting and thereby corrupting """-strings and XML literals. */
     val tokens = List("\"\"\"", "</", "/>")
     val noIndent = (code contains "\n") && (tokens exists code.contains)
 
-    if (noIndent) ""
-    else prompt drop 1 map (_ => ' ')
+    !noIndent
   }
   /** Indent some code by the width of the scala> prompt.
    *  This way, compiler error messages read better.
    */
-  def indentCode(code: String) = {
-    val indent = spaces(code)
-    stringFromWriter(str =>
-      for (line <- code.lines) {
-        str print indent
-        str print (line + "\n")
-        str.flush()
-      }
-    )
-  }
+  def indentCode(code: String) = stringFromWriter(str =>
+    for (line <- code.lines) {
+      if (indenting(code)) str print indentation
+      str println line
+      str.flush()
+    }
+  )
 }
diff --git a/src/repl/scala/tools/nsc/interpreter/ILoop.scala b/src/repl/scala/tools/nsc/interpreter/ILoop.scala
index a3047ccc8e..525609171e 100644
--- a/src/repl/scala/tools/nsc/interpreter/ILoop.scala
+++ b/src/repl/scala/tools/nsc/interpreter/ILoop.scala
@@ -111,11 +111,10 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
   }
 
   class ILoopInterpreter extends IMain(settings, out) {
-    outer =>
-
-    override lazy val formatting = new Formatting {
-      def prompt = ILoop.this.prompt
-    }
+    // the expanded prompt but without color escapes and without leading newline, for purposes of indenting
+    override lazy val formatting: Formatting = new Formatting(
+      (replProps.promptString format Properties.versionNumberString).lines.toList.last.length
+    )
     override protected def parentClassLoader =
       settings.explicitParentLoader.getOrElse( classOf[ILoop].getClassLoader )
   }
@@ -199,10 +198,8 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
       echo("%d %s".format(index + offset, line))
   }
 
-  private val currentPrompt = Properties.shellPromptString
-
   /** Prompt to print when awaiting input */
-  def prompt = currentPrompt
+  def prompt = replProps.prompt
 
   import LoopCommand.{ cmd, nullary }
 
@@ -412,14 +409,8 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
   }
 
   private def readOneLine() = {
-    import scala.io.AnsiColor.{ MAGENTA, RESET }
     out.flush()
-    in readLine (
-      if (replProps.colorOk)
-        MAGENTA + prompt + RESET
-      else
-        prompt
-    )
+    in readLine prompt
   }
 
   /** The main read-eval-print loop for the repl.  It calls
@@ -770,8 +761,13 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
   }
 
   private object paste extends Pasted {
+    import scala.util.matching.Regex.quote
     val ContinueString = "     | "
-    val PromptString   = "scala> "
+    val PromptString   = prompt.lines.toList.last
+    val anyPrompt = s"""\\s*(?:${quote(PromptString.trim)}|${quote(AltPromptString.trim)})\\s*""".r
+
+    def isPrompted(line: String)   = matchesPrompt(line)
+    def isPromptOnly(line: String) = line match { case anyPrompt() => true ; case _ => false }
 
     def interpret(line: String): Unit = {
       echo(line.trim)
@@ -781,10 +777,17 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
 
     def transcript(start: String) = {
       echo("\n// Detected repl transcript paste: ctrl-D to finish.\n")
-      apply(Iterator(start) ++ readWhile(_.trim != PromptString.trim))
+      apply(Iterator(start) ++ readWhile(!isPromptOnly(_)))
     }
+
+    def unapply(line: String): Boolean = isPrompted(line)
+  }
+
+  private object invocation {
+    def unapply(line: String): Boolean = Completion.looksLikeInvocation(line)
   }
-  import paste.{ ContinueString, PromptString }
+
+  private val lineComment = """\s*//.*""".r   // all comment
 
   /** Interpret expressions starting with the first line.
     * Read lines until a complete compilation unit is available
@@ -796,53 +799,42 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
     // signal completion non-completion input has been received
     in.completion.resetVerbosity()
 
-    def reallyInterpret = {
-      val reallyResult = intp.interpret(code)
-      (reallyResult, reallyResult match {
-        case IR.Error       => None
-        case IR.Success     => Some(code)
-        case IR.Incomplete  =>
-          if (in.interactive && code.endsWith("\n\n")) {
-            echo("You typed two blank lines.  Starting a new command.")
+    def reallyInterpret = intp.interpret(code) match {
+      case IR.Error      => None
+      case IR.Success    => Some(code)
+      case IR.Incomplete if in.interactive && code.endsWith("\n\n") =>
+        echo("You typed two blank lines.  Starting a new command.")
+        None
+      case IR.Incomplete =>
+        in.readLine(paste.ContinueString) match {
+          case null =>
+            // we know compilation is going to fail since we're at EOF and the
+            // parser thinks the input is still incomplete, but since this is
+            // a file being read non-interactively we want to fail.  So we send
+            // it straight to the compiler for the nice error message.
+            intp.compileString(code)
             None
-          }
-          else in.readLine(ContinueString) match {
-            case null =>
-              // we know compilation is going to fail since we're at EOF and the
-              // parser thinks the input is still incomplete, but since this is
-              // a file being read non-interactively we want to fail.  So we send
-              // it straight to the compiler for the nice error message.
-              intp.compileString(code)
-              None
-
-            case line => interpretStartingWith(code + "\n" + line)
-          }
-      })
+
+          case line => interpretStartingWith(code + "\n" + line)
+        }
     }
 
-    /** Here we place ourselves between the user and the interpreter and examine
-     *  the input they are ostensibly submitting.  We intervene in several cases:
+    /* Here we place ourselves between the user and the interpreter and examine
+     * the input they are ostensibly submitting.  We intervene in several cases:
      *
-     *  1) If the line starts with "scala> " it is assumed to be an interpreter paste.
-     *  2) If the line starts with "." (but not ".." or "./") it is treated as an invocation
-     *     on the previous result.
-     *  3) If the Completion object's execute returns Some(_), we inject that value
-     *     and avoid the interpreter, as it's likely not valid scala code.
+     * 1) If the line starts with "scala> " it is assumed to be an interpreter paste.
+     * 2) If the line starts with "." (but not ".." or "./") it is treated as an invocation
+     *    on the previous result.
+     * 3) If the Completion object's execute returns Some(_), we inject that value
+     *    and avoid the interpreter, as it's likely not valid scala code.
      */
-    if (code == "") None
-    else if (!paste.running && code.trim.startsWith(PromptString)) {
-      paste.transcript(code)
-      None
-    }
-    else if (Completion.looksLikeInvocation(code) && intp.mostRecentVar != "") {
-      interpretStartingWith(intp.mostRecentVar + code)
+    code match {
+      case ""                                       => None
+      case lineComment()                            => None                 // line comment, do nothing
+      case paste() if !paste.running                => paste.transcript(code) ; None
+      case invocation() if intp.mostRecentVar != "" => interpretStartingWith(intp.mostRecentVar + code)
+      case _                                        => reallyInterpret
     }
-    else if (code.trim startsWith "//") {
-      // line comment, do nothing
-      None
-    }
-    else
-      reallyInterpret._2
   }
 
   // runs :load `file` on any files passed via -i
diff --git a/src/repl/scala/tools/nsc/interpreter/IMain.scala b/src/repl/scala/tools/nsc/interpreter/IMain.scala
index e355d9f864..2550a5dc57 100644
--- a/src/repl/scala/tools/nsc/interpreter/IMain.scala
+++ b/src/repl/scala/tools/nsc/interpreter/IMain.scala
@@ -112,12 +112,13 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
   def this(factory: ScriptEngineFactory) = this(factory, new Settings())
   def this() = this(new Settings())
 
-  lazy val formatting: Formatting = new Formatting {
-    val prompt = Properties.shellPromptString
-  }
+  // the expanded prompt but without color escapes and without leading newline, for purposes of indenting
+  lazy val formatting: Formatting = new Formatting(
+    (replProps.promptString format Properties.versionNumberString).lines.toList.last.length
+  )
   lazy val reporter: ReplReporter = new ReplReporter(this)
 
-  import formatting._
+  import formatting.indentCode
   import reporter.{ printMessage, printUntruncatedMessage }
 
   // This exists mostly because using the reporter too early leads to deadlock.
@@ -468,7 +469,7 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
   }
 
   private def requestFromLine(line: String, synthetic: Boolean): Either[IR.Result, Request] = {
-    val content = indentCode(line)
+    val content = line  //indentCode(line)
     val trees = parse(content) match {
       case parse.Incomplete     => return Left(IR.Incomplete)
       case parse.Error          => return Left(IR.Error)
@@ -909,10 +910,10 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
         else List("def %s = %s".format("$line", tquoted(originalLine)), "def %s = Nil".format("$trees"))
       }
       def preamble = s"""
-        |$preambleHeader
-        |%s%s%s
-      """.stripMargin.format(lineRep.readName, envLines.map("  " + _ + ";\n").mkString,
-        importsPreamble, indentCode(toCompute))
+        |${preambleHeader format lineRep.readName}
+        |${envLines mkString ("  ", ";\n  ", ";\n")}
+        |$importsPreamble
+        |${indentCode(toCompute)}""".stripMargin
 
       val generate = (m: MemberHandler) => m extraCodeToEvaluate Request.this
 
diff --git a/src/repl/scala/tools/nsc/interpreter/Pasted.scala b/src/repl/scala/tools/nsc/interpreter/Pasted.scala
index f5db3d9e3a..5f388eb15b 100644
--- a/src/repl/scala/tools/nsc/interpreter/Pasted.scala
+++ b/src/repl/scala/tools/nsc/interpreter/Pasted.scala
@@ -16,17 +16,21 @@ package interpreter
  *  the same result.
  */
 abstract class Pasted {
+  def interpret(line: String): Unit
   def ContinueString: String
   def PromptString: String
-  def interpret(line: String): Unit
+  def AltPromptString: String = "scala> "
+
+  private val testBoth = PromptString != AltPromptString
+  private val spacey   = " \t".toSet
 
-  def matchesPrompt(line: String) = matchesString(line, PromptString)
+  def matchesPrompt(line: String) = matchesString(line, PromptString) || testBoth && matchesString(line, AltPromptString)
   def matchesContinue(line: String) = matchesString(line, ContinueString)
   def running = isRunning
 
   private def matchesString(line: String, target: String): Boolean = (
     (line startsWith target) ||
-    (line.nonEmpty && " \t".toSet(line.head) && matchesString(line.tail, target))
+    (line.nonEmpty && spacey(line.head) && matchesString(line.tail, target))
   )
   private def stripString(line: String, target: String) = line indexOf target match {
     case -1   => line
@@ -39,7 +43,9 @@ abstract class Pasted {
 
   private class PasteAnalyzer(val lines: List[String]) {
     val referenced = lines flatMap (resReference findAllIn _.trim.stripPrefix("res")) toSet
-    val cmds       = lines reduceLeft append split PromptString filterNot (_.trim == "") toList
+    val ActualPromptString = lines find matchesPrompt map (s =>
+      if (matchesString(s, PromptString)) PromptString else AltPromptString) getOrElse PromptString
+    val cmds       = lines reduceLeft append split ActualPromptString filterNot (_.trim == "") toList
 
     /** If it's a prompt or continuation line, strip the formatting bits and
      *  assemble the code.  Otherwise ship it off to be analyzed for res references
@@ -67,10 +73,10 @@ abstract class Pasted {
      */
     def fixResRefs(code: String, line: String) = line match {
       case resCreation(resName) if referenced(resName) =>
-        code.lastIndexOf(PromptString) match {
+        code.lastIndexOf(ActualPromptString) match {
           case -1   => code
           case idx  =>
-            val (str1, str2) = code splitAt (idx + PromptString.length)
+            val (str1, str2) = code splitAt (idx + ActualPromptString.length)
             str2 match {
               case resAssign(`resName`) => code
               case _                    => "%sval %s = { %s }".format(str1, resName, str2)
@@ -79,10 +85,10 @@ abstract class Pasted {
       case _ => code
     }
 
-    def run() {
+    def run(): Unit = {
       println("// Replaying %d commands from transcript.\n" format cmds.size)
       cmds foreach { cmd =>
-        print(PromptString)
+        print(ActualPromptString)
         interpret(cmd)
       }
     }
diff --git a/src/repl/scala/tools/nsc/interpreter/ReplProps.scala b/src/repl/scala/tools/nsc/interpreter/ReplProps.scala
index 8c4faf7278..df65e9974d 100644
--- a/src/repl/scala/tools/nsc/interpreter/ReplProps.scala
+++ b/src/repl/scala/tools/nsc/interpreter/ReplProps.scala
@@ -6,12 +6,13 @@
 package scala.tools.nsc
 package interpreter
 
+import Properties.shellPromptString
 import scala.sys._
 import Prop._
 
 class ReplProps {
   private def bool(name: String) = BooleanProp.keyExists(name)
-  private def int(name: String) = IntProp(name)
+  private def int(name: String)  = Prop[Int](name)
 
   // This property is used in TypeDebugging. Let's recycle it.
   val colorOk = bool("scala.color")
@@ -21,6 +22,14 @@ class ReplProps {
   val trace = bool("scala.repl.trace")
   val power = bool("scala.repl.power")
 
+  // Handy system prop for shell prompt, or else pick it up from compiler.properties
+  val promptString = Prop[String]("scala.repl.prompt").option getOrElse (if (info) "%nscala %s> " else shellPromptString)
+  val prompt = {
+    import scala.io.AnsiColor.{ MAGENTA, RESET }
+    val p = promptString format Properties.versionNumberString
+    if (colorOk) s"$MAGENTA$p$RESET" else p
+  }
+
   /** CSV of paged,across to enable pagination or `-x` style
    *  columns, "across" instead of down the column.  Since
    *  pagination turns off columnar output, these flags are
diff --git a/test/files/jvm/interpreter.check b/test/files/jvm/interpreter.check
index d03edb638c..9e875235c7 100644
--- a/test/files/jvm/interpreter.check
+++ b/test/files/jvm/interpreter.check
@@ -32,7 +32,7 @@ scala> val four: anotherint = 4
 four: anotherint = 4
 
 scala> val bogus: anotherint = "hello"
-<console>:8: error: type mismatch;
+<console>:11: error: type mismatch;
  found   : String("hello")
  required: anotherint
     (which expands to)  Int
@@ -280,13 +280,13 @@ scala> // both of the following should abort immediately:
 
 scala> def x => y => z
 <console>:1: error: '=' expected but '=>' found.
-       def x => y => z
-             ^
+def x => y => z
+      ^
 
 scala> [1,2,3]
 <console>:1: error: illegal start of definition
-       [1,2,3]
-       ^
+[1,2,3]
+^
 
 scala> 
 
@@ -355,7 +355,7 @@ defined class Term
 scala> def f(e: Exp) = e match {  // non-exhaustive warning here
   case _:Fact => 3
 }
-<console>:18: warning: match may not be exhaustive.
+<console>:21: warning: match may not be exhaustive.
 It would fail on the following inputs: Exp(), Term()
        def f(e: Exp) = e match {  // non-exhaustive warning here
                        ^
@@ -365,6 +365,6 @@ scala> :quit
 plusOne: (x: Int)Int
 res0: Int = 6
 res0: String = after reset
-<console>:8: error: not found: value plusOne
-              plusOne(5) // should be undefined now
-              ^
+<console>:11: error: not found: value plusOne
+       plusOne(5) // should be undefined now
+       ^
diff --git a/test/files/run/constrained-types.check b/test/files/run/constrained-types.check
index 89a08d5ccb..6dbf8088c9 100644
--- a/test/files/run/constrained-types.check
+++ b/test/files/run/constrained-types.check
@@ -135,16 +135,16 @@ y: String = hello
 scala> 
 
 scala> val x = 3 : Int @Annot(e+f+g+h) // should have a graceful error message
-<console>:8: error: not found: value e
+<console>:11: error: not found: value e
        val x = 3 : Int @Annot(e+f+g+h) // should have a graceful error message
                               ^
-<console>:8: error: not found: value f
+<console>:11: error: not found: value f
        val x = 3 : Int @Annot(e+f+g+h) // should have a graceful error message
                                 ^
-<console>:8: error: not found: value g
+<console>:11: error: not found: value g
        val x = 3 : Int @Annot(e+f+g+h) // should have a graceful error message
                                   ^
-<console>:8: error: not found: value h
+<console>:11: error: not found: value h
        val x = 3 : Int @Annot(e+f+g+h) // should have a graceful error message
                                     ^
 
diff --git a/test/files/run/kind-repl-command.check b/test/files/run/kind-repl-command.check
index 586b2710e1..1853213555 100644
--- a/test/files/run/kind-repl-command.check
+++ b/test/files/run/kind-repl-command.check
@@ -21,8 +21,8 @@ scala> :k new { def empty = false }
 AnyRef{def empty: Boolean}'s kind is A
 
 scala> :k Nonexisting
-<console>:8: error: not found: value Nonexisting
-              Nonexisting
-              ^
+<console>:11: error: not found: value Nonexisting
+       Nonexisting
+       ^
 
 scala> :quit
diff --git a/test/files/run/reify-repl-fail-gracefully.check b/test/files/run/reify-repl-fail-gracefully.check
index c9e69744d6..eac4d25869 100644
--- a/test/files/run/reify-repl-fail-gracefully.check
+++ b/test/files/run/reify-repl-fail-gracefully.check
@@ -10,8 +10,8 @@ import scala.reflect.runtime.universe._
 scala> 
 
 scala> reify
-<console>:12: error: too few argument lists for macro invocation
-              reify
-              ^
+<console>:15: error: too few argument lists for macro invocation
+       reify
+       ^
 
 scala> :quit
diff --git a/test/files/run/reify_newimpl_22.check b/test/files/run/reify_newimpl_22.check
index 952f384a1c..24334df92c 100644
--- a/test/files/run/reify_newimpl_22.check
+++ b/test/files/run/reify_newimpl_22.check
@@ -17,9 +17,9 @@ scala> {
   }
   println(code.eval)
 }
-<console>:15: free term: Ident(TermName("x")) defined by res0  in <console>:14:21
-                val code = reify {
-                                 ^
+<console>:18: free term: Ident(TermName("x")) defined by res0  in <console>:17:14
+         val code = reify {
+                          ^
 2
 
 scala> :quit
diff --git a/test/files/run/reify_newimpl_23.check b/test/files/run/reify_newimpl_23.check
index b7e9bfdfbc..f8379958db 100644
--- a/test/files/run/reify_newimpl_23.check
+++ b/test/files/run/reify_newimpl_23.check
@@ -16,7 +16,7 @@ scala> def foo[T]{
   }
   println(code.eval)
 }
-<console>:13: free type: Ident(TypeName("T")) defined by foo in <console>:12:16
+<console>:16: free type: Ident(TypeName("T")) defined by foo in <console>:15:16
          val code = reify {
                           ^
 foo: [T]=> Unit
diff --git a/test/files/run/reify_newimpl_25.check b/test/files/run/reify_newimpl_25.check
index 4f36ba10ee..f9a5d7b578 100644
--- a/test/files/run/reify_newimpl_25.check
+++ b/test/files/run/reify_newimpl_25.check
@@ -7,9 +7,9 @@ scala> {
   val tt = implicitly[TypeTag[x.type]]
   println(tt)
 }
-<console>:11: free term: Ident(TermName("x")) defined by res0  in <console>:10:21
-                val tt = implicitly[TypeTag[x.type]]
-                                   ^
+<console>:14: free term: Ident(TermName("x")) defined by res0  in <console>:13:14
+         val tt = implicitly[TypeTag[x.type]]
+                            ^
 TypeTag[x.type]
 
 scala> :quit
diff --git a/test/files/run/reify_newimpl_26.check b/test/files/run/reify_newimpl_26.check
index 681b862795..bd77d3d707 100644
--- a/test/files/run/reify_newimpl_26.check
+++ b/test/files/run/reify_newimpl_26.check
@@ -6,7 +6,7 @@ scala> def foo[T]{
   val tt = implicitly[WeakTypeTag[List[T]]]
   println(tt)
 }
-<console>:9: free type: Ident(TypeName("T")) defined by foo in <console>:7:16
+<console>:12: free type: Ident(TypeName("T")) defined by foo in <console>:10:16
          val tt = implicitly[WeakTypeTag[List[T]]]
                             ^
 foo: [T]=> Unit
diff --git a/test/files/run/repl-bare-expr.check b/test/files/run/repl-bare-expr.check
index 07cf23412f..38ad7e818d 100644
--- a/test/files/run/repl-bare-expr.check
+++ b/test/files/run/repl-bare-expr.check
@@ -2,33 +2,33 @@ Type in expressions to have them evaluated.
 Type :help for more information.
 
 scala> 2 ; 3
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              2 ;;
-              ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       2 ;;
+       ^
 res0: Int = 3
 
 scala> { 2 ; 3 }
-<console>:8: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              { 2 ; 3 }
-                ^
+<console>:11: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       { 2 ; 3 }
+         ^
 res1: Int = 3
 
 scala> 5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
   1 +
   2 +
   3 } ; bippy+88+11
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
-              ^
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
-                  ^
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
-                                         ^
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
-                                                                                                ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
+       ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
+           ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
+                                  ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
+                                                                                         ^
 defined object Cow
 defined class Moo
 bippy: Int
diff --git a/test/files/run/repl-colon-type.check b/test/files/run/repl-colon-type.check
index 9898027c1d..fa33af3beb 100644
--- a/test/files/run/repl-colon-type.check
+++ b/test/files/run/repl-colon-type.check
@@ -3,8 +3,8 @@ Type :help for more information.
 
 scala> :type List[1, 2, 3]
 <console>:1: error: identifier expected but integer literal found.
-       List[1, 2, 3]
-            ^
+List[1, 2, 3]
+     ^
 
 scala> :type List(1, 2, 3)
 List[Int]
diff --git a/test/files/run/repl-parens.check b/test/files/run/repl-parens.check
index 74d15ff93c..756a063b68 100644
--- a/test/files/run/repl-parens.check
+++ b/test/files/run/repl-parens.check
@@ -20,12 +20,12 @@ scala>   (  (2 + 2 )  )
 res5: Int = 4
 
 scala> 5 ;   (  (2 + 2 )  ) ; ((5))
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              5 ;   (  (2 + 2 )  ) ;;
-              ^
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              5 ;   (  (2 + 2 )  ) ;;
-                          ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       5 ;   (  (2 + 2 )  ) ;;
+       ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       5 ;   (  (2 + 2 )  ) ;;
+                   ^
 res6: Int = 5
 
 scala> (((2 + 2)), ((2 + 2)))
@@ -40,18 +40,18 @@ res9: String = 4423
 scala> 
 
 scala> 55 ; ((2 + 2)) ; (1, 2, 3)
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              55 ; ((2 + 2)) ;;
-              ^
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              55 ; ((2 + 2)) ;;
-                       ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       55 ; ((2 + 2)) ;;
+       ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       55 ; ((2 + 2)) ;;
+                ^
 res10: (Int, Int, Int) = (1,2,3)
 
 scala> 55 ; (x: Int) => x + 1 ; () => ((5))
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              55 ; (x: Int) => x + 1 ;;
-              ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       55 ; (x: Int) => x + 1 ;;
+       ^
 res11: () => Int = <function0>
 
 scala> 
@@ -60,9 +60,9 @@ scala> () => 5
 res12: () => Int = <function0>
 
 scala> 55 ; () => 5
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              55 ;;
-              ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       55 ;;
+       ^
 res13: () => Int = <function0>
 
 scala> () => { class X ; new X }
diff --git a/test/files/run/repl-paste-2.check b/test/files/run/repl-paste-2.check
index 6ea8e2f419..bc80615107 100644
--- a/test/files/run/repl-paste-2.check
+++ b/test/files/run/repl-paste-2.check
@@ -44,7 +44,7 @@ scala> res5 + res6
 res1: Int = 690
 
 scala> val x = dingus
-<console>:7: error: not found: value dingus
+<console>:10: error: not found: value dingus
        val x = dingus
                ^
 
diff --git a/test/files/run/repl-reset.check b/test/files/run/repl-reset.check
index cd7893bbc3..a2d88fd445 100644
--- a/test/files/run/repl-reset.check
+++ b/test/files/run/repl-reset.check
@@ -30,23 +30,23 @@ Forgetting all expression results and named terms: $intp, BippyBungus, x1, x2, x
 Forgetting defined types: BippyBungus
 
 scala> x1 + x2 + x3
-<console>:8: error: not found: value x1
-              x1 + x2 + x3
-              ^
-<console>:8: error: not found: value x2
-              x1 + x2 + x3
-                   ^
-<console>:8: error: not found: value x3
-              x1 + x2 + x3
-                        ^
+<console>:11: error: not found: value x1
+       x1 + x2 + x3
+       ^
+<console>:11: error: not found: value x2
+       x1 + x2 + x3
+            ^
+<console>:11: error: not found: value x3
+       x1 + x2 + x3
+                 ^
 
 scala> val x1 = 4
 x1: Int = 4
 
 scala> new BippyBungus
-<console>:8: error: not found: type BippyBungus
-              new BippyBungus
-                  ^
+<console>:11: error: not found: type BippyBungus
+       new BippyBungus
+           ^
 
 scala> class BippyBungus() { def f = 5 }
 defined class BippyBungus
diff --git a/test/files/run/repl-trim-stack-trace.scala b/test/files/run/repl-trim-stack-trace.scala
index a53ce3b3e4..b8c1668691 100644
--- a/test/files/run/repl-trim-stack-trace.scala
+++ b/test/files/run/repl-trim-stack-trace.scala
@@ -13,7 +13,7 @@ f: Nothing
 
 scala> f
 java.lang.Exception: Uh-oh
-  at .f(<console>:7)
+  at .f(<console>:10)
   ... 69 elided
 
 scala> def f = throw new Exception("")
@@ -21,7 +21,7 @@ f: Nothing
 
 scala> f
 java.lang.Exception:
-  at .f(<console>:7)
+  at .f(<console>:10)
   ... 69 elided
 
 scala> def f = throw new Exception
@@ -29,7 +29,7 @@ f: Nothing
 
 scala> f
 java.lang.Exception
-  at .f(<console>:7)
+  at .f(<console>:10)
   ... 69 elided
 
 scala> :quit"""
diff --git a/test/files/run/t4542.check b/test/files/run/t4542.check
index f7716dc2f0..f7aad3deb2 100644
--- a/test/files/run/t4542.check
+++ b/test/files/run/t4542.check
@@ -7,7 +7,7 @@ scala> @deprecated("foooo", "ReplTest version 1.0-FINAL") class Foo() {
 defined class Foo
 
 scala> val f = new Foo
-<console>:8: warning: class Foo is deprecated: foooo
+<console>:11: warning: class Foo is deprecated: foooo
        val f = new Foo
                    ^
 f: Foo = Bippy
diff --git a/test/files/run/t4594-repl-settings.scala b/test/files/run/t4594-repl-settings.scala
index db5dc19866..1b883983cf 100644
--- a/test/files/run/t4594-repl-settings.scala
+++ b/test/files/run/t4594-repl-settings.scala
@@ -17,7 +17,7 @@ object Test extends SessionTest {
     |scala> :settings -deprecation
     |
     |scala> def b = depp
-    |<console>:8: warning: method depp is deprecated: Please don't do that.
+    |<console>:11: warning: method depp is deprecated: Please don't do that.
     |       def b = depp
     |               ^
     |b: String
diff --git a/test/files/run/t5655.check b/test/files/run/t5655.check
index 4bbc54b641..e8375c3e90 100644
--- a/test/files/run/t5655.check
+++ b/test/files/run/t5655.check
@@ -8,19 +8,19 @@ scala> import x._
 import x._
 
 scala> x
-<console>:12: error: reference to x is ambiguous;
+<console>:15: error: reference to x is ambiguous;
 it is imported twice in the same scope by
 import x._
 and import x
-              x
-              ^
+       x
+       ^
 
 scala> x
-<console>:12: error: reference to x is ambiguous;
+<console>:15: error: reference to x is ambiguous;
 it is imported twice in the same scope by
 import x._
 and import x
-              x
-              ^
+       x
+       ^
 
 scala> :quit
diff --git a/test/files/run/t7319.check b/test/files/run/t7319.check
index e35cfc90c0..885136b432 100644
--- a/test/files/run/t7319.check
+++ b/test/files/run/t7319.check
@@ -17,25 +17,25 @@ warning: there was one feature warning; re-run with -feature for details
 convert: [F[X <: F[X]]](builder: F[_ <: F[_]])Int
 
 scala> convert(Some[Int](0))
-<console>:12: error: no type parameters for method convert: (builder: F[_ <: F[_]])Int exist so that it can be applied to arguments (Some[Int])
+<console>:15: error: no type parameters for method convert: (builder: F[_ <: F[_]])Int exist so that it can be applied to arguments (Some[Int])
  --- because ---
 argument expression's type is not compatible with formal parameter type;
  found   : Some[Int]
  required: ?F[_$1] forSome { type _$1 <: ?F[_$2] forSome { type _$2 } }
-              convert(Some[Int](0))
-              ^
-<console>:12: error: type mismatch;
+       convert(Some[Int](0))
+       ^
+<console>:15: error: type mismatch;
  found   : Some[Int]
  required: F[_ <: F[_]]
-              convert(Some[Int](0))
-                               ^
+       convert(Some[Int](0))
+                        ^
 
 scala> Range(1,2).toArray: Seq[_]
-<console>:11: error: polymorphic expression cannot be instantiated to expected type;
+<console>:14: error: polymorphic expression cannot be instantiated to expected type;
  found   : [B >: Int]Array[B]
  required: Seq[_]
-              Range(1,2).toArray: Seq[_]
-                         ^
+       Range(1,2).toArray: Seq[_]
+                  ^
 
 scala> 0
 res2: Int = 0
diff --git a/test/files/run/t7747-repl.check b/test/files/run/t7747-repl.check
index 5f436ba6b1..98e3d3b821 100644
--- a/test/files/run/t7747-repl.check
+++ b/test/files/run/t7747-repl.check
@@ -17,33 +17,33 @@ scala> val z = x * y
 z: Int = 156
 
 scala> 2 ; 3
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              2 ;;
-              ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       2 ;;
+       ^
 res0: Int = 3
 
 scala> { 2 ; 3 }
-<console>:8: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              { 2 ; 3 }
-                ^
+<console>:11: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       { 2 ; 3 }
+         ^
 res1: Int = 3
 
 scala> 5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
   1 +
   2 +
   3 } ; bippy+88+11
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
-              ^
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
-                  ^
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
-                                         ^
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
-                                                                                                ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
+       ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
+           ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
+                                  ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       5 ; 10 ; case object Cow ; 20 ; class Moo { override def toString = "Moooooo" } ; 30 ; def bippy = {
+                                                                                         ^
 defined object Cow
 defined class Moo
 bippy: Int
@@ -83,12 +83,12 @@ scala>   (  (2 + 2 )  )
 res10: Int = 4
 
 scala> 5 ;   (  (2 + 2 )  ) ; ((5))
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              5 ;   (  (2 + 2 )  ) ;;
-              ^
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              5 ;   (  (2 + 2 )  ) ;;
-                          ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       5 ;   (  (2 + 2 )  ) ;;
+       ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       5 ;   (  (2 + 2 )  ) ;;
+                   ^
 res11: Int = 5
 
 scala> (((2 + 2)), ((2 + 2)))
@@ -103,18 +103,18 @@ res14: String = 4423
 scala> 
 
 scala> 55 ; ((2 + 2)) ; (1, 2, 3)
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              55 ; ((2 + 2)) ;;
-              ^
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              55 ; ((2 + 2)) ;;
-                       ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       55 ; ((2 + 2)) ;;
+       ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       55 ; ((2 + 2)) ;;
+                ^
 res15: (Int, Int, Int) = (1,2,3)
 
 scala> 55 ; (x: Int) => x + 1 ; () => ((5))
-<console>:9: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              55 ; (x: Int) => x + 1 ;;
-              ^
+<console>:12: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       55 ; (x: Int) => x + 1 ;;
+       ^
 res16: () => Int = <function0>
 
 scala> 
@@ -123,9 +123,9 @@ scala> () => 5
 res17: () => Int = <function0>
 
 scala> 55 ; () => 5
-<console>:7: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-              55 ;;
-              ^
+<console>:10: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+       55 ;;
+       ^
 res18: () => Int = <function0>
 
 scala> () => { class X ; new X }
@@ -211,23 +211,23 @@ Forgetting all expression results and named terms: $intp, BippyBungus, Bovine, C
 Forgetting defined types: BippyBungus, Moo, Ruminant
 
 scala> x1 + x2 + x3
-<console>:8: error: not found: value x1
-              x1 + x2 + x3
-              ^
-<console>:8: error: not found: value x2
-              x1 + x2 + x3
-                   ^
-<console>:8: error: not found: value x3
-              x1 + x2 + x3
-                        ^
+<console>:11: error: not found: value x1
+       x1 + x2 + x3
+       ^
+<console>:11: error: not found: value x2
+       x1 + x2 + x3
+            ^
+<console>:11: error: not found: value x3
+       x1 + x2 + x3
+                 ^
 
 scala> val x1 = 4
 x1: Int = 4
 
 scala> new BippyBungus
-<console>:8: error: not found: type BippyBungus
-              new BippyBungus
-                  ^
+<console>:11: error: not found: type BippyBungus
+       new BippyBungus
+           ^
 
 scala> class BippyBungus() { def f = 5 }
 defined class BippyBungus
diff --git a/test/files/run/t9170.scala b/test/files/run/t9170.scala
index 25a0e84581..67a58d6803 100644
--- a/test/files/run/t9170.scala
+++ b/test/files/run/t9170.scala
@@ -10,17 +10,17 @@ object Test extends SessionTest {
 Type :help for more information.
 
 scala> object Y { def f[A](a: => A) = 1 ; def f[A](a: => Either[Exception, A]) = 2 }
-<console>:7: error: double definition:
-def f[A](a: => A): Int at line 7 and
-def f[A](a: => Either[Exception,A]): Int at line 7
+<console>:10: error: double definition:
+def f[A](a: => A): Int at line 10 and
+def f[A](a: => Either[Exception,A]): Int at line 10
 have same type after erasure: (a: Function0)Int
        object Y { def f[A](a: => A) = 1 ; def f[A](a: => Either[Exception, A]) = 2 }
                                               ^
 
 scala> object Y { def f[A](a: => A) = 1 ; def f[A](a: => Either[Exception, A]) = 2 }
-<console>:7: error: double definition:
-def f[A](a: => A): Int at line 7 and
-def f[A](a: => Either[Exception,A]): Int at line 7
+<console>:10: error: double definition:
+def f[A](a: => A): Int at line 10 and
+def f[A](a: => Either[Exception,A]): Int at line 10
 have same type after erasure: (a: Function0)Int
        object Y { def f[A](a: => A) = 1 ; def f[A](a: => Either[Exception, A]) = 2 }
                                               ^
@@ -29,9 +29,9 @@ scala> object Y {
      |   def f[A](a: =>  A) = 1
      |   def f[A](a: => Either[Exception, A]) = 2
      | }
-<console>:9: error: double definition:
-def f[A](a: => A): Int at line 8 and
-def f[A](a: => Either[Exception,A]): Int at line 9
+<console>:12: error: double definition:
+def f[A](a: => A): Int at line 11 and
+def f[A](a: => Either[Exception,A]): Int at line 12
 have same type after erasure: (a: Function0)Int
          def f[A](a: => Either[Exception, A]) = 2
              ^
@@ -46,9 +46,9 @@ object Y {
 
 // Exiting paste mode, now interpreting.
 
-<console>:9: error: double definition:
-def f[A](a: => A): Int at line 8 and
-def f[A](a: => Either[Exception,A]): Int at line 9
+<console>:12: error: double definition:
+def f[A](a: => A): Int at line 11 and
+def f[A](a: => Either[Exception,A]): Int at line 12
 have same type after erasure: (a: Function0)Int
          def f[A](a: => Either[Exception, A]) = 2
              ^
diff --git a/test/files/run/t9206.scala b/test/files/run/t9206.scala
new file mode 100644
index 0000000000..2942d0f73e
--- /dev/null
+++ b/test/files/run/t9206.scala
@@ -0,0 +1,39 @@
+
+import scala.tools.partest.SessionTest
+
+object Test extends SessionTest {
+  //override def prompt = "XXX> "
+//Welcome to Scala version 2.11.6 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_40).
+  def session =
+    s"""|Type in expressions to have them evaluated.
+        |Type :help for more information.
+        |
+        |scala> val i: Int = "foo"
+        |<console>:10: error: type mismatch;
+        | found   : String("foo")
+        | required: Int
+        |       val i: Int = "foo"
+        |                    ^
+        |
+        |scala> { val j = 42 ; val i: Int = "foo" + j }
+        |<console>:11: error: type mismatch;
+        | found   : String
+        | required: Int
+        |       { val j = 42 ; val i: Int = "foo" + j }
+        |                                         ^
+        |
+        |scala> :quit"""
+        /*
+        |XXX> XXX> def f = 42
+        |
+        |// Detected repl transcript paste: ctrl-D to finish.
+        |
+        |// Replaying 1 commands from transcript.
+        |
+        |XXX> def f = 42
+        |f: Int
+        |
+        |XXX> :quit"""
+        */
+
+}
diff --git a/test/files/run/xMigration.check b/test/files/run/xMigration.check
index 378f7bb6c3..304132a848 100644
--- a/test/files/run/xMigration.check
+++ b/test/files/run/xMigration.check
@@ -12,10 +12,10 @@ res1: Iterable[String] = MapLike(eis)
 scala> :setting -Xmigration:any
 
 scala> Map(1 -> "eis").values    // warn
-<console>:8: warning: method values in trait MapLike has changed semantics in version 2.8.0:
+<console>:11: warning: method values in trait MapLike has changed semantics in version 2.8.0:
 `values` returns `Iterable[B]` rather than `Iterator[B]`.
-              Map(1 -> "eis").values    // warn
-                              ^
+       Map(1 -> "eis").values    // warn
+                       ^
 res2: Iterable[String] = MapLike(eis)
 
 scala> :setting -Xmigration:2.8
@@ -26,10 +26,10 @@ res3: Iterable[String] = MapLike(eis)
 scala> :setting -Xmigration:2.7
 
 scala> Map(1 -> "eis").values    // warn
-<console>:8: warning: method values in trait MapLike has changed semantics in version 2.8.0:
+<console>:11: warning: method values in trait MapLike has changed semantics in version 2.8.0:
 `values` returns `Iterable[B]` rather than `Iterator[B]`.
-              Map(1 -> "eis").values    // warn
-                              ^
+       Map(1 -> "eis").values    // warn
+                       ^
 res4: Iterable[String] = MapLike(eis)
 
 scala> :setting -Xmigration:2.11
@@ -40,10 +40,10 @@ res5: Iterable[String] = MapLike(eis)
 scala> :setting -Xmigration      // same as :any
 
 scala> Map(1 -> "eis").values    // warn
-<console>:8: warning: method values in trait MapLike has changed semantics in version 2.8.0:
+<console>:11: warning: method values in trait MapLike has changed semantics in version 2.8.0:
 `values` returns `Iterable[B]` rather than `Iterator[B]`.
-              Map(1 -> "eis").values    // warn
-                              ^
+       Map(1 -> "eis").values    // warn
+                       ^
 res6: Iterable[String] = MapLike(eis)
 
 scala> :quit