@oml/language 0.7.0

package/src/oml/oml-module.ts

@@ -0,0 +1,105 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { type Module, inject } from 'langium';
+import { createDefaultModule, createDefaultSharedModule, type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices, type PartialLangiumSharedServices } from 'langium/lsp';
+import { OmlGeneratedModule, OmlGeneratedSharedModule } from './generated/module.js';
+import { OmlCompletionProvider } from './oml-completion.js';
+import { OmlCodeActionProvider } from './oml-code-actions.js';
+import { OmlValueConverter } from './oml-converter.js';
+import { OmlDocumentValidator } from './oml-document-validator.js';
+import { OmlDocumentUpdateHandler } from './oml-document.js';
+import { OmlFormatter } from './oml-formatter.js';
+import { OmlHoverProvider } from './oml-hover.js';
+import { OmlRenameProvider } from './oml-rename.js';
+import { OmlScopeComputation, OmlScopeProvider } from './oml-scope.js';
+import { OmlValidator, registerValidationChecks } from './oml-validator.js';
+import { OmlWorkspaceManager } from './oml-workspace.js';
+
+/**
+ * Declaration of custom services - add your own service classes here.
+ */
+export type OmlAddedServices = {
+    validation: {
+        OmlValidator: OmlValidator
+    }
+}
+
+/**
+ * Union of Langium default services and your custom services - use this as constructor parameter
+ * of custom service classes.
+ */
+export type OmlServices = LangiumServices & OmlAddedServices
+
+/**
+ * Dependency injection module that overrides Langium default services and contributes the
+ * declared custom services. The Langium defaults can be partially specified to override only
+ * selected services, while the custom services must be fully specified.
+ */
+export const OmlModule: Module<OmlServices, PartialLangiumServices & OmlAddedServices> = {
+    lsp: {
+        CodeActionProvider: () => new OmlCodeActionProvider(),
+        CompletionProvider: (services) => new OmlCompletionProvider(services),
+        Formatter: () => new OmlFormatter(),
+        HoverProvider: (services) => new OmlHoverProvider(services),
+        RenameProvider: (services) => new OmlRenameProvider(services)
+    },
+    parser: {
+        ValueConverter: () => new OmlValueConverter()
+    },
+    references: {
+        ScopeComputation: (services) => new OmlScopeComputation(services),
+        ScopeProvider: (services) => new OmlScopeProvider(services)
+    },
+    validation: {
+        DocumentValidator: (services) => new OmlDocumentValidator(services),
+        OmlValidator: (services) => new OmlValidator(services)
+    }
+};
+
+export const OmlSharedModule: Module<LangiumSharedServices, PartialLangiumSharedServices> = {
+    lsp: {
+        DocumentUpdateHandler: (services) => new OmlDocumentUpdateHandler(services)
+    },
+    workspace: {
+        WorkspaceManager: (services) => new OmlWorkspaceManager(services)
+    }
+};
+
+/**
+ * Create the full set of services required by Langium.
+ *
+ * First inject the shared services by merging two modules:
+ *  - Langium default shared services
+ *  - Services generated by langium-cli
+ *
+ * Then inject the language-specific services by merging three modules:
+ *  - Langium default language-specific services
+ *  - Services generated by langium-cli
+ *  - Services specified in this file
+ *
+ * @param context Optional module context with the LSP connection
+ * @returns An object wrapping the shared services and the language-specific services
+ */
+export function createOmlServices(context: DefaultSharedModuleContext): {
+    shared: LangiumSharedServices,
+    Oml: OmlServices
+} {
+    const shared = inject(
+        createDefaultSharedModule(context),
+        OmlGeneratedSharedModule,
+        OmlSharedModule
+    );
+    const Oml = inject(
+        createDefaultModule({ shared }),
+        OmlGeneratedModule,
+        OmlModule
+    );
+    shared.ServiceRegistry.register(Oml);
+    registerValidationChecks(Oml);
+    if (!context.connection) {
+        // We don't run inside a language server
+        // Therefore, initialize the configuration provider instantly
+        shared.workspace.ConfigurationProvider.initialized({});
+    }
+    return { shared, Oml };
+}

package/src/oml/oml-rename.ts

@@ -0,0 +1,140 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { DefaultRenameProvider, type LangiumServices } from 'langium/lsp';
+import type { Position, Range, RenameParams, TextDocumentPositionParams, WorkspaceEdit } from 'vscode-languageserver-protocol';
+import { CstUtils, GrammarUtils, URI } from 'langium';
+import type { LangiumDocument } from 'langium';
+import { TextEdit } from 'vscode-languageserver-types';
+import { isOntology, type Ontology } from './generated/ast.js';
+
+export class OmlRenameProvider extends DefaultRenameProvider {
+    private readonly documents;
+
+    constructor(services: LangiumServices) {
+        super(services);
+        this.documents = services.shared.workspace.LangiumDocuments;
+    }
+
+    override async rename(
+        document: LangiumDocument,
+        params: RenameParams,
+        cancelToken?: any
+    ): Promise<WorkspaceEdit | undefined> {
+        const namespaceRename = this.renameOntologyNamespace(document, params.position, params.newName);
+        if (namespaceRename) {
+            return namespaceRename;
+        }
+        const result = await super.rename(document, params, cancelToken);
+        if (!result?.changes) {
+            return result;
+        }
+        for (const [uri, edits] of Object.entries(result.changes)) {
+            const refDoc = await this.documents.getOrCreateDocument(URI.parse(uri));
+            edits.forEach((edit) => {
+                const refText = refDoc.textDocument.getText(edit.range);
+                edit.newText = this.buildReplacement(refText, params.newName);
+            });
+        }
+        return result;
+    }
+
+    override async prepareRename(
+        document: LangiumDocument,
+        params: TextDocumentPositionParams,
+        cancelToken?: any
+    ) {
+        const target = this.findOntologyNamespaceRenameTarget(document, params.position);
+        if (target) {
+            return target.range;
+        }
+        return super.prepareRename(document, params, cancelToken);
+    }
+
+    private renameOntologyNamespace(document: LangiumDocument, position: Position, newName: string): WorkspaceEdit | undefined {
+        const target = this.findOntologyNamespaceRenameTarget(document, position);
+        if (!target) {
+            return undefined;
+        }
+
+        const newNamespaceText = this.toNamespaceToken(newName);
+        const changes: Record<string, TextEdit[]> = {};
+        changes[document.uri.toString()] = [TextEdit.replace(target.range, newNamespaceText)];
+
+        const references = this.references.findReferences(target.ontology, { includeDeclaration: false });
+        for (const ref of references) {
+            const uri = ref.sourceUri.toString();
+            const change = TextEdit.replace(ref.segment.range, newNamespaceText);
+            if (changes[uri]) {
+                changes[uri].push(change);
+            } else {
+                changes[uri] = [change];
+            }
+        }
+        return { changes };
+    }
+
+    private findOntologyNamespaceRenameTarget(
+        document: LangiumDocument,
+        position: Position
+    ): { ontology: Ontology; range: Range } | undefined {
+        const root = document.parseResult?.value;
+        const rootCst = root?.$cstNode;
+        if (!rootCst || !root || !isOntology(root)) {
+            return undefined;
+        }
+
+        const offset = document.textDocument.offsetAt(position);
+        const namespaceNode = GrammarUtils.findNodeForProperty(rootCst, 'namespace');
+        if (namespaceNode && offset >= namespaceNode.offset && offset <= namespaceNode.offset + namespaceNode.length) {
+            return { ontology: root, range: namespaceNode.range };
+        }
+
+        const leaf = CstUtils.findLeafNodeAtOffset(rootCst, offset);
+        if (!leaf) {
+            return undefined;
+        }
+        const declarations = this.references.findDeclarations(leaf);
+        const ontology = declarations.find((node): node is Ontology => isOntology(node));
+        if (!ontology) {
+            return undefined;
+        }
+        const ontologyNamespaceNode = GrammarUtils.findNodeForProperty(ontology.$cstNode, 'namespace');
+        if (!ontologyNamespaceNode) {
+            return undefined;
+        }
+        return { ontology, range: ontologyNamespaceNode.range };
+    }
+
+    private toNamespaceToken(name: string): string {
+        const trimmed = name.trim();
+        if (trimmed.startsWith('<') && trimmed.endsWith('>')) {
+            return trimmed;
+        }
+        return `<${trimmed.replace(/^<|>$/g, '')}>`;
+    }
+
+    private buildReplacement(refText: string, newName: string): string {
+        if (refText.startsWith('<') && refText.endsWith('>')) {
+            const inner = refText.slice(1, -1);
+            return `<${this.replaceIriTail(inner, newName)}>`;
+        }
+        if (refText.includes('://')) {
+            return this.replaceIriTail(refText, newName);
+        }
+        const qnameMatch = refText.match(/^([A-Za-z_][\w-]*:)[A-Za-z_][\w-]*$/);
+        if (qnameMatch) {
+            return `${qnameMatch[1]}${newName}`;
+        }
+        return newName;
+    }
+
+    private replaceIriTail(iri: string, newName: string): string {
+        const hashIdx = iri.lastIndexOf('#');
+        const slashIdx = iri.lastIndexOf('/');
+        const idx = Math.max(hashIdx, slashIdx);
+        if (idx >= 0) {
+            return `${iri.slice(0, idx + 1)}${newName}`;
+        }
+        return newName;
+    }
+}

package/src/oml/oml-scope.ts

@@ -0,0 +1,279 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+/**
+ * OML Scope Provider
+ * Handles cross-file reference resolution, IRI abbreviation, and qualified name scoping
+ *
+ * Provides enhanced scope resolution for references across imported ontologies and abbreviated IRI names.
+ */
+
+import { AstUtils, DefaultScopeComputation, DefaultScopeProvider, EMPTY_SCOPE, URI, stream } from 'langium';
+import type { AstNodeDescription, LangiumCoreServices, ReferenceInfo, Scope } from 'langium';
+import type { LangiumDocument } from 'langium';
+import type { LangiumSharedServices } from 'langium/lsp';
+import type { CancellationToken } from 'vscode-languageserver';
+import { type Import, type Ontology, isOntology, isRelationBase, isRelationEntity } from './generated/ast.js';
+import { getOntologyModelIndex } from './oml-index.js';
+import {
+    normalizeNamespace,
+} from './oml-utils.js';
+
+interface ExportedSymbol {
+    node: any;
+    name: string;
+    relationAlias: boolean;
+}
+
+interface WorkspaceOntology {
+    document: LangiumDocument;
+    ontology: Ontology;
+    namespace: string;
+}
+
+interface ResolvedImport {
+    prefix?: string;
+    target: WorkspaceOntology;
+}
+
+export class OmlScopeComputation extends DefaultScopeComputation {
+    constructor(services: LangiumCoreServices) {
+        super(services);
+    }
+
+    override async collectExportedSymbols(
+        document: LangiumDocument,
+        cancelToken?: CancellationToken
+    ): Promise<AstNodeDescription[]> {
+        let exported: AstNodeDescription[];
+        try {
+            exported = await super.collectExportedSymbols(document, cancelToken);
+        } catch {
+            return [];
+        }
+        const root = document.parseResult?.value;
+        if (!root || !isOntology(root)) {
+            return exported;
+        }
+
+        const namespace = ((root as any).namespace ?? '').toString().replace(/^<|>$/g, '').trim();
+        if (!namespace) {
+            return exported;
+        }
+
+        const exportedNames = new Set(exported.filter((desc) => desc.node === root).map((desc) => desc.name));
+        const rawName = `<${namespace}>`;
+        if (!exportedNames.has(rawName)) {
+            exported.push(this.descriptions.createDescription(root, rawName, document));
+        }
+
+        // Default Langium exports only the root and its direct children. OML also needs
+        // nested forward/reverse relations exported so workspace-wide completion and
+        // cross-document linking can resolve them as SemanticProperty references.
+        const nestedExportKeys = new Set(exported.map((desc) => `${desc.path}|${desc.name}`));
+        const statements = (root as any).ownedStatements ?? [];
+        for (const statement of statements) {
+            if (!statement || typeof statement !== 'object') {
+                continue;
+            }
+            const forwardRelation = (statement as any).forwardRelation;
+            if (forwardRelation?.name) {
+                const key = `${document.uri.toString()}#${forwardRelation.$cstNode?.offset ?? ''}|${forwardRelation.name}`;
+                if (!nestedExportKeys.has(key)) {
+                    exported.push(this.descriptions.createDescription(forwardRelation, forwardRelation.name as string, document));
+                    nestedExportKeys.add(key);
+                }
+            }
+            if (isRelationBase(statement) && (statement as any).reverseRelation?.name) {
+                const reverseRelation = (statement as any).reverseRelation;
+                const key = `${document.uri.toString()}#${reverseRelation.$cstNode?.offset ?? ''}|${reverseRelation.name}`;
+                if (!nestedExportKeys.has(key)) {
+                    exported.push(this.descriptions.createDescription(reverseRelation, reverseRelation.name as string, document));
+                    nestedExportKeys.add(key);
+                }
+            }
+        }
+        return exported;
+    }
+}
+
+/**
+ * OML-specific scope provider for resolving cross-document references.
+ */
+export class OmlScopeProvider extends DefaultScopeProvider {
+    protected services: LangiumCoreServices;
+
+    constructor(services: LangiumCoreServices) {
+        super(services);
+        this.services = services;
+    }
+
+    override getScope(context: ReferenceInfo): Scope {
+        let referenceType = '';
+
+        // Determine the expected reference type
+        try {
+            referenceType = this.reflection.getReferenceType(context);
+        } catch {
+            return EMPTY_SCOPE;
+        }
+
+        const document = AstUtils.getDocument(context.container);
+        const localSymbols = (document as any)?.localSymbols;
+        // Linking should stay local/import-based. Workspace-global scope is only for ontology imports.
+        let result: Scope = referenceType === 'Ontology'
+            ? this.getGlobalScope(referenceType, context)
+            : EMPTY_SCOPE;
+
+        // Add lexical local symbols (same behavior as DefaultScopeProvider, minus workspace-global fallback).
+        if (localSymbols) {
+            const scopes = [];
+            let currentNode: any = context.container;
+            do {
+                if (localSymbols.has(currentNode)) {
+                    scopes.push(localSymbols.getStream(currentNode).filter((desc: any) => this.reflection.isSubtype(desc.type, referenceType)));
+                }
+                currentNode = currentNode.$container;
+            } while (currentNode);
+
+            for (let i = scopes.length - 1; i >= 0; i--) {
+                result = this.createScope(scopes[i], result);
+            }
+        }
+
+        // Enhance with cross-document IRI abbreviations from imports
+        const ontology = document?.parseResult?.value as Ontology | undefined;
+
+        if (ontology) {
+            result = this.addCurrentOntologyEntries(result, document, ontology);
+            result = this.addImportedOntologyEntries(result, ontology);
+        }
+
+        return result;
+    }
+
+    private getExportedSymbols(ontology: Ontology): ExportedSymbol[] {
+        const symbols: ExportedSymbol[] = [];
+        const statements = (ontology as any).ownedStatements || (ontology as any).ownedMembers || [];
+        for (const statement of statements) {
+            if (!statement || typeof statement !== 'object') {
+                continue;
+            }
+            if ('name' in statement && (statement as any).name) {
+                symbols.push({ node: statement, name: (statement as any).name as string, relationAlias: false });
+            }
+            if (isRelationEntity(statement) && (statement as any).forwardRelation?.name) {
+                symbols.push({
+                    node: (statement as any).forwardRelation,
+                    name: (statement as any).forwardRelation.name as string,
+                    relationAlias: true
+                });
+            }
+            if (isRelationBase(statement) && (statement as any).reverseRelation?.name) {
+                symbols.push({
+                    node: (statement as any).reverseRelation,
+                    name: (statement as any).reverseRelation.name as string,
+                    relationAlias: true
+                });
+            }
+        }
+        return symbols;
+    }
+
+    private getImportNamespace(imp: Import): string {
+        // IMPORTANT: never dereference `imp.imported.ref` while building scopes,
+        // otherwise linking can recursively try to resolve the same import.
+        const raw = (imp.imported as any)?.$refText
+            ?? (imp as any)?.imported
+            ?? '';
+        return typeof raw === 'string' ? raw.replace(/^<|>$/g, '') : '';
+    }
+
+    private resolveOntologyDocument(modelUri: string): WorkspaceOntology | undefined {
+        const document = this.services.shared.workspace.LangiumDocuments.getDocument(URI.parse(modelUri));
+        if (!document) {
+            return undefined;
+        }
+        const root = document.parseResult?.value;
+        if (!root || !isOntology(root)) {
+            return undefined;
+        }
+        const namespace = ((root as any).namespace ?? '').toString().replace(/^<|>$/g, '');
+        if (!namespace) {
+            return undefined;
+        }
+        return {
+            document,
+            ontology: root,
+            namespace
+        };
+    }
+
+    private findOntologyByNamespace(normalizedNamespace: string): WorkspaceOntology | undefined {
+        const index = getOntologyModelIndex(this.services.shared as LangiumSharedServices);
+        const modelUri = index.resolveModelUri(normalizedNamespace);
+        return modelUri ? this.resolveOntologyDocument(modelUri) : undefined;
+    }
+
+    private resolveImports(ontology: Ontology): ResolvedImport[] {
+        const imports = ((ontology as any).ownedImports ?? []) as Import[];
+        const resolved: ResolvedImport[] = [];
+        for (const imp of imports) {
+            const ns = this.getImportNamespace(imp);
+            const normalized = normalizeNamespace(ns);
+            if (!normalized) {
+                continue;
+            }
+            const target = this.findOntologyByNamespace(normalized);
+            if (!target) {
+                continue;
+            }
+            resolved.push({ prefix: imp.prefix, target });
+        }
+        return resolved;
+    }
+
+    private addDescription(scope: Scope, node: any, name: string, document: LangiumDocument): Scope {
+        try {
+            const desc = this.descriptions.createDescription(node, name, document);
+            return this.createScope(stream([desc]), scope);
+        } catch {
+            return scope;
+        }
+    }
+
+    private addCurrentOntologyEntries(scope: Scope, document: LangiumDocument, ontology: Ontology): Scope {
+        let result = scope;
+        const prefix = (ontology as any).prefix as string | undefined;
+        for (const symbol of this.getExportedSymbols(ontology)) {
+            if (prefix) {
+                result = this.addDescription(result, symbol.node, `${prefix}:${symbol.name}`, document);
+            }
+            if (symbol.relationAlias) {
+                result = this.addDescription(result, symbol.node, symbol.name, document);
+            }
+        }
+        return result;
+    }
+
+    private addImportedOntologyEntries(scope: Scope, current: Ontology): Scope {
+        let result = scope;
+        for (const resolvedImport of this.resolveImports(current)) {
+            const imported = resolvedImport.target;
+            const importedSymbols = this.getExportedSymbols(imported.ontology);
+            for (const symbol of importedSymbols) {
+                if (resolvedImport.prefix) {
+                    result = this.addDescription(result, symbol.node, `${resolvedImport.prefix}:${symbol.name}`, imported.document);
+                }
+                const separator = imported.namespace.endsWith('#') || imported.namespace.endsWith('/') ? '' : '#';
+                result = this.addDescription(
+                    result,
+                    symbol.node,
+                    `<${imported.namespace}${separator}${symbol.name}>`,
+                    imported.document
+                );
+            }
+        }
+        return result;
+    }
+
+}