@reqlan/language 1.9.6 → 1.10.1

package/src/reqlan-reference-at-position.ts

@@ -1,5 +1,8 @@
 /**
  * Locates file path references at a cursor position and resolves them to files, folders, or missing paths.
+ * Missing targets are omitted here so go-to-definition can still try import-path resolution
+ * (for example `from "./target"` → `./target.rq`). Diagnostics still underline those refs.
+ * rq:["../../../reqlan rq/extension/language-support/language-server-errors.rq".file_reference_errors]
  */
 import type { CstNode, FileSystemProvider, LangiumDocument, LangiumDocuments } from 'langium';
 import { CstUtils, GrammarUtils } from 'langium';
@@ -55,15 +58,26 @@ export function findFileReferenceAtPosition(
     }
     const embeddedReference = findEmbeddedFileReferenceAt(document, position);
     if (embeddedReference) {
-        return resolveEmbeddedFileReferenceLink(embeddedReference, document, documents, fileSystem, pathContext);
+        return navigableFileLink(
+            resolveEmbeddedFileReferenceLink(embeddedReference, document, documents, fileSystem, pathContext)
+        );
     }
     const fileReference = findFileReferenceNodeAtPosition(document, position);
     if (fileReference) {
-        return resolveFileReferenceLink(fileReference.node, documents, fileSystem, pathContext);
+        return navigableFileLink(
+            resolveFileReferenceLink(fileReference.node, documents, fileSystem, pathContext)
+        );
     }
     return undefined;
 }
 
+function navigableFileLink(link: ResolvedFileLink | undefined): ResolvedFileLink | undefined {
+    if (!link || link.resolution === 'missing') {
+        return undefined;
+    }
+    return link;
+}
+
 function resolvePathReference(
     document: LangiumDocument,
     path: string,

package/src/reqlan-scope.ts

@@ -1,18 +1,20 @@
 /**
  * Publishes idea and ideaset declarations for file-local and cross-file reference resolution.
+ * Local declarations are collected first; imports are consulted only when a name is not local.
+ * rq:["../../../reqlan rq/language/syntax.rq".same_file_reference]
+ * rq:["../../../reqlan rq/language/syntax.rq".reference_resolution_order]
  */
 import type { AstNodeDescription, LangiumDocument, ReferenceInfo } from 'langium';
 import { AstUtils, DefaultScopeComputation, DefaultScopeProvider, StreamScope, stream, type Scope } from 'langium';
 import {
     isFromImport,
     isFromImportSpecifier,
-    isIdea,
+    isIdeaDeclaration,
     isIdeaSet,
     isInvalidFromImport,
     isLocalReference,
     isModel,
     isNamespaceImport,
-    isOneLinerIdea,
     isQualifiedImport,
     isQualifiedReference,
     type FromImportSpecifier,
@@ -34,7 +36,7 @@ export class ReqlanScopeComputation extends DefaultScopeComputation {
         const model = document.parseResult.value;
         if (isModel(model)) {
             for (const element of model.elements) {
-                if (isIdea(element) || isOneLinerIdea(element) || isIdeaSet(element)) {
+                if (isIdeaDeclaration(element)) {
                     this.addExportedSymbol(element, exports, document);
                 }
             }
@@ -146,20 +148,49 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
     }
 
     private buildFileIdeasScope(document: LangiumDocument): Scope {
+        const locals = this.localDeclarationDescriptions(document);
+        return new StreamScope(
+            stream(locals),
+            new LazyScope(() => this.importedIdeaScope(document)),
+            { concatOuterScope: false }
+        );
+    }
+
+    /**
+     * Every named top-level declaration in the file, regardless of source order.
+     * Bare `[name]` and ideaset members resolve against this set first.
+     */
+    private localDeclarationDescriptions(document: LangiumDocument): AstNodeDescription[] {
         const model = document.parseResult.value as Model;
         if (!isModel(model)) {
-            return new StreamScope(stream([]));
+            return [];
         }
-        const descriptions = model.elements
-            .filter(element => isIdea(element) || isOneLinerIdea(element))
-            .map(idea => this.descriptions.createDescription(idea, idea.name, document));
+        return model.elements
+            .filter(isIdeaDeclaration)
+            .map(element => this.descriptions.createDescription(element, element.name, document));
+    }
+
+    /**
+     * Imported bindings only. Built lazily so a fully-local file never walks import `.ref`s
+     * while resolving same-file names.
+     */
+    private importedIdeaScope(document: LangiumDocument): Scope {
+        return new StreamScope(stream(this.importedIdeaDescriptions(document)));
+    }
+
+    private importedIdeaDescriptions(document: LangiumDocument): AstNodeDescription[] {
+        const model = document.parseResult.value as Model;
+        if (!isModel(model)) {
+            return [];
+        }
+        const descriptions: AstNodeDescription[] = [];
         // Imported ideas enter scope under their binding name only (alias when present).
         // See import_tokenisation: aliased base names are not reserved locally.
         for (const importDecl of model.imports) {
             if (isFromImport(importDecl)) {
                 for (const specifier of importDecl.specifiers) {
                     const target = specifier.idea.ref;
-                    if (!target || (!isIdea(target) && !isOneLinerIdea(target))) {
+                    if (!target || !isIdeaDeclaration(target)) {
                         continue;
                     }
                     const name = specifierBindingName(specifier) ?? target.name;
@@ -169,21 +200,21 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
             }
             if (isQualifiedImport(importDecl)) {
                 const target = importDecl.idea.ref;
-                if (!target || (!isIdea(target) && !isOneLinerIdea(target))) {
+                if (!target || !isIdeaDeclaration(target)) {
                     continue;
                 }
                 const name = importDecl.alias ?? target.name;
                 descriptions.push(this.descriptions.createDescription(target, name, AstUtils.getDocument(target)));
             }
         }
-        return new StreamScope(stream(descriptions));
+        return descriptions;
     }
 
     private scopeForIdeasetMembers(ideaset: IdeaSet, document: LangiumDocument): Scope {
         const descriptions = ideaset.members
             .map(member => member.ref)
             .filter((target): target is NonNullable<typeof target> =>
-                target !== undefined && (isIdea(target) || isOneLinerIdea(target))
+                target !== undefined && isIdeaDeclaration(target)
             )
             .map(target => this.descriptions.createDescription(target, target.name, AstUtils.getDocument(target)));
         if (descriptions.length > 0) {
@@ -209,7 +240,7 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
             return new StreamScope(stream([]));
         }
         const locals = model.elements
-            .filter(element => isIdea(element) || isOneLinerIdea(element) || isIdeaSet(element))
+            .filter(isIdeaDeclaration)
             .map(element => this.descriptions.createDescription(element, element.name, document));
         const namedImports = model.imports.flatMap(importDecl => {
             if (isFromImport(importDecl)) {
@@ -247,7 +278,7 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
                 return undefined;
             }
             const target = importDecl.idea.ref;
-            if (!target || (!isIdea(target) && !isOneLinerIdea(target))) {
+            if (!target || !isIdeaDeclaration(target)) {
                 return undefined;
             }
             const description = this.descriptions.createDescription(target, target.name, imported);
@@ -261,7 +292,7 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
             const descriptions = importDecl.specifiers
                 .map(specifier => specifier.idea.ref)
                 .filter((target): target is NonNullable<typeof target> =>
-                    target !== undefined && (isIdea(target) || isOneLinerIdea(target))
+                    target !== undefined && isIdeaDeclaration(target)
                 )
                 .map(target => this.descriptions.createDescription(target, target.name, imported));
             return new StreamScope(stream(descriptions));
@@ -272,7 +303,7 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
                 return undefined;
             }
             const target = importDecl.idea.ref;
-            if (!target || (!isIdea(target) && !isOneLinerIdea(target))) {
+            if (!target || !isIdeaDeclaration(target)) {
                 return undefined;
             }
             const description = this.descriptions.createDescription(target, target.name, imported);
@@ -315,7 +346,7 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
             return undefined;
         }
         const descriptions = model.elements
-            .filter(element => isIdea(element) || isOneLinerIdea(element))
+            .filter(isIdeaDeclaration)
             .map(idea => this.descriptions.createDescription(idea, idea.name, imported));
         const scope = new StreamScope(stream(descriptions));
         this.importPathCache.set(key, { version: imported.textDocument.version, scope });
@@ -349,3 +380,29 @@ function importAlias(entry: Import): string | undefined {
     }
     return entry.alias;
 }
+
+/**
+ * Defers outer-scope construction until a local lookup misses.
+ * StreamScope `getElement` does not call the outer scope when a local name matches.
+ */
+class LazyScope implements Scope {
+    private resolved: Scope | undefined;
+
+    constructor(private readonly load: () => Scope) {}
+
+    getElement(name: string): AstNodeDescription | undefined {
+        return this.inner().getElement(name);
+    }
+
+    getElements(name: string): ReturnType<Scope['getElements']> {
+        return this.inner().getElements(name);
+    }
+
+    getAllElements(): ReturnType<Scope['getAllElements']> {
+        return this.inner().getAllElements();
+    }
+
+    private inner(): Scope {
+        return this.resolved ??= this.load();
+    }
+}

package/src/reqlan-validator.ts

@@ -3,16 +3,18 @@ import { AstUtils } from 'langium';
 import type { reqlanAstType } from './generated/ast.js';
 import {
     isFromImport,
-    isIdea,
+    isIdeaDeclaration,
     isInvalidFromImport,
     isModel,
-    isOneLinerIdea,
     isWildcardReference,
     type AnonymousBlock,
     type Model
 } from './generated/ast.js';
+import { collectCommentReferenceIssues } from './reqlan-comment-diagnostics.js';
 import {
     collectFileLinks,
+    FILE_REFERENCE_MISSING,
+    fileLinkMissingMessage,
     fileLinkTargetIssueMessage
 } from './reqlan-file-link-resolver.js';
 import {
@@ -33,9 +35,12 @@ import {
 /**
  * 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/extension/language-support/language-server-errors.rq".file_reference_errors]
  * 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]
+ * rq:["../../../reqlan rq/language/syntax.rq".comment_reference_resolution_error]
+ * rq:["../../../reqlan rq/extension/features-non-rq-code-comment/functional-code-comment-references.rq".comment_reference_resolution_error_state]
  */
 export function registerValidationChecks(services: ReqlanServices) {
     const registry = services.validation.ValidationRegistry;
@@ -50,9 +55,14 @@ export function registerValidationChecks(services: ReqlanServices) {
 /**
  * Custom validations for Reqlan documents.
  * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_does_not_exist_error]
+ * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_folder_targets]
+ * rq:["../../../reqlan rq/extension/language-support/language-server-errors.rq".file_reference_errors]
  * 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]
+ * rq:["../../../reqlan rq/language/syntax.rq".comment_reference_resolution_error]
+ * rq:["../../../reqlan rq/core_analysis/check.rq".check_wildcard_sparse]
+ * rq:["../../../reqlan rq/extension/features-non-rq-code-comment/functional-code-comment-references.rq".comment_reference_resolution_error_state]
  */
 export class ReqlanValidator {
 
@@ -64,6 +74,7 @@ export class ReqlanValidator {
         this.checkImportSyntax(model, accept);
         this.checkImportTargets(model, accept);
         this.checkFileReferenceTargets(model, accept);
+        this.checkCommentReferences(model, accept);
         this.checkWildcardReferences(model, accept);
     }
 
@@ -133,6 +144,8 @@ export class ReqlanValidator {
     /**
      * Duplicate check uses import *bindings* only (alias when present, otherwise the idea name).
      * An aliased import does not reserve the imported base name for local ideas.
+     * Ideasets share the same name space as ideas in the file.
+     * rq:["../../../reqlan rq/language/syntax.rq".idea_name]
      */
     checkDuplicateIdeaNames(model: Model, accept: ValidationAcceptor): void {
         const seen = new Map<string, AstNode>();
@@ -142,7 +155,7 @@ export class ReqlanValidator {
             }
         }
         for (const element of model.elements) {
-            if (!isIdea(element) && !isOneLinerIdea(element)) {
+            if (!isIdeaDeclaration(element)) {
                 continue;
             }
             const name = element.name;
@@ -158,7 +171,7 @@ export class ReqlanValidator {
     }
 
     /**
-     * Error underline when an `import` / `from` path does not resolve to a file.
+     * Error underline when an `import` / `from` path does not resolve to a file or folder.
      * Missing imported ideas are reported by the linker as unresolved references.
      */
     checkImportTargets(model: Model, accept: ValidationAcceptor): void {
@@ -202,6 +215,14 @@ export class ReqlanValidator {
             shared.workspace.FileSystemProvider,
             pathResolveContextFromServices(this.services)
         )) {
+            if (link.resolution === 'missing') {
+                accept('error', fileLinkMissingMessage(link.authoredPath ?? ''), {
+                    node: model,
+                    range: link.sourceRange,
+                    code: FILE_REFERENCE_MISSING
+                });
+                continue;
+            }
             if (!link.targetIssue) {
                 continue;
             }
@@ -212,6 +233,23 @@ export class ReqlanValidator {
         }
     }
 
+    checkCommentReferences(model: Model, accept: ValidationAcceptor): void {
+        const document = AstUtils.getDocument(model);
+        const { shared } = this.services;
+        for (const issue of collectCommentReferenceIssues(
+            document,
+            shared.workspace.LangiumDocuments,
+            shared.workspace.FileSystemProvider,
+            pathResolveContextFromServices(this.services)
+        )) {
+            accept('error', issue.message, {
+                node: model,
+                range: issue.range,
+                code: issue.code
+            });
+        }
+    }
+
     checkWildcardReferences(model: Model, accept: ValidationAcceptor): void {
         const { shared } = this.services;
         const context = pathResolveContextFromServices(this.services);
@@ -235,6 +273,12 @@ export class ReqlanValidator {
                     `No ideas match wildcard reference [${wildcardReferenceLabel(path, node.ideaPattern)}].`,
                     { node }
                 );
+            } else if (matches.length === 1) {
+                accept(
+                    'warning',
+                    `Wildcard reference [${wildcardReferenceLabel(path, node.ideaPattern)}] matches only 1 idea.`,
+                    { node }
+                );
             }
         }
     }

package/src/reqlan.langium

@@ -38,8 +38,11 @@ OneLinerIdea:
 OneLinerBody:
     content+=(MarkdownLink | BracketReference | WikiLink | OneLinerText)+;
 
+// Bare [name] refs resolve to any of these. Collect all declarations before linking
+// so a reference may target a name declared later in the same file.
+// rq:["../../../reqlan rq/language/syntax.rq".reference_resolution_order]
 IdeaDeclaration:
-    Idea | OneLinerIdea;
+    Idea | OneLinerIdea | IdeaSet;
 
 Idea:
     name=IdeaName '{'