Only show tool warning if trying to use built-in tools (#409)

* only show tool warning if trying to use built-in

---------

Signed-off-by: Jens Reinecke <jens.reinecke@arm.com>

Author: jreineckearm

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## Unreleased
+
+- Fixes [#407](https://github.com/Open-CMSIS-Pack/vscode-cmsis-debugger/issues/407): Warning pops up when using an absolute path in the launch config.
+
 ## 0.5.0
 
 - **IMPORTANT**: This release updates the [license](https://github.com/Open-CMSIS-Pack/vscode-cmsis-debugger/blob/main/LICENSE) for the CMSIS Debugger extension from `Apache License 2.0` to `Apache License 2.0 and GNU General Public License v3.0 or later`.

src/debug-configuration/gdbtarget-configuration-provider.ts

@@ -24,6 +24,7 @@ import {
     JlinkConfigurationProvider
 } from './subproviders';
 import { BuiltinToolPath } from '../desktop/builtin-tool-path';
+import { resolveToolPath } from '../desktop/tool-path-utils';
 
 const GDB_TARGET_DEBUGGER_TYPE = 'gdbtarget';
 const ARM_NONE_EABI_GDB_NAME = 'arm-none-eabi-gdb';
@@ -139,19 +140,8 @@ export class GDBTargetConfigurationProvider implements vscode.DebugConfiguration
     ): Promise<vscode.DebugConfiguration | null | undefined> {
         // Only resolve GDB path once, otherwise regexp check will fail
         logger.debug('resolveDebugConfigurationWithSubstitutedVariables: Resolve GDB path');
-        this.resolveGdbPath(debugConfiguration);
+        debugConfiguration.gdb = resolveToolPath(debugConfiguration.gdb, ARM_NONE_EABI_GDB_NAME, ARM_NONE_EABI_GDB_EXECUTABLE_ONLY_REGEXP, this.builtinArmNoneEabiGdb);
         return this.resolveDebugConfigurationByResolverType('resolveDebugConfigurationWithSubstitutedVariables', folder, debugConfiguration, token);
     }
 
-    protected resolveGdbPath(config: GDBTargetConfiguration): void {
-        const gdb = config.gdb;
-        const useBuiltin = !gdb || ARM_NONE_EABI_GDB_EXECUTABLE_ONLY_REGEXP.test(gdb);
-        const updateUri = useBuiltin ? this.builtinArmNoneEabiGdb.getAbsolutePath() : undefined;
-        if (updateUri) {
-            config.gdb = updateUri.fsPath;
-        } else {
-            vscode.window.showWarningMessage(`Cannot find ${ARM_NONE_EABI_GDB_BUILTIN_PATH} in CMSIS Debugger installation.\nUsing ${ARM_NONE_EABI_GDB_NAME} from PATH instead.`);
-        }
-    }
-
 }

src/debug-configuration/subproviders/pyocd-configuration-provider.ts

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-import * as vscode from 'vscode';
 import { BaseConfigurationProvider } from './base-configuration-provider';
 import { GDBTargetConfiguration, TargetConfiguration } from '../gdbtarget-configuration';
 import { BuiltinToolPath } from '../../desktop/builtin-tool-path';
 import { getCmsisPackRootPath } from '../../utils';
 import { logger } from '../../logger';
+import { resolveToolPath } from '../../desktop/tool-path-utils';
 
 const PYOCD_NAME = 'pyocd';
 const PYOCD_BUILTIN_PATH = 'tools/pyocd/pyocd';
@@ -33,17 +33,6 @@ const PYOCD_CLI_ARG_CBUILDRUN = '--cbuild-run';
 export class PyocdConfigurationProvider extends BaseConfigurationProvider {
     protected builtinPyocd = new BuiltinToolPath(PYOCD_BUILTIN_PATH);
 
-    protected resolveServerPath(target: TargetConfiguration): void {
-        const targetServer = target.server;
-        const useBuiltin = !targetServer || PYOCD_EXECUTABLE_ONLY_REGEXP.test(targetServer);
-        const updateUri = useBuiltin ? this.builtinPyocd.getAbsolutePath() : undefined;
-        if (updateUri) {
-            target.server = updateUri.fsPath;
-        } else {
-            vscode.window.showWarningMessage(`Cannot find ${PYOCD_BUILTIN_PATH} in CMSIS Debugger installation.\nUsing ${PYOCD_NAME} from PATH instead.`);
-        }
-    }
-
     protected resolveCmsisPackRootPath(target: TargetConfiguration): void {
         if (target.environment?.CMSIS_PACK_ROOT) {
             return;
@@ -59,7 +48,7 @@ export class PyocdConfigurationProvider extends BaseConfigurationProvider {
             return debugConfiguration;
         }
         // server
-        this.resolveServerPath(debugConfiguration.target);
+        debugConfiguration.target.server = resolveToolPath(debugConfiguration.target.server, PYOCD_NAME, PYOCD_EXECUTABLE_ONLY_REGEXP, this.builtinPyocd);
         // serverParameters
         debugConfiguration.target.serverParameters ??= [];
         const parameters = debugConfiguration.target.serverParameters;

src/desktop/builtin-tool-path.ts

@@ -22,7 +22,7 @@ import { isWindows } from '../utils';
 import assert from 'assert';
 
 export class BuiltinToolPath {
-    constructor(protected toolPath: string) {
+    constructor(public readonly toolPath: string) {
         assert(toolPath.length, 'BuiltinToolManager: \'toolPath\' must not be empty');
     }
 

src/desktop/tool-path-utils.ts

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2025 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as vscode from 'vscode';
+import { BuiltinToolPath } from './builtin-tool-path';
+
+export const resolveToolPath = (toolpath: string | undefined, toolName: string, toolRegexp: RegExp, builtInTool: BuiltinToolPath): string => {
+    const useBuiltin = !toolpath || toolRegexp.test(toolpath);
+    if (!useBuiltin) {
+        // Leave as is
+        return toolpath;
+    }
+    const updateUri = builtInTool.getAbsolutePath();
+    if (!updateUri) {
+        const warnMessage =
+            `Cannot find './${builtInTool.toolPath}' in CMSIS Debugger extension installation.\n`
+            + `Using '${toolName}' from PATH instead.`;
+        vscode.window.showWarningMessage(warnMessage);
+        return toolName;
+    }
+    return updateUri.fsPath;
+};