Add Eval step in debug check file

Author: adpi2

compiler/test/dotty/tools/debug/DebugStepAssert.scala

@@ -19,14 +19,45 @@ private[debug] object DebugStepAssert:
     val break = s"break ($sym) ($line)$trailing".r
     val step = s"step ($sym|$line)$trailing".r
     val next = s"next ($sym|$line)$trailing".r
-    readLines(checkFile).flatMap:
-      case break(className , lineStr) =>
-        val line = lineStr.toInt
-        Some(DebugStepAssert(Break(className, line), checkClassAndLine(className, line)))
-      case step(pattern) => Some(DebugStepAssert(Step, checkLineOrMethod(pattern)))
-      case next(pattern) => Some(DebugStepAssert(Next, checkLineOrMethod(pattern)))
-      case trailing() => None
-      case invalid => throw new Exception(s"Cannot parse debug step: $invalid")
+    val multiLineEval = s"eval$trailing".r
+    val eval = s"eval (.*)".r
+    val result = "result (.*)".r
+    val error = "error (.*)".r
+
+    def loop(lines: List[String], acc: List[DebugStepAssert[?]]): List[DebugStepAssert[?]] =
+      lines match
+        case Nil => acc.reverse
+        case break(className , lineStr) :: tail =>
+          val line = lineStr.toInt
+          val step = DebugStepAssert(Break(className, line), checkClassAndLine(className, line))
+          loop(tail, step :: acc)
+        case step(pattern) :: tail =>
+          val step = DebugStepAssert(Step, checkLineOrMethod(pattern))
+          loop(tail, step :: acc)
+        case next(pattern) :: tail =>
+          val step = DebugStepAssert(Next, checkLineOrMethod(pattern))
+          loop(tail, step :: acc)
+        case eval(expr) :: resOrError :: tail =>
+          val expected = parseResultOrError(resOrError)
+          val step = DebugStepAssert(Eval(expr), checkEval(expected))
+          loop(tail, step :: acc)
+        case multiLineEval() :: tail0 =>
+          val (exprLines, tail1) = tail0.span(_.startsWith("  "))
+          val expr = exprLines.map(s => s.stripPrefix("  ")).mkString("\n")
+          val expected = parseResultOrError(tail1.head)
+          val step = DebugStepAssert(Eval(expr), checkEval(expected))
+          loop(tail1.tail, step :: acc)
+        case trailing() :: tail => loop(tail, acc)
+        case invalid :: tail => throw new Exception(s"Cannot parse debug step: $invalid")
+
+    def parseResultOrError(line: String): Either[String, String] =
+      line match
+        case result(expected) => Right(expected)
+        case error(expected) => Left(expected)
+        case invalid => throw new Exception(s"Cannot parse as result or error: $invalid")
+
+    loop(readLines(checkFile), Nil)
+  end parseCheckFile
 
   private def checkClassAndLine(className: String, line: Int)(location: Location): Unit =
     assert(className == location.declaringType.name, s"obtained ${location.declaringType.name}, expected ${className}")
@@ -39,12 +70,21 @@ private[debug] object DebugStepAssert:
     assert(location.lineNumber == line, s"obtained ${location.lineNumber}, expected $line")
 
   private def checkMethod(methodName: String)(location: Location): Unit = assert(methodName == location.method.name)
+
+  private def checkEval(expected: Either[String, String])(obtained: Either[String, String]): Unit =
+    (expected, obtained) match
+      case (Left(expected), Left(obtained)) => assert(expected.r.matches(obtained), s"obtained $obtained, expected $expected")
+      case (Right(expected), Right(obtained)) => assert(expected.r.matches(obtained.toString), s"obtained $obtained, expected $expected")
+      case (Left(_), Right(_)) => throw new AssertionError("evaluation succeeded but error expected")
+      case (Right(_), Left(_)) => throw new AssertionError("evaluation failed")
+
 end DebugStepAssert
 
 private[debug] enum DebugStep[T]:
   case Break(className: String, line: Int) extends DebugStep[Location]
   case Step extends DebugStep[Location]
   case Next extends DebugStep[Location]
+  case Eval(expression: String) extends DebugStep[Either[String, String]]
 
 
 

compiler/test/dotty/tools/debug/DebugTests.scala

@@ -13,7 +13,7 @@ class DebugTests:
   import DebugTests.*
   @Test def debug: Unit =
     implicit val testGroup: TestGroup = TestGroup("debug")
-    // compileFile("tests/debug/tailrec.scala", TestConfiguration.defaultOptions).checkDebug()
+    // compileFile("tests/debug/for.scala", TestConfiguration.defaultOptions).checkDebug()
     compileFilesInDir("tests/debug", TestConfiguration.defaultOptions).checkDebug()
 
 object DebugTests extends ParallelTesting:
@@ -100,5 +100,9 @@ object DebugTests extends ParallelTesting:
             thread = debugger.step(thread)
             if verbose then println(s"step ${location.lineNumber}")
             assert(location)
+          case DebugStepAssert(Eval(expr), assert) =>
+            val result = debugger.evaluate(expr, thread)
+            if verbose then println(s"eval $expr $result")
+            assert(result)
     end playDebugSteps
   end DebugTest

tests/debug/for.check

@@ -1,3 +1,9 @@
 break Test$ 3
 step 4
+eval b
+result 72
+eval
+  val c = b + 1
+  c + 1
+result 74
 step 10