Merge branch 'main' into update-node-version

Author: soumeh01

src/generic/text-file.factory.ts

@@ -39,4 +39,6 @@ export const textFileFactory = makeFactory<ITextFile, IErrorList>({
     clear: () => jest.fn(),
     exists: () => jest.fn(),
     unlink: () => jest.fn(),
+    hasExternalFileChanged: () => jest.fn().mockReturnValue(false),
+    refreshExternalFileStamp: () => jest.fn(),
 }, errorListFactory);

src/generic/text-file.test.ts

@@ -370,4 +370,32 @@ describe('TextFile', () => {
 
         testDataHandler.rmDir(unicodeDir);
     });
+
+    it('primes external stamp when checked before load/save', async () => {
+        fsUtils.writeTextFile(TEST_FILE, initialContent);
+        const tf = new TextFile(TEST_FILE);
+
+        expect(tf.hasExternalFileChanged()).toBe(false);
+
+        fsUtils.writeTextFile(TEST_FILE, `${changedContent}!`);
+        await new Promise(resolve => setTimeout(resolve, 500));
+
+        expect(tf.hasExternalFileChanged()).toBe(true);
+    });
+
+    it('detects external on-disk updates and then re-baselines', async () => {
+        const tf = new TextFile(TEST_FILE);
+        tf.text = initialContent;
+        const saveResult = await tf.save();
+        expect(saveResult).toBe(ETextFileResult.Success);
+
+        tf.refreshExternalFileStamp();
+        expect(tf.hasExternalFileChanged()).toBe(false);
+
+        fsUtils.writeTextFile(TEST_FILE, `${changedContent}!`);
+        await new Promise(resolve => setTimeout(resolve, 500));
+
+        expect(tf.hasExternalFileChanged()).toBe(true);
+        expect(tf.hasExternalFileChanged()).toBe(false);
+    });
 });

src/generic/text-file.ts

@@ -15,6 +15,7 @@
  */
 
 import path from 'node:path';
+import * as fs from 'node:fs';
 import * as fsUtils from '../utils/fs-utils';
 import * as vscodeUtils from '../utils/vscode-utils';
 import { ITextParser } from './text-parser';
@@ -40,6 +41,12 @@ export enum ETextFileResult {
     NotExists = 3
 }
 
+type ExternalFileStamp = {
+    path: string;
+    mtimeMs: number;
+    size: number;
+};
+
 /**
  * Represents a text file with parsing, rendering, and error handling capabilities.
  * Provides methods and properties for managing file content, file metadata, and associated parsers/renderers.
@@ -170,6 +177,16 @@ export interface ITextFile extends IErrorList {
     /** Clears file content and errors */
     clear(): void;
 
+    /**
+     * Refreshes the stored external file stamp baseline.
+     */
+    refreshExternalFileStamp(): void;
+
+    /**
+     * Checks whether the file changed externally since the last stamp refresh/check.
+     */
+    hasExternalFileChanged(): boolean;
+
     /** Copy text and parse it to the object, does not change filename
      * @param src source file
      */
@@ -194,6 +211,7 @@ export class TextFile extends ErrorList implements ITextFile {
     protected textRenderer?: ITextRenderer;
 
     private _readOnly = false;
+    private externalFileStamp?: ExternalFileStamp;
 
     /**
      * Constructs a TextFile instance
@@ -243,6 +261,7 @@ export class TextFile extends ErrorList implements ITextFile {
         this._dirty = false;
         this.contentString = '';
         this.contentObject = undefined;
+        this.externalFileStamp = undefined;
         this.clearErrors();
     }
 
@@ -285,6 +304,7 @@ export class TextFile extends ErrorList implements ITextFile {
         if (value !== this._fileName) {
             this._fileName = value;
             this._fileDir = path.dirname(value);
+            this.externalFileStamp = undefined;
         }
     }
 
@@ -360,6 +380,7 @@ export class TextFile extends ErrorList implements ITextFile {
             this.fileName = fileName;
         }
         const result = this.doLoad();
+        this.refreshExternalFileStamp();
         this.showErrorMessage(result);
         return result;
     }
@@ -402,10 +423,47 @@ export class TextFile extends ErrorList implements ITextFile {
             this._dirty = true; // force saving
         }
         const result = this.doSave();
+        this.refreshExternalFileStamp();
         this.showErrorMessage(result);
         return result;
     }
 
+    private getCurrentFileStamp(): ExternalFileStamp | undefined {
+        if (!this.fileName || !fsUtils.fileExists(this.fileName)) {
+            return undefined;
+        }
+        try {
+            const stat = fs.statSync(this.fileName);
+            return {
+                path: this.fileName,
+                mtimeMs: stat.mtimeMs,
+                size: stat.size,
+            };
+        } catch {
+            return undefined;
+        }
+    }
+
+    public refreshExternalFileStamp(): void {
+        this.externalFileStamp = this.getCurrentFileStamp();
+    }
+
+    public hasExternalFileChanged(): boolean {
+        const currentStamp = this.getCurrentFileStamp();
+        if (!this.externalFileStamp) {
+            this.externalFileStamp = currentStamp;
+            return false;
+        }
+
+        const changed = !currentStamp
+            || currentStamp.path !== this.externalFileStamp.path
+            || currentStamp.mtimeMs !== this.externalFileStamp.mtimeMs
+            || currentStamp.size !== this.externalFileStamp.size;
+
+        this.externalFileStamp = currentStamp;
+        return changed;
+    }
+
     /**
      * Saves file content to disk
      * @returns Save result

src/views/manage-solution/manage-solution-controller.test.ts

@@ -145,6 +145,28 @@ describe('manage-solution-controller', () => {
         expect(controller.activeTargetTypeName).toBe(initialName);
     });
 
+    it('should recover from persisted empty active target type using first known target', async () => {
+        const controller = new ManageSolutionController();
+        await controller.loadSolution('test-resources/solutions/solution-with-debuggers.csolution');
+
+        controller.activeTargetTypeName = '';
+        const updated = await controller.ensureActiveTargetTypeName();
+
+        expect(updated).toBe(true);
+        expect(controller.activeTargetTypeName).toBe(controller.solutionData.targets[0].name);
+    });
+
+    it('should clear persisted invalid active target type when no target types are available', async () => {
+        const controller = new ManageSolutionController();
+        await controller.loadSolution('test-resources/solutions/solution-with-debuggers.csolution');
+
+        controller.activeTargetTypeName = 'invalid-target';
+        const updated = await controller['ensureActiveTargetTypeNameInKnownTargets']([]);
+
+        expect(updated).toBe(true);
+        expect(controller.cmsisJsonFile.activeTargetTypeName).toBeUndefined();
+    });
+
     it('should get active target set name', async () => {
         const controller = new ManageSolutionController();
         await controller.loadSolution('test-resources/solutions/solution-with-debuggers.csolution');