@reqlan/language 1.7.0 → 1.8.2

package/src/reqlan-completion-provider.ts

@@ -6,10 +6,12 @@
  * rq:["../../../reqlan rq/extension/features-syntax-highlighting.rq".reference_code_completion_sequencing]
  * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_code_completion]
  * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_code_completion_ranking]
+ * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_code_completion_rendering]
+ * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_code_completion_auto_file_import]
  * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".anonymous_reference_code_completion]
  */
 import type { AstNode, AstNodeDescription, FileSystemProvider, LangiumDocument, LangiumDocuments } from 'langium';
-import { AstUtils, stream } from 'langium';
+import { AstUtils, UriUtils, stream } from 'langium';
 import type { MaybePromise } from 'langium';
 import {
     DefaultCompletionProvider,
@@ -18,7 +20,7 @@ import {
     type CompletionProviderOptions
 } from 'langium/lsp';
 import { reqlanStringDelimiter } from './reqlan-quoted-strings.js';
-import type { CompletionList, CompletionParams } from 'vscode-languageserver';
+import type { CompletionItem, CompletionList, CompletionParams } from 'vscode-languageserver';
 import { CompletionItemKind, CompletionList as LspCompletionList } from 'vscode-languageserver';
 import {
     isAttribute,
@@ -39,6 +41,7 @@ import {
     getCompletionSite,
     getReferencePrefixContext
 } from './reqlan-completion-context.js';
+import { buildFromImportEdit, relativeRqImportPath } from './reqlan-import-edits.js';
 import {
     collectPathCompletionCandidates,
     comparePathCompletionCandidates,
@@ -51,6 +54,12 @@ import { referenceIdea } from './reqlan-references.js';
 import { collectWorkspaceAttributeCatalog } from './reqlan-workspace-attribute-catalog.js';
 import type { ReqlanServices } from './reqlan-module.js';
 
+type ReferenceCompletionCandidate = {
+    name: string;
+    document: LangiumDocument;
+    importable: boolean;
+};
+
 const UNREACHABLE_DISTANCE = 9999;
 
 export class ReqlanCompletionProvider extends DefaultCompletionProvider {
@@ -194,47 +203,92 @@ export class ReqlanCompletionProvider extends DefaultCompletionProvider {
         if (!context) {
             return LspCompletionList.create([], true);
         }
-        const names = new Set<string>();
         const docs = this.documents.all.toArray();
-        if (!docs.some(doc => doc.uri.toString() === document.uri.toString())) {
+        if (!docs.some(doc => UriUtils.equals(doc.uri, document.uri))) {
             docs.push(document);
         }
+        const candidates = this.collectReferenceCompletionCandidates(docs, context.prefix);
+        const center = findContainingIdea(document, params.position)?.name;
+        const distances = center
+            ? hopDistancesFromCenter(center, buildIdeaReferenceAdjacency(docs))
+            : new Map<string, number>();
+        const items = candidates.map(candidate =>
+            this.toReferenceCompletionItem(document, candidate, context, distances)
+        ).sort((left, right) => {
+            const leftDistance = distances.get(String(left.label)) ?? UNREACHABLE_DISTANCE;
+            const rightDistance = distances.get(String(right.label)) ?? UNREACHABLE_DISTANCE;
+            return leftDistance - rightDistance
+                || String(left.label).localeCompare(String(right.label))
+                || String(left.detail ?? '').localeCompare(String(right.detail ?? ''));
+        });
+        return LspCompletionList.create(items, true);
+    }
+
+    /** Collect named ideas/ideasets across loaded documents for bracket/wikilink completion. */
+    private collectReferenceCompletionCandidates(
+        docs: LangiumDocument[],
+        prefix: string
+    ): ReferenceCompletionCandidate[] {
+        const byKey = new Map<string, ReferenceCompletionCandidate>();
         for (const doc of docs) {
             const model = doc.parseResult.value;
             if (!isModel(model)) {
                 continue;
             }
             for (const element of model.elements) {
-                if (isIdea(element) || isOneLinerIdea(element) || isIdeaSet(element)) {
-                    names.add(element.name);
+                const importable = isIdea(element) || isOneLinerIdea(element);
+                if (!importable && !isIdeaSet(element)) {
+                    continue;
+                }
+                if (prefix && !element.name.startsWith(prefix)) {
+                    continue;
+                }
+                const key = `${doc.uri.toString()}::${element.name}`;
+                if (!byKey.has(key)) {
+                    byKey.set(key, { name: element.name, document: doc, importable });
                 }
             }
         }
-        const center = findContainingIdea(document, params.position)?.name;
-        const distances = center
-            ? hopDistancesFromCenter(center, buildIdeaReferenceAdjacency(docs))
-            : new Map<string, number>();
-        const items = [...names].flatMap(name => {
-            if (context.prefix && !name.startsWith(context.prefix)) {
-                return [];
-            }
-            const distance = distances.get(name) ?? UNREACHABLE_DISTANCE;
-            return [{
-                label: name,
-                kind: CompletionItemKind.Reference,
-                insertText: name,
-                sortText: `${String(distance).padStart(4, '0')}_${name}`,
+        return [...byKey.values()];
+    }
+
+    /**
+     * Cross-file idea completions show their import path and may insert a from-import.
+     * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_code_completion_rendering]
+     * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_code_completion_auto_file_import]
+     */
+    private toReferenceCompletionItem(
+        document: LangiumDocument,
+        candidate: ReferenceCompletionCandidate,
+        context: NonNullable<ReturnType<typeof getReferencePrefixContext>>,
+        distances: Map<string, number>
+    ): CompletionItem {
+        const sameFile = UriUtils.equals(candidate.document.uri, document.uri);
+        const distance = distances.get(candidate.name) ?? UNREACHABLE_DISTANCE;
+        const item: CompletionItem = {
+            label: candidate.name,
+            kind: CompletionItemKind.Reference,
+            sortText: `${String(distance).padStart(4, '0')}_${candidate.name}`,
+            textEdit: {
+                newText: candidate.name,
                 range: {
                     start: context.replaceStart,
                     end: context.replaceEnd
                 }
-            }];
-        }).sort((left, right) => {
-            const leftDistance = distances.get(String(left.label)) ?? UNREACHABLE_DISTANCE;
-            const rightDistance = distances.get(String(right.label)) ?? UNREACHABLE_DISTANCE;
-            return leftDistance - rightDistance || String(left.label).localeCompare(String(right.label));
-        });
-        return LspCompletionList.create(items, true);
+            }
+        };
+        if (sameFile) {
+            return item;
+        }
+        const importPath = relativeRqImportPath(document.uri, candidate.document.uri);
+        item.detail = importPath;
+        if (candidate.importable) {
+            const importEdit = buildFromImportEdit(document, importPath, candidate.name);
+            if (importEdit) {
+                item.additionalTextEdits = [importEdit];
+            }
+        }
+        return item;
     }
 
     private completeAnonymousImportPath(document: LangiumDocument, params: CompletionParams): CompletionList {

package/src/reqlan-definition-provider.ts

@@ -2,7 +2,7 @@
  * Go-to-definition for imports, file references, symbols, and embedded comment references.
  */
 import type { CstNode, FileSystemProvider, LangiumDocument, MaybePromise } from 'langium';
-import { AstUtils, CstUtils, GrammarUtils, URI } from 'langium';
+import { CstUtils, GrammarUtils, URI } from 'langium';
 import { DefaultDefinitionProvider, type GoToLink } from 'langium/lsp';
 import type { DefinitionParams, Position } from 'vscode-languageserver';
 import { LocationLink } from 'vscode-languageserver';
@@ -33,6 +33,7 @@ import {
     isInvalidFromImport,
     isLocalReference,
     isQualifiedReference,
+    isWildcardReference,
     type FileReference,
     type FileSymbolReference,
     type Import,
@@ -41,6 +42,7 @@ import {
 } from './generated/ast.js';
 import type { ReqlanServices } from './reqlan-module.js';
 import { pathResolveContextFromServices } from './reqlan-path-resolve.js';
+import { findWildcardReferenceAtPosition } from './reqlan-wildcard-resolve.js';
 
 export class ReqlanDefinitionProvider extends DefaultDefinitionProvider {
 
@@ -60,9 +62,20 @@ export class ReqlanDefinitionProvider extends DefaultDefinitionProvider {
     }
 
     override getDefinition(document: LangiumDocument, params: DefinitionParams): MaybePromise<LocationLink[] | undefined> {
+        // Fast path: when the cursor is on an idea token inside a bracket/wiki reference the
+        // answer is just the cached Langium ref target — no text scans, no file-system calls.
+        // Same-file and cross-file idea refs both take this path, so neither is slower than the other.
+        if (this.isIdeaReferencePosition(document, params.position)) {
+            return super.getDefinition(document, params);
+        }
         if (isMarkdownLinkLabelPosition(document, params.position)) {
             return undefined;
         }
+        // Wildcard refs open the activity-bar search pane via extension command (document link / middleware).
+        const offset = document.textDocument.offsetAt(params.position);
+        if (findWildcardReferenceAtPosition(document, offset)) {
+            return undefined;
+        }
         const commentPart = findCommentReferencePartAt(document, params.position);
         if (commentPart?.property === 'idea') {
             return this.createCommentIdeaReferenceLinks(document, commentPart.reference);
@@ -75,7 +88,11 @@ export class ReqlanDefinitionProvider extends DefaultDefinitionProvider {
             this.pathContext()
         );
         if (fileReference) {
-            if (fileReference.resolution === 'folder' || fileReference.resolution === 'missing') {
+            if (
+                fileReference.resolution === 'folder'
+                || fileReference.resolution === 'missing'
+                || fileReference.resolution === 'wildcard'
+            ) {
                 return undefined;
             }
             return [this.resolvedFileLinkToLocationLink(fileReference)];
@@ -95,6 +112,56 @@ export class ReqlanDefinitionProvider extends DefaultDefinitionProvider {
         return super.getDefinition(document, params);
     }
 
+    /**
+     * Returns true when the cursor sits on an idea/ideaset name token inside a bracket or
+     * wikilink reference (LocalReference or QualifiedReference) but NOT on the path/qualifier
+     * token that points to an import.  This lets us skip all text-scan pre-checks and jump
+     * straight to the cached Langium ref resolution.
+     */
+    private isIdeaReferencePosition(document: LangiumDocument, position: Position): boolean {
+        const root = document.parseResult.value.$cstNode;
+        if (!root) {
+            return false;
+        }
+        const offset = document.textDocument.offsetAt(position);
+        let current: CstNode | undefined = CstUtils.findLeafNodeAtOffset(root, offset);
+        while (current) {
+            const node = current.astNode;
+            if (isLocalReference(node)) {
+                // A local ref whose idea is already resolved → fast O(1) path.
+                // Unresolved ones still go through the normal flow so file-link checks can try.
+                return node.idea?.ref !== undefined;
+            }
+            if (isQualifiedReference(node)) {
+                const assignment = GrammarUtils.findAssignment(current);
+                if (!assignment) {
+                    current = current.container;
+                    continue;
+                }
+                // On the path/qualifier token → defer to import-path checks.
+                if (assignment.feature === 'path' || assignment.feature === 'qualifier') {
+                    return false;
+                }
+                // On the idea or ideaset token → O(1) cached ref lookup.
+                if (assignment.feature === 'idea' || assignment.feature === 'ideaset') {
+                    return node.idea?.ref !== undefined || node.ideaset?.ref !== undefined;
+                }
+                return false;
+            }
+            // FileReference / FileSymbolReference / Import / WildcardReference → not idea refs, stop.
+            if (
+                isFileReference(node)
+                || isFileSymbolReference(node)
+                || isImport(node)
+                || isWildcardReference(node)
+            ) {
+                return false;
+            }
+            current = current.container;
+        }
+        return false;
+    }
+
     protected override findLinks(source: CstNode): GoToLink[] {
         const fileLink = this.linkForFileReference(source) ?? this.linkForNamespaceImportReference(source);
         if (fileLink) {
@@ -229,24 +296,30 @@ export class ReqlanDefinitionProvider extends DefaultDefinitionProvider {
     }
 
     private findAnonymousImportPathLinkAtPosition(document: LangiumDocument, position: Position): GoToLink | undefined {
+        const root = document.parseResult.value.$cstNode;
+        if (!root) {
+            return undefined;
+        }
         const offset = document.textDocument.offsetAt(position);
-        for (const node of AstUtils.streamAst(document.parseResult.value)) {
-            if (!isQualifiedReference(node) || node.path?.ref) {
-                continue;
-            }
-            const pathNode = node.path?.$refNode ?? GrammarUtils.findNodeForProperty(node.$cstNode, 'path');
-            if (!pathNode || offset < pathNode.offset || offset >= pathNode.end) {
-                continue;
-            }
-            const resolved = resolveQualifiedReferencePathLink(node, this.documents, this.pathContext());
-            if (!resolved) {
-                continue;
-            }
-            const targetDocument = this.documents.getDocument(URI.parse(resolved.targetUri.split('#')[0]));
-            if (!targetDocument) {
-                continue;
+        // Walk up from the leaf node — O(depth) rather than O(all AST nodes).
+        let current: CstNode | undefined = CstUtils.findLeafNodeAtOffset(root, offset);
+        while (current) {
+            const node = current.astNode;
+            if (isQualifiedReference(node) && !node.path?.ref) {
+                const pathNode = node.path?.$refNode ?? GrammarUtils.findNodeForProperty(node.$cstNode, 'path');
+                if (pathNode && offset >= pathNode.offset && offset < pathNode.end) {
+                    const resolved = resolveQualifiedReferencePathLink(node, this.documents, this.pathContext());
+                    if (!resolved) {
+                        return undefined;
+                    }
+                    const targetDocument = this.documents.getDocument(URI.parse(resolved.targetUri.split('#')[0]));
+                    if (!targetDocument) {
+                        return undefined;
+                    }
+                    return resolvedFileLinkToGoToTarget(resolved, pathNode, targetDocument);
+                }
             }
-            return resolvedFileLinkToGoToTarget(resolved, pathNode, targetDocument);
+            current = current.container;
         }
         return undefined;
     }

package/src/reqlan-document-link-provider.ts

@@ -1,5 +1,6 @@
 /**
- * Clickable document links for file references and import paths.
+ * Clickable document links for idea references, file references, and import paths.
+ * Same-file and cross-file idea refs both get links so the editor underline is consistent.
  */
 import type { LangiumDocument } from 'langium';
 import type { DocumentLinkProvider } from 'langium/lsp';
@@ -7,6 +8,7 @@ import type { DocumentLink, DocumentLinkParams } from 'vscode-languageserver';
 import { DocumentLink as LspDocumentLink } from 'vscode-languageserver';
 import { collectFileLinks, resolvedFileLinkTargetUri } from './reqlan-file-link-resolver.js';
 import { folderReferenceCommandTarget } from './reqlan-reference-at-position.js';
+import { wildcardReferenceCommandTarget } from './reqlan-wildcard-resolve.js';
 import type { ReqlanServices } from './reqlan-module.js';
 import { pathResolveContextFromServices } from './reqlan-path-resolve.js';
 
@@ -35,6 +37,12 @@ export class ReqlanDocumentLinkProvider implements DocumentLinkProvider {
                     folderReferenceCommandTarget(link.targetUri)
                 )];
             }
+            if (link.resolution === 'wildcard' && link.wildcardArgs) {
+                return [LspDocumentLink.create(
+                    link.sourceRange,
+                    wildcardReferenceCommandTarget(link.wildcardArgs)
+                )];
+            }
             const target = resolvedFileLinkTargetUri(link);
             if (!target) {
                 return [];

package/src/reqlan-file-link-resolver.ts

@@ -1,7 +1,8 @@
 /**
- * Resolves file references and import paths to target URIs and editor ranges.
+ * Resolves file references, idea references, and import paths to target URIs and editor ranges.
+ * Document links use these so same-file and cross-file refs share the same underline/click affordance.
  */
-import type { CstNode, FileSystemProvider, LangiumDocument, LangiumDocuments, URI } from 'langium';
+import type { AstNode, CstNode, FileSystemProvider, LangiumDocument, LangiumDocuments, Reference, URI } from 'langium';
 import { AstUtils, CstUtils, GrammarUtils } from 'langium';
 import type { Range } from 'vscode-languageserver';
 import { resolveFileUri } from './reqlan-comment-resolver.js';
@@ -23,11 +24,14 @@ import {
     isLocalReference,
     isMarkdownLink,
     isQualifiedReference,
+    isWildcardReference,
     type FileReference,
     type FileSymbolReference,
     type Import,
+    type LocalReference,
     type MarkdownLink,
-    type QualifiedReference
+    type QualifiedReference,
+    type WildcardReference
 } from './generated/ast.js';
 import { parseMarkdownLink } from './reqlan-references.js';
 import { reqlanStringDelimiter } from './reqlan-quoted-strings.js';
@@ -35,8 +39,14 @@ import {
     isNamespaceImportOnlyReference,
     resolveNamespaceImportReferenceLink
 } from './reqlan-namespace-import-links.js';
+import {
+    resolveWildcardReferenceMatches,
+    wildcardArgsFromReference,
+    type WildcardMatch,
+    type WildcardReferenceArgs
+} from './reqlan-wildcard-resolve.js';
 
-export type ReferenceResolution = 'file' | 'folder' | 'missing';
+export type ReferenceResolution = 'file' | 'folder' | 'missing' | 'wildcard';
 
 export type FileLinkTargetIssue = 'empty' | 'parse-error';
 
@@ -47,6 +57,9 @@ export interface ResolvedFileLink {
     resolution?: ReferenceResolution;
     folderFiles?: string[];
     targetIssue?: FileLinkTargetIssue;
+    /** Present when resolution is `wildcard`. */
+    wildcardArgs?: WildcardReferenceArgs;
+    wildcardMatches?: WildcardMatch[];
 }
 
 function withFileSystem(
@@ -368,6 +381,80 @@ function fileStartRange(): Range {
     };
 }
 
+/**
+ * Document link for a resolved Langium cross-reference (same-file or imported idea/ideaset).
+ * Source range is the reference name; target is the declaration name (or whole node).
+ */
+export function resolveLinkedAstReferenceLink(reference: Reference<AstNode> | undefined): ResolvedFileLink | undefined {
+    const target = reference?.ref;
+    const sourceNode = reference?.$refNode;
+    if (!target || !sourceNode) {
+        return undefined;
+    }
+    const targetDocument = AstUtils.getDocument(target);
+    const nameNode = GrammarUtils.findNodeForProperty(target.$cstNode, 'name') ?? target.$cstNode;
+    if (!nameNode) {
+        return undefined;
+    }
+    return {
+        sourceRange: sourceNode.range,
+        targetUri: targetDocument.textDocument.uri,
+        targetRange: nameNode.range,
+        resolution: 'file'
+    };
+}
+
+/** Idea/ideaset name links inside bracket and qualified references (not namespace-file aliases). */
+export function resolveIdeaReferenceLinks(
+    reference: LocalReference | QualifiedReference
+): ResolvedFileLink[] {
+    if (isLocalReference(reference)) {
+        if (isNamespaceImportOnlyReference(reference)) {
+            return [];
+        }
+        const link = resolveLinkedAstReferenceLink(reference.idea);
+        return link ? [link] : [];
+    }
+    const links: ResolvedFileLink[] = [];
+    const ideasetLink = resolveLinkedAstReferenceLink(reference.ideaset);
+    if (ideasetLink) {
+        links.push(ideasetLink);
+    }
+    const ideaLink = resolveLinkedAstReferenceLink(reference.idea);
+    if (ideaLink) {
+        links.push(ideaLink);
+    }
+    return links;
+}
+
+export function resolveWildcardReferenceLink(
+    reference: WildcardReference,
+    documents: LangiumDocuments,
+    context?: PathResolveContext
+): ResolvedFileLink | undefined {
+    const pathNode = GrammarUtils.findNodeForProperty(reference.$cstNode, 'pathPattern');
+    const ideaNode = GrammarUtils.findNodeForProperty(reference.$cstNode, 'ideaPattern');
+    const sourceRange = reference.$cstNode?.range
+        ?? (pathNode && ideaNode
+            ? {
+                start: pathNode.range.start,
+                end: ideaNode.range.end
+            }
+            : pathNode?.range);
+    if (!sourceRange) {
+        return undefined;
+    }
+    const matches = resolveWildcardReferenceMatches(reference, documents, context);
+    const args = wildcardArgsFromReference(reference);
+    return {
+        sourceRange,
+        targetUri: AstUtils.getDocument(reference).uri.toString(),
+        resolution: 'wildcard',
+        wildcardArgs: args,
+        wildcardMatches: matches
+    };
+}
+
 export function collectFileLinks(
     document: LangiumDocument,
     documents: LangiumDocuments,
@@ -377,40 +464,49 @@ export function collectFileLinks(
     const pathContext = withFileSystem(fileSystem, context);
     const links: ResolvedFileLink[] = [];
     const linkedRanges: string[] = [];
+    const pushLink = (link: ResolvedFileLink): void => {
+        links.push(link);
+        linkedRanges.push(rangeKey(link.sourceRange));
+    };
     for (const node of AstUtils.streamAst(document.parseResult.value)) {
         if (isFileReference(node) || isFileSymbolReference(node)) {
             const link = resolveFileReferenceLink(node, documents, fileSystem, pathContext);
             if (link) {
-                links.push(link);
-                linkedRanges.push(rangeKey(link.sourceRange));
+                pushLink(link);
+            }
+        }
+        if (isWildcardReference(node)) {
+            const link = resolveWildcardReferenceLink(node, documents, pathContext);
+            if (link) {
+                pushLink(link);
             }
         }
         if ((isLocalReference(node) || isQualifiedReference(node)) && isNamespaceImportOnlyReference(node)) {
             const link = resolveNamespaceImportReferenceLink(node, documents, fileSystem, pathContext);
             if (link) {
-                links.push(link);
-                linkedRanges.push(rangeKey(link.sourceRange));
+                pushLink(link);
+            }
+        } else if (isLocalReference(node) || isQualifiedReference(node)) {
+            for (const link of resolveIdeaReferenceLinks(node)) {
+                pushLink(link);
             }
         }
         if (isImport(node)) {
             const link = resolveImportPathLink(node, documents, pathContext);
             if (link) {
-                links.push(link);
-                linkedRanges.push(rangeKey(link.sourceRange));
+                pushLink(link);
             }
         }
         if (isQualifiedReference(node) && node.path && !node.path.ref) {
             const link = resolveQualifiedReferencePathLink(node, documents, pathContext);
             if (link) {
-                links.push(link);
-                linkedRanges.push(rangeKey(link.sourceRange));
+                pushLink(link);
             }
         }
         if (isMarkdownLink(node)) {
             const link = resolveMarkdownLinkTargetLink(node, document, documents, fileSystem, pathContext);
             if (link) {
-                links.push(link);
-                linkedRanges.push(rangeKey(link.sourceRange));
+                pushLink(link);
             }
         }
     }
@@ -421,8 +517,7 @@ export function collectFileLinks(
         }
         const link = resolveEmbeddedFileReferenceLink(reference, document, documents, fileSystem, pathContext);
         if (link) {
-            links.push(link);
-            linkedRanges.push(key);
+            pushLink(link);
         }
     }
     return links;
@@ -440,7 +535,7 @@ function rangesOverlap(left: Range, right: Range): boolean {
 }
 
 export function resolvedFileLinkTargetUri(link: ResolvedFileLink): string | undefined {
-    if (link.resolution === 'folder' || link.resolution === 'missing') {
+    if (link.resolution === 'folder' || link.resolution === 'missing' || link.resolution === 'wildcard') {
         return undefined;
     }
     if (link.targetRange) {

package/src/reqlan-import-edits.ts

@@ -1,6 +1,8 @@
 /**
- * Shared WorkspaceEdit helpers for import insertion used by unresolved-reference quick fixes.
+ * Shared WorkspaceEdit helpers for import insertion used by unresolved-reference quick fixes
+ * and cross-file reference completion auto-import.
  * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_error]
+ * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_code_completion_auto_file_import]
  */
 import type { LangiumDocument, URI } from 'langium';
 import { UriUtils } from 'langium';