@reqlan/language 1.9.7 → 1.10.1

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 = /\.[^./\\]+$/;

package/src/reqlan-ignore-error.ts

@@ -1,28 +1,14 @@
 /**
- * Suppresses diagnostics on lines immediately following `//rq-ignore-error`.
+ * Langium glue: drop diagnostics on lines that `//rq-ignore-error` suppresses.
+ * Line detection is the core Rust scanner (`find_rq_ignore_error_target_lines`).
  * 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/;
+import { findRqIgnoreErrorTargetLines as nativeFindRqIgnoreErrorTargetLines } from '@reqlan/analytical/core';
 
 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;
+    return new Set(nativeFindRqIgnoreErrorTargetLines(text));
 }
 
 export function filterRqIgnoredDiagnostics(text: string, diagnostics: Diagnostic[]): Diagnostic[] {

package/src/reqlan-imports.ts

@@ -1,8 +1,10 @@
 /**
  * Resolves imported requirement documents from relative and import-root-aliased paths.
  * Interacts with scope linking and go-to-definition for import paths.
+ * A path that exists as a folder is a valid import target (same as a file).
  * rq:["../../../reqlan rq/ontology.rq".import_statement]
  * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".implicit_file_extension]
+ * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_folder_targets]
  */
 import type { FileSystemProvider, LangiumDocument, LangiumDocuments, URI } from 'langium';
 import {
@@ -16,7 +18,7 @@ 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.
+ * extensionless files and folders on disk keep resolving.
  */
 export function importPathCandidates(path: string): string[] {
     const implicit = importPathWithImplicitExtension(path);
@@ -99,10 +101,7 @@ function isImportTarget(
     if (documents.getDocument(uri)) {
         return true;
     }
-    if (!fileSystem?.existsSync(uri)) {
-        return false;
-    }
-    return !fileSystem.statSync(uri).isDirectory;
+    return fileSystem?.existsSync(uri) === true;
 }
 
 function withFileSystem(

package/src/reqlan-module.ts

@@ -110,6 +110,7 @@ export function createReqlanServices(context: DefaultSharedModuleContext): {
     );
     shared.ServiceRegistry.register(Reqlan);
     registerValidationChecks(Reqlan);
+    // rq:["../../../reqlan rq/language/syntax.rq".comment_reference_ignore]
     registerRqIgnoreErrorFiltering(shared);
     if (!context.connection) {
         // We don't run inside a language server

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,10 +3,9 @@ import { AstUtils } from 'langium';
 import type { reqlanAstType } from './generated/ast.js';
 import {
     isFromImport,
-    isIdea,
+    isIdeaDeclaration,
     isInvalidFromImport,
     isModel,
-    isOneLinerIdea,
     isWildcardReference,
     type AnonymousBlock,
     type Model
@@ -14,6 +13,8 @@ import {
 import { collectCommentReferenceIssues } from './reqlan-comment-diagnostics.js';
 import {
     collectFileLinks,
+    FILE_REFERENCE_MISSING,
+    fileLinkMissingMessage,
     fileLinkTargetIssueMessage
 } from './reqlan-file-link-resolver.js';
 import {
@@ -34,6 +35,7 @@ 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]
@@ -53,10 +55,13 @@ 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 {
@@ -139,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>();
@@ -148,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;
@@ -164,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 {
@@ -208,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;
             }
@@ -258,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 '{'