@likec4/language-server 1.42.1 → 1.44.0

package/dist/references/scope-computation.js

@@ -0,0 +1,288 @@
+import { nonexhaustive } from '@likec4/core';
+import { DefaultScopeComputation, MultiMap, } from 'langium';
+import { entries, filter, flatMap, forEachObj, groupBy, isNullish, isTruthy, pipe } from 'remeda';
+import { ast } from '../ast';
+import { logWarnError } from '../logger';
+function uniqueDescriptions(descs) {
+    return pipe(descs, groupBy(desc => `${desc.type}.${desc.name}`), entries(), flatMap(([_, descs]) => descs.length === 1 ? descs : []));
+}
+export class LikeC4ScopeComputation extends DefaultScopeComputation {
+    constructor(services) {
+        super(services);
+    }
+    async computeExports(document, _cancelToken) {
+        const docExports = [];
+        try {
+            const { specifications, models, views, globals, likec4lib, deployments, } = document.parseResult.value;
+            // Process library
+            this.exportLibrary(likec4lib, docExports, document);
+            // Process specification
+            this.exportSpecification(specifications, docExports, document);
+            // Process models
+            this.exportModel(models, docExports, document);
+            // Process views
+            this.exportViews(views, docExports, document);
+            // Process global
+            this.exportGlobals(globals, docExports, document);
+            this.exportDeployments(deployments, docExports, document);
+        }
+        catch (e) {
+            logWarnError(e);
+        }
+        return docExports;
+    }
+    exportViews(modelViews, docExports, document) {
+        const views = modelViews?.flatMap(m => m.views);
+        if (isNullish(views) || views.length === 0) {
+            return;
+        }
+        for (const viewAst of views) {
+            try {
+                if (isTruthy(viewAst.name)) {
+                    docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
+                }
+            }
+            catch (e) {
+                logWarnError(e);
+            }
+        }
+    }
+    exportGlobals(globals, docExports, document) {
+        if (isNullish(globals) || globals.length === 0) {
+            return;
+        }
+        for (const globalPredicateAst of globals.flatMap(g => g.predicates)) {
+            try {
+                const id = globalPredicateAst;
+                if (isTruthy(id.name)) {
+                    docExports.push(this.descriptions.createDescription(id, id.name, document));
+                }
+            }
+            catch (e) {
+                logWarnError(e);
+            }
+        }
+        for (const globalStyleAst of globals.flatMap(g => g.styles)) {
+            try {
+                const id = globalStyleAst.id;
+                if (isTruthy(id.name)) {
+                    docExports.push(this.descriptions.createDescription(id, id.name, document));
+                }
+            }
+            catch (e) {
+                logWarnError(e);
+            }
+        }
+    }
+    exportModel(models, docExports, document) {
+        if (isNullish(models) || models.length === 0) {
+            return;
+        }
+        for (const elAst of models.flatMap(m => m.elements)) {
+            try {
+                if (ast.isElement(elAst) && isTruthy(elAst.name)) {
+                    docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
+                }
+            }
+            catch (e) {
+                logWarnError(e);
+            }
+        }
+    }
+    exportLibrary(likec4lib, docExports, document) {
+        if (isNullish(likec4lib)) {
+            return;
+        }
+        try {
+            for (const iconAst of likec4lib.flatMap(l => l.icons)) {
+                docExports.push(this.descriptions.createDescription(iconAst, iconAst.name, document));
+            }
+        }
+        catch (e) {
+            logWarnError(e);
+        }
+    }
+    exportSpecification(specifications, docExports, document) {
+        if (isNullish(specifications) || specifications.length === 0) {
+            return;
+        }
+        for (const spec of specifications.flatMap(s => [
+            ...s.elements,
+            ...s.relationships,
+            ...s.deploymentNodes,
+            ...s.tags,
+            ...s.colors,
+        ])) {
+            try {
+                switch (true) {
+                    case ast.isSpecificationDeploymentNodeKind(spec):
+                    case ast.isSpecificationElementKind(spec): {
+                        if (isTruthy(spec.kind.name)) {
+                            docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
+                        }
+                        continue;
+                    }
+                    case ast.isSpecificationTag(spec): {
+                        if (isTruthy(spec.tag.name)) {
+                            docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
+                        }
+                        continue;
+                    }
+                    case ast.isSpecificationRelationshipKind(spec): {
+                        if (isTruthy(spec.kind.name)) {
+                            docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
+                        }
+                        continue;
+                    }
+                    case ast.isSpecificationColor(spec): {
+                        if (isTruthy(spec.name.name)) {
+                            docExports.push(this.descriptions.createDescription(spec.name, spec.name.name, document));
+                        }
+                        continue;
+                    }
+                    // Thow error if not exhaustive
+                    default:
+                        nonexhaustive(spec);
+                }
+            }
+            catch (e) {
+                logWarnError(e);
+            }
+        }
+    }
+    exportDeployments(modelDeployments, docExports, document) {
+        const nodes = modelDeployments?.flatMap(m => m.elements);
+        if (isNullish(nodes) || nodes.length === 0) {
+            return;
+        }
+        for (const node of nodes) {
+            try {
+                if (ast.isDeploymentNode(node) && isTruthy(node.name)) {
+                    docExports.push(this.descriptions.createDescription(node, node.name, document));
+                }
+            }
+            catch (e) {
+                logWarnError(e);
+            }
+        }
+    }
+    computeLocalScopes(document, _cancelToken) {
+        return new Promise(resolve => {
+            const root = document.parseResult.value;
+            const descendants = [];
+            const scopes = new MultiMap();
+            for (const model of root.models) {
+                try {
+                    descendants.push(...this.processContainer(model, scopes, document));
+                }
+                catch (e) {
+                    logWarnError(e);
+                }
+            }
+            for (const deployment of root.deployments) {
+                try {
+                    descendants.push(...this.processDeployments(deployment, scopes, document));
+                }
+                catch (e) {
+                    logWarnError(e);
+                }
+            }
+            for (const imports of root.imports.flatMap(i => i.imports)) {
+                try {
+                    let imported = imports;
+                    while (imported) {
+                        descendants.push(this.descriptions.createDescription(imported, imported.imported.$refText));
+                        imported = imported.prev;
+                    }
+                }
+                catch (e) {
+                    logWarnError(e);
+                }
+            }
+            uniqueDescriptions(descendants).forEach(desc => {
+                scopes.add(root, desc);
+            });
+            resolve(scopes);
+        });
+    }
+    processContainer(container, scopes, document) {
+        const localScope = new MultiMap();
+        const descedants = [];
+        for (const el of container.elements) {
+            if (ast.isRelation(el)) {
+                continue;
+            }
+            let subcontainer;
+            if (ast.isElement(el)) {
+                if (isTruthy(el.name)) {
+                    localScope.add(el.name, this.descriptions.createDescription(el, el.name, document));
+                }
+                subcontainer = el.body;
+                if (subcontainer) {
+                    scopes.add(subcontainer, this.descriptions.createDescription(el, 'this', document));
+                    scopes.add(subcontainer, this.descriptions.createDescription(el, 'it', document));
+                }
+            }
+            else if (ast.isExtendElement(el)) {
+                subcontainer = el.body;
+            }
+            if (subcontainer && subcontainer.elements.length > 0) {
+                try {
+                    descedants.push(...this.processContainer(subcontainer, scopes, document));
+                }
+                catch (e) {
+                    logWarnError(e);
+                }
+            }
+        }
+        if (descedants.length) {
+            pipe(descedants, filter(desc => !localScope.has(desc.name)), groupBy(desc => desc.name), forEachObj((descs, name) => {
+                if (descs.length === 1) {
+                    localScope.add(name, descs[0]);
+                }
+            }));
+        }
+        const local = [...localScope.values()];
+        scopes.addAll(container, local);
+        return local;
+    }
+    processDeployments(container, scopes, document) {
+        const localScope = new MultiMap();
+        const descedants = [];
+        for (const el of container.elements) {
+            if (ast.isDeploymentRelation(el)) {
+                continue;
+            }
+            let subcontainer = el.body;
+            if (!ast.isExtendDeployment(el)) {
+                let name = this.nameProvider.getName(el);
+                if (isTruthy(name)) {
+                    const desc = this.descriptions.createDescription(el, name, document);
+                    localScope.add(name, desc);
+                }
+                if (subcontainer) {
+                    scopes.add(subcontainer, this.descriptions.createDescription(el, 'this', document));
+                    scopes.add(subcontainer, this.descriptions.createDescription(el, 'it', document));
+                }
+            }
+            if (subcontainer) {
+                try {
+                    descedants.push(...this.processDeployments(subcontainer, scopes, document));
+                }
+                catch (e) {
+                    logWarnError(e);
+                }
+            }
+        }
+        if (descedants.length) {
+            pipe(descedants, filter(desc => !localScope.has(desc.name)), groupBy(desc => desc.name), forEachObj((descs, name) => {
+                if (descs.length === 1) {
+                    localScope.add(name, descs[0]);
+                }
+            }));
+        }
+        const local = [...localScope.values()];
+        scopes.addAll(container, local);
+        return local;
+    }
+}

package/dist/references/scope-provider.d.ts

@@ -10,10 +10,10 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
     protected readonly indexManager: IndexManager;
     constructor(services: LikeC4Services);
     getScope(context: ReferenceInfo): Scope;
-    protected genUniqueDescedants(of: () => ast.Element | ast.DeploymentNode | undefined): Generator<Stream<import("../ast").AstNodeDescriptionWithFqn>, void, any>;
+    protected genUniqueDescedants(of: () => ast.Element | ast.DeploymentNode | undefined): Generator<import("../ast").AstNodeDescriptionWithFqn, void, any>;
     protected genScopeExtendElement({ element }: ast.ExtendElement): Generator<AstNodeDescription>;
     protected genScopeElementView({ viewOf, extends: ext }: ast.ElementView): Generator<AstNodeDescription>;
-    protected getScopeForStrictFqnRef(projectId: ProjectId, container: ast.StrictFqnRef, context: ReferenceInfo): any;
+    protected getScopeForStrictFqnRef(projectId: ProjectId, container: ast.StrictFqnRef, context: ReferenceInfo): Scope;
     protected genScopeExtendDeployment({ deploymentNode }: ast.ExtendDeployment): Generator<AstNodeDescription>;
     protected streamForFqnRef(projectId: ProjectId, container: ast.FqnRef, context: ReferenceInfo): Stream<AstNodeDescription>;
     protected genScopeForParentlessFqnRef(projectId: ProjectId, container: ast.FqnRef, context: ReferenceInfo): Generator<AstNodeDescription>;
@@ -28,7 +28,7 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
      * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
      * Finally, it combines the collected scopes with the global scope to produce the final scope.
      */
-    protected computeScope(projectId: ProjectId, context: ReferenceInfo, referenceType?: any): Generator<AstNodeDescription>;
+    protected computeScope(projectId: ProjectId, context: ReferenceInfo, referenceType?: string): Generator<AstNodeDescription>;
     /**
      * Create a global scope filtered for the given reference type.
      */

package/dist/references/scope-provider.js

@@ -0,0 +1,242 @@
+import { nonexhaustive } from '@likec4/core';
+import { AstUtils, DefaultScopeProvider, EMPTY_SCOPE, EMPTY_STREAM, MapScope, stream, StreamScope, } from 'langium';
+import { ast, isFqnRefInsideGlobals, isFqnRefInsideModel } from '../ast';
+import { logWarnError } from '../logger';
+import { projectIdFrom } from '../utils';
+import { elementRef, readStrictFqn } from '../utils/elementRef';
+const { getDocument } = AstUtils;
+export class LikeC4ScopeProvider extends DefaultScopeProvider {
+    deploymentsIndex;
+    fqnIndex;
+    indexManager;
+    constructor(services) {
+        super(services);
+        this.indexManager = services.shared.workspace.IndexManager;
+        this.fqnIndex = services.likec4.FqnIndex;
+        this.deploymentsIndex = services.likec4.DeploymentsIndex;
+    }
+    getScope(context) {
+        try {
+            const projectId = projectIdFrom(context.container);
+            const referenceType = this.reflection.getReferenceType(context);
+            try {
+                const container = context.container;
+                if (ast.isFqnRef(container)) {
+                    return new StreamScope(this.streamForFqnRef(projectId, container, context));
+                }
+                if (ast.isStrictFqnRef(container)) {
+                    return this.getScopeForStrictFqnRef(projectId, container, context);
+                }
+                if (referenceType !== ast.Element) {
+                    return this.getProjectScope(projectId, referenceType, context);
+                }
+                if (ast.isImported(container)) {
+                    const projectId = projectIdFrom(container);
+                    return new StreamScope(this.fqnIndex.rootElements(projectId));
+                }
+                if (ast.isStrictFqnElementRef(container) && context.property === 'el') {
+                    const parent = container.parent;
+                    if (!parent) {
+                        return this.getProjectScope(projectId, referenceType, context);
+                    }
+                    return new StreamScope(this.fqnIndex.directChildrenOf(projectId, readStrictFqn(parent)));
+                }
+                return new StreamScope(stream(this.computeScope(projectId, context)));
+            }
+            catch (e) {
+                logWarnError(e);
+                return this.getProjectScope(projectId, referenceType, context);
+            }
+        }
+        catch (e) {
+            logWarnError(e);
+            return EMPTY_SCOPE;
+        }
+    }
+    // we need lazy resolving here
+    *genUniqueDescedants(of) {
+        const element = of();
+        if (!element) {
+            return;
+        }
+        const projectId = projectIdFrom(element);
+        if (ast.isElement(element)) {
+            const fqn = this.fqnIndex.getFqn(element);
+            yield* this.fqnIndex.uniqueDescedants(projectId, fqn);
+            return;
+        }
+        if (ast.isDeploymentNode(element)) {
+            const fqn = this.deploymentsIndex.getFqn(element);
+            yield* this.deploymentsIndex.uniqueDescedants(projectId, fqn);
+        }
+    }
+    *genScopeExtendElement({ element }) {
+        if (element.el.$nodeDescription) {
+            yield element.el.$nodeDescription;
+            yield {
+                ...element.el.$nodeDescription,
+                name: 'this',
+            };
+            yield {
+                ...element.el.$nodeDescription,
+                name: 'it',
+            };
+        }
+        // we make extended element resolvable inside ExtendElementBody
+        yield* this.genUniqueDescedants(() => elementRef(element));
+    }
+    *genScopeElementView({ viewOf, extends: ext }) {
+        if (viewOf) {
+            // If we have "view of parent.target"
+            // we make "target" resolvable inside ElementView
+            if (viewOf.modelElement.value.$nodeDescription) {
+                yield viewOf.modelElement.value.$nodeDescription;
+            }
+            yield* this.genUniqueDescedants(() => elementRef(viewOf));
+            return;
+        }
+        if (ext) {
+            const view = ext.view.ref;
+            if (view) {
+                yield* this.genScopeElementView(view);
+            }
+        }
+    }
+    getScopeForStrictFqnRef(projectId, container, context) {
+        const parent = container.parent;
+        if (!parent) {
+            return this.getProjectScope(projectId, ast.DeploymentNode, context);
+        }
+        return new StreamScope(this.deploymentsIndex
+            .directChildrenOf(projectId, readStrictFqn(parent))
+            .filter(desc => this.reflection.isSubtype(desc.type, ast.DeploymentNode)));
+    }
+    *genScopeExtendDeployment({ deploymentNode }) {
+        if (deploymentNode.value.$nodeDescription) {
+            yield deploymentNode.value.$nodeDescription;
+        }
+        yield* this.genUniqueDescedants(() => {
+            const target = deploymentNode.value.ref;
+            return target && ast.isDeploymentNode(target) ? target : undefined;
+        });
+    }
+    streamForFqnRef(projectId, container, context) {
+        const parent = container.parent;
+        if (!parent) {
+            return stream(this.genScopeForParentlessFqnRef(projectId, container, context));
+        }
+        const parentRef = parent.value.ref;
+        if (!parentRef) {
+            return EMPTY_STREAM;
+        }
+        if (ast.isImported(parentRef)) {
+            return stream(this.genUniqueDescedants(() => {
+                return parentRef.imported.ref;
+            }));
+        }
+        if (ast.isDeploymentNode(parentRef)) {
+            return stream(this.genUniqueDescedants(() => parentRef));
+        }
+        if (ast.isDeployedInstance(parentRef)) {
+            // if (ast.isElement(target)) {
+            return stream(this.genUniqueDescedants(() => {
+                const target = parentRef.target.modelElement.value.ref;
+                if (ast.isImported(target)) {
+                    return target.imported.ref;
+                }
+                return ast.isElement(target) ? target : undefined;
+            }));
+        }
+        if (ast.isElement(parentRef)) {
+            return stream(this.genUniqueDescedants(() => parentRef));
+        }
+        return nonexhaustive(parentRef);
+    }
+    *genScopeForParentlessFqnRef(projectId, container, context) {
+        if (AstUtils.hasContainerOfType(container, ast.isElementRef) ||
+            isFqnRefInsideModel(container)) {
+            // Inside model scope we only need to resolve elements
+            yield* this.computeScope(projectId, context, ast.Element);
+        }
+        else if (isFqnRefInsideGlobals(container)) {
+            yield* this.computeScope(projectId, context, ast.Element);
+            yield* this.computeScope(projectId, context, ast.DeploymentNode);
+            yield* this.computeScope(projectId, context, ast.DeployedInstance);
+        }
+        else {
+            // First preference for deployment nodes
+            yield* this.computeScope(projectId, context, ast.DeploymentNode);
+            // Second preference for deployed instances
+            yield* this.computeScope(projectId, context, ast.DeployedInstance);
+            // Third preference for elements if we are in deployment view
+            if (AstUtils.hasContainerOfType(container, ast.isDeploymentViewBody)) {
+                yield* this.computeScope(projectId, context, ast.Element);
+            }
+        }
+        const doc = getDocument(container);
+        const precomputed = doc.precomputedScopes;
+        // Fourth preference for imported models
+        if (precomputed) {
+            yield* precomputed.values().filter(nd => this.reflection.isSubtype(nd.type, ast.Imported));
+        }
+    }
+    /**
+     * Computes the scope for a given reference context.
+     *
+     * @param context - The reference information containing the context for which the scope is being computed.
+     * @param referenceType - The type of reference being resolved. Defaults to the reference type derived from the context.
+     * @returns A scope containing the relevant AST node descriptions for the given reference context.
+     *
+     * This method first checks if there are precomputed scopes available in the document. If not, it falls back to the global scope.
+     * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
+     * Finally, it combines the collected scopes with the global scope to produce the final scope.
+     */
+    *computeScope(projectId, context, referenceType = this.reflection.getReferenceType(context)) {
+        const isElementReference = this.reflection.isSubtype(referenceType, ast.Element);
+        const isDeploymentReference = this.reflection.isSubtype(referenceType, ast.DeploymentElement);
+        const doc = getDocument(context.container);
+        const precomputed = doc.precomputedScopes;
+        if (!precomputed) {
+            yield* this.getProjectScope(projectId, referenceType, context).getAllElements();
+            return;
+        }
+        const byReferenceType = (desc) => this.reflection.isSubtype(desc.type, referenceType);
+        let container = context.container;
+        while (container) {
+            const elements = precomputed.get(container).filter(byReferenceType);
+            if (elements.length > 0) {
+                yield* elements;
+            }
+            if (isDeploymentReference && ast.isExtendDeploymentBody(container)) {
+                yield* this.genScopeExtendDeployment(container.$container);
+            }
+            if (isElementReference && ast.isExtendElementBody(container)) {
+                yield* this.genScopeExtendElement(container.$container);
+            }
+            if (isElementReference && ast.isElementViewBody(container)) {
+                yield* this.genScopeElementView(container.$container);
+            }
+            container = container.$container;
+        }
+        yield* this.getProjectScope(projectId, referenceType, context).getAllElements();
+    }
+    /**
+     * Create a global scope filtered for the given reference type.
+     */
+    getProjectScope(projectId, referenceType, context) {
+        if (referenceType === ast.LibIcon) {
+            return super.getGlobalScope(referenceType, context);
+        }
+        return this.globalScopeCache.get(`${projectId}::${referenceType}`, () => new MapScope(this.indexManager.projectElements(projectId, referenceType)));
+    }
+    /**
+     * Create a global scope filtered for the given reference type.
+     */
+    getGlobalScope(referenceType, context) {
+        if (referenceType === ast.LibIcon) {
+            return super.getGlobalScope(referenceType, context);
+        }
+        const projectId = projectIdFrom(context.container);
+        return this.getProjectScope(projectId, referenceType, context);
+    }
+}

package/dist/shared/NodeKindProvider.js

@@ -0,0 +1,57 @@
+import { isAstNode } from 'langium';
+import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-types';
+import { ast } from '../ast';
+export class NodeKindProvider {
+    services;
+    constructor(services) {
+        this.services = services;
+    }
+    /**
+     * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
+     */
+    // prettier-ignore
+    getSymbolKind(node) {
+        const nodeType = isAstNode(node) ? node.$type : node.type;
+        const hasType = (...types) => types.some(t => this.services.AstReflection.isSubtype(nodeType, t));
+        switch (true) {
+            case hasType(ast.Element, ast.ExtendElement, ast.DeploymentNode, ast.DeployedInstance, ast.Imported):
+                return SymbolKind.Constructor;
+            case hasType(ast.Model, ast.ModelViews, ast.ModelDeployments, ast.Globals, ast.SpecificationRule):
+                return SymbolKind.Namespace;
+            case hasType(ast.LikeC4View):
+                return SymbolKind.Class;
+            case hasType(ast.Tag, ast.LibIcon, ast.CustomColor, ast.SpecificationTag):
+                return SymbolKind.EnumMember;
+            case hasType(ast.RelationshipKind, ast.SpecificationRelationshipKind):
+                return SymbolKind.Event;
+            case hasType(ast.ElementKind, ast.DeploymentNodeKind, ast.SpecificationElementKind, ast.SpecificationDeploymentNodeKind):
+                return SymbolKind.TypeParameter;
+        }
+        return SymbolKind.Field;
+    }
+    /**
+     * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
+     */
+    getCompletionItemKind(node) {
+        const nodeType = isAstNode(node) ? node.$type : node.type;
+        const hasType = (...types) => types.some(t => this.services.AstReflection.isSubtype(nodeType, t));
+        switch (true) {
+            case hasType(ast.CustomColor):
+                return CompletionItemKind.Color;
+            case hasType(ast.Element, ast.DeploymentNode, ast.DeployedInstance, ast.ExtendElement, ast.Imported):
+                return CompletionItemKind.Constructor;
+            case hasType(ast.Model, ast.ModelViews, ast.ModelDeployments, ast.Globals, ast.SpecificationRule):
+                return CompletionItemKind.Module;
+            case hasType(ast.LikeC4View):
+                return CompletionItemKind.Class;
+            case hasType(ast.Tag, ast.LibIcon, ast.CustomColor, ast.SpecificationTag):
+                return CompletionItemKind.EnumMember;
+            case hasType(ast.RelationshipKind, ast.SpecificationRelationshipKind):
+                return CompletionItemKind.Event;
+            case hasType(ast.ElementKind, ast.SpecificationElementKind, ast.DeploymentNodeKind, ast.SpecificationDeploymentNodeKind):
+                return CompletionItemKind.TypeParameter;
+            default:
+                return CompletionItemKind.Reference;
+        }
+    }
+}

package/dist/shared/{WorkspaceSymbolProvider.mjs → WorkspaceSymbolProvider.js}

@@ -1,3 +1,3 @@
-import { DefaultWorkspaceSymbolProvider } from "langium/lsp";
+import { DefaultWorkspaceSymbolProvider } from 'langium/lsp';
 export class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {
 }

package/dist/shared/index.js

@@ -0,0 +1,2 @@
+export * from './NodeKindProvider';
+export * from './WorkspaceSymbolProvider';

package/dist/test/index.js

@@ -0,0 +1 @@
+export * from './testServices';