@likec4/language-server 1.20.1 → 1.20.2

package/src/utils/disposable.ts

@@ -0,0 +1,30 @@
+import { Disposable } from 'langium'
+import { logError } from '../logger'
+
+export abstract class ADisposable implements Disposable {
+  protected toDispose: Disposable[] = []
+  protected isDisposed = false
+
+  onDispose(...disposable: Disposable[]): void {
+    this.toDispose.push(...disposable)
+  }
+
+  dispose(): void {
+    this.throwIfDisposed()
+    this.isDisposed = true
+    let item: Disposable | undefined
+    while (item = this.toDispose.pop()) {
+      try {
+        item.dispose()
+      } catch (e) {
+        logError(e)
+      }
+    }
+  }
+
+  protected throwIfDisposed(): void {
+    if (this.isDisposed) {
+      throw new Error('This has already been disposed')
+    }
+  }
+}

package/src/utils/index.ts

@@ -1 +1,2 @@
+export * from './disposable'
 export * from './stringHash'

package/src/validation/_shared.ts

@@ -9,17 +9,20 @@ export const RESERVED_WORDS = [
   'self',
   'super',
   'likec4lib',
-  'global'
+  'global',
 ]
 
 export function tryOrLog<T extends AstNode>(fn: ValidationCheck<T>): ValidationCheck<T> {
-  return async (node: T, accept: ValidationAcceptor, cancelToken: CancellationToken) => {
+  return async function tryOrLogFn(node: T, accept: ValidationAcceptor, cancelToken: CancellationToken) {
     try {
       const result = fn(node, accept, cancelToken)
       if (isPromise(result)) {
         await result
       }
+      return
     } catch (e) {
+      const message = e instanceof Error ? e.message : String(e)
+      accept('error', `Validation failed: ${message}`, { node })
       logWarnError(e)
     }
   }

package/src/validation/index.ts

@@ -1,4 +1,4 @@
-import type { AstNode } from 'langium'
+import { type AstNode, DocumentState } from 'langium'
 import { isNullish } from 'remeda'
 import { DiagnosticSeverity } from 'vscode-languageserver-types'
 import { type LikeC4AstNode, type LikeC4LangiumDocument, ast } from '../ast'
@@ -11,6 +11,7 @@ import { elementChecks } from './element'
 import { iconPropertyRuleChecks, notesPropertyRuleChecks, opacityPropertyRuleChecks } from './property-checks'
 import { relationBodyChecks, relationChecks } from './relation'
 import {
+  deploymentNodeKindChecks,
   elementKindChecks,
   globalPredicateChecks,
   globalsChecks,
@@ -97,7 +98,9 @@ const findInvalidContainer = (node: LikeC4AstNode): ValidatableAstNode | undefin
 }
 
 export function checksFromDiagnostics(doc: LikeC4LangiumDocument) {
-  const errors = doc.diagnostics?.filter(d => d.severity === DiagnosticSeverity.Error) ?? []
+  const errors = doc.state >= DocumentState.Validated
+    ? (doc.diagnostics?.filter(d => d.severity === DiagnosticSeverity.Error) ?? [])
+    : []
   const invalidNodes = new WeakSet()
   for (const { node } of errors) {
     if (isNullish(node) || invalidNodes.has(node)) {
@@ -123,6 +126,7 @@ export function registerValidationChecks(services: LikeC4Services) {
   const registry = services.validation.ValidationRegistry
   registry.register<ast.LikeC4AstType>({
     DeployedInstance: deployedInstanceChecks(services),
+    DeploymentNodeKind: deploymentNodeKindChecks(services),
     DeploymentNode: deploymentNodeChecks(services),
     DeploymentRelation: deploymentRelationChecks(services),
     FqnRefExpr: fqnRefExprChecks(services),

package/src/validation/specification.ts

@@ -72,6 +72,40 @@ export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast
   })
 }
 
+export const deploymentNodeKindChecks = (services: LikeC4Services): ValidationCheck<ast.DeploymentNodeKind> => {
+  const index = services.shared.workspace.IndexManager
+  return tryOrLog((node, accept) => {
+    if (RESERVED_WORDS.includes(node.name)) {
+      accept('error', `Reserved word: ${node.name}`, {
+        node: node,
+        property: 'name',
+      })
+    }
+    const sameKind = index
+      .allElements(ast.DeploymentNodeKind)
+      .filter(n => n.name === node.name && n.node !== node)
+      .head()
+    if (sameKind) {
+      const isAnotherDoc = sameKind.documentUri !== AstUtils.getDocument(node).uri
+      accept('error', `Duplicate deploymentNode kind '${node.name}'`, {
+        node: node,
+        property: 'name',
+        ...isAnotherDoc && {
+          relatedInformation: [
+            {
+              location: {
+                range: sameKind.nameSegment!.range,
+                uri: sameKind.documentUri.toString(),
+              },
+              message: `conflicting definition`,
+            },
+          ],
+        },
+      })
+    }
+  })
+}
+
 export const tagChecks = (services: LikeC4Services): ValidationCheck<ast.Tag> => {
   const index = services.shared.workspace.IndexManager
   return tryOrLog((node, accept) => {

package/contrib/likec4.tmLanguage.json

@@ -1,73 +0,0 @@
-{
-  "name": "likec4",
-  "scopeName": "source.likec4",
-  "fileTypes": [
-    ".c4",
-    ".likec4",
-    ".like-c4"
-  ],
-  "patterns": [
-    {
-      "include": "#comments"
-    },
-    {
-      "name": "keyword.control.likec4",
-      "match": "\\b(BottomTop|LeftRight|RightLeft|TopBottom|amber|and|autoLayout|blue|border|browser|color|crow|cylinder|dashed|deployment|deploymentNode|description|diamond|dot|dotted|dynamic|dynamicPredicateGroup|element|element\\.kind|element\\.tag|exclude|extend|extends|global|gray|green|group|head|icon|icons|include|indigo|instance|instanceOf|is|kind|likec4lib|line|link|metadata|mobile|model|muted|navigateTo|node|none|normal|not|notation|notes|odiamond|odot|of|onormal|opacity|open|or|par|parallel|person|predicate|predicateGroup|primary|queue|rectangle|red|relationship|secondary|shape|sky|slate|solid|source|specification|storage|style|styleGroup|tag|tail|target|technology|title|vee|view|views|where|with)\\b"
-    },
-    {
-      "name": "string.quoted.double.likec4",
-      "begin": "\"",
-      "end": "\"",
-      "patterns": [
-        {
-          "include": "#string-character-escape"
-        }
-      ]
-    },
-    {
-      "name": "string.quoted.single.likec4",
-      "begin": "'",
-      "end": "'",
-      "patterns": [
-        {
-          "include": "#string-character-escape"
-        }
-      ]
-    }
-  ],
-  "repository": {
-    "comments": {
-      "patterns": [
-        {
-          "name": "comment.block.likec4",
-          "begin": "/\\*",
-          "beginCaptures": {
-            "0": {
-              "name": "punctuation.definition.comment.likec4"
-            }
-          },
-          "end": "\\*/",
-          "endCaptures": {
-            "0": {
-              "name": "punctuation.definition.comment.likec4"
-            }
-          }
-        },
-        {
-          "begin": "//",
-          "beginCaptures": {
-            "1": {
-              "name": "punctuation.whitespace.comment.leading.likec4"
-            }
-          },
-          "end": "(?=$)",
-          "name": "comment.line.likec4"
-        }
-      ]
-    },
-    "string-character-escape": {
-      "name": "constant.character.escape.likec4",
-      "match": "\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\\{[0-9A-Fa-f]+\\}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)"
-    }
-  }
-}