@likec4/language-server 1.19.0 → 1.19.2

package/src/references/scope-computation.ts

@@ -2,27 +2,27 @@ import { nonexhaustive } from '@likec4/core'
 import {
   type AstNode,
   type AstNodeDescription,
+  type PrecomputedScopes,
   DefaultScopeComputation,
   MultiMap,
-  type PrecomputedScopes
 } from 'langium'
-import { entries, filter, flatMap, forEach, forEachObj, groupBy, isNullish, isTruthy, pipe } from 'remeda'
+import { entries, filter, flatMap, forEachObj, groupBy, isNullish, isTruthy, pipe } from 'remeda'
 import type { CancellationToken } from 'vscode-languageserver'
-import { ast, type LikeC4LangiumDocument } from '../ast'
-import { logError, logWarnError } from '../logger'
+import { type LikeC4LangiumDocument, ast } from '../ast'
+import { 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[]
+  descs: AstNodeDescription[],
 ): AstNodeDescription[] {
   return pipe(
     descs,
     groupBy(desc => `${desc.type}.${desc.name}`),
     entries(),
-    flatMap(([_, descs]) => descs.length === 1 ? descs : [])
+    flatMap(([_, descs]) => descs.length === 1 ? descs : []),
   )
 }
 
@@ -33,7 +33,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
 
   override async computeExports(
     document: LikeC4LangiumDocument,
-    _cancelToken?: CancellationToken
+    _cancelToken?: CancellationToken,
   ): Promise<AstNodeDescription[]> {
     const docExports: AstNodeDescription[] = []
     try {
@@ -56,7 +56,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
 
       this.exportDeployments(deployments, docExports, document)
     } catch (e) {
-      logError(e)
+      logWarnError(e)
     }
     return docExports
   }
@@ -64,7 +64,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
   private exportViews(
     modelViews: ast.ModelViews[] | undefined,
     docExports: AstNodeDescription[],
-    document: LikeC4LangiumDocument
+    document: LikeC4LangiumDocument,
   ) {
     const views = modelViews?.flatMap(m => m.views)
     if (isNullish(views) || views.length === 0) {
@@ -76,7 +76,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document))
         }
       } catch (e) {
-        logError(e)
+        logWarnError(e)
       }
     }
   }
@@ -84,7 +84,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
   private exportGlobals(
     globals: ast.Globals[] | undefined,
     docExports: AstNodeDescription[],
-    document: LikeC4LangiumDocument
+    document: LikeC4LangiumDocument,
   ) {
     if (isNullish(globals) || globals.length === 0) {
       return
@@ -96,7 +96,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(id, id.name, document))
         }
       } catch (e) {
-        logError(e)
+        logWarnError(e)
       }
     }
     for (const globalStyleAst of globals.flatMap(g => g.styles)) {
@@ -106,7 +106,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(id, id.name, document))
         }
       } catch (e) {
-        logError(e)
+        logWarnError(e)
       }
     }
   }
@@ -114,7 +114,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
   private exportModel(
     models: ast.Model[] | undefined,
     docExports: AstNodeDescription[],
-    document: LikeC4LangiumDocument
+    document: LikeC4LangiumDocument,
   ) {
     if (isNullish(models) || models.length === 0) {
       return
@@ -125,7 +125,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(elAst, elAst.name, document))
         }
       } catch (e) {
-        logError(e)
+        logWarnError(e)
       }
     }
   }
@@ -133,7 +133,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
   private exportLibrary(
     likec4lib: ast.LikeC4Lib[] | undefined,
     docExports: AstNodeDescription[],
-    document: LikeC4LangiumDocument
+    document: LikeC4LangiumDocument,
   ) {
     if (isNullish(likec4lib)) {
       return
@@ -143,14 +143,14 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         docExports.push(this.descriptions.createDescription(iconAst, iconAst.name, document))
       }
     } catch (e) {
-      logError(e)
+      logWarnError(e)
     }
   }
 
   private exportSpecification(
     specifications: ast.SpecificationRule[] | undefined,
     docExports: AstNodeDescription[],
-    document: LikeC4LangiumDocument
+    document: LikeC4LangiumDocument,
   ) {
     if (isNullish(specifications) || specifications.length === 0) {
       return
@@ -161,7 +161,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         ...s.relationships,
         ...s.deploymentNodes,
         ...s.tags,
-        ...s.colors
+        ...s.colors,
       ])
     ) {
       try {
@@ -170,7 +170,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           case ast.isSpecificationElementKind(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
@@ -178,7 +178,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           case ast.isSpecificationTag(spec): {
             if (isTruthy(spec.tag.name)) {
               docExports.push(
-                this.descriptions.createDescription(spec.tag, '#' + spec.tag.name, document)
+                this.descriptions.createDescription(spec.tag, '#' + spec.tag.name, document),
               )
             }
             continue
@@ -187,7 +187,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
             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)
+                this.descriptions.createDescription(spec.kind, '.' + spec.kind.name, document),
               )
             }
             continue
@@ -195,7 +195,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           case ast.isSpecificationColor(spec): {
             if (isTruthy(spec.name.name)) {
               docExports.push(
-                this.descriptions.createDescription(spec.name, spec.name.name, document)
+                this.descriptions.createDescription(spec.name, spec.name.name, document),
               )
             }
             continue
@@ -205,7 +205,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
             nonexhaustive(spec)
         }
       } catch (e) {
-        logError(e)
+        logWarnError(e)
       }
     }
   }
@@ -213,7 +213,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
   private exportDeployments(
     modelDeployments: ast.ModelDeployments[] | undefined,
     docExports: AstNodeDescription[],
-    document: LikeC4LangiumDocument
+    document: LikeC4LangiumDocument,
   ) {
     const nodes = modelDeployments?.flatMap(m => m.elements)
     if (isNullish(nodes) || nodes.length === 0) {
@@ -232,7 +232,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
 
   override computeLocalScopes(
     document: LikeC4LangiumDocument,
-    _cancelToken?: CancellationToken
+    _cancelToken?: CancellationToken,
   ): Promise<PrecomputedScopes> {
     return new Promise(resolve => {
       const root = document.parseResult.value
@@ -242,16 +242,16 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
       for (const model of root.models) {
         try {
           descendants.push(
-            ...this.processContainer(model, scopes, document)
+            ...this.processContainer(model, scopes, document),
           )
         } catch (e) {
-          logError(e)
+          logWarnError(e)
         }
       }
       for (const deployment of root.deployments) {
         try {
           descendants.push(
-            ...this.processDeployments(deployment, scopes, document)
+            ...this.processDeployments(deployment, scopes, document),
           )
         } catch (e) {
           logWarnError(e)
@@ -269,7 +269,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
   protected processContainer(
     container: ElementsContainer,
     scopes: PrecomputedScopes,
-    document: LikeC4LangiumDocument
+    document: LikeC4LangiumDocument,
   ): AstNodeDescription[] {
     const localScope = new MultiMap<string, AstNodeDescription>()
     const descedants = [] as AstNodeDescription[]
@@ -292,7 +292,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
       if (subcontainer && subcontainer.elements.length > 0) {
         try {
           descedants.push(
-            ...this.processContainer(subcontainer, scopes, document)
+            ...this.processContainer(subcontainer, scopes, document),
           )
         } catch (e) {
           logWarnError(e)
@@ -309,7 +309,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           if (descs.length === 1) {
             localScope.add(name, descs[0])
           }
-        })
+        }),
       )
     }
     const local = [...localScope.values()]
@@ -320,7 +320,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
   protected processDeployments(
     container: DeploymentsContainer,
     scopes: PrecomputedScopes,
-    document: LikeC4LangiumDocument
+    document: LikeC4LangiumDocument,
   ): AstNodeDescription[] {
     const localnames = new Set<string>()
     const descedants = [] as AstNodeDescription[]
@@ -340,7 +340,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
       if (ast.isDeploymentNode(el) && el.body) {
         try {
           descedants.push(
-            ...this.processDeployments(el.body, scopes, document)
+            ...this.processDeployments(el.body, scopes, document),
           )
         } catch (e) {
           logWarnError(e)
@@ -356,7 +356,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           if (descs.length === 1) {
             scopes.add(container, descs[0])
           }
-        })
+        }),
       )
     }
     return [...scopes.get(container).values()]

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

@@ -2,21 +2,22 @@ import { nonexhaustive } from '@likec4/core'
 import type { ValidationCheck } from 'langium'
 import { ast, elementExpressionFromPredicate } from '../ast'
 import type { LikeC4Services } from '../module'
+import { tryOrLog } from './_shared'
 
 export const dynamicViewRulePredicate = (
-  _services: LikeC4Services
+  _services: LikeC4Services,
 ): ValidationCheck<ast.DynamicViewPredicateIterator> => {
-  return (predicate, accept) => {
+  return tryOrLog((predicate, accept) => {
     const expr = elementExpressionFromPredicate(predicate.value)
     switch (true) {
       case ast.isElementKindExpression(expr):
       case ast.isElementTagExpression(expr):
       case ast.isWildcardExpression(expr): {
         accept('warning', `Predicate is ignored, as not supported in dynamic views`, {
-          node: predicate
+          node: predicate,
         })
         return
       }
     }
-  }
+  })
 }

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

@@ -4,36 +4,33 @@ import { ast } from '../ast'
 import { logError } from '../logger'
 import type { LikeC4Services } from '../module'
 import { elementRef } from '../utils/elementRef'
+import { tryOrLog } from './_shared'
 
 export const dynamicViewStep = (services: LikeC4Services): ValidationCheck<ast.DynamicViewStep> => {
   const fqnIndex = services.likec4.FqnIndex
-  return (el, accept) => {
-    try {
-      const sourceEl: ast.Element | undefined = elementRef(el.source)
-      const source = sourceEl && fqnIndex.getFqn(sourceEl)
-      if (!source) {
-        accept('error', 'Source not found (not parsed/indexed yet)', {
-          node: el,
-          property: 'source'
-        })
-      }
+  return tryOrLog((el, accept) => {
+    const sourceEl: ast.Element | undefined = elementRef(el.source)
+    const source = sourceEl && fqnIndex.getFqn(sourceEl)
+    if (!source) {
+      accept('error', 'Source not found (not parsed/indexed yet)', {
+        node: el,
+        property: 'source',
+      })
+    }
 
-      const targetEl: ast.Element | undefined = elementRef(el.target)
-      const target = targetEl && fqnIndex.getFqn(targetEl)
-      if (!target) {
-        accept('error', 'Target not found (not parsed/indexed yet)', {
-          node: el,
-          property: 'target'
-        })
-      }
+    const targetEl: ast.Element | undefined = elementRef(el.target)
+    const target = targetEl && fqnIndex.getFqn(targetEl)
+    if (!target) {
+      accept('error', 'Target not found (not parsed/indexed yet)', {
+        node: el,
+        property: 'target',
+      })
+    }
 
-      if (source && target && (isAncestor(source, target) || isAncestor(target, source))) {
-        accept('error', 'Invalid parent-child relationship', {
-          node: el
-        })
-      }
-    } catch (e) {
-      logError(e)
+    if (source && target && (isAncestor(source, target) || isAncestor(target, source))) {
+      accept('error', 'Invalid parent-child relationship', {
+        node: el,
+      })
     }
-  }
+  })
 }

package/src/validation/property-checks.ts

@@ -1,30 +1,31 @@
-import { AstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
+import { tryOrLog } from './_shared'
 
 export const opacityPropertyRuleChecks = (
-  _: LikeC4Services
+  _: LikeC4Services,
 ): ValidationCheck<ast.OpacityProperty> => {
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     const opacity = parseFloat(node.value)
     if (isNaN(opacity) || opacity < 0 || opacity > 100) {
       accept('warning', `Value ignored, must be between 0% and 100%`, {
         node,
-        property: 'value'
+        property: 'value',
       })
     }
-  }
+  })
 }
 
 export const iconPropertyRuleChecks = (
-  _: LikeC4Services
+  _: 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
+        node,
       })
     }
     if (
@@ -32,19 +33,19 @@ export const iconPropertyRuleChecks = (
       && container.$container.props.some(p => ast.isIconProperty(p))
     ) {
       accept('warning', `Redundant as icon defined on element`, {
-        node
+        node,
       })
     }
   }
 }
 
 export const notesPropertyRuleChecks = (
-  _: LikeC4Services
+  _: LikeC4Services,
 ): ValidationCheck<ast.NotesProperty> => {
   return (node, accept) => {
     if (!AstUtils.hasContainerOfType(node, ast.isDynamicViewStep)) {
       accept('error', `Notes can be defined only inside dynamic view`, {
-        node
+        node,
       })
     }
   }

package/src/validation/specification.ts

@@ -1,41 +1,41 @@
-import { AstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
 import { RESERVED_WORDS, tryOrLog } from './_shared'
 
 export const specificationRuleChecks = (
-  _: LikeC4Services
+  _: LikeC4Services,
 ): ValidationCheck<ast.SpecificationRule> => {
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
       accept('warning', `Prefer one specification per document`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }
 
 export const modelRuleChecks = (_: LikeC4Services): ValidationCheck<ast.Model> => {
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
       accept('warning', `Prefer one model per document`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }
 
 export const globalsChecks = (_: LikeC4Services): ValidationCheck<ast.Globals> => {
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
       accept('warning', `Prefer one global block per document`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }
 
 export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast.ElementKind> => {
@@ -44,7 +44,7 @@ export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast
     if (RESERVED_WORDS.includes(node.name)) {
       accept('error', `Reserved word: ${node.name}`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
     const sameKind = index
@@ -61,12 +61,12 @@ export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast
             {
               location: {
                 range: sameKind.nameSegment!.range,
-                uri: sameKind.documentUri.toString()
+                uri: sameKind.documentUri.toString(),
               },
-              message: `conflicting definition`
-            }
-          ]
-        }
+              message: `conflicting definition`,
+            },
+          ],
+        },
       })
     }
   })
@@ -74,7 +74,7 @@ export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast
 
 export const tagChecks = (services: LikeC4Services): ValidationCheck<ast.Tag> => {
   const index = services.shared.workspace.IndexManager
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     const tagname = '#' + node.name
     const sameTag = index
       .allElements(ast.Tag)
@@ -93,27 +93,27 @@ export const tagChecks = (services: LikeC4Services): ValidationCheck<ast.Tag> =>
               {
                 location: {
                   range: sameTag.nameSegment!.range,
-                  uri: sameTag.documentUri.toString()
+                  uri: sameTag.documentUri.toString(),
                 },
-                message: `conflicting definition`
-              }
-            ]
-          }
-        }
+                message: `conflicting definition`,
+              },
+            ],
+          },
+        },
       )
     }
-  }
+  })
 }
 
 export const relationshipChecks = (
-  services: LikeC4Services
+  services: LikeC4Services,
 ): ValidationCheck<ast.RelationshipKind> => {
   const index = services.shared.workspace.IndexManager
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     if (RESERVED_WORDS.includes(node.name)) {
       accept('error', `Reserved word: ${node.name}`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
     const sameKinds = index
@@ -124,17 +124,17 @@ export const relationshipChecks = (
     if (sameKinds > 1) {
       accept('error', `Duplicate RelationshipKind '${node.name}'`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }
 
 export const globalPredicateChecks = (
-  services: LikeC4Services
+  services: LikeC4Services,
 ): ValidationCheck<ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup> => {
   const index = services.shared.workspace.IndexManager
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     const predicateGroups = index.allElements(ast.GlobalPredicateGroup)
     const dynamicPredicateGroups = index.allElements(ast.GlobalDynamicPredicateGroup)
     const sameName = predicateGroups
@@ -145,17 +145,17 @@ export const globalPredicateChecks = (
     if (sameName > 1) {
       accept('error', `Duplicate GlobalPredicateGroup or GlobalDynamicPredicateGroup name '${node.name}'`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }
 
 export const globalStyleIdChecks = (
-  services: LikeC4Services
+  services: LikeC4Services,
 ): ValidationCheck<ast.GlobalStyleId> => {
   const index = services.shared.workspace.IndexManager
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     const sameName = index
       .allElements(ast.GlobalStyleId)
       .filter(s => s.name === node.name)
@@ -164,8 +164,8 @@ export const globalStyleIdChecks = (
     if (sameName > 1) {
       accept('error', `Duplicate GlobalStyleId name '${node.name}'`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }

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

@@ -3,15 +3,16 @@ import type { ValidationCheck } from 'langium'
 import { AstUtils } from 'langium'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
 
 export const elementPredicateWithChecks = (
-  _services: LikeC4Services
+  _services: LikeC4Services,
 ): ValidationCheck<ast.ElementPredicateWith> => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate)
     if (ast.isExcludePredicate(container)) {
       accept('error', 'Invalid usage inside "exclude"', {
-        node: el
+        node: el,
       })
     }
     const subject = ast.isElementPredicateWhere(el.subject) ? el.subject.subject : el.subject
@@ -25,11 +26,11 @@ export const elementPredicateWithChecks = (
       case ast.isElementTagExpression(subject):
         accept('error', 'Invalid target (expect reference to specific element)', {
           node: el,
-          property: 'subject'
+          property: 'subject',
         })
         return
       default:
         nonexhaustive(subject)
     }
-  }
+  })
 }

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

@@ -1,15 +1,16 @@
-import { AstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
 
 export const expandElementExprChecks = (
-  _services: LikeC4Services
+  _services: LikeC4Services,
 ): ValidationCheck<ast.ExpandElementExpression> => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     if (AstUtils.hasContainerOfType(el, ast.isRelationExpression)) {
       accept('warning', `Redundant usage, expand predicate resolves parent element only when used in relations`, {
-        node: el
+        node: el,
       })
     }
-  }
+  })
 }