Try to fix step over and step out. Add yarn script for moving debuggers out

Author: shanedell

build/yarn-scripts.ts

@@ -22,6 +22,12 @@ const fs = require('fs')
 const { glob } = require('glob')
 const concurrently = require('concurrently')
 const child_process = require('child_process')
+const jsoncParse = require('jsonc-parser').parse
+
+const packageData = jsoncParse(
+  fs.readFileSync(path.resolve('package.json'), 'utf8')
+)
+const pkg_version = packageData['version']
 
 function rmFileOrDirectory(path) {
   if (fs.existsSync(path)) fs.rmSync(path, { recursive: true })
@@ -102,6 +108,37 @@ function package() {
   )
 }
 
+function getScalaVersions() {
+  const scalaVersions = ['2.12', '2.13']
+
+  // The scala 3 version of the debugger should only exist if JDK >= 17 is being used
+  if (fs.existsSync(`debugger/target/jvm-3/universal/stage`)) {
+    scalaVersions.push('3')
+  }
+
+  return scalaVersions
+}
+
+function moveDebuggers() {
+  getScalaVersions().forEach(async (scalaVersion) => {
+    const serverPackage = `daffodil-debugger-${scalaVersion}-${pkg_version}`
+    const jvmFolderName = `jvm-${scalaVersion}`
+    const stageFilePath = path.resolve(
+      `debugger/target/${jvmFolderName}/universal/stage`
+    )
+
+    const serverPackageFolder = path.join('dist/debuggers', serverPackage)
+
+    // remove debugger package folder if exists
+    if (fs.existsSync(serverPackageFolder)) {
+      fs.rmSync(serverPackageFolder, { recursive: true, force: true })
+    }
+
+    // Copy staged debugger files to desired location
+    fs.cpSync(stageFilePath, serverPackageFolder, { recursive: true })
+  })
+}
+
 /* START SECTION: Update version */
 // helper function to get the version passed in
 function parseArgs() {
@@ -259,4 +296,5 @@ module.exports = {
   package: package,
   checkMissingLicenseData: checkMissingLicenseData,
   checkLicenseCompatibility: checkLicenseCompatibility,
+  moveDebuggers: moveDebuggers,
 }

debugger/src/main/scala/org.apache.daffodil.debugger.dap/Parse.scala

@@ -1310,40 +1310,41 @@ object Parse {
                   .complete(()) *> nextContinue.get.as(true)
               case Running                                      => Running -> IO.pure(false)
               case s @ Stopped(whenContinued, nextAwaitStarted) =>
-                s -> nextAwaitStarted.complete(()) *>
-                  // Decide whether to block or let parser continue
-                  stopTarget.get.flatMap {
-                    case None                      => whenContinued.get.as(true)
-                    case Some((targetDepth, mode)) =>
-                      for {
-                        cur <- currentDepth.get
-                        kind <- awaitingKind.get
-                        res <- mode match {
-                          // Allow running while deeper than target.
-                          // When at or above target and we're at an end-element, block once then clear target
-                          case "stepOut" =>
-                            if (cur > targetDepth) IO.pure(false)
-                            else if (kind == "end") whenContinued.get.flatMap(_ => stopTarget.set(None).as(true))
-                            else IO.pure(false)
-
-                          // Allow running until we reach a deeper depth, then pause at the start-element and clear target
-                          case "stepOver" =>
-                            if (cur < targetDepth) IO.pure(false)
-                            else if (kind == "start") whenContinued.get.flatMap(_ => stopTarget.set(None).as(true))
-                            else IO.pure(false)
-
-                          // Block once and clear the stopTarget so subsequent awaits don't re-trigger
-                          case _ => whenContinued.get.flatMap(_ => stopTarget.set(None).as(true))
-                        }
-                      } yield res
-                  }
+                s -> stopTarget.get.flatMap {
+                  case None =>
+                    // No step target, pause immediately and signal that we've stopped
+                    nextAwaitStarted.complete(()).void *> whenContinued.get.as(true)
+                  case Some((targetDepth, mode)) =>
+                    for {
+                      cur <- currentDepth.get
+                      kind <- awaitingKind.get
+                      res <- mode match {
+                        // stepIn: Stop at the very next 'start' event, completely ignoring 'end' events
+                        case "stepIn" =>
+                          if (kind == "start")
+                            stopTarget.set(None) *> nextAwaitStarted.complete(()).void *> whenContinued.get.as(true)
+                          else IO.pure(false)
+
+                        // stepOver / stepOut: Run invisibly until we hit a 'start' event at the target depth or shallower
+                        case "stepOver" | "stepOut" =>
+                          if (kind == "start" && cur <= targetDepth)
+                            stopTarget.set(None) *> nextAwaitStarted.complete(()).void *> whenContinued.get.as(true)
+                          else
+                            IO.pure(false) // Ignore ALL 'end' events and any 'start' events deeper than our target
+
+                        // Block once and clear the stopTarget so subsequent awaits don't re-trigger
+                        case _ =>
+                          stopTarget.set(None) *> nextAwaitStarted.complete(()).void *> whenContinued.get.as(true)
+                      }
+                    } yield res
+                }
             }.flatten
           } yield awaited
 
         def performStep(stepType: String, addedDepth: Int): IO[Unit] =
           for {
             nextContinue <- Deferred[IO, Unit]
-            nextAwaitStarted <- Deferred[IO, Unit]
+            newAwaitStarted <- Deferred[IO, Unit]
             _ <- state.modify {
               case s @ AwaitingFirstAwait(waiterArrived) =>
                 s -> waiterArrived.get *> (stepType match {
@@ -1353,12 +1354,12 @@ object Parse {
                 })
               case Running                   => Running -> IO.unit
               case Stopped(whenContinued, _) =>
-                Stopped(nextContinue, nextAwaitStarted) -> (
+                Stopped(nextContinue, newAwaitStarted) -> (
                   for {
                     d <- currentDepth.get
                     _ <- stopTarget.set(Some((d + addedDepth, stepType)))
-                    _ <- whenContinued.complete(())
-                    _ <- nextAwaitStarted.get
+                    _ <- whenContinued.complete(()) // Unblock the parser to continue running invisibly
+                    _ <- newAwaitStarted.get // WAIT here until the parser hits the target 'start' event and stops
                   } yield ()
                 )
             }.flatten
@@ -1376,20 +1377,23 @@ object Parse {
           state.modify {
             case s @ AwaitingFirstAwait(waiterArrived) =>
               s -> waiterArrived.get *> continue()
-            case Running                   => Running -> IO.unit
-            case Stopped(whenContinued, _) =>
-              Running -> (stopTarget.set(None) *> whenContinued.complete(())).void // wake up await-ers
+            case Running                                  => Running -> IO.unit
+            case Stopped(whenContinued, nextAwaitStarted) =>
+              Running -> (stopTarget.set(None) *> nextAwaitStarted.complete(()).void *> whenContinued.complete(())).void
           }.flatten
 
         def pause(): IO[Unit] =
           for {
             nextContinue <- Deferred[IO, Unit]
-            nextAwaitStarted <- Deferred[IO, Unit]
-            _ <- state.update {
-              case Running               => Stopped(nextContinue, nextAwaitStarted)
-              case s: AwaitingFirstAwait => s
-              case s: Stopped            => s
-            }
+            newAwaitStarted <- Deferred[IO, Unit]
+            _ <- state.modify {
+              case Running =>
+                Stopped(nextContinue, newAwaitStarted) -> IO.unit
+              case s: AwaitingFirstAwait            => s -> IO.unit
+              case s @ Stopped(_, nextAwaitStarted) =>
+                // If we are hit by a breakpoint during a step, clear target and unblock performStep
+                s -> (stopTarget.set(None) *> nextAwaitStarted.complete(()).void)
+            }.flatten
           } yield ()
       }
   }

package.json

@@ -46,6 +46,7 @@
     "test": "sbt test && yarn test:svelte && node ./out/tests/runTest.js",
     "test:svelte": "mocha --import=tsx ./src/svelte/tests/**/*.test.ts",
     "sbt": "sbt Universal/stage",
+    "move-debuggers": "run-func build/yarn-scripts.ts moveDebuggers",
     "svelte:check": "svelte-check --tsconfig ./src/svelte/tsconfig.json",
     "svelte:build": "cd src/svelte && vite build --config ./vite.config.mjs --mode production --emptyOutDir",
     "update-version": "run-func build/yarn-scripts.ts updateVersion",

src/infoset.ts

@@ -82,6 +82,23 @@ export async function activate(ctx: vscode.ExtensionContext) {
       }
       sid = undefined
       await openInfosetFilePrompt()
+
+      const tabs: vscode.Tab[] = vscode.window.tabGroups.all
+        .map((tg) => tg.tabs)
+        .flat()
+
+      // Find the tab that matches the file Uri
+      const foundTab = tabs.find(
+        (tab) =>
+          tab.input instanceof vscode.TabInputText &&
+          tab.input.uri.path === doc?.fileName
+      )
+
+      // If the tab is found, close it
+      if (foundTab) {
+        // The close method can take a single tab or an array of tabs
+        await vscode.window.tabGroups.close(foundTab)
+      }
     })
   )