@reqlan/language 1.4.0

package/src/reqlan-token-builder.ts

@@ -0,0 +1,492 @@
+/**
+ * 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.
+ */
+import type { Grammar } from 'langium';
+import { DefaultTokenBuilder, type TokenBuilderOptions } from 'langium';
+
+const SL_COMMENT_PATTERN = /\/\/[^\n\r]*/y;
+
+function isInsideNakedQuote(text: string, offset: number): boolean {
+    let inDouble = false;
+    let inSingle = false;
+    const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
+    for (let index = lineStart; index < offset; index++) {
+        const char = text[index]!;
+        if (inDouble || inSingle) {
+            if (char === '\\') {
+                index++;
+                continue;
+            }
+            if (inDouble && char === '"') {
+                inDouble = false;
+            } else if (inSingle && char === "'") {
+                inSingle = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inDouble = true;
+        } else if (char === "'") {
+            inSingle = true;
+        }
+    }
+    return inDouble || inSingle;
+}
+
+const slCommentPattern = (text: string, offset: number): RegExpExecArray | null => {
+    if (text.charCodeAt(offset) !== 47 || text.charCodeAt(offset + 1) !== 47) {
+        return null;
+    }
+    if (isInsideNakedQuote(text, offset)) {
+        return null;
+    }
+    let previousIndex = offset - 1;
+    while (previousIndex >= 0 && /[ \t]/.test(text[previousIndex]!)) {
+        previousIndex--;
+    }
+    const previous = previousIndex >= 0 ? text[previousIndex]! : '';
+    if (previous === ':' || previous === '/') {
+        return null;
+    }
+    SL_COMMENT_PATTERN.lastIndex = offset;
+    return SL_COMMENT_PATTERN.exec(text);
+};
+
+function makeMatch(text: string, offset: number, length: number): RegExpExecArray {
+    const image = text.slice(offset, offset + length);
+    const match = [image] as unknown as RegExpExecArray;
+    match.index = offset;
+    match.input = text;
+    return match;
+}
+
+/**
+ * `@` marks an attribute only when it is the first non-whitespace character on a line.
+ * Mid-line `@` (and `\@` at line start) fall through to OTHER as body text.
+ */
+const atSignAttributeMarker = (text: string, offset: number): RegExpExecArray | null => {
+    if (text[offset] !== '@') {
+        return null;
+    }
+    let previousIndex = offset - 1;
+    while (previousIndex >= 0 && (text[previousIndex] === ' ' || text[previousIndex] === '\t')) {
+        previousIndex--;
+    }
+    if (previousIndex >= 0 && text[previousIndex] !== '\n' && text[previousIndex] !== '\r') {
+        return null;
+    }
+    return makeMatch(text, offset, 1);
+};
+
+const markdownLink = (text: string, offset: number): RegExpExecArray | null => {
+    if (text[offset] !== '[' || text[offset + 1] === '[') {
+        return null;
+    }
+    let index = offset + 1;
+    while (index < text.length) {
+        if (text[index] === ']' && text[index + 1] === '(') {
+            const label = text.slice(offset + 1, index);
+            const targetStart = index + 2;
+            let targetEnd = targetStart;
+            while (targetEnd < text.length && text[targetEnd] !== ')') {
+                if (text[targetEnd] === '\n' || text[targetEnd] === '\r') {
+                    return null;
+                }
+                targetEnd++;
+            }
+            if (targetEnd >= text.length || label.length === 0 || targetEnd === targetStart) {
+                return null;
+            }
+            return makeMatch(text, offset, targetEnd + 1 - offset);
+        }
+        if (text[index] === '\n' || text[index] === '\r') {
+            return null;
+        }
+        index++;
+    }
+    return null;
+};
+
+const topLevelBlockOpener = /(?:^|\n)[ \t]*(?:[A-Za-z_.][\w.-]*|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\s*$/;
+
+function isEscapedAt(text: string, offset: number): boolean {
+    let backslashes = 0;
+    for (let index = offset - 1; index >= 0 && text[index] === '\\'; index--) {
+        backslashes++;
+    }
+    return backslashes % 2 === 1;
+}
+
+function isStructuralOpenBraceAtDepth(text: string, offset: number, depth: number): boolean {
+    if (text[offset] !== '{') {
+        return false;
+    }
+    if (isEscapedAt(text, offset)) {
+        return false;
+    }
+    const before = text.slice(0, offset).replace(/[ \t]+$/, '');
+
+    if (depth === 0 && topLevelBlockOpener.test(before)) {
+        return true;
+    }
+    if (/@[A-Za-z_][\w-]*(?::)?\s*$/.test(before)) {
+        return true;
+    }
+    if (depth >= 1 && isLineStartAt(text, offset)) {
+        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 false;
+}
+
+/**
+ * A `}` closes a structural block only when it is the last non-whitespace on its line
+ * and it is not pairing with an unmatched prose `{` earlier on that line / in the body.
+ * Own-line closers (`}` after only indentation) always close structurally so an
+ * unbalanced prose `{` does not swallow the idea's closing brace.
+ */
+function isStructuralCloseBraceAt(text: string, offset: number): boolean {
+    if (text[offset] !== '}') {
+        return false;
+    }
+    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) {
+        return false;
+    }
+    const { structuralDepth, proseDepth } = scanBraceState(text, offset);
+    if (structuralDepth <= 0) {
+        return false;
+    }
+    if (isLineStartAt(text, offset)) {
+        return true;
+    }
+    return proseDepth === 0;
+}
+
+interface BraceScanState {
+    structuralDepth: number;
+    proseDepth: number;
+}
+
+function scanBraceState(text: string, offset: number): BraceScanState {
+    let structuralDepth = 0;
+    const proseDepthByStructural: number[] = [0];
+
+    const proseDepthAt = (): number => proseDepthByStructural[structuralDepth] ?? 0;
+    const setProseDepth = (value: number): void => {
+        proseDepthByStructural[structuralDepth] = value;
+    };
+
+    for (let index = 0; index < offset; index++) {
+        const char = text[index];
+        if (char === '{') {
+            if (isEscapedAt(text, index)) {
+                continue;
+            }
+            if (isStructuralOpenBraceAtDepth(text, index, structuralDepth)) {
+                structuralDepth++;
+                proseDepthByStructural[structuralDepth] = 0;
+            } else {
+                setProseDepth(proseDepthAt() + 1);
+            }
+            continue;
+        }
+        if (char !== '}') {
+            continue;
+        }
+        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;
+        if (!atEndOfLine) {
+            if (proseDepthAt() > 0) {
+                setProseDepth(proseDepthAt() - 1);
+            }
+            continue;
+        }
+        if (structuralDepth <= 0) {
+            if (proseDepthAt() > 0) {
+                setProseDepth(proseDepthAt() - 1);
+            }
+            continue;
+        }
+        if (isLineStartAt(text, index)) {
+            structuralDepth--;
+            continue;
+        }
+        if (proseDepthAt() > 0) {
+            setProseDepth(proseDepthAt() - 1);
+        } else {
+            structuralDepth--;
+        }
+    }
+
+    return {
+        structuralDepth,
+        proseDepth: proseDepthAt()
+    };
+}
+
+function scanStructuralBraceDepth(text: string, offset: number): number {
+    return scanBraceState(text, offset).structuralDepth;
+}
+
+function isStructuralOpenBraceAt(text: string, offset: number): boolean {
+    return isStructuralOpenBraceAtDepth(text, offset, scanStructuralBraceDepth(text, offset));
+}
+
+const structuralOpenBrace = (text: string, offset: number): RegExpExecArray | null => {
+    if (text[offset] !== '{') {
+        return null;
+    }
+    return isStructuralOpenBraceAt(text, offset) ? makeMatch(text, offset, 1) : null;
+};
+
+const structuralCloseBrace = (text: string, offset: number): RegExpExecArray | null => {
+    if (text[offset] !== '}') {
+        return null;
+    }
+    return isStructuralCloseBraceAt(text, offset) ? makeMatch(text, offset, 1) : null;
+};
+
+const proseOpenBrace = (text: string, offset: number): RegExpExecArray | null => {
+    if (text[offset] !== '{') {
+        return null;
+    }
+    return isStructuralOpenBraceAt(text, offset) ? null : makeMatch(text, offset, 1);
+};
+
+const proseCloseBrace = (text: string, offset: number): RegExpExecArray | null => {
+    if (text[offset] !== '}') {
+        return null;
+    }
+    return isStructuralCloseBraceAt(text, offset) ? null : makeMatch(text, offset, 1);
+};
+
+function braceDepthBefore(text: string, offset: number): number {
+    return scanStructuralBraceDepth(text, offset);
+}
+
+function isLineStartAt(text: string, offset: number): boolean {
+    let previousIndex = offset - 1;
+    while (previousIndex >= 0 && (text[previousIndex] === ' ' || text[previousIndex] === '\t')) {
+        previousIndex--;
+    }
+    return previousIndex < 0 || text[previousIndex] === '\n' || text[previousIndex] === '\r';
+}
+
+function isStringLiteralContext(text: string, offset: number): boolean {
+    const depth = braceDepthBefore(text, offset);
+    const trimmed = text.slice(0, offset).replace(/[ \t]+$/, '');
+    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) {
+        return true;
+    }
+    return false;
+}
+
+/** Import keywords are reserved only at top level; in bodies they lex as ordinary words. */
+function topLevelFromKeyword(text: string, offset: number): RegExpExecArray | null {
+    if (!text.startsWith('from', offset)) {
+        return null;
+    }
+    const next = text[offset + 4];
+    if (next !== undefined && /[\w-]/.test(next)) {
+        return null;
+    }
+    if (braceDepthBefore(text, offset) !== 0 || !isLineStartAt(text, offset)) {
+        return null;
+    }
+    return makeMatch(text, offset, 4);
+};
+
+function topLevelImportKeyword(text: string, offset: number): RegExpExecArray | null {
+    if (!text.startsWith('import', offset)) {
+        return null;
+    }
+    const next = text[offset + 6];
+    if (next !== undefined && /[\w-]/.test(next)) {
+        return null;
+    }
+    if (braceDepthBefore(text, offset) !== 0) {
+        return null;
+    }
+    if (isLineStartAt(text, offset)) {
+        return makeMatch(text, offset, 6);
+    }
+    const before = text.slice(0, offset).replace(/[ \t]+$/, '');
+    if (/(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')$/.test(before)) {
+        return makeMatch(text, offset, 6);
+    }
+    return null;
+};
+
+function topLevelAsKeyword(text: string, offset: number): RegExpExecArray | null {
+    if (!text.startsWith('as', offset)) {
+        return null;
+    }
+    const next = text[offset + 2];
+    if (next !== undefined && /[\w-]/.test(next)) {
+        return null;
+    }
+    if (braceDepthBefore(text, offset) !== 0) {
+        return null;
+    }
+    const before = text.slice(0, offset).replace(/[ \t]+$/, '');
+    if (/(?:[_a-zA-Z][\w-]*|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')$/.test(before)) {
+        return makeMatch(text, offset, 2);
+    }
+    return null;
+};
+
+const reqlanString = (text: string, offset: number): RegExpExecArray | null => {
+    const quote = text[offset];
+    if (quote !== '"' && quote !== "'") {
+        return null;
+    }
+    if (!isStringLiteralContext(text, offset)) {
+        return null;
+    }
+    let index = offset + 1;
+    while (index < text.length) {
+        const char = text[index]!;
+        if (char === '\n' || char === '\r') {
+            return null;
+        }
+        if (char === '\\') {
+            index += 2;
+            continue;
+        }
+        if (char === quote) {
+            return makeMatch(text, offset, index + 1 - offset);
+        }
+        index++;
+    }
+    return null;
+};
+
+/** Body words with interior apostrophes (e.g. user's); plain identifiers stay ID. */
+const reqlanWord = (text: string, offset: number): RegExpExecArray | null => {
+    const match = /^[A-Za-z_][\w']*/.exec(text.slice(offset));
+    if (!match || !match[0].includes("'")) {
+        return null;
+    }
+    return makeMatch(text, offset, match[0].length);
+};
+
+export class ReqlanTokenBuilder extends DefaultTokenBuilder {
+    override buildTokens(grammar: Grammar, options?: TokenBuilderOptions) {
+        const tokens = super.buildTokens(grammar, options);
+        if (!Array.isArray(tokens)) {
+            return tokens;
+        }
+        const atToken = tokens.find(token => token.name === '@');
+        if (atToken) {
+            atToken.PATTERN = atSignAttributeMarker;
+            atToken.LINE_BREAKS = false;
+        }
+        const markdownIndex = tokens.findIndex(token => token.name === 'MARKDOWN_LINK');
+        if (markdownIndex >= 0) {
+            const [markdown] = tokens.splice(markdownIndex, 1);
+            tokens.unshift(markdown);
+        }
+        const wordIndex = tokens.findIndex(token => token.name === 'WORD');
+        const idIndex = tokens.findIndex(token => token.name === 'ID');
+        if (wordIndex >= 0 && idIndex >= 0 && idIndex < wordIndex) {
+            const [word] = tokens.splice(wordIndex, 1);
+            tokens.splice(idIndex, 0, word);
+        }
+        for (const [name, pattern] of [
+            ['from', topLevelFromKeyword],
+            ['import', topLevelImportKeyword],
+            ['as', topLevelAsKeyword]
+        ] as const) {
+            const token = tokens.find(entry => entry.name === name);
+            if (token) {
+                token.PATTERN = pattern;
+                token.LINE_BREAKS = false;
+            }
+        }
+        const openBrace = tokens.find(entry => entry.name === '{');
+        if (openBrace) {
+            openBrace.PATTERN = structuralOpenBrace;
+            openBrace.LINE_BREAKS = false;
+        }
+        const closeBrace = tokens.find(entry => entry.name === '}');
+        if (closeBrace) {
+            closeBrace.PATTERN = structuralCloseBrace;
+            closeBrace.LINE_BREAKS = false;
+        }
+        const otherIndex = tokens.findIndex(entry => entry.name === 'OTHER');
+        if (otherIndex >= 0) {
+            const other = tokens[otherIndex]!;
+            const basePattern = other.PATTERN;
+            other.PATTERN = (text: string, offset: number) => {
+                const proseBrace = proseOpenBrace(text, offset) ?? proseCloseBrace(text, offset);
+                if (proseBrace) {
+                    return proseBrace;
+                }
+                if (typeof basePattern === 'function') {
+                    return basePattern(text, offset);
+                }
+                if (basePattern instanceof RegExp) {
+                    const slice = text.slice(offset);
+                    const match = basePattern.exec(slice);
+                    return match?.index === 0 ? makeMatch(text, offset, match[0].length) : null;
+                }
+                return null;
+            };
+            other.LINE_BREAKS = false;
+        }
+        return tokens;
+    }
+
+    protected override buildTerminalToken(terminal: { name: string }): import('chevrotain').TokenType {
+        if (terminal.name === 'SL_COMMENT') {
+            return {
+                name: 'SL_COMMENT',
+                GROUP: 'hidden',
+                LINE_BREAKS: true,
+                PATTERN: slCommentPattern
+            };
+        }
+        if (terminal.name === 'MARKDOWN_LINK') {
+            return {
+                name: 'MARKDOWN_LINK',
+                LINE_BREAKS: false,
+                PATTERN: markdownLink
+            };
+        }
+        if (terminal.name === 'STRING') {
+            return {
+                name: 'STRING',
+                LINE_BREAKS: false,
+                PATTERN: reqlanString
+            };
+        }
+        if (terminal.name === 'WORD') {
+            return {
+                name: 'WORD',
+                LINE_BREAKS: false,
+                PATTERN: reqlanWord
+            };
+        }
+        return super.buildTerminalToken(terminal as Parameters<DefaultTokenBuilder['buildTerminalToken']>[0]);
+    }
+}

package/src/reqlan-validator.ts

@@ -0,0 +1,149 @@
+import type { AstNode, ValidationAcceptor, ValidationChecks } from 'langium';
+import { AstUtils } from 'langium';
+import type { ReqlanAstType } from './generated/ast.js';
+import {
+    isIdea,
+    isOneLinerIdea,
+    type Model
+} from './generated/ast.js';
+import {
+    collectFileLinks,
+    fileLinkTargetIssueMessage
+} from './reqlan-file-link-resolver.js';
+import { importBindings, importedIdeaNames } from './reqlan-import-bindings.js';
+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';
+
+/**
+ * Registers validation hooks for the requirement graph AST.
+ * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_does_not_exist_error]
+ */
+export function registerValidationChecks(services: ReqlanServices) {
+    const registry = services.validation.ValidationRegistry;
+    const validator = services.validation.ReqlanValidator;
+    const checks: ValidationChecks<ReqlanAstType> = {
+        Model: validator.checkModelDuplicates
+    };
+    registry.register(checks, validator);
+}
+
+/**
+ * Custom validations for Reqlan documents.
+ * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_does_not_exist_error]
+ */
+export class ReqlanValidator {
+
+    constructor(private readonly services: ReqlanServices) {}
+
+    checkModelDuplicates(model: Model, accept: ValidationAcceptor): void {
+        this.checkDuplicateImportBindings(model, accept);
+        this.checkDuplicateIdeaNames(model, accept);
+        this.checkImportTargets(model, accept);
+        this.checkFileReferenceTargets(model, accept);
+    }
+
+    checkDuplicateImportBindings(model: Model, accept: ValidationAcceptor): void {
+        const seen = new Map<string, ImportBindingSource>();
+        for (const importDecl of model.imports) {
+            for (const binding of importBindings(importDecl)) {
+                if (seen.has(binding.name)) {
+                    accept('error', `'${binding.name}' is already defined in this file.`, {
+                        node: binding.node,
+                        property: binding.property
+                    });
+                } else {
+                    seen.set(binding.name, binding);
+                }
+            }
+        }
+    }
+
+    checkDuplicateIdeaNames(model: Model, accept: ValidationAcceptor): void {
+        const seen = new Map<string, AstNode>();
+        for (const importDecl of model.imports) {
+            for (const binding of importBindings(importDecl)) {
+                seen.set(binding.name, importDecl);
+            }
+        }
+        for (const element of model.elements) {
+            if (!isIdea(element) && !isOneLinerIdea(element)) {
+                continue;
+            }
+            const name = element.name;
+            if (seen.has(name)) {
+                accept('error', `'${name}' is already defined in this file.`, {
+                    node: element,
+                    property: 'name'
+                });
+                continue;
+            }
+            const importedNameConflict = model.imports.some(importDecl =>
+                importedIdeaNames(importDecl).includes(name)
+            );
+            if (importedNameConflict) {
+                accept('error', `'${name}' is already defined in this file.`, {
+                    node: element,
+                    property: 'name'
+                });
+                continue;
+            }
+            seen.set(name, element);
+        }
+    }
+
+    /**
+     * Error underline when an `import` / `from` path does not resolve to a file.
+     * Missing imported ideas are reported by the linker as unresolved references.
+     */
+    checkImportTargets(model: Model, accept: ValidationAcceptor): void {
+        const document = AstUtils.getDocument(model);
+        const { shared } = this.services;
+        const pathContext = pathResolveContextFromServices(this.services);
+        for (const importDecl of model.imports) {
+            const path = unquoteReqlanString(importDecl.path);
+            if (!path || isRemoteImportPath(path)) {
+                continue;
+            }
+            if (isResolvableImportPath(
+                path,
+                document,
+                shared.workspace.LangiumDocuments,
+                shared.workspace.FileSystemProvider,
+                pathContext
+            )) {
+                continue;
+            }
+            accept('error', `Could not resolve import '${path}'.`, {
+                node: importDecl,
+                property: 'path'
+            });
+        }
+    }
+
+    checkFileReferenceTargets(model: Model, accept: ValidationAcceptor): void {
+        const document = AstUtils.getDocument(model);
+        const { shared } = this.services;
+        for (const link of collectFileLinks(
+            document,
+            shared.workspace.LangiumDocuments,
+            shared.workspace.FileSystemProvider,
+            pathResolveContextFromServices(this.services)
+        )) {
+            if (!link.targetIssue) {
+                continue;
+            }
+            accept('warning', fileLinkTargetIssueMessage(link.targetIssue), {
+                node: model,
+                range: link.sourceRange
+            });
+        }
+    }
+}
+
+type ImportBindingSource = ReturnType<typeof importBindings>[number];
+
+function isRemoteImportPath(path: string): boolean {
+    return /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(path);
+}

package/src/reqlan-workspace-attribute-catalog.ts

@@ -0,0 +1,62 @@
+/**
+ * Collects attribute keys and values from parsed workspace documents.
+ */
+import type { LangiumDocuments } from 'langium';
+import { AstUtils } from 'langium';
+import { isAttribute, isModel, isScalarValue, type Attribute } from './generated/ast.js';
+import type { AttributeCatalog } from './reqlan-attribute-catalog.js';
+
+export function collectWorkspaceAttributeCatalog(documents: LangiumDocuments): AttributeCatalog {
+    const keys = new Set<string>();
+    const valuesByKey = new Map<string, Set<string>>();
+    for (const document of documents.all.toArray()) {
+        const model = document.parseResult.value;
+        if (!isModel(model)) {
+            continue;
+        }
+        for (const attribute of AstUtils.streamAst(model).filter(isAttribute)) {
+            keys.add(attribute.name);
+            const values = valuesForAttribute(attribute);
+            if (values.length === 0) {
+                continue;
+            }
+            if (!valuesByKey.has(attribute.name)) {
+                valuesByKey.set(attribute.name, new Set());
+            }
+            for (const value of values) {
+                valuesByKey.get(attribute.name)!.add(value);
+            }
+        }
+    }
+    return {
+        keys: [...keys].sort((left, right) => left.localeCompare(right)),
+        valuesByKey: Object.fromEntries(
+            [...valuesByKey.entries()].map(([key, values]) => [key, [...values].sort()])
+        )
+    };
+}
+
+function valuesForAttribute(attribute: Attribute): string[] {
+    if (!attribute.value) {
+        return [];
+    }
+    if (isScalarValue(attribute.value)) {
+        const text = attribute.value.parts
+            .map(part => typeof part === 'string' ? part : '')
+            .join('')
+            .trim();
+        return text ? [text] : [];
+    }
+    if (attribute.value.$type === 'ListValue') {
+        return attribute.value.items.flatMap(item => {
+            if (item.$type === 'OneLinerListItem') {
+                return item.body.content
+                    .map(part => typeof part === 'string' ? part : '')
+                    .join('')
+                    .trim();
+            }
+            return [];
+        }).filter(Boolean);
+    }
+    return [];
+}