@domainlang/language 0.7.0 → 0.8.0

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

@@ -1,13 +1,13 @@
 /**
  * DomainLang Scope Provider
  *
- * Implements import-based scoping for the DomainLang DSL.
+ * Implements import-based scoping with alias support and package-boundary transitive imports.
  *
- * **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)
+ * **Key Concepts (per ADR-003):**
+ * - Elements are only visible if defined in current document OR explicitly imported
+ * - Import aliases control visibility: `import "pkg" as ddd` makes types visible as `ddd.*` only
+ * - Package-boundary transitive imports: External packages (.dlang/packages/) can re-export
+ * - Local file imports remain non-transitive (explicit dependencies only)
  *
  * **Why this matters:**
  * Without this, Langium's DefaultScopeProvider would make ALL indexed documents visible
@@ -17,6 +17,7 @@
  * 3. Create confusion about dependencies between files
  *
  * @see https://langium.org/docs/recipes/scoping/ for Langium scoping patterns
+ * @see ADR-003 for alias and package-boundary design decisions
  */
 
 import type {
@@ -30,10 +31,13 @@ import {
     AstUtils,
     DefaultScopeProvider,
     EMPTY_SCOPE,
-    MapScope
+    MapScope,
+    stream
 } from 'langium';
 import type { DomainLangServices } from '../domain-lang-module.js';
 import type { DomainLangIndexManager } from './domain-lang-index-manager.js';
+import type { PackageBoundaryDetector } from '../services/package-boundary-detector.js';
+import type { ImportInfo } from '../services/types.js';
 
 /**
  * Custom scope provider that restricts cross-file references to imported documents only.
@@ -42,93 +46,205 @@ import type { DomainLangIndexManager } from './domain-lang-index-manager.js';
  */
 export class DomainLangScopeProvider extends DefaultScopeProvider {
     /**
-     * Reference to IndexManager for getting resolved imports.
+     * Reference to IndexManager for getting resolved imports with aliases.
      */
     private readonly domainLangIndexManager: DomainLangIndexManager;
 
+    /**
+     * Detects package boundaries for transitive import resolution.
+     */
+    private readonly packageBoundaryDetector: PackageBoundaryDetector;
+
     constructor(services: DomainLangServices) {
         super(services);
         this.domainLangIndexManager = services.shared.workspace.IndexManager as DomainLangIndexManager;
+        this.packageBoundaryDetector = services.imports.PackageBoundaryDetector;
     }
 
     /**
-     * Override getGlobalScope to restrict it to imported documents only.
+     * Override getGlobalScope to implement alias-scoped and package-boundary transitive imports.
      *
      * The default Langium behavior includes ALL documents in the workspace.
-     * We restrict this to:
+     * We restrict and transform scope to:
      * 1. The current document's own exported symbols
-     * 2. Exported symbols from directly imported documents
+     * 2. Symbols from directly imported documents (with alias prefixing)
+     * 3. Symbols from package-boundary transitive imports (external packages only)
      *
      * @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) {
+        try {
+            const document = AstUtils.getDocument(context.container);
+            if (!document) {
+                return EMPTY_SCOPE;
+            }
+
+            const descriptions = this.computeVisibleDescriptions(referenceType, document);
+            return new MapScope(descriptions);
+        } catch (error) {
+            console.error('Error in getGlobalScope:', error);
             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.
+     * Computes all visible descriptions for a document, including:
+     * - Current document's own symbols
+     * - Direct imports (with alias prefixing)
+     * - Package-boundary transitive imports
      *
-     * @param document - The document to get imports for
-     * @returns Set of imported document URIs (as strings)
+     * @param referenceType - The AST type being referenced
+     * @param document - The document making the reference
+     * @returns Stream of visible descriptions
      */
-    private getImportedDocumentUris(document: LangiumDocument): Set<string> {
+    private computeVisibleDescriptions(
+        referenceType: string,
+        document: LangiumDocument
+    ): Stream<AstNodeDescription> {
         const docUri = document.uri.toString();
+        const allVisibleDescriptions: AstNodeDescription[] = [];
+
+        // 1. Always include current document's own symbols
+        const ownDescriptions = this.indexManager.allElements(referenceType)
+            .filter(desc => desc.documentUri.toString() === docUri);
+        allVisibleDescriptions.push(...ownDescriptions.toArray());
+
+        // 2. Get import info (with aliases)
+        const importInfo = this.domainLangIndexManager.getImportInfo(docUri);
 
-        // Get resolved imports from the index manager (tracked during indexing)
-        const resolvedImports = this.domainLangIndexManager.getResolvedImports(docUri);
+        // Track which documents we've already included to avoid duplicates
+        const processedUris = new Set<string>([docUri]);
 
-        // Always include the current document itself
-        const importedUris = new Set<string>([docUri]);
+        // 3. Process each direct import
+        for (const imp of importInfo) {
+            if (!imp.resolvedUri || processedUris.has(imp.resolvedUri)) {
+                continue;
+            }
 
-        // Add all resolved import URIs
-        for (const resolvedUri of resolvedImports) {
-            importedUris.add(resolvedUri);
+            // Add descriptions from the directly imported document
+            this.addDescriptionsFromImport(
+                imp,
+                referenceType,
+                processedUris,
+                allVisibleDescriptions
+            );
+
+            // 4. Check for package-boundary transitive imports
+            this.addPackageBoundaryTransitiveImports(
+                imp,
+                referenceType,
+                document,
+                processedUris,
+                allVisibleDescriptions
+            );
         }
 
-        return importedUris;
+        return stream(allVisibleDescriptions);
     }
 
     /**
-     * Filters the global index to only include descriptions from imported documents.
+     * Adds descriptions from a single import, applying alias prefixing if needed.
      *
+     * @param imp - Import information (specifier, alias, resolved URI)
+     * @param referenceType - The AST type being referenced
+     * @param processedUris - Set of already-processed URIs to avoid duplicates
+     * @param output - Array to append visible descriptions to
+     */
+    private addDescriptionsFromImport(
+        imp: ImportInfo,
+        referenceType: string,
+        processedUris: Set<string>,
+        output: AstNodeDescription[]
+    ): void {
+        const descriptions = this.indexManager.allElements(referenceType)
+            .filter(desc => desc.documentUri.toString() === imp.resolvedUri);
+
+        if (imp.alias) {
+            // With alias: prefix all names with alias
+            // Example: CoreDomain → ddd.CoreDomain
+            for (const desc of descriptions) {
+                output.push(this.createAliasedDescription(desc, imp.alias));
+            }
+        } else {
+            // Without alias: use original names
+            output.push(...descriptions.toArray());
+        }
+
+        processedUris.add(imp.resolvedUri);
+    }
+
+    /**
+     * Adds package-boundary transitive imports for external packages.
+     *
+     * When document A imports package document B (e.g., index.dlang),
+     * and B imports internal package files C, D, etc. (same package root),
+     * then A can see types from C, D, etc. (package re-exports).
+     *
+     * Local file imports remain non-transitive.
+     *
+     * @param imp - Import information for the direct import
      * @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
+     * @param processedUris - Set of already-processed URIs to avoid duplicates
+     * @param output - Array to append visible descriptions to
      */
-    private filterDescriptionsByImports(
+    private addPackageBoundaryTransitiveImports(
+        imp: ImportInfo,
         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);
-        });
+        processedUris: Set<string>,
+        output: AstNodeDescription[]
+    ): void {
+        // Get the imports of the imported document (B's imports)
+        const transitiveImports = this.domainLangIndexManager.getImportInfo(imp.resolvedUri);
+
+        for (const transitiveImp of transitiveImports) {
+            if (!transitiveImp.resolvedUri || processedUris.has(transitiveImp.resolvedUri)) {
+                continue;
+            }
+
+            // Check if both documents are in the same external package
+            // (package boundary = same commit directory within .dlang/packages/)
+            const samePackage = this.packageBoundaryDetector.areInSamePackageSync(
+                imp.resolvedUri,
+                transitiveImp.resolvedUri
+            );
+
+            if (samePackage) {
+                // Within package boundary: include transitive imports
+                // Apply the top-level import's alias (if any)
+                this.addDescriptionsFromImport(
+                    {
+                        specifier: transitiveImp.specifier,
+                        alias: imp.alias, // Use the top-level import's alias
+                        resolvedUri: transitiveImp.resolvedUri
+                    },
+                    referenceType,
+                    processedUris,
+                    output
+                );
+            }
+        }
+    }
+
+    /**
+     * Creates an alias-prefixed version of a description.
+     *
+     * Example: CoreDomain with alias "ddd" → ddd.CoreDomain
+     *
+     * @param original - Original description
+     * @param alias - Import alias to prefix with
+     * @returns New description with prefixed name
+     */
+    private createAliasedDescription(
+        original: AstNodeDescription,
+        alias: string
+    ): AstNodeDescription {
+        return {
+            ...original,
+            name: `${alias}.${original.name}`
+        };
     }
 }

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

@@ -4,6 +4,8 @@ import { DefaultWorkspaceManager, URI, UriUtils, type FileSystemNode, type Langi
 import type { CancellationToken } from 'vscode-languageserver-protocol';
 import { ensureImportGraphFromDocument } from '../utils/import-utils.js';
 import { findManifestsInDirectories } from '../utils/manifest-utils.js';
+import type { ImportResolver } from '../services/import-resolver.js';
+import type { DomainLangServices } from '../domain-lang-module.js';
 
 /**
  * Langium WorkspaceManager override implementing manifest-centric import loading per PRS-010.
@@ -54,11 +56,26 @@ import { findManifestsInDirectories } from '../utils/manifest-utils.js';
 export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
     private readonly sharedServices: LangiumSharedCoreServices;
 
+    /**
+     * DI-injected import resolver. Set via late-binding because
+     * WorkspaceManager (shared module) is created before ImportResolver (language module).
+     * Falls back to standalone ensureImportGraphFromDocument when not set.
+     */
+    private importResolver: ImportResolver | undefined;
+
     constructor(services: LangiumSharedCoreServices) {
         super(services);
         this.sharedServices = services;
     }
 
+    /**
+     * Late-binds the language-specific services after DI initialization.
+     * Called from `createDomainLangServices()` after the language module is created.
+     */
+    setLanguageServices(services: DomainLangServices): void {
+        this.importResolver = services.imports.ImportResolver;
+    }
+
     override shouldIncludeEntry(entry: FileSystemNode): boolean {
         // Prevent auto-including .dlang files; we'll load via entry/import graph
         const name = UriUtils.basename(entry.uri);
@@ -93,7 +110,7 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
                     validation: true
                 });
 
-                const uris = await ensureImportGraphFromDocument(entryDoc, this.langiumDocuments);
+                const uris = await this.loadImportGraph(entryDoc);
                 const importedDocs: LangiumDocument[] = [];
                 for (const uriString of uris) {
                     const uri = URI.parse(uriString);
@@ -125,7 +142,7 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
      * 
      * Skips:
      * - Module directories (directories with model.yaml) - loaded via import graph
-     * - `.dlang/cache` directory - package cache managed by CLI
+     * - `.dlang/packages` directory - package cache managed by CLI
      * 
      * @param folders - Workspace folders to scan
      * @param moduleDirectories - Set of directories containing model.yaml (to skip)
@@ -154,7 +171,7 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
 
     /**
      * Recursively loads .dlang files from a directory.
-     * Skips module directories and the .dlang/cache package cache.
+     * Skips module directories and the .dlang/packages cache.
      */
     private async loadDlangFilesRecursively(
         dirPath: string,
@@ -166,13 +183,13 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
             return [];
         }
 
-        // Skip .dlang/cache - package cache managed by CLI
+        // Skip .dlang/packages - package cache managed by CLI
         const baseName = path.basename(dirPath);
         const parentName = path.basename(path.dirname(dirPath));
-        if (baseName === 'cache' && parentName === '.dlang') {
+        if (baseName === 'packages' && parentName === '.dlang') {
             return [];
         }
-        // Also skip the .dlang directory itself if it contains cache
+        // Also skip the .dlang directory itself (contains packages cache)
         if (baseName === '.dlang') {
             return [];
         }
@@ -249,4 +266,45 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
         const directories = folders.map(f => URI.parse(f.uri).fsPath);
         return findManifestsInDirectories(directories);
     }
+
+    /**
+     * Recursively builds the import graph from a document.
+     * Uses the DI-injected ImportResolver when available,
+     * falling back to the standalone utility.
+     *
+     * @param document - The starting document
+     * @returns Set of URIs (as strings) for all documents in the import graph
+     */
+    private async loadImportGraph(document: LangiumDocument): Promise<Set<string>> {
+        if (!this.importResolver) {
+            // Fallback to standalone utility when DI isn't wired
+            return ensureImportGraphFromDocument(document, this.langiumDocuments);
+        }
+
+        const resolver = this.importResolver;
+        const langiumDocuments = this.langiumDocuments;
+        const visited = new Set<string>();
+
+        async function visit(doc: LangiumDocument): Promise<void> {
+            const uriString = doc.uri.toString();
+            if (visited.has(uriString)) return;
+            visited.add(uriString);
+
+            const model = doc.parseResult.value as { imports?: Array<{ uri?: string }> };
+            for (const imp of model.imports ?? []) {
+                if (!imp.uri) continue;
+
+                try {
+                    const resolvedUri = await resolver.resolveForDocument(doc, imp.uri);
+                    const childDoc = await langiumDocuments.getOrCreateDocument(resolvedUri);
+                    await visit(childDoc);
+                } catch {
+                    // Import resolution failed — validation will report the error
+                }
+            }
+        }
+
+        await visit(document);
+        return visited;
+    }
 }