@oml/language 0.9.0 → 0.11.0

package/src/oml/oml-index.ts

@@ -1,34 +1,42 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
-import { DocumentState, type LangiumDocument } from 'langium';
+import { DocumentState, URI, type LangiumDocument } from 'langium';
 import type { LangiumSharedServices } from 'langium/lsp';
-import { isOntology } from './generated/ast.js';
-import { isTransientEditorDocumentUri } from './oml-utils.js';
+import { isAspect, isConcept, isConceptInstance, isDescription, isOntology, isRelationEntity, isRelationInstance, isScalar } from './generated/ast.js';
+import { collectOntologyMembers, getIriForNode, isTransientEditorDocumentUri } from './oml-utils.js';
 
-const ontologyIndexByShared = new WeakMap<object, OntologyModelIndex>();
+const OML_LABEL_IRI = 'http://opencaesar.io/oml#label';
 
-export function getOntologyModelIndex(shared: LangiumSharedServices): OntologyModelIndex {
+const ontologyIndexByShared = new WeakMap<object, OmlIndex>();
+
+export function getOntologyModelIndex(shared: LangiumSharedServices): OmlIndex {
     const key = shared as object;
     const existing = ontologyIndexByShared.get(key);
     if (existing) {
         return existing;
     }
-    const created = new OntologyModelIndex(shared);
+    const created = new OmlIndex(shared);
     ontologyIndexByShared.set(key, created);
     return created;
 }
 
-export class OntologyModelIndex {
-    private readonly ontologyIdentifierToModelUri = new Map<string, string>();
-    private readonly modelUriToOntologyIri = new Map<string, string>();
+export class OmlIndex {
     private readonly workspaceModelUrisByOntologyIri = new Map<string, Set<string>>();
-    private readonly workspaceOntologyIriByModelUri = new Map<string, string>();
     private readonly workspaceNamespaceByModelUri = new Map<string, string>();
+    private readonly memberLabelByIri = new Map<string, string>();
+    private readonly labeledMemberIrisByModelUri = new Map<string, Set<string>>();
+    private readonly instanceIrisByTypeIri = new Map<string, Set<string>>();
+    private readonly instanceTypeIrisByModelUri = new Map<string, Map<string, Set<string>>>();
+    private readonly subTypeIrisByTypeIri = new Map<string, Set<string>>();
+    private readonly typeSuperIrisByModelUri = new Map<string, Map<string, Set<string>>>();
 
     constructor(private readonly shared: LangiumSharedServices) {
         this.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Parsed, (document) => {
             this.indexDocument(document);
         });
+        this.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Linked, (document) => {
+            this.indexLinkedDocument(document);
+        });
     }
 
     resolveModelUri(identifier: string): string | undefined {
@@ -46,11 +54,83 @@ export class OntologyModelIndex {
     }
 
     resolveOntologyIri(modelUri: string): string | undefined {
-        this.ensureIndexedFromLoadedDocuments();
-        return this.modelUriToOntologyIri.get(modelUri);
+        const document = this.shared.workspace.LangiumDocuments.getDocument(URI.parse(modelUri));
+        if (!document) {
+            return undefined;
+        }
+        return this.getOntologyIri(document);
+    }
+
+    getMemberLabel(memberIri: string): string | undefined {
+        return this.memberLabelByIri.get(this.normalizeIri(memberIri));
+    }
+
+    getMemberLabelSnapshot(modelUris: Iterable<string>): Record<string, string> {
+        const snapshot: Record<string, string> = {};
+        for (const modelUri of modelUris) {
+            const labeledMemberIris = this.labeledMemberIrisByModelUri.get(modelUri);
+            if (!labeledMemberIris) {
+                continue;
+            }
+            for (const memberIri of labeledMemberIris) {
+                const label = this.memberLabelByIri.get(memberIri);
+                if (label) {
+                    snapshot[memberIri] = label;
+                }
+            }
+        }
+        return snapshot;
+    }
+
+    getTypeMemberIris(typeIri: string): string[] {
+        const normalizedTypeIri = this.normalizeIri(typeIri);
+        if (!normalizedTypeIri) {
+            return [];
+        }
+        const candidateTypeIris = new Set<string>();
+        const worklist = [normalizedTypeIri];
+        while (worklist.length > 0) {
+            const current = worklist.pop()!;
+            if (candidateTypeIris.has(current)) {
+                continue;
+            }
+            candidateTypeIris.add(current);
+            const subTypes = this.subTypeIrisByTypeIri.get(current);
+            if (!subTypes) {
+                continue;
+            }
+            for (const subType of subTypes) {
+                if (!candidateTypeIris.has(subType)) {
+                    worklist.push(subType);
+                }
+            }
+        }
+        const iris: string[] = [];
+        for (const candidateTypeIri of candidateTypeIris) {
+            const instanceIris = this.instanceIrisByTypeIri.get(candidateTypeIri);
+            if (!instanceIris) {
+                continue;
+            }
+            iris.push(...instanceIris);
+        }
+        return [...new Set(iris)].sort();
     }
 
-    removeModel(modelUri: string): void {
+    getAllDescriptionInstanceIris(): string[] {
+        const iris = new Set<string>();
+        for (const instanceIris of this.instanceIrisByTypeIri.values()) {
+            for (const iri of instanceIris) {
+                iris.add(iri);
+            }
+        }
+        return [...iris].sort();
+    }
+
+    removeDocument(document: LangiumDocument): void {
+        const modelUri = document.uri.toString();
+        this.removeLabelsForModelUri(modelUri);
+        this.removeTypesForModelUri(modelUri);
+        this.removeTypeHierarchyForModelUri(modelUri);
         this.unindexModelUri(modelUri);
     }
 
@@ -68,57 +148,180 @@ export class OntologyModelIndex {
     private indexDocument(document: LangiumDocument): void {
         const modelUri = document.uri.toString();
         this.unindexModelUri(modelUri);
-        const root = document.parseResult?.value;
-        if (!isOntology(root)) {
+        const ontologyIri = this.getOntologyIri(document);
+        if (!ontologyIri) {
             return;
         }
-        const namespace = this.normalizeNamespace((root as any).namespace ?? '');
+        const namespace = this.getNamespace(document);
         if (!namespace) {
             return;
         }
         if (isTransientEditorDocumentUri(modelUri)) {
             return;
         }
-        const ontologyIri = this.ontologyIriFromNamespace(namespace);
         const modelUris = this.workspaceModelUrisByOntologyIri.get(ontologyIri) ?? new Set<string>();
         modelUris.add(modelUri);
         this.workspaceModelUrisByOntologyIri.set(ontologyIri, modelUris);
-        this.workspaceOntologyIriByModelUri.set(modelUri, ontologyIri);
         this.workspaceNamespaceByModelUri.set(modelUri, namespace);
-        this.modelUriToOntologyIri.set(modelUri, ontologyIri);
-        if (modelUris.size === 1) {
-            this.ontologyIdentifierToModelUri.set(namespace, modelUri);
-            this.ontologyIdentifierToModelUri.set(ontologyIri, modelUri);
+    }
+
+    private indexLinkedDocument(document: LangiumDocument): void {
+        const modelUri = document.uri.toString();
+        this.removeLabelsForModelUri(modelUri);
+        this.removeTypesForModelUri(modelUri);
+        this.removeTypeHierarchyForModelUri(modelUri);
+        const root = document.parseResult?.value;
+        if (!isOntology(root) || isTransientEditorDocumentUri(modelUri)) {
+            return;
+        }
+
+        this.indexTypeHierarchy(root as any, modelUri);
+
+        if (!isDescription(root)) {
             return;
         }
-        this.ontologyIdentifierToModelUri.delete(namespace);
-        this.ontologyIdentifierToModelUri.delete(ontologyIri);
+
+        const labeledMemberIris = new Set<string>();
+        const typedInstanceIrisByTypeIri = new Map<string, Set<string>>();
+        for (const member of collectOntologyMembers(root as any)) {
+            const memberIri = this.normalizeIri(getIriForNode(member) ?? '');
+            if (!memberIri) {
+                continue;
+            }
+            const label = this.extractLabel(member);
+            if (label !== undefined) {
+                this.memberLabelByIri.set(memberIri, label);
+                labeledMemberIris.add(memberIri);
+            }
+
+            if (!isConceptInstance(member) && !isRelationInstance(member)) {
+                continue;
+            }
+            const instanceIri = this.resolveInstanceIri(member);
+            if (!instanceIri) {
+                continue;
+            }
+            const ownedTypes = Array.isArray((member as any).ownedTypes) ? (member as any).ownedTypes : [];
+            for (const typeAssertion of ownedTypes) {
+                const typeIri = this.resolveTypeIri(typeAssertion?.type);
+                if (!typeIri) {
+                    continue;
+                }
+                const instanceIris = this.instanceIrisByTypeIri.get(typeIri) ?? new Set<string>();
+                instanceIris.add(instanceIri);
+                this.instanceIrisByTypeIri.set(typeIri, instanceIris);
+
+                const modelTypeIris = typedInstanceIrisByTypeIri.get(typeIri) ?? new Set<string>();
+                modelTypeIris.add(instanceIri);
+                typedInstanceIrisByTypeIri.set(typeIri, modelTypeIris);
+            }
+        }
+
+        if (labeledMemberIris.size > 0) {
+            this.labeledMemberIrisByModelUri.set(modelUri, labeledMemberIris);
+        }
+        if (typedInstanceIrisByTypeIri.size > 0) {
+            this.instanceTypeIrisByModelUri.set(modelUri, typedInstanceIrisByTypeIri);
+        }
+    }
+
+    private indexTypeHierarchy(root: any, modelUri: string): void {
+        const typeSuperIrisByTypeIri = new Map<string, Set<string>>();
+        for (const member of collectOntologyMembers(root as any)) {
+            if (!isConcept(member) && !isAspect(member) && !isRelationEntity(member) && !isScalar(member)) {
+                continue;
+            }
+            const typeIri = this.normalizeIri(getIriForNode(member) ?? '');
+            if (!typeIri) {
+                continue;
+            }
+            const directSupers = typeSuperIrisByTypeIri.get(typeIri) ?? new Set<string>();
+            const specializations = Array.isArray((member as any).ownedSpecializations) ? (member as any).ownedSpecializations : [];
+            for (const specialization of specializations) {
+                const superIri = this.normalizeIri(getIriForNode(specialization?.superTerm?.ref) ?? '');
+                if (!superIri) {
+                    continue;
+                }
+                directSupers.add(superIri);
+                const subTypes = this.subTypeIrisByTypeIri.get(superIri) ?? new Set<string>();
+                subTypes.add(typeIri);
+                this.subTypeIrisByTypeIri.set(superIri, subTypes);
+            }
+            if (directSupers.size > 0) {
+                typeSuperIrisByTypeIri.set(typeIri, directSupers);
+            }
+        }
+        if (typeSuperIrisByTypeIri.size > 0) {
+            this.typeSuperIrisByModelUri.set(modelUri, typeSuperIrisByTypeIri);
+        }
     }
 
     private unindexModelUri(modelUri: string): void {
-        for (const [identifier, uri] of this.ontologyIdentifierToModelUri.entries()) {
-            if (uri === modelUri) {
-                this.ontologyIdentifierToModelUri.delete(identifier);
-            }
-        }
-        const ontologyIri = this.workspaceOntologyIriByModelUri.get(modelUri);
-        if (ontologyIri) {
-            const modelUris = this.workspaceModelUrisByOntologyIri.get(ontologyIri);
-            modelUris?.delete(modelUri);
-            if (!modelUris || modelUris.size === 0) {
-                this.workspaceModelUrisByOntologyIri.delete(ontologyIri);
-            } else if (modelUris.size === 1) {
-                const survivingModelUri = [...modelUris][0];
-                const survivingNamespace = this.workspaceNamespaceByModelUri.get(survivingModelUri);
-                this.ontologyIdentifierToModelUri.set(ontologyIri, survivingModelUri);
-                if (survivingNamespace) {
-                    this.ontologyIdentifierToModelUri.set(survivingNamespace, survivingModelUri);
+        const namespace = this.workspaceNamespaceByModelUri.get(modelUri);
+        if (!namespace) {
+            return;
+        }
+        this.workspaceNamespaceByModelUri.delete(modelUri);
+        const ontologyIri = this.ontologyIriFromNamespace(namespace);
+        const modelUris = this.workspaceModelUrisByOntologyIri.get(ontologyIri);
+        if (!modelUris) {
+            return;
+        }
+        modelUris.delete(modelUri);
+        if (modelUris.size === 0) {
+            this.workspaceModelUrisByOntologyIri.delete(ontologyIri);
+        }
+    }
+
+    private removeLabelsForModelUri(modelUri: string): void {
+        const labeledMemberIris = this.labeledMemberIrisByModelUri.get(modelUri);
+        if (!labeledMemberIris) {
+            return;
+        }
+        for (const memberIri of labeledMemberIris) {
+            this.memberLabelByIri.delete(memberIri);
+        }
+        this.labeledMemberIrisByModelUri.delete(modelUri);
+    }
+
+    private removeTypesForModelUri(modelUri: string): void {
+        const typedInstanceIrisByTypeIri = this.instanceTypeIrisByModelUri.get(modelUri);
+        if (!typedInstanceIrisByTypeIri) {
+            return;
+        }
+        for (const [typeIri, instanceIris] of typedInstanceIrisByTypeIri.entries()) {
+            const globalInstanceIris = this.instanceIrisByTypeIri.get(typeIri);
+            if (!globalInstanceIris) {
+                continue;
+            }
+            for (const instanceIri of instanceIris) {
+                globalInstanceIris.delete(instanceIri);
+            }
+            if (globalInstanceIris.size === 0) {
+                this.instanceIrisByTypeIri.delete(typeIri);
+            }
+        }
+        this.instanceTypeIrisByModelUri.delete(modelUri);
+    }
+
+    private removeTypeHierarchyForModelUri(modelUri: string): void {
+        const typeSuperIrisByTypeIri = this.typeSuperIrisByModelUri.get(modelUri);
+        if (!typeSuperIrisByTypeIri) {
+            return;
+        }
+        for (const [typeIri, superIris] of typeSuperIrisByTypeIri.entries()) {
+            for (const superIri of superIris) {
+                const subTypes = this.subTypeIrisByTypeIri.get(superIri);
+                if (!subTypes) {
+                    continue;
+                }
+                subTypes.delete(typeIri);
+                if (subTypes.size === 0) {
+                    this.subTypeIrisByTypeIri.delete(superIri);
                 }
             }
-            this.workspaceOntologyIriByModelUri.delete(modelUri);
-            this.workspaceNamespaceByModelUri.delete(modelUri);
         }
-        this.modelUriToOntologyIri.delete(modelUri);
+        this.typeSuperIrisByModelUri.delete(modelUri);
     }
 
     getDuplicateWorkspaceModelUris(identifier: string): string[] {
@@ -139,7 +342,90 @@ export class OntologyModelIndex {
         return namespace.replace(/^<|>$/g, '');
     }
 
+    private normalizeIri(iri: string): string {
+        return iri.replace(/^<|>$/g, '').trim();
+    }
+
+    private getOntologyIri(document: LangiumDocument): string | undefined {
+        const namespace = this.getNamespace(document);
+        if (!namespace) {
+            return undefined;
+        }
+        return this.ontologyIriFromNamespace(namespace);
+    }
+
+    private getNamespace(document: LangiumDocument): string | undefined {
+        const root = document.parseResult?.value;
+        if (!isOntology(root)) {
+            return undefined;
+        }
+        const namespace = this.normalizeNamespace((root as any).namespace ?? '');
+        if (!namespace) {
+            return undefined;
+        }
+        return namespace;
+    }
+
     private ontologyIriFromNamespace(namespace: string): string {
         return namespace.replace(/[\/#]+$/, '');
     }
+
+    private extractLabel(member: any): string | undefined {
+        const annotations = Array.isArray(member?.ownedAnnotations) ? member.ownedAnnotations : [];
+        if (annotations.length === 0) {
+            return undefined;
+        }
+        for (const annotation of annotations) {
+            const propertyIri = this.normalizeIri(getIriForNode(annotation?.property?.ref) ?? '');
+            if (propertyIri !== OML_LABEL_IRI) {
+                continue;
+            }
+            const label = this.readAnnotationLiteral(annotation);
+            if (label) {
+                return label;
+            }
+        }
+        return undefined;
+    }
+
+    private readAnnotationLiteral(annotation: any): string | undefined {
+        const literal = Array.isArray(annotation?.literalValues) ? annotation.literalValues[0] : undefined;
+        if (!literal) {
+            return undefined;
+        }
+        const value = literal?.value;
+        if (typeof value === 'string') {
+            return value.trim();
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value);
+        }
+        return undefined;
+    }
+
+    private resolveInstanceIri(member: any): string | undefined {
+        const namedIri = this.normalizeIri(getIriForNode(member) ?? '');
+        if (namedIri) {
+            return namedIri;
+        }
+        const resolved = member?.ref?.ref ?? member?.ref?._ref;
+        if (resolved) {
+            const resolvedIri = this.normalizeIri(getIriForNode(resolved) ?? '');
+            if (resolvedIri) {
+                return resolvedIri;
+            }
+        }
+        return undefined;
+    }
+
+    private resolveTypeIri(typeRef: any): string | undefined {
+        const resolved = typeRef?.ref ?? typeRef?._ref;
+        if (resolved) {
+            const resolvedIri = this.normalizeIri(getIriForNode(resolved) ?? '');
+            if (resolvedIri) {
+                return resolvedIri;
+            }
+        }
+        return undefined;
+    }
 }

package/src/oml/oml-rename.ts

@@ -114,6 +114,7 @@ export class OmlRenameProvider extends DefaultRenameProvider {
     }
 
     private buildReplacement(refText: string, newName: string): string {
+        const escapedName = escapeIdentifier(newName);
         if (refText.startsWith('<') && refText.endsWith('>')) {
             const inner = refText.slice(1, -1);
             return `<${this.replaceIriTail(inner, newName)}>`;
@@ -125,7 +126,7 @@ export class OmlRenameProvider extends DefaultRenameProvider {
         if (qnameMatch) {
             return `${qnameMatch[1]}${newName}`;
         }
-        return newName;
+        return escapedName;
     }
 
     private replaceIriTail(iri: string, newName: string): string {
@@ -138,3 +139,22 @@ export class OmlRenameProvider extends DefaultRenameProvider {
         return newName;
     }
 }
+
+const OML_KEYWORDS = new Set([
+    'all', 'annotation', 'as', 'aspect', 'asymmetric', 'builtIn', 'builtin', 'bundle', 'concept', 'description',
+    'differentFrom', 'domain', 'entity', 'exactly', 'extends', 'forward', 'from', 'functional', 'includes',
+    'instance', 'inverse', 'irreflexive', 'key', 'language', 'length', 'max', 'maxExclusive', 'maxInclusive',
+    'maxLength', 'min', 'minExclusive', 'minInclusive', 'minLength', 'oneOf', 'pattern', 'property', 'range', 'ref',
+    'reflexive', 'relation', 'restricts', 'reverse', 'rule', 'sameAs', 'scalar', 'self', 'some', 'symmetric', 'to',
+    'transitive', 'uses', 'vocabulary'
+]);
+
+function escapeIdentifier(value: string): string {
+    if (!value) {
+        return '';
+    }
+    if (value.startsWith('^')) {
+        return value;
+    }
+    return OML_KEYWORDS.has(value) ? `^${value}` : value;
+}

package/src/oml/oml-utils.ts

@@ -164,6 +164,7 @@ const GITHUB_COPILOT_TRANSIENT_DOCUMENT_SCHEMES = new Set([
     'chat-editing-text-model',
     'chat-editing-snapshot-text-model',
     'vscode-chat-code-block',
+    'git',
 ]);
 
 export function isTransientEditorDocumentUri(uri: string): boolean {

package/out/oml/oml-index-manager.d.ts

@@ -1,10 +0,0 @@
-import { DefaultIndexManager, type AstNode, type LangiumDocument, type LangiumSharedCoreServices, type ReferenceDescription } from 'langium';
-import type { CancellationToken } from 'vscode-jsonrpc';
-export declare class OmlIndexManager extends DefaultIndexManager {
-    private readonly services;
-    constructor(services: LangiumSharedCoreServices);
-    findAllReferences(targetNode: AstNode, astNodePath: string): import("langium").Stream<ReferenceDescription>;
-    updateReferences(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
-    isAffected(document: LangiumDocument, changedUris: Set<string>): boolean;
-    private canonicalizeUri;
-}

package/out/oml/oml-index-manager.js

@@ -1,48 +0,0 @@
-// Copyright (c) 2026 Modelware. All rights reserved.
-import { AstUtils, DefaultIndexManager, URI, UriUtils, stream } from 'langium';
-import { canonicalizeWorkspaceDocumentUri } from './oml-workspace.js';
-export class OmlIndexManager extends DefaultIndexManager {
-    constructor(services) {
-        super(services);
-        this.services = services;
-    }
-    findAllReferences(targetNode, astNodePath) {
-        const targetDocUri = this.canonicalizeUri(AstUtils.getDocument(targetNode).uri);
-        const result = [];
-        this.referenceIndex.forEach(docRefs => {
-            docRefs.forEach(refDescr => {
-                if (UriUtils.equals(this.canonicalizeUri(refDescr.targetUri), targetDocUri) && refDescr.targetPath === astNodePath) {
-                    result.push(refDescr);
-                }
-            });
-        });
-        return stream(result);
-    }
-    async updateReferences(document, cancelToken) {
-        const services = this.serviceRegistry.getServices(document.uri);
-        const references = await services.workspace.ReferenceDescriptionProvider.createDescriptions(document, cancelToken);
-        const sourceUri = this.canonicalizeUri(document.uri);
-        this.referenceIndex.set(document.uri.toString(), references.map(ref => {
-            const targetUri = this.canonicalizeUri(ref.targetUri);
-            return {
-                ...ref,
-                sourceUri,
-                targetUri,
-                local: UriUtils.equals(sourceUri, targetUri),
-            };
-        }));
-    }
-    isAffected(document, changedUris) {
-        const references = this.referenceIndex.get(document.uri.toString());
-        if (!references) {
-            return false;
-        }
-        const canonicalChangedUris = new Set(Array.from(changedUris, uri => this.canonicalizeUri(uri).toString()));
-        return references.some(ref => !ref.local && canonicalChangedUris.has(this.canonicalizeUri(ref.targetUri).toString()));
-    }
-    canonicalizeUri(uri) {
-        const parsedUri = typeof uri === 'string' ? URI.parse(uri) : uri;
-        return canonicalizeWorkspaceDocumentUri(this.services.workspace.WorkspaceManager, parsedUri);
-    }
-}
-//# sourceMappingURL=oml-index-manager.js.map

package/out/oml/oml-index-manager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"oml-index-manager.js","sourceRoot":"","sources":["../../src/oml/oml-index-manager.ts"],"names":[],"mappings":"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"}

package/src/oml/oml-index-manager.ts

@@ -1,56 +0,0 @@
-// Copyright (c) 2026 Modelware. All rights reserved.
-
-import { AstUtils, DefaultIndexManager, URI, UriUtils, stream, type AstNode, type LangiumDocument, type LangiumSharedCoreServices, type ReferenceDescription } from 'langium';
-import type { CancellationToken } from 'vscode-jsonrpc';
-import { canonicalizeWorkspaceDocumentUri } from './oml-workspace.js';
-
-export class OmlIndexManager extends DefaultIndexManager {
-    private readonly services: LangiumSharedCoreServices;
-
-    constructor(services: LangiumSharedCoreServices) {
-        super(services);
-        this.services = services;
-    }
-
-    override findAllReferences(targetNode: AstNode, astNodePath: string) {
-        const targetDocUri = this.canonicalizeUri(AstUtils.getDocument(targetNode).uri);
-        const result: ReferenceDescription[] = [];
-        this.referenceIndex.forEach(docRefs => {
-            docRefs.forEach(refDescr => {
-                if (UriUtils.equals(this.canonicalizeUri(refDescr.targetUri), targetDocUri) && refDescr.targetPath === astNodePath) {
-                    result.push(refDescr);
-                }
-            });
-        });
-        return stream(result);
-    }
-
-    override async updateReferences(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void> {
-        const services = this.serviceRegistry.getServices(document.uri);
-        const references = await services.workspace.ReferenceDescriptionProvider.createDescriptions(document, cancelToken);
-        const sourceUri = this.canonicalizeUri(document.uri);
-        this.referenceIndex.set(document.uri.toString(), references.map(ref => {
-            const targetUri = this.canonicalizeUri(ref.targetUri);
-            return {
-                ...ref,
-                sourceUri,
-                targetUri,
-                local: UriUtils.equals(sourceUri, targetUri),
-            };
-        }));
-    }
-
-    override isAffected(document: LangiumDocument, changedUris: Set<string>): boolean {
-        const references = this.referenceIndex.get(document.uri.toString());
-        if (!references) {
-            return false;
-        }
-        const canonicalChangedUris = new Set(Array.from(changedUris, uri => this.canonicalizeUri(uri).toString()));
-        return references.some(ref => !ref.local && canonicalChangedUris.has(this.canonicalizeUri(ref.targetUri).toString()));
-    }
-
-    private canonicalizeUri(uri: URI | string): URI {
-        const parsedUri = typeof uri === 'string' ? URI.parse(uri) : uri;
-        return canonicalizeWorkspaceDocumentUri(this.services.workspace.WorkspaceManager, parsedUri);
-    }
-}