Merge pull request #1951 from dotty-staging/fix-1484

fix #1484: position of while incorrect in debug

4 files changed, 207 insertions, 2 deletions

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index eda4a12dc..e3102fda2 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -991,12 +991,12 @@ object desugar {
         else Apply(ref(tupleTypeRef.classSymbol.companionModule.valRef), ts)
       case WhileDo(cond, body) =>
         // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() }
-        val call = Apply(Ident(nme.WHILE_PREFIX), Nil)
+        val call = Apply(Ident(nme.WHILE_PREFIX), Nil).withPos(tree.pos)
         val rhs = If(cond, Block(body, call), unitLiteral)
         labelDefAndCall(nme.WHILE_PREFIX, rhs, call)
       case DoWhile(body, cond) =>
         // { label def doWhile$(): Unit = { body; if (cond) doWhile$() } ; doWhile$() }
-        val call = Apply(Ident(nme.DO_WHILE_PREFIX), Nil)
+        val call = Apply(Ident(nme.DO_WHILE_PREFIX), Nil).withPos(tree.pos)
         val rhs = Block(body, If(cond, call, unitLiteral))
         labelDefAndCall(nme.DO_WHILE_PREFIX, rhs, call)
       case ForDo(enums, body) =>
diff --git a/compiler/test/debug/Gen b/compiler/test/debug/Gen
new file mode 100755
index 000000000..c5c4d6ec6
--- /dev/null
+++ b/compiler/test/debug/Gen
@@ -0,0 +1,13 @@
+#! /usr/bin/env bash
+
+DIR="$( cd "$( dirname "$0" )" && pwd )"
+
+SOURCE=$DIR/Gen.scala
+CLASS=./Gen.class
+
+if [ ! -e $CLASS ] || [ $SOURCE -nt $CLASS ]; then
+  ./bin/dotc $DIR/Gen.scala
+fi
+
+./bin/dotr Gen $@
+
diff --git a/compiler/test/debug/Gen.scala b/compiler/test/debug/Gen.scala
new file mode 100755
index 000000000..f7a5cc432
--- /dev/null
+++ b/compiler/test/debug/Gen.scala
@@ -0,0 +1,171 @@
+import scala.io.Source
+import scala.collection.mutable.ListBuffer
+
+/** Automate testing debuggability of generated code using JDB and expect
+ *
+ *  The debugging information is annotated as comments to the code in brackets:
+ *
+ *  val x = f(3) // [break] [next: line=5]
+ *  val y = 5
+ *
+ *  1. A jdb command must be wrapped in brackets, like `[step]`. All jdb commands can be used.
+ *  2. To check output of jdb for a command, use `[cmd: expect]`.
+ *  3. If `expect` is wrapped in double quotes, regex is supported.
+ *  4. Break commands are collected and set globally.
+ *  5. Other commands will be send to jdb in the order they appear in the source file
+ *
+ *  Note: jdb uses line number starts from 1
+ */
+
+object Gen {
+  val MainObject = "Test"
+  val CommandWait = 0.5
+
+  sealed trait Tree
+
+  case class Break(line: Int) extends Tree
+
+  case class Command(val name: String, val expect: Expect = EmptyExpect) extends Tree
+
+  sealed trait Expect
+
+  case object EmptyExpect extends Expect
+
+  case class LitExpect(lit: String) extends Expect
+
+  case class PatExpect(pat: String) extends Expect
+
+  case class Program(breaks: Seq[Break], commands: Seq[Command])
+
+  def error(msg: String): Nothing = {
+    throw new Exception(msg)
+  }
+
+  def parseCommand(command: String, lineNo: Int): Tree = {
+    val index = command.indexOf(':')
+    if (index == -1) {
+      // simple command
+      if (command == "break") Break(lineNo)
+      else Command(command)
+    } else {
+      val Seq(cmd, rhs) = command.split(":", 2).toSeq.map(_.trim)
+      if (rhs.startsWith("\"")) {
+        // regex match
+        val content = "\"(.+)\"".r
+        rhs match {
+          case content(expect) => Command(cmd, PatExpect(expect))
+          case _ => error(s"""incorrect specification: `$rhs` for `$cmd` at line $lineNo. Ending " expected.""")
+        }
+      } else {
+        // literal match
+        Command(cmd, LitExpect(rhs))
+      }
+    }
+  }
+
+  def parse(file: String): Program = {
+    val lines = Source.fromFile(file).getLines.toBuffer
+
+    val breaks = new ListBuffer[Break]()
+    val cmds = new ListBuffer[Command]()
+    lines.zipWithIndex.map { case (code, line) =>
+      val comment = if (code.indexOf("//") != -1) code.split("//").last else ""
+      val regex = """(?<=\[).*?(?=\])""".r
+      for (p <- regex findAllIn comment) parseCommand(p.trim, line + 1) match { // jdb index from 0
+        case b: Break   => breaks += b
+        case c: Command => cmds += c
+      }
+    }
+
+    Program(breaks, cmds)
+  }
+
+  def generate(program: Program, source: String = "tests/debug/"): String = {
+    val Program(breaks, cmds) = program
+    val breakpoints = (breaks.map {
+      case Break(point) =>
+          s"""|send "stop at $MainObject$$:$point\\r"
+              |sleep $CommandWait
+              |expect "breakpoint $MainObject$$:$point"
+              |expect -re $$
+              """.stripMargin
+    }).mkString("\n\n")
+
+    val commands = (cmds.map {
+    case Command(cmd, EmptyExpect)      =>
+        s"""|# send_user "send command `$cmd`\\n"
+            |send "$cmd\\r"
+            |sleep $CommandWait
+            |expect -re $$
+            """.stripMargin
+    case Command(cmd, LitExpect(lit))   =>
+        s"""|# send_user "send command `$cmd`\\n"
+            |send "$cmd\\r"
+            |sleep $CommandWait
+            |expect {
+            |   "*$lit*" { send_user "success - $cmd : $lit \\n" }
+            |   timeout {
+            |       send_user "timeout while waiting for response: $cmd : $lit\\n"
+            |       exit 1
+            |    }
+            |}
+            |expect -re $$
+            |""".stripMargin
+    case Command(cmd, PatExpect(pat))   =>
+        s"""|# send_user "send command `$cmd`\\n"
+            |send "$cmd\\r"
+            |sleep $CommandWait
+            |expect {
+            |   -re {$pat} { send_user "success - $cmd : $pat \\n" }
+            |   timeout {
+            |       send_user "timeout while waiting for response: $cmd : $pat\\n"
+            |       exit 1
+            |    }
+            |}
+            |expect -re $$
+            |""".stripMargin
+    }).mkString("\n\n")
+
+s"""|#!/usr/bin/expect
+    |
+    |# log_user 1
+    |# exp_internal 1
+    |# set timeout 5
+    |
+    |send_user "spawning job...\\n"
+    |
+    |spawn jdb -attach 5005 -sourcepath $source
+    |
+    |send_user "interacting...\\n"
+    |
+    |expect {
+    |  "*VM Started*" { send_user "success - connected to server \\n" }
+    |  timeout {
+    |      send_user "timeout while waiting for: *VM Started*\\n"
+    |      exit 1
+    |  }
+    |}
+    |
+    |send_user "setting breakpoints...\\n"
+    |
+    |# breakpoints
+    |$breakpoints
+    |
+    |# run
+    |send_user "run program...\\n"
+    |send "run\\r"
+    |expect "Breakpoint hit"
+    |
+    |# interactions
+    |$commands""".stripMargin
+  }
+
+  def main(args: Array[String]): Unit = {
+    val prog = Gen.parse(args(0))
+    // println("--------------------------------")
+    // println("prog:" + prog)
+    // println("\n\n\n scrip:")
+    // println("--------------------------------")
+    println(Gen.generate(prog))
+  }
+}
diff --git a/compiler/test/debug/test b/compiler/test/debug/test
new file mode 100755
index 000000000..603e3c153
--- /dev/null
+++ b/compiler/test/debug/test
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+DIR="$( cd "$( dirname "$0" )" && pwd )"
+
+echo "start debug test..."
+for file in tests/debug/*.scala; do
+   ./bin/dotc $file || exit 1
+   ./bin/dotr -d Test > /dev/null &
+   $DIR/Gen $file > robot
+   expect robot 2>&1 > /dev/null
+
+   if [[ $? != 0 ]]; then
+      echo "debug test failed for file $file"
+      exit 1
+   fi
+
+   echo "$file -- success"
+done
+
+echo "debug test success!"
+