@domainlang/language 0.5.2 → 0.7.0

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

@@ -0,0 +1,134 @@
+/**
+ * DomainLang Scope Provider
+ *
+ * Implements import-based scoping for the DomainLang DSL.
+ *
+ * **Key Concept:**
+ * Unlike languages with global namespaces, DomainLang enforces strict import-based scoping:
+ * - Elements are only visible if they are defined in the current document OR explicitly imported
+ * - The global scope is restricted to imported documents only
+ * - Transitive imports do NOT provide scope (only direct imports)
+ *
+ * **Why this matters:**
+ * Without this, Langium's DefaultScopeProvider would make ALL indexed documents visible
+ * in the global scope, which would:
+ * 1. Allow referencing elements that haven't been imported
+ * 2. Make the import system meaningless
+ * 3. Create confusion about dependencies between files
+ *
+ * @see https://langium.org/docs/recipes/scoping/ for Langium scoping patterns
+ */
+
+import type {
+    AstNodeDescription,
+    LangiumDocument,
+    ReferenceInfo,
+    Scope,
+    Stream
+} from 'langium';
+import {
+    AstUtils,
+    DefaultScopeProvider,
+    EMPTY_SCOPE,
+    MapScope
+} from 'langium';
+import type { DomainLangServices } from '../domain-lang-module.js';
+import type { DomainLangIndexManager } from './domain-lang-index-manager.js';
+
+/**
+ * Custom scope provider that restricts cross-file references to imported documents only.
+ *
+ * Extends Langium's DefaultScopeProvider to override the global scope computation.
+ */
+export class DomainLangScopeProvider extends DefaultScopeProvider {
+    /**
+     * Reference to IndexManager for getting resolved imports.
+     */
+    private readonly domainLangIndexManager: DomainLangIndexManager;
+
+    constructor(services: DomainLangServices) {
+        super(services);
+        this.domainLangIndexManager = services.shared.workspace.IndexManager as DomainLangIndexManager;
+    }
+
+    /**
+     * Override getGlobalScope to restrict it to imported documents only.
+     *
+     * The default Langium behavior includes ALL documents in the workspace.
+     * We restrict this to:
+     * 1. The current document's own exported symbols
+     * 2. Exported symbols from directly imported documents
+     *
+     * @param referenceType - The AST type being referenced
+     * @param context - Information about the reference
+     * @returns A scope containing only visible elements
+     */
+    protected override getGlobalScope(referenceType: string, context: ReferenceInfo): Scope {
+        const document = AstUtils.getDocument(context.container);
+        if (!document) {
+            return EMPTY_SCOPE;
+        }
+
+        // Get the set of URIs that are in scope for this document
+        const importedUris = this.getImportedDocumentUris(document);
+
+        // Filter the global index to only include descriptions from imported documents
+        const filteredDescriptions = this.filterDescriptionsByImports(
+            referenceType,
+            document,
+            importedUris
+        );
+
+        // Create a scope from the filtered descriptions
+        return new MapScope(filteredDescriptions);
+    }
+
+    /**
+     * Gets the set of document URIs that are directly imported by the given document.
+     *
+     * Uses the resolved imports tracked by DomainLangIndexManager during indexing.
+     * This ensures accurate resolution including path aliases.
+     *
+     * @param document - The document to get imports for
+     * @returns Set of imported document URIs (as strings)
+     */
+    private getImportedDocumentUris(document: LangiumDocument): Set<string> {
+        const docUri = document.uri.toString();
+
+        // Get resolved imports from the index manager (tracked during indexing)
+        const resolvedImports = this.domainLangIndexManager.getResolvedImports(docUri);
+
+        // Always include the current document itself
+        const importedUris = new Set<string>([docUri]);
+
+        // Add all resolved import URIs
+        for (const resolvedUri of resolvedImports) {
+            importedUris.add(resolvedUri);
+        }
+
+        return importedUris;
+    }
+
+    /**
+     * Filters the global index to only include descriptions from imported documents.
+     *
+     * @param referenceType - The AST type being referenced
+     * @param currentDocument - The document making the reference
+     * @param importedUris - Set of URIs that are in scope
+     * @returns Stream of filtered descriptions
+     */
+    private filterDescriptionsByImports(
+        referenceType: string,
+        currentDocument: LangiumDocument,
+        importedUris: Set<string>
+    ): Stream<AstNodeDescription> {
+        // Get all descriptions of the reference type from the index
+        const allDescriptions = this.indexManager.allElements(referenceType);
+
+        // Filter to only those from imported documents
+        return allDescriptions.filter(desc => {
+            const descDocUri = desc.documentUri.toString();
+            return importedUris.has(descDocUri);
+        });
+    }
+}

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,62 @@
+import fs from 'node:fs/promises';
 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 +73,180 @@ 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
-        }
+        // Find ALL model.yaml files in workspace (supports mixed mode)
+        const manifestInfos = await this.findAllManifestsInFolders(folders);
+        
+        // Track directories covered by manifests to avoid loading their files as standalone
+        const moduleDirectories = new Set(
+            manifestInfos.map(m => path.dirname(m.manifestPath))
+        );
 
-        const entryUri = URI.file(manifestInfo.entryPath);
-        const entryDoc = await this.langiumDocuments.getOrCreateDocument(entryUri);
-        collector(entryDoc);
+        // 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);
 
-        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);
+                // Build entry document first to ensure it's ready for import resolution
+                await this.sharedServices.workspace.DocumentBuilder.build([entryDoc], {
+                    validation: true
+                });
+
+                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);
+                }
+
+                // 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
+            }
         }
+
+        // Load standalone .dlang files in workspace root folders
+        // These are files NOT covered by any module's import graph
+        await this.loadStandaloneFiles(folders, moduleDirectories, collector);
     }
 
-    private async findManifestInFolders(folders: WorkspaceFolder[]): Promise<{ manifestPath: string; entryPath: string } | undefined> {
+    /**
+     * Loads standalone .dlang files from workspace folders recursively.
+     * 
+     * Skips:
+     * - Module directories (directories with model.yaml) - loaded via import graph
+     * - `.dlang/cache` directory - package cache managed by CLI
+     * 
+     * @param folders - Workspace folders to scan
+     * @param moduleDirectories - Set of directories containing model.yaml (to skip)
+     * @param collector - Document collector callback
+     */
+    private async loadStandaloneFiles(
+        folders: WorkspaceFolder[],
+        moduleDirectories: Set<string>,
+        collector: (document: LangiumDocument) => void
+    ): Promise<void> {
+        const standaloneDocs: LangiumDocument[] = [];
+
         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 };
-            }
+            const folderPath = URI.parse(folder.uri).fsPath;
+            const docs = await this.loadDlangFilesRecursively(folderPath, moduleDirectories, collector);
+            standaloneDocs.push(...docs);
+        }
+
+        // Build all standalone documents in batch for performance
+        if (standaloneDocs.length > 0) {
+            await this.sharedServices.workspace.DocumentBuilder.build(standaloneDocs, {
+                validation: true
+            });
         }
-        return undefined;
     }
 
-    private async findNearestManifest(startUri: string): Promise<string | undefined> {
-        let current = path.resolve(URI.parse(startUri).fsPath);
-        const { root } = path.parse(current);
+    /**
+     * Recursively loads .dlang files from a directory.
+     * Skips module directories and the .dlang/cache package cache.
+     */
+    private async loadDlangFilesRecursively(
+        dirPath: string,
+        moduleDirectories: Set<string>,
+        collector: (document: LangiumDocument) => void
+    ): Promise<LangiumDocument[]> {
+        // Skip module directories - they're loaded via import graph
+        if (moduleDirectories.has(dirPath)) {
+            return [];
+        }
 
-        while (true) {
-            const candidate = path.join(current, 'model.yaml');
-            if (await this.pathExists(candidate)) {
-                return candidate;
-            }
+        // Skip .dlang/cache - package cache managed by CLI
+        const baseName = path.basename(dirPath);
+        const parentName = path.basename(path.dirname(dirPath));
+        if (baseName === 'cache' && parentName === '.dlang') {
+            return [];
+        }
+        // Also skip the .dlang directory itself if it contains cache
+        if (baseName === '.dlang') {
+            return [];
+        }
 
-            if (current === root) {
-                return undefined;
-            }
+        const docs: LangiumDocument[] = [];
+
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            
+            for (const entry of entries) {
+                const entryPath = path.join(dirPath, entry.name);
 
-            const parent = path.dirname(current);
-            if (parent === current) {
-                return undefined;
+                if (entry.isDirectory()) {
+                    // Recurse into subdirectories
+                    const subDocs = await this.loadDlangFilesRecursively(entryPath, moduleDirectories, collector);
+                    docs.push(...subDocs);
+                } else if (this.isDlangFile(entry)) {
+                    const doc = await this.tryLoadDocument(dirPath, entry.name, collector);
+                    if (doc) {
+                        docs.push(doc);
+                    }
+                }
             }
-            current = parent;
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Failed to read directory ${dirPath}: ${message}`);
         }
+
+        return docs;
     }
 
-    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 {
+    /**
+     * Checks if a directory entry is a .dlang file.
+     */
+    private isDlangFile(entry: { isFile(): boolean; name: string }): boolean {
+        return entry.isFile() && entry.name.toLowerCase().endsWith('.dlang');
+    }
+
+    /**
+     * Attempts to load a document, returning undefined on failure.
+     */
+    private async tryLoadDocument(
+        folderPath: string,
+        fileName: string,
+        collector: (document: LangiumDocument) => void
+    ): Promise<LangiumDocument | undefined> {
+        const filePath = path.join(folderPath, fileName);
+        const uri = URI.file(filePath);
+        
+        // Skip if already loaded (e.g., through imports)
+        if (this.langiumDocuments.hasDocument(uri)) {
             return undefined;
         }
-    }
 
-    private async pathExists(target: string): Promise<boolean> {
         try {
-            await this.fileSystemProvider.stat(URI.file(target));
-            return true;
-        } catch {
-            return false;
+            const doc = await this.langiumDocuments.getOrCreateDocument(uri);
+            collector(doc);
+            return doc;
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Failed to load standalone file ${filePath}: ${message}`);
+            return undefined;
         }
     }
+
+    /**
+     * 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);
+    }
 }