@likec4/language-server 1.18.0 → 1.19.1

package/dist/references/scope-computation.js

@@ -0,0 +1,281 @@
+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.js";
+import { logWarnError } from "../logger.js";
+function uniqueDescriptions(descs) {
+  return pipe(
+    descs,
+    groupBy((desc) => `${desc.type}.${desc.name}`),
+    entries(),
+    flatMap(([_, descs2]) => descs2.length === 1 ? descs2 : [])
+  );
+}
+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;
+      this.exportLibrary(likec4lib, docExports, document);
+      this.exportSpecification(specifications, docExports, document);
+      this.exportModel(models, docExports, document);
+      this.exportViews(views, docExports, document);
+      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),
+                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);
+        }
+      }
+      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;
+      } 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 localnames = /* @__PURE__ */ new Set();
+    const descedants = [];
+    for (const el of container.elements) {
+      if (ast.isDeploymentRelation(el)) {
+        continue;
+      }
+      let name = this.nameProvider.getName(el);
+      if (isTruthy(name)) {
+        const desc = this.descriptions.createDescription(el, name, document);
+        scopes.add(container, desc);
+        localnames.add(desc.name);
+      }
+      if (ast.isDeploymentNode(el) && el.body) {
+        try {
+          descedants.push(
+            ...this.processDeployments(el.body, scopes, document)
+          );
+        } catch (e) {
+          logWarnError(e);
+        }
+      }
+    }
+    if (descedants.length > 0) {
+      pipe(
+        descedants,
+        filter((desc) => !localnames.has(desc.name)),
+        groupBy((desc) => desc.name),
+        forEachObj((descs, name) => {
+          if (descs.length === 1) {
+            scopes.add(container, descs[0]);
+          }
+        })
+      );
+    }
+    return [...scopes.get(container).values()];
+  }
+}

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

@@ -0,0 +1,16 @@
+import { DefaultScopeProvider, type ReferenceInfo, type Scope } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
+    private deploymentsIndex;
+    private fqnIndex;
+    constructor(services: LikeC4Services);
+    private directChildrenOf;
+    private uniqueDescedants;
+    private scopeElementRef;
+    private scopeExtendElement;
+    private scopeElementView;
+    getScope(context: ReferenceInfo): Scope;
+    protected getScopeForFqnRef(container: ast.FqnRef, context: ReferenceInfo): any;
+    protected computeScope(context: ReferenceInfo, referenceType?: any): any;
+}

package/dist/references/scope-provider.js

@@ -0,0 +1,165 @@
+import { nonexhaustive } from "@likec4/core";
+import {
+  AstUtils,
+  DefaultScopeProvider,
+  DONE_RESULT,
+  EMPTY_SCOPE,
+  EMPTY_STREAM,
+  MapScope,
+  stream,
+  StreamImpl,
+  StreamScope
+} from "langium";
+import { ast } from "../ast.js";
+import { logger } from "../logger.js";
+import { elementRef, getFqnElementRef } from "../utils/elementRef.js";
+const { getDocument } = AstUtils;
+export class LikeC4ScopeProvider extends DefaultScopeProvider {
+  deploymentsIndex;
+  fqnIndex;
+  constructor(services) {
+    super(services);
+    this.fqnIndex = services.likec4.FqnIndex;
+    this.deploymentsIndex = services.likec4.DeploymentsIndex;
+  }
+  directChildrenOf(parent) {
+    return this.fqnIndex.directChildrenOf(parent);
+  }
+  // we need lazy resolving here
+  uniqueDescedants(of) {
+    return new StreamImpl(
+      () => {
+        const element = of();
+        const fqn = element && this.fqnIndex.getFqn(element);
+        if (fqn) {
+          return this.fqnIndex.uniqueDescedants(fqn).iterator();
+        }
+        return null;
+      },
+      (iterator) => {
+        if (iterator) {
+          return iterator.next();
+        }
+        return DONE_RESULT;
+      }
+    );
+  }
+  scopeElementRef(ref) {
+    return this.uniqueDescedants(() => ref.el.ref);
+  }
+  scopeExtendElement({ element }) {
+    return stream([element.el.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => elementRef(element)));
+  }
+  scopeElementView({ viewOf, extends: ext }) {
+    if (viewOf) {
+      return stream([viewOf.el.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => elementRef(viewOf)));
+    }
+    if (ext) {
+      return stream([ext]).flatMap((v) => {
+        const view = v.view.ref;
+        return view ? this.scopeElementView(view) : EMPTY_STREAM;
+      });
+    }
+    return EMPTY_STREAM;
+  }
+  getScope(context) {
+    try {
+      const referenceType = this.reflection.getReferenceType(context);
+      try {
+        const container = context.container;
+        if (ast.isFqnRef(container)) {
+          return this.getScopeForFqnRef(container, context);
+        }
+        if (referenceType !== ast.Element) {
+          return this.getGlobalScope(referenceType, context);
+        }
+        if (ast.isFqnElementRef(container) && context.property === "el") {
+          const parent = container.parent;
+          if (!parent) {
+            return this.getGlobalScope(referenceType, context);
+          }
+          return new StreamScope(this.directChildrenOf(getFqnElementRef(parent)));
+        }
+        if (ast.isElementRef(container) && context.property === "el") {
+          const parent = container.parent;
+          if (parent) {
+            return new StreamScope(this.scopeElementRef(parent));
+          }
+          if (context.reference.$refText === "this" || context.reference.$refText === "it") {
+            const closestElement = AstUtils.getContainerOfType(container, ast.isElement);
+            if (closestElement) {
+              return new MapScope([
+                this.descriptions.createDescription(closestElement, context.reference.$refText)
+              ]);
+            } else {
+              return EMPTY_SCOPE;
+            }
+          }
+        }
+        return this.computeScope(context);
+      } catch (e) {
+        logger.warn(e);
+        return this.getGlobalScope(referenceType, context);
+      }
+    } catch (e) {
+      logger.warn(e);
+      return EMPTY_SCOPE;
+    }
+  }
+  getScopeForFqnRef(container, context) {
+    const parent = container.parent;
+    if (!parent) {
+      return this.createScope(
+        // First preference for deployment nodes
+        this.computeScope(context, ast.DeploymentNode).getAllElements(),
+        this.createScope(
+          // Second preference for deployed instances
+          this.computeScope(context, ast.DeployedInstance).getAllElements(),
+          // Third preference for elements if we are in deployment view
+          AstUtils.hasContainerOfType(container, ast.isDeploymentView) ? this.computeScope(context, ast.Element) : EMPTY_SCOPE
+        )
+      );
+    }
+    const parentRef = parent.value.ref;
+    if (!parentRef) {
+      return EMPTY_SCOPE;
+    }
+    if (ast.isDeploymentNode(parentRef)) {
+      return new StreamScope(this.deploymentsIndex.nested(parentRef));
+    }
+    if (ast.isDeployedInstance(parentRef)) {
+      return new StreamScope(this.scopeElementRef(parentRef.element));
+    }
+    if (ast.isElement(parentRef)) {
+      return new StreamScope(this.uniqueDescedants(() => parentRef));
+    }
+    return nonexhaustive(parentRef);
+  }
+  computeScope(context, referenceType = this.reflection.getReferenceType(context)) {
+    const isElementReference = this.reflection.isSubtype(referenceType, ast.Element);
+    const scopes = [];
+    const doc = getDocument(context.container);
+    const precomputed = doc.precomputedScopes;
+    if (!precomputed) {
+      return this.getGlobalScope(referenceType, context);
+    }
+    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) {
+        scopes.push(stream(elements));
+      }
+      if (isElementReference && ast.isExtendElementBody(container)) {
+        scopes.push(this.scopeExtendElement(container.$container));
+      }
+      if (isElementReference && ast.isElementViewBody(container)) {
+        scopes.push(this.scopeElementView(container.$container));
+      }
+      container = container.$container;
+    }
+    return scopes.reduceRight((outerScope, elements) => {
+      return this.createScope(elements, outerScope);
+    }, this.getGlobalScope(referenceType, context));
+  }
+}

package/dist/shared/NodeKindProvider.d.ts

@@ -0,0 +1,15 @@
+import { type AstNode, type AstNodeDescription } from 'langium';
+import type { LangiumSharedServices, NodeKindProvider as LspNodeKindProvider } from 'langium/lsp';
+import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-types';
+export declare class NodeKindProvider implements LspNodeKindProvider {
+    private services;
+    constructor(services: LangiumSharedServices);
+    /**
+     * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
+     */
+    getSymbolKind(node: AstNode | AstNodeDescription): SymbolKind;
+    /**
+     * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
+     */
+    getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind;
+}

package/dist/shared/NodeKindProvider.js

@@ -0,0 +1,108 @@
+import { isAstNode } from "langium";
+import { CompletionItemKind, SymbolKind } from "vscode-languageserver-types";
+import { ast } from "../ast.js";
+export class NodeKindProvider {
+  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
+      ):
+        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
+      ):
+        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/WorkspaceManager.d.ts

@@ -0,0 +1,18 @@
+import type { LangiumDocument } from 'langium';
+import { DefaultWorkspaceManager } from 'langium';
+import type { LangiumSharedServices } from 'langium/lsp';
+import type { WorkspaceFolder } from 'vscode-languageserver';
+import { URI } from 'vscode-uri';
+export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+    private documentFactory;
+    constructor(services: LangiumSharedServices);
+    /**
+     * Load all additional documents that shall be visible in the context of the given workspace
+     * folders and add them to the collector. This can be used to include built-in libraries of
+     * your language, which can be either loaded from provided files or constructed in memory.
+     */
+    protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
+    workspace(): any;
+    get workspaceUri(): URI;
+    get workspaceURL(): URL;
+}

package/dist/shared/WorkspaceManager.js

@@ -0,0 +1,36 @@
+import { hasAtLeast, invariant } from "@likec4/core";
+import { DefaultWorkspaceManager } from "langium";
+import { URI } from "vscode-uri";
+import * as BuiltIn from "../likec4lib.js";
+export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+  documentFactory;
+  constructor(services) {
+    super(services);
+    this.documentFactory = services.workspace.LangiumDocumentFactory;
+  }
+  /**
+   * Load all additional documents that shall be visible in the context of the given workspace
+   * folders and add them to the collector. This can be used to include built-in libraries of
+   * your language, which can be either loaded from provided files or constructed in memory.
+   */
+  async loadAdditionalDocuments(folders, collector) {
+    collector(this.documentFactory.fromString(BuiltIn.Content, URI.parse(BuiltIn.Uri)));
+    await super.loadAdditionalDocuments(folders, collector);
+  }
+  workspace() {
+    if (this.folders && hasAtLeast(this.folders, 1)) {
+      return this.folders[0];
+    }
+    return null;
+  }
+  get workspaceUri() {
+    const workspace = this.workspace();
+    invariant(workspace, "Workspace not initialized");
+    return URI.parse(workspace.uri);
+  }
+  get workspaceURL() {
+    const workspace = this.workspace();
+    invariant(workspace, "Workspace not initialized");
+    return new URL(workspace.uri);
+  }
+}

package/dist/shared/WorkspaceSymbolProvider.d.ts

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

package/dist/shared/WorkspaceSymbolProvider.js

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

package/dist/shared/index.d.ts

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

package/dist/shared/index.js

@@ -0,0 +1,3 @@
+export * from "./NodeKindProvider.js";
+export * from "./WorkspaceManager.js";
+export * from "./WorkspaceSymbolProvider.js";

package/dist/test/index.d.ts

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

package/dist/test/index.js

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

package/dist/test/setup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/setup.js

@@ -0,0 +1,7 @@
+import { consola } from "@likec4/log";
+import { beforeEach, vi } from "vitest";
+import { logger } from "../logger.js";
+beforeEach(() => {
+  consola.mockTypes(() => vi.fn());
+  logger.mockTypes(() => vi.fn());
+});