@likec4/language-server 1.5.0 → 1.6.1

package/src/model-change/changeElementStyle.ts

@@ -1,6 +1,6 @@
 import { type Fqn, invariant, isAncestor, type NonEmptyArray, nonNullable, type ViewChanges } from '@likec4/core'
 import { GrammarUtils } from 'langium'
-import { entries, filter, findLast, last } from 'remeda'
+import { entries, filter, findLast, isTruthy, last } from 'remeda'
 import { type Range, TextEdit } from 'vscode-languageserver-protocol'
 import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast'
 import type { FqnIndex } from '../model'
@@ -37,8 +37,8 @@ const isMatchingViewRule =
     if (!ast.isViewRuleStyle(rule)) {
       return false
     }
-    const [target, ...rest] = rule.targets
-    if (!target || rest.length > 0 || !ast.isElementRef(target)) {
+    const target = rule.target.value
+    if (!target || isTruthy(rule.target.prev) || !ast.isElementRef(target)) {
       return false
     }
     const ref = target.el.ref
@@ -127,7 +127,7 @@ export function changeElementStyle(services: LikeC4Services, {
       invariant(ruleCstNode, 'RuleCstNode not found')
       for (const [key, _value] of entries(style)) {
         const value = key === 'opacity' ? _value.toString() + '%' : _value
-        const ruleProp = rule.styleprops.find(p => p.key === key)
+        const ruleProp = rule.props.find(p => p.key === key)
         // replace existing  property
         if (ruleProp && ruleProp.$cstNode) {
           const { range: { start, end } } = nonNullable(

package/src/model-graph/compute-view/__test__/fixture.ts

@@ -16,7 +16,7 @@ import type {
   ThemeColor,
   ViewID,
   ViewRule,
-  ViewRuleExpression,
+  ViewRulePredicate,
   ViewRuleStyle
 } from '@likec4/core'
 import { indexBy, isString, map, prop } from 'remeda'
@@ -418,12 +418,12 @@ export function $expr(expr: Expression | C4Expression): C4Expression {
   }
 }
 
-export function $include(expr: Expression | C4Expression): ViewRuleExpression {
+export function $include(expr: Expression | C4Expression): ViewRulePredicate {
   return {
     include: [$expr(expr)]
   }
 }
-export function $exclude(expr: Expression | C4Expression): ViewRuleExpression {
+export function $exclude(expr: Expression | C4Expression): ViewRulePredicate {
   return {
     exclude: [$expr(expr)]
   }

package/src/model-graph/compute-view/compute.ts

@@ -5,7 +5,7 @@ import type {
   Element,
   ElementView,
   Relation,
-  ViewRuleExpression
+  ViewRulePredicate
 } from '@likec4/core'
 import {
   ancestorsFqn,
@@ -16,7 +16,7 @@ import {
   isAncestor,
   isScopedElementView,
   isViewRuleAutoLayout,
-  isViewRuleExpression,
+  isViewRulePredicate,
   nonexhaustive,
   parentFqn
 } from '@likec4/core'
@@ -92,7 +92,7 @@ export class ComputeCtx {
     this.reset()
     const { rules, ...view } = this.view
 
-    const viewPredicates = rules.filter(isViewRuleExpression)
+    const viewPredicates = rules.filter(isViewRulePredicate)
     if (this.root && viewPredicates.length == 0) {
       this.addElement(this.graph.element(this.root))
     }
@@ -399,7 +399,7 @@ export class ComputeCtx {
     }, [] as ComputeCtx.Edge[])
   }
 
-  protected processPredicates(viewRules: ViewRuleExpression[]): this {
+  protected processPredicates(viewRules: ViewRulePredicate[]): this {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     for (const rule of viewRules) {
       const isInclude = 'include' in rule

package/src/model-graph/dynamic-view/__test__/fixture.ts

@@ -1,4 +1,4 @@
-import type { DynamicViewRule, DynamicViewStep, Fqn, ViewID, ViewRuleExpression } from '@likec4/core'
+import type { DynamicViewRule, DynamicViewStep, Fqn, ViewID, ViewRulePredicate } from '@likec4/core'
 import { partition } from 'remeda'
 import { type FakeElementIds, fakeModel } from '../../compute-view/__test__/fixture'
 import { computeDynamicView } from '../index'
@@ -36,7 +36,7 @@ export function $step(expr: StepExpr, title?: string): DynamicViewStep {
   throw new Error(`Invalid step expression: ${expr}`)
 }
 
-export function compute(stepsAndRules: (DynamicViewStep | ViewRuleExpression)[]) {
+export function compute(stepsAndRules: (DynamicViewStep | ViewRulePredicate)[]) {
   const [steps, rules] = partition(stepsAndRules, (s): s is DynamicViewStep => 'source' in s)
   const result = computeDynamicView(
     {

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/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,33 +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):
-            continue
-          case ast.isElementKindExpr(expr):
-          case ast.isElementTagExpr(expr):
-          case ast.isWildcardExpr(expr): {
-            accept('warning', `Predicate is ignored, as not supported in dynamic views`, {
-              node: expr
-            })
-            continue
-          }
-          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/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,
@@ -28,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),
@@ -37,13 +38,13 @@ export function registerValidationChecks(services: LikeC4Services) {
     ElementKind: elementKindChecks(services),
     Relation: relationChecks(services),
     Tag: tagChecks(services),
-    DynamicViewRulePredicate: dynamicViewRulePredicate(services),
-    CustomElementExpr: customElementExprChecks(services),
-    CustomRelationExpr: customRelationExprChecks(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,25 +1,27 @@
 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)) {
+    const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate)
+    if (ast.isExcludePredicate(container)) {
       accept('error', 'Invalid usage inside "exclude"', {
         node: el
       })
     }
     switch (true) {
       case ast.isElementRef(el.target):
+      case ast.isElementDescedantsExpression(el.target):
+      case ast.isExpandElementExpression(el.target):
         return
-      case ast.isExpandElementExpr(el.target):
-      case ast.isElementKindExpr(el.target):
-      case ast.isElementTagExpr(el.target):
-      case ast.isWildcardExpr(el.target):
-      case ast.isDescedantsExpr(el.target):
+      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'

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

@@ -1,12 +1,13 @@
-import type { ValidationCheck } from 'langium'
+import { AstUtils, type ValidationCheck } from 'langium'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
 
 export const customRelationExprChecks = (
   _services: LikeC4Services
-): ValidationCheck<ast.CustomRelationExpr> => {
+): ValidationCheck<ast.CustomRelationExpression> => {
   return (el, accept) => {
-    if (ast.isExcludePredicate(el.$container)) {
+    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/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
         })