@reqlan/language 1.5.0 → 1.6.0

package/src/reqlan-idea-refactor.ts

@@ -0,0 +1,222 @@
+/**
+ * Plan workspace edits for moving or deleting idea declarations and their references.
+ * rq:["../../../reqlan rq/extension/refactor_support.rq".refactor_symbol_move]
+ * rq:["../../../reqlan rq/extension/refactor_support.rq".refactor_symbol_delete]
+ * rq:["../../../reqlan rq/extension/refactor_support.rq".refactor_changes]
+ */
+import type { AstNode, LangiumDocument, ReferenceDescription } from 'langium';
+import { AstUtils } from 'langium';
+import type { Range, TextEdit } from 'vscode-languageserver';
+import {
+    isIdea,
+    isModel,
+    isOneLinerIdea,
+    type Idea,
+    type Model,
+    type OneLinerIdea
+} from './generated/ast.js';
+import {
+    buildFromImportEdit,
+    findImportInsertPosition,
+    relativeRqImportPath
+} from './reqlan-import-edits.js';
+
+export type RefactorIdeaDeclaration = Idea | OneLinerIdea;
+
+export interface DocumentTextEdits {
+    uri: string;
+    edits: TextEdit[];
+}
+
+export function isRefactorIdeaDeclaration(node: AstNode): node is RefactorIdeaDeclaration {
+    return isIdea(node) || isOneLinerIdea(node);
+}
+
+export function ideaDeclarationText(document: LangiumDocument, idea: RefactorIdeaDeclaration): string | undefined {
+    const range = idea.$cstNode?.range;
+    if (!range) {
+        return undefined;
+    }
+    return document.textDocument.getText(range);
+}
+
+export function planIdeaDeleteEdits(
+    idea: RefactorIdeaDeclaration,
+    references: readonly ReferenceDescription[],
+    documentsText?: Map<string, string>
+): DocumentTextEdits[] {
+    const byUri = new Map<string, TextEdit[]>();
+    const declarationDoc = AstUtils.getDocument(idea);
+    const declarationUri = declarationDoc.uri.toString();
+    const declarationRange = expandDeclarationRange(idea);
+    if (declarationRange) {
+        pushEdit(byUri, declarationUri, { range: declarationRange, newText: '' });
+    }
+
+    for (const reference of references) {
+        const uri = reference.sourceUri.toString();
+        if (uri === declarationUri && rangesOverlap(reference.segment.range, declarationRange)) {
+            continue;
+        }
+        const clearRange = expandReferenceClearRange(
+            documentsText?.get(uri),
+            reference.segment.range
+        );
+        pushEdit(byUri, uri, { range: clearRange, newText: '' });
+    }
+
+    if (documentsText) {
+        for (const [uri, text] of documentsText) {
+            for (const edit of planCommentReferenceRemovals(text, idea.name)) {
+                pushEdit(byUri, uri, edit);
+            }
+        }
+    }
+
+    return toDocumentEdits(byUri);
+}
+
+export function planIdeaMoveEdits(input: {
+    idea: RefactorIdeaDeclaration;
+    sourceDocument: LangiumDocument;
+    destinationDocument: LangiumDocument;
+    references: readonly ReferenceDescription[];
+}): DocumentTextEdits[] {
+    const ideaText = ideaDeclarationText(input.sourceDocument, input.idea);
+    if (!ideaText) {
+        return [];
+    }
+
+    const byUri = new Map<string, TextEdit[]>();
+    const sourceUri = input.sourceDocument.uri.toString();
+    const destUri = input.destinationDocument.uri.toString();
+    const declarationRange = expandDeclarationRange(input.idea);
+    if (declarationRange) {
+        pushEdit(byUri, sourceUri, { range: declarationRange, newText: '' });
+    }
+
+    const destModel = input.destinationDocument.parseResult.value;
+    if (isModel(destModel)) {
+        const insert = findIdeaInsertPosition(destModel);
+        pushEdit(byUri, destUri, {
+            range: { start: insert, end: insert },
+            newText: `${ideaText}\n`
+        });
+    }
+
+    if (sourceKeepsReferences(input.references, sourceUri, declarationRange)) {
+        const importPath = relativeRqImportPath(input.sourceDocument.uri, input.destinationDocument.uri);
+        const importEdit = buildFromImportEdit(input.sourceDocument, importPath, input.idea.name);
+        if (importEdit) {
+            pushEdit(byUri, sourceUri, importEdit);
+        }
+    }
+
+    return toDocumentEdits(byUri);
+}
+
+function sourceKeepsReferences(
+    references: readonly ReferenceDescription[],
+    sourceUri: string,
+    declarationRange: Range | undefined
+): boolean {
+    return references.some(reference =>
+        reference.sourceUri.toString() === sourceUri
+        && !rangesOverlap(reference.segment.range, declarationRange)
+    );
+}
+
+function findIdeaInsertPosition(model: Model): { line: number; character: number } {
+    const lastElement = model.elements[model.elements.length - 1];
+    if (lastElement?.$cstNode) {
+        const end = lastElement.$cstNode.range.end;
+        return { line: end.line + 1, character: 0 };
+    }
+    return findImportInsertPosition(model).position;
+}
+
+function expandDeclarationRange(idea: RefactorIdeaDeclaration): Range | undefined {
+    const range = idea.$cstNode?.range;
+    if (!range) {
+        return undefined;
+    }
+    return {
+        start: { line: range.start.line, character: 0 },
+        end: { line: range.end.line + 1, character: 0 }
+    };
+}
+
+function expandReferenceClearRange(text: string | undefined, range: Range): Range {
+    if (!text) {
+        return range;
+    }
+    const line = text.split(/\r?\n/)[range.start.line] ?? '';
+    const before = line.slice(0, range.start.character);
+    const after = line.slice(range.end.character);
+    const wikiOpen = before.endsWith('[[') ? 2 : before.endsWith('[') ? 1 : 0;
+    const wikiClose = after.startsWith(']]') ? 2 : after.startsWith(']') ? 1 : 0;
+    if (wikiOpen > 0 && wikiClose > 0) {
+        return {
+            start: { line: range.start.line, character: range.start.character - wikiOpen },
+            end: { line: range.end.line, character: range.end.character + wikiClose }
+        };
+    }
+    return range;
+}
+
+function planCommentReferenceRemovals(text: string, ideaName: string): TextEdit[] {
+    const edits: TextEdit[] = [];
+    const pattern = /rq:\s*\[[^\]]*\]/g;
+    for (const match of text.matchAll(pattern)) {
+        const body = match[0]!;
+        if (!new RegExp(`(\\.|\\[)${escapeRegExp(ideaName)}(\\]|$)`).test(body)) {
+            continue;
+        }
+        const start = offsetToPosition(text, match.index ?? 0);
+        const end = offsetToPosition(text, (match.index ?? 0) + body.length);
+        edits.push({ range: { start, end }, newText: '' });
+    }
+    return edits;
+}
+
+function pushEdit(map: Map<string, TextEdit[]>, uri: string, edit: TextEdit): void {
+    const list = map.get(uri) ?? [];
+    list.push(edit);
+    map.set(uri, list);
+}
+
+function toDocumentEdits(byUri: Map<string, TextEdit[]>): DocumentTextEdits[] {
+    return [...byUri.entries()].map(([uri, edits]) => ({
+        uri,
+        edits: [...edits].sort((left, right) => {
+            if (left.range.start.line !== right.range.start.line) {
+                return right.range.start.line - left.range.start.line;
+            }
+            return right.range.start.character - left.range.start.character;
+        })
+    }));
+}
+
+function rangesOverlap(left: Range, right: Range | undefined): boolean {
+    if (!right) {
+        return false;
+    }
+    const leftStart = left.start.line * 1e9 + left.start.character;
+    const leftEnd = left.end.line * 1e9 + left.end.character;
+    const rightStart = right.start.line * 1e9 + right.start.character;
+    const rightEnd = right.end.line * 1e9 + right.end.character;
+    return leftStart < rightEnd && rightStart < leftEnd;
+}
+
+function offsetToPosition(text: string, offset: number): { line: number; character: number } {
+    const before = text.slice(0, offset);
+    const lines = before.split(/\r?\n/);
+    return {
+        line: lines.length - 1,
+        character: lines[lines.length - 1]!.length
+    };
+}
+
+function escapeRegExp(value: string): string {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/reqlan-import-bindings.ts

@@ -18,6 +18,11 @@ export interface ImportBinding {
 
 export type PathBearingImport = Exclude<Import, InvalidFromImport>;
 
+/**
+ * Local binding name for a from-import specifier.
+ * When `as alias` is present, only the alias is bound; the imported idea's base name
+ * remains free for a local idea (see import_tokenisation).
+ */
 export function specifierBindingName(specifier: FromImportSpecifier): string | undefined {
     return specifier.alias ?? specifier.idea.$refText;
 }
@@ -35,6 +40,10 @@ export function importPathOf(importDecl: Import): string | undefined {
     return isPathBearingImport(importDecl) ? importDecl.path : undefined;
 }
 
+/**
+ * Names bound into the importing file's local namespace.
+ * Aliased imports bind only the alias — never the imported idea's base name.
+ */
 export function importBindings(importDecl: Import): ImportBinding[] {
     if (isFromImport(importDecl)) {
         // Mistaken `from "path" as alias` (no idea specifiers) must not bind a name.
@@ -73,16 +82,6 @@ export function importBindings(importDecl: Import): ImportBinding[] {
     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) {

package/src/reqlan-module.ts

@@ -13,6 +13,7 @@ import { ReqlanCodeActionProvider } from './reqlan-code-action-provider.js';
 import { sharedAttributeCatalog } from './reqlan-attribute-catalog.js';
 import { ReqlanCodeLensProvider } from './reqlan-code-lens-provider.js';
 import { ReqlanInlayHintProvider } from './reqlan-inlay-hint-provider.js';
+import { ReqlanRenameProvider } from './reqlan-rename-provider.js';
 import { ReqlanSemanticTokenProvider } from './reqlan-semantic-token-provider.js';
 import { ReqlanTokenBuilder } from './reqlan-token-builder.js';
 import { registerRqIgnoreErrorFiltering } from './reqlan-ignore-error.js';
@@ -60,7 +61,8 @@ export const ReqlanModule: Module<ReqlanServices, PartialLangiumServices & Reqla
         InlayHintProvider: services => new ReqlanInlayHintProvider(services),
         CodeLensProvider: services => new ReqlanCodeLensProvider(services),
         CompletionProvider: services => new ReqlanCompletionProvider(services, sharedAttributeCatalog),
-        CodeActionProvider: services => new ReqlanCodeActionProvider(services)
+        CodeActionProvider: services => new ReqlanCodeActionProvider(services),
+        RenameProvider: services => new ReqlanRenameProvider(services)
     }
 };
 

package/src/reqlan-path-references.ts

@@ -1,5 +1,7 @@
 /**
  * Collects relative file path strings in .rq imports and embedded references, and rq: paths in comments.
+ * rq:["../../../reqlan rq/extension/refactor_support.rq".refactor_file_moves]
+ * rq:["../../../reqlan rq/extension/features-mutation-hooks.rq".move_file]
  */
 import type { Range } from 'vscode-languageserver';
 import { findCommentReferencesInText } from './reqlan-comment-resolver.js';

package/src/reqlan-path-resolve.ts

@@ -8,7 +8,10 @@ import type { FileSystemProvider, LangiumDocument, URI } from 'langium';
 import { URI as UriCtor, UriUtils } from 'langium';
 
 export const DEFAULT_IMPORT_ROOT_ALIAS = '@';
-export const RQCONFIG_FILENAME = '.rqconfig.json';
+/** Base marker / application-memory directory name (must match analytical APPLICATION_MEMORY_DIR). */
+export const REQLAN_DIR = '.reqlan';
+/** Config filename under `<base>/.reqlan/`. */
+export const CONFIG_FILENAME = 'config.json';
 
 export interface ImportRootMapping {
     alias: string;
@@ -53,7 +56,7 @@ export interface PathResolveContext {
     workspaceFolderUri?: URI;
     fileSystem?: FileSystemProvider;
     /**
-     * Preloaded config. `undefined` loads nearest `.rqconfig.json` when fileSystem is set.
+     * Preloaded config. `undefined` loads the owning base’s `.reqlan/config.json` when fileSystem is set.
      * `null` skips loading and uses defaults only.
      */
     config?: RqConfig | null;
@@ -117,15 +120,24 @@ export function findWorkspaceFolderUri(
     return best;
 }
 
+/**
+ * Walk ancestors from startDir. The first directory that owns `.reqlan/` is the applying base.
+ * Load that base’s `.reqlan/config.json` when present; otherwise return undefined (defaults).
+ * Does not inherit a parent base’s config.
+ */
 export function loadApplyingRqConfig(
     startDirUri: URI,
     fileSystem: FileSystemProvider
 ): RqConfig | undefined {
     let dir = startDirUri;
     for (;;) {
-        const configUri = UriUtils.joinPath(dir, RQCONFIG_FILENAME);
-        if (fileSystem.existsSync(configUri) && !fileSystem.statSync(configUri).isDirectory) {
-            return parseRqConfig(configUri, fileSystem);
+        const reqlanDir = UriUtils.joinPath(dir, REQLAN_DIR);
+        if (fileSystem.existsSync(reqlanDir) && fileSystem.statSync(reqlanDir).isDirectory) {
+            const configUri = UriUtils.joinPath(reqlanDir, CONFIG_FILENAME);
+            if (fileSystem.existsSync(configUri) && !fileSystem.statSync(configUri).isDirectory) {
+                return parseRqConfig(configUri, dir, fileSystem);
+            }
+            return undefined;
         }
         const parent = UriUtils.dirname(dir);
         if (UriUtils.equals(parent, dir)) {
@@ -135,7 +147,11 @@ export function loadApplyingRqConfig(
     }
 }
 
-function parseRqConfig(configUri: URI, fileSystem: FileSystemProvider): RqConfig | undefined {
+function parseRqConfig(
+    configUri: URI,
+    baseRootUri: URI,
+    fileSystem: FileSystemProvider
+): RqConfig | undefined {
     let raw: unknown;
     try {
         raw = JSON.parse(fileSystem.readFileSync(configUri));
@@ -146,11 +162,11 @@ function parseRqConfig(configUri: URI, fileSystem: FileSystemProvider): RqConfig
         return undefined;
     }
     const record = raw as Record<string, unknown>;
-    const importRoots = parseImportRoots(record.importRoots, configUri);
+    const importRoots = parseImportRoots(record.importRoots, baseRootUri);
     if (record.importRoots !== undefined && importRoots === undefined) {
         return undefined;
     }
-    const parsedExport = parseExportConfig(record.export, UriUtils.dirname(configUri));
+    const parsedExport = parseExportConfig(record.export, baseRootUri);
     const config: RqConfig = {
         importRoots: importRoots ?? defaultRqConfig().importRoots
     };
@@ -160,7 +176,7 @@ function parseRqConfig(configUri: URI, fileSystem: FileSystemProvider): RqConfig
     return config;
 }
 
-function parseImportRootEntry(entry: unknown, configDir: URI): ImportRootMapping | undefined {
+function parseImportRootEntry(entry: unknown, baseRootUri: URI): ImportRootMapping | undefined {
     if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
         return undefined;
     }
@@ -172,22 +188,21 @@ function parseImportRootEntry(entry: unknown, configDir: URI): ImportRootMapping
     if (typeof record.root === 'string' && record.root.length > 0) {
         mapping.rootUri = isAbsoluteUriOrPath(record.root)
             ? toDirectoryUri(record.root)
-            : UriUtils.resolvePath(configDir, record.root);
+            : UriUtils.resolvePath(baseRootUri, record.root);
     }
     return mapping;
 }
 
-function parseImportRoots(raw: unknown, configUri: URI): ImportRootMapping[] | undefined {
+function parseImportRoots(raw: unknown, baseRootUri: URI): ImportRootMapping[] | undefined {
     if (raw === undefined) {
         return undefined;
     }
     if (!Array.isArray(raw)) {
         return undefined;
     }
-    const configDir = UriUtils.dirname(configUri);
     const importRoots: ImportRootMapping[] = [];
     for (const entry of raw) {
-        const mapping = parseImportRootEntry(entry, configDir);
+        const mapping = parseImportRootEntry(entry, baseRootUri);
         if (mapping) {
             importRoots.push(mapping);
         }
@@ -195,7 +210,7 @@ function parseImportRoots(raw: unknown, configUri: URI): ImportRootMapping[] | u
     return importRoots.length > 0 ? importRoots : defaultRqConfig().importRoots;
 }
 
-function parseExportConfig(raw: unknown, configDir: URI): RqExportConfig | undefined {
+function parseExportConfig(raw: unknown, baseRootUri: URI): RqExportConfig | undefined {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
         return undefined;
     }
@@ -205,7 +220,7 @@ function parseExportConfig(raw: unknown, configDir: URI): RqExportConfig | undef
     if (typeof record.outputFolder === 'string' && record.outputFolder.trim().length > 0) {
         config.outputFolder = isAbsoluteUriOrPath(record.outputFolder)
             ? toDirectoryUri(record.outputFolder).fsPath
-            : UriUtils.resolvePath(configDir, record.outputFolder).fsPath;
+            : UriUtils.resolvePath(baseRootUri, record.outputFolder).fsPath;
     }
     if (typeof record.templateId === 'string' && record.templateId.trim().length > 0) {
         config.templateId = record.templateId.trim();

package/src/reqlan-rename-provider.ts

@@ -0,0 +1,124 @@
+/**
+ * LSP rename for reqlan symbols, including `rq:[...]` comment idea tokens in .rq docs.
+ * rq:["../../../reqlan rq/extension/refactor_support.rq".refactor_symbol_rename]
+ * rq:["../../../reqlan rq/extension/syntax/features-syntax.rq".refactor_support]
+ */
+import type { AstNode, LangiumDocument } from 'langium';
+import { AstUtils, CstUtils } from 'langium';
+import { DefaultRenameProvider } from 'langium/lsp';
+import type { Position, RenameParams, WorkspaceEdit } from 'vscode-languageserver';
+import { TextEdit } from 'vscode-languageserver';
+import { isIdea, isIdeaSet, isOneLinerIdea } from './generated/ast.js';
+import { findCommentIdeaRenameMatches } from './reqlan-comment-rename.js';
+import type { ReqlanServices } from './reqlan-module.js';
+
+export class ReqlanRenameProvider extends DefaultRenameProvider {
+    private readonly documents: ReqlanServices['shared']['workspace']['LangiumDocuments'];
+
+    constructor(services: ReqlanServices) {
+        super(services);
+        this.documents = services.shared.workspace.LangiumDocuments;
+    }
+
+    override async rename(
+        document: LangiumDocument,
+        params: RenameParams
+    ): Promise<WorkspaceEdit | undefined> {
+        const base = await super.rename(document, params);
+        const target = this.resolveRenameTarget(document, params.position);
+        const oldName = targetName(target, node => this.nameProvider.getName(node));
+        if (!oldName || oldName === params.newName) {
+            return base;
+        }
+
+        const declarationDoc = target ? AstUtils.getDocument(target) : document;
+        const declarationPath = declarationDoc.uri.path;
+        const changes = { ...(base?.changes ?? {}) };
+
+        for (const doc of this.documents.all) {
+            const uri = doc.uri.toString();
+            const text = doc.textDocument.getText();
+            const matches = findCommentIdeaRenameMatches(text, oldName, { includePathless: true });
+            const edits = matches
+                .filter(match => commentMatchApplies(
+                    match.path,
+                    declarationPath,
+                    doc.uri.toString() === declarationDoc.uri.toString()
+                ))
+                .map(match => ({
+                    range: match.range,
+                    newText: params.newName
+                }))
+                .filter(edit => !(changes[uri] ?? []).some(existing => rangesEqual(existing.range, edit.range)));
+
+            if (edits.length === 0) {
+                continue;
+            }
+            changes[uri] = [
+                ...(changes[uri] ?? []),
+                ...edits.map(edit => TextEdit.replace(edit.range, edit.newText))
+            ];
+        }
+
+        return Object.keys(changes).length > 0 ? { changes } : base;
+    }
+
+    private resolveRenameTarget(document: LangiumDocument, position: Position): AstNode | undefined {
+        const rootNode = document.parseResult.value.$cstNode;
+        if (!rootNode) {
+            return undefined;
+        }
+        const offset = document.textDocument.offsetAt(position);
+        const leafNode = CstUtils.findDeclarationNodeAtOffset(
+            rootNode,
+            offset,
+            this.grammarConfig.nameRegexp
+        );
+        if (!leafNode) {
+            return undefined;
+        }
+        const declarations = this.references.findDeclarations(leafNode);
+        return declarations[0] ?? leafNode.astNode;
+    }
+}
+
+function targetName(
+    target: AstNode | undefined,
+    getName: (node: AstNode) => string | undefined
+): string | undefined {
+    if (!target) {
+        return undefined;
+    }
+    if (isIdea(target) || isOneLinerIdea(target) || isIdeaSet(target)) {
+        return target.name;
+    }
+    return getName(target);
+}
+
+function commentMatchApplies(
+    path: string | undefined,
+    declarationPath: string,
+    isDeclarationDocument: boolean
+): boolean {
+    if (path === undefined) {
+        return isDeclarationDocument;
+    }
+    const normalizedDecl = declarationPath.replace(/\\/g, '/');
+    const normalizedPath = path.replace(/\\/g, '/');
+    const declBase = normalizedDecl.slice(normalizedDecl.lastIndexOf('/') + 1);
+    const pathBase = normalizedPath.slice(normalizedPath.lastIndexOf('/') + 1);
+    return normalizedDecl.endsWith(normalizedPath)
+        || normalizedDecl.endsWith(`${normalizedPath.replace(/\.rq$/i, '')}.rq`)
+        || declBase === pathBase
+        || declBase.replace(/\.rq$/i, '') === pathBase.replace(/\.rq$/i, '');
+}
+
+function rangesEqual(
+    left: { start: { line: number; character: number }; end: { line: number; character: number } },
+    right: { start: { line: number; character: number }; end: { line: number; character: number } }
+): boolean {
+    return left.start.line === right.start.line
+        && left.start.character === right.start.character
+        && left.end.line === right.end.line
+        && left.end.character === right.end.character;
+}

package/src/reqlan-scope.ts

@@ -127,6 +127,8 @@ export class ReqlanScopeProvider extends DefaultScopeProvider {
         const descriptions = model.elements
             .filter(element => isIdea(element) || isOneLinerIdea(element))
             .map(idea => this.descriptions.createDescription(idea, idea.name, document));
+        // 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) {

package/src/reqlan-validator.ts

@@ -15,7 +15,6 @@ import {
 import {
     importBindings,
     importPathOf,
-    importedIdeaNames,
     isWellFormedFromImport
 } from './reqlan-import-bindings.js';
 import { isResolvableImportPath } from './reqlan-imports.js';
@@ -27,6 +26,7 @@ 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]
  * rq:["../../../reqlan rq/language/imports.rq".import_error_recovery]
+ * rq:["../../../reqlan rq/language/imports.rq".import_tokenisation]
  */
 export function registerValidationChecks(services: ReqlanServices) {
     const registry = services.validation.ValidationRegistry;
@@ -41,6 +41,7 @@ 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/language/imports.rq".import_error_recovery]
+ * rq:["../../../reqlan rq/language/imports.rq".import_tokenisation]
  */
 export class ReqlanValidator {
 
@@ -101,6 +102,10 @@ 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.
+     */
     checkDuplicateIdeaNames(model: Model, accept: ValidationAcceptor): void {
         const seen = new Map<string, AstNode>();
         for (const importDecl of model.imports) {
@@ -120,16 +125,6 @@ export class ReqlanValidator {
                 });
                 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);
         }
     }

package/src/reqlan.langium

@@ -199,10 +199,12 @@ LocalReference:
     idea=[IdeaDeclaration:ReferenceName];
 
 // ---------------------------------------------------------------------------
-// import_from, import_namespace, import_qualified — see imports.rq
+// import_from, import_namespace, import_qualified, import_tokenisation — see imports.rq
 // InvalidFromImport recovers unquoted/malformed `from` lines so later ideas still parse.
 // FromImport allows a mistaken `from "path" as alias` shape for a local diagnostic
 // (valid form still requires `import` + idea specifiers).
+// When a specifier/qualified import has `as alias`, only `alias` binds locally; the
+// imported idea's base name stays free for a local idea declaration.
 // ---------------------------------------------------------------------------
 
 Import:
@@ -214,12 +216,14 @@ FromImport:
       | 'as' alias=ID
     )?;
 
+// Binding name is `alias` when present, otherwise the imported idea name.
 FromImportSpecifier:
     idea=[IdeaDeclaration:ID] ('as' alias=ID)?;
 
 NamespaceImport:
     'import' path=STRING ('as' alias=ID)?;
 
+// Binding name is `alias` when present, otherwise the imported idea name.
 QualifiedImport:
     'import' path=STRING '.' ideaset=ID '.' idea=[IdeaDeclaration:ID] ('as' alias=ID)?;