@domainlang/language 0.5.2 → 0.6.0

package/src/lsp/domain-lang-index-manager.ts

@@ -0,0 +1,256 @@
+import type { LangiumDocument, LangiumSharedCoreServices, URI } from 'langium';
+import { DefaultIndexManager, DocumentState } from 'langium';
+import { CancellationToken } from 'vscode-jsonrpc';
+import { resolveImportPath } from '../utils/import-utils.js';
+import type { Model } from '../generated/ast.js';
+
+/**
+ * Custom IndexManager that extends Langium's default to:
+ * 1. Automatically load imported documents during indexing
+ * 2. Track import dependencies for cross-file revalidation
+ * 
+ * **Why this exists:**
+ * Langium's `DefaultIndexManager.isAffected()` only checks cross-references
+ * (elements declared with `[Type]` grammar syntax). DomainLang's imports use
+ * string literals (`import "path"`), which are not cross-references.
+ * 
+ * **How it works:**
+ * - When a document is indexed, we ensure all its imports are also loaded
+ * - Maintains a reverse dependency graph: importedUri → Set<importingUri>
+ * - Overrides `isAffected()` to also check this graph
+ * - This integrates with Langium's native `DocumentBuilder.update()` flow
+ * 
+ * **Integration with Langium:**
+ * This approach is idiomatic because:
+ * 1. `updateContent()` is called for EVERY document during build
+ * 2. We load imports during indexing, BEFORE linking/validation
+ * 3. `DocumentBuilder.shouldRelink()` calls `IndexManager.isAffected()`
+ * 4. No need for separate lifecycle service - this IS the central place
+ */
+export class DomainLangIndexManager extends DefaultIndexManager {
+    /**
+     * Reverse dependency graph: maps a document URI to all documents that import it.
+     * Key: imported document URI (string)
+     * Value: Set of URIs of documents that import the key document
+     */
+    private readonly importDependencies = new Map<string, Set<string>>();
+    
+    /**
+     * Tracks documents that have had their imports loaded to avoid redundant work.
+     * Cleared on workspace config changes.
+     */
+    private readonly importsLoaded = new Set<string>();
+    
+    /**
+     * Reference to shared services for accessing LangiumDocuments.
+     */
+    private readonly sharedServices: LangiumSharedCoreServices;
+
+    constructor(services: LangiumSharedCoreServices) {
+        super(services);
+        this.sharedServices = services;
+    }
+
+    /**
+     * Extends the default content update to:
+     * 1. Ensure all imported documents are loaded
+     * 2. Track import dependencies for change propagation
+     * 
+     * Called by Langium during the IndexedContent build phase.
+     * This is BEFORE linking/validation, so imports are available for resolution.
+     */
+    override async updateContent(document: LangiumDocument, cancelToken = CancellationToken.None): Promise<void> {
+        // First, do the standard content indexing
+        await super.updateContent(document, cancelToken);
+
+        // Then, ensure imports are loaded and track dependencies
+        await this.ensureImportsLoaded(document);
+        await this.trackImportDependencies(document);
+    }
+
+    /**
+     * Extends the default remove to also clean up import dependencies.
+     */
+    override remove(uri: URI): void {
+        super.remove(uri);
+        const uriString = uri.toString();
+        this.removeImportDependencies(uriString);
+        this.importsLoaded.delete(uriString);
+    }
+
+    /**
+     * Extends the default content removal to also clean up import dependencies.
+     */
+    override removeContent(uri: URI): void {
+        super.removeContent(uri);
+        const uriString = uri.toString();
+        this.removeImportDependencies(uriString);
+        this.importsLoaded.delete(uriString);
+    }
+
+    /**
+     * Extends `isAffected` to also check import dependencies.
+     * 
+     * A document is affected if:
+     * 1. It has cross-references to any changed document (default Langium behavior)
+     * 2. It imports any of the changed documents (our extension)
+     */
+    override isAffected(document: LangiumDocument, changedUris: Set<string>): boolean {
+        // First check Langium's default: cross-references
+        if (super.isAffected(document, changedUris)) {
+            return true;
+        }
+
+        // Then check our import dependencies
+        const docUri = document.uri.toString();
+        for (const changedUri of changedUris) {
+            const dependents = this.importDependencies.get(changedUri);
+            if (dependents?.has(docUri)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Tracks import dependencies for a document.
+     * For each import in the document, records that the imported URI is depended upon.
+     */
+    private async trackImportDependencies(document: LangiumDocument): Promise<void> {
+        const importingUri = document.uri.toString();
+        
+        // First, remove old dependencies from this document
+        // (in case imports changed)
+        this.removeDocumentFromDependencies(importingUri);
+
+        // Skip if document isn't ready (no parse result)
+        if (document.state < DocumentState.Parsed) {
+            return;
+        }
+
+        const model = document.parseResult.value as unknown as Model;
+        if (!model.imports) {
+            return;
+        }
+
+        for (const imp of model.imports) {
+            if (!imp.uri) continue;
+
+            try {
+                const resolvedUri = await resolveImportPath(document, imp.uri);
+                const importedUri = resolvedUri.toString();
+
+                // Add to reverse dependency graph: importedUri → importingUri
+                let dependents = this.importDependencies.get(importedUri);
+                if (!dependents) {
+                    dependents = new Set();
+                    this.importDependencies.set(importedUri, dependents);
+                }
+                dependents.add(importingUri);
+            } catch {
+                // Import resolution failed - validation will report the error
+            }
+        }
+    }
+
+    /**
+     * Ensures all imported documents are loaded and available.
+     * This is called during indexing, BEFORE linking/validation,
+     * so that cross-file references can be resolved.
+     * 
+     * Works for both workspace files and standalone files.
+     */
+    private async ensureImportsLoaded(document: LangiumDocument): Promise<void> {
+        const uriString = document.uri.toString();
+        
+        // Skip if already processed (avoid redundant work and infinite loops)
+        if (this.importsLoaded.has(uriString)) {
+            return;
+        }
+        this.importsLoaded.add(uriString);
+
+        // Skip if document isn't ready (no parse result)
+        if (document.state < DocumentState.Parsed) {
+            return;
+        }
+
+        const model = document.parseResult.value as unknown as Model;
+        if (!model.imports || model.imports.length === 0) {
+            return;
+        }
+
+        const langiumDocuments = this.sharedServices.workspace.LangiumDocuments;
+        const documentBuilder = this.sharedServices.workspace.DocumentBuilder;
+        const newDocs: LangiumDocument[] = [];
+
+        for (const imp of model.imports) {
+            if (!imp.uri) continue;
+
+            try {
+                const resolvedUri = await resolveImportPath(document, imp.uri);
+                const importedUriString = resolvedUri.toString();
+                
+                // Skip if already loaded
+                if (this.importsLoaded.has(importedUriString)) {
+                    continue;
+                }
+
+                // Load or create the imported document
+                const importedDoc = await langiumDocuments.getOrCreateDocument(resolvedUri);
+                
+                // If document is new (not yet indexed), add to batch
+                if (importedDoc.state < DocumentState.IndexedContent) {
+                    newDocs.push(importedDoc);
+                }
+            } catch {
+                // Import resolution failed - validation will report the error
+            }
+        }
+
+        // Build any newly discovered documents
+        // This triggers indexing which will recursively load their imports
+        if (newDocs.length > 0) {
+            await documentBuilder.build(newDocs, { validation: true });
+        }
+    }
+
+    /**
+     * Removes a document from the import dependencies graph entirely.
+     * Called when a document is deleted.
+     */
+    private removeImportDependencies(uri: string): void {
+        // Remove as an imported document
+        this.importDependencies.delete(uri);
+        
+        // Remove from all dependency sets (as an importer)
+        this.removeDocumentFromDependencies(uri);
+    }
+
+    /**
+     * Removes a document from all dependency sets.
+     * Called when a document's imports change or it's deleted.
+     */
+    private removeDocumentFromDependencies(uri: string): void {
+        for (const deps of this.importDependencies.values()) {
+            deps.delete(uri);
+        }
+    }
+
+    /**
+     * Clears all import-related caches.
+     * Call this when workspace configuration changes.
+     */
+    clearImportDependencies(): void {
+        this.importDependencies.clear();
+        this.importsLoaded.clear();
+    }
+
+    /**
+     * Marks a document as needing import re-loading.
+     * Called when a document's content changes.
+     */
+    markForReprocessing(uri: string): void {
+        this.importsLoaded.delete(uri);
+    }
+}

package/src/lsp/domain-lang-scope.ts

@@ -48,22 +48,28 @@ export class DomainLangScopeComputation extends DefaultScopeComputation {
      * @returns A promise resolving to an array of AstNodeDescription
      */
     override async collectExportedSymbols(document: LangiumDocument, cancelToken = CancellationToken.None): Promise<AstNodeDescription[]> {
-        const descr: AstNodeDescription[] = [];
-        for (const modelNode of AstUtils.streamAllContents(document.parseResult.value)) {
-            await interruptAndCheck(cancelToken);
-            if (isType(modelNode)) {
-                let name = this.nameProvider.getName(modelNode);
-                if (!name) {
-                    // Defensive: skip unnamed types
-                    continue;
-                }
-                if (isNamespaceDeclaration(modelNode.$container)) {
-                    name = this.qualifiedNameProvider.getQualifiedName(modelNode.$container as NamespaceDeclaration, name);
+        try {
+            const descr: AstNodeDescription[] = [];
+            for (const modelNode of AstUtils.streamAllContents(document.parseResult.value)) {
+                await interruptAndCheck(cancelToken);
+                if (isType(modelNode)) {
+                    let name = this.nameProvider.getName(modelNode);
+                    if (!name) {
+                        // Defensive: skip unnamed types
+                        continue;
+                    }
+                    if (isNamespaceDeclaration(modelNode.$container)) {
+                        name = this.qualifiedNameProvider.getQualifiedName(modelNode.$container, name);
+                    }
+                    descr.push(this.descriptions.createDescription(modelNode, name, document));
                 }
-                descr.push(this.descriptions.createDescription(modelNode, name, document));
             }
+            return descr;
+        } catch (error) {
+            console.error('Error in collectExportedSymbols:', error);
+            // Return empty array on error to prevent crash
+            return [];
         }
-        return descr;
     }
 
     /**
@@ -73,10 +79,16 @@ export class DomainLangScopeComputation extends DefaultScopeComputation {
      * @returns A promise resolving to a LocalSymbols map
      */
     override async collectLocalSymbols(document: LangiumDocument, cancelToken = CancellationToken.None): Promise<LocalSymbols> {
-        const model = document.parseResult.value as Model;
-        const scopes = new MultiMap<AstNode, AstNodeDescription>();
-        await this.processContainer(model, scopes, document, cancelToken);
-        return scopes;
+        try {
+            const model = document.parseResult.value as Model;
+            const scopes = new MultiMap<AstNode, AstNodeDescription>();
+            await this.processContainer(model, scopes, document, cancelToken);
+            return scopes;
+        } catch (error) {
+            console.error('Error in collectLocalSymbols:', error);
+            // Return empty multimap on error to prevent crash
+            return new MultiMap<AstNode, AstNodeDescription>();
+        }
     }
 
     /**

package/src/lsp/domain-lang-workspace-manager.ts

@@ -1,21 +1,60 @@
-import path from 'node:path';
-import YAML from 'yaml';
 import { DefaultWorkspaceManager, URI, UriUtils, type FileSystemNode, type LangiumDocument, type LangiumSharedCoreServices, type WorkspaceFolder } from 'langium';
 import type { CancellationToken } from 'vscode-languageserver-protocol';
 import { ensureImportGraphFromDocument } from '../utils/import-utils.js';
+import { findManifestsInDirectories } from '../utils/manifest-utils.js';
 
 /**
  * Langium WorkspaceManager override implementing manifest-centric import loading per PRS-010.
  *
- * Behavior:
- * - Skips pre-loading *.dlang during workspace scan (only entry graph is loaded when manifest exists).
- * - Mode A (with manifest): find nearest model.yaml in folder, load entry (default index.dlang) and its import graph.
- * - Mode B (no manifest): no pre-loading; imports resolved on-demand when a document is opened.
- * - Never performs network fetches; relies on cached dependencies/lock files. Missing cache produces diagnostics upstream.
+ * **Three Operational Modes:**
+ * 
+ * **Mode A (Pure Workspace with model.yaml):**
+ * - model.yaml exists at workspace root
+ * - Loads entry file (default: index.dlang, or custom via model.entry)
+ * - Pre-builds entry and follows import graph
+ * - All imported documents built to Validated state before workspace ready
+ * - LSP features have immediate access to complete reference information
+ * 
+ * **Mode B (Pure Standalone files):**
+ * - No model.yaml anywhere in workspace
+ * - No pre-loading of .dlang files during workspace scan
+ * - Documents loaded on-demand when user opens them
+ * - Imports resolved lazily via ImportResolver
+ * - Each document built individually when opened
+ * - Works with relative imports only (no path aliases or external deps)
+ * 
+ * **Mode C (Mixed - Standalone + Module folders):**
+ * - Workspace contains both standalone .dlang files AND folders with model.yaml
+ * - Each model.yaml folder treated as a module/package:
+ *   - Module entry + import graph pre-loaded
+ *   - Path aliases and external deps work within module
+ * - Standalone files outside modules loaded on-demand
+ * - Example structure:
+ *   ```
+ *   workspace/
+ *   ├── standalone.dlang        ← Mode B (on-demand)
+ *   ├── core/
+ *   │   ├── model.yaml          ← Module root
+ *   │   ├── index.dlang         ← Pre-loaded
+ *   │   └── domains/
+ *   │       └── sales.dlang     ← Pre-loaded via imports
+ *   └── util.dlang              ← Mode B (on-demand)
+ *   ```
+ * 
+ * **Performance Characteristics:**
+ * - Mode A/C modules: Slower initial load, instant LSP features afterward
+ * - Mode B/C standalone: Instant workspace init, per-file build on open
+ * - All modes cache import resolution for subsequent access
+ * 
+ * **Never performs network fetches** - relies on cached dependencies/lock files.
+ * Missing cache produces diagnostics upstream via ImportValidator.
  */
 export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
+    private readonly sharedServices: LangiumSharedCoreServices;
+
     constructor(services: LangiumSharedCoreServices) {
         super(services);
+        this.sharedServices = services;
     }
 
     override shouldIncludeEntry(entry: FileSystemNode): boolean {
@@ -32,73 +71,57 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
     }
 
     protected override async loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void> {
-        const manifestInfo = await this.findManifestInFolders(folders);
-        if (!manifestInfo) {
-            return; // Mode B: no manifest
-        }
-
-        const entryUri = URI.file(manifestInfo.entryPath);
-        const entryDoc = await this.langiumDocuments.getOrCreateDocument(entryUri);
-        collector(entryDoc);
-
-        const uris = await ensureImportGraphFromDocument(entryDoc, this.langiumDocuments);
-        for (const uriString of uris) {
-            const uri = URI.parse(uriString);
-            const doc = await this.langiumDocuments.getOrCreateDocument(uri);
-            collector(doc);
-        }
-    }
-
-    private async findManifestInFolders(folders: WorkspaceFolder[]): Promise<{ manifestPath: string; entryPath: string } | undefined> {
-        for (const folder of folders) {
-            const manifestPath = await this.findNearestManifest(folder.uri);
-            if (manifestPath) {
-                const entry = await this.readEntryFromManifest(manifestPath) ?? 'index.dlang';
-                const entryPath = path.resolve(path.dirname(manifestPath), entry);
-                return { manifestPath, entryPath };
-            }
+        // Find ALL model.yaml files in workspace (supports mixed mode)
+        const manifestInfos = await this.findAllManifestsInFolders(folders);
+        
+        if (manifestInfos.length === 0) {
+            return; // Pure Mode B: no manifests, all files loaded on-demand
         }
-        return undefined;
-    }
 
-    private async findNearestManifest(startUri: string): Promise<string | undefined> {
-        let current = path.resolve(URI.parse(startUri).fsPath);
-        const { root } = path.parse(current);
+        // Mode A or Mode C: Load each module's entry + import graph
+        for (const manifestInfo of manifestInfos) {
+            try {
+                const entryUri = URI.file(manifestInfo.entryPath);
+                const entryDoc = await this.langiumDocuments.getOrCreateDocument(entryUri);
+                collector(entryDoc);
 
-        while (true) {
-            const candidate = path.join(current, 'model.yaml');
-            if (await this.pathExists(candidate)) {
-                return candidate;
-            }
+                // Build entry document first to ensure it's ready for import resolution
+                await this.sharedServices.workspace.DocumentBuilder.build([entryDoc], {
+                    validation: true
+                });
 
-            if (current === root) {
-                return undefined;
-            }
+                const uris = await ensureImportGraphFromDocument(entryDoc, this.langiumDocuments);
+                const importedDocs: LangiumDocument[] = [];
+                for (const uriString of uris) {
+                    const uri = URI.parse(uriString);
+                    const doc = await this.langiumDocuments.getOrCreateDocument(uri);
+                    collector(doc);
+                    importedDocs.push(doc);
+                }
 
-            const parent = path.dirname(current);
-            if (parent === current) {
-                return undefined;
+                // Build all imported documents in batch for performance
+                if (importedDocs.length > 0) {
+                    await this.sharedServices.workspace.DocumentBuilder.build(importedDocs, {
+                        validation: true
+                    });
+                }
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`Failed to load import graph from ${manifestInfo.manifestPath}: ${message}`);
+                // Continue with other modules - partial failure is acceptable
             }
-            current = parent;
-        }
-    }
-
-    private async readEntryFromManifest(manifestPath: string): Promise<string | undefined> {
-        try {
-            const content = await this.fileSystemProvider.readFile(URI.file(manifestPath));
-            const manifest = (YAML.parse(content) ?? {}) as { model?: { entry?: string } };
-            return manifest.model?.entry;
-        } catch {
-            return undefined;
         }
     }
 
-    private async pathExists(target: string): Promise<boolean> {
-        try {
-            await this.fileSystemProvider.stat(URI.file(target));
-            return true;
-        } catch {
-            return false;
-        }
+    /**
+     * Finds ALL model.yaml files in the workspace.
+     * Delegates to shared manifest utilities.
+     * 
+     * @param folders - Workspace folders to search
+     * @returns Array of manifest info (one per model.yaml found)
+     */
+    private async findAllManifestsInFolders(folders: WorkspaceFolder[]): Promise<Array<{ manifestPath: string; entryPath: string }>> {
+        const directories = folders.map(f => URI.parse(f.uri).fsPath);
+        return findManifestsInDirectories(directories);
     }
 }