Add custom view for easy access to the Rascal debugger

rascal-vscode-extension/package.json

@@ -47,8 +47,22 @@
       {
         "command": "rascalmpl.importModule",
         "title": "Start Rascal Terminal and Import this module"
+      },
+      {
+        "command": "rascalmpl.startDebuggerForRepl",
+        "title": "Start Rascal debugger for REPL",
+        "icon": "$(debug)"
       }
     ],
+    "menus": {
+      "view/item/context": [
+        {
+          "command": "rascalmpl.startDebuggerForRepl",
+          "when": "view == rascalmpl-debugger-view && viewItem == 'canStartDebugging'",
+          "group": "inline"
+        }
+      ]
+    },
     "languages": [
       {
         "id": "rascalmpl",
@@ -89,12 +103,24 @@
           "icon": "./assets/images/rascal-logo-v2.1.svg",
           "visibility": "collapsed"
         }
+      ],
+      "debug": [
+        {
+          "id": "rascalmpl-debugger-view",
+          "name": "Debug Rascal Terminal",
+          "icon": "$(debug)",
+          "visibility": "visible"
+        }
       ]
     },
     "viewsWelcome": [
       {
         "view": "rascalmpl-configuration-view",
         "contents": "No Rascal Projects found in the workspace"
+      },
+      {
+        "view": "rascalmpl-debugger-view",
+        "contents": "No active Rascal REPLs found"
       }
     ],
     "breakpoints": [

rascal-vscode-extension/src/RascalExtension.ts

@@ -36,6 +36,7 @@ import { RascalTerminalLinkProvider } from './RascalTerminalLinkProvider';
 import { VSCodeUriResolverServer } from './fs/VSCodeURIResolver';
 import { RascalLibraryProvider } from './ux/LibraryNavigator';
 import { FileType } from 'vscode';
+import { RascalReplNode, RascalDebugViewProvider } from './dap/RascalDebugView';
 
 export class RascalExtension implements vscode.Disposable {
     private readonly vfsServer: VSCodeUriResolverServer;
@@ -52,9 +53,11 @@ export class RascalExtension implements vscode.Disposable {
         this.registerTerminalCommand();
         this.registerMainRun();
         this.registerImportModule();
+        this.registerDebuggerCommand();
         checkForJVMUpdate();
 
         vscode.window.registerTreeDataProvider('rascalmpl-configuration-view', new RascalLibraryProvider(this.rascal.rascalClient));
+        vscode.window.registerTreeDataProvider('rascalmpl-debugger-view', new RascalDebugViewProvider(this.rascal.rascalDebugClient, context));
         vscode.window.registerTerminalLinkProvider(new RascalTerminalLinkProvider(this.rascal.rascalClient));
     }
 
@@ -103,6 +106,16 @@ export class RascalExtension implements vscode.Disposable {
         );
     }
 
+    private registerDebuggerCommand() {
+        this.context.subscriptions.push(
+            vscode.commands.registerCommand("rascalmpl.startDebuggerForRepl", (replNode: RascalReplNode) => {
+                if (replNode.serverPort !== undefined) {
+                    this.rascal.rascalDebugClient.startDebuggingSession(replNode.serverPort);
+                }
+            })
+        );
+    }
+
     private async startTerminal(uri: vscode.Uri | undefined, ...extraArgs: string[]) {
         try {
             await vscode.window.withProgress({

rascal-vscode-extension/src/dap/RascalDebugClient.ts

@@ -24,7 +24,7 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
-import { debug, DebugConfiguration, DebugSession, Terminal, window } from "vscode";
+import { debug, DebugConfiguration, DebugSession, Terminal, window, commands } from "vscode";
 import { RascalDebugAdapterDescriptorFactory } from "./RascalDebugAdapterDescriptorFactory";
 import { RascalDebugConfigurationProvider } from "./RascalDebugConfigurationProvider";
 
@@ -77,13 +77,11 @@ export class RascalDebugClient {
 
     registerDebugServerPort(processID: number, serverPort: number){
         this.debugSocketServersPorts.set(processID, serverPort);
+        commands.executeCommand('rascalmpl.updateDebugView');
     }
 
-    getServerPort(processID: number | undefined){
-        if(processID !== undefined && this.debugSocketServersPorts.has(processID)){
-            return this.debugSocketServersPorts.get(processID);
-        }
-        return undefined;
+    getServerPort(processId: number){
+        return this.debugSocketServersPorts.get(processId);
     }
 
     isConnectedToDebugServer(serverPort: number){

rascal-vscode-extension/src/dap/RascalDebugConfigurationProvider.ts

@@ -59,6 +59,9 @@ export class RascalDebugConfigurationProvider implements DebugConfigurationProvi
 
         if (!debugConfiguration['serverPort']){
             const terminalProcessID = await window.activeTerminal?.processId;
+            if (terminalProcessID === undefined) {
+                throw Error("Active terminal has no associated process ID!");
+            }
             const port = this.debugClient.getServerPort(terminalProcessID);
             if(port === undefined) {
                 throw Error("Active terminal has not a debug server port registered !");

rascal-vscode-extension/src/dap/RascalDebugView.ts

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2018-2023, NWO-I CWI and Swat.engineering
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+import * as vscode from 'vscode';
+import { RascalDebugClient } from './RascalDebugClient';
+
+export class RascalDebugViewProvider implements vscode.TreeDataProvider<RascalReplNode> {
+    private changeEmitter = new vscode.EventEmitter<RascalReplNode | undefined>();
+    readonly onDidChangeTreeData = this.changeEmitter.event;
+
+    constructor(private readonly rascalDebugClient: RascalDebugClient, readonly context: vscode.ExtensionContext) {
+        vscode.window.onDidOpenTerminal(_e => {
+            this.changeEmitter.fire(undefined);
+        });
+        vscode.window.onDidCloseTerminal(_e => {
+            this.changeEmitter.fire(undefined);
+        });
+        vscode.window.onDidChangeActiveTerminal(_e => {
+            this.changeEmitter.fire(undefined);
+        });
+        vscode.debug.onDidStartDebugSession(_e => {
+            this.changeEmitter.fire(undefined);
+        });
+        vscode.debug.onDidTerminateDebugSession(_e => {
+            this.changeEmitter.fire(undefined);
+        });
+        vscode.debug.onDidReceiveDebugSessionCustomEvent(_e => {
+            this.changeEmitter.fire(undefined);
+        });
+        context.subscriptions.push(vscode.commands.registerCommand('rascalmpl.updateDebugView', () => {
+            this.changeEmitter.fire(undefined);
+        }));
+    }
+
+    getTreeItem(element: RascalReplNode): vscode.TreeItem | Thenable<vscode.TreeItem> {
+        return element;
+    }
+    getChildren(element?: RascalReplNode | undefined): vscode.ProviderResult<RascalReplNode[]> {
+        if (element === undefined) {
+            return this.updateRascalDebugView();
+        }
+        return [];
+    }
+    getParent?(_element: RascalReplNode): vscode.ProviderResult<RascalReplNode> {
+        return undefined;
+    }
+    resolveTreeItem?(item: vscode.TreeItem, _element: RascalReplNode, _token: vscode.CancellationToken): vscode.ProviderResult<vscode.TreeItem> {
+        return item;
+    }
+
+    async makeLabel(label: string, processId : number) : Promise<string | vscode.TreeItemLabel> {
+        if (await this.isActiveTerminal(processId)) {
+            return {label: label, highlights : [[0, label.length]]};
+        }
+        return label;
+    }
+
+    async updateRascalDebugView() : Promise<vscode.TreeItem[]> {
+        const result : RascalReplNode[] = [];
+        for (const terminal of vscode.window.terminals) {
+            const processId = await terminal.processId;
+            if (processId === undefined) {
+                continue;
+            }
+            if (terminal.name.includes("Rascal terminal")) {
+                const label = await this.makeLabel(terminal.name, processId);
+                const serverPort = this.rascalDebugClient.getServerPort(processId);
+                const isDebugging = serverPort !== undefined && this.rascalDebugClient.isConnectedToDebugServer(serverPort);
+                const replNode = new RascalReplNode(label, serverPort, isDebugging);
+                if (serverPort !== undefined && !isDebugging) {
+                    replNode.contextValue = "canStartDebugging";
+                }
+                result.push(replNode);
+            }
+        }
+        return result;
+    }
+
+    async isActiveTerminal(processId : number) : Promise<boolean> {
+        const activeTerminal = vscode.window.activeTerminal;
+        if (activeTerminal === undefined) {
+            return false;
+        }
+        return processId === await activeTerminal.processId;
+    }
+
+}
+
+export class RascalReplNode extends vscode.TreeItem {
+    serverPort? : number | undefined;
+
+    constructor(label : string | vscode.TreeItemLabel, serverPort : number | undefined, isDebugging : boolean) {
+        super(label, vscode.TreeItemCollapsibleState.None);
+        this.serverPort = serverPort;
+        this.iconPath = new vscode.ThemeIcon(isDebugging ? "debug" : "terminal");
+    }
+}