Cleanup

Author: ManuelHentschel

src/debugSession.ts src/debugAdapter.tssrc/debugSession.ts renamed to src/debugAdapter.ts

@@ -1,10 +1,18 @@
 
-"use strict";
+/* 
+This file contains an implementation of vscode.Debugadapter.
+
+DAP messages are received via `DebugAdapter.handleMessage` and sent via
+`onDidSendMessage`.
+
+Most messages are simply passed to the R pacakge by calling
+`this.debugRuntime.dispatchRequest()`, only some requests are modified/handled
+in `this.dispatchRequest()`.
+*/
 
 import { DebugRuntime } from './debugRuntime';
-import { ProtocolServer } from './protocol';
 import { DebugProtocol } from 'vscode-debugprotocol';
-import { InitializeRequest, ResponseWithBody, InitializeRequestArguments, ContinueRequest } from './debugProtocolModifications';
+import { InitializeRequest } from './debugProtocolModifications';
 import { config, getVSCodePackageVersion } from './utils';
 
 import * as vscode from 'vscode';
@@ -28,25 +36,17 @@ function logMessage(message: DebugProtocol.ProtocolMessage){
     return ret;
 }
 
-export class DebugSession extends ProtocolServer {
 
-	// we don't support multiple threads, so we can use a hardcoded ID for the default thread
-	private THREAD_ID = 1;
-
-	// a runtime (or debugger)
-    private runtime: DebugRuntime;
+export class DebugAdapter implements vscode.DebugAdapter {
 
+    // properties
+	private sendMessage = new vscode.EventEmitter<DebugProtocol.ProtocolMessage>(); // used by onDidSendMessage
+    private sequence: number = 0; // seq of messages sent to VS Code
+	private THREAD_ID = 1; // dummy value
+    private runtime: DebugRuntime; // actually handles requests etc. that are not forwarded
     private disconnectTimeout: number = config().get<number>('timeouts.startup', 1000);
 
-
-    sendProtocolMessage(message: DebugProtocol.ProtocolMessage): void {
-        logger.info(logMessage(message), message);
-        super.sendProtocolMessage(message);
-    }
-
     constructor() {
-        super();
-
 		// construct R runtime
 		this.runtime = new DebugRuntime();
 
@@ -56,12 +56,26 @@ export class DebugSession extends ProtocolServer {
         });
     }
 
-    // static run(debugSession: typeof DebugSession): void {
-    //     const session = new debugSession();
-    //     session.start(process.stdin, process.stdout);
-    // }
+    // dummy, required by vscode.Disposable (?)
+    public dispose(): void {};
+    
+    // used to send messages from R to VS Code
+	readonly onDidSendMessage: vscode.Event<DebugProtocol.ProtocolMessage> = this.sendMessage.event;
 
-    protected dispatchRequest(request: DebugProtocol.Request) {
+    // used to send messages from VS Code to R
+	public handleMessage(msg: DebugProtocol.ProtocolMessage): void {
+		if(msg.type === 'request') {
+			this.dispatchRequest(<DebugProtocol.Request>msg);
+		}
+	}
+
+	protected sendProtocolMessage(message: DebugProtocol.ProtocolMessage): void {
+        logger.info(logMessage(message), message);
+		message.seq = this.sequence++;
+		this.sendMessage.fire(message);
+	}
+
+    protected dispatchRequest(request: DebugProtocol.Request): void {
         // prepare response
         const response: DebugProtocol.Response = {
             command: request.command,
@@ -90,15 +104,18 @@ export class DebugSession extends ProtocolServer {
                 case 'evaluate':
                     const matches = /^### ?[sS][tT][dD][iI][nN]\s*(.*)$/s.exec(request.arguments.expression);
                     if(matches){
+                        // send directly to stdin, don't send request
                         const toStdin = matches[1];
                         logger.debug('user to stdin:\n' + toStdin);
                         this.runtime.rSession.writeToStdin(toStdin);
                     } else{
+                        // dispatch normally
                         dispatchToR = true;
                         sendResponse = false;
                     }
                     break;
                 case 'disconnect':
+                    // kill R process after timeout, in case it doesn't quit successfully
                     setTimeout(()=>{
                         console.log('killing R...');
                         this.runtime.killR();
@@ -107,7 +124,8 @@ export class DebugSession extends ProtocolServer {
                     sendResponse = false;
                     break;
                 case 'continue':
-                    // this.runtime.continue(<ContinueRequest>request);
+                    // pass info about the currently open text editor
+                    // can be used to start .vsc.debugSource(), when called from global workspace
                     const doc = vscode.window.activeTextEditor.document;
                     if(doc.uri.scheme === 'file'){
                         const filename = doc.fileName;
@@ -125,18 +143,25 @@ export class DebugSession extends ProtocolServer {
                     // request not handled here -> send to R
                     dispatchToR = true;
                     sendResponse = false;
+                // end cases
             }
-            if(dispatchToR){
-                this.runtime.dispatchRequest(request);
-            } else{
-                logger.info("request " + request.seq + " (handled in VS Code): " + request.command, request);
-            }
-            if(sendResponse){
-                this.sendProtocolMessage(response);
-            }
+        } catch (e) {
+            logger.error("Error while handling request " + request.seq + ": " + request.command);
+            response.success = false;
+            dispatchToR = false;
+            sendResponse = true;
+        }
+
+        // dispatch to R if not (completely) handled here
+        if(dispatchToR){
+            this.runtime.dispatchRequest(request);
+        } else{
+            logger.info("request " + request.seq + " (handled in VS Code): " + request.command, request);
         }
-        catch (e) {
-			logger.error("Error while handling request " + request.seq + ": " + request.command);
+
+        // send response if (completely) handled here
+        if(sendResponse){
+            this.sendProtocolMessage(response);
         }
     }
 }

src/debugRuntime.ts

@@ -1,6 +1,3 @@
-/*---------------------------------------------------------
- * Copyright (C) Microsoft Corporation. All rights reserved.
- *--------------------------------------------------------*/
 
 import { EventEmitter } from 'events';
 import * as vscode from 'vscode';
@@ -80,22 +77,18 @@ export class DebugRuntime extends EventEmitter {
 	public async initializeRequest(response: DebugProtocol.InitializeResponse, args: MDebugProtocol.InitializeRequestArguments, request: MDebugProtocol.InitializeRequest) {
 		// This function initializes a debug session with the following steps:
 		// 1. Handle arguments
-		// 2. Launch a child process 
+		// 2. Launch a child process running R
 		// 3. Check that the child process started 
 		// 4. Load the R package vscDebugger
 		// 5. Check that the R package is present and has a correct version
 
 
 		//// (1) Handle arguments
-		if(args.rStrings){
-			const rs1 = args.rStrings;
-			const rs0 = this.rStrings;
-			this.rStrings.prompt = rs1.prompt || rs0.prompt;
-			this.rStrings.continue = rs1.continue || rs0.continue;
-			this.rStrings.startup = rs1.startup || rs0.startup;
-			this.rStrings.libraryNotFound = rs1.libraryNotFound || rs0.libraryNotFound;
-			this.rStrings.packageName = rs1.packageName || rs0.packageName;
-		}
+		// update rStrings
+		this.rStrings = {
+			...this.rStrings,
+			...args.rStrings
+		};
 		args.rStrings = this.rStrings;
 
 		// read settings from vsc-settings
@@ -106,15 +99,14 @@ export class DebugRuntime extends EventEmitter {
 		this.outputModes["sinkSocket"] =  config().get<OutputMode>('printSinkSocket', 'filtered');
 
 		// start R in child process
-		const rStartupArguments: MDebugProtocol.RStartupArguments = await getRStartupArguments();
+		const rStartupArguments  = await getRStartupArguments();
 		const openFolders = vscode.workspace.workspaceFolders;
 		if(openFolders){
 			rStartupArguments.cwd = openFolders[0].uri.fsPath;
 		}
 
 		if(!rStartupArguments.path){
 			const message = 'No R path was found in the settings/path/registry.\n(Can be changed in setting rdebugger.rterm.XXX)';
-			// const message = 'R path not working:\n' + rPath + '\n';
 			await this.abortInitializeRequest(response, message);
 			return false;
 		}
@@ -124,7 +116,6 @@ export class DebugRuntime extends EventEmitter {
 		this.startOutputGroup('Starting R session...', true);
 		this.writeOutput('R Startup:\n' + JSON.stringify(rStartupArguments, undefined, 2));
 
-
 		//// (2) Launch child process
 		const tmpHandleLine: LineHandler = (line: string, from: DataSource, isFullLine: boolean) => {
 			return this.handleLine(line, from, isFullLine);
@@ -143,7 +134,7 @@ export class DebugRuntime extends EventEmitter {
 
 		// read ports that were assigned to the child process and add to initialize args
 		if(this.rSession.jsonPort <= 0 || this.rSession.sinkPort <= 0){
-			const message = 'Failed to connect to R process using ports!';
+			const message = 'Failed to listen on port!';
 			await this.abortInitializeRequest(response, message);
 			return false;
 		} else{
@@ -160,7 +151,7 @@ export class DebugRuntime extends EventEmitter {
 		const escapedStartupString = escapeStringForR(this.rStrings.startup + '\n');
 		const startupCmd = `base::cat(${escapedStartupString})`;
 		this.rSession.writeToStdin(startupCmd);
-		// this.rSession.callFunction('cat', this.rStrings.startup, '\n', true, 'base');
+
 		// `this.rSessionStartup` is notified when the output of the above `cat()` call is received
 		await this.rSessionStartup.wait(this.startupTimeout);
 		if (this.rSessionReady) {
@@ -220,7 +211,7 @@ export class DebugRuntime extends EventEmitter {
 		return true;
 	}
 
-	private async abortInitializeRequest(response: DebugProtocol.InitializeResponse, message: string, endOutputGroup: boolean = true){
+	protected async abortInitializeRequest(response: DebugProtocol.InitializeResponse, message: string, endOutputGroup: boolean = true){
 		// used to abort the debug session and return an unsuccessful InitializeResponse
 		logger.error(message);
 		if(endOutputGroup){
@@ -241,7 +232,7 @@ export class DebugRuntime extends EventEmitter {
 	// Output-handlers: (for output of the R process to stdout/stderr)
 	//////////
 
-	public handleLine(line: string, from: DataSource, isFullLine: boolean): string {
+	protected handleLine(line: string, from: DataSource, isFullLine: boolean): string {
 		// handle output from the R process line by line
 		// is called by rSession.handleData()
 
@@ -359,7 +350,7 @@ export class DebugRuntime extends EventEmitter {
 		return line;
 	}
 
-	private async handlePrompt(which: "browser"|"topLevel", text?: string){
+	protected async handlePrompt(which: "browser"|"topLevel", text?: string){
 		logger.debug("matches prompt: " + which);
 
 		// wait for timeout to give json socket time to catch up
@@ -391,7 +382,7 @@ export class DebugRuntime extends EventEmitter {
 		}
 	}
 
-	private sendShowingPromptRequest(which: "browser"|"topLevel", text?: string){
+	protected sendShowingPromptRequest(which: "browser"|"topLevel", text?: string){
 		const request: MDebugProtocol.ShowingPromptRequest = {
 			command: "custom",
 			arguments: {
@@ -405,7 +396,7 @@ export class DebugRuntime extends EventEmitter {
 		this.dispatchRequest(request);
 	}
 
-	public handleJsonString(json: string, from?: DataSource, isFullLine: boolean = true){
+	protected handleJsonString(json: string, from?: DataSource, isFullLine: boolean = true){
 		if(!isFullLine){
 			return json;
 		} else{
@@ -415,7 +406,7 @@ export class DebugRuntime extends EventEmitter {
 		}
 	}
 
-	public handleJson(json: any){
+	protected handleJson(json: any){
 		if(json.type === "response"){
 			if(json.command === "initialize"){
 				this.rPackageFound = true;
@@ -450,7 +441,12 @@ export class DebugRuntime extends EventEmitter {
 		}
 	}
 
-	public handleWriteToStdinEvent(args: MDebugProtocol.WriteToStdinBody){
+	// send DAP message to the debugSession
+	protected sendProtocolMessage(message: DebugProtocol.ProtocolMessage){
+		this.emit("protocolMessage", message);
+	}
+
+	protected handleWriteToStdinEvent(args: MDebugProtocol.WriteToStdinBody){
 		let count: number = 0;
 		if(args.count !== 0){
 			count = args.count || 1;
@@ -491,7 +487,6 @@ export class DebugRuntime extends EventEmitter {
 	public writeToStdin(text: string){
 		if(text){
 			logger.debug("Writing to stdin: ", text);
-			// this.rSession.runCommand(text, [], true);
 			this.rSession.writeToStdin(text);
 			return true;
 		} else{
@@ -519,10 +514,6 @@ export class DebugRuntime extends EventEmitter {
 		}
 	}
 
-	// send message to the debugSession
-	private sendProtocolMessage(message: DebugProtocol.ProtocolMessage){
-		this.emit("protocolMessage", message);
-	}
 
 
 	//////////////////////////////////////////////
@@ -536,6 +527,7 @@ export class DebugRuntime extends EventEmitter {
 		data: object = {}
 	): boolean {
 		// writes output to the debug console (of the vsc instance runnning the R code)
+		// used during start up to print info about errors/progress
 		if(text.slice(-1) !== '\n' && addNewline){
 			text = text + '\n';
 		}
@@ -565,7 +557,7 @@ export class DebugRuntime extends EventEmitter {
 		this.sendProtocolMessage(event);
 		return true; // output event was sent
 	}
-	private startOutputGroup(text: string = "", collapsed: boolean = false, addNewline = false, toStderr = false, line = 1){
+	public startOutputGroup(text: string = "", collapsed: boolean = false, addNewline = false, toStderr = false, line = 1){
 		const group = (collapsed ? 'startCollapsed' : 'start');
 		this.writeOutput(text, addNewline, (toStderr ? 'stderr' : 'stdout'), line, group);
 	}

src/extension.ts

@@ -1,7 +1,7 @@
 
 import * as vscode from 'vscode';
 import { WorkspaceFolder, ProviderResult, CancellationToken, DebugConfigurationProviderTriggerKind } from 'vscode';
-import { DebugSession } from './debugSession';
+import { DebugAdapter } from './debugAdapter';
 import {
 	DebugMode, FunctionDebugConfiguration,
 	FileDebugConfiguration, WorkspaceDebugConfiguration,
@@ -19,8 +19,6 @@ export async function activate(context: vscode.ExtensionContext) {
 	terminalHandler = new TerminalHandler();
 	const port = await terminalHandler.portPromise;
 
-	console.log('activate');
-
 	// register configuration resolver
 	const resolver = new DebugConfigurationResolver(port);
 	context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider('R-Debugger', resolver));
@@ -57,6 +55,22 @@ export function deactivate() {
 	}
 }
 
+class DebugAdapterDescriptorFactory implements vscode.DebugAdapterDescriptorFactory {
+	createDebugAdapterDescriptor(session: vscode.DebugSession): ProviderResult<vscode.DebugAdapterDescriptor> {
+		const config = session.configuration;
+		if(config.request === 'launch'){
+			return new vscode.DebugAdapterInlineImplementation(new DebugAdapter());
+		} else if(config.request === 'attach'){
+			const port: number = config.port || 18721;
+			const host: string = config.host || 'localhost';
+			return new vscode.DebugAdapterServer(port, host);
+		} else{
+			throw new Error('Invalid entry "request" in debug config. Valid entries are "launch" and "attach"');
+		}
+	}
+}
+
+
 class InitialDebugConfigurationProvider implements vscode.DebugConfigurationProvider {
 	provideDebugConfigurations(folder: WorkspaceFolder | undefined): ProviderResult<StrictDebugConfiguration[]>{
 		return [
@@ -232,19 +246,3 @@ class DebugConfigurationResolver implements vscode.DebugConfigurationProvider {
 		return strictConfig;
 	}
 }
-
-class DebugAdapterDescriptorFactory implements vscode.DebugAdapterDescriptorFactory {
-	createDebugAdapterDescriptor(session: vscode.DebugSession): ProviderResult<vscode.DebugAdapterDescriptor> {
-		const config = session.configuration;
-		if(config.request === 'launch'){
-			return new vscode.DebugAdapterInlineImplementation(new DebugSession());
-		} else if(config.request === 'attach'){
-			const port: number = config.port || 18721;
-			const host: string = config.host || 'localhost';
-			return new vscode.DebugAdapterServer(port, host);
-		} else{
-			throw new Error('Invalid entry "request" in debug config. Valid entries are "launch" and "attach"');
-		}
-	}
-}
-