Reload active solution when used dbgconf files change (#382)

* Reload active solution when used dbgconf files change

Watch dbgconf changes and resolve referenced dbgconf paths from cbuild files.
Only files used by the active solution trigger reloads, avoiding unnecessary
converts for unrelated debugger configs.

* Remove unused pattern from test

* fix test

* Update src/solutions/solution-manager.ts

Co-authored-by: Daniel Brondani <daniel.brondani@arm.com>

* remove and ignore .cmsis-dev files

---------

Co-authored-by: Daniel Brondani <daniel.brondani@arm.com>

Author: edriouk

.gitignore

@@ -42,4 +42,5 @@ test-results/**
 tools
 guide
 schemas
-src/json-rpc/interface/*
+src/json-rpc/interface/*
+.cmsis-dev

src/solutions/active-solution-tracker.test.ts

@@ -15,7 +15,13 @@
  */
 
 import 'jest';
-import { ActiveSolutionTrackerImpl, COMMAND_ACTIVATE_SOLUTION, COMMAND_DEACTIVATE_SOLUTION, solutionFileWatchPattern } from './active-solution-tracker';
+import {
+    ActiveSolutionTrackerImpl,
+    COMMAND_ACTIVATE_SOLUTION,
+    COMMAND_DEACTIVATE_SOLUTION,
+    dbgconfFileWatchPattern,
+    solutionFileWatchPattern,
+} from './active-solution-tracker';
 import * as vscode from 'vscode';
 import { WorkspaceFolder } from 'vscode';
 import { URI } from 'vscode-uri';
@@ -611,6 +617,7 @@ describe('ActiveSolutionTracker solution file watching', () => {
 
     it('registers a file watcher on activation', () => {
         expect(fileWatcherProvider.watchFiles).toHaveBeenCalledWith(solutionFileWatchPattern, expect.any(Object), expect.anything());
+        expect(fileWatcherProvider.watchFiles).toHaveBeenCalledWith(dbgconfFileWatchPattern, expect.any(Object), expect.anything());
     });
 
     it('fires onActiveSolutionFilesChanged when the csolution file is modified', async () => {
@@ -636,6 +643,22 @@ describe('ActiveSolutionTracker solution file watching', () => {
         expect(changeListener).toHaveBeenCalledWith(packFile);
     });
 
+    it('fires onActiveSolutionFilesChanged when a dbgconf file is modified', async () => {
+        const dbgconfFile = path.join(solutionRoot, 'DebugConfig', 'My.dbgconf');
+        fileWatcherProvider.mockFireEvent(dbgconfFileWatchPattern, dbgconfFile, 'change');
+
+        expect(changeListener).toHaveBeenCalledTimes(1);
+        expect(changeListener).toHaveBeenCalledWith(dbgconfFile);
+    });
+
+    it('fires onActiveSolutionFilesChanged when a dbgconf file in .cmsis is modified', async () => {
+        const dbgconfFile = path.join(solutionRoot, '.cmsis', 'My.dbgconf');
+        fileWatcherProvider.mockFireEvent(dbgconfFileWatchPattern, dbgconfFile, 'change');
+
+        expect(changeListener).toHaveBeenCalledTimes(1);
+        expect(changeListener).toHaveBeenCalledWith(dbgconfFile);
+    });
+
     it('fires onActiveSolutionFilesChanged when an inactive csolution file is modified', async () => {
         const inactiveSolution = path.join(__dirname, 'another-solution', 'NotMy.csolution.yaml');
         fileWatcherProvider.mockFireEvent(solutionFileWatchPattern, inactiveSolution, 'change');

src/solutions/active-solution-tracker.ts

@@ -34,11 +34,11 @@ export const COMMAND_GET_SOLUTION_FILE = `${manifest.PACKAGE_NAME}.getSolutionFi
 /** @deprecated */
 export const COMMAND_GET_SOLUTION_PATH = `${manifest.PACKAGE_NAME}.getSolutionPath`;
 
-
 // this pattern covers csolution, project, layer and global generator files
 export const solutionFileWatchPattern =
     '**/{cdefault,*.csolution,*.cproject,*.clayer,*.cgen}.{yaml,yml}';
 
+export const dbgconfFileWatchPattern = '**/*.dbgconf';
 
 interface SolutionDetails {
     displayName: string;
@@ -57,7 +57,7 @@ export interface ActiveSolutionTracker {
     readonly onDidChangeActiveSolution: vscode.Event<void>;
 
     /**
-     * Event fired when a watched solution YAML file changes.
+     * Event fired when a watched solution-related file changes.
      */
     readonly onActiveSolutionFilesChanged: vscode.Event<string>;
 
@@ -121,6 +121,9 @@ export class ActiveSolutionTrackerImpl implements ActiveSolutionTracker {
                 onChange: this.handleActiveSolutionFileChange,
                 onCreate: this.handleActiveSolutionFileChange,
             }, this),
+            this.fileWatcherProvider.watchFiles(dbgconfFileWatchPattern, {
+                onChange: this.handleActiveSolutionFileChange,
+            }, this),
             this.commandsProvider.registerCommand(COMMAND_OPEN_SOLUTION, this.handleActivateSolution, this),
             this.commandsProvider.registerCommand(COMMAND_ACTIVATE_SOLUTION, this.handleActivateSolution, this),
             this.commandsProvider.registerCommand(COMMAND_DEACTIVATE_SOLUTION, this.handleDeactivateSolution, this),

src/solutions/csolution.test.ts

@@ -718,4 +718,41 @@ describe('CSolution', () => {
             expect(files).toHaveLength(1 + projectPaths.length + layerPaths.length);
         });
     });
+
+    describe('getUsedDbgconfFiles', () => {
+        it('returns empty list when no solution is loaded', () => {
+            const csolution = new CSolution();
+
+            expect(csolution.getUsedDbgconfFiles()).toEqual([]);
+        });
+
+        it('returns deduplicated absolute dbgconf paths from cbuild files', async () => {
+            const csolution = new CSolution();
+            const fileName = path.join(testDataHandler.tmpDir, 'solutions', 'WestSupport', 'solution.csolution.yml');
+
+            await csolution.load(fileName);
+
+            expect(csolution.getUsedDbgconfFiles()).toEqual([
+                path.join(testDataHandler.tmpDir, 'solutions', 'WestSupport', '.cmsis', 'solution+CM0.dbgconf'),
+            ]);
+        });
+
+        it('returns all dbgconf file entries from a cbuild file', () => {
+            const csolution = new CSolution();
+            const cbuildPath = path.join(testDataHandler.tmpDir, 'solutions', 'multiple-dbgconf.cbuild.yml');
+            csolution.cbuildYmlRoot.set(cbuildPath, parseYamlToCTreeItem(YAML.stringify({
+                build: {
+                    dbgconf: [
+                        { file: 'first.dbgconf' },
+                        { file: 'debug/second.dbgconf' },
+                    ],
+                },
+            }), cbuildPath) as CTreeItem);
+
+            expect(csolution.getUsedDbgconfFiles()).toEqual([
+                path.join(testDataHandler.tmpDir, 'solutions', 'first.dbgconf'),
+                path.join(testDataHandler.tmpDir, 'solutions', 'debug', 'second.dbgconf'),
+            ]);
+        });
+    });
 });

src/solutions/csolution.ts

@@ -87,6 +87,26 @@ export class CSolution {
         return ymlFiles;
     }
 
+    public getUsedDbgconfFiles(): string[] {
+        const dbgconfFiles: string[] = [];
+        const seen = new Set<string>();
+
+        for (const cbuild of this.cbuildYmlRoot.values()) {
+            for (const dbgConfigFile of cbuild.getChildItem()?.getGrandChildren('dbgconf') ?? []) {
+                const fileName = dbgConfigFile.getValue('file');
+                if (!fileName) {
+                    continue;
+                }
+                const filePath = cbuild.resolvePath(fileName);
+                if (!seen.has(filePath)) {
+                    seen.add(filePath);
+                    dbgconfFiles.push(filePath);
+                }
+            }
+        }
+        return dbgconfFiles;
+    }
+
     cbuildPackFile = new CbuildPackFile();
 
     cbuilds?: ITreeItem<CTreeItem>[];

src/solutions/solution-manager.test.ts

@@ -316,6 +316,42 @@ describe('SolutionManager', () => {
         );
     });
 
+    it('reloads the solution when a changed dbgconf file is used by the active solution', async () => {
+        await activateTestSolution();
+        const dbgconfPath = path.join(path.dirname(testSolutionPath), '.cmsis', 'Used.Debug+B-U585I-IOT02A.dbgconf');
+        jest.spyOn(solutionManager.getCsolution()!, 'getUsedDbgconfFiles').mockReturnValue([dbgconfPath]);
+        convertMock.mockClear();
+        loadBuildFilesListener.mockClear();
+
+        changeSolutionFilesEmitter.fire(dbgconfPath);
+        await waitTimeout(100);
+
+        expect(convertMock).toHaveBeenCalledTimes(1);
+        expect(convertMock).toHaveBeenCalledWith(
+            expect.objectContaining({
+                solutionPath: testSolutionPath,
+                updateRte: true,
+                restartRpc: false,
+                lockAbort: false,
+            }),
+        );
+        expect(loadBuildFilesListener).toHaveBeenCalledTimes(1);
+    });
+
+    it('does not reload when a changed dbgconf file is not used by the active solution', async () => {
+        await activateTestSolution();
+        const dbgconfPath = path.join(path.dirname(testSolutionPath), '.cmsis', 'Inactive.Debug+B-U585I-IOT02A.dbgconf');
+        jest.spyOn(solutionManager.getCsolution()!, 'getUsedDbgconfFiles').mockReturnValue([
+            path.join(path.dirname(testSolutionPath), '.cmsis', 'Used.Debug+B-U585I-IOT02A.dbgconf'),
+        ]);
+        convertMock.mockClear();
+
+        changeSolutionFilesEmitter.fire(dbgconfPath);
+        await waitTimeout(100);
+
+        expect(convertMock).not.toHaveBeenCalled();
+    });
+
     it('does not reload for a watched YAML file inside the solution directory when it is not in the active solution model', async () => {
         await activateTestSolution();
         const unrelatedProjectPath = path.join(path.dirname(testSolutionPath), 'Unrelated.cproject.yml');

src/solutions/solution-manager.ts

@@ -180,7 +180,10 @@ export class SolutionManagerImpl implements SolutionManager {
 
     private handleActiveSolutionFilesChanged(changedPath: string): void {
         const solutionFiles = this.csolution?.getSolutionYmlFiles();
-        if (!solutionFiles?.some(solutionFile => pathsEqual(solutionFile, changedPath))) {
+        const isSolutionYmlFile = solutionFiles?.some(solutionFile => pathsEqual(solutionFile, changedPath));
+        const isUsedDbgconfFile = changedPath.toLowerCase().endsWith('.dbgconf')
+            && this.csolution?.getUsedDbgconfFiles().some(dbgconfFile => pathsEqual(dbgconfFile, changedPath));
+        if (!isSolutionYmlFile && !isUsedDbgconfFile) {
             return;
         }
         this.debouncedHandleActiveSolutionFileChange();