Merge branch 'main' into update-node-version

Author: edriouk

src/desktop/extension.ts

@@ -248,7 +248,7 @@ export const activate = async (context: ExtensionContext): Promise<CsolutionExte
     const cmsisCommands = new CmsisCommands(configurationProvider, commandsProvider, solutionManager, debugProvider, serialMonitorExtension);
     const buildStopCommand = new BuildStopCommand(commandsProvider, buildTaskProvider);
     const configurationWizardView = new ConfWizWebview(context);
-    const solutionLanguageFeatures = new SolutionLanguageFeaturesProvider();
+    const solutionLanguageFeatures = new SolutionLanguageFeaturesProvider(solutionManager);
     const packInstallCommands = new PackInstallCommands(commandsProvider, cmsisToolboxManager, outputChannelProvider);
     const protocolHandler = new ProtocolHandler(cmsisToolboxManager, outputChannelProvider);
 

src/generic/tree-item-yaml-parser.test.ts

@@ -59,6 +59,15 @@ describe('parseYamlToCTreeItem', () => {
         expect(yamlString).toEqual('scalar\n');
     });
 
+    it('stores scalar range as start and value-end offsets', async () => {
+        const input = 'key: value\n';
+        const root = parseYamlToCTreeItem(input, './dummyFile');
+        const valueNode = root?.getChild('key');
+
+        expect(valueNode).toBeDefined();
+        expect(valueNode?.range).toEqual([5, 10]);
+    });
+
     it('test parseYamlToCTreeItem parsing sequence', async () => {
         const prime = dedent`
         # document comment

src/generic/tree-item-yaml-parser.ts

@@ -131,6 +131,9 @@ export class GenericTreeItemYamlParser<T extends ITreeItem<T>> extends GenericTr
     protected parseScalar(node: YAML.Scalar, treeItem: ITreeItem<T>): void {
         treeItem.setProperty('scalarType', node.type);
         treeItem.setKind(ETreeItemKind.Scalar);
+        if (node.range) {
+            treeItem.range = [node.range[0], node.range[1]];
+        }
         if (node.value !== null && node.value !== undefined) {
             const text = node.source ? node.source : node.toString();
             treeItem.setText(text);

src/generic/tree-item.test.ts

@@ -126,6 +126,33 @@ describe('CTreeItem', () => {
         expect(data.getKind()).toEqual(ETreeItemKind.Scalar);
     });
 
+    it('stores and retrieves range via range get/set', () => {
+        const item = new CTreeItem('root');
+        const range: [number, number] = [1, 4];
+
+        expect(item.range).toBeUndefined();
+
+        item.range = range;
+        expect(item.range).toEqual([1, 4]);
+
+        item.range = undefined;
+        expect(item.range).toBeUndefined();
+    });
+
+    it('filters items across the entire tree using a predicate', () => {
+        const root = new CTreeItem('root');
+        root.createChild('group').createChild('file').setText('first.txt');
+        root.getChild('group')?.createChild('nested')?.createChild('file').setText('second.txt');
+        root.createChild('file').setText('third.txt');
+        root.createChild('other').setText('ignore.txt');
+
+        const fileTexts = root
+            .filterItems(item => item.getTag() === 'file')
+            .map(item => item.getText());
+
+        expect(fileTexts).toEqual(['first.txt', 'second.txt', 'third.txt']);
+    });
+
     it('toObject converts item tree to plain object', async () => {
         const myObject = {
             'target-types': [{

src/generic/tree-item.ts

@@ -16,6 +16,7 @@
 
 import { CAttributedItem, IAttributedItem } from './attributed-item';
 
+export type SourceRange = [number, number];
 
 /** An enum to describe ITreeItem kind */
 export enum ETreeItemKind {
@@ -58,6 +59,12 @@ export interface ITreeItem<T extends ITreeItem<T>> extends IAttributedItem {
      */
     get isPlain(): boolean;
 
+    /** Returns the item's source range if assigned */
+    get range(): SourceRange | undefined;
+
+    /** Sets or clears the item's source range */
+    set range(range: SourceRange | undefined);
+
     /** Returns item's parent matching tag
      * @param tag optional parent's tag
      * @returns parent item or undefined
@@ -197,6 +204,13 @@ export interface ITreeItem<T extends ITreeItem<T>> extends IAttributedItem {
     */
     childAtIndex(index: number): ITreeItem<T> | undefined;
 
+    /**
+     * Traverses this item and all descendants depth-first and returns items matching the predicate.
+     * @param predicate match function applied to each visited item, including this item
+     * @returns array of matching items in depth-first order
+     */
+    filterItems(predicate: (item: ITreeItem<T>) => boolean): ITreeItem<T>[];
+
     /**
      * Adds a child and returns the supplied item
      * @param c child to add
@@ -398,6 +412,14 @@ export class GenericTreeItem<T extends GenericTreeItem<T>> extends CAttributedIt
         return this;
     }
 
+    get range(): SourceRange | undefined {
+        return this.getProperty('range') as SourceRange | undefined;
+    }
+
+    set range(range: SourceRange | undefined) {
+        this.setProperty('range', range);
+    }
+
     getKind(): ETreeItemKind {
         let kind = this.data.kind as ETreeItemKind;
         if (kind) {
@@ -576,6 +598,21 @@ export class GenericTreeItem<T extends GenericTreeItem<T>> extends CAttributedIt
         return this.getChildren().at(index);
     }
 
+    filterItems(predicate: (item: ITreeItem<T>) => boolean): ITreeItem<T>[] {
+        const matches: ITreeItem<T>[] = [];
+        const visit = (item: ITreeItem<T>) => {
+            if (predicate(item)) {
+                matches.push(item);
+            }
+            for (const child of item.getChildren()) {
+                visit(child);
+            }
+        };
+
+        visit(this);
+        return matches;
+    }
+
     findChild(tags: string[]): ITreeItem<T> | undefined {
         let c: ITreeItem<T> | undefined = this;
         for (const tag of tags) {

src/solutions/language-features/reference-link-provider.test.ts

@@ -16,11 +16,13 @@
 
 import 'jest';
 import { textDocumentFactory } from '../../vscode-api/text-document.factories';
-import { createReferenceLinkProvider } from './reference-link-provider';
+import { ReferenceLinkProvider } from './reference-link-provider';
 import { URI as Uri, Utils as UriUtils } from 'vscode-uri';
 import * as path from 'path';
+import { solutionManagerFactory } from '../solution-manager.factories';
+import { SolutionRpcDataMock } from '../solution-rpc-data.factory';
 
-describe('createReferenceLinkProvider', () => {
+describe('ReferenceLinkProvider', () => {
     it('returns no links if the document cannot be parsed', () => {
         const unparsableDoc = `
             notMe:
@@ -33,30 +35,41 @@ describe('createReferenceLinkProvider', () => {
         const textDocument = textDocumentFactory();
         textDocument.getText.mockReturnValue(unparsableDoc);
 
-        const provider = createReferenceLinkProvider({ referenceNode: 'sublayer', parentNode: 'layer', listNode: 'sublayers' });
+        const provider = new ReferenceLinkProvider(solutionManagerFactory());
         const output = provider.provideDocumentLinks(textDocument, { isCancellationRequested: false, onCancellationRequested: jest.fn() });
 
         expect(output).toEqual([]);
     });
 
     it('returns links for link nodes that can be parsed', () => {
         const parsableDoc = `
-            layer:
-                sublayers:
-                    - sublayer: ./file1.sublayer.yml
-                    - sublayer: ./file2.sublayer.yml
+            project:
+                files:
+                    - file: ./file1.c
+                linker:
+                    - script: ./my.sct
+                layers:
+                    - layer: ./$Board-layer$
         `;
 
-        const documentUri = Uri.file(path.join(__dirname, 'my.clayer.yml'));
-        const textDocument = textDocumentFactory({ uri: documentUri });
+        const documentFileName = path.join(__dirname, 'my.cproject.yml');
+        const documentUri = Uri.file(documentFileName);
+        const textDocument = textDocumentFactory({ uri: documentUri, fileName: documentFileName });
         textDocument.getText.mockReturnValue(parsableDoc);
 
-        const provider = createReferenceLinkProvider({ referenceNode: 'sublayer', parentNode: 'layer', listNode: 'sublayers' });
+        const solutionManager = solutionManagerFactory();
+        const csolution = solutionManager.getCsolution();
+        jest.spyOn(csolution!, 'actionContext', 'get').mockReturnValue('my.Build+Target');
+        const rpcData = solutionManager.getRpcData() as SolutionRpcDataMock;
+        rpcData.seedVariables('my.Build+Target', { 'Board-layer': 'mylayer.clayer.yml' });
+
+        const provider = new ReferenceLinkProvider(solutionManager);
         const output = provider.provideDocumentLinks(textDocument, { isCancellationRequested: false, onCancellationRequested: jest.fn() });
 
         expect(output).toEqual([
-            expect.objectContaining({ target: UriUtils.joinPath(documentUri, '../file1.sublayer.yml') }),
-            expect.objectContaining({ target: UriUtils.joinPath(documentUri, '../file2.sublayer.yml') }),
+            expect.objectContaining({ target: expect.objectContaining({ fsPath: UriUtils.joinPath(documentUri, '../file1.c').fsPath }) }),
+            expect.objectContaining({ target: expect.objectContaining({ fsPath: UriUtils.joinPath(documentUri, '../my.sct').fsPath }) }),
+            expect.objectContaining({ target: expect.objectContaining({ fsPath: UriUtils.joinPath(documentUri, '../mylayer.clayer.yml').fsPath }) }),
         ]);
     });
 });

src/solutions/language-features/reference-link-provider.ts

@@ -14,65 +14,95 @@
  * limitations under the License.
  */
 
-import * as YAML from 'yaml';
-import { DocumentLink, DocumentLinkProvider, TextDocument, Uri } from 'vscode';
-import { readMapFromMap, readSeqFromMap, requireMap } from '../parsing/yaml-file-parsing';
-import { rangeFromYamlNode } from './yaml-range';
+import { CancellationToken, DocumentLink, DocumentLinkProvider, Range, TextDocument, Uri } from 'vscode';
+import { parseYamlToCTreeItem } from '../../generic/tree-item-yaml-parser';
+import { CTreeItem, ETreeItemKind, ITreeItem } from '../../generic/tree-item';
+import type { SolutionManager } from '../solution-manager';
 
-export type ReferenceLinkProviderOptions = {
-    /**
-     * Name of the root node for the YAML file, e.g., solution.
-     */
-    parentNode: string;
+/**
+ * Provide links for file references in solution and project files.
+ */
+export class ReferenceLinkProvider implements DocumentLinkProvider<DocumentLink> {
+    constructor(
+        private readonly solutionManager: SolutionManager,
+    ) {
+    }
 
-    /**
-     * Name of the node containing the list of linkable references, e.g., projects.
-     */
-    listNode: string;
+    public provideDocumentLinks(textDocument: TextDocument, _token?: CancellationToken): DocumentLink[] {
+        try {
+            const topItem = parseYamlToCTreeItem(textDocument.getText(), textDocument.fileName);
 
-    /**
-     * Name of the node on the linkable reference, e.g., project.
-     */
-    referenceNode: string;
-}
+            return (topItem?.filterItems(item => this.isReferenceFileItem(item)) ?? [])?.flatMap((item): DocumentLink[] => {
+                const documentLink = this.treeItemToDocumentLink(item, textDocument);
+                return documentLink ? [documentLink] : [];
+            }) ?? [];
+        } catch {
+            // If we can't parse the document, we can't provide links
+            return [];
+        }
+    }
 
-const projectNodeToDocumentLink = (
-    textDocument: TextDocument,
-    options: ReferenceLinkProviderOptions,
-    projectNode: YAML.YAMLMap,
-): DocumentLink | undefined => {
-    const projectScalar = projectNode.get(options.referenceNode, true);
+    public resolveDocumentLink(link: DocumentLink): DocumentLink {
+        return link;
+    }
 
-    if (projectScalar && typeof projectScalar.value === 'string') {
+    protected isReferenceFileItem(item: ITreeItem<CTreeItem>): item is CTreeItem {
+        const tag = item.getTag();
+        return !!tag && this.getReferenceItemTags().includes(tag);
+    }
+
+    protected getReferenceItemTags(): string[] {
+        return ['file', 'layer', 'project', 'script', 'regions'];
+    }
+
+    private treeItemToDocumentLink(item: ITreeItem<CTreeItem> | undefined, textDocument: TextDocument) : DocumentLink | undefined {
+        const uri = this.getUriFromItem(item);
+        if (!uri) {
+            return undefined;
+        }
+        const range = this.rangeFromItem(item, textDocument);
         return {
-            range: rangeFromYamlNode(textDocument, projectScalar),
-            target: Uri.joinPath(textDocument.uri, '..', projectScalar.value),
+            range,
+            target: uri,
         };
     }
 
-    return undefined;
-};
 
-/**
- * Provide links for file references in solution and project files.
- */
-export const createReferenceLinkProvider = (options: ReferenceLinkProviderOptions): DocumentLinkProvider<DocumentLink> => ({
-    provideDocumentLinks: (textDocument: TextDocument): DocumentLink[] => {
-        try {
-            const yamlDocument = YAML.parseDocument(textDocument.getText());
-            const root = requireMap(yamlDocument.contents);
-            const parent = readMapFromMap(options.parentNode)(root);
-            const list = readSeqFromMap(options.listNode)(parent);
-            const itemMaps = list.items.filter(YAML.isMap);
+    private getUriFromItem(item?: ITreeItem<CTreeItem>): Uri | undefined {
+        if (!item || item.getKind() !== ETreeItemKind.Scalar) {
+            return undefined;
+        }
+        let text = item.getText();
+        if (!text) {
+            return undefined;
+        }
+        const rpcData = this.solutionManager.getRpcData();
+        const context = this.getItemContext(item);
+        if (rpcData && context) {
+            text = rpcData.expandString(text, context);
+        }
 
-            return itemMaps.flatMap((projectNode): DocumentLink[] => {
-                const documentLink = projectNodeToDocumentLink(textDocument, options, projectNode);
-                return documentLink ? [documentLink] : [];
-            });
-        } catch {
-            // If we can't parse the document, we can't provide links
-            return [];
+        const resolvedPath = item.resolvePath(text);
+        return resolvedPath ? Uri.file(resolvedPath) : undefined;
+    }
+
+    private rangeFromItem(item: ITreeItem<CTreeItem> | undefined, textDocument: TextDocument): Range {
+        return new Range(
+            textDocument.positionAt(item?.range?.[0] ?? 0),
+            textDocument.positionAt(item?.range?.[1] ?? 0),
+        );
+    }
+
+    private getItemContext(item: ITreeItem<CTreeItem>): string | undefined {
+        const csolution = this.solutionManager.getCsolution();
+        if (!csolution) {
+            return undefined;
+        }
+        const rootFileName = item.rootFileName;
+        let context = undefined;
+        if (rootFileName.includes('.cproject.y')) {
+            context = csolution.getContextDescriptor(rootFileName)?.displayName;
         }
-    },
-    resolveDocumentLink: (link: DocumentLink): DocumentLink => link,
-});
+        return context ?? csolution.actionContext;
+    }
+}

src/solutions/language-features/solution-language-features-provider.test.ts

@@ -15,22 +15,19 @@
  */
 
 import 'jest';
-import { SolutionLanguageFeaturesProvider, projectSelectors, solutionSelectors } from './solution-language-features-provider';
-import type { DocumentLink, DocumentLinkProvider } from 'vscode';
+import { SolutionLanguageFeaturesProvider, solutionFilesSelectors } from './solution-language-features-provider';
+import { ReferenceLinkProvider } from './reference-link-provider';
+import type { SolutionManager } from '../solution-manager';
 
 describe('SolutionLanguageFeaturesProvider', () => {
-    it('registers document link providers for solution and project files on activation', async () => {
+    it('registers a document link provider for solution, project, and layer files on activation', async () => {
         const registerDocumentLinkProvider = jest.fn();
-        const provider = new SolutionLanguageFeaturesProvider({ registerDocumentLinkProvider });
+        const solutionManager = {} as SolutionManager;
+        const provider = new SolutionLanguageFeaturesProvider(solutionManager, { registerDocumentLinkProvider });
 
         await provider.activate({ subscriptions: [] });
 
-        const expectedLinkProvider: DocumentLinkProvider<DocumentLink> = {
-            resolveDocumentLink: expect.any(Function),
-            provideDocumentLinks: expect.any(Function),
-        };
-
-        expect(registerDocumentLinkProvider).toHaveBeenCalledWith(solutionSelectors, expectedLinkProvider);
-        expect(registerDocumentLinkProvider).toHaveBeenCalledWith(projectSelectors, expectedLinkProvider);
+        expect(registerDocumentLinkProvider).toHaveBeenCalledWith(solutionFilesSelectors, expect.any(ReferenceLinkProvider));
+        expect(registerDocumentLinkProvider).toHaveBeenCalledTimes(1);
     });
 });