Code improvements.

extension/src/debugger/EnhancedDebugSession.ts

@@ -0,0 +1,70 @@
+import { DebugSession } from "vscode";
+import { CompletionItem } from "../webviewContract";
+import { observable } from "mobx";
+
+export class EnhancedDebugSession {
+	@observable protected activeStackFrame: number | undefined;
+
+	constructor(public readonly session: DebugSession) {}
+
+	protected async getStackTrace(args: {
+		threadId: number;
+		startFrame?: number;
+		levels?: number;
+	}): Promise<{ totalFrames?: number; stackFrames: StackFrame[] }> {
+		try {
+			const reply = (await this.session.customRequest("stackTrace", {
+				threadId: args.threadId,
+				levels: args.levels,
+				startFrame: args.startFrame || 0,
+			})) as { totalFrames?: number; stackFrames: StackFrame[] };
+			return reply;
+		} catch (e) {
+			console.error(e);
+			throw e;
+		}
+	}
+
+	public async getCompletions(args: {
+		text: string;
+		column: number;
+		frameId: number | undefined;
+	}): Promise<CompletionItem[]> {
+		try {
+			const reply = await this.session.customRequest("completions", {
+				text: args.text,
+				frameId: args.frameId,
+				column: args.column,
+			});
+			if (!reply) {
+				return [];
+			}
+			return reply.targets;
+		} catch (error) {
+			console.error(error);
+			return [];
+		}
+	}
+
+	/**
+	 * Evaluates the given expression.
+	 * If context is "watch", long results are usually shortened.
+	 */
+
+	public async evaluate(args: {
+		expression: string;
+		frameId: number | undefined;
+		context: "watch" | "repl" | "copy";
+	}): Promise<{ result: string }> {
+		const reply = await this.session.customRequest("evaluate", {
+			expression: args.expression,
+			frameId: args.frameId,
+			context: args.context,
+		});
+		return { result: reply.result };
+	}
+}
+interface StackFrame {
+	id: number;
+	name: string;
+}

extension/src/debugger/VsCodeDebugger.ts

@@ -0,0 +1,116 @@
+import { Disposable } from "@hediet/std/disposable";
+import { debug, DebugSession } from "vscode";
+import { EventEmitter } from "@hediet/std/events";
+import { runInAction } from "mobx";
+import { EnhancedDebugSession } from "./EnhancedDebugSession";
+
+/**
+ * Decorates DebugSession instances and emits an event for new debug sessions.
+ */
+export class VsCodeDebugger {
+	public readonly dispose = Disposable.fn();
+	private readonly sessions = new Map<DebugSession, EnhancedDebugSession>();
+
+	private readonly _onDidStartDebugSession = new EventEmitter<{
+		session: EnhancedDebugSession;
+	}>();
+	public readonly onDidStartDebugSession = this._onDidStartDebugSession.asEvent();
+
+	public getEnhancedDebugSession(
+		session: DebugSession
+	): EnhancedDebugSession {
+		let result = this.sessions.get(session);
+		if (!result) {
+			result = new EnhancedDebugSession(session);
+			this.sessions.set(session, result);
+		}
+		return result;
+	}
+
+	constructor() {
+		this.dispose.track([
+			debug.onDidStartDebugSession(session => {
+				const e = this.sessions.get(session)!;
+				this._onDidStartDebugSession.emit({ session: e });
+			}),
+			debug.onDidTerminateDebugSession(session => {
+				this.sessions.delete(session);
+			}),
+			debug.registerDebugAdapterTrackerFactory("*", {
+				createDebugAdapterTracker: session => {
+					const extendedSession = this.getEnhancedDebugSession(
+						session
+					);
+					return {
+						onDidSendMessage: async msg => {
+							type Message =
+								| StoppedEvent
+								| ThreadsResponse
+								| ContinueLikeResponse;
+
+							interface ContinueLikeResponse {
+								type: "response";
+								command:
+									| "continue"
+									| "stepIn"
+									| "stepOut"
+									| "next";
+							}
+
+							interface StoppedEvent {
+								type: "event";
+								event: "stopped";
+								body: {
+									threadId: number;
+								};
+							}
+
+							interface ThreadsResponse {
+								type: "response";
+								command: "threads";
+								success: boolean;
+								body: {
+									threads: ThreadInfo[];
+								};
+							}
+
+							interface ThreadInfo {
+								id: number;
+								name: string;
+							}
+
+							const m = msg as Message;
+							if (m.type === "event") {
+								if (m.event === "stopped") {
+									const threadId = m.body.threadId;
+									const r = await extendedSession[
+										"getStackTrace"
+									]({
+										threadId,
+										startFrame: 0,
+										levels: 1,
+									});
+									extendedSession["activeStackFrame"] =
+										r.stackFrames.length > 0
+											? r.stackFrames[0].id
+											: undefined;
+								}
+							} else if (m.type === "response") {
+								if (
+									m.command === "continue" ||
+									m.command === "next" ||
+									m.command === "stepIn" ||
+									m.command === "stepOut"
+								) {
+									extendedSession[
+										"activeStackFrame"
+									] = undefined;
+								}
+							}
+						},
+					};
+				},
+			}),
+		]);
+	}
+}

extension/src/debugger/VsCodeDebuggerView.ts

@@ -0,0 +1,48 @@
+import { Disposable } from "@hediet/std/disposable";
+import { debug, DebugSession } from "vscode";
+import { observable, action } from "mobx";
+import { VsCodeDebugger } from "./VsCodeDebugger";
+import { EnhancedDebugSession } from "./EnhancedDebugSession";
+
+/**
+ * Tracks the currently active debug session and its currently active stack frame.
+ * This is currently all faked. A proper API would be nice.
+ */
+export class VsCodeDebuggerView {
+	public readonly dispose = Disposable.fn();
+
+	@observable private _activeDebugSession: EnhancedDebugSession | undefined;
+
+	public get activeDebugSession(): EnhancedDebugSession | undefined {
+		return this._activeDebugSession;
+	}
+
+	public get activeFrameId(): number | undefined {
+		if (!this._activeDebugSession) {
+			return undefined;
+		} else {
+			return this._activeDebugSession["activeStackFrame"];
+		}
+	}
+
+	constructor(private vsCodeDebugger: VsCodeDebugger) {
+		this.dispose.track(
+			debug.onDidChangeActiveDebugSession(activeSession => {
+				this.updateActiveDebugSession(activeSession);
+			})
+		);
+		this.updateActiveDebugSession(debug.activeDebugSession);
+	}
+
+	@action
+	private updateActiveDebugSession(activeSession: DebugSession | undefined) {
+		if (!activeSession) {
+			this._activeDebugSession = undefined;
+		} else {
+			const s = this.vsCodeDebugger.getEnhancedDebugSession(
+				activeSession
+			);
+			this._activeDebugSession = s;
+		}
+	}
+}