Improved variable resolution and error handling

Author: spoenemann

arduino-debugger-extension/src/browser/arduino-variable-resolver.ts

@@ -2,9 +2,12 @@
 import { VariableContribution, VariableRegistry, Variable } from '@theia/variable-resolver/lib/browser';
 import { injectable, inject } from 'inversify';
 import URI from '@theia/core/lib/common/uri';
+import { MessageService } from '@theia/core/lib/common/message-service';
+import { ApplicationShell, Navigatable } from '@theia/core/lib/browser';
+import { FileStat, FileSystem } from '@theia/filesystem/lib/common';
+import { WorkspaceVariableContribution } from '@theia/workspace/lib/browser/workspace-variable-contribution';
 import { BoardsServiceClientImpl } from 'arduino-ide-extension/lib/browser/boards/boards-service-client-impl';
 import { BoardsService, ToolLocations } from 'arduino-ide-extension/lib/common/protocol/boards-service';
-import { WorkspaceVariableContribution } from '@theia/workspace/lib/browser/workspace-variable-contribution';
 
 @injectable()
 export class ArduinoVariableResolver implements VariableContribution {
@@ -18,64 +21,134 @@ export class ArduinoVariableResolver implements VariableContribution {
     @inject(WorkspaceVariableContribution)
     protected readonly workspaceVars: WorkspaceVariableContribution;
 
+    @inject(ApplicationShell)
+    protected readonly applicationShell: ApplicationShell;
+
+    @inject(FileSystem)
+    protected readonly fileSystem: FileSystem;
+
+    @inject(MessageService)
+    protected readonly messageService: MessageService
+
     registerVariables(variables: VariableRegistry): void {
         variables.registerVariable(<Variable>{
-            name: `boardTools`,
-            description: "Provides paths and access to board specific tooling",
+            name: 'boardTools',
+            description: 'Provides paths and access to board specific tooling',
             resolve: this.resolveBoardTools.bind(this),
         });
         variables.registerVariable(<Variable>{
-            name: "board",
-            description: "Provides details about the currently selected board",
+            name: 'board',
+            description: 'Provides details about the currently selected board',
             resolve: this.resolveBoard.bind(this),
         });
-
         variables.registerVariable({
-            name: "sketchBinary",
-            description: "Path to the sketch's binary file",
+            name: 'sketchBinary',
+            description: 'Path to the sketch\'s binary file',
             resolve: this.resolveSketchBinary.bind(this)
         });
     }
 
-    // TODO: this function is a total hack. Instead of botching around with URI's it should ask something on the backend
-    //       that properly udnerstands the filesystem.
-    protected async resolveSketchBinary(context?: URI, argument?: string, configurationSection?: string): Promise<Object> {
-        let sketchPath = argument || this.workspaceVars.getResourceUri()!.path.toString();
-        return sketchPath.substring(0, sketchPath.length - 3) + "arduino.samd.arduino_zero_edbg.elf";
+    protected resolveSketchBinary(context?: URI, argument?: string, configurationSection?: string): Promise<Object | undefined> {
+        if (argument) {
+            return this.resolveBinaryWithHint(argument);
+        }
+        const resourceUri = this.workspaceVars.getResourceUri();
+        if (resourceUri) {
+            return this.resolveBinaryWithHint(resourceUri.toString());
+        }
+        for (const tabBar of this.applicationShell.mainAreaTabBars) {
+            if (tabBar.currentTitle && Navigatable.is(tabBar.currentTitle.owner)) {
+                const uri = tabBar.currentTitle.owner.getResourceUri();
+                if (uri) {
+                    return this.resolveBinaryWithHint(uri.toString());
+                }
+            }
+        }
+        this.messageService.error('No sketch available. Please open a sketch to start debugging.');
+        return Promise.resolve(undefined);
+    }
+
+    private async resolveBinaryWithHint(hint: string): Promise<string | undefined> {
+        const fileStat = await this.fileSystem.getFileStat(hint);
+        if (!fileStat) {
+            this.messageService.error('Cannot find sketch binary: ' + hint);
+            return undefined;
+        }
+        if (!fileStat.isDirectory && fileStat.uri.endsWith('.elf')) {
+            return fileStat.uri;
+        }
+
+        let parent: FileStat | undefined;
+        let prefix: string | undefined;
+        let suffix: string;
+        if (fileStat.isDirectory) {
+            parent = fileStat;
+        } else {
+            const uri = new URI(fileStat.uri);
+            parent = await this.fileSystem.getFileStat(uri.parent.toString());
+            prefix = uri.path.name;
+        }
+        const { boardsConfig } = this.boardsServiceClient;
+        if (boardsConfig && boardsConfig.selectedBoard && boardsConfig.selectedBoard.fqbn) {
+            suffix = boardsConfig.selectedBoard.fqbn.replace(/:/g, '.') + '.elf';
+        } else {
+            suffix = '.elf';
+        }
+        if (parent && parent.children) {
+            let bin: FileStat | undefined;
+            if (prefix) {
+                bin = parent.children.find(c => c.uri.startsWith(prefix!) && c.uri.endsWith(suffix));
+            }
+            if (!bin) {
+                bin = parent.children.find(c => c.uri.endsWith(suffix));
+            }
+            if (!bin && suffix.length > 4) {
+                bin = parent.children.find(c => c.uri.endsWith('.elf'));
+            }
+            if (bin) {
+                return bin.uri;
+            }
+        }
+        this.messageService.error('Cannot find sketch binary: ' + hint);
+        return undefined;
     }
 
-    protected async resolveBoard(context?: URI, argument?: string, configurationSection?: string): Promise<Object> {
+    protected async resolveBoard(context?: URI, argument?: string, configurationSection?: string): Promise<string | undefined> {
         const { boardsConfig } = this.boardsServiceClient;
         if (!boardsConfig || !boardsConfig.selectedBoard) {
-            throw new Error('No boards selected. Please select a board.');
+            this.messageService.error('No boards selected. Please select a board.');
+            return undefined;
         }
 
-        if (!argument || argument === "fqbn") {
+        if (!argument || argument === 'fqbn') {
             return boardsConfig.selectedBoard.fqbn!;
         }
-        if (argument === "name") {
+        if (argument === 'name') {
             return boardsConfig.selectedBoard.name;
         }
 
-        const details = await this.boardsService.detail({id: boardsConfig.selectedBoard.fqbn!});
+        const details = await this.boardsService.detail({ id: boardsConfig.selectedBoard.fqbn! });
         if (!details.item) {
-            throw new Error("Cannot get board details");
+            this.messageService.error('Details of the selected boards are not available.');
+            return undefined;
         }
-        if (argument === "openocd-debug-file") {
+        if (argument === 'openocd-debug-file') {
             return details.item.locations!.debugScript;
         }
 
         return boardsConfig.selectedBoard.fqbn!;
     }
 
-    protected async resolveBoardTools(context?: URI, argument?: string, configurationSection?: string): Promise<Object> {
+    protected async resolveBoardTools(context?: URI, argument?: string, configurationSection?: string): Promise<string | undefined> {
         const { boardsConfig } = this.boardsServiceClient;
         if (!boardsConfig || !boardsConfig.selectedBoard) {
-            throw new Error('No boards selected. Please select a board.');
+            this.messageService.error('No boards selected. Please select a board.');
+            return undefined;
         }
-        const details = await this.boardsService.detail({id: boardsConfig.selectedBoard.fqbn!});
+        const details = await this.boardsService.detail({ id: boardsConfig.selectedBoard.fqbn! });
         if (!details.item) {
-            throw new Error("Cannot get board details")
+            this.messageService.error('Details of the selected boards are not available.');
+            return undefined;
         }
 
         let toolLocations: { [name: string]: ToolLocations } = {};
@@ -84,17 +157,37 @@ export class ArduinoVariableResolver implements VariableContribution {
         })
 
         switch (argument) {
-            case "openocd":
-                return toolLocations["openocd"].main;
-            case "openocd-scripts":
-                return toolLocations["openocd"].scripts;
-            case "objdump":
-                return toolLocations["arm-none-eabi-gcc"].objdump;
-            case "gdb":
-                return toolLocations["arm-none-eabi-gcc"].gdb;
+            case 'openocd': {
+                const openocd = toolLocations['openocd'];
+                if (openocd) {
+                    return openocd.main;
+                }
+                this.messageService.error('Unable to find debugging tool: openocd');
+                return undefined;
+            }
+            case 'openocd-scripts': {
+                const openocd = toolLocations['openocd'];
+                return openocd ? openocd.scripts : undefined;
+            }
+            case 'objdump': {
+                const gcc = Object.keys(toolLocations).find(key => key.endsWith('gcc'));
+                if (gcc) {
+                    return toolLocations[gcc].objdump;
+                }
+                this.messageService.error('Unable to find debugging tool: objdump');
+                return undefined;
+            }
+            case 'gdb': {
+                const gcc = Object.keys(toolLocations).find(key => key.endsWith('gcc'));
+                if (gcc) {
+                    return toolLocations[gcc].gdb;
+                }
+                this.messageService.error('Unable to find debugging tool: gdb');
+                return undefined;
+            }
         }
 
         return boardsConfig.selectedBoard.name;
     }
 
-}
+}

arduino-debugger-extension/src/node/arduino-debug-adapter-contribution.ts

@@ -1,59 +1,59 @@
 import { injectable } from 'inversify';
 import { DebugAdapterContribution, DebugAdapterExecutable, DebugAdapterSessionFactory } from '@theia/debug/lib/common/debug-model';
-import { DebugConfiguration } from "@theia/debug/lib/common/debug-configuration";
-import { MaybePromise } from "@theia/core/lib/common/types";
-import { IJSONSchema, IJSONSchemaSnippet } from "@theia/core/lib/common/json-schema";
+import { DebugConfiguration } from '@theia/debug/lib/common/debug-configuration';
+import { MaybePromise } from '@theia/core/lib/common/types';
+import { IJSONSchema, IJSONSchemaSnippet } from '@theia/core/lib/common/json-schema';
 import * as path from 'path';
 
 @injectable()
 export class ArduinoDebugAdapterContribution implements DebugAdapterContribution {
 
-    type = "arduino";
+    type = 'arduino';
 
-    label = "Arduino";
+    label = 'Arduino';
 
-    languages = ["c", "cpp", "ino"];
+    languages = ['c', 'cpp', 'ino'];
 
     debugAdapterSessionFactory?: DebugAdapterSessionFactory;
 
-    getSchemaAttributes?(): MaybePromise<IJSONSchema[]> {
+    getSchemaAttributes(): MaybePromise<IJSONSchema[]> {
         return [
             {
-                "required": [
-                    "program"
+                'required': [
+                    'program'
                 ],
-                "properties": {
-                    "sketch": {
-                        "type": "string",
-                        "description": "path to the sketch root ino file",
-                        "default": "${file}",
+                'properties': {
+                    'sketch': {
+                        'type': 'string',
+                        'description': 'path to the sketch root ino file',
+                        'default': '${file}',
                     },
-                    "fqbn": {
-                        "type": "string",
-                        "description": "Fully-qualified board name to debug on",
-                        "default": ""
+                    'fqbn': {
+                        'type': 'string',
+                        'description': 'Fully-qualified board name to debug on',
+                        'default': ''
                     },
-                    "runToMain": {
-                        "description": "If enabled the debugger will run until the start of the main function.",
-                        "type": "boolean",
-                        "default": false
+                    'runToMain': {
+                        'description': 'If enabled the debugger will run until the start of the main function.',
+                        'type': 'boolean',
+                        'default': false
                     },
-                    "verbose": {
-                        "type": "boolean",
-                        "description": "Produce verbose log output",
-                        "default": false
+                    'verbose': {
+                        'type': 'boolean',
+                        'description': 'Produce verbose log output',
+                        'default': false
                     },
-                    "debugDebugAdapter": {
-                        "type": "boolean",
-                        "description": "Start the debug adapter in debug mode (with --inspect-brk)",
-                        "default": false
+                    'debugDebugAdapter': {
+                        'type': 'boolean',
+                        'description': 'Start the debug adapter in debug mode (with --inspect-brk)',
+                        'default': false
                     },
                 }
             }
         ]
     }
 
-    getConfigurationSnippets?(): MaybePromise<IJSONSchemaSnippet[]> {
+    getConfigurationSnippets(): MaybePromise<IJSONSchemaSnippet[]> {
         return []
     }
 
@@ -65,53 +65,53 @@ export class ArduinoDebugAdapterContribution implements DebugAdapterContribution
         args = args.concat([path.join(__dirname, 'debug-adapter', 'main')]);
 
         return {
-            command: "node",
+            command: 'node',
             args: args,
         }
     }
 
-    provideDebugConfigurations?(workspaceFolderUri?: string): MaybePromise<DebugConfiguration[]> {
+    provideDebugConfigurations(workspaceFolderUri?: string): MaybePromise<DebugConfiguration[]> {
         return [
             <DebugConfiguration>{
                 name: this.label,
                 type: this.type,
-                request: "launch",
-                sketch: "${file}",
+                request: 'launch',
+                sketch: '${file}',
             },
             <DebugConfiguration>{
-                name: this.label + " (explicit)",
+                name: this.label + ' (explicit)',
                 type: this.type,
-                request: "launch",
+                request: 'launch',
 
-                program: "${sketchBinary}",
-                objdump: "${boardTools:objdump}",
-                gdb: "${boardTools:gdb}",
-                gdbServer: "${boardTools:openocd}",
-                gdbServerArguments: ["-s", "${boardTools:openocd-scripts}", "--file", "${board:openocd-debug-file}"],
+                program: '${sketchBinary}',
+                objdump: '${boardTools:objdump}',
+                gdb: '${boardTools:gdb}',
+                gdbServer: '${boardTools:openocd}',
+                gdbServerArguments: ['-s', '${boardTools:openocd-scripts}', '--file', '${board:openocd-debug-file}'],
 
                 runToMain: false,
                 verbose: false,
             }
         ];
     }
 
-    async resolveDebugConfiguration?(config: DebugConfiguration, workspaceFolderUri?: string): Promise<DebugConfiguration> {
+    async resolveDebugConfiguration(config: DebugConfiguration, workspaceFolderUri?: string): Promise<DebugConfiguration> {
         // if program is present we expect to have an explicit config here
         if (!!config.program) {
             return config;
         }
 
-        let sketchBinary = "${sketchBinary}"
-        if (config.sketch !== "${file}") {
-            sketchBinary = "${sketchBinary:" + config.sketch + "}";
+        let sketchBinary = '${sketchBinary}'
+        if (typeof config.sketch === 'string' && config.sketch.indexOf('${') < 0) {
+            sketchBinary = '${sketchBinary:' + config.sketch + '}';
         }
         const res: ActualDebugConfig = {
             ...config,
 
-            objdump: "${boardTools:objdump}",
-            gdb: "${boardTools:gdb}",
-            gdbServer: "${boardTools:openocd}",
-            gdbServerArguments: ["-s", "${boardTools:openocd-scripts}", "--file", "${board:openocd-debug-file}"],
+            objdump: '${boardTools:objdump}',
+            gdb: '${boardTools:gdb}',
+            gdbServer: '${boardTools:openocd}',
+            gdbServerArguments: ['-s', '${boardTools:openocd-scripts}', '--file', '${board:openocd-debug-file}'],
             program: sketchBinary
         }
         return res;