@likec4/language-server 1.17.1 → 1.19.0

package/src/lsp/SemanticTokenProvider.ts

@@ -10,6 +10,26 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
     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,
@@ -70,6 +90,20 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       })
       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,
@@ -108,6 +142,18 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       })
       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.isFqnElementRef(node)) {
       acceptor({
         node,
@@ -137,7 +183,10 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       })
       return
     }
-    if (ast.isSpecificationElementKind(node) || ast.isSpecificationRelationshipKind(node)) {
+    if (
+      ast.isSpecificationElementKind(node) || ast.isSpecificationRelationshipKind(node)
+      || ast.isSpecificationDeploymentNodeKind(node)
+    ) {
       acceptor({
         node,
         property: 'kind',
@@ -196,30 +245,13 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         property: 'key',
         type: SemanticTokenTypes.property
       })
-      if (ast.isIconProperty(node)) {
-        if (node.libicon) {
-          acceptor({
-            node,
-            property: 'libicon',
-            type: SemanticTokenTypes.enum,
-            modifier: [SemanticTokenModifiers.defaultLibrary]
-          })
-        } else {
-          if (node.value === 'none') {
-            acceptor({
-              node,
-              property: 'value',
-              type: SemanticTokenTypes.enum,
-              modifier: [SemanticTokenModifiers.defaultLibrary]
-            })
-          } else {
-            acceptor({
-              node,
-              property: 'value',
-              type: SemanticTokenTypes.string
-            })
-          }
-        }
+      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) {
@@ -252,15 +284,9 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       }
       return 'prune'
     }
-    if (ast.isElement(node)) {
-      return this.highlightAstElement(node, acceptor)
-    }
-    if (ast.isLikeC4View(node)) {
-      return this.highlightView(node, acceptor)
-    }
   }
 
-  private highlightAstElement(node: ast.Element, acceptor: SemanticTokenAcceptor) {
+  private highlightNameAndKind(node: ast.Element | ast.DeploymentNode, acceptor: SemanticTokenAcceptor) {
     acceptor({
       node,
       property: 'name',

package/src/model/deployments-index.ts

@@ -0,0 +1,222 @@
+import type { Fqn } from '@likec4/core'
+import type { LangiumDocument, 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'
+
+const DeploymentsIndexKey = Symbol.for('DeploymentsIndex')
+
+type IndexedDocument = LangiumDocument & {
+  [DeploymentsIndexKey]?: DocumentDeploymentsIndex
+}
+
+export class DeploymentsIndex {
+  protected Names: LikeC4NameProvider
+  protected langiumDocuments: LangiumDocuments
+
+  constructor(private services: LikeC4Services) {
+    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 as IndexedDocument)[DeploymentsIndexKey]
+        }
+      },
+    )
+  }
+
+  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 (document as IndexedDocument)[DeploymentsIndexKey] ??= 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
+  }
+}

package/src/model/fqn-computation.ts

@@ -3,9 +3,9 @@ import type * as c4 from '@likec4/core'
 import { type AstNodeDescription, type AstNodeLocator, AstUtils, CstUtils, GrammarUtils, MultiMap } from 'langium'
 import { isDefined, isEmpty } from 'remeda'
 import { ast, ElementOps, type LikeC4LangiumDocument } from '../ast'
-import { getFqnElementRef } from '../elementRef'
 import { logError } from '../logger'
 import type { LikeC4Services } from '../module'
+import { getFqnElementRef } from '../utils/elementRef'
 
 const { findNodeForProperty } = GrammarUtils
 const { toDocumentSegment } = CstUtils

package/src/model/fqn-index.ts

@@ -6,7 +6,6 @@ import type { ast, DocFqnIndexAstNodeDescription, FqnIndexedDocument } from '../
 import { ElementOps, isFqnIndexedDocument, isLikeC4LangiumDocument } from '../ast'
 import { logger, logWarnError } from '../logger'
 import type { LikeC4Services } from '../module'
-import { printDocs } from '../utils/printDocs'
 import { computeDocumentFqn } from './fqn-computation'
 
 export interface FqnIndexEntry {

package/src/model/index.ts

@@ -1,3 +1,4 @@
+export * from './deployments-index'
 export * from './fqn-computation'
 export * from './fqn-index'
 export * from './model-builder'