@likec4/language-server 1.4.0 → 1.6.0

package/src/references/scope-computation.ts

@@ -6,7 +6,7 @@ import {
   MultiMap,
   type PrecomputedScopes
 } from 'langium'
-import { isTruthy } from 'remeda'
+import { isNullish, isTruthy } from 'remeda'
 import type { CancellationToken } from 'vscode-languageserver'
 import { ast, type LikeC4LangiumDocument } from '../ast'
 import { logError } from '../logger'
@@ -20,77 +20,130 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
   ): Promise<AstNodeDescription[]> {
     const docExports: AstNodeDescription[] = []
     try {
-      const { specifications, models, views } = document.parseResult.value
+      const { specifications, models, views, likec4lib } = document.parseResult.value
+
+      // Process library
+      this.exportLibrary(likec4lib, docExports, document)
 
       // Process specification
-      for (
-        const spec of specifications.flatMap(s => [
-          ...s.elements,
-          ...s.relationships,
-          ...s.tags
-        ])
-      ) {
-        try {
-          switch (true) {
-            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
-            }
-            // Thow error if not exhaustive
-            default:
-              nonexhaustive(spec)
-          }
-        } catch (e) {
-          logError(e)
+      this.exportSpecification(specifications, docExports, document)
+
+      // Process models
+      this.exportModel(models, docExports, document)
+
+      // Process views
+      this.exportViews(views, docExports, document)
+    } catch (e) {
+      logError(e)
+    }
+    return docExports
+  }
+
+  private exportViews(
+    views: ast.ModelViews[] | undefined,
+    docExports: AstNodeDescription[],
+    document: LikeC4LangiumDocument
+  ) {
+    if (isNullish(views) || views.length === 0) {
+      return
+    }
+    for (const viewAst of views.flatMap(v => v.views)) {
+      try {
+        if (isTruthy(viewAst.name)) {
+          docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document))
         }
+      } catch (e) {
+        logError(e)
       }
+    }
+  }
 
-      // Process models
-      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) {
-          logError(e)
+  private exportModel(
+    models: ast.Model[] | undefined,
+    docExports: AstNodeDescription[],
+    document: LikeC4LangiumDocument
+  ) {
+    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) {
+        logError(e)
       }
+    }
+  }
 
-      // Process views
-      for (const viewAst of views.flatMap(v => v.views)) {
-        try {
-          if (isTruthy(viewAst.name)) {
-            docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document))
+  private exportLibrary(
+    likec4lib: ast.LikeC4Lib[] | undefined,
+    docExports: AstNodeDescription[],
+    document: LikeC4LangiumDocument
+  ) {
+    if (isNullish(likec4lib) || likec4lib.length === 0) {
+      return
+    }
+    for (const iconAst of likec4lib.flatMap(l => l.icons)) {
+      try {
+        docExports.push(this.descriptions.createDescription(iconAst, iconAst.name, document))
+      } catch (e) {
+        logError(e)
+      }
+    }
+  }
+
+  private exportSpecification(
+    specifications: ast.SpecificationRule[] | undefined,
+    docExports: AstNodeDescription[],
+    document: LikeC4LangiumDocument
+  ) {
+    if (isNullish(specifications) || specifications.length === 0) {
+      return
+    }
+    for (
+      const spec of specifications.flatMap(s => [
+        ...s.elements,
+        ...s.relationships,
+        ...s.tags
+      ])
+    ) {
+      try {
+        switch (true) {
+          case ast.isSpecificationElementKind(spec): {
+            if (isTruthy(spec.kind.name)) {
+              docExports.push(
+                this.descriptions.createDescription(spec.kind, spec.kind.name, document)
+              )
+            }
+            continue
           }
-        } catch (e) {
-          logError(e)
+          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
+          }
+          // Thow error if not exhaustive
+          default:
+            nonexhaustive(spec)
         }
+      } catch (e) {
+        logError(e)
       }
-    } catch (e) {
-      logError(e)
     }
-    return docExports
   }
 
   override computeLocalScopes(

package/src/references/scope-provider.ts

@@ -3,12 +3,10 @@ import type { AstNode } from 'langium'
 import {
   type AstNodeDescription,
   AstUtils,
-  CstUtils,
   DefaultScopeProvider,
   DONE_RESULT,
   EMPTY_SCOPE,
   EMPTY_STREAM,
-  GrammarUtils,
   type ReferenceInfo,
   type Scope,
   type Stream,
@@ -19,29 +17,11 @@ import {
 import { ast } from '../ast'
 import { elementRef, getFqnElementRef } from '../elementRef'
 import { logger } from '../logger'
-import type { FqnIndex, FqnIndexEntry } from '../model/fqn-index'
+import type { FqnIndex } from '../model/fqn-index'
 import type { LikeC4Services } from '../module'
 
-const { findNodeForProperty } = GrammarUtils
-const { toDocumentSegment } = CstUtils
 const { getDocument } = AstUtils
 
-function toAstNodeDescription(entry: FqnIndexEntry): AstNodeDescription {
-  const $cstNode = findNodeForProperty(entry.el.$cstNode, 'name')
-  return {
-    documentUri: entry.doc.uri,
-    name: entry.name,
-    ...(entry.el.$cstNode && {
-      selectionSegment: toDocumentSegment(entry.el.$cstNode)
-    }),
-    ...($cstNode && {
-      nameSegment: toDocumentSegment($cstNode)
-    }),
-    path: entry.path,
-    type: ast.Element
-  }
-}
-
 export class LikeC4ScopeProvider extends DefaultScopeProvider {
   private fqnIndex: FqnIndex
 
@@ -51,7 +31,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
   }
 
   private directChildrenOf(parent: c4.Fqn): Stream<AstNodeDescription> {
-    return this.fqnIndex.directChildrenOf(parent).map(toAstNodeDescription)
+    return this.fqnIndex.directChildrenOf(parent)
   }
 
   // we need lazy resolving here
@@ -61,7 +41,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         const element = of()
         const fqn = element && this.fqnIndex.getFqn(element)
         if (fqn) {
-          return this.fqnIndex.uniqueDescedants(fqn).map(toAstNodeDescription).iterator()
+          return this.fqnIndex.uniqueDescedants(fqn).iterator()
         }
         return null
       },

package/src/shared/NodeKindProvider.ts

@@ -25,6 +25,7 @@ export class NodeKindProvider implements LspNodeKindProvider {
         return SymbolKind.Class
       }
       case (ast.isTag(node) || hasType(ast.Tag))
+        || (ast.isLibIcon(node) || hasType(ast.LibIcon))
         || (ast.isSpecificationTag(node) || hasType(ast.SpecificationTag)): {
         return SymbolKind.EnumMember
       }

package/src/shared/WorkspaceManager.ts

@@ -1,21 +1,30 @@
 import { hasAtLeast, invariant } from '@likec4/core'
-import type { LangiumDocument } from 'langium'
+import type { LangiumDocument, LangiumDocumentFactory } from 'langium'
 import { DefaultWorkspaceManager } from 'langium'
+import type { LangiumSharedServices } from 'langium/lsp'
 import type { WorkspaceFolder } from 'vscode-languageserver'
 import { URI } from 'vscode-uri'
+import * as BuiltIn from '../likec4lib'
 
 export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+  private documentFactory: LangiumDocumentFactory
+
+  constructor(services: LangiumSharedServices) {
+    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.
    */
-  protected override loadAdditionalDocuments(
-    _folders: WorkspaceFolder[],
-    _collector: (document: LangiumDocument) => void
+  protected override async loadAdditionalDocuments(
+    folders: WorkspaceFolder[],
+    collector: (document: LangiumDocument) => void
   ): Promise<void> {
-    // collector(this.documentFactory.fromString(builtin.specification.document, URI.parse(builtin.specification.uri)))
-    return Promise.resolve()
+    await super.loadAdditionalDocuments(folders, collector)
+    collector(this.documentFactory.fromString(BuiltIn.Content, URI.parse(BuiltIn.Uri)))
   }
 
   public workspace() {

package/src/validation/dynamic-view-rule.ts

@@ -1,35 +1,28 @@
 import { nonexhaustive } from '@likec4/core'
 import type { ValidationCheck } from 'langium'
 import { ast } from '../ast'
-import { logError } from '../logger'
 import type { LikeC4Services } from '../module'
 
-export const dynamicViewRulePredicate = (_services: LikeC4Services): ValidationCheck<ast.DynamicViewRulePredicate> => {
-  return (el, accept) => {
-    try {
-      for (const expr of el.expressions) {
-        switch (true) {
-          case ast.isElementRef(expr):
-          case ast.isDescedantsExpr(expr):
-          case ast.isCustomElementExpr(expr):
-          case ast.isExpandElementExpr(expr):
-            return
-          case ast.isRelationExpr(expr):
-          case ast.isInOutExpr(expr):
-          case ast.isIncomingExpr(expr):
-          case ast.isOutgoingExpr(expr):
-          case ast.isElementKindExpr(expr):
-          case ast.isElementTagExpr(expr):
-          case ast.isWildcardExpr(expr):
-            return accept('warning', `Expression is not supported by dynamic views`, {
-              node: expr
-            })
-          default:
-            nonexhaustive(expr)
-        }
+export const dynamicViewRulePredicate = (
+  _services: LikeC4Services
+): ValidationCheck<ast.DynamicViewRulePredicateIterator> => {
+  return (expr, accept) => {
+    switch (true) {
+      case ast.isElementRef(expr.value):
+      case ast.isElementDescedantsExpression(expr.value):
+      case ast.isCustomElementExpression(expr.value):
+      case ast.isExpandElementExpression(expr.value):
+        return
+      case ast.isElementKindExpression(expr.value):
+      case ast.isElementTagExpression(expr.value):
+      case ast.isWildcardExpression(expr.value): {
+        accept('warning', `Predicate is ignored, as not supported in dynamic views`, {
+          node: expr
+        })
+        return
       }
-    } catch (e) {
-      logError(e)
+      default:
+        nonexhaustive(expr.value)
     }
   }
 }

package/src/validation/element.ts

@@ -6,6 +6,7 @@ const { getDocument } = AstUtils
 
 export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Element> => {
   const fqnIndex = services.likec4.FqnIndex
+  const locator = services.workspace.AstNodeLocator
   return (el, accept) => {
     const fqn = fqnIndex.getFqn(el)
     if (!fqn) {
@@ -15,12 +16,15 @@ export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Ele
       })
       return
     }
+    const doc = getDocument(el)
+    const docUri = doc.uri
+    const elPath = locator.getAstNodePath(el)
     const withSameFqn = fqnIndex
       .byFqn(fqn)
-      .filter(v => v.el !== el)
+      .filter(v => v.documentUri !== docUri || v.path !== elPath)
       .head()
     if (withSameFqn) {
-      const isAnotherDoc = withSameFqn.doc.uri !== getDocument(el).uri
+      const isAnotherDoc = withSameFqn.documentUri !== docUri
       accept(
         'error',
         `Duplicate element name ${el.name !== fqn ? el.name + ' (' + fqn + ')' : el.name}`,
@@ -31,8 +35,8 @@ export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Ele
             relatedInformation: [
               {
                 location: {
-                  range: withSameFqn.el.$cstNode!.range,
-                  uri: withSameFqn.doc.uri.toString()
+                  range: (withSameFqn.nameSegment?.range ?? withSameFqn.selectionSegment?.range)!,
+                  uri: withSameFqn.documentUri.toString()
                 },
                 message: `conflicting element`
               }

package/src/validation/index.ts

@@ -4,7 +4,7 @@ import type { LikeC4Services } from '../module'
 import { dynamicViewRulePredicate } from './dynamic-view-rule'
 import { dynamicViewStep } from './dynamic-view-step'
 import { elementChecks } from './element'
-import { opacityPropertyRuleChecks } from './property-checks'
+import { iconPropertyRuleChecks, opacityPropertyRuleChecks } from './property-checks'
 import { relationChecks } from './relation'
 import {
   elementKindChecks,
@@ -17,6 +17,7 @@ import {
 import { viewChecks } from './view'
 import {
   customElementExprChecks,
+  customRelationExprChecks,
   expandElementExprChecks,
   incomingExpressionChecks,
   outgoingExpressionChecks
@@ -27,6 +28,7 @@ export function registerValidationChecks(services: LikeC4Services) {
   const registry = services.validation.ValidationRegistry
   registry.register<ast.LikeC4AstType>({
     OpacityProperty: opacityPropertyRuleChecks(services),
+    IconProperty: iconPropertyRuleChecks(services),
     SpecificationRule: specificationRuleChecks(services),
     Model: modelRuleChecks(services),
     ModelViews: modelViewsChecks(services),
@@ -36,12 +38,13 @@ export function registerValidationChecks(services: LikeC4Services) {
     ElementKind: elementKindChecks(services),
     Relation: relationChecks(services),
     Tag: tagChecks(services),
-    DynamicViewRulePredicate: dynamicViewRulePredicate(services),
-    CustomElementExpr: customElementExprChecks(services),
-    ExpandElementExpr: expandElementExprChecks(services),
+    DynamicViewRulePredicateIterator: dynamicViewRulePredicate(services),
+    CustomElementExpression: customElementExprChecks(services),
+    CustomRelationExpression: customRelationExprChecks(services),
+    ExpandElementExpression: expandElementExprChecks(services),
     RelationshipKind: relationshipChecks(services),
-    IncomingExpr: incomingExpressionChecks(services),
-    OutgoingExpr: outgoingExpressionChecks(services)
+    IncomingRelationExpression: incomingExpressionChecks(services),
+    OutgoingRelationExpression: outgoingExpressionChecks(services)
   })
   const connection = services.shared.lsp.Connection
   if (connection) {

package/src/validation/property-checks.ts

@@ -1,5 +1,5 @@
 import type { ValidationCheck } from 'langium'
-import type { ast } from '../ast'
+import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
 
 export const opacityPropertyRuleChecks = (
@@ -15,3 +15,25 @@ export const opacityPropertyRuleChecks = (
     }
   }
 }
+
+export const iconPropertyRuleChecks = (
+  _: LikeC4Services
+): ValidationCheck<ast.IconProperty> => {
+  return (node, accept) => {
+    const container = node.$container
+    const anotherIcon = container.props.some(p => ast.isIconProperty(p) && p !== node)
+    if (anotherIcon) {
+      accept('error', `Icon must be defined once`, {
+        node
+      })
+    }
+    if (
+      ast.isStyleProperties(container) && ast.isElementBody(container.$container)
+      && container.$container.props.some(p => ast.isIconProperty(p))
+    ) {
+      accept('warning', `Redundant as icon defined on element`, {
+        node
+      })
+    }
+  }
+}

package/src/validation/view-predicates/custom-element-expr.ts

@@ -1,21 +1,34 @@
+import { nonexhaustive } from '@likec4/core'
 import type { ValidationCheck } from 'langium'
+import { AstUtils } from 'langium'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
 
 export const customElementExprChecks = (
   _services: LikeC4Services
-): ValidationCheck<ast.CustomElementExpr> => {
+): ValidationCheck<ast.CustomElementExpression> => {
   return (el, accept) => {
-    if (ast.isExcludePredicate(el.$container)) {
-      accept('error', 'Invalid inside "exclude"', {
+    const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate)
+    if (ast.isExcludePredicate(container)) {
+      accept('error', 'Invalid usage inside "exclude"', {
         node: el
       })
     }
-    if (!ast.isElementRef(el.target)) {
-      accept('error', 'Invalid target for customization', {
-        node: el,
-        property: 'target'
-      })
+    switch (true) {
+      case ast.isElementRef(el.target):
+      case ast.isElementDescedantsExpression(el.target):
+      case ast.isExpandElementExpression(el.target):
+        return
+      case ast.isElementKindExpression(el.target):
+      case ast.isElementTagExpression(el.target):
+      case ast.isWildcardExpression(el.target):
+        accept('error', 'Invalid target (expect reference to specific element)', {
+          node: el,
+          property: 'target'
+        })
+        return
+      default:
+        nonexhaustive(el.target)
     }
   }
 }

package/src/validation/view-predicates/custom-relation-expr.ts

@@ -0,0 +1,16 @@
+import { AstUtils, type ValidationCheck } from 'langium'
+import { ast } from '../../ast'
+import type { LikeC4Services } from '../../module'
+
+export const customRelationExprChecks = (
+  _services: LikeC4Services
+): ValidationCheck<ast.CustomRelationExpression> => {
+  return (el, accept) => {
+    const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate)
+    if (ast.isExcludePredicate(container)) {
+      accept('error', 'Invalid usage inside "exclude"', {
+        node: el
+      })
+    }
+  }
+}

package/src/validation/view-predicates/expanded-element.ts

@@ -1,34 +1,23 @@
 import { nonexhaustive } from '@likec4/core'
-import type { ValidationCheck } from 'langium'
+import { type AstNode, AstUtils, type ValidationCheck } from 'langium'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
 
 export const expandElementExprChecks = (
   _services: LikeC4Services
-): ValidationCheck<ast.ExpandElementExpr> => {
+): ValidationCheck<ast.ExpandElementExpression> => {
   return (el, accept) => {
-    switch (true) {
-      case ast.isIncludePredicate(el.$container):
-      case ast.isDynamicViewRulePredicate(el.$container):
-      case ast.isViewRuleStyle(el.$container):
-        return
-      case ast.isCustomElementExpr(el.$container):
-        return accept('warning', `Custom rules apply only to parent`, {
-          node: el
-        })
-      case ast.isExcludePredicate(el.$container):
-        return accept('warning', `Ignored, as can't be used in exclude`, {
-          node: el
-        })
-      case ast.isInOutExpr(el.$container):
-      case ast.isIncomingExpr(el.$container):
-      case ast.isOutgoingExpr(el.$container):
-      case ast.isRelationExpr(el.$container):
-        return accept('warning', `Wrong usage of expanded element in relations predicate`, {
-          node: el
-        })
-      default:
-        nonexhaustive(el.$container)
+    const isInside = <T extends AstNode>(typePredicate: (n: AstNode) => n is T): boolean =>
+      !!AstUtils.getContainerOfType(el, typePredicate)
+    if (isInside(ast.isRelationExpression)) {
+      accept('warning', `Redundant usage, expand predicate resolves parent element only when used in relations`, {
+        node: el
+      })
+    }
+    if (isInside(ast.isExcludePredicate)) {
+      accept('warning', `Expand predicate is ignored in exclude`, {
+        node: el
+      })
     }
   }
 }

package/src/validation/view-predicates/incoming.ts

@@ -1,15 +1,15 @@
-import type { ValidationCheck } from 'langium'
+import { AstUtils, type ValidationCheck } from 'langium'
 import { isNullish } from 'remeda'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
 
 export const incomingExpressionChecks = (
   _services: LikeC4Services
-): ValidationCheck<ast.IncomingExpr> => {
+): ValidationCheck<ast.IncomingRelationExpression> => {
   return (el, accept) => {
-    if (ast.isWildcardExpr(el.to) && ast.isViewRulePredicate(el.$container)) {
-      const view = el.$container.$container.$container
-      if (isNullish(view.viewOf)) {
+    if (ast.isWildcardExpression(el.to) && ast.isExpressions(el.$container)) {
+      const view = AstUtils.getContainerOfType(el, ast.isElementView)
+      if (isNullish(view?.viewOf)) {
         accept('warning', 'Predicate is ignored as it concerns all relationships', {
           node: el
         })

package/src/validation/view-predicates/index.ts

@@ -1,4 +1,5 @@
 export * from './custom-element-expr'
+export * from './custom-relation-expr'
 export * from './expanded-element'
 export * from './incoming'
 export * from './outgoing'

package/src/validation/view-predicates/outgoing.ts

@@ -1,15 +1,15 @@
-import type { ValidationCheck } from 'langium'
+import { AstUtils, type ValidationCheck } from 'langium'
 import { isNullish } from 'remeda'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
 
 export const outgoingExpressionChecks = (
   _services: LikeC4Services
-): ValidationCheck<ast.OutgoingExpr> => {
+): ValidationCheck<ast.OutgoingRelationExpression> => {
   return (el, accept) => {
-    if (ast.isWildcardExpr(el.from)) {
-      const view = el.$container.$container.$container
-      if (view.$type === 'ElementView' && isNullish(view.viewOf)) {
+    if (ast.isWildcardExpression(el.from) && ast.isExpressions(el.$container)) {
+      const view = AstUtils.getContainerOfType(el, ast.isElementView)
+      if (isNullish(view?.viewOf)) {
         accept('warning', 'Predicate is ignored as it concerns all relationships', {
           node: el
         })

package/src/view-utils/assignNavigateTo.ts

@@ -1,11 +1,11 @@
 import { type ComputedView, type Fqn, isComputedElementView, type ViewID } from '@likec4/core'
-import { find } from 'remeda'
+import { find, isNullish } from 'remeda'
 
 export function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R {
   const allElementViews = new Map<Fqn, ViewID[]>()
 
   for (const v of views) {
-    if (isComputedElementView(v) && v.viewOf && !v.extends) {
+    if (isComputedElementView(v) && v.viewOf && isNullish(v.extends)) {
       const viewsOf = allElementViews.get(v.viewOf) ?? []
       viewsOf.push(v.id)
       allElementViews.set(v.viewOf, viewsOf)