@reqlan/language 1.6.2 → 1.8.1

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;
@@ -108,7 +132,15 @@ const markdownLink = (text: string, offset: number): RegExpExecArray | null => {
     return null;
 };
 
-const topLevelBlockOpener = /(?:^|\n)[ \t]*(?:[A-Za-z_.][\w.-]*|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\s*$/;
+const blockOpenerLine = /^[ \t]*(?:[A-Za-z_.][\w.-]*|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\s*$/;
+
+function lineStartOffset(text: string, offset: number): number {
+    return text.lastIndexOf('\n', offset - 1) + 1;
+}
+
+function textBeforeOnLine(text: string, offset: number): string {
+    return text.slice(lineStartOffset(text, offset), offset).replace(/[ \t]+$/, '');
+}
 
 function isEscapedAt(text: string, offset: number): boolean {
     let backslashes = 0;
@@ -125,9 +157,11 @@ function isStructuralOpenBraceAtDepth(text: string, offset: number, depth: numbe
     if (isEscapedAt(text, offset)) {
         return false;
     }
-    const before = text.slice(0, offset).replace(/[ \t]+$/, '');
+    const before = textBeforeOnLine(text, offset);
 
-    if (depth === 0 && topLevelBlockOpener.test(before)) {
+    // Top-level named blocks (`name {`) and nameless recoverable blocks (`{` alone).
+    // Leading indentation is allowed — top-level ideas are often indented in fixtures.
+    if (depth === 0 && (blockOpenerLine.test(before) || (isLineStartAt(text, offset) && before.trim().length === 0))) {
         return true;
     }
     if (/@[A-Za-z_][\w-]*(?::)?\s*$/.test(before)) {
@@ -137,8 +171,7 @@ function isStructuralOpenBraceAtDepth(text: string, offset: number, depth: numbe
         return true;
     }
     if (depth >= 1 && /[A-Za-z_][\w-]*\s*$/.test(before) && !isLineStartAt(text, offset)) {
-        const after = text.slice(offset + 1);
-        return /^[ \t]*(?:\r?\n|$)/.test(after);
+        return restOfLineIsBlank(text, offset);
     }
     return false;
 }
@@ -156,12 +189,10 @@ function isStructuralCloseBraceAt(text: string, offset: number): boolean {
     if (isEscapedAt(text, offset)) {
         return false;
     }
-    const after = text.slice(offset + 1);
-    const restOfLine = after.split(/\r?\n/, 1)[0] ?? '';
-    if (restOfLine.trim().length !== 0) {
+    if (!restOfLineIsBlank(text, offset)) {
         return false;
     }
-    const { structuralDepth, proseDepth } = scanBraceState(text, offset);
+    const { structuralDepth, proseDepth } = braceStateBefore(text, offset);
     if (structuralDepth <= 0) {
         return false;
     }
@@ -176,16 +207,84 @@ interface BraceScanState {
     proseDepth: number;
 }
 
-function scanBraceState(text: string, offset: number): BraceScanState {
+/**
+ * Sparse depth timeline: event `i` applies for offsets in
+ * [offsets[i], offsets[i + 1]). Avoids O(n) Int32Arrays on every re-lex.
+ */
+interface BraceScanCache {
+    text: string;
+    offsets: number[];
+    structuralDepth: number[];
+    proseDepth: number[];
+}
+
+let braceScanCache: BraceScanCache | undefined;
+
+function fenceEndAfter(text: string, openOffset: number): number {
+    // Match CODE_FENCE: ```…``` including optional body; return index after closing fence.
+    if (
+        text.charCodeAt(openOffset) !== 96
+        || text.charCodeAt(openOffset + 1) !== 96
+        || text.charCodeAt(openOffset + 2) !== 96
+    ) {
+        return openOffset;
+    }
+    const afterOpen = openOffset + 3;
+    const firstNewline = text.indexOf('\n', afterOpen);
+    if (firstNewline < 0) {
+        const sameLineClose = text.indexOf('```', afterOpen);
+        return sameLineClose < 0 ? text.length : sameLineClose + 3;
+    }
+    const close = text.indexOf('```', firstNewline + 1);
+    return close < 0 ? text.length : close + 3;
+}
+
+function restOfLineIsBlank(text: string, offset: number): boolean {
+    for (let index = offset + 1; index < text.length; index++) {
+        const char = text[index];
+        if (char === '\n' || char === '\r') {
+            return true;
+        }
+        if (char !== ' ' && char !== '\t') {
+            return false;
+        }
+    }
+    return true;
+}
+
+function buildBraceScanCache(text: string): BraceScanCache {
     let structuralDepth = 0;
     const proseDepthByStructural: number[] = [0];
+    const offsets = [0];
+    const structuralDepthAt = [0];
+    const proseDepthAtOffsets = [0];
 
     const proseDepthAt = (): number => proseDepthByStructural[structuralDepth] ?? 0;
     const setProseDepth = (value: number): void => {
         proseDepthByStructural[structuralDepth] = value;
     };
+    const recordStateFrom = (offset: number): void => {
+        const last = offsets.length - 1;
+        if (offsets[last] === offset) {
+            structuralDepthAt[last] = structuralDepth;
+            proseDepthAtOffsets[last] = proseDepthAt();
+            return;
+        }
+        offsets.push(offset);
+        structuralDepthAt.push(structuralDepth);
+        proseDepthAtOffsets.push(proseDepthAt());
+    };
 
-    for (let index = 0; index < offset; index++) {
+    for (let index = 0; index < text.length; index++) {
+        // Fenced snippets are opaque to the parser; braces inside must not change depth.
+        if (
+            text.charCodeAt(index) === 96
+            && text.charCodeAt(index + 1) === 96
+            && text.charCodeAt(index + 2) === 96
+        ) {
+            index = fenceEndAfter(text, index) - 1;
+            continue;
+        }
         const char = text[index];
         if (char === '{') {
             if (isEscapedAt(text, index)) {
@@ -197,6 +296,7 @@ function scanBraceState(text: string, offset: number): BraceScanState {
             } else {
                 setProseDepth(proseDepthAt() + 1);
             }
+            recordStateFrom(index + 1);
             continue;
         }
         if (char !== '}') {
@@ -205,23 +305,24 @@ function scanBraceState(text: string, offset: number): BraceScanState {
         if (isEscapedAt(text, index)) {
             continue;
         }
-        const after = text.slice(index + 1);
-        const restOfLine = after.split(/\r?\n/, 1)[0] ?? '';
-        const atEndOfLine = restOfLine.trim().length === 0;
+        const atEndOfLine = restOfLineIsBlank(text, index);
         if (!atEndOfLine) {
             if (proseDepthAt() > 0) {
                 setProseDepth(proseDepthAt() - 1);
+                recordStateFrom(index + 1);
             }
             continue;
         }
         if (structuralDepth <= 0) {
             if (proseDepthAt() > 0) {
                 setProseDepth(proseDepthAt() - 1);
+                recordStateFrom(index + 1);
             }
             continue;
         }
         if (isLineStartAt(text, index)) {
             structuralDepth--;
+            recordStateFrom(index + 1);
             continue;
         }
         if (proseDepthAt() > 0) {
@@ -229,20 +330,41 @@ function scanBraceState(text: string, offset: number): BraceScanState {
         } else {
             structuralDepth--;
         }
+        recordStateFrom(index + 1);
     }
 
+    return { text, offsets, structuralDepth: structuralDepthAt, proseDepth: proseDepthAtOffsets };
+}
+
+function braceStateAtOffset(cache: BraceScanCache, offset: number): BraceScanState {
+    const { offsets, structuralDepth, proseDepth } = cache;
+    let low = 0;
+    let high = offsets.length - 1;
+    while (low <= high) {
+        const mid = (low + high) >> 1;
+        if (offsets[mid]! <= offset) {
+            low = mid + 1;
+        } else {
+            high = mid - 1;
+        }
+    }
+    const index = Math.max(0, high);
     return {
-        structuralDepth,
-        proseDepth: proseDepthAt()
+        structuralDepth: structuralDepth[index] ?? 0,
+        proseDepth: proseDepth[index] ?? 0
     };
 }
 
-function scanStructuralBraceDepth(text: string, offset: number): number {
-    return scanBraceState(text, offset).structuralDepth;
+function braceStateBefore(text: string, offset: number): BraceScanState {
+    if (braceScanCache?.text !== text) {
+        braceScanCache = buildBraceScanCache(text);
+    }
+    const boundedOffset = Math.max(0, Math.min(offset, text.length));
+    return braceStateAtOffset(braceScanCache, boundedOffset);
 }
 
 function isStructuralOpenBraceAt(text: string, offset: number): boolean {
-    return isStructuralOpenBraceAtDepth(text, offset, scanStructuralBraceDepth(text, offset));
+    return isStructuralOpenBraceAtDepth(text, offset, braceStateBefore(text, offset).structuralDepth);
 }
 
 const structuralOpenBrace = (text: string, offset: number): RegExpExecArray | null => {
@@ -274,7 +396,7 @@ const proseCloseBrace = (text: string, offset: number): RegExpExecArray | null =
 };
 
 function braceDepthBefore(text: string, offset: number): number {
-    return scanStructuralBraceDepth(text, offset);
+    return braceStateBefore(text, offset).structuralDepth;
 }
 
 function isLineStartAt(text: string, offset: number): boolean {
@@ -287,15 +409,14 @@ function isLineStartAt(text: string, offset: number): boolean {
 
 function isStringLiteralContext(text: string, offset: number): boolean {
     const depth = braceDepthBefore(text, offset);
-    const trimmed = text.slice(0, offset).replace(/[ \t]+$/, '');
+    const trimmed = textBeforeOnLine(text, offset);
     if (depth === 0 && /\b(?:from|import)\s*$/.test(trimmed)) {
         return true;
     }
     if (/\[\s*$/.test(trimmed)) {
         return true;
     }
-    const lineStart = trimmed.lastIndexOf('\n') + 1;
-    if (trimmed.slice(lineStart).length === 0 && depth === 0) {
+    if (trimmed.length === 0 && depth === 0) {
         return true;
     }
     return false;
@@ -330,7 +451,7 @@ function topLevelImportKeyword(text: string, offset: number): RegExpExecArray |
     if (isLineStartAt(text, offset)) {
         return makeMatch(text, offset, 6);
     }
-    const before = text.slice(0, offset).replace(/[ \t]+$/, '');
+    const before = textBeforeOnLine(text, offset);
     if (/(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')$/.test(before)) {
         return makeMatch(text, offset, 6);
     }
@@ -348,8 +469,15 @@ function topLevelAsKeyword(text: string, offset: number): RegExpExecArray | null
     if (braceDepthBefore(text, offset) !== 0) {
         return null;
     }
-    const before = text.slice(0, offset).replace(/[ \t]+$/, '');
-    if (/(?:[_a-zA-Z][\w-]*|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')$/.test(before)) {
+    // `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);
+    // 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;
@@ -454,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;
     }
 
@@ -466,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

@@ -5,7 +5,10 @@ import {
     isFromImport,
     isIdea,
     isInvalidFromImport,
+    isModel,
     isOneLinerIdea,
+    isWildcardReference,
+    type AnonymousBlock,
     type Model
 } from './generated/ast.js';
 import {
@@ -21,18 +24,25 @@ 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.
  * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_does_not_exist_error]
  * rq:["../../../reqlan rq/language/imports.rq".import_error_recovery]
  * rq:["../../../reqlan rq/language/imports.rq".import_tokenisation]
+ * rq:["../../../reqlan rq/language/syntax.rq".no_name_idea_safe_warning]
  */
 export function registerValidationChecks(services: ReqlanServices) {
     const registry = services.validation.ValidationRegistry;
     const validator = services.validation.ReqlanValidator;
     const checks: ValidationChecks<ReqlanAstType> = {
-        Model: validator.checkModelDuplicates
+        Model: validator.checkModelDuplicates,
+        AnonymousBlock: validator.checkNamelessIdeaBlock
     };
     registry.register(checks, validator);
 }
@@ -42,6 +52,7 @@ export function registerValidationChecks(services: ReqlanServices) {
  * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_does_not_exist_error]
  * rq:["../../../reqlan rq/language/imports.rq".import_error_recovery]
  * rq:["../../../reqlan rq/language/imports.rq".import_tokenisation]
+ * rq:["../../../reqlan rq/language/syntax.rq".no_name_idea_safe_warning]
  */
 export class ReqlanValidator {
 
@@ -53,6 +64,23 @@ export class ReqlanValidator {
         this.checkImportSyntax(model, accept);
         this.checkImportTargets(model, accept);
         this.checkFileReferenceTargets(model, accept);
+        this.checkWildcardReferences(model, accept);
+    }
+
+    /**
+     * Top-level nameless `{ ... }` blocks parse so the rest of the file stays alive,
+     * but they need a name to be addressable ideas.
+     * List-item anonymous blocks remain valid (see lists).
+     */
+    checkNamelessIdeaBlock(block: AnonymousBlock, accept: ValidationAcceptor): void {
+        if (!isModel(block.$container)) {
+            return;
+        }
+        accept(
+            'warning',
+            'Nameless idea block: add a name before `{` (for example `my_idea { ... }`). The block was kept so the rest of the file still parses.',
+            { node: block }
+        );
     }
 
     /**
@@ -183,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];