@likec4/language-server 1.17.1 → 1.19.0

package/src/references/scope-computation.ts

@@ -6,21 +6,38 @@ import {
   MultiMap,
   type PrecomputedScopes
 } from 'langium'
-import { isNullish, isTruthy } from 'remeda'
+import { entries, filter, flatMap, forEach, forEachObj, groupBy, isNullish, isTruthy, pipe } from 'remeda'
 import type { CancellationToken } from 'vscode-languageserver'
 import { ast, type LikeC4LangiumDocument } from '../ast'
-import { logError } from '../logger'
+import { logError, logWarnError } from '../logger'
+import type { LikeC4Services } from '../module'
 
 type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody
+type DeploymentsContainer = ast.ModelDeployments | ast.DeploymentNodeBody
+
+function uniqueDescriptions(
+  descs: AstNodeDescription[]
+): AstNodeDescription[] {
+  return pipe(
+    descs,
+    groupBy(desc => `${desc.type}.${desc.name}`),
+    entries(),
+    flatMap(([_, descs]) => descs.length === 1 ? descs : [])
+  )
+}
 
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
+  constructor(services: LikeC4Services) {
+    super(services)
+  }
+
   override async computeExports(
     document: LikeC4LangiumDocument,
     _cancelToken?: CancellationToken
   ): Promise<AstNodeDescription[]> {
     const docExports: AstNodeDescription[] = []
     try {
-      const { specifications, models, views, globals, likec4lib } = document.parseResult.value
+      const { specifications, models, views, globals, likec4lib, deployments } = document.parseResult.value
 
       // Process library
       this.exportLibrary(likec4lib, docExports, document)
@@ -36,6 +53,8 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
 
       // Process global
       this.exportGlobals(globals, docExports, document)
+
+      this.exportDeployments(deployments, docExports, document)
     } catch (e) {
       logError(e)
     }
@@ -43,14 +62,15 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
   }
 
   private exportViews(
-    views: ast.ModelViews[] | undefined,
+    modelViews: ast.ModelViews[] | undefined,
     docExports: AstNodeDescription[],
     document: LikeC4LangiumDocument
   ) {
+    const views = modelViews?.flatMap(m => m.views)
     if (isNullish(views) || views.length === 0) {
       return
     }
-    for (const viewAst of views.flatMap(v => v.views)) {
+    for (const viewAst of views) {
       try {
         if (isTruthy(viewAst.name)) {
           docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document))
@@ -139,12 +159,14 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
       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(
@@ -188,21 +210,58 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
     }
   }
 
+  private exportDeployments(
+    modelDeployments: ast.ModelDeployments[] | undefined,
+    docExports: AstNodeDescription[],
+    document: LikeC4LangiumDocument
+  ) {
+    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)
+      }
+    }
+  }
+
   override computeLocalScopes(
     document: LikeC4LangiumDocument,
     _cancelToken?: CancellationToken
   ): Promise<PrecomputedScopes> {
     return new Promise(resolve => {
       const root = document.parseResult.value
+      const descendants = [] as AstNodeDescription[]
       const scopes = new MultiMap<AstNode, AstNodeDescription>()
+
       for (const model of root.models) {
         try {
-          const nested = this.processContainer(model, scopes, document)
-          scopes.addAll(root, nested.values())
+          descendants.push(
+            ...this.processContainer(model, scopes, document)
+          )
         } catch (e) {
           logError(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)
     })
   }
@@ -211,9 +270,10 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
     container: ElementsContainer,
     scopes: PrecomputedScopes,
     document: LikeC4LangiumDocument
-  ) {
+  ): AstNodeDescription[] {
     const localScope = new MultiMap<string, AstNodeDescription>()
-    const nestedScopes = new MultiMap<string, AstNodeDescription>()
+    const descedants = [] as AstNodeDescription[]
+
     for (const el of container.elements) {
       if (ast.isRelation(el)) {
         continue
@@ -231,25 +291,74 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
 
       if (subcontainer && subcontainer.elements.length > 0) {
         try {
-          const nested = this.processContainer(subcontainer, scopes, document)
-          for (const [nestedName, desc] of nested) {
-            nestedScopes.add(nestedName, desc)
-          }
+          descedants.push(
+            ...this.processContainer(subcontainer, scopes, document)
+          )
         } catch (e) {
-          logError(e)
+          logWarnError(e)
         }
       }
     }
 
-    if (nestedScopes.size > 0) {
-      for (const [name, descriptions] of nestedScopes.entriesGroupedByKey()) {
-        // If name is unique for current scope
-        if (!localScope.has(name) && descriptions.length === 1) {
-          localScope.add(name, descriptions[0]!)
+    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
+  }
+
+  protected processDeployments(
+    container: DeploymentsContainer,
+    scopes: PrecomputedScopes,
+    document: LikeC4LangiumDocument
+  ): AstNodeDescription[] {
+    const localnames = new Set<string>()
+    const descedants = [] as AstNodeDescription[]
+
+    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)
         }
       }
     }
-    scopes.addAll(container, localScope.values())
-    return localScope
+    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/src/references/scope-provider.ts

@@ -1,5 +1,5 @@
-import { invariant } from '@likec4/core'
 import type * as c4 from '@likec4/core'
+import { nonexhaustive } from '@likec4/core'
 import type { AstNode } from 'langium'
 import {
   type AstNodeDescription,
@@ -17,19 +17,21 @@ import {
   StreamScope
 } from 'langium'
 import { ast } from '../ast'
-import { elementRef, getFqnElementRef } from '../elementRef'
 import { logger } from '../logger'
-import type { FqnIndex } from '../model/fqn-index'
+import type { DeploymentsIndex, FqnIndex } from '../model'
 import type { LikeC4Services } from '../module'
+import { elementRef, getFqnElementRef } from '../utils/elementRef'
 
 const { getDocument } = AstUtils
 
 export class LikeC4ScopeProvider extends DefaultScopeProvider {
+  private deploymentsIndex: DeploymentsIndex
   private fqnIndex: FqnIndex
 
   constructor(services: LikeC4Services) {
     super(services)
     this.fqnIndex = services.likec4.FqnIndex
+    this.deploymentsIndex = services.likec4.DeploymentsIndex
   }
 
   private directChildrenOf(parent: c4.Fqn): Stream<AstNodeDescription> {
@@ -87,15 +89,20 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
   override getScope(context: ReferenceInfo): Scope {
     try {
       const referenceType = this.reflection.getReferenceType(context)
-      if (referenceType !== ast.Element) {
-        return this.getGlobalScope(referenceType)
-      }
       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)
+            return this.getGlobalScope(referenceType, context)
           }
           return new StreamScope(this.directChildrenOf(getFqnElementRef(parent)))
         }
@@ -119,7 +126,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         return this.computeScope(context)
       } catch (e) {
         logger.warn(e)
-        return this.getGlobalScope(referenceType)
+        return this.getGlobalScope(referenceType, context)
       }
     } catch (e) {
       logger.warn(e)
@@ -127,42 +134,68 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
     }
   }
 
-  protected computeScope(context: ReferenceInfo) {
-    const referenceType = this.reflection.getReferenceType(context)
-    // computeScope is called only for elements
-    invariant(referenceType === ast.Element, 'Invalid reference type')
+  protected getScopeForFqnRef(container: ast.FqnRef, context: ReferenceInfo) {
+    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)
+  }
+
+  protected computeScope(context: ReferenceInfo, referenceType = this.reflection.getReferenceType(context)) {
+    const isElementReference = this.reflection.isSubtype(referenceType, ast.Element)
+
     const scopes: Stream<AstNodeDescription>[] = []
     const doc = getDocument(context.container)
     const precomputed = doc.precomputedScopes
 
-    if (precomputed) {
-      const byReferenceType = (desc: AstNodeDescription) => this.reflection.isSubtype(desc.type, referenceType)
-      let container: AstNode | undefined = context.container
-      while (container) {
-        const elements = precomputed.get(container).filter(byReferenceType)
-        if (elements.length > 0) {
-          scopes.push(stream(elements))
-        }
+    if (!precomputed) {
+      return this.getGlobalScope(referenceType, context)
+    }
 
-        if (ast.isExtendElementBody(container)) {
-          scopes.push(this.scopeExtendElement(container.$container))
-        }
-        if (ast.isElementViewBody(container)) {
-          scopes.push(this.scopeElementView(container.$container))
-        }
-        container = container.$container
+    const byReferenceType = (desc: AstNodeDescription) => this.reflection.isSubtype(desc.type, referenceType)
+    let container: AstNode | undefined = 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))
-  }
-
-  /**
-   * Create a global scope filtered for the given reference type.
-   */
-  protected override getGlobalScope(referenceType: string): Scope {
-    return new StreamScope(this.indexManager.allElements(referenceType))
+    }, this.getGlobalScope(referenceType, context))
   }
 }

package/src/shared/NodeKindProvider.ts

@@ -16,13 +16,17 @@ export class NodeKindProvider implements LspNodeKindProvider {
     switch (true) {
       case hasType(
         ast.Element,
-        ast.ExtendElement
+        ast.ExtendElement,
+        ast.DeploymentNode,
+        ast.DeployedInstance
       ):
         return SymbolKind.Constructor
 
       case hasType(
         ast.Model,
         ast.ModelViews,
+        ast.ModelDeployments,
+        ast.Globals,
         ast.SpecificationRule
       ):
         return SymbolKind.Namespace
@@ -46,7 +50,9 @@ export class NodeKindProvider implements LspNodeKindProvider {
 
       case hasType(
         ast.ElementKind,
-        ast.SpecificationElementKind
+        ast.DeploymentNodeKind,
+        ast.SpecificationElementKind,
+        ast.SpecificationDeploymentNodeKind
       ):
         return SymbolKind.TypeParameter
     }
@@ -66,6 +72,8 @@ export class NodeKindProvider implements LspNodeKindProvider {
 
       case hasType(
         ast.Element,
+        ast.DeploymentNode,
+        ast.DeployedInstance,
         ast.ExtendElement
       ):
         return CompletionItemKind.Constructor
@@ -73,6 +81,8 @@ export class NodeKindProvider implements LspNodeKindProvider {
       case hasType(
         ast.Model,
         ast.ModelViews,
+        ast.ModelDeployments,
+        ast.Globals,
         ast.SpecificationRule
       ):
         return CompletionItemKind.Module
@@ -98,7 +108,9 @@ export class NodeKindProvider implements LspNodeKindProvider {
 
       case hasType(
         ast.ElementKind,
-        ast.SpecificationElementKind
+        ast.SpecificationElementKind,
+        ast.DeploymentNodeKind,
+        ast.SpecificationDeploymentNodeKind
       ):
         return CompletionItemKind.TypeParameter
 

package/src/{elementRef.ts → utils/elementRef.ts}

@@ -1,5 +1,5 @@
 import type * as c4 from '@likec4/core'
-import type { ast } from './ast'
+import type { ast } from '../ast'
 /**
  * Returns referenced AST Element
  */

package/src/utils/fqnRef.ts

@@ -0,0 +1,56 @@
+import { AstUtils } from 'langium'
+import { isNullish } from 'remeda'
+import { ast } from '../ast'
+
+export function instanceRef(deploymentRef: ast.FqnRef): ast.DeployedInstance | null {
+  let referenceable
+  while ((referenceable = deploymentRef.value?.ref)) {
+    if (ast.isDeploymentNode(referenceable)) {
+      return null
+    }
+    if (ast.isDeployedInstance(referenceable)) {
+      return referenceable
+    }
+    if (isNullish(deploymentRef.parent)) {
+      return null
+    }
+    deploymentRef = deploymentRef.parent
+  }
+  return null
+}
+
+export function deploymentNodeRef(deploymentRef: ast.FqnRef): ast.DeploymentNode | null {
+  let referenceable = deploymentRef.value.ref ?? null
+  if (!referenceable || ast.isDeploymentNode(referenceable)) {
+    return referenceable
+  }
+  const artifact = instanceRef(deploymentRef)
+  // Because path in deploymentRef may be omitted,
+  // we find artifact first and then its container
+  return artifact ? AstUtils.getContainerOfType(artifact, ast.isDeploymentNode) ?? null : null
+}
+
+export function isReferenceToLogicalModel(node: ast.FqnRef) {
+  // iterate up the root parent
+  while (node.parent) {
+    node = node.parent
+  }
+  return ast.isElement(node.value.ref)
+}
+
+/**
+ * Returns true if node references deployment model
+ */
+export function isReferenceToDeploymentModel(node: ast.FqnRef) {
+  let referenceable
+  while ((referenceable = node.value?.ref)) {
+    if (ast.isDeploymentElement(referenceable)) {
+      return true
+    }
+    if (isNullish(node.parent)) {
+      return false
+    }
+    node = node.parent
+  }
+  return false
+}

package/src/utils/stringHash.ts

@@ -1,6 +1,6 @@
-import hash from 'string-hash'
+import { stringHash as hash } from '@likec4/core'
 
 export function stringHash(...str: [string, ...string[]]): string {
   var s = str.length > 1 ? str.join(':::') : str[0]
-  return hash(s).toString(36)
+  return hash(s)
 }

package/src/validation/_shared.ts

@@ -1,4 +1,5 @@
-import { type AstNode, interruptAndCheck, type ValidationAcceptor, type ValidationCheck } from 'langium'
+import { type AstNode, type ValidationAcceptor, type ValidationCheck } from 'langium'
+import { isPromise } from 'remeda'
 import type { CancellationToken } from 'vscode-jsonrpc'
 import { logWarnError } from '../logger'
 
@@ -13,11 +14,11 @@ export const RESERVED_WORDS = [
 
 export function tryOrLog<T extends AstNode>(fn: ValidationCheck<T>): ValidationCheck<T> {
   return async (node: T, accept: ValidationAcceptor, cancelToken: CancellationToken) => {
-    if (cancelToken) {
-      await interruptAndCheck(cancelToken)
-    }
     try {
-      await fn(node, accept, cancelToken)
+      const result = fn(node, accept, cancelToken)
+      if (isPromise(result)) {
+        await result
+      }
     } catch (e) {
       logWarnError(e)
     }

package/src/validation/deployment-checks.ts

@@ -0,0 +1,131 @@
+import { FqnRef, isSameHierarchy, nonNullable } from '@likec4/core'
+import { type ValidationCheck, AstUtils } from 'langium'
+import { ast } from '../ast'
+import type { LikeC4Services } from '../module'
+import type { LikeC4NameProvider } from '../references'
+import { RESERVED_WORDS, tryOrLog } from './_shared'
+
+const { getDocument } = AstUtils
+
+export const deploymentNodeChecks = (services: LikeC4Services): ValidationCheck<ast.DeploymentNode> => {
+  const DeploymentsIndex = services.likec4.DeploymentsIndex
+  const Names = services.references.NameProvider
+  return tryOrLog((el, accept) => {
+    const nodeName = Names.getName(el)
+    if (!nodeName) {
+      accept('error', 'DeploymentNode must be named', {
+        node: el,
+      })
+      return
+    }
+    const range = nonNullable(Names.getNameNode(el), 'name CstNode not found').range
+
+    if (RESERVED_WORDS.includes(nodeName)) {
+      accept('error', `Reserved word: ${nodeName}`, {
+        node: el,
+        range,
+      })
+    }
+    const fqnName = DeploymentsIndex.getFqn(el)
+
+    const withSameName = DeploymentsIndex.byFqn(fqnName).limit(2).toArray()
+    if (withSameName.length > 1) {
+      accept(
+        'error',
+        `Duplicate node name "${fqnName}"`,
+        {
+          node: el,
+          range,
+        },
+      )
+    }
+  })
+}
+
+export const deployedInstanceChecks = (services: LikeC4Services): ValidationCheck<ast.DeployedInstance> => {
+  const DeploymentsIndex = services.likec4.DeploymentsIndex
+  const Names = services.references.NameProvider as LikeC4NameProvider
+  // const Locator = services.workspace.AstNodeLocator
+  return tryOrLog((el, accept) => {
+    const artifactName = Names.getName(el)
+    if (!artifactName) {
+      accept('error', 'Deployed instance must be named, unique inside node', {
+        node: el,
+      })
+      return
+    }
+    const range = nonNullable(Names.getNameNode(el), 'name CstNode not found').range
+
+    if (RESERVED_WORDS.includes(artifactName)) {
+      accept('error', `Reserved word: ${artifactName}`, {
+        node: el,
+        range,
+      })
+    }
+
+    const fqnName = DeploymentsIndex.getFqn(el)
+
+    const withSameName = DeploymentsIndex.byFqn(fqnName).limit(2).toArray()
+    if (withSameName.length > 1) {
+      accept(
+        'error',
+        `Duplicate instance name "${fqnName}"`,
+        {
+          node: el,
+          range,
+        },
+      )
+    }
+  })
+}
+
+export const deploymentRelationChecks = (services: LikeC4Services): ValidationCheck<ast.DeploymentRelation> => {
+  const ModelParser = services.likec4.ModelParser
+  return tryOrLog((el, accept) => {
+    const source = el.source?.value?.ref
+    if (!source) {
+      let sourceCstText = el.source?.$cstNode?.text ?? ''
+      accept('error', `DeploymentRelation source '${sourceCstText}' not resolved`, {
+        node: el,
+        property: 'source',
+      })
+      return
+    }
+    const target = el.target?.value?.ref
+    if (!target) {
+      let targetCstText = el.target?.$cstNode?.text ?? ''
+      accept('error', `DeploymentRelation target '${targetCstText}' not resolved`, {
+        node: el,
+        property: 'target',
+      })
+      return
+    }
+
+    const doc = getDocument(el)
+    const parser = ModelParser.forDocument(doc)
+
+    const sourceFqnRef = parser.parseFqnRef(el.source)
+    if (FqnRef.isModelRef(sourceFqnRef)) {
+      accept('error', 'DeploymentRelation must refer deployment element', {
+        node: el,
+        property: 'source',
+      })
+      return
+    }
+
+    const targetFqnRef = parser.parseFqnRef(el.target)
+    if (FqnRef.isModelRef(targetFqnRef)) {
+      accept('error', 'DeploymentRelation must refer deployment element', {
+        node: el,
+        property: 'target',
+      })
+      return
+    }
+
+    if (isSameHierarchy(sourceFqnRef.deployment, targetFqnRef.deployment)) {
+      accept('error', 'Invalid parent-child relationship', {
+        node: el,
+      })
+    }
+  })
+}