@likec4/language-server 1.21.1 → 1.22.1

package/src/lsp/HoverProvider.ts

@@ -1,92 +0,0 @@
-import { type AstNode, AstUtils, type MaybePromise } from 'langium'
-import { AstNodeHoverProvider } from 'langium/lsp'
-import { isTruthy } from 'remeda'
-import stripIndent from 'strip-indent'
-import type { Hover } from 'vscode-languageserver-types'
-import { ast } from '../ast'
-import type { LikeC4ModelLocator, LikeC4ModelParser } from '../model'
-import type { LikeC4Services } from '../module'
-
-export class LikeC4HoverProvider extends AstNodeHoverProvider {
-  private parser: LikeC4ModelParser
-  private locator: LikeC4ModelLocator
-
-  constructor(services: LikeC4Services) {
-    super(services)
-    this.parser = services.likec4.ModelParser
-    this.locator = services.likec4.ModelLocator
-  }
-
-  protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined> {
-    if (ast.isTag(node)) {
-      return {
-        contents: {
-          kind: 'markdown',
-          value: stripIndent(`
-            tag: \`${node.name}\`
-          `)
-        }
-      }
-    }
-
-    if (ast.isDeploymentNode(node)) {
-      const doc = AstUtils.getDocument(node)
-      const el = this.parser.forDocument(doc).parseDeploymentNode(node)
-      const lines = [el.id as string + '  ']
-      if (el.title !== node.name) {
-        lines.push(`### ${el.title}`)
-      }
-      lines.push('Deployment: `' + el.kind + '` ')
-      return {
-        contents: {
-          kind: 'markdown',
-          value: lines.join('\n')
-        }
-      }
-    }
-
-    if (ast.isDeployedInstance(node)) {
-      const doc = AstUtils.getDocument(node)
-      const instance = this.parser.forDocument(doc).parseDeployedInstance(node)
-      const el = this.locator.getParsedElement(instance.element)
-      const lines = [instance.id + '  ', `instance of \`${instance.element}\``]
-      if (el) {
-        lines.push(`### ${el.title}`, 'Element: `' + el.kind + '` ')
-      }
-      return {
-        contents: {
-          kind: 'markdown',
-          value: lines.join('\n')
-        }
-      }
-    }
-
-    // if (ast.isElementKind(node)) {
-    //   const spec = this.specIndex.get(node.name as ElementKind)
-    //   return {
-    //     contents: {
-    //       kind: 'markdown',
-    //       value: stripIndent(`
-    //         kind: **${spec.id}**
-    //         shape: ${spec.style.shape}
-    //       `)
-    //     }
-    //   }
-    // }
-
-    if (ast.isElement(node)) {
-      const el = this.locator.getParsedElement(node)
-      if (!el) {
-        return
-      }
-      const lines = [el.id, `### ${el.title}`, 'Element: `' + el.kind + '` ']
-      return {
-        contents: {
-          kind: 'markdown',
-          value: lines.join('\n')
-        }
-      }
-    }
-    return
-  }
-}

package/src/lsp/RenameProvider.ts

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

package/src/lsp/SemanticTokenProvider.ts

@@ -1,383 +0,0 @@
-import type { AstNode } from 'langium'
-import { type SemanticTokenAcceptor, AbstractSemanticTokenProvider } from 'langium/lsp'
-import { isTruthy } from 'remeda'
-import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver-types'
-import { ast } from '../ast'
-
-export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  protected override highlightElement(
-    node: AstNode,
-    acceptor: SemanticTokenAcceptor,
-  ): void | undefined | 'prune' {
-    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.isWhereRelationParticipantKind(node) || ast.isWhereRelationParticipantTag(node))) {
-      acceptor({
-        node,
-        property: 'participant',
-        type: SemanticTokenTypes.keyword,
-      })
-    }
-    if (ast.isElementKindExpression(node) && isTruthy(node.kind)) {
-      acceptor({
-        node,
-        property: 'kind',
-        type: SemanticTokenTypes.type,
-        modifier: [SemanticTokenModifiers.definition],
-      })
-      return 'prune'
-    }
-    if (
-      ast.isGlobalStyleGroup(node)
-      || ast.isGlobalStyle(node)
-    ) {
-      acceptor({
-        node,
-        property: 'id',
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly,
-        ],
-      })
-      return
-    }
-    if (ast.isViewRuleGlobalStyle(node)) {
-      acceptor({
-        node,
-        property: 'style',
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly,
-        ],
-      })
-      return
-    }
-    if (
-      ast.isGlobalPredicateGroup(node)
-      || ast.isGlobalDynamicPredicateGroup(node)
-    ) {
-      acceptor({
-        node,
-        property: 'name',
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly,
-        ],
-      })
-      return
-    }
-    if (ast.isViewRuleGlobalPredicateRef(node)) {
-      acceptor({
-        node,
-        property: 'predicate',
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly,
-        ],
-      })
-      return
-    }
-    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' : undefined
-    }
-    if (ast.isElementRef(node) || ast.isStrictFqnElementRef(node)) {
-      acceptor({
-        node,
-        property: 'el',
-        type: node.parent ? SemanticTokenTypes.property : SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly,
-        ],
-      })
-      return !node.parent ? 'prune' : undefined
-    }
-    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)
-      || ast.isSizeProperty(node)
-    ) {
-      acceptor({
-        node,
-        property: 'key',
-        type: SemanticTokenTypes.property,
-      })
-      if ('value' in node) {
-        acceptor({
-          node,
-          property: 'value',
-          type: SemanticTokenTypes.enum,
-        })
-      }
-      return 'prune'
-    }
-  }
-
-  private highlightNameAndKind(node: ast.Element | ast.DeploymentNode, acceptor: SemanticTokenAcceptor) {
-    acceptor({
-      node,
-      property: 'name',
-      type: SemanticTokenTypes.variable,
-      modifier: [
-        SemanticTokenModifiers.declaration,
-        SemanticTokenModifiers.readonly,
-      ],
-    })
-    acceptor({
-      node,
-      property: 'kind',
-      type: SemanticTokenTypes.keyword,
-      modifier: [],
-    })
-  }
-
-  private highlightView(node: ast.LikeC4View, acceptor: SemanticTokenAcceptor) {
-    if (node.name) {
-      acceptor({
-        node,
-        property: 'name',
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.declaration,
-          SemanticTokenModifiers.readonly,
-          'local',
-        ],
-      })
-    }
-  }
-}

package/src/lsp/index.ts

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

package/src/model/deployments-index.ts

@@ -1,209 +0,0 @@
-import type { Fqn } from '@likec4/core'
-import type { DocumentCache, LangiumDocuments, Stream } from 'langium'
-import { AstUtils, DocumentState, MultiMap } from 'langium'
-import { forEachObj, groupBy, isTruthy, pipe, prop } from 'remeda'
-import {
-  type DeploymentAstNodeDescription,
-  type LikeC4LangiumDocument,
-  ast,
-  ElementOps,
-  isLikeC4LangiumDocument,
-} from '../ast'
-import { logWarnError } from '../logger'
-import type { LikeC4Services } from '../module'
-import type { LikeC4NameProvider } from '../references'
-
-export class DeploymentsIndex {
-  protected Names: LikeC4NameProvider
-  protected langiumDocuments: LangiumDocuments
-  protected documentCache: DocumentCache<string, DocumentDeploymentsIndex>
-
-  constructor(private services: LikeC4Services) {
-    this.Names = services.references.NameProvider
-    this.langiumDocuments = services.shared.workspace.LangiumDocuments
-    this.documentCache = services.DocumentCache
-  }
-
-  private documents() {
-    return this.langiumDocuments.all.filter((d): d is LikeC4LangiumDocument =>
-      isLikeC4LangiumDocument(d) && d.state >= DocumentState.IndexedContent
-    )
-  }
-
-  public get(document: LikeC4LangiumDocument): DocumentDeploymentsIndex {
-    if (document.state < DocumentState.IndexedContent) {
-      logWarnError(`Document ${document.uri.path} is not indexed`)
-    }
-    return this.documentCache.get(document.uri, 'DeploymentsIndex', () => this.createDocumentIndex(document))
-  }
-  /**
-   * Nested elements (nodes/artifacts) of the node
-   * @param nodeName Name of the deployment node
-   * @returns Stream of artifacts
-   */
-  public nested(node: ast.DeploymentNode): Stream<DeploymentAstNodeDescription> {
-    const fqnName = this.getFqn(node)
-    return this.documents().flatMap(doc => this.get(doc).nested(fqnName))
-  }
-
-  public byFqn(fqnName: string): Stream<DeploymentAstNodeDescription> {
-    return this.documents().flatMap(doc => this.get(doc).byFqn(fqnName))
-  }
-
-  public getFqn(node: ast.DeploymentElement): Fqn {
-    let id = ElementOps.readId(node)
-    if (isTruthy(id)) {
-      return id
-    }
-    const fqn = [
-      this.Names.getNameStrict(node),
-    ]
-    let _node = node
-    let parentNode: ast.DeploymentNode | undefined
-    while ((parentNode = AstUtils.getContainerOfType(_node.$container, ast.isDeploymentNode))) {
-      fqn.push(this.Names.getNameStrict(parentNode))
-      _node = parentNode
-    }
-    id = fqn.reduceRight((acc, cur) => `${acc}.${cur}`) as Fqn
-    ElementOps.writeId(node, id)
-    return id
-  }
-
-  public createDocumentIndex(document: LikeC4LangiumDocument): DocumentDeploymentsIndex {
-    const rootNodes = document.parseResult.value.deployments.flatMap(m => m.elements)
-    if (rootNodes.length === 0) {
-      return DocumentDeploymentsIndex.EMPTY
-    }
-    const _root = new Array<DeploymentAstNodeDescription>()
-    const _nested = new MultiMap<string, DeploymentAstNodeDescription>()
-    const _byfqn = new MultiMap<string, DeploymentAstNodeDescription>()
-    const Names = this.Names
-    const Descriptions = this.services.workspace.AstNodeDescriptionProvider
-
-    const createAndSaveDescription = (
-      props: { node: ast.DeploymentNode | ast.DeployedInstance; name: string; fqn: string },
-    ) => {
-      const desc = {
-        ...Descriptions.createDescription(props.node, props.name, document),
-        fqn: props.fqn,
-      }
-      ElementOps.writeId(props.node, props.fqn as Fqn)
-      _byfqn.add(props.fqn, desc)
-      return desc
-    }
-
-    const traverseNode = (
-      container: ast.DeploymentNode,
-      parentFqn: string,
-    ): readonly DeploymentAstNodeDescription[] => {
-      const _descedants = [] as DeploymentAstNodeDescription[]
-      const children = container.body?.elements
-      if (!children || children.length === 0) {
-        return []
-      }
-      const directChildren = new Set<string>()
-      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)
-  }
-}
-
-/**
- * Index of deployment elements in the document
- */
-export class DocumentDeploymentsIndex {
-  static readonly EMPTY = new DocumentDeploymentsIndex([], new MultiMap(), new MultiMap())
-
-  constructor(
-    private _rootNodes: Array<DeploymentAstNodeDescription>,
-    /**
-     * Nested of a deployment node
-     */
-    private _nested: MultiMap<string, DeploymentAstNodeDescription>,
-    /**
-     * All elements by FQN
-     */
-    private _byfqn: MultiMap<string, DeploymentAstNodeDescription>,
-  ) {}
-
-  public rootNodes(): readonly DeploymentAstNodeDescription[] {
-    return this._rootNodes
-  }
-
-  public byFqn(fqnName: string): readonly DeploymentAstNodeDescription[] {
-    return this._byfqn.get(fqnName)
-  }
-
-  /**
-   * Returns artifacts of a deployment node
-   * @param nodeName Name of the deployment node
-   * @returns Stream of artifacts
-   */
-  public nested(nodeName: string): readonly DeploymentAstNodeDescription[] {
-    return this._nested.get(nodeName)
-  }
-
-  /**
-   * Returns all deployment elements in the document,
-   * with unique combination "type and name"
-   */
-  public unique(): readonly DeploymentAstNodeDescription[] {
-    const result = [] as DeploymentAstNodeDescription[]
-    pipe(
-      [...this._byfqn.values()],
-      groupBy(prop('name')),
-      forEachObj(descs => {
-        if (descs.length === 1) {
-          result.push(descs[0])
-        }
-      }),
-    )
-    return result
-  }
-}