Fix exception breakpoints not carrying over into new debuggers (close #10)

Author: object-Object

CHANGELOG.md

@@ -13,6 +13,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 ### Fixed
 
 - Fixed a crash when closing the Splicing Table with Hexical 1.5.0 installed ([#62](https://github.com/object-Object/HexDebug/issues/62)).
+- Fixed exceptions not being caught by exception breakpoints after the first hex in a debug session.
 
 ## `0.7.0+1.20.1` - 2025-10-02
 

Common/src/main/kotlin/gay/object/hexdebug/adapter/DebugAdapter.kt

@@ -39,6 +39,8 @@ import java.util.concurrent.CompletionException
 class DebugAdapter(val player: ServerPlayer) : IDebugProtocolServer {
     private var state: DebugAdapterState = NotDebugging()
 
+    private val exceptionBreakpoints = mutableSetOf<ExceptionBreakpointType>()
+
     private val debuggers get() = (state as? Debugging)?.debuggers
 
     val launcher: IHexDebugLauncher by lazy {
@@ -85,12 +87,12 @@ class DebugAdapter(val player: ServerPlayer) : IDebugProtocolServer {
         val debugger = when (val state = state) {
             is Debugging -> {
                 state.restartArgs[threadId] = args
-                HexDebugger(threadId, state.initArgs, state.launchArgs, args).also {
+                HexDebugger(threadId, exceptionBreakpoints, state.initArgs, state.launchArgs, args).also {
                     state.debuggers[threadId] = it
                 }
             }
             is NotDebugging -> {
-                val newState = Debugging(state, args, threadId)
+                val newState = Debugging(threadId, exceptionBreakpoints, state, args)
                 this.state = newState
                 newState.debuggers[threadId]!!
             }
@@ -293,14 +295,21 @@ class DebugAdapter(val player: ServerPlayer) : IDebugProtocolServer {
     }
 
     override fun setExceptionBreakpoints(args: SetExceptionBreakpointsArguments): CompletableFuture<SetExceptionBreakpointsResponse> {
-        return SetExceptionBreakpointsResponse().apply {
-            // FIXME: we need to save this somewhere and pass it to the debuggers on creation
-            debuggers?.values?.forEach {
-                it.setExceptionBreakpoints(args.filters)
-            }
-            breakpoints = Array(args.filters.size) {
-                Breakpoint().apply { isVerified = true }
+        exceptionBreakpoints.clear()
+        val responseBreakpoints = mutableListOf<Breakpoint>()
+
+        for (name in args.filters) {
+            val verified = try {
+                exceptionBreakpoints.add(ExceptionBreakpointType.valueOf(name))
+                true
+            } catch (_: IllegalArgumentException) {
+                false
             }
+            responseBreakpoints.add(Breakpoint().apply { isVerified = verified })
+        }
+
+        return SetExceptionBreakpointsResponse().apply {
+            breakpoints = responseBreakpoints.toTypedArray()
         }.toFuture()
     }
 

Common/src/main/kotlin/gay/object/hexdebug/adapter/DebugAdapterState.kt

@@ -1,6 +1,7 @@
 package gay.`object`.hexdebug.adapter
 
 import gay.`object`.hexdebug.debugger.CastArgs
+import gay.`object`.hexdebug.debugger.ExceptionBreakpointType
 import gay.`object`.hexdebug.debugger.HexDebugger
 import org.eclipse.lsp4j.debug.InitializeRequestArguments
 
@@ -26,12 +27,17 @@ sealed interface DebugAdapterState {
         override val restartArgs: MutableMap<Int, CastArgs>,
         val debuggers: MutableMap<Int, HexDebugger>,
     ) : DebugAdapterState {
-        constructor(state: DebugAdapterState, castArgs: CastArgs, threadId: Int = 0) : this(
+        constructor(
+            threadId: Int,
+            exceptionBreakpoints: Set<ExceptionBreakpointType>,
+            state: DebugAdapterState,
+            castArgs: CastArgs,
+        ) : this(
             state.isConnected,
             state.initArgs,
             state.launchArgs,
             mutableMapOf(threadId to castArgs),
-            mutableMapOf(threadId to HexDebugger(threadId, state.initArgs, state.launchArgs, castArgs)),
+            mutableMapOf(threadId to HexDebugger(threadId, exceptionBreakpoints, state.initArgs, state.launchArgs, castArgs)),
         )
     }
 }

Common/src/main/kotlin/gay/object/hexdebug/debugger/CastArgs.kt

@@ -8,5 +8,6 @@ data class CastArgs(
     val iotas: List<Iota>,
     val env: CastingEnvironment,
     val world: ServerLevel,
-    val onExecute: ((Iota) -> Unit)? = null
-)
+    val onExecute: ((Iota) -> Unit)? = null,
+
+)

Common/src/main/kotlin/gay/object/hexdebug/debugger/HexDebugger.kt

@@ -32,6 +32,7 @@ import org.eclipse.lsp4j.debug.LoadedSourceEventArgumentsReason as LoadedSourceR
 
 class HexDebugger(
     threadId: Int,
+    private val exceptionBreakpoints: Set<ExceptionBreakpointType>,
     var initArgs: InitializeRequestArguments,
     var launchArgs: LaunchArgs,
     private val defaultEnv: CastingEnvironment,
@@ -42,11 +43,12 @@ class HexDebugger(
 ) {
     constructor(
         threadId: Int,
+        exceptionBreakpoints: Set<ExceptionBreakpointType>,
         initArgs: InitializeRequestArguments,
         launchArgs: LaunchArgs,
         castArgs: CastArgs,
         image: CastingImage = CastingImage(),
-    ) : this(threadId, initArgs, launchArgs, castArgs.env, castArgs.world, castArgs.onExecute, castArgs.iotas, image)
+    ) : this(threadId, exceptionBreakpoints, initArgs, launchArgs, castArgs.env, castArgs.world, castArgs.onExecute, castArgs.iotas, image)
 
     var lastEvaluatedMetadata: IotaMetadata? = null
         private set
@@ -70,7 +72,6 @@ class HexDebugger(
     private val virtualFrames = IdentityHashMap<SpellContinuation, MutableList<StackFrame>>()
 
     private val breakpoints = mutableMapOf<Int, MutableMap<Int, SourceBreakpointMode>>() // source id -> line number
-    private val exceptionBreakpoints = mutableSetOf<ExceptionBreakpointType>()
 
     // this gets set to true by registerNewSource if a frame is loaded that contains a cognitohazard iota
     private var isPoisoned = false
@@ -359,13 +360,6 @@ class HexDebugger(
         }
     }
 
-    fun setExceptionBreakpoints(typeNames: Array<String>) {
-        exceptionBreakpoints.clear()
-        for (typeName in typeNames) {
-            exceptionBreakpoints.add(ExceptionBreakpointType.valueOf(typeName))
-        }
-    }
-
     private fun isAtBreakpoint(): Boolean {
         val nextIota = when (val frame = nextFrame) {
             // why is this empty sometimes??????