@reqlan/language 1.7.0 → 1.8.2

package/src/reqlan-inbound-reference-inlay-label.ts

@@ -28,43 +28,108 @@ export type ReferencedDeclaration = IdeaDeclaration | IdeaSet;
 
 const MAX_INLINE_NAMES = 3;
 
+/** Target key: `${documentUri}#${astNodePath}` — matches IndexManager reference descriptions. */
+export type InboundReferencerIndex = Map<string, InboundReferencer[]>;
+
 /**
- * Collect inbound idea referencers from the whole Langium workspace index
- * (every indexed `.rq` document), not only the declaration's file.
+ * Langium's IndexManager stores outbound refs per source document and scans every
+ * document for each `findAllReferences` call. Building the inverse once makes
+ * inlay hints O(workspace refs) instead of O(ideas × workspace refs).
+ * rq:["../../../reqlan rq/extension/syntax/features-syntax-highlighting.rq".inbound_inlay_index_performance]
  */
-export function collectInboundReferencers(
+type IndexManagerReferenceIndex = {
+    referenceIndex: Map<string, Array<{
+        sourceUri: { toString(): string };
+        sourcePath: string;
+        targetUri: { toString(): string };
+        targetPath: string;
+    }>>;
+};
+
+export function declarationInboundKey(
     services: ReqlanServices,
     declaration: ReferencedDeclaration
-): InboundReferencer[] {
+): string {
+    const document = AstUtils.getDocument(declaration);
+    const path = services.workspace.AstNodeLocator.getAstNodePath(declaration);
+    return `${document.uri.toString()}#${path}`;
+}
+
+/**
+ * Build inbound referencers for every idea/ideaset target in one pass.
+ */
+export function buildInboundReferencerIndex(services: ReqlanServices): InboundReferencerIndex {
     const documents = services.shared.workspace.LangiumDocuments;
     const locator = services.workspace.AstNodeLocator;
-    const referencers = new Map<string, InboundReferencer>();
-
-    // findReferences without documentUri walks IndexManager across the workspace.
-    for (const reference of services.references.References.findReferences(declaration, { includeDeclaration: false }).toArray()) {
-        const sourceDocument = documents.getDocument(reference.sourceUri);
-        if (!sourceDocument) {
-            continue;
-        }
-        const sourceNode = locator.getAstNode(sourceDocument.parseResult.value, reference.sourcePath);
-        if (!sourceNode) {
-            continue;
-        }
-        const referrer = enclosingReferrerDeclaration(sourceNode);
-        if (!referrer || isSameDeclaration(referrer, declaration)) {
-            continue;
-        }
-        const location = locationForReferrer(referrer);
-        if (!location) {
-            continue;
+    const indexManager = services.shared.workspace.IndexManager as unknown as IndexManagerReferenceIndex;
+    const buckets = new Map<string, Map<string, InboundReferencer>>();
+
+    for (const docRefs of indexManager.referenceIndex.values()) {
+        for (const reference of docRefs) {
+            const sourceDocument = documents.getDocument(reference.sourceUri as never);
+            if (!sourceDocument) {
+                continue;
+            }
+            const sourceNode = locator.getAstNode(sourceDocument.parseResult.value, reference.sourcePath);
+            if (!sourceNode) {
+                continue;
+            }
+            const referrer = enclosingReferrerDeclaration(sourceNode);
+            if (!referrer) {
+                continue;
+            }
+            const location = locationForReferrer(referrer);
+            if (!location) {
+                continue;
+            }
+            const targetKey = `${reference.targetUri.toString()}#${reference.targetPath}`;
+            const referrerDoc = AstUtils.getDocument(referrer).uri.toString();
+            const referrerPath = locator.getAstNodePath(referrer);
+            if (targetKey === `${referrerDoc}#${referrerPath}`) {
+                continue;
+            }
+            let byLocation = buckets.get(targetKey);
+            if (!byLocation) {
+                byLocation = new Map();
+                buckets.set(targetKey, byLocation);
+            }
+            byLocation.set(locationKey(location), {
+                name: referrer.name,
+                location
+            });
         }
-        referencers.set(locationKey(location), {
-            name: referrer.name,
-            location
-        });
     }
 
-    return [...referencers.values()].sort((left, right) => left.name.localeCompare(right.name));
+    const result: InboundReferencerIndex = new Map();
+    for (const [targetKey, byLocation] of buckets) {
+        result.set(
+            targetKey,
+            [...byLocation.values()].sort((left, right) => left.name.localeCompare(right.name))
+        );
+    }
+    return result;
+}
+
+export function lookupInboundReferencers(
+    index: InboundReferencerIndex,
+    services: ReqlanServices,
+    declaration: ReferencedDeclaration
+): InboundReferencer[] {
+    return index.get(declarationInboundKey(services, declaration)) ?? [];
+}
+
+/**
+ * Collect inbound idea referencers from the whole Langium workspace index
+ * (every indexed `.rq` document), not only the declaration's file.
+ *
+ * Prefer {@link buildInboundReferencerIndex} + {@link lookupInboundReferencers}
+ * when resolving many declarations (e.g. inlay hints).
+ */
+export function collectInboundReferencers(
+    services: ReqlanServices,
+    declaration: ReferencedDeclaration
+): InboundReferencer[] {
+    return lookupInboundReferencers(buildInboundReferencerIndex(services), services, declaration);
 }
 
 /** @deprecated Use {@link collectInboundReferencers} */
@@ -86,16 +151,6 @@ function enclosingReferrerDeclaration(node: AstNode): ReferencedDeclaration | un
     return undefined;
 }
 
-function isSameDeclaration(left: ReferencedDeclaration, right: ReferencedDeclaration): boolean {
-    if (left === right) {
-        return true;
-    }
-    if (left.name !== right.name) {
-        return false;
-    }
-    return AstUtils.getDocument(left).uri.toString() === AstUtils.getDocument(right).uri.toString();
-}
-
 function locationForReferrer(referrer: ReferencedDeclaration): Location | undefined {
     const nameNode = GrammarUtils.findNodeForProperty(referrer.$cstNode, 'name');
     if (!nameNode?.range) {

package/src/reqlan-inlay-hint-provider.ts

@@ -1,10 +1,15 @@
 /**
  * Inlay hints showing inbound references on idea declarations as a computed attribute.
+ *
+ * Builds a single workspace inbound index per request so large `.rq` files stay responsive
+ * (avoids per-idea full-workspace `findAllReferences` scans).
+ * rq:["../../../reqlan rq/extension/syntax/features-syntax-highlighting.rq".inbound_inlay_index_performance]
+ * rq:["../../../reqlan rq/extension/syntax/features-syntax-highlighting.rq".view_references_as_inlay_hints]
  */
-import { AstUtils, GrammarUtils, type AstNode, type LangiumDocument } from 'langium';
+import { AstUtils, GrammarUtils, interruptAndCheck, type AstNode, type LangiumDocument } from 'langium';
 import { AbstractInlayHintProvider } from 'langium/lsp';
 import type { CancellationToken } from 'vscode-languageserver';
-import { InlayHintKind, type InlayHint, type InlayHintParams } from 'vscode-languageserver';
+import { CancellationToken as CancelToken, InlayHintKind, type InlayHint, type InlayHintParams } from 'vscode-languageserver';
 import {
     isIdea,
     isIdeaSet,
@@ -12,7 +17,9 @@ import {
 } from './generated/ast.js';
 import {
     buildInboundReferencesInlayLabel,
-    collectInboundReferencers,
+    buildInboundReferencerIndex,
+    lookupInboundReferencers,
+    type InboundReferencerIndex,
     type ReferencedDeclaration
 } from './reqlan-inbound-reference-inlay-label.js';
 import {
@@ -25,6 +32,7 @@ import type { ReqlanServices } from './reqlan-module.js';
 export class ReqlanInlayHintProvider extends AbstractInlayHintProvider {
 
     private readonly services: ReqlanServices;
+    private inboundIndex: InboundReferencerIndex | undefined;
 
     constructor(services: ReqlanServices) {
         super();
@@ -34,7 +42,7 @@ export class ReqlanInlayHintProvider extends AbstractInlayHintProvider {
     override async getInlayHints(
         document: LangiumDocument,
         params: InlayHintParams,
-        cancelToken?: CancellationToken
+        cancelToken: CancellationToken = CancelToken.None
     ): Promise<InlayHint[] | undefined> {
         const settings = await this.services.shared.workspace.ConfigurationProvider.getConfiguration(
             'reqlan',
@@ -43,7 +51,28 @@ export class ReqlanInlayHintProvider extends AbstractInlayHintProvider {
         if (!referenceInlayHintsEnabled(settings)) {
             return [];
         }
-        return super.getInlayHints(document, params, cancelToken);
+        // Must throw Langium's OperationCancelled symbol so the LSP maps this to
+        // RequestCancelled (-32800), not InternalError (-32603) with "Operation cancelled".
+        await interruptAndCheck(cancelToken);
+        // One inverse index for the whole request — not findReferences per idea.
+        this.inboundIndex = buildInboundReferencerIndex(this.services);
+        try {
+            const root = document.parseResult.value;
+            const inlayHints: InlayHint[] = [];
+            const acceptor = (hint: InlayHint): void => {
+                inlayHints.push(hint);
+            };
+            let checked = 0;
+            for (const node of AstUtils.streamAst(root, { range: params.range })) {
+                if ((++checked & 31) === 0) {
+                    await interruptAndCheck(cancelToken);
+                }
+                this.computeInlayHint(node, acceptor);
+            }
+            return inlayHints;
+        } finally {
+            this.inboundIndex = undefined;
+        }
     }
 
     computeInlayHint(node: AstNode, acceptor: (hint: InlayHint) => void): void {
@@ -64,7 +93,8 @@ export class ReqlanInlayHintProvider extends AbstractInlayHintProvider {
         if (!nameNode?.range) {
             return;
         }
-        const referencers = collectInboundReferencers(this.services, declaration);
+        const index = this.inboundIndex ?? buildInboundReferencerIndex(this.services);
+        const referencers = lookupInboundReferencers(index, this.services, declaration);
         const document = AstUtils.getDocument(declaration);
         const formatted = buildInboundReferencesInlayLabel(
             referencers,

package/src/reqlan-markdown-links.ts

@@ -40,6 +40,8 @@ export function isMarkdownLinkLabelPosition(document: LangiumDocument, position:
     const offset = document.textDocument.offsetAt(position);
     const root = document.parseResult.value.$cstNode;
     if (root) {
+        // The CST covers the entire document. Walk up from the leaf; if no MarkdownLink ancestor
+        // is found, the position is definitively not inside a markdown label — no text scan needed.
         const leaf = CstUtils.findLeafNodeAtOffset(root, offset);
         let current: CstNode | undefined = leaf;
         while (current) {
@@ -52,7 +54,9 @@ export function isMarkdownLinkLabelPosition(document: LangiumDocument, position:
             }
             current = current.container;
         }
+        return false;
     }
+    // No CST (e.g. plain-text document) — fall back to text scan.
     return isMarkdownLinkLabelOffsetInText(document.textDocument.getText(), offset);
 }
 

package/src/reqlan-path-resolve.ts

@@ -60,6 +60,13 @@ export interface PathResolveContext {
      * `null` skips loading and uses defaults only.
      */
     config?: RqConfig | null;
+    /**
+     * Shared cache for resolved configs, keyed by directory URI string.
+     * When provided, `resolveRqConfig` reads and populates this cache instead of hitting the filesystem
+     * on every call. Lives on the workspace manager so it is scoped to a service instance and cleared
+     * on workspace reinitialisation.
+     */
+    configCache?: Map<string, RqConfig | undefined>;
 }
 
 export function defaultRqConfig(): RqConfig {
@@ -297,9 +304,21 @@ export function resolveRqConfig(document: LangiumDocument, context?: PathResolve
         return context.config;
     }
     if (context?.fileSystem) {
-        const loaded = loadApplyingRqConfig(UriUtils.dirname(document.uri), context.fileSystem);
-        if (loaded) {
-            return loaded;
+        const dirKey = UriUtils.dirname(document.uri).toString();
+        const cache = context.configCache;
+        if (cache) {
+            if (!cache.has(dirKey)) {
+                cache.set(dirKey, loadApplyingRqConfig(UriUtils.dirname(document.uri), context.fileSystem));
+            }
+            const cached = cache.get(dirKey);
+            if (cached) {
+                return cached;
+            }
+        } else {
+            const loaded = loadApplyingRqConfig(UriUtils.dirname(document.uri), context.fileSystem);
+            if (loaded) {
+                return loaded;
+            }
         }
     }
     return defaultRqConfig();
@@ -351,7 +370,10 @@ export function workspaceFolderUrisFromManager(
 export function pathResolveContextFromServices(services: {
     shared: {
         workspace: {
-            WorkspaceManager: { workspaceFolders?: ReadonlyArray<{ uri: string }> };
+            WorkspaceManager: {
+                workspaceFolders?: ReadonlyArray<{ uri: string }>;
+                rqConfigCache?: Map<string, RqConfig | undefined>;
+            };
             FileSystemProvider: FileSystemProvider;
         };
     };
@@ -360,6 +382,7 @@ export function pathResolveContextFromServices(services: {
         fileSystem: services.shared.workspace.FileSystemProvider,
         workspaceFolderUris: workspaceFolderUrisFromManager(
             services.shared.workspace.WorkspaceManager.workspaceFolders
-        )
+        ),
+        configCache: services.shared.workspace.WorkspaceManager.rqConfigCache
     };
 }

package/src/reqlan-reference-search-site.ts

@@ -15,6 +15,9 @@ import {
 } from './reqlan-idea-reference-site.js';
 import { isIdea, isOneLinerIdea, type IdeaDeclaration } from './generated/ast.js';
 
+/** Custom LSP request: resolve search/wrap site at a range (no command-arg cache). */
+export const REQLAN_REFERENCE_SEARCH_SITE_REQUEST = 'reqlan/referenceSearchSite';
+
 export type ReferenceSearchMode = 'replace' | 'wrap';
 
 export interface ReferenceSearchContext {
@@ -35,6 +38,28 @@ export interface ReferenceSearchSite {
     context?: ReferenceSearchContext;
 }
 
+/** Result of {@link REQLAN_REFERENCE_SEARCH_SITE_REQUEST} / extension command payload. */
+export interface ReferenceSearchSiteRequestResult {
+    documentUri: string;
+    refText: string;
+    range: Range;
+    mode: ReferenceSearchMode;
+    context?: ReferenceSearchContext;
+}
+
+export function toReferenceSearchCommandArgs(
+    documentUri: string,
+    site: ReferenceSearchSite
+): ReferenceSearchSiteRequestResult {
+    return {
+        documentUri,
+        refText: site.refText,
+        range: site.range,
+        mode: site.mode,
+        context: site.context
+    };
+}
+
 /**
  * Prefer an existing [reference]/[[wikilink]] under the cursor; otherwise a
  * selection or word in idea-body prose that can be wrapped as `[name]`.

package/src/reqlan-scope.ts

@@ -43,10 +43,25 @@ export class ReqlanScopeComputation extends DefaultScopeComputation {
     }
 }
 
+interface ScopeEntry {
+    version: number | undefined;
+    scope: Scope;
+}
+
 export class ReqlanScopeProvider extends DefaultScopeProvider {
 
     protected readonly documents: ReqlanServices['shared']['workspace']['LangiumDocuments'];
     private readonly services: ReqlanServices;
+    /**
+     * Per-document cache for `scopeForFileIdeas`. Key is the document URI string.
+     * Invalidated when the document version changes so edits always get a fresh scope.
+     */
+    private readonly fileIdeasCache = new Map<string, ScopeEntry>();
+    /**
+     * Per-(document, importPath) cache for `scopeForImportPath`. Key is the imported document URI string.
+     * The cached scope is keyed to the imported document's version.
+     */
+    private readonly importPathCache = new Map<string, ScopeEntry>();
 
     constructor(services: ReqlanServices) {
         super(services);
@@ -120,6 +135,17 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
     }
 
     private scopeForFileIdeas(document: LangiumDocument): Scope {
+        const key = document.uri.toString();
+        const cached = this.fileIdeasCache.get(key);
+        if (cached && cached.version === document.textDocument.version) {
+            return cached.scope;
+        }
+        const scope = this.buildFileIdeasScope(document);
+        this.fileIdeasCache.set(key, { version: document.textDocument.version, scope });
+        return scope;
+    }
+
+    private buildFileIdeasScope(document: LangiumDocument): Scope {
         const model = document.parseResult.value as Model;
         if (!isModel(model)) {
             return new StreamScope(stream([]));
@@ -279,6 +305,11 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
         if (!imported) {
             return undefined;
         }
+        const key = imported.uri.toString();
+        const cached = this.importPathCache.get(key);
+        if (cached && cached.version === imported.textDocument.version) {
+            return cached.scope;
+        }
         const model = imported.parseResult.value;
         if (!isModel(model)) {
             return undefined;
@@ -286,7 +317,9 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
         const descriptions = model.elements
             .filter(element => isIdea(element) || isOneLinerIdea(element))
             .map(idea => this.descriptions.createDescription(idea, idea.name, imported));
-        return new StreamScope(stream(descriptions));
+        const scope = new StreamScope(stream(descriptions));
+        this.importPathCache.set(key, { version: imported.textDocument.version, scope });
+        return scope;
     }
 
     private findImportedDocument(path: string, document: LangiumDocument): LangiumDocument | undefined {

package/src/reqlan-semantic-token-provider.ts

@@ -20,6 +20,7 @@ import {
     isQualifiedImport,
     isQualifiedReference,
     isOneLinerIdea,
+    isWildcardReference,
     type Import
 } from './generated/ast.js';
 import { isWellFormedFromImport } from './reqlan-import-bindings.js';
@@ -50,6 +51,11 @@ export class ReqlanSemanticTokenProvider extends AbstractSemanticTokenProvider {
             });
             return;
         }
+        if (isWildcardReference(node)) {
+            acceptor({ node, property: 'pathPattern', type: SemanticTokenTypes.string });
+            acceptor({ node, property: 'ideaPattern', type: SemanticTokenTypes.variable });
+            return;
+        }
         if (isQualifiedReference(node)) {
             if (node.qualifier) {
                 acceptor({ node, property: 'qualifier', type: SemanticTokenTypes.namespace });

package/src/reqlan-token-builder.ts

@@ -1,11 +1,13 @@
 /**
- * Custom token builder so line comments do not match `//` in URLs or inside string literals,
- * and so `@` only introduces attributes at the start of a line.
+ * Custom token builder so line/block comments do not match inside string literals,
+ * empty slash-star-star-slash glob segments do not steal path text, and `@` only
+ * introduces attributes at the start of a line.
  */
 import type { Grammar } from 'langium';
 import { DefaultTokenBuilder, type TokenBuilderOptions } from 'langium';
 
 const SL_COMMENT_PATTERN = /\/\/[^\n\r]*/y;
+const ML_COMMENT_PATTERN = /\/\*[\s\S]*?\*\//y;
 
 function isInsideNakedQuote(text: string, offset: number): boolean {
     let inDouble = false;
@@ -53,6 +55,28 @@ const slCommentPattern = (text: string, offset: number): RegExpExecArray | null
     return SL_COMMENT_PATTERN.exec(text);
 };
 
+// Block comments must not open inside quotes. Reject the empty four-character
+// slash-star-star-slash form so recursive globs like ../mod/**/*.rq stay path text
+// in prose and naked quotes (reference STRING paths already consume the whole literal).
+const mlCommentPattern = (text: string, offset: number): RegExpExecArray | null => {
+    if (text.charCodeAt(offset) !== 47 || text.charCodeAt(offset + 1) !== 42) {
+        return null;
+    }
+    if (isInsideNakedQuote(text, offset)) {
+        return null;
+    }
+    ML_COMMENT_PATTERN.lastIndex = offset;
+    const match = ML_COMMENT_PATTERN.exec(text);
+    if (!match) {
+        return null;
+    }
+    // /* immediately followed by */ — recursive glob segment, not a comment.
+    if (match[0].length === 4) {
+        return null;
+    }
+    return match;
+};
+
 function makeMatch(text: string, offset: number, length: number): RegExpExecArray {
     const image = text.slice(offset, offset + length);
     const match = [image] as unknown as RegExpExecArray;
@@ -445,8 +469,15 @@ function topLevelAsKeyword(text: string, offset: number): RegExpExecArray | null
     if (braceDepthBefore(text, offset) !== 0) {
         return null;
     }
+    // `as` is reserved only on from/import lines — not after arbitrary top-level identifiers
+    // (e.g. one-liner prose "such as this").
+    const linePrefix = text.slice(lineStartOffset(text, offset), offset);
+    if (!/^[ \t]*(?:from|import)\b/.test(linePrefix)) {
+        return null;
+    }
     const before = textBeforeOnLine(text, offset);
-    if (/(?:[_a-zA-Z][\w-]*|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')$/.test(before)) {
+    // After import path (optionally qualified) or after a from-import specifier name.
+    if (/(?:(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')(?:\.[A-Za-z_][\w-]*)*|[A-Za-z_][\w-]*)$/.test(before)) {
         return makeMatch(text, offset, 2);
     }
     return null;
@@ -551,6 +582,16 @@ export class ReqlanTokenBuilder extends DefaultTokenBuilder {
             };
             other.LINE_BREAKS = false;
         }
+        // ID is a prefix of WILDCARD_NAME (e.g. import_ vs import_*) — require longer-alt check.
+        const idToken = tokens.find(entry => entry.name === 'ID');
+        const wildcardToken = tokens.find(entry => entry.name === 'WILDCARD_NAME');
+        if (idToken && wildcardToken) {
+            const existing = idToken.LONGER_ALT;
+            const alts = Array.isArray(existing) ? existing : existing ? [existing] : [];
+            if (!alts.includes(wildcardToken)) {
+                idToken.LONGER_ALT = [...alts, wildcardToken];
+            }
+        }
         return tokens;
     }
 
@@ -563,6 +604,14 @@ export class ReqlanTokenBuilder extends DefaultTokenBuilder {
                 PATTERN: slCommentPattern
             };
         }
+        if (terminal.name === 'ML_COMMENT') {
+            return {
+                name: 'ML_COMMENT',
+                GROUP: 'hidden',
+                LINE_BREAKS: true,
+                PATTERN: mlCommentPattern
+            };
+        }
         if (terminal.name === 'MARKDOWN_LINK') {
             return {
                 name: 'MARKDOWN_LINK',

package/src/reqlan-validator.ts

@@ -7,6 +7,7 @@ import {
     isInvalidFromImport,
     isModel,
     isOneLinerIdea,
+    isWildcardReference,
     type AnonymousBlock,
     type Model
 } from './generated/ast.js';
@@ -23,6 +24,11 @@ import { isResolvableImportPath } from './reqlan-imports.js';
 import type { ReqlanServices } from './reqlan-module.js';
 import { pathResolveContextFromServices } from './reqlan-path-resolve.js';
 import { unquoteReqlanString } from './reqlan-quoted-strings.js';
+import {
+    resolveWildcardReferenceMatches,
+    parseWildcardPathPattern,
+    wildcardReferenceLabel
+} from './reqlan-wildcard-resolve.js';
 
 /**
  * Registers validation hooks for the requirement graph AST.
@@ -58,6 +64,7 @@ export class ReqlanValidator {
         this.checkImportSyntax(model, accept);
         this.checkImportTargets(model, accept);
         this.checkFileReferenceTargets(model, accept);
+        this.checkWildcardReferences(model, accept);
     }
 
     /**
@@ -204,6 +211,33 @@ export class ReqlanValidator {
             });
         }
     }
+
+    checkWildcardReferences(model: Model, accept: ValidationAcceptor): void {
+        const { shared } = this.services;
+        const context = pathResolveContextFromServices(this.services);
+        for (const node of AstUtils.streamAst(model)) {
+            if (!isWildcardReference(node)) {
+                continue;
+            }
+            const path = parseWildcardPathPattern(node.pathPattern);
+            if (!path.trim()) {
+                accept('warning', 'Wildcard path pattern is empty.', { node, property: 'pathPattern' });
+                continue;
+            }
+            const matches = resolveWildcardReferenceMatches(
+                node,
+                shared.workspace.LangiumDocuments,
+                context
+            );
+            if (matches.length === 0) {
+                accept(
+                    'warning',
+                    `No ideas match wildcard reference [${wildcardReferenceLabel(path, node.ideaPattern)}].`,
+                    { node }
+                );
+            }
+        }
+    }
 }
 
 type ImportBindingSource = ReturnType<typeof importBindings>[number];