@domainlang/language 0.7.0 → 0.9.0

package/src/lsp/domain-lang-document-symbol-provider.ts

@@ -0,0 +1,254 @@
+/**
+ * Custom DocumentSymbolProvider for DomainLang.
+ *
+ * Extends Langium's DefaultDocumentSymbolProvider to add meaningful
+ * `detail` text to outline items, improving the Outline view, breadcrumbs,
+ * and Go to Symbol experience.
+ *
+ * The default provider handles the full AST walk, child nesting, and
+ * range computation. We only override `getSymbol` to enrich the detail
+ * property with DDD-relevant information (descriptions, visions, counts).
+ *
+ * @module lsp/domain-lang-document-symbol-provider
+ */
+
+import type { AstNode, LangiumDocument } from 'langium';
+import { DocumentSymbol, SymbolKind } from 'vscode-languageserver';
+import { CstUtils } from 'langium';
+import { DefaultDocumentSymbolProvider } from 'langium/lsp';
+import {
+    isDomain,
+    isBoundedContext,
+    isContextMap,
+    isDomainMap,
+    isNamespaceDeclaration,
+    isRelationship,
+    isThisRef,
+} from '../generated/ast.js';
+import type { BoundedContext, Relationship, MetadataEntry } from '../generated/ast.js';
+
+/**
+ * Enriches document symbols with DDD-specific detail text and grouping.
+ *
+ * Detail text shown in the Outline view next to each symbol:
+ * - Domain: vision or description
+ * - BoundedContext: description or domain name
+ * - ContextMap: number of contained contexts
+ * - DomainMap: number of contained domains
+ * - Namespace: qualified namespace name
+ * - Relationship: formatted endpoint summary (e.g., "OrderContext -> PaymentContext")
+ * 
+ * Grouping: Creates synthetic folder nodes for collections in the grammar:
+ * - BoundedContext: decisions, terminology, relationships, metadata
+ * 
+ * Note: Relationship and MetadataEntry symbols are created manually (not via NameProvider)
+ * to avoid polluting the global scope/reference system. These are display-only synthetic symbols.
+ */
+export class DomainLangDocumentSymbolProvider extends DefaultDocumentSymbolProvider {
+
+    protected override getSymbol(document: LangiumDocument, astNode: AstNode): DocumentSymbol[] {
+        try {
+            const symbols = super.getSymbol(document, astNode);
+            const detail = this.getDetailText(astNode);
+            if (detail !== undefined) {
+                for (const symbol of symbols) {
+                    symbol.detail = detail;
+                }
+            }
+            return symbols;
+        } catch (error) {
+            console.error('Error in DomainLangDocumentSymbolProvider.getSymbol:', error);
+            return super.getSymbol(document, astNode);
+        }
+    }
+
+    /**
+     * Override to add synthetic grouping folders for collections.
+     * Groups decisions, terminology, relationships, and metadata under folder nodes.
+     */
+    protected override getChildSymbols(document: LangiumDocument, astNode: AstNode): DocumentSymbol[] | undefined {
+        // Only group for BoundedContext nodes
+        if (!isBoundedContext(astNode)) {
+            return super.getChildSymbols(document, astNode);
+        }
+
+        const grouped: DocumentSymbol[] = [];
+
+        // Process each collection type
+        this.addDecisionsFolder(document, astNode, grouped);
+        this.addTerminologyFolder(document, astNode, grouped);
+        this.addRelationshipsFolder(astNode, grouped);
+        this.addMetadataFolder(astNode, grouped);
+
+        return grouped.length > 0 ? grouped : undefined;
+    }
+
+    /** Adds decisions folder if collection is non-empty. */
+    private addDecisionsFolder(document: LangiumDocument, bc: BoundedContext, grouped: DocumentSymbol[]): void {
+        if (bc.decisions && bc.decisions.length > 0) {
+            const symbols = bc.decisions.flatMap(d => this.getSymbol(document, d));
+            if (symbols.length > 0) {
+                grouped.push(this.createFolderSymbol('decisions', symbols));
+            }
+        }
+    }
+
+    /** Adds terminology folder if collection is non-empty. */
+    private addTerminologyFolder(document: LangiumDocument, bc: BoundedContext, grouped: DocumentSymbol[]): void {
+        if (bc.terminology && bc.terminology.length > 0) {
+            const symbols = bc.terminology.flatMap(t => this.getSymbol(document, t));
+            if (symbols.length > 0) {
+                grouped.push(this.createFolderSymbol('terminology', symbols));
+            }
+        }
+    }
+
+    /** Adds relationships folder with manually created symbols. */
+    private addRelationshipsFolder(bc: BoundedContext, grouped: DocumentSymbol[]): void {
+        if (bc.relationships && bc.relationships.length > 0) {
+            const symbols = bc.relationships.map(r => this.createRelationshipSymbol(r)).filter((s): s is DocumentSymbol => s !== undefined);
+            if (symbols.length > 0) {
+                grouped.push(this.createFolderSymbol('relationships', symbols));
+            }
+        }
+    }
+
+    /** Adds metadata folder with manually created symbols. */
+    private addMetadataFolder(bc: BoundedContext, grouped: DocumentSymbol[]): void {
+        if (bc.metadata && bc.metadata.length > 0) {
+            const symbols = bc.metadata.map(m => this.createMetadataSymbol(m)).filter((s): s is DocumentSymbol => s !== undefined);
+            if (symbols.length > 0) {
+                grouped.push(this.createFolderSymbol('metadata', symbols));
+            }
+        }
+    }
+
+    /**
+     * Creates a synthetic folder DocumentSymbol for grouping children.
+     */
+    private createFolderSymbol(name: string, children: DocumentSymbol[]): DocumentSymbol {
+        // Use the first child's range for the folder
+        const firstChild = children[0];
+        
+        return DocumentSymbol.create(
+            name,
+            `${children.length} items`,
+            SymbolKind.Object,
+            firstChild.range,
+            firstChild.selectionRange,
+            children
+        );
+    }
+
+    /**
+     * Creates a DocumentSymbol for a Relationship node.
+     */
+    private createRelationshipSymbol(rel: Relationship): DocumentSymbol | undefined {
+        const cstNode = rel.$cstNode;
+        if (!cstNode) return undefined;
+
+        const left = isThisRef(rel.left) ? 'this' : rel.left?.link?.ref?.name ?? '?';
+        const right = isThisRef(rel.right) ? 'this' : rel.right?.link?.ref?.name ?? '?';
+        const name = `${left} → ${right}`;
+
+        const range = CstUtils.toDocumentSegment(cstNode).range;
+        return DocumentSymbol.create(
+            name,
+            undefined,
+            SymbolKind.Interface,
+            range,
+            range
+        );
+    }
+
+    /**
+     * Creates a DocumentSymbol for a MetadataEntry node.
+     */
+    private createMetadataSymbol(meta: MetadataEntry): DocumentSymbol | undefined {
+        const cstNode = meta.$cstNode;
+        if (!cstNode) return undefined;
+
+        const name = meta.key?.ref?.name ?? 'unknown';
+        const range = CstUtils.toDocumentSegment(cstNode).range;
+
+        return DocumentSymbol.create(
+            name,
+            meta.value,
+            SymbolKind.Field,
+            range,
+            range
+        );
+    }
+
+    /**
+     * Returns DDD-specific detail text for a given AST node.
+     * Shown alongside the symbol name in the Outline view.
+     */
+    private getDetailText(node: AstNode): string | undefined {
+        if (isDomain(node))              return "Domain — " + (node.vision ?? node.description);
+        if (isBoundedContext(node))      return this.getBcDetail(node);
+        if (isContextMap(node))          return this.pluralize('context', node.boundedContexts?.length ?? 0);
+        if (isDomainMap(node))           return this.pluralize('domain', node.domains?.length ?? 0);
+        if (isNamespaceDeclaration(node)) return node.name;
+        if (isRelationship(node))        return this.formatRelationshipDetail(node);
+        return undefined;
+    }
+
+    /** Builds BC detail: "BC for DomainName — description". */
+    private getBcDetail(node: BoundedContext): string | undefined {
+        const parts: string[] = [];
+        if (node.domain?.ref?.name) {
+            parts.push(`BC for ${node.domain.ref.name}`);
+        }
+        if (node.description) {
+            parts.push(node.description);
+        }
+        return parts.length > 0 ? parts.join(' — ') : undefined;
+    }
+
+    /** Returns "N item(s)" or undefined when count is 0. */
+    private pluralize(label: string, count: number): string | undefined {
+        if (count === 0) return undefined;
+        const suffix = count === 1 ? '' : 's';
+        return `${count} ${label}${suffix}`;
+    }
+
+    /**
+     * Formats a relationship as a compact detail string:
+     * e.g., "OrderContext -> PaymentContext"
+     */
+    private formatRelationshipDetail(
+        node: ReturnType<typeof Object> & { left?: unknown; right?: unknown; arrow?: string }
+    ): string | undefined {
+        try {
+            // We know this is a Relationship node thanks to isRelationship guard above
+            const rel = node as { left?: { link?: { $refText?: string } }; right?: { link?: { $refText?: string } }; arrow?: string };
+            const leftName = this.getRefName(rel.left);
+            const rightName = this.getRefName(rel.right);
+            const arrow = rel.arrow ?? '->';
+            if (leftName && rightName) {
+                return `${leftName} ${arrow} ${rightName}`;
+            }
+            return undefined;
+        } catch {
+            return undefined;
+        }
+    }
+
+    /**
+     * Gets a display name from a BoundedContextRef.
+     */
+    private getRefName(ref: unknown): string | undefined {
+        if (!ref || typeof ref !== 'object') return undefined;
+
+        // Check for ThisRef
+        const refObj = ref as Record<string, unknown>;
+        if (refObj.$type === 'ThisRef' || isThisRef(ref as AstNode)) {
+            return 'this';
+        }
+
+        // Check for named reference
+        const link = refObj.link as { $refText?: string } | undefined;
+        return link?.$refText;
+    }
+}

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

@@ -3,6 +3,9 @@ import { DefaultIndexManager, DocumentState } from 'langium';
 import { CancellationToken } from 'vscode-jsonrpc';
 import { resolveImportPath } from '../utils/import-utils.js';
 import type { Model } from '../generated/ast.js';
+import type { ImportResolver } from '../services/import-resolver.js';
+import type { DomainLangServices } from '../domain-lang-module.js';
+import type { ImportInfo } from '../services/types.js';
 
 /**
  * Custom IndexManager that extends Langium's default to:
@@ -37,12 +40,12 @@ export class DomainLangIndexManager extends DefaultIndexManager {
     private readonly importDependencies = new Map<string, Set<string>>();
     
     /**
-     * Maps document URI to its import specifiers and their resolved URIs.
-     * Used to detect when file moves could affect import resolution.
+     * Maps document URI to its import information (specifier, alias, resolved URI).
+     * Used for scope resolution with aliases and detecting when file moves affect imports.
      * Key: importing document URI
-     * Value: Map of import specifier → resolved URI
+     * Value: Array of ImportInfo objects
      */
-    private readonly documentImportSpecifiers = new Map<string, Map<string, string>>();
+    private readonly documentImportInfo = new Map<string, ImportInfo[]>();
     
     /**
      * Tracks documents that have had their imports loaded to avoid redundant work.
@@ -55,11 +58,41 @@ export class DomainLangIndexManager extends DefaultIndexManager {
      */
     private readonly sharedServices: LangiumSharedCoreServices;
 
+    /**
+     * DI-injected import resolver. Set via late-binding because
+     * IndexManager (shared module) is created before ImportResolver (language module).
+     * Falls back to standalone resolveImportPath 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.
+     *
+     * This is necessary because the IndexManager lives in the shared module,
+     * which is created before the language module that provides ImportResolver.
+     */
+    setLanguageServices(services: DomainLangServices): void {
+        this.importResolver = services.imports.ImportResolver;
+    }
+
+    /**
+     * Resolves an import path using the DI-injected ImportResolver when available,
+     * falling back to the standalone resolver for backwards compatibility.
+     */
+    private async resolveImport(document: LangiumDocument, specifier: string): Promise<URI> {
+        if (this.importResolver) {
+            return this.importResolver.resolveForDocument(document, specifier);
+        }
+        // Fallback for contexts where language services aren't wired (e.g., tests)
+        return resolveImportPath(document, specifier);
+    }
+
     /**
      * Extends the default content update to:
      * 1. Ensure all imported documents are loaded
@@ -126,7 +159,7 @@ export class DomainLangIndexManager extends DefaultIndexManager {
      * Tracks import dependencies for a document.
      * For each import in the document, records:
      * 1. That the imported URI is depended upon (for direct change detection)
-     * 2. The import specifier used (for file move detection)
+     * 2. The import specifier and alias (for scope resolution)
      */
     private async trackImportDependencies(document: LangiumDocument): Promise<void> {
         const importingUri = document.uri.toString();
@@ -134,7 +167,7 @@ export class DomainLangIndexManager extends DefaultIndexManager {
         // First, remove old dependencies from this document
         // (in case imports changed)
         this.removeDocumentFromDependencies(importingUri);
-        this.documentImportSpecifiers.delete(importingUri);
+        this.documentImportInfo.delete(importingUri);
 
         // Skip if document isn't ready (no parse result)
         if (document.state < DocumentState.Parsed) {
@@ -146,17 +179,21 @@ export class DomainLangIndexManager extends DefaultIndexManager {
             return;
         }
 
-        const specifierMap = new Map<string, string>();
+        const importInfoList: ImportInfo[] = [];
         
         for (const imp of model.imports) {
             if (!imp.uri) continue;
 
             try {
-                const resolvedUri = await resolveImportPath(document, imp.uri);
+                const resolvedUri = await this.resolveImport(document, imp.uri);
                 const importedUri = resolvedUri.toString();
 
-                // Track the specifier → resolved URI mapping
-                specifierMap.set(imp.uri, importedUri);
+                // Track the full import info (specifier, alias, resolved URI)
+                importInfoList.push({
+                    specifier: imp.uri,
+                    alias: imp.alias,
+                    resolvedUri: importedUri
+                });
 
                 // Add to reverse dependency graph: importedUri → importingUri
                 let dependents = this.importDependencies.get(importedUri);
@@ -167,12 +204,16 @@ export class DomainLangIndexManager extends DefaultIndexManager {
                 dependents.add(importingUri);
             } catch {
                 // Import resolution failed - still track the specifier with empty resolution
-                specifierMap.set(imp.uri, '');
+                importInfoList.push({
+                    specifier: imp.uri,
+                    alias: imp.alias,
+                    resolvedUri: ''
+                });
             }
         }
         
-        if (specifierMap.size > 0) {
-            this.documentImportSpecifiers.set(importingUri, specifierMap);
+        if (importInfoList.length > 0) {
+            this.documentImportInfo.set(importingUri, importInfoList);
         }
     }
 
@@ -210,7 +251,7 @@ export class DomainLangIndexManager extends DefaultIndexManager {
             if (!imp.uri) continue;
 
             try {
-                const resolvedUri = await resolveImportPath(document, imp.uri);
+                const resolvedUri = await this.resolveImport(document, imp.uri);
                 const importedUriString = resolvedUri.toString();
                 
                 // Skip if already loaded
@@ -267,7 +308,7 @@ export class DomainLangIndexManager extends DefaultIndexManager {
      */
     clearImportDependencies(): void {
         this.importDependencies.clear();
-        this.documentImportSpecifiers.clear();
+        this.documentImportInfo.clear();
         this.importsLoaded.clear();
     }
 
@@ -298,21 +339,32 @@ export class DomainLangIndexManager extends DefaultIndexManager {
      * @returns Set of resolved import URIs, or empty set if none
      */
     getResolvedImports(documentUri: string): Set<string> {
-        const specifierMap = this.documentImportSpecifiers.get(documentUri);
-        if (!specifierMap) {
+        const importInfoList = this.documentImportInfo.get(documentUri);
+        if (!importInfoList) {
             return new Set();
         }
         
         const resolved = new Set<string>();
-        for (const resolvedUri of specifierMap.values()) {
+        for (const info of importInfoList) {
             // Only include successfully resolved imports (non-empty string)
-            if (resolvedUri) {
-                resolved.add(resolvedUri);
+            if (info.resolvedUri) {
+                resolved.add(info.resolvedUri);
             }
         }
         return resolved;
     }
 
+    /**
+     * Gets the full import information (including aliases) for a document.
+     * Used by the scope provider to implement alias-prefixed name resolution.
+     * 
+     * @param documentUri - The URI of the document
+     * @returns Array of ImportInfo objects, or empty array if none
+     */
+    getImportInfo(documentUri: string): ImportInfo[] {
+        return this.documentImportInfo.get(documentUri) ?? [];
+    }
+
     /**
      * Gets all documents that would be affected by changes to the given URIs.
      * This includes direct dependents and transitive dependents.
@@ -406,8 +458,8 @@ export class DomainLangIndexManager extends DefaultIndexManager {
     private findDocumentsMatchingPaths(changedPaths: Set<string>): Set<string> {
         const affected = new Set<string>();
 
-        for (const [docUri, specifierMap] of this.documentImportSpecifiers) {
-            if (this.hasMatchingSpecifierOrResolvedUri(specifierMap, changedPaths)) {
+        for (const [docUri, importInfoList] of this.documentImportInfo) {
+            if (this.hasMatchingSpecifierOrResolvedUri(importInfoList, changedPaths)) {
                 affected.add(docUri);
             }
         }
@@ -425,19 +477,19 @@ export class DomainLangIndexManager extends DefaultIndexManager {
      * 
      * We check both to ensure moves of aliased imports trigger revalidation.
      */
-    private hasMatchingSpecifierOrResolvedUri(specifierMap: Map<string, string>, changedPaths: Set<string>): boolean {
-        for (const [specifier, resolvedUri] of specifierMap.entries()) {
-            const normalizedSpecifier = specifier.replace(/^[.@/]+/, '');
+    private hasMatchingSpecifierOrResolvedUri(importInfoList: ImportInfo[], changedPaths: Set<string>): boolean {
+        for (const info of importInfoList) {
+            const normalizedSpecifier = info.specifier.replace(/^[.@/]+/, '');
             
             for (const changedPath of changedPaths) {
                 // Check the raw specifier (handles relative imports)
-                if (specifier.includes(changedPath) || changedPath.endsWith(normalizedSpecifier)) {
+                if (info.specifier.includes(changedPath) || changedPath.endsWith(normalizedSpecifier)) {
                     return true;
                 }
                 
                 // Check the resolved URI (handles path aliases like @domains/...)
                 // The resolved URI contains the full file path which matches moved files
-                if (resolvedUri?.includes(changedPath)) {
+                if (info.resolvedUri?.includes(changedPath)) {
                     return true;
                 }
             }

package/src/lsp/domain-lang-node-kind-provider.ts

@@ -0,0 +1,119 @@
+/**
+ * Custom NodeKindProvider — maps DomainLang AST types to VS Code SymbolKinds.
+ *
+ * Langium's DefaultNodeKindProvider returns `SymbolKind.Field` for everything.
+ * This override provides semantically meaningful icons for the Outline view,
+ * breadcrumbs, Go to Symbol, and completion items.
+ *
+ * @module lsp/domain-lang-node-kind-provider
+ */
+
+import { DefaultNodeKindProvider } from 'langium/lsp';
+import { CompletionItemKind, SymbolKind } from 'vscode-languageserver';
+import type { AstNode, AstNodeDescription } from 'langium';
+import {
+    isDomain,
+    isBoundedContext,
+    isTeam,
+    isClassification,
+    isMetadata,
+    isContextMap,
+    isDomainMap,
+    isNamespaceDeclaration,
+    isRelationship,
+    isDomainTerm,
+    isDecision,
+    isPolicy,
+    isBusinessRule,
+    isMetadataEntry,
+} from '../generated/ast.js';
+
+/**
+ * AST type to icon kind mapping table.
+ */
+type KindMapping = readonly [
+    guard: (node: AstNode) => boolean,
+    symbolKind: SymbolKind,
+    completionKind: CompletionItemKind
+];
+
+const KIND_MAPPINGS: readonly KindMapping[] = [
+    // Strategic design
+    [isDomain,                SymbolKind.Namespace,     CompletionItemKind.Folder],
+    [isBoundedContext,        SymbolKind.Package,       CompletionItemKind.Module],
+    
+    // Tactical design
+    [isTeam,                  SymbolKind.Interface,     CompletionItemKind.Interface],
+    [isClassification,        SymbolKind.Enum,          CompletionItemKind.Enum],
+    [isMetadata,              SymbolKind.Enum,          CompletionItemKind.Enum],
+    
+    // Architecture mapping
+    [isContextMap,            SymbolKind.Package,       CompletionItemKind.Module],
+    [isDomainMap,             SymbolKind.Package,       CompletionItemKind.Module],
+    
+    // Module system
+    [isNamespaceDeclaration,  SymbolKind.Namespace,     CompletionItemKind.Module],
+    
+    // Relationships
+    [isRelationship,          SymbolKind.Interface,         CompletionItemKind.Interface],
+    
+    // Documentation & governance
+    [isDomainTerm,            SymbolKind.Field,         CompletionItemKind.Field],
+    [isDecision,              SymbolKind.Field,         CompletionItemKind.Field],
+    [isPolicy,                SymbolKind.Field,         CompletionItemKind.Field],
+    [isBusinessRule,          SymbolKind.Field,         CompletionItemKind.Field],
+    
+    // Metadata entries
+    [isMetadataEntry,         SymbolKind.Field,         CompletionItemKind.Field],
+] as const;
+
+/**
+ * Maps DomainLang AST types to semantically appropriate SymbolKind values.
+ *
+ * Used by the DocumentSymbolProvider (outline/breadcrumbs), WorkspaceSymbolProvider,
+ * and the CompletionProvider.
+ */
+export class DomainLangNodeKindProvider extends DefaultNodeKindProvider {
+
+    override getSymbolKind(node: AstNode | AstNodeDescription): SymbolKind {
+        try {
+            const astNode = this.resolveNode(node);
+            if (!astNode) return super.getSymbolKind(node);
+
+            for (const [guard, symbolKind] of KIND_MAPPINGS) {
+                if (guard(astNode)) return symbolKind;
+            }
+            return super.getSymbolKind(node);
+        } catch (error) {
+            console.error('Error in getSymbolKind:', error);
+            return super.getSymbolKind(node);
+        }
+    }
+
+    override getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind {
+        try {
+            const astNode = this.resolveNode(node);
+            if (!astNode) return super.getCompletionItemKind(node);
+
+            for (const [guard, , completionKind] of KIND_MAPPINGS) {
+                if (guard(astNode)) return completionKind;
+            }
+            return super.getCompletionItemKind(node);
+        } catch (error) {
+            console.error('Error in getCompletionItemKind:', error);
+            return super.getCompletionItemKind(node);
+        }
+    }
+
+    /**
+     * Resolves an AstNode from an AstNodeDescription (which may only have a reference).
+     * Returns the node directly if it's already an AstNode.
+     */
+    private resolveNode(node: AstNode | AstNodeDescription): AstNode | undefined {
+        if ('$type' in node) {
+            return node;
+        }
+        // AstNodeDescription — resolve if possible
+        return node.node;
+    }
+}