@reqlan/language 1.6.2 → 1.8.1

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-linker.ts

@@ -5,7 +5,7 @@
  */
 import type { AstNode, FileSystemProvider, LangiumDocument, LangiumDocuments, ReferenceInfo } from 'langium';
 import { AstUtils, DefaultLinker, type DefaultReference } from 'langium';
-import { isLocalReference, isModel, isQualifiedReference } from './generated/ast.js';
+import { isIdea, isIdeaSet, isLocalReference, isModel, isOneLinerIdea, isQualifiedReference } from './generated/ast.js';
 import { isOpaqueFileReferencePath } from './reqlan-file-references.js';
 import { findNamespaceImportByAlias } from './reqlan-import-bindings.js';
 import { isResolvableImportPath } from './reqlan-imports.js';
@@ -69,7 +69,9 @@ export class ReqlanLinker extends DefaultLinker {
             return false;
         }
         const name = refInfo.reference.$refText;
-        if (model.elements.some(element => element.name === name)) {
+        if (model.elements.some(element =>
+            (isIdea(element) || isOneLinerIdea(element) || isIdeaSet(element)) && element.name === name
+        )) {
             return false;
         }
         return findNamespaceImportByAlias(model.imports, name) !== undefined;

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-module.ts

@@ -1,4 +1,4 @@
-import { type Module, inject } from 'langium';
+import { type Module, inject, type PartialLangiumSharedCoreServices } from 'langium';
 import { createDefaultModule, createDefaultSharedModule, type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
 import { ReqlanGeneratedModule, ReqlanGeneratedSharedModule } from './generated/module.js';
 import { ReqlanDefinitionProvider } from './reqlan-definition-provider.js';
@@ -18,6 +18,9 @@ import { ReqlanSemanticTokenProvider } from './reqlan-semantic-token-provider.js
 import { ReqlanTokenBuilder } from './reqlan-token-builder.js';
 import { registerRqIgnoreErrorFiltering } from './reqlan-ignore-error.js';
 import { ReqlanValidator, registerValidationChecks } from './reqlan-validator.js';
+import { ReqlanWorkspaceManager } from './reqlan-workspace-manager.js';
+import { ReqlanAsyncParser } from './reqlan-async-parser.js';
+import { ReqlanLangiumDocumentFactory } from './reqlan-document-factory.js';
 
 /**
  * Declaration of custom services - add your own service classes here.
@@ -39,6 +42,13 @@ export type ReqlanServices = LangiumServices & ReqlanAddedServices
  * declared custom services. The Langium defaults can be partially specified to override only
  * selected services, while the custom services must be fully specified.
  */
+export const ReqlanSharedModule: Module<LangiumSharedServices, PartialLangiumSharedCoreServices> = {
+    workspace: {
+        WorkspaceManager: services => new ReqlanWorkspaceManager(services),
+        LangiumDocumentFactory: services => new ReqlanLangiumDocumentFactory(services)
+    }
+};
+
 export const ReqlanModule: Module<ReqlanServices, PartialLangiumServices & ReqlanAddedServices> = {
     validation: {
         ReqlanValidator: services => new ReqlanValidator(services)
@@ -51,7 +61,8 @@ export const ReqlanModule: Module<ReqlanServices, PartialLangiumServices & Reqla
     },
     parser: {
         GrammarConfig: createReqlanGrammarConfig,
-        TokenBuilder: () => new ReqlanTokenBuilder()
+        TokenBuilder: () => new ReqlanTokenBuilder(),
+        AsyncParser: (services: ReqlanServices) => new ReqlanAsyncParser(services)
     },
     lsp: {
         DefinitionProvider: services => new ReqlanDefinitionProvider(services),
@@ -87,7 +98,8 @@ export function createReqlanServices(context: DefaultSharedModuleContext): {
 } {
     const shared = inject(
         createDefaultSharedModule(context),
-        ReqlanGeneratedSharedModule
+        ReqlanGeneratedSharedModule,
+        ReqlanSharedModule
     );
     const Reqlan = inject(
         createDefaultModule({ shared }),

package/src/reqlan-parse-budget.ts

@@ -0,0 +1,155 @@
+/**
+ * Per-file parse/lex budget: if a document cannot finish within the budget,
+ * return an empty model plus warning + error diagnostics instead of hanging the host.
+ * rq:["../../../reqlan rq/language/parser_lexer.rq".parse_budget_timeout]
+ */
+import type { AstNode, LangiumParser, ParseResult } from 'langium';
+
+/** Default wall-clock budget for lex+parse of one file (worker-enforced). */
+export const DEFAULT_PARSE_BUDGET_MS = 8_000;
+
+/**
+ * Prefer in-process sync parse below this size. Worker threads (killable budget)
+ * are reserved for larger inputs, hang-sentinel tests, sticky timeout escalation,
+ * or an explicit force.
+ */
+export const DEFAULT_WORKER_PARSE_THRESHOLD_CHARS = 64_000;
+
+/** Test-only sentinel: a worker that sees this marker hangs until terminated. */
+export const PARSE_HANG_SENTINEL = '__REQLAN_PARSE_HANG__';
+
+export const PARSE_TIMEOUT_WARNING =
+    'Parse budget exceeded for this file; semantic features may be incomplete until the file is simplified or the budget is raised.';
+
+export function parseTimeoutErrorMessage(timeoutMs: number): string {
+    return `Failed to lex/parse this file within ${timeoutMs}ms; left unloaded so the rest of the workspace can continue.`;
+}
+
+export function parseFailureErrorMessage(cause: string): string {
+    return `Lex/parse aborted for this file (${cause}); left unloaded so the rest of the workspace can continue.`;
+}
+
+export type ParseWorkerMode = boolean | 'auto';
+
+export interface ParseWorkerEscalationOptions {
+    /** `auto` (default): sync below threshold; worker for large / sentinel / force. */
+    useWorker?: ParseWorkerMode;
+    forceWorker?: boolean;
+    thresholdChars?: number;
+}
+
+/** Whether this parse should run in a killable worker thread. */
+export function shouldEscalateToParseWorker(
+    text: string,
+    options: ParseWorkerEscalationOptions = {}
+): boolean {
+    const mode = options.useWorker ?? 'auto';
+    if (mode === false) {
+        return false;
+    }
+    if (mode === true || options.forceWorker) {
+        return true;
+    }
+    if (text.includes(PARSE_HANG_SENTINEL)) {
+        return true;
+    }
+    const threshold = options.thresholdChars ?? DEFAULT_WORKER_PARSE_THRESHOLD_CHARS;
+    return text.length >= threshold;
+}
+
+/** Lexer error plus optional severity used for budget-timeout warnings. */
+export type ReqlanLexerError = ParseResult['lexerErrors'][number] & {
+    severity?: 'warning' | 'error' | 'info' | 'hint';
+};
+
+export interface ReqlanParseResult<T extends AstNode = AstNode> extends Omit<ParseResult<T>, 'lexerErrors'> {
+    lexerErrors: ReqlanLexerError[];
+    /** Set when lex/parse did not complete successfully within budget (timeout or crash). */
+    reqlanIncomplete?: {
+        reason: 'timeout' | 'failure';
+        timeoutMs?: number;
+        cause?: string;
+    };
+}
+
+export function isReqlanIncompleteParseResult(
+    result: ParseResult
+): result is ReqlanParseResult {
+    return Boolean((result as ReqlanParseResult).reqlanIncomplete);
+}
+
+interface PlaceholderToken {
+    image: string;
+    startOffset: number;
+    endOffset: number;
+    startLine: number;
+    endLine: number;
+    startColumn: number;
+    endColumn: number;
+    tokenTypeIdx: number;
+    tokenType: { name: string };
+}
+
+function placeholderToken(): PlaceholderToken {
+    return {
+        image: '',
+        startOffset: Number.NaN,
+        endOffset: Number.NaN,
+        startLine: Number.NaN,
+        endLine: Number.NaN,
+        startColumn: Number.NaN,
+        endColumn: Number.NaN,
+        tokenTypeIdx: -1,
+        tokenType: { name: 'EOF' }
+    };
+}
+
+function timeoutParserError(message: string) {
+    return {
+        name: 'ReqlanParseTimeout',
+        message,
+        token: placeholderToken(),
+        resyncedTokens: [],
+        context: {
+            ruleStack: [],
+            ruleOccurrenceStack: []
+        }
+    };
+}
+
+function timeoutLexerWarning(message: string): ReqlanLexerError {
+    return {
+        offset: 0,
+        line: 1,
+        column: 1,
+        length: 1,
+        message,
+        severity: 'warning'
+    };
+}
+
+/**
+ * Empty model with a lexer warning and a parser error so the editor shows both severities.
+ */
+export function createIncompleteParseResult<T extends AstNode>(
+    parser: LangiumParser,
+    options: {
+        reason: 'timeout' | 'failure';
+        timeoutMs?: number;
+        cause?: string;
+    }
+): ReqlanParseResult<T> {
+    const empty = parser.parse('') as ReqlanParseResult<T>;
+    const errorMessage = options.reason === 'timeout'
+        ? parseTimeoutErrorMessage(options.timeoutMs ?? DEFAULT_PARSE_BUDGET_MS)
+        : parseFailureErrorMessage(options.cause ?? 'unexpected error');
+    // Casts: Chevrotain exception shapes are structural; Langium only needs message + token positions.
+    empty.parserErrors = [timeoutParserError(errorMessage) as ReqlanParseResult<T>['parserErrors'][number]];
+    empty.lexerErrors = [timeoutLexerWarning(PARSE_TIMEOUT_WARNING)];
+    empty.reqlanIncomplete = {
+        reason: options.reason,
+        timeoutMs: options.timeoutMs,
+        cause: options.cause
+    };
+    return empty;
+}

package/src/reqlan-parse-worker.ts

@@ -0,0 +1,35 @@
+/**
+ * Langium worker-thread parse entry: sync lex/parse, dehydrate, postMessage.
+ * The parent enforces the wall-clock budget via worker.terminate().
+ * rq:["../../../reqlan rq/language/parser_lexer.rq".parse_budget_timeout]
+ */
+import { parentPort } from 'node:worker_threads';
+import { EmptyFileSystem } from 'langium';
+import { createReqlanServices } from './reqlan-module.js';
+import { PARSE_HANG_SENTINEL } from './reqlan-parse-budget.js';
+
+if (!parentPort) {
+    throw new Error('reqlan-parse-worker must run as a worker thread');
+}
+
+const { Reqlan } = createReqlanServices(EmptyFileSystem);
+const parser = Reqlan.parser.LangiumParser;
+const hydrator = Reqlan.serializer.Hydrator;
+
+parentPort.on('message', (text: unknown) => {
+    const input = typeof text === 'string' ? text : '';
+    if (input.includes(PARSE_HANG_SENTINEL)) {
+        // Intentional hang for tests — parent terminates on budget expiry.
+        for (;;) {
+            /* spin */
+        }
+    }
+    try {
+        const result = parser.parse(input);
+        parentPort!.postMessage(hydrator.dehydrate(result));
+    } catch (error) {
+        // Surface as worker 'error' so ParserWorker rejects instead of hydrating garbage.
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`reqlan parse worker failed: ${message}`);
+    }
+});

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 });