@reqlan/language 1.6.2 → 1.8.1

package/src/generated/module.ts

@@ -11,14 +11,14 @@ export const ReqlanLanguageMetaData = {
     languageId: 'reqlan',
     fileExtensions: ['.rq'],
     caseInsensitive: false,
-    mode: 'development'
+    mode: 'production'
 } as const satisfies LanguageMetaData;
 
 export const ReqlanCommentLanguageMetaData = {
     languageId: 'reqlan-comment',
     fileExtensions: [],
     caseInsensitive: false,
-    mode: 'development'
+    mode: 'production'
 } as const satisfies LanguageMetaData;
 
 export const ReqlanGeneratedSharedModule: Module<LangiumSharedCoreServices, LangiumGeneratedSharedCoreServices> = {

package/src/index.ts

@@ -1,4 +1,7 @@
 export * from './reqlan-module.js';
+export * from './reqlan-parse-budget.js';
+export { ReqlanAsyncParser, resolveParseWorkerPath } from './reqlan-async-parser.js';
+export { ReqlanLangiumDocumentFactory } from './reqlan-document-factory.js';
 export * from './reqlan-validator.js';
 export * from './reqlan-comment-resolver.js';
 export * from './reqlan-ignore-error.js';
@@ -20,6 +23,7 @@ export * from './reqlan-path-resolve.js';
 export * from './reqlan-imports.js';
 export * from './reqlan-quoted-strings.js';
 export * from './reqlan-references.js';
+export * from './reqlan-wildcard-resolve.js';
 export * from './reqlan-reference-at-position.js';
 export * from './reqlan-attribute-catalog.js';
 export * from './reqlan-completion-context.js';

package/src/reqlan-async-parser.ts

@@ -0,0 +1,178 @@
+/**
+ * Per-file parse budget via Langium's worker-thread async parser.
+ * Happy path is in-process sync parse; workers enforce a killable wall-clock budget
+ * for large files, sticky timeout escalation, or explicit force.
+ * rq:["../../../reqlan rq/language/parser_lexer.rq".parse_budget_timeout]
+ */
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+    type AstNode,
+    type LangiumCoreServices,
+    type LangiumParser
+} from 'langium';
+import { WorkerThreadAsyncParser } from 'langium/node';
+import {
+    CancellationToken,
+    CancellationTokenSource
+} from 'vscode-languageserver';
+import {
+    createIncompleteParseResult,
+    DEFAULT_PARSE_BUDGET_MS,
+    DEFAULT_WORKER_PARSE_THRESHOLD_CHARS,
+    type ParseWorkerMode,
+    type ReqlanParseResult,
+    shouldEscalateToParseWorker
+} from './reqlan-parse-budget.js';
+
+export interface ReqlanAsyncParserOptions {
+    timeoutMs?: number;
+    /** Override worker script path (tests). */
+    workerPath?: string;
+    /**
+     * `auto` (default): sync below size threshold; worker when escalated.
+     * `true` / `false`: always / never use workers.
+     */
+    useWorker?: ParseWorkerMode;
+    /** Characters at or above which `auto` mode uses a worker. */
+    workerThresholdChars?: number;
+    /** Worker pool size (Langium default is 8; keep small for startup). */
+    threadCount?: number;
+}
+
+export interface ReqlanParseCallOptions {
+    /** Force the killable worker path for this call (sticky URI escalate, tests). */
+    forceWorker?: boolean;
+}
+
+/**
+ * Directory of this module (or of the CJS bundle that inlined it).
+ * Avoid static `import.meta.url`: esbuild format cjs + target es2017 empties it
+ * (see reqlan rq/extension/startup-performance.rq invalid_url_activation_failure).
+ */
+declare const __dirname: string | undefined;
+
+function moduleDirectory(): string {
+    if (typeof __dirname === 'string') {
+        return __dirname;
+    }
+    // Native ESM only — hide from esbuild's empty-import-meta rewrite.
+    const metaUrl = (0, eval)('import.meta.url') as string;
+    return dirname(fileURLToPath(metaUrl));
+}
+
+export function resolveParseWorkerPath(explicit?: string): string {
+    if (explicit) {
+        return explicit;
+    }
+    const dir = moduleDirectory();
+    const jsPath = join(dir, 'reqlan-parse-worker.js');
+    if (existsSync(jsPath)) {
+        return jsPath;
+    }
+    const cjsPath = join(dir, 'reqlan-parse-worker.cjs');
+    if (existsSync(cjsPath)) {
+        return cjsPath;
+    }
+    return jsPath;
+}
+
+export class ReqlanAsyncParser extends WorkerThreadAsyncParser {
+    private readonly timeoutMs: number;
+    private readonly useWorker: ParseWorkerMode;
+    private readonly workerThresholdChars: number;
+    private readonly syncParser: LangiumParser;
+
+    constructor(services: LangiumCoreServices, options: ReqlanAsyncParserOptions = {}) {
+        super(services, () => resolveParseWorkerPath(options.workerPath));
+        this.syncParser = services.parser.LangiumParser;
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_PARSE_BUDGET_MS;
+        this.useWorker = options.useWorker ?? 'auto';
+        this.workerThresholdChars = options.workerThresholdChars ?? DEFAULT_WORKER_PARSE_THRESHOLD_CHARS;
+        this.threadCount = options.threadCount ?? 2;
+        // Fail fast after cancel so the budget is close to timeoutMs wall-clock.
+        this.terminationDelay = 50;
+    }
+
+    override async parse<T extends AstNode>(
+        text: string,
+        cancelToken: CancellationToken,
+        callOptions: ReqlanParseCallOptions = {}
+    ): Promise<ReqlanParseResult<T>> {
+        if (cancelToken.isCancellationRequested) {
+            return createIncompleteParseResult<T>(this.syncParser, {
+                reason: 'failure',
+                cause: 'cancelled'
+            });
+        }
+
+        const escalate = shouldEscalateToParseWorker(text, {
+            useWorker: this.useWorker,
+            forceWorker: callOptions.forceWorker,
+            thresholdChars: this.workerThresholdChars
+        });
+        if (!escalate) {
+            return this.parseOnThread<T>(text);
+        }
+
+        return this.parseInWorker<T>(text, cancelToken);
+    }
+
+    /** Sync entry used by document factory / tests. */
+    parseSync<T extends AstNode>(text: string): ReqlanParseResult<T> {
+        return this.parseOnThread<T>(text);
+    }
+
+    private async parseInWorker<T extends AstNode>(
+        text: string,
+        cancelToken: CancellationToken
+    ): Promise<ReqlanParseResult<T>> {
+        const timeoutSource = new CancellationTokenSource();
+        const timer = setTimeout(() => timeoutSource.cancel(), this.timeoutMs);
+        const callerCancel = cancelToken.onCancellationRequested(() => {
+            timeoutSource.cancel();
+        });
+
+        try {
+            return await super.parse<T>(text, timeoutSource.token) as ReqlanParseResult<T>;
+        } catch (error) {
+            if (timeoutSource.token.isCancellationRequested) {
+                if (cancelToken.isCancellationRequested) {
+                    return createIncompleteParseResult<T>(this.syncParser, {
+                        reason: 'failure',
+                        cause: 'cancelled'
+                    });
+                }
+                return createIncompleteParseResult<T>(this.syncParser, {
+                    reason: 'timeout',
+                    timeoutMs: this.timeoutMs
+                });
+            }
+            return createIncompleteParseResult<T>(this.syncParser, {
+                reason: 'failure',
+                cause: error instanceof Error ? error.message : String(error)
+            });
+        } finally {
+            clearTimeout(timer);
+            callerCancel.dispose();
+            timeoutSource.dispose();
+        }
+    }
+
+    private parseOnThread<T extends AstNode>(text: string): ReqlanParseResult<T> {
+        try {
+            return this.syncParser.parse(text) as ReqlanParseResult<T>;
+        } catch (error) {
+            return createIncompleteParseResult<T>(this.syncParser, {
+                reason: 'failure',
+                cause: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+
+    /** Exposed for tests that need the underlying sync parser. */
+    get langiumParser(): LangiumParser {
+        return this.syncParser;
+    }
+}

package/src/reqlan-code-action-provider.ts

@@ -1,8 +1,11 @@
 /**
  * Quick fixes for unresolved references: add import, rewrite qualified ref, search, create.
  * Also offers a search code action when the cursor is inside a [reference] / [[wikilink]].
+ * File-level source actions include barrel page.
  * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_error]
  * rq:["../../../reqlan rq/extension/features-commands.rq".search_code_actions]
+ * rq:["../../../reqlan rq/extension/features-commands.rq".barrel_page]
+ * rq:["../../../reqlan rq/extension/features-commands.rq".file_based_code_actions]
  */
 import type { LangiumDocument, URI } from 'langium';
 import { AstUtils, DocumentValidator, URI as UriCtor, UriUtils } from 'langium';
@@ -27,13 +30,16 @@ import {
     type NameCatalogEntry,
     type NameCatalogKind
 } from './reqlan-name-catalog.js';
-import { findReferenceSearchSite, buildContextForRange } from './reqlan-reference-search-site.js';
+import { findReferenceSearchSite } from './reqlan-reference-search-site.js';
 
 export const REQLAN_IMPORT_ERROR_SEARCH_COMMAND = 'reqlan.importError.search';
 export const REQLAN_IMPORT_ERROR_CREATE_COMMAND = 'reqlan.importError.createFile';
 export const REQLAN_SEARCH_REFERENCE_COMMAND = 'reqlan.searchReference';
 export const REQLAN_REFACTOR_DELETE_IDEA_COMMAND = 'reqlan.refactor.deleteIdea';
 export const REQLAN_REFACTOR_MOVE_IDEA_COMMAND = 'reqlan.refactor.moveIdea';
+export const REQLAN_BARREL_PAGE_COMMAND = 'reqlan.barrelPage';
+/** Source-action kind for whole-file barrel page. */
+export const REQLAN_BARREL_PAGE_KIND = `${CodeActionKind.Source}.barrelPage`;
 
 /** Args for idea move/delete refactor commands. */
 export interface IdeaRefactorCommandArgs {
@@ -58,18 +64,7 @@ export interface ImportErrorCommandArgs {
 }
 
 /** Args for reference search webview (replace existing ref or wrap prose). */
-export interface SearchReferenceCommandArgs {
-    documentUri: string;
-    refText: string;
-    range: Diagnostic['range'];
-    mode: 'replace' | 'wrap';
-    context?: {
-        ideaName: string;
-        before: string;
-        target: string;
-        after: string;
-    };
-}
+export type SearchReferenceCommandArgs = import('./reqlan-reference-search-site.js').ReferenceSearchSiteRequestResult;
 
 interface SymbolMatch {
     name: string;
@@ -99,9 +94,40 @@ export class ReqlanCodeActionProvider implements CodeActionProvider {
             actions.push(searchFromCursor);
         }
         actions.push(...this.createIdeaRefactorActions(document, params));
+        const barrelPage = this.createBarrelPageAction(document, params);
+        if (barrelPage) {
+            actions.push(barrelPage);
+        }
         return actions;
     }
 
+    /**
+     * Whole-file source action: barrel top-level ideas into sibling files + container.
+     * rq:["../../../reqlan rq/extension/features-commands.rq".barrel_page]
+     * rq:["../../../reqlan rq/extension/features-commands.rq".file_based_code_actions]
+     */
+    private createBarrelPageAction(
+        document: LangiumDocument,
+        params: CodeActionParams
+    ): CodeActionLike | undefined {
+        if (!actionKindAllowed(params.context.only, REQLAN_BARREL_PAGE_KIND)) {
+            return undefined;
+        }
+        if (!documentHasTopLevelIdeas(document)) {
+            return undefined;
+        }
+        // No command arguments: VS Code caches arg-bearing commands and may dispose
+        // them when code actions refresh. The extension resolves the active editor.
+        return {
+            title: 'Barrel page into container…',
+            kind: REQLAN_BARREL_PAGE_KIND,
+            command: {
+                title: 'Barrel page',
+                command: REQLAN_BARREL_PAGE_COMMAND
+            }
+        };
+    }
+
     /**
      * rq:["../../../reqlan rq/extension/refactor_support.rq".refactor_symbol_move]
      * rq:["../../../reqlan rq/extension/refactor_support.rq".refactor_symbol_delete]
@@ -163,13 +189,11 @@ export class ReqlanCodeActionProvider implements CodeActionProvider {
         if (alreadyHasSearch) {
             return undefined;
         }
-        const args: SearchReferenceCommandArgs = {
-            documentUri: document.textDocument.uri,
-            refText: site.refText,
-            range: site.range,
-            mode: site.mode,
-            context: site.context
-        };
+        // No command arguments: VS Code caches arg-bearing commands and disposes
+        // them when code actions refresh (common under Langium revalidation),
+        // which surfaces as "Actual command not found, wanted to execute
+        // reqlan.searchReference /N". The extension resolves the site from the
+        // active editor when the command runs.
         const title = site.mode === 'wrap'
             ? (site.refText
                 ? `Wrap '${site.refText}' as idea reference…`
@@ -182,8 +206,7 @@ export class ReqlanCodeActionProvider implements CodeActionProvider {
             kind: CodeActionKind.Refactor,
             command: {
                 title: 'Search for idea reference',
-                command: REQLAN_SEARCH_REFERENCE_COMMAND,
-                arguments: [args]
+                command: REQLAN_SEARCH_REFERENCE_COMMAND
             }
         };
     }
@@ -335,25 +358,17 @@ export class ReqlanCodeActionProvider implements CodeActionProvider {
     }
 
     private createSearchCommand(
-        document: LangiumDocument,
+        _document: LangiumDocument,
         diagnostic: Diagnostic,
         refText: string
     ): CodeActionLike {
-        const args: SearchReferenceCommandArgs = {
-            documentUri: document.textDocument.uri,
-            refText,
-            range: diagnostic.range,
-            mode: 'replace',
-            context: buildContextForRange(document, diagnostic.range)
-        };
         return {
             title: `Search for idea to replace '${refText}'…`,
             kind: CodeActionKind.QuickFix,
             diagnostics: [diagnostic],
             command: {
                 title: `Search for idea to replace '${refText}'`,
-                command: REQLAN_SEARCH_REFERENCE_COMMAND,
-                arguments: [args]
+                command: REQLAN_SEARCH_REFERENCE_COMMAND
             }
         };
     }
@@ -385,6 +400,26 @@ function isResolvableIdeaProperty(property: string | undefined): boolean {
     return property === 'idea' || property === 'ideaset' || property === 'members';
 }
 
+/** True when `only` is unset or the action kind matches a requested kind (LSP subtype rules). */
+export function actionKindAllowed(only: readonly string[] | undefined, kind: string): boolean {
+    if (!only || only.length === 0) {
+        return true;
+    }
+    return only.some(requested =>
+        kind === requested
+        || kind.startsWith(`${requested}.`)
+        || requested.startsWith(`${kind}.`)
+    );
+}
+
+function documentHasTopLevelIdeas(document: LangiumDocument): boolean {
+    const model = document.parseResult.value;
+    if (!isModel(model)) {
+        return false;
+    }
+    return model.elements.some(element => isRefactorIdeaDeclaration(element));
+}
+
 function rangesOverlap(
     left: { start: { line: number; character: number }; end: { line: number; character: number } },
     right: { start: { line: number; character: number }; end: { line: number; character: number } }

package/src/reqlan-comment-resolver.ts

@@ -169,6 +169,11 @@ export function findCommentSpansInText(text: string): CommentSpan[] {
             continue;
         }
         if (char === '/' && next === '*') {
+            // Empty slash-star-star-slash is a glob segment, not a block comment (same as .rq lexer).
+            if (text[index + 2] === '*' && text[index + 3] === '/') {
+                index += 4;
+                continue;
+            }
             blockComment = 'slash';
             lineCommentStart = index;
             index += 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 {
@@ -124,7 +133,7 @@ export class ReqlanCompletionProvider extends DefaultCompletionProvider {
                 return [];
             }
             return model.elements
-                .filter(element => {
+                .filter((element): element is typeof element & { name: string } => {
                     if (refInfo.property === 'ideaset') {
                         return isIdeaSet(element);
                     }
@@ -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 {