@reqlan/language 1.9.6 → 1.10.1

package/src/reqlan-completion-provider.ts

@@ -2,8 +2,8 @@
  * Code completion for references, import paths, file paths, and attributes.
  * rq:["../../../reqlan rq/extension/configuration.rq".configuration_import_roots]
  * rq:["../../../reqlan rq/language/imports.rq".configuration_import_root_alias]
- * rq:["../../../reqlan rq/extension/features-syntax-highlighting.rq".reference_code_completion]
- * rq:["../../../reqlan rq/extension/features-syntax-highlighting.rq".reference_code_completion_sequencing]
+ * rq:["../../../reqlan rq/extension/syntax/features-syntax-highlighting.rq".reference_code_completion]
+ * rq:["../../../reqlan rq/extension/syntax/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]

package/src/reqlan-definition-provider.ts

@@ -278,7 +278,7 @@ export class ReqlanDefinitionProvider extends DefaultDefinitionProvider {
 
     private createFileLink(source: CstNode, reference: FileReference | FileSymbolReference): GoToLink | undefined {
         const resolved = resolveFileReferenceLink(reference, this.documents, this.fileSystem, this.pathContext());
-        if (!resolved) {
+        if (!resolved || resolved.resolution === 'missing') {
             return undefined;
         }
         const targetDocument = this.documents.getDocument(URI.parse(resolved.targetUri));

package/src/reqlan-document-builder.ts

@@ -0,0 +1,35 @@
+/**
+ * Rebuilds documents whose comment-reference diagnostics depend on other `.rq` files.
+ * rq:["../../../reqlan rq/extension/features-non-rq-code-comment/functional-code-comment-references.rq".comment_reference_resolution_error_state]
+ */
+import {
+    DefaultDocumentBuilder,
+    type LangiumDocument,
+    type LangiumSharedCoreServices
+} from 'langium';
+import { shouldRelinkCommentReferences } from './reqlan-comment-diagnostics.js';
+import { pathResolveContextFromServices } from './reqlan-path-resolve.js';
+
+export class ReqlanDocumentBuilder extends DefaultDocumentBuilder {
+    constructor(services: LangiumSharedCoreServices) {
+        super(services);
+    }
+
+    protected override shouldRelink(document: LangiumDocument, changedUris: Set<string>): boolean {
+        if (super.shouldRelink(document, changedUris)) {
+            return true;
+        }
+        return shouldRelinkCommentReferences(
+            document,
+            changedUris,
+            pathResolveContextFromServices({
+                shared: {
+                    workspace: {
+                        WorkspaceManager: this.workspaceManager(),
+                        FileSystemProvider: this.fileSystemProvider
+                    }
+                }
+            })
+        );
+    }
+}

package/src/reqlan-document-link-provider.ts

@@ -1,11 +1,17 @@
 /**
- * Clickable document links for idea references, file references, and import paths.
+ * Clickable document links for idea references, file references, import paths, and comment references.
  * Same-file and cross-file idea refs both get links so the editor underline is consistent.
+ * Comment-reference links come from the same presentation as the missing-idea underline.
+ * Missing file refs get an error underline and no document link.
+ * rq:["../../../reqlan rq/extension/features-non-rq-code-comment/functional-code-comment-references.rq".comment_reference_resolution_error_state]
+ * rq:["../../../reqlan rq/extension/language-support/language-server-errors.rq".file_reference_errors]
  */
 import type { LangiumDocument } from 'langium';
+import { URI } from 'langium';
 import type { DocumentLinkProvider } from 'langium/lsp';
 import type { DocumentLink, DocumentLinkParams } from 'vscode-languageserver';
 import { DocumentLink as LspDocumentLink } from 'vscode-languageserver';
+import { presentCommentReferencesForDocument } from './reqlan-comment-diagnostics.js';
 import { collectFileLinks, resolvedFileLinkTargetUri } from './reqlan-file-link-resolver.js';
 import { folderReferenceCommandTarget } from './reqlan-reference-at-position.js';
 import { wildcardReferenceCommandTarget } from './reqlan-wildcard-resolve.js';
@@ -25,11 +31,12 @@ export class ReqlanDocumentLinkProvider implements DocumentLinkProvider {
     }
 
     getDocumentLinks(document: LangiumDocument, _params: DocumentLinkParams): DocumentLink[] {
-        return collectFileLinks(
+        const pathContext = pathResolveContextFromServices(this.services);
+        const fileLinks = collectFileLinks(
             document,
             this.documents,
             this.fileSystem,
-            pathResolveContextFromServices(this.services)
+            pathContext
         ).flatMap(link => {
             if (link.resolution === 'folder') {
                 return [LspDocumentLink.create(
@@ -37,6 +44,9 @@ export class ReqlanDocumentLinkProvider implements DocumentLinkProvider {
                     folderReferenceCommandTarget(link.targetUri)
                 )];
             }
+            if (link.resolution === 'missing') {
+                return [];
+            }
             if (link.resolution === 'wildcard' && link.wildcardArgs) {
                 return [LspDocumentLink.create(
                     link.sourceRange,
@@ -49,5 +59,15 @@ export class ReqlanDocumentLinkProvider implements DocumentLinkProvider {
             }
             return [LspDocumentLink.create(link.sourceRange, target)];
         });
+        const commentLinks = presentCommentReferencesForDocument(
+            document,
+            this.documents,
+            this.fileSystem,
+            pathContext
+        ).links.map(link => LspDocumentLink.create(
+            link.range,
+            link.targetUri ?? URI.file(link.targetPath).toString()
+        ));
+        return [...fileLinks, ...commentLinks];
     }
 }

package/src/reqlan-embedded-file-references.ts

@@ -1,5 +1,8 @@
 /**
  * Locates quoted file paths embedded in .rq source text, including @tests list entries.
+ * Skips inline code (`…`) and fenced ``` blocks — those are opaque examples, not live refs.
+ * rq:["../../../reqlan rq/language/syntax.rq".inline_code]
+ * rq:["../../../reqlan rq/language/syntax.rq".code_snippets]
  */
 import type { LangiumDocument } from 'langium';
 import type { Position, Range } from 'vscode-languageserver';
@@ -18,27 +21,69 @@ const FILE_REFERENCE_LIKE = /(?:\.\w[\w.]*|\/)/;
 export function findEmbeddedFileReferencesInText(text: string, lineOffset = 0): EmbeddedFileReference[] {
     const references: EmbeddedFileReference[] = [];
     const lines = text.split(/\r?\n/);
+    let inFence = false;
     for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
         const line = lines[lineIndex];
+        if (isCodeFenceLine(line)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence) {
+            continue;
+        }
+        const opaque = inlineCodeSpans(line);
         for (const match of line.matchAll(BRACKETED_FILE_REFERENCE_PATTERN)) {
-            pushEmbeddedReference(references, match, lineIndex, lineOffset, line);
+            pushEmbeddedReference(references, match, lineIndex, lineOffset, line, opaque);
         }
         for (const match of line.matchAll(QUOTED_FILE_REFERENCE_PATTERN)) {
             if (line.slice(Math.max(0, (match.index ?? 0) - 1), match.index).includes('[')) {
                 continue;
             }
-            pushEmbeddedReference(references, match, lineIndex, lineOffset, line);
+            pushEmbeddedReference(references, match, lineIndex, lineOffset, line, opaque);
         }
     }
     return references;
 }
 
+function isCodeFenceLine(line: string): boolean {
+    return line.trimStart().startsWith('```');
+}
+
+function inlineCodeSpans(line: string): Array<{ start: number; end: number }> {
+    const spans: Array<{ start: number; end: number }> = [];
+    let index = 0;
+    while (index < line.length) {
+        if (line[index] !== '`') {
+            index++;
+            continue;
+        }
+        if (line.startsWith('```', index)) {
+            index += 3;
+            continue;
+        }
+        const close = line.indexOf('`', index + 1);
+        if (close < 0) {
+            break;
+        }
+        if (close > index + 1) {
+            spans.push({ start: index, end: close + 1 });
+        }
+        index = close + 1;
+    }
+    return spans;
+}
+
+function rangeOverlapsOpaque(start: number, end: number, opaque: Array<{ start: number; end: number }>): boolean {
+    return opaque.some(span => start < span.end && end > span.start);
+}
+
 function pushEmbeddedReference(
     references: EmbeddedFileReference[],
     match: RegExpMatchArray,
     lineIndex: number,
     lineOffset: number,
-    line: string
+    line: string,
+    opaque: Array<{ start: number; end: number }>
 ): void {
     const quoted = match[1];
     const file = parseReqlanQuotedString(quoted);
@@ -46,14 +91,18 @@ function pushEmbeddedReference(
         return;
     }
     const start = match.index ?? 0;
-    if (isRangeInsideMarkdownLinkLabel(line, start, start + match[0].length)) {
+    const end = start + match[0].length;
+    if (rangeOverlapsOpaque(start, end, opaque)) {
+        return;
+    }
+    if (isRangeInsideMarkdownLinkLabel(line, start, end)) {
         return;
     }
     references.push({
         file,
         range: {
             start: { line: lineOffset + lineIndex, character: start },
-            end: { line: lineOffset + lineIndex, character: start + match[0].length }
+            end: { line: lineOffset + lineIndex, character: end }
         }
     });
 }

package/src/reqlan-file-link-resolver.ts

@@ -1,6 +1,10 @@
 /**
  * Resolves file references, idea references, and import paths to target URIs and editor ranges.
  * Document links use these so same-file and cross-file refs share the same underline/click affordance.
+ * Missing file refs stay in this result so the validator can underline them without creating a link.
+ * rq:["../../../reqlan rq/extension/language-support/language-server-errors.rq".file_reference_errors]
+ * rq:["../../../reqlan rq/extension/syntax/features-syntax.rq".file_references]
+ * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_folder_targets]
  */
 import type { AstNode, CstNode, FileSystemProvider, LangiumDocument, LangiumDocuments, Reference, URI } from 'langium';
 import { AstUtils, CstUtils, GrammarUtils } from 'langium';
@@ -50,6 +54,8 @@ export type ReferenceResolution = 'file' | 'folder' | 'missing' | 'wildcard';
 
 export type FileLinkTargetIssue = 'empty' | 'parse-error';
 
+export const FILE_REFERENCE_MISSING = 'file-reference-missing';
+
 export interface ResolvedFileLink {
     sourceRange: Range;
     targetUri: string;
@@ -57,6 +63,8 @@ export interface ResolvedFileLink {
     resolution?: ReferenceResolution;
     folderFiles?: string[];
     targetIssue?: FileLinkTargetIssue;
+    /** Authored path (no test/line suffix) for missing-file diagnostics. */
+    authoredPath?: string;
     /** Present when resolution is `wildcard`. */
     wildcardArgs?: WildcardReferenceArgs;
     wildcardMatches?: WildcardMatch[];
@@ -126,14 +134,18 @@ export function resolveImportPathLink(
     }
     const imported = findImportedDocument(path, document, documents, context);
     const target = imported?.parseResult.value.$cstNode;
-    if (!imported || !target) {
+    if (imported && target) {
+        return {
+            sourceRange,
+            targetUri: imported.textDocument.uri,
+            targetRange: target.range
+        };
+    }
+    const fileSystem = context?.fileSystem;
+    if (!fileSystem) {
         return undefined;
     }
-    return {
-        sourceRange,
-        targetUri: imported.textDocument.uri,
-        targetRange: target.range
-    };
+    return resolveImportedFileLink(document, documents, fileSystem, path, sourceRange, context);
 }
 
 export function resolveQualifiedReferencePathLink(
@@ -238,21 +250,28 @@ function resolvePathStringLink(
     targetUri: URI,
     sourceRange: Range
 ): ResolvedFileLink | undefined {
+    if (!parsed.filePath.trim()) {
+        return missingFileLink(sourceRange, targetUri, parsed.filePath);
+    }
+    if (isRemoteFileReferencePath(parsed.filePath)) {
+        return undefined;
+    }
     const resolution = classifyReferenceUri(targetUri, documents, fileSystem);
     if (resolution === 'missing') {
-        return undefined;
+        return missingFileLink(sourceRange, targetUri, parsed.filePath);
     }
     if (resolution === 'folder') {
         return {
             sourceRange,
             targetUri: targetUri.toString(),
             resolution,
-            folderFiles: listFolderFileNames(fileSystem, targetUri)
+            folderFiles: listFolderFileNames(fileSystem, targetUri),
+            authoredPath: parsed.filePath
         };
     }
     const text = readTargetText(targetUri, documents, fileSystem);
     if (text === undefined) {
-        return undefined;
+        return missingFileLink(sourceRange, targetUri, parsed.filePath);
     }
     const targetIssue = detectFileLinkTargetIssue(text, findTargetDocument(targetUri, documents));
     let targetRange: Range | undefined;
@@ -271,10 +290,24 @@ function resolvePathStringLink(
         targetUri: targetUri.toString(),
         targetRange,
         resolution: 'file',
-        targetIssue
+        targetIssue,
+        authoredPath: parsed.filePath
+    };
+}
+
+function missingFileLink(sourceRange: Range, targetUri: URI, authoredPath: string): ResolvedFileLink {
+    return {
+        sourceRange,
+        targetUri: targetUri.toString(),
+        resolution: 'missing',
+        authoredPath
     };
 }
 
+function isRemoteFileReferencePath(path: string): boolean {
+    return /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(path);
+}
+
 export function detectFileLinkTargetIssue(
     text: string,
     targetDocument: LangiumDocument | undefined
@@ -297,6 +330,14 @@ export function fileLinkTargetIssueMessage(issue: FileLinkTargetIssue): string {
     }
 }
 
+export function fileLinkMissingMessage(path: string): string {
+    const trimmed = path.trim();
+    if (!trimmed) {
+        return 'Could not resolve file reference.';
+    }
+    return `Could not resolve file reference '${trimmed}'.`;
+}
+
 function findTargetDocument(targetUri: URI, documents: LangiumDocuments): LangiumDocument | undefined {
     const direct = documents.getDocument(targetUri);
     if (direct) {
@@ -347,7 +388,11 @@ export function resolveImportedFileLink(
     context?: PathResolveContext
 ): ResolvedFileLink | undefined {
     const targetUri = resolveExistingImportUri(filePath, document, documents, fileSystem, context);
-    return resolvePathStringLink(document, documents, fileSystem, { filePath }, targetUri, sourceRange);
+    const link = resolvePathStringLink(document, documents, fileSystem, { filePath }, targetUri, sourceRange);
+    if (!link || link.resolution === 'missing') {
+        return undefined;
+    }
+    return link;
 }
 
 export function filePathRangeInStringNode(pathNode: CstNode, parsed: ParsedFileReference): Range {

package/src/reqlan-file-references.ts

@@ -1,5 +1,6 @@
 /**
  * Parses file path strings from bracket references, including L# line suffixes and :test name suffixes.
+ * rq:["../../../reqlan rq/language/syntax.rq".reference_file]
  */
 
 export interface ParsedFileReference {
@@ -30,28 +31,37 @@ export function parseFileReferenceString(file: string): ParsedFileReference {
 }
 
 function parseTestNameSuffix(file: string): { filePath: string; testName?: string } {
-    let colonIndex = -1;
-    for (let index = file.length - 1; index >= 0; index--) {
+    for (let index = 0; index < file.length; index++) {
         if (file[index] !== ':') {
             continue;
         }
-        if (index > 0 && file[index - 1] === '/' && index > 1 && file[index - 2] === '/') {
+        if (isUriSchemeColon(file, index) || isWindowsDriveColon(file, index)) {
             continue;
         }
-        colonIndex = index;
-        break;
-    }
-    if (colonIndex < 0) {
-        return { filePath: file };
-    }
-    const testName = file.slice(colonIndex + 1);
-    if (!testName) {
-        return { filePath: file };
+        const testName = file.slice(index + 1);
+        if (!testName) {
+            return { filePath: file };
+        }
+        return {
+            filePath: file.slice(0, index),
+            testName
+        };
     }
-    return {
-        filePath: file.slice(0, colonIndex),
-        testName
-    };
+    return { filePath: file };
+}
+
+/** `https://` / `file://` — the colon that starts `://`. */
+function isUriSchemeColon(file: string, index: number): boolean {
+    return file[index + 1] === '/' && file[index + 2] === '/';
+}
+
+/** Drive letter in `C:\…` or `file://C:/…`. */
+function isWindowsDriveColon(file: string, index: number): boolean {
+    const previous = file[index - 1];
+    const next = file[index + 1];
+    return previous !== undefined
+        && /[A-Za-z]/.test(previous)
+        && (next === '\\' || next === '/');
 }
 
 const NON_RQ_FILE_EXTENSION = /\.[^./\\]+$/;