Improve breakpoint setting and subscription handling

Introduce a new 'SubscriptionBag' type that makes it easier to
disposed of no longer needed subscriptions.

Author: fwcd

adapter/src/main/kotlin/org/javacs/ktda/jdi/JDIDebuggee.kt

@@ -11,6 +11,7 @@ import org.javacs.ktda.core.breakpoint.Breakpoint
 import org.javacs.ktda.core.breakpoint.ExceptionBreakpoint
 import org.javacs.kt.LOG
 import org.javacs.ktda.util.ObservableList
+import org.javacs.ktda.util.SubscriptionBag
 import org.javacs.ktda.classpath.findValidKtFilePath
 import org.javacs.ktda.classpath.toJVMClassNames
 import org.javacs.ktda.jdi.event.VMEventBus
@@ -38,6 +39,8 @@ class JDIDebuggee(
 	override val stdin: OutputStream?
 	override val stdout: InputStream?
 	override val stderr: InputStream?
+
+	private var breakpointSubscriptions = SubscriptionBag()
 
 	init {
 		eventBus = VMEventBus(vm)
@@ -66,6 +69,7 @@ class JDIDebuggee(
 	}
 
 	private fun setAllBreakpoints(breakpoints: List<Breakpoint>) {
+		breakpointSubscriptions.unsubscribe()
 		vm.eventRequestManager().deleteAllBreakpoints()
 		breakpoints.forEach { bp ->
 			bp.position.let { setBreakpoint(
@@ -94,25 +98,27 @@ class JDIDebuggee(
 	private fun setBreakpoint(filePath: String, lineNumber: Long) {
 		val eventRequestManager = vm.eventRequestManager()
 		toJVMClassNames(filePath)
+			.flatMap { listOf(it, "$it$*") } // For local types
 			.forEach { className ->
 				// Try setting breakpoint using a ClassPrepareRequest
-				
-				eventRequestManager
-					.createClassPrepareRequest()
-					.apply { addClassFilter(className) } // For global types
-					.enable()
-				eventRequestManager
+
+				val request = eventRequestManager
 					.createClassPrepareRequest()
-					.apply { addClassFilter(className + "$*") } // For local types
-					.enable()
+					.apply { addClassFilter(className) }
+
+				breakpointSubscriptions.add(eventBus.subscribe(ClassPrepareEvent::class) {
+					if (it.jdiEvent.request() == request) {
+						LOG.info("Setting breakpoint at prepared type {}", it.jdiEvent.referenceType().name())
+						setBreakpointAtType(it.jdiEvent.referenceType(), lineNumber)
+					}
+				})
 
-				eventBus.subscribe(ClassPrepareEvent::class) {
-					setBreakpointAtType(it.jdiEvent.referenceType(), lineNumber)
-				}
+				request.enable()
 
 				// Try setting breakpoint using loaded VM classes
 
 				vm.classesByName(className).forEach {
+					LOG.info("Setting breakpoint at known type {}", it.name())
 					setBreakpointAtType(it, lineNumber)
 				}
 			}
@@ -122,13 +128,11 @@ class JDIDebuggee(
 	private fun setBreakpointAtType(refType: ReferenceType, lineNumber: Long): Boolean {
 		try {
 			val location = refType
-					.locationsOfLine(lineNumber.toInt())
-					?.firstOrNull() ?: return false
+				.locationsOfLine(lineNumber.toInt())
+				?.firstOrNull() ?: return false
 			val request = vm.eventRequestManager()
-					.createBreakpointRequest(location)
-			request?.let {
-				it.enable()
-			}
+				.createBreakpointRequest(location)
+			request?.enable()
 			return request != null
 		} catch (e: AbsentInformationException) {
 			return false

adapter/src/main/kotlin/org/javacs/ktda/jdi/event/VMEventBus.kt

@@ -1,6 +1,7 @@
 package org.javacs.ktda.jdi.event
 
 import org.javacs.kt.LOG
+import org.javacs.ktda.util.Box
 import org.javacs.ktda.util.ListenerList
 import org.javacs.ktda.util.Subscription
 import org.javacs.ktda.core.event.DebuggeeEventBus
@@ -117,6 +118,7 @@ class VMEventBus(private val vm: VirtualMachine): DebuggeeEventBus {
 
 	private fun toThreadID(event: JDILocatableEvent) = event.thread().uniqueID()
 
+	/** Subscribes to a JDI event type and lets the caller decide when to stop subscribing. */
 	@Suppress("UNCHECKED_CAST")
 	fun <E: JDIEvent> subscribe(eventClass: KClass<E>, listener: (VMEvent<E>) -> Unit): Subscription {
 		eventListeners.putIfAbsent(eventClass, ListenerList())
@@ -130,6 +132,21 @@ class VMEventBus(private val vm: VirtualMachine): DebuggeeEventBus {
 			}
 		}
 	}
+
+	/** Subscribes to a JDI event type and lets the listener decide whether to stop subscribing. */
+	fun <E: JDIEvent> listen(eventClass: KClass<E>, listener: (VMEvent<E>) -> Boolean) {
+		var box = Box<((VMEvent<E>) -> Unit)?>(null)
+		box.value = {
+			val continueSubscribing = listener(it)
+
+			if (!continueSubscribing) {
+				// See method above for rationale
+				@Suppress("UNCHECKED_CAST")
+				eventListeners[eventClass]?.remove(box.value as (VMEvent<JDIEvent>) -> Unit)
+			}
+		}
+		subscribe(eventClass, box.value!!)
+	}
 
 	private fun dispatchEvent(event: JDIEvent, eventSet: JDIEventSet): Boolean {
 		val VMEvent = VMEvent(event, eventSet)

adapter/src/main/kotlin/org/javacs/ktda/util/Box.kt

@@ -0,0 +1,4 @@
+package org.javacs.ktda.util
+
+/** A simple boxing wrapper. Useful for captured local variables that have to be mutated. */
+class Box<T>(var value: T)

adapter/src/main/kotlin/org/javacs/ktda/util/SubscriptionBag.kt

@@ -0,0 +1,17 @@
+package org.javacs.ktda.util
+
+class SubscriptionBag: Subscription {
+    private val subscriptions = mutableListOf<Subscription>()
+
+    fun add(subscription: Subscription) {
+        subscriptions.add(subscription)
+    }
+
+    override fun unsubscribe() {
+        var iterator = subscriptions.iterator()
+        while (iterator.hasNext()) {
+            iterator.next().unsubscribe()
+            iterator.remove()
+        }
+    }
+}