feat: use new debug -I -P CLI output

- Can pick a programmer if missing, - Can auto-select a programmer on app start, - Can edit the `launch.json`, - Adjust board discovery to new gRPC API. From now on, it's a client read stream, not a duplex. - Allow `.cxx` and `.cc` file extensions. (Closes #2265) - Drop `debuggingSupported` from `BoardDetails`. - Dedicated service endpoint for checking the debugger. Signed-off-by: Akos Kitta <a.kitta@arduino.cc>
2025-11-16 05:39:28 +00:00 · 2023-11-08 12:04:44 +01:00
parent 42bf1a0e99
commit 73b6dc4774
48 changed files with 4697 additions and 3041 deletions
--- a/arduino-ide-extension/src/browser/contributions/debug.ts
+++ b/arduino-ide-extension/src/browser/contributions/debug.ts
@@ -1,12 +1,20 @@
+import { Emitter, Event } from '@theia/core/lib/common/event';
+import { MenuModelRegistry } from '@theia/core/lib/common/menu/menu-model-registry';
+import { nls } from '@theia/core/lib/common/nls';
+import { MaybePromise } from '@theia/core/lib/common/types';
 import { inject, injectable } from '@theia/core/shared/inversify';
+import { noBoardSelected } from '../../common/nls';
 import {
-  Board,
+  BoardDetails,
  BoardIdentifier,
  BoardsService,
+  CheckDebugEnabledParams,
  ExecutableService,
+  SketchRef,
  isBoardIdentifierChangeEvent,
-  Sketch,
+  isCompileSummary,
 } from '../../common/protocol';
+import { BoardsDataStore } from '../boards/boards-data-store';
 import { BoardsServiceProvider } from '../boards/boards-service-provider';
 import { HostedPluginSupport } from '../hosted/hosted-plugin-support';
 import { ArduinoMenus } from '../menu/arduino-menus';
@@ -14,95 +22,119 @@ import { NotificationCenter } from '../notification-center';
 import { CurrentSketch } from '../sketches-service-client-impl';
 import { ArduinoToolbar } from '../toolbar/arduino-toolbar';
 import {
-  URI,
  Command,
  CommandRegistry,
  SketchContribution,
  TabBarToolbarRegistry,
+  URI,
 } from './contribution';
-import { MenuModelRegistry, nls } from '@theia/core/lib/common';
-import { CurrentSketch } from '../sketches-service-client-impl';
-import { ArduinoMenus } from '../menu/arduino-menus';

 const COMPILE_FOR_DEBUG_KEY = 'arduino-compile-for-debug';

+interface StartDebugParams {
+  /**
+   * Absolute filesystem path to the Arduino CLI executable.
+   */
+  readonly cliPath: string;
+  /**
+   * The the board to debug.
+   */
+  readonly board: Readonly<{ fqbn: string; name?: string }>;
+  /**
+   * Absolute filesystem path of the sketch to debug.
+   */
+  readonly sketchPath: string;
+  /**
+   * Location where the `launch.json` will be created on the fly before starting every debug session.
+   * If not defined, it falls back to `sketchPath/.vscode/launch.json`.
+   */
+  readonly launchConfigsDirPath?: string;
+  /**
+   * Absolute path to the `arduino-cli.yaml` file. If not specified, it falls back to `~/.arduinoIDE/arduino-cli.yaml`.
+   */
+  readonly cliConfigPath?: string;
+  /**
+   * Programmer for the debugging.
+   */
+  readonly programmer?: string;
+  /**
+   * Custom progress title to use when getting the debug information from the CLI.
+   */
+  readonly title?: string;
+}
+type StartDebugResult = boolean;
+
@injectable()
 export class Debug extends SketchContribution {
  @inject(HostedPluginSupport)
  private readonly hostedPluginSupport: HostedPluginSupport;
-
  @inject(NotificationCenter)
  private readonly notificationCenter: NotificationCenter;
-
  @inject(ExecutableService)
  private readonly executableService: ExecutableService;
-
  @inject(BoardsService)
  private readonly boardService: BoardsService;
-
  @inject(BoardsServiceProvider)
  private readonly boardsServiceProvider: BoardsServiceProvider;
+  @inject(BoardsDataStore)
+  private readonly boardsDataStore: BoardsDataStore;

  /**
-   * If `undefined`, debugging is enabled. Otherwise, the reason why it's disabled.
+   * If `undefined`, debugging is enabled. Otherwise, the human-readable reason why it's disabled.
   */
-  private _disabledMessages?: string = nls.localize(
-    'arduino/common/noBoardSelected',
-    'No board selected'
-  ); // Initial pessimism.
-  private disabledMessageDidChangeEmitter = new Emitter<string | undefined>();
-  private onDisabledMessageDidChange =
-    this.disabledMessageDidChangeEmitter.event;
+  private _message?: string = noBoardSelected; // Initial pessimism.
+  private didChangeMessageEmitter = new Emitter<string | undefined>();
+  private onDidChangeMessage = this.didChangeMessageEmitter.event;

-  private get disabledMessage(): string | undefined {
-    return this._disabledMessages;
+  private get message(): string | undefined {
+    return this._message;
  }
-  private set disabledMessage(message: string | undefined) {
-    this._disabledMessages = message;
-    this.disabledMessageDidChangeEmitter.fire(this._disabledMessages);
+  private set message(message: string | undefined) {
+    this._message = message;
+    this.didChangeMessageEmitter.fire(this._message);
  }

  private readonly debugToolbarItem = {
    id: Debug.Commands.START_DEBUGGING.id,
    command: Debug.Commands.START_DEBUGGING.id,
    tooltip: `${
-      this.disabledMessage
+      this.message
        ? nls.localize(
            'arduino/debug/debugWithMessage',
            'Debug - {0}',
-            this.disabledMessage
+            this.message
          )
        : Debug.Commands.START_DEBUGGING.label
    }`,
    priority: 3,
-    onDidChange: this.onDisabledMessageDidChange as Event<void>,
+    onDidChange: this.onDidChangeMessage as Event<void>,
  };

  override onStart(): void {
-    this.onDisabledMessageDidChange(
+    this.onDidChangeMessage(
      () =>
        (this.debugToolbarItem.tooltip = `${
-          this.disabledMessage
+          this.message
            ? nls.localize(
                'arduino/debug/debugWithMessage',
                'Debug - {0}',
-                this.disabledMessage
+                this.message
              )
            : Debug.Commands.START_DEBUGGING.label
        }`)
    );
    this.boardsServiceProvider.onBoardsConfigDidChange((event) => {
      if (isBoardIdentifierChangeEvent(event)) {
-        this.refreshState(event.selectedBoard);
+        this.updateMessage();
      }
    });
-    this.notificationCenter.onPlatformDidInstall(() => this.refreshState());
-    this.notificationCenter.onPlatformDidUninstall(() => this.refreshState());
+    this.notificationCenter.onPlatformDidInstall(() => this.updateMessage());
+    this.notificationCenter.onPlatformDidUninstall(() => this.updateMessage());
    this.boardsDataStore.onDidChange((event) => {
      const selectedFqbn =
        this.boardsServiceProvider.boardsConfig.selectedBoard?.fqbn;
      if (event.changes.find((change) => change.fqbn === selectedFqbn)) {
-        this.refreshState();
+        this.updateMessage();
      }
    });
    this.commandService.onDidExecuteCommand((event) => {
@@ -111,13 +143,13 @@ export class Debug extends SketchContribution {
        commandId === 'arduino.languageserver.notifyBuildDidComplete' &&
        isCompileSummary(args[0])
      ) {
-        this.refreshState();
+        this.updateMessage();
      }
    });
  }

  override onReady(): void {
-    this.boardsServiceProvider.ready.then(() => this.refreshState());
+    this.boardsServiceProvider.ready.then(() => this.updateMessage());
  }

  override registerCommands(registry: CommandRegistry): void {
@@ -125,7 +157,7 @@ export class Debug extends SketchContribution {
      execute: () => this.startDebug(),
      isVisible: (widget) =>
        ArduinoToolbar.is(widget) && widget.side === 'left',
-      isEnabled: () => !this.disabledMessage,
+      isEnabled: () => !this.message,
    });
    registry.registerCommand(Debug.Commands.TOGGLE_OPTIMIZE_FOR_DEBUG, {
      execute: () => this.toggleCompileForDebug(),
@@ -148,94 +180,56 @@ export class Debug extends SketchContribution {
    });
  }

-  private async refreshState(
-    board: Board | undefined = this.boardsServiceProvider.boardsConfig
+  private async updateMessage(): Promise<void> {
+    try {
+      await this.isDebugEnabled();
+      this.message = undefined;
+    } catch (err) {
+      let message = String(err);
+      if (err instanceof Error) {
+        message = err.message;
+      }
+      this.message = message;
+    }
+  }
+
+  private async isDebugEnabled(
+    board: BoardIdentifier | undefined = this.boardsServiceProvider.boardsConfig
      .selectedBoard
-  ): Promise<void> {
-    if (!board) {
-      this.disabledMessage = nls.localize(
-        'arduino/common/noBoardSelected',
-        'No board selected'
-      );
-      return;
-    }
-    const fqbn = board.fqbn;
-    if (!fqbn) {
-      this.disabledMessage = nls.localize(
-        'arduino/debug/noPlatformInstalledFor',
-        "Platform is not installed for '{0}'",
-        board.name
-      );
-      return;
-    }
-    const details = await this.boardService.getBoardDetails({ fqbn });
-    if (!details) {
-      this.disabledMessage = nls.localize(
-        'arduino/debug/noPlatformInstalledFor',
-        "Platform is not installed for '{0}'",
-        board.name
-      );
-      return;
-    }
-    const { debuggingSupported } = details;
-    if (!debuggingSupported) {
-      this.disabledMessage = nls.localize(
-        'arduino/debug/debuggingNotSupported',
-        "Debugging is not supported by '{0}'",
-        board.name
-      );
-    } else {
-      this.disabledMessage = undefined;
-    }
+  ): Promise<string> {
+    const debugFqbn = await isDebugEnabled(
+      board,
+      (fqbn) => this.boardService.getBoardDetails({ fqbn }),
+      (fqbn) => this.boardsDataStore.getData(fqbn),
+      (fqbn) => this.boardsDataStore.appendConfigToFqbn(fqbn),
+      (params) => this.boardService.checkDebugEnabled(params)
+    );
+    return debugFqbn;
  }

  private async startDebug(
    board: BoardIdentifier | undefined = this.boardsServiceProvider.boardsConfig
-      .selectedBoard
-  ): Promise<void> {
-    if (!board) {
-      return;
+      .selectedBoard,
+    sketch:
+      | CurrentSketch
+      | undefined = this.sketchServiceClient.tryGetCurrentSketch()
+  ): Promise<StartDebugResult> {
+    if (!CurrentSketch.isValid(sketch)) {
+      return false;
    }
-    const { name, fqbn } = board;
-    if (!fqbn) {
-      return;
+    const params = await this.createStartDebugParams(board);
+    if (!params) {
+      return false;
    }
    await this.hostedPluginSupport.didStart;
-    const [sketch, executables] = await Promise.all([
-      this.sketchServiceClient.currentSketch(),
-      this.executableService.list(),
-    ]);
-    if (!CurrentSketch.isValid(sketch)) {
-      return;
-    }
-    const ideTempFolderUri = await this.sketchesService.getIdeTempFolderUri(
-      sketch
-    );
-    const [cliPath, sketchPath, configPath] = await Promise.all([
-      this.fileService.fsPath(new URI(executables.cliUri)),
-      this.fileService.fsPath(new URI(sketch.uri)),
-      this.fileService.fsPath(new URI(ideTempFolderUri)),
-    ]);
-    const config = {
-      cliPath,
-      board: {
-        fqbn,
-        name,
-      },
-      sketchPath,
-      configPath,
-    };
    try {
-      await this.commandService.executeCommand('arduino.debug.start', config);
+      const result = await this.debug(params);
+      return Boolean(result);
    } catch (err) {
      if (await this.isSketchNotVerifiedError(err, sketch)) {
        const yes = nls.localize('vscode/extensionsUtils/yes', 'Yes');
        const answer = await this.messageService.error(
-          nls.localize(
-            'arduino/debug/sketchIsNotCompiled',
-            "Sketch '{0}' must be verified before starting a debug session. Please verify the sketch and start debugging again. Do you want to verify the sketch now?",
-            sketch.name
-          ),
+          sketchIsNotCompiled(sketch.name),
          yes
        );
        if (answer === yes) {
@@ -247,6 +241,16 @@ export class Debug extends SketchContribution {
        );
      }
    }
+    return false;
+  }
+
+  private async debug(
+    params: StartDebugParams
+  ): Promise<StartDebugResult | undefined> {
+    return this.commandService.executeCommand<StartDebugResult>(
+      'arduino.debug.start',
+      params
+    );
  }

  get compileForDebug(): boolean {
@@ -254,7 +258,7 @@ export class Debug extends SketchContribution {
    return value === 'true';
  }

-  async toggleCompileForDebug(): Promise<void> {
+  private toggleCompileForDebug(): void {
    const oldState = this.compileForDebug;
    const newState = !oldState;
    window.localStorage.setItem(COMPILE_FOR_DEBUG_KEY, String(newState));
@@ -263,7 +267,7 @@ export class Debug extends SketchContribution {

  private async isSketchNotVerifiedError(
    err: unknown,
-    sketch: Sketch
+    sketch: SketchRef
  ): Promise<boolean> {
    if (err instanceof Error) {
      try {
@@ -277,6 +281,48 @@ export class Debug extends SketchContribution {
    }
    return false;
  }
+
+  private async createStartDebugParams(
+    board: BoardIdentifier | undefined
+  ): Promise<StartDebugParams | undefined> {
+    if (!board || !board.fqbn) {
+      return undefined;
+    }
+    let debugFqbn: string | undefined = undefined;
+    try {
+      debugFqbn = await this.isDebugEnabled(board);
+    } catch {}
+    if (!debugFqbn) {
+      return undefined;
+    }
+    const [sketch, executables, boardsData] = await Promise.all([
+      this.sketchServiceClient.currentSketch(),
+      this.executableService.list(),
+      this.boardsDataStore.getData(board.fqbn),
+    ]);
+    if (!CurrentSketch.isValid(sketch)) {
+      return undefined;
+    }
+    const ideTempFolderUri = await this.sketchesService.getIdeTempFolderUri(
+      sketch
+    );
+    const [cliPath, sketchPath, launchConfigsDirPath] = await Promise.all([
+      this.fileService.fsPath(new URI(executables.cliUri)),
+      this.fileService.fsPath(new URI(sketch.uri)),
+      this.fileService.fsPath(new URI(ideTempFolderUri)),
+    ]);
+    return {
+      board: { fqbn: debugFqbn, name: board.name },
+      cliPath,
+      sketchPath,
+      launchConfigsDirPath,
+      programmer: boardsData.selectedProgrammer?.id,
+      title: nls.localize(
+        'arduino/debug/getDebugInfo',
+        'Getting debug info...'
+      ),
+    };
+  }
 }
 export namespace Debug {
  export namespace Commands {
@@ -301,3 +347,89 @@ export namespace Debug {
    };
  }
 }
+
+/**
+ * (non-API)
+ */
+export async function isDebugEnabled(
+  board: BoardIdentifier | undefined,
+  getDetails: (fqbn: string) => MaybePromise<BoardDetails | undefined>,
+  getData: (fqbn: string) => MaybePromise<BoardsDataStore.Data>,
+  appendConfigToFqbn: (fqbn: string) => MaybePromise<string | undefined>,
+  checkDebugEnabled: (params: CheckDebugEnabledParams) => MaybePromise<string>
+): Promise<string> {
+  if (!board) {
+    throw new Error(noBoardSelected);
+  }
+  const { fqbn } = board;
+  if (!fqbn) {
+    throw new Error(noPlatformInstalledFor(board.name));
+  }
+  const [details, data, fqbnWithConfig] = await Promise.all([
+    getDetails(fqbn),
+    getData(fqbn),
+    appendConfigToFqbn(fqbn),
+  ]);
+  if (!details) {
+    throw new Error(noPlatformInstalledFor(board.name));
+  }
+  if (!fqbnWithConfig) {
+    throw new Error(
+      `Failed to append boards config to the FQBN. Original FQBN was: ${fqbn}`
+    );
+  }
+  if (!data.selectedProgrammer) {
+    throw new Error(noProgrammerSelectedFor(board.name));
+  }
+  const params = {
+    fqbn: fqbnWithConfig,
+    programmer: data.selectedProgrammer.id,
+  };
+  try {
+    const debugFqbn = await checkDebugEnabled(params);
+    return debugFqbn;
+  } catch (err) {
+    throw new Error(debuggingNotSupported(board.name));
+  }
+}
+
+/**
+ * (non-API)
+ */
+export function sketchIsNotCompiled(sketchName: string): string {
+  return nls.localize(
+    'arduino/debug/sketchIsNotCompiled',
+    "Sketch '{0}' must be verified before starting a debug session. Please verify the sketch and start debugging again. Do you want to verify the sketch now?",
+    sketchName
+  );
+}
+/**
+ * (non-API)
+ */
+export function noPlatformInstalledFor(boardName: string): string {
+  return nls.localize(
+    'arduino/debug/noPlatformInstalledFor',
+    "Platform is not installed for '{0}'",
+    boardName
+  );
+}
+/**
+ * (non-API)
+ */
+export function debuggingNotSupported(boardName: string): string {
+  return nls.localize(
+    'arduino/debug/debuggingNotSupported',
+    "Debugging is not supported by '{0}'",
+    boardName
+  );
+}
+/**
+ * (non-API)
+ */
+export function noProgrammerSelectedFor(boardName: string): string {
+  return nls.localize(
+    'arduino/debug/noProgrammerSelectedFor',
+    "No programmer selected for '{0}'",
+    boardName
+  );
+}