@likec4/language-server 1.17.1 → 1.19.0

package/dist/lsp/RenameProvider.d.ts

@@ -0,0 +1,5 @@
+import { DefaultRenameProvider } from 'langium/lsp';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4RenameProvider extends DefaultRenameProvider {
+    constructor(services: LikeC4Services);
+}

package/dist/lsp/RenameProvider.js

@@ -0,0 +1,6 @@
+import { DefaultRenameProvider } from "langium/lsp";
+export class LikeC4RenameProvider extends DefaultRenameProvider {
+  constructor(services) {
+    super(services);
+  }
+}

package/dist/lsp/SemanticTokenProvider.d.ts

@@ -0,0 +1,7 @@
+import type { AstNode } from 'langium';
+import { AbstractSemanticTokenProvider, type SemanticTokenAcceptor } from 'langium/lsp';
+export declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
+    protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
+    private highlightNameAndKind;
+    private highlightView;
+}

package/dist/lsp/SemanticTokenProvider.js

@@ -0,0 +1,297 @@
+import { AbstractSemanticTokenProvider } from "langium/lsp";
+import { isTruthy } from "remeda";
+import { SemanticTokenModifiers, SemanticTokenTypes } from "vscode-languageserver-types";
+import { ast } from "../ast.js";
+export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
+  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+  highlightElement(node, acceptor) {
+    if (ast.isElement(node) || ast.isDeploymentNode(node)) {
+      return this.highlightNameAndKind(node, acceptor);
+    }
+    if (ast.isDeployedInstance(node)) {
+      if ("name" in node) {
+        acceptor({
+          node,
+          property: "name",
+          type: SemanticTokenTypes.variable,
+          modifier: [
+            SemanticTokenModifiers.definition,
+            SemanticTokenModifiers.readonly
+          ]
+        });
+      }
+      return;
+    }
+    if (ast.isLikeC4View(node)) {
+      return this.highlightView(node, acceptor);
+    }
+    if (ast.isRelationshipKind(node)) {
+      return acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.function
+      });
+    }
+    if (ast.isLibIcon(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.type,
+        modifier: [SemanticTokenModifiers.definition]
+      });
+      return "prune";
+    }
+    if (ast.isOutgoingRelationExpression(node) && "kind" in node) {
+      acceptor({
+        node,
+        property: "kind",
+        type: SemanticTokenTypes.function
+      });
+      return;
+    }
+    if (ast.isRelation(node) && "kind" in node) {
+      acceptor({
+        node,
+        property: "kind",
+        type: SemanticTokenTypes.function
+      });
+    }
+    if (ast.isNavigateToProperty(node) || ast.isRelationNavigateToProperty(node)) {
+      acceptor({
+        node,
+        property: "key",
+        type: SemanticTokenTypes.property
+      });
+      acceptor({
+        node,
+        property: "value",
+        type: SemanticTokenTypes.variable,
+        modifier: [
+          SemanticTokenModifiers.definition,
+          SemanticTokenModifiers.readonly
+        ]
+      });
+      return "prune";
+    }
+    if ((ast.isElementDescedantsExpression(node) || ast.isWildcardExpression(node)) && node.$cstNode) {
+      acceptor({
+        cst: node.$cstNode,
+        type: SemanticTokenTypes.variable,
+        modifier: [
+          SemanticTokenModifiers.definition,
+          SemanticTokenModifiers.readonly
+        ]
+      });
+      return "prune";
+    }
+    if (ast.isFqnRefExpr(node)) {
+      if (node.selector) {
+        acceptor({
+          node,
+          property: "selector",
+          type: SemanticTokenTypes.variable,
+          modifier: [
+            SemanticTokenModifiers.definition,
+            SemanticTokenModifiers.readonly
+          ]
+        });
+      }
+      return;
+    }
+    if (ast.isWhereRelationKind(node) && isTruthy(node.value)) {
+      acceptor({
+        node,
+        property: "value",
+        type: SemanticTokenTypes.function
+      });
+      return;
+    }
+    if ((ast.isWhereElement(node) || ast.isWhereRelation(node)) && isTruthy(node.value)) {
+      acceptor({
+        node,
+        property: "value",
+        type: SemanticTokenTypes.type,
+        modifier: [
+          SemanticTokenModifiers.definition,
+          SemanticTokenModifiers.readonly
+        ]
+      });
+      return;
+    }
+    if (ast.isElementKindExpression(node) && isTruthy(node.kind)) {
+      acceptor({
+        node,
+        property: "kind",
+        type: SemanticTokenTypes.type,
+        modifier: [SemanticTokenModifiers.definition]
+      });
+      return "prune";
+    }
+    if (ast.isElementTagExpression(node) && isTruthy(node.tag)) {
+      acceptor({
+        node,
+        property: "tag",
+        type: SemanticTokenTypes.type,
+        modifier: [SemanticTokenModifiers.definition]
+      });
+      return "prune";
+    }
+    if (ast.isFqnRef(node)) {
+      acceptor({
+        node,
+        property: "value",
+        type: node.parent ? SemanticTokenTypes.property : SemanticTokenTypes.variable,
+        modifier: [
+          SemanticTokenModifiers.definition,
+          SemanticTokenModifiers.readonly
+        ]
+      });
+      return !node.parent ? "prune" : void 0;
+    }
+    if (ast.isElementRef(node) || ast.isFqnElementRef(node)) {
+      acceptor({
+        node,
+        property: "el",
+        type: node.parent ? SemanticTokenTypes.property : SemanticTokenTypes.variable,
+        modifier: [
+          SemanticTokenModifiers.definition,
+          SemanticTokenModifiers.readonly
+        ]
+      });
+      return !node.parent ? "prune" : void 0;
+    }
+    if (ast.isSpecificationColor(node)) {
+      acceptor({
+        node,
+        keyword: "color",
+        type: SemanticTokenTypes.keyword
+      });
+      acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.type,
+        modifier: [
+          SemanticTokenModifiers.declaration,
+          SemanticTokenModifiers.readonly
+        ]
+      });
+      return;
+    }
+    if (ast.isSpecificationElementKind(node) || ast.isSpecificationRelationshipKind(node) || ast.isSpecificationDeploymentNodeKind(node)) {
+      acceptor({
+        node,
+        property: "kind",
+        type: SemanticTokenTypes.type,
+        modifier: [
+          SemanticTokenModifiers.declaration,
+          SemanticTokenModifiers.readonly
+        ]
+      });
+    }
+    if (ast.isTags(node)) {
+      return acceptor({
+        node,
+        property: "values",
+        type: SemanticTokenTypes.interface
+      });
+    }
+    if (ast.isTag(node)) {
+      return acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.type,
+        modifier: [SemanticTokenModifiers.definition]
+      });
+    }
+    if (ast.isRelationStyleProperty(node) || ast.isElementStyleProperty(node) && ast.isElementBody(node.$container)) {
+      acceptor({
+        node,
+        property: "key",
+        type: SemanticTokenTypes.property
+      });
+    }
+    if (ast.isOpacityProperty(node)) {
+      acceptor({
+        node,
+        property: "key",
+        type: SemanticTokenTypes.property
+      });
+      acceptor({
+        node,
+        property: "value",
+        type: SemanticTokenTypes.number
+      });
+      return "prune";
+    }
+    if (ast.isLinkProperty(node) || ast.isIconProperty(node) || ast.isStringProperty(node)) {
+      acceptor({
+        node,
+        property: "key",
+        type: SemanticTokenTypes.property
+      });
+      if (ast.isIconProperty(node) && (node.libicon || node.value === "none")) {
+        acceptor({
+          node,
+          property: node.libicon ? "libicon" : "value",
+          type: SemanticTokenTypes.enum,
+          modifier: [SemanticTokenModifiers.defaultLibrary]
+        });
+        return "prune";
+      }
+      if ("value" in node && node.value) {
+        acceptor({
+          node,
+          property: "value",
+          type: SemanticTokenTypes.string
+        });
+      }
+      return "prune";
+    }
+    if (ast.isColorProperty(node) || ast.isShapeProperty(node) || ast.isArrowProperty(node) || ast.isLineProperty(node) || ast.isBorderProperty(node)) {
+      acceptor({
+        node,
+        property: "key",
+        type: SemanticTokenTypes.property
+      });
+      if ("value" in node) {
+        acceptor({
+          node,
+          property: "value",
+          type: SemanticTokenTypes.enum
+        });
+      }
+      return "prune";
+    }
+  }
+  highlightNameAndKind(node, acceptor) {
+    acceptor({
+      node,
+      property: "name",
+      type: SemanticTokenTypes.variable,
+      modifier: [
+        SemanticTokenModifiers.declaration,
+        SemanticTokenModifiers.readonly
+      ]
+    });
+    acceptor({
+      node,
+      property: "kind",
+      type: SemanticTokenTypes.keyword,
+      modifier: []
+    });
+  }
+  highlightView(node, acceptor) {
+    if (node.name) {
+      acceptor({
+        node,
+        property: "name",
+        type: SemanticTokenTypes.variable,
+        modifier: [
+          SemanticTokenModifiers.declaration,
+          SemanticTokenModifiers.readonly,
+          "local"
+        ]
+      });
+    }
+  }
+}

package/dist/lsp/index.d.ts

@@ -0,0 +1,7 @@
+export * from './CodeLensProvider';
+export * from './CompletionProvider';
+export * from './DocumentHighlightProvider';
+export * from './DocumentLinkProvider';
+export * from './DocumentSymbolProvider';
+export * from './HoverProvider';
+export * from './SemanticTokenProvider';

package/dist/lsp/index.js

@@ -0,0 +1,7 @@
+export * from "./CodeLensProvider.js";
+export * from "./CompletionProvider.js";
+export * from "./DocumentHighlightProvider.js";
+export * from "./DocumentLinkProvider.js";
+export * from "./DocumentSymbolProvider.js";
+export * from "./HoverProvider.js";
+export * from "./SemanticTokenProvider.js";

package/dist/model/deployments-index.d.ts

@@ -0,0 +1,60 @@
+import type { Fqn } from '@likec4/core';
+import type { LangiumDocuments, Stream } from 'langium';
+import { MultiMap } from 'langium';
+import { type DeploymentAstNodeDescription, type LikeC4LangiumDocument, ast } from '../ast';
+import type { LikeC4Services } from '../module';
+import type { LikeC4NameProvider } from '../references';
+export declare class DeploymentsIndex {
+    private services;
+    protected Names: LikeC4NameProvider;
+    protected langiumDocuments: LangiumDocuments;
+    constructor(services: LikeC4Services);
+    private documents;
+    get(document: LikeC4LangiumDocument): DocumentDeploymentsIndex;
+    /**
+     * Nested elements (nodes/artifacts) of the node
+     * @param nodeName Name of the deployment node
+     * @returns Stream of artifacts
+     */
+    nested(node: ast.DeploymentNode): Stream<DeploymentAstNodeDescription>;
+    byFqn(fqnName: string): Stream<DeploymentAstNodeDescription>;
+    getFqn(node: ast.DeploymentElement): Fqn;
+    createDocumentIndex(document: LikeC4LangiumDocument): DocumentDeploymentsIndex;
+}
+/**
+ * Index of deployment elements in the document
+ */
+export declare class DocumentDeploymentsIndex {
+    private _rootNodes;
+    /**
+     * Nested of a deployment node
+     */
+    private _nested;
+    /**
+     * All elements by FQN
+     */
+    private _byfqn;
+    static readonly EMPTY: DocumentDeploymentsIndex;
+    constructor(_rootNodes: Array<DeploymentAstNodeDescription>, 
+    /**
+     * Nested of a deployment node
+     */
+    _nested: MultiMap<string, DeploymentAstNodeDescription>, 
+    /**
+     * All elements by FQN
+     */
+    _byfqn: MultiMap<string, DeploymentAstNodeDescription>);
+    rootNodes(): readonly DeploymentAstNodeDescription[];
+    byFqn(fqnName: string): readonly DeploymentAstNodeDescription[];
+    /**
+     * Returns artifacts of a deployment node
+     * @param nodeName Name of the deployment node
+     * @returns Stream of artifacts
+     */
+    nested(nodeName: string): readonly DeploymentAstNodeDescription[];
+    /**
+     * Returns all deployment elements in the document,
+     * with unique combination "type and name"
+     */
+    unique(): readonly DeploymentAstNodeDescription[];
+}

package/dist/model/deployments-index.js

@@ -0,0 +1,181 @@
+import { AstUtils, DocumentState, MultiMap } from "langium";
+import { forEachObj, groupBy, isTruthy, pipe, prop } from "remeda";
+import {
+  ast,
+  ElementOps,
+  isLikeC4LangiumDocument
+} from "../ast.js";
+import { logWarnError } from "../logger.js";
+const DeploymentsIndexKey = Symbol.for("DeploymentsIndex");
+export class DeploymentsIndex {
+  constructor(services) {
+    this.services = services;
+    this.Names = services.references.NameProvider;
+    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+    services.shared.workspace.DocumentBuilder.onBuildPhase(
+      DocumentState.IndexedContent,
+      (docs, _cancelToken) => {
+        for (const doc of docs) {
+          delete doc[DeploymentsIndexKey];
+        }
+      }
+    );
+  }
+  Names;
+  langiumDocuments;
+  documents() {
+    return this.langiumDocuments.all.filter(
+      (d) => isLikeC4LangiumDocument(d) && d.state >= DocumentState.IndexedContent
+    );
+  }
+  get(document) {
+    if (document.state < DocumentState.IndexedContent) {
+      logWarnError(`Document ${document.uri.path} is not indexed`);
+    }
+    return document[DeploymentsIndexKey] ??= this.createDocumentIndex(document);
+  }
+  /**
+   * Nested elements (nodes/artifacts) of the node
+   * @param nodeName Name of the deployment node
+   * @returns Stream of artifacts
+   */
+  nested(node) {
+    const fqnName = this.getFqn(node);
+    return this.documents().flatMap((doc) => this.get(doc).nested(fqnName));
+  }
+  byFqn(fqnName) {
+    return this.documents().flatMap((doc) => this.get(doc).byFqn(fqnName));
+  }
+  getFqn(node) {
+    let id = ElementOps.readId(node);
+    if (isTruthy(id)) {
+      return id;
+    }
+    const fqn = [
+      this.Names.getNameStrict(node)
+    ];
+    let _node = node;
+    let parentNode;
+    while (parentNode = AstUtils.getContainerOfType(_node.$container, ast.isDeploymentNode)) {
+      fqn.push(this.Names.getNameStrict(parentNode));
+      _node = parentNode;
+    }
+    id = fqn.reduceRight((acc, cur) => `${acc}.${cur}`);
+    ElementOps.writeId(node, id);
+    return id;
+  }
+  createDocumentIndex(document) {
+    const rootNodes = document.parseResult.value.deployments.flatMap((m) => m.elements);
+    if (rootNodes.length === 0) {
+      return DocumentDeploymentsIndex.EMPTY;
+    }
+    const _root = new Array();
+    const _nested = new MultiMap();
+    const _byfqn = new MultiMap();
+    const Names = this.Names;
+    const Descriptions = this.services.workspace.AstNodeDescriptionProvider;
+    const createAndSaveDescription = (props) => {
+      const desc = {
+        ...Descriptions.createDescription(props.node, props.name, document),
+        fqn: props.fqn
+      };
+      ElementOps.writeId(props.node, props.fqn);
+      _byfqn.add(props.fqn, desc);
+      return desc;
+    };
+    const traverseNode = (container, parentFqn) => {
+      const _descedants = [];
+      const children = container.body?.elements;
+      if (!children || children.length === 0) {
+        return [];
+      }
+      const directChildren = /* @__PURE__ */ new Set();
+      for (const node of children) {
+        if (ast.isDeploymentRelation(node)) {
+          continue;
+        }
+        try {
+          const name = Names.getName(node);
+          if (isTruthy(name)) {
+            const fqn = `${parentFqn}.${name}`;
+            const desc = createAndSaveDescription({ node, name, fqn });
+            _nested.add(parentFqn, desc);
+            directChildren.add(desc.name);
+            if (ast.isDeploymentNode(node) && node.body) {
+              _descedants.push(...traverseNode(node, fqn));
+            }
+          }
+        } catch (e) {
+          logWarnError(e);
+        }
+      }
+      if (_descedants.length > 0) {
+        pipe(
+          _descedants,
+          groupBy(prop("name")),
+          forEachObj((descs, key) => {
+            if (descs.length > 1 || directChildren.has(key)) {
+              return;
+            }
+            _nested.add(parentFqn, descs[0]);
+          })
+        );
+      }
+      return _nested.get(parentFqn);
+    };
+    for (const node of rootNodes) {
+      try {
+        if (ast.isDeploymentRelation(node)) {
+          continue;
+        }
+        const name = Names.getName(node);
+        if (isTruthy(name)) {
+          _root.push(createAndSaveDescription({ node, name, fqn: name }));
+          traverseNode(node, name);
+        }
+      } catch (e) {
+        logWarnError(e);
+      }
+    }
+    return new DocumentDeploymentsIndex(_root, _nested, _byfqn);
+  }
+}
+export class DocumentDeploymentsIndex {
+  constructor(_rootNodes, _nested, _byfqn) {
+    this._rootNodes = _rootNodes;
+    this._nested = _nested;
+    this._byfqn = _byfqn;
+  }
+  static EMPTY = new DocumentDeploymentsIndex([], new MultiMap(), new MultiMap());
+  rootNodes() {
+    return this._rootNodes;
+  }
+  byFqn(fqnName) {
+    return this._byfqn.get(fqnName);
+  }
+  /**
+   * Returns artifacts of a deployment node
+   * @param nodeName Name of the deployment node
+   * @returns Stream of artifacts
+   */
+  nested(nodeName) {
+    return this._nested.get(nodeName);
+  }
+  /**
+   * Returns all deployment elements in the document,
+   * with unique combination "type and name"
+   */
+  unique() {
+    const result = [];
+    pipe(
+      [...this._byfqn.values()],
+      groupBy(prop("name")),
+      forEachObj((descs) => {
+        if (descs.length === 1) {
+          result.push(descs[0]);
+        }
+      })
+    );
+    return result;
+  }
+}

package/dist/model/fqn-computation.d.ts

@@ -0,0 +1,3 @@
+import { type LikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare function computeDocumentFqn(document: LikeC4LangiumDocument, services: LikeC4Services): void;

package/dist/model/fqn-computation.js

@@ -0,0 +1,72 @@
+import { AsFqn, nonexhaustive } from "@likec4/core";
+import { AstUtils, CstUtils, GrammarUtils, MultiMap } from "langium";
+import { isDefined, isEmpty } from "remeda";
+import { ast, ElementOps } from "../ast.js";
+import { logError } from "../logger.js";
+import { getFqnElementRef } from "../utils/elementRef.js";
+const { findNodeForProperty } = GrammarUtils;
+const { toDocumentSegment } = CstUtils;
+const { getDocument } = AstUtils;
+function toAstNodeDescription(locator, entry, doc) {
+  const $cstNode = findNodeForProperty(entry.$cstNode, "name");
+  return {
+    documentUri: doc.uri,
+    name: entry.name,
+    ...entry.$cstNode && {
+      selectionSegment: toDocumentSegment(entry.$cstNode)
+    },
+    ...$cstNode && {
+      nameSegment: toDocumentSegment($cstNode)
+    },
+    path: locator.getAstNodePath(entry),
+    type: ast.Element
+  };
+}
+export function computeDocumentFqn(document, services) {
+  const c4fqnIndex = document.c4fqnIndex = new MultiMap();
+  const elements = document.parseResult.value.models.flatMap((m) => m.elements);
+  if (elements.length === 0) {
+    return;
+  }
+  const locator = services.workspace.AstNodeLocator;
+  const traverseStack = elements.map((el) => [el, null]);
+  let pair;
+  while (pair = traverseStack.shift()) {
+    try {
+      const [el, parent] = pair;
+      if (ast.isRelation(el)) {
+        continue;
+      }
+      if (ast.isExtendElement(el)) {
+        if (isDefined(el.body) && !isEmpty(el.body.elements)) {
+          const fqn = getFqnElementRef(el.element);
+          for (const child of el.body.elements) {
+            if (!ast.isRelation(child)) {
+              traverseStack.push([child, fqn]);
+            }
+          }
+        }
+        continue;
+      }
+      if (ast.isElement(el)) {
+        const fqn = AsFqn(el.name, parent);
+        c4fqnIndex.add(fqn, {
+          ...toAstNodeDescription(locator, el, document),
+          fqn
+        });
+        ElementOps.writeId(el, fqn);
+        if (isDefined(el.body) && !isEmpty(el.body.elements)) {
+          for (const child of el.body.elements) {
+            if (!ast.isRelation(child)) {
+              traverseStack.push([child, fqn]);
+            }
+          }
+        }
+        continue;
+      }
+      nonexhaustive(el);
+    } catch (e) {
+      logError(e);
+    }
+  }
+}

package/dist/model/fqn-index.d.ts

@@ -0,0 +1,25 @@
+import type { Fqn } from '@likec4/core';
+import type { AstNodeDescription, LangiumDocuments, Stream } from 'langium';
+import type { ast, FqnIndexedDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+export interface FqnIndexEntry {
+    fqn: Fqn;
+    name: string;
+    el: ast.Element;
+    doc: FqnIndexedDocument;
+    path: string;
+}
+export declare class FqnIndex {
+    private services;
+    protected langiumDocuments: LangiumDocuments;
+    constructor(services: LikeC4Services);
+    get documents(): any;
+    private entries;
+    getFqn(el: ast.Element): Fqn | null;
+    byFqn(fqn: Fqn): Stream<AstNodeDescription>;
+    directChildrenOf(parent: Fqn): Stream<AstNodeDescription>;
+    /**
+     * Returns descedant elements with unique names in the scope
+     */
+    uniqueDescedants(parent: Fqn): Stream<AstNodeDescription>;
+}