@reqlan/language 1.4.0

package/src/reqlan-idea-summary.ts

@@ -0,0 +1,162 @@
+/**
+ * Compact idea body summaries for inline editor hints and indexing.
+ */
+import {
+    isBodyLine,
+    isBracketReference,
+    isFileReference,
+    isFileSymbolReference,
+    isIdea,
+    isLocalReference,
+    isMarkdownLink,
+    isOneLinerIdea,
+    isQualifiedReference,
+    isRichTextPart,
+    isWikiLink,
+    type BodyLine,
+    type BracketReference,
+    type IdeaDeclaration,
+    type OneLinerIdea,
+    type ReferenceTarget,
+    type WikiLink
+} from './generated/ast.js';
+import { parseMarkdownLink, referenceIdea, unquoteReqlanString } from './reqlan-references.js';
+
+/** Preserve the source token so consumers can restyle/link refs (not a bare "[ref]"). */
+function summarizeReferencePart(part: WikiLink | BracketReference): string {
+    const raw = part.$cstNode?.text?.replace(/\s+/g, ' ').trim();
+    if (raw) {
+        return raw;
+    }
+    const label = referenceDisplayName(part);
+    if (isWikiLink(part)) {
+        return label ? `[[${label}]]` : '[ref]';
+    }
+    return label ? `[${label}]` : '[ref]';
+}
+
+function wikiAliasText(part: WikiLink): string | undefined {
+    const alias = part.alias
+        ?.map(piece => piece.text ?? '')
+        .join('')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return alias || undefined;
+}
+
+function referenceTargetLabel(target: ReferenceTarget | undefined): string | undefined {
+    if (!target) {
+        return undefined;
+    }
+    if (isFileReference(target)) {
+        return fileBaseName(unquoteReqlanString(target.file));
+    }
+    if (isFileSymbolReference(target)) {
+        return fileBaseName(unquoteReqlanString(target.file));
+    }
+    if (isQualifiedReference(target) || isLocalReference(target)) {
+        const idea = referenceIdea(target);
+        const name = idea?.ref?.name ?? idea?.$refText;
+        if (name) {
+            return name;
+        }
+    }
+    return target.$cstNode?.text?.replace(/\s+/g, ' ').trim();
+}
+
+function referenceDisplayName(part: WikiLink | BracketReference): string | undefined {
+    if (isWikiLink(part)) {
+        const alias = wikiAliasText(part);
+        if (alias) {
+            return alias;
+        }
+    }
+    return referenceTargetLabel(part.target);
+}
+
+function fileBaseName(path: string): string {
+    const cleaned = path.trim();
+    const segments = cleaned.split(/[/\\]/).filter(Boolean);
+    return segments[segments.length - 1] || cleaned;
+}
+
+function summarizeOneLinerPart(part: NonNullable<OneLinerIdea['body']>['content'][number]): string {
+    if (typeof part === 'string') {
+        return part;
+    }
+    if (isMarkdownLink(part)) {
+        return parseMarkdownLink(part.raw)?.label ?? part.raw;
+    }
+    if (isWikiLink(part) || isBracketReference(part)) {
+        return summarizeReferencePart(part);
+    }
+    return '';
+}
+
+function summarizeRichTextPart(part: BodyLine['parts'][number]): string {
+    if (typeof part === 'string') {
+        return part;
+    }
+    if (isRichTextPart(part) && part.$type === 'RichTextPart') {
+        return part.text ?? part.inlineCode ?? part.lparen ?? part.rparen ?? '';
+    }
+    if (isMarkdownLink(part)) {
+        return parseMarkdownLink(part.raw)?.label ?? part.raw;
+    }
+    if (isWikiLink(part) || isBracketReference(part)) {
+        return summarizeReferencePart(part);
+    }
+    return '';
+}
+
+function summarizeOneLinerBody(idea: OneLinerIdea): string {
+    if (!idea.body) {
+        return '';
+    }
+    return idea.body.content
+        .map(summarizeOneLinerPart)
+        .join(' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
+function summarizeBlockIdeaBody(idea: IdeaDeclaration): string {
+    if (!isIdea(idea)) {
+        return '';
+    }
+    const lines: string[] = [];
+    for (const element of idea.elements) {
+        if (!isBodyLine(element)) {
+            continue;
+        }
+        const line = element.parts
+            .map(summarizeRichTextPart)
+            .filter(part => part.length > 0)
+            .join(' ')
+            .replace(/\s+([.,!?;:])/g, '$1')
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (line) {
+            lines.push(line);
+        }
+    }
+    return lines.join('\n');
+}
+
+export function summarizeIdeaDeclaration(idea: IdeaDeclaration): string {
+    if (isOneLinerIdea(idea)) {
+        return summarizeOneLinerBody(idea);
+    }
+    if (isIdea(idea)) {
+        return summarizeBlockIdeaBody(idea);
+    }
+    return '';
+}
+
+export function truncateSummary(text: string, maxLength = 80): string {
+    const normalized = text.replace(/\s+/g, ' ').trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength - 1).trimEnd()}…`;
+}

package/src/reqlan-ignore-error.ts

@@ -0,0 +1,50 @@
+/**
+ * Suppresses diagnostics on lines immediately following `//rq-ignore-error`.
+ * rq:["../../../reqlan rq/language/syntax.rq".comment_reference_ignore]
+ */
+import { DocumentState, type LangiumDocument, type LangiumSharedCoreServices } from 'langium';
+import type { Diagnostic } from 'vscode-languageserver';
+import { findLineCommentStart } from './reqlan-comment-resolver.js';
+
+const RQ_IGNORE_ERROR = /\/\/\s*rq-ignore-error\b/;
+
+export function findRqIgnoreErrorTargetLines(text: string): Set<number> {
+    const lines = text.split(/\r?\n/);
+    const targetLines = new Set<number>();
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex]!;
+        const commentStart = findLineCommentStart(line);
+        if (commentStart < 0) {
+            continue;
+        }
+        const commentText = line.slice(commentStart);
+        if (RQ_IGNORE_ERROR.test(commentText) && lineIndex + 1 < lines.length) {
+            targetLines.add(lineIndex + 1);
+        }
+    }
+    return targetLines;
+}
+
+export function filterRqIgnoredDiagnostics(text: string, diagnostics: Diagnostic[]): Diagnostic[] {
+    const ignoredLines = findRqIgnoreErrorTargetLines(text);
+    if (ignoredLines.size === 0) {
+        return diagnostics;
+    }
+    return diagnostics.filter(diagnostic => !ignoredLines.has(diagnostic.range.start.line));
+}
+
+export function applyRqIgnoreErrorFiltering(document: LangiumDocument): void {
+    if (!document.diagnostics?.length) {
+        return;
+    }
+    document.diagnostics = filterRqIgnoredDiagnostics(
+        document.textDocument.getText(),
+        document.diagnostics
+    );
+}
+
+export function registerRqIgnoreErrorFiltering(shared: LangiumSharedCoreServices): void {
+    shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Validated, (document: LangiumDocument) => {
+        applyRqIgnoreErrorFiltering(document);
+    });
+}

package/src/reqlan-import-bindings.ts

@@ -0,0 +1,87 @@
+import type { AstNode } from 'langium';
+import {
+    isFromImport,
+    isNamespaceImport,
+    isQualifiedImport,
+    type FromImportSpecifier,
+    type Import
+} from './generated/ast.js';
+
+export interface ImportBinding {
+    name: string;
+    node: AstNode;
+    property: 'alias' | 'idea';
+}
+
+export function specifierBindingName(specifier: FromImportSpecifier): string | undefined {
+    return specifier.alias ?? specifier.idea.$refText;
+}
+
+export function importBindings(importDecl: Import): ImportBinding[] {
+    if (isFromImport(importDecl)) {
+        return importDecl.specifiers.flatMap(specifier => {
+            const name = specifierBindingName(specifier);
+            if (!name) {
+                return [];
+            }
+            return [{
+                name,
+                node: specifier,
+                property: specifier.alias ? 'alias' as const : 'idea' as const
+            }];
+        });
+    }
+    if (isQualifiedImport(importDecl)) {
+        const name = importDecl.alias ?? importDecl.idea.$refText;
+        if (!name) {
+            return [];
+        }
+        return [{
+            name,
+            node: importDecl,
+            property: importDecl.alias ? 'alias' : 'idea'
+        }];
+    }
+    if (importDecl.alias) {
+        return [{ name: importDecl.alias, node: importDecl, property: 'alias' }];
+    }
+    return [];
+}
+
+export function importedIdeaNames(importDecl: Import): string[] {
+    if (isFromImport(importDecl)) {
+        return importDecl.specifiers.map(specifier => specifier.idea.$refText);
+    }
+    if (isQualifiedImport(importDecl)) {
+        return [importDecl.idea.$refText];
+    }
+    return [];
+}
+
+export function findNamespaceImportByAlias(imports: Import[], alias: string): Import | undefined {
+    for (const importDecl of imports) {
+        if (!isNamespaceImport(importDecl) || importDecl.alias !== alias) {
+            continue;
+        }
+        return importDecl;
+    }
+    return undefined;
+}
+
+export function findFromImportSpecifierByBinding(
+    imports: Import[],
+    bindingName: string
+): FromImportSpecifier | undefined {
+    for (const importDecl of imports) {
+        if (!isFromImport(importDecl)) {
+            continue;
+        }
+        const specifier = importDecl.specifiers.find(
+            entry => specifierBindingName(entry) === bindingName
+        );
+        if (specifier) {
+            return specifier;
+        }
+    }
+    return undefined;
+}

package/src/reqlan-import-edits.ts

@@ -0,0 +1,124 @@
+/**
+ * Shared WorkspaceEdit helpers for import insertion used by unresolved-reference quick fixes.
+ * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_error]
+ */
+import type { LangiumDocument, URI } from 'langium';
+import { UriUtils } from 'langium';
+import type { Position, TextEdit } from 'vscode-languageserver';
+import {
+    isFromImport,
+    isModel,
+    isNamespaceImport,
+    type FromImport,
+    type Model
+} from './generated/ast.js';
+import { unquoteReqlanString } from './reqlan-references.js';
+
+export function relativeRqImportPath(fromUri: URI, toUri: URI): string {
+    const sourceDir = UriUtils.dirname(fromUri);
+    let relativePath = UriUtils.relative(sourceDir, toUri);
+    if (!relativePath.startsWith('./') && !relativePath.startsWith('../')) {
+        relativePath = `./${relativePath}`;
+    }
+    return relativePath;
+}
+
+export function findImportInsertPosition(model: Model): { position: Position; trailingNewline: boolean } {
+    if (model.imports.length > 0) {
+        const last = model.imports[model.imports.length - 1]!;
+        const end = last.$cstNode?.range.end;
+        if (end) {
+            return {
+                position: { line: end.line + 1, character: 0 },
+                trailingNewline: false
+            };
+        }
+    }
+    const firstElement = model.elements[0];
+    if (firstElement?.$cstNode) {
+        return {
+            position: firstElement.$cstNode.range.start,
+            trailingNewline: true
+        };
+    }
+    return { position: { line: 0, character: 0 }, trailingNewline: true };
+}
+
+export function findExistingFromImport(model: Model, importPath: string): FromImport | undefined {
+    return model.imports.find((decl): decl is FromImport => {
+        if (!isFromImport(decl)) {
+            return false;
+        }
+        return unquoteReqlanString(decl.path) === importPath;
+    });
+}
+
+export function hasNamespaceImport(model: Model, importPath: string): boolean {
+    return model.imports.some(decl =>
+        isNamespaceImport(decl) && unquoteReqlanString(decl.path) === importPath
+    );
+}
+
+export function buildFromImportEdit(
+    document: LangiumDocument,
+    importPath: string,
+    symbolName: string
+): TextEdit | undefined {
+    const model = document.parseResult.value;
+    if (!isModel(model)) {
+        return undefined;
+    }
+    const existing = findExistingFromImport(model, importPath);
+    if (existing) {
+        const alreadyImported = existing.specifiers.some(specifier => {
+            const binding = specifier.alias ?? specifier.idea.$refText;
+            return binding === symbolName || specifier.idea.$refText === symbolName;
+        });
+        if (alreadyImported) {
+            return undefined;
+        }
+        const lastSpecifier = existing.specifiers[existing.specifiers.length - 1];
+        const insertAt = lastSpecifier?.$cstNode?.range.end ?? existing.$cstNode?.range.end;
+        if (!insertAt) {
+            return undefined;
+        }
+        return {
+            range: { start: insertAt, end: insertAt },
+            newText: `, ${symbolName}`
+        };
+    }
+    const insert = findImportInsertPosition(model);
+    const line = `from "${importPath}" import ${symbolName}`;
+    return {
+        range: { start: insert.position, end: insert.position },
+        newText: insert.trailingNewline ? `${line}\n\n` : `${line}\n`
+    };
+}
+
+export function buildNamespaceImportEdit(
+    document: LangiumDocument,
+    importPath: string,
+    alias: string
+): TextEdit | undefined {
+    const model = document.parseResult.value;
+    if (!isModel(model)) {
+        return undefined;
+    }
+    if (hasNamespaceImport(model, importPath)) {
+        return undefined;
+    }
+    const insert = findImportInsertPosition(model);
+    const line = `import "${importPath}" as ${alias}`;
+    return {
+        range: { start: insert.position, end: insert.position },
+        newText: insert.trailingNewline ? `${line}\n\n` : `${line}\n`
+    };
+}
+
+export function fileBasenameAlias(fileUri: string | URI): string {
+    const uriString = typeof fileUri === 'string' ? fileUri : fileUri.toString();
+    const base = uriString.split('/').pop() ?? uriString;
+    const withoutExt = base.replace(/\.rq$/i, '');
+    const cleaned = withoutExt.replace(/[^A-Za-z0-9_]+/g, '_').replace(/^(\d)/, '_$1');
+    return cleaned || 'imported';
+}

package/src/reqlan-imports.ts

@@ -0,0 +1,115 @@
+/**
+ * Resolves imported requirement documents from relative and import-root-aliased paths.
+ * Interacts with scope linking and go-to-definition for import paths.
+ * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".implicit_file_extension]
+ */
+import type { FileSystemProvider, LangiumDocument, LangiumDocuments, URI } from 'langium';
+import {
+    resolveDocumentPathUri,
+    type PathResolveContext
+} from './reqlan-path-resolve.js';
+
+export type { PathResolveContext };
+
+export const IMPLICIT_IMPORT_EXTENSION = '.rq';
+
+/**
+ * Import paths written without an extension mean `.rq`; the literal path stays a fallback so
+ * extensionless files on disk keep resolving.
+ */
+export function importPathCandidates(path: string): string[] {
+    const implicit = importPathWithImplicitExtension(path);
+    return implicit ? [implicit, path] : [path];
+}
+
+export function importPathWithImplicitExtension(path: string): string | undefined {
+    const basename = path.slice(path.lastIndexOf('/') + 1);
+    if (basename.length === 0 || basename === '.' || basename === '..') {
+        return undefined;
+    }
+    if (basename.includes('.', 1)) {
+        return undefined;
+    }
+    return `${path}${IMPLICIT_IMPORT_EXTENSION}`;
+}
+
+export function resolveImportUri(
+    path: string,
+    document: LangiumDocument,
+    context?: PathResolveContext
+) {
+    return resolveDocumentPathUri(path, document, context);
+}
+
+/** Candidate URIs in preference order: implicit `.rq` first, then the path as written. */
+export function resolveImportCandidateUris(
+    path: string,
+    document: LangiumDocument,
+    context?: PathResolveContext
+): URI[] {
+    return importPathCandidates(path).map(candidate =>
+        resolveDocumentPathUri(candidate, document, context)
+    );
+}
+
+export function isResolvableImportPath(
+    path: string,
+    document: LangiumDocument,
+    documents: LangiumDocuments,
+    fileSystem?: FileSystemProvider,
+    context?: PathResolveContext
+): boolean {
+    return resolveImportCandidateUris(path, document, withFileSystem(context, fileSystem))
+        .some(uri => isImportTarget(uri, documents, fileSystem));
+}
+
+export function findImportedDocument(
+    path: string,
+    document: LangiumDocument,
+    documents: LangiumDocuments,
+    context?: PathResolveContext
+): LangiumDocument | undefined {
+    for (const uri of resolveImportCandidateUris(path, document, context)) {
+        const imported = documents.getDocument(uri);
+        if (imported) {
+            return imported;
+        }
+    }
+    return undefined;
+}
+
+/** First candidate that exists, falling back to the path as written when none do. */
+export function resolveExistingImportUri(
+    path: string,
+    document: LangiumDocument,
+    documents: LangiumDocuments,
+    fileSystem?: FileSystemProvider,
+    context?: PathResolveContext
+): URI {
+    const uris = resolveImportCandidateUris(path, document, withFileSystem(context, fileSystem));
+    return uris.find(uri => isImportTarget(uri, documents, fileSystem)) ?? uris[uris.length - 1]!;
+}
+
+function isImportTarget(
+    uri: URI,
+    documents: LangiumDocuments,
+    fileSystem: FileSystemProvider | undefined
+): boolean {
+    if (documents.getDocument(uri)) {
+        return true;
+    }
+    if (!fileSystem?.existsSync(uri)) {
+        return false;
+    }
+    return !fileSystem.statSync(uri).isDirectory;
+}
+
+function withFileSystem(
+    context: PathResolveContext | undefined,
+    fileSystem: FileSystemProvider | undefined
+): PathResolveContext | undefined {
+    if (!fileSystem && !context) {
+        return undefined;
+    }
+    return { ...context, fileSystem: fileSystem ?? context?.fileSystem };
+}