Remove old Gen script for running debug tests

Author: adpi2

.gitignore

@@ -62,7 +62,6 @@ testlogs/
 
 # Put local stuff here
 local/
-compiler/test/debug/Gen.jar
 
 /bin/.cp
 

compiler/test/debug/Gen

@@ -26,71 +26,6 @@ $ jdb -attach 5005 -sourcepath tests/debug/
 
 You can run `help` for commands that supported by JDB.
 
-## Debug Automatically with Expect
-
-### 1. Annotate the source code with debug information.
-
-Following file (`tests/debug/while.scala`) is an example of annotated source code:
-
-```scala
-object Test {
-
-  def main(args: Array[String]): Unit = {
-    var a = 1 + 2
-    a = a + 3
-    a = 4 + 5 // [break] [step: while]
-
-    while (a * 8 < 100) { // [step: a += 1]
-      a += 1              // [step: while] [cont: print]
-    }
-
-    print(a) // [break] [cont]
-  }
-}
-```
-
-The debugging information is annotated as comments to the code in brackets:
-
-```scala
-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 that JDB uses line number starts from 1.
-
-### 2. Generate Expect File
-
-Now we can run the following command to generate an expect file:
-
-```shell
-compiler/test/debug/Gen tests/debug/while.scala > robot
-```
-
-### 3. Run the Test
-
-First, compile the file `tests/debug/while.scala`:
-
-```shell
-$ scalac tests/debug/while.scala
-```
-
-Second, run the compiled class with debugging enabled:
-
-```shell
-$ scala -d Test
-```
-
-Finally, run the expect script:
-
-```shell
-expect robot
-```
 ## Other tips
 ### Show for human readable output
 

compiler/test/debug/Gen.scala

@@ -1,16 +1,16 @@
 object Test {
   def main(args: Array[String]): Unit = {
-     val b = 8 * 9  // [break] [step: f()]
-     f()            // [step: val a]
+     val b = 8 * 9
+     f()
      20 + b
      println(b)
   }
 
   def f(): Unit = {
-    val a = for (i <- 1 to 5; j <- 10 to 20)        // [cont]
-              yield (i, j)      // Error: incorrect reaching this line
+    val a = for (i <- 1 to 5; j <- 10 to 20)
+              yield (i, j)
 
     for (i <- 1 to 5; j <- 10 to 20)
-      println(i + j)           // TODO: i is renamed to i$2 --> reduce debuggability
+      println(i + j)
   }
 }

compiler/test/debug/test

@@ -1,14 +1,14 @@
 object Test {
   def main(args: Array[String]): Unit = {
     val a = 1 + 2
-    val b = a * 9        // [break] [step: plus] [step: c = plus]
-    val plus = (x: Int, y: Int) => {    // [cont: x * x]
-      val a = x * x                     // [break] [step: y * y]
-      val b = y * y                     // [step: a + b]
-      a + b                             // [next] [next]
+    val b = a * 9
+    val plus = (x: Int, y: Int) => {
+      val a = x * x
+      val b = y * y
+      a + b
     }
-    val c = plus(a, b)   // [next: print]
-    println(c)             // [cont]
+    val c = plus(a, b)
+    println(c)
   }
 
 }

docs/_docs/contributing/debugging/other-debugging.md

@@ -1,19 +1,19 @@
 object Test {
 
   def main(args: Array[String]): Unit = {
-    var a = 1 + 2 // [break] [step: a + 3]
-    a = a + 3     // [step: 4 + 5]
-    a = 4 + 5     // [step: if]
+    var a = 1 + 2
+    a = a + 3
+    a = 4 + 5
 
-    if (a * 8 > 20)  // [step: 9 * 9]
-      a = 9 * 9      // [step: if]
+    if (a * 8 > 20)
+      a = 9 * 9
     else
       a = 34 * 23
 
-    if (a * 8 < 20)  // [step: 34 * 23]
+    if (a * 8 < 20)
       a = 9 * 9
     else
-      a = 34 * 23    // [step: print]
+      a = 34 * 23
 
     println(a)
   }

tests/debug/for.scala

@@ -1,14 +1,14 @@
 object Test {
   def main(args: Array[String]): Unit = {
-    val a = 1 + 2        // [break] [step: a * 9]
-    val b = a * 9        // [step: plus]
-    val c = plus(a, b)   // [step: x * x]
+    val a = 1 + 2
+    val b = a * 9
+    val c = plus(a, b)
     println(c)
   }
 
   def plus(x: Int, y: Int) = {
-    val a = x * x               // [step: y * y]
-    val b = y * y               // [step: a + b]
-    a + b                       // [step: plus] [step: print] [cont]
+    val a = x * x
+    val b = y * y
+    a + b
   }
 }