@likec4/language-server 1.8.0 → 1.8.1

package/src/like-c4.langium

@@ -72,7 +72,7 @@ Model:
   name='model' '{'
     elements+=(
       ExtendElement |
-      ExplicitRelation |
+      Relation<true> |
       Element
     )*
   '}'
@@ -97,7 +97,7 @@ ElementBody: '{'
   tags=Tags?
   props+=ElementProperty*
   elements+=(
-    Relation |
+    Relation<false> |
     Element
   )*
 '}'
@@ -115,7 +115,7 @@ ExtendElement:
 
 ExtendElementBody:  '{'
   elements+=(
-    ExplicitRelation |
+    Relation<true> |
     Element
   )*
 '}'
@@ -132,20 +132,18 @@ Tags:
   (values+=[Tag:TagId])+ ({infer Tags.prev=current} ',' (values+=[Tag:TagId])*)* ';'?
 ;
 
-Relation:
-  ExplicitRelation | ImplicitRelation;
-
-ExplicitRelation:
-  source=ElementRef RelationFragment;
-
-ImplicitRelation:
-  ('this' | 'it')? RelationFragment;
-
-fragment RelationFragment:
-  ('->' | '-[' kind=[RelationshipKind] ']->' | kind=[RelationshipKind:DotId] )
+Relation<isExplicit>:
+  (<isExplicit> source=ElementRef | <!isExplicit> source=ElementRef?)
+  (
+    kind=[RelationshipKind:DotId] |
+    '-[' kind=[RelationshipKind] ']->' |
+    '->'
+  )
   target=ElementRef
-  title=String?
-  technology=String?
+  (
+    title=String
+    technology=String?
+  )?
   tags=Tags?
   body=RelationBody?
 ;

package/src/references/scope-provider.ts

@@ -1,4 +1,4 @@
-import type { likec4 as c4 } from '@likec4/core'
+import { invariant, type likec4 as c4 } from '@likec4/core'
 import type { AstNode } from 'langium'
 import {
   type AstNodeDescription,
@@ -7,6 +7,7 @@ import {
   DONE_RESULT,
   EMPTY_SCOPE,
   EMPTY_STREAM,
+  MapScope,
   type ReferenceInfo,
   type Scope,
   type Stream,
@@ -102,6 +103,17 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
           if (parent) {
             return new StreamScope(this.scopeElementRef(parent))
           }
+          // if we have elementRef "this" or "it" we resolve it to the closest element
+          if (context.reference.$refText === 'this' || context.reference.$refText === 'it') {
+            const closestElement = AstUtils.getContainerOfType(container, ast.isElement)
+            if (closestElement) {
+              return new MapScope([
+                this.descriptions.createDescription(closestElement, context.reference.$refText)
+              ])
+            } else {
+              return EMPTY_SCOPE
+            }
+          }
         }
         return this.computeScope(context)
       } catch (e) {
@@ -116,26 +128,26 @@ 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')
     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 (referenceType === ast.Element) {
-          if (ast.isExtendElementBody(container)) {
-            scopes.push(this.scopeExtendElement(container.$container))
-          }
-          if (ast.isElementViewBody(container)) {
-            scopes.push(this.scopeElementView(container.$container))
-          }
+
+        if (ast.isExtendElementBody(container)) {
+          scopes.push(this.scopeExtendElement(container.$container))
+        }
+        if (ast.isElementViewBody(container)) {
+          scopes.push(this.scopeElementView(container.$container))
         }
         container = container.$container
       }

package/src/validation/_shared.ts

@@ -0,0 +1,24 @@
+import { type AstNode, interruptAndCheck, type ValidationAcceptor, type ValidationCheck } from 'langium'
+import type { CancellationToken } from 'vscode-jsonrpc'
+import { logWarnError } from '../logger'
+
+export const RESERVED_WORDS = [
+  'this',
+  'it',
+  'self',
+  'super',
+  'likec4lib'
+]
+
+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)
+    } catch (e) {
+      logWarnError(e)
+    }
+  }
+}

package/src/validation/element.ts

@@ -1,13 +1,14 @@
 import { AstUtils, type ValidationCheck } from 'langium'
 import type { ast } from '../ast'
 import type { LikeC4Services } from '../module'
+import { RESERVED_WORDS, tryOrLog } from './_shared'
 
 const { getDocument } = AstUtils
 
 export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Element> => {
   const fqnIndex = services.likec4.FqnIndex
   const locator = services.workspace.AstNodeLocator
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     const fqn = fqnIndex.getFqn(el)
     if (!fqn) {
       accept('error', 'Not indexed element', {
@@ -16,6 +17,12 @@ export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Ele
       })
       return
     }
+    if (RESERVED_WORDS.includes(el.name)) {
+      accept('error', `Reserved word: ${el.name}`, {
+        node: el,
+        property: 'name'
+      })
+    }
     const doc = getDocument(el)
     const docUri = doc.uri
     const elPath = locator.getAstNodePath(el)
@@ -45,12 +52,5 @@ export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Ele
         }
       )
     }
-    // for (let i = 3; i < el.props.length; i++) {
-    //   accept('error', `Too many properties, max 3 allowed`, {
-    //     node: el,
-    //     property: 'props',
-    //     index: i
-    //   })
-    // }
-  }
+  })
 }

package/src/validation/index.ts

@@ -5,7 +5,7 @@ import { dynamicViewRulePredicate } from './dynamic-view-rule'
 import { dynamicViewStep } from './dynamic-view-step'
 import { elementChecks } from './element'
 import { iconPropertyRuleChecks, opacityPropertyRuleChecks } from './property-checks'
-import { relationChecks } from './relation'
+import { relationBodyChecks, relationChecks } from './relation'
 import {
   elementKindChecks,
   modelRuleChecks,
@@ -37,6 +37,7 @@ export function registerValidationChecks(services: LikeC4Services) {
     Element: elementChecks(services),
     ElementKind: elementKindChecks(services),
     Relation: relationChecks(services),
+    RelationBody: relationBodyChecks(services),
     Tag: tagChecks(services),
     DynamicViewPredicateIterator: dynamicViewRulePredicate(services),
     ElementPredicateWith: elementPredicateWithChecks(services),

package/src/validation/relation.ts

@@ -1,57 +1,63 @@
 import { isSameHierarchy } from '@likec4/core'
 import type { ValidationCheck } from 'langium'
+import { isDefined } from 'remeda'
 import { ast } from '../ast'
 import { elementRef } from '../elementRef'
-import { logError } from '../logger'
 import type { LikeC4Services } from '../module'
+import { tryOrLog } from './_shared'
 
 export const relationChecks = (services: LikeC4Services): ValidationCheck<ast.Relation> => {
   const fqnIndex = services.likec4.FqnIndex
-  return (el, accept) => {
-    try {
-      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)', {
+  return tryOrLog((el, accept) => {
+    const targetEl: ast.Element | undefined = elementRef(el.target)
+    const target = targetEl && fqnIndex.getFqn(targetEl)
+    if (!target) {
+      accept('error', 'Target not resolved', {
+        node: el,
+        property: 'target'
+      })
+    }
+    let sourceEl
+    if (isDefined(el.source)) {
+      sourceEl = elementRef(el.source)
+      if (!sourceEl) {
+        return accept('error', 'Source not resolved', {
           node: el,
-          property: 'target'
+          property: 'source'
         })
       }
-      let sourceEl
-      if (ast.isExplicitRelation(el)) {
-        sourceEl = elementRef(el.source)
-        if (!sourceEl) {
-          return accept('error', 'Source not found (not parsed/indexed yet)', {
-            node: el,
-            property: 'source'
-          })
-        }
-      } else {
-        sourceEl = el.$container.$container
-      }
-
-      const source = fqnIndex.getFqn(sourceEl)
-
-      if (!source) {
-        accept('error', 'Source not found (not parsed/indexed yet)', {
+    } else {
+      if (!ast.isElementBody(el.$container)) {
+        return accept('error', 'Sourceless relation must be nested', {
           node: el
         })
       }
+      sourceEl = el.$container.$container
+    }
 
-      if (source && target && isSameHierarchy(source, target)) {
-        accept('error', 'Invalid parent-child relationship', {
-          node: el
-        })
-      }
+    const source = fqnIndex.getFqn(sourceEl)
 
-      if (el.tags?.values && el.body?.tags?.values) {
-        accept('error', 'Relation cannot have tags in both header and body', {
-          node: el,
-          property: 'tags'
-        })
-      }
-    } catch (e) {
-      logError(e)
+    if (!source) {
+      accept('error', 'Source not resolved', {
+        node: el
+      })
+    }
+
+    if (source && target && isSameHierarchy(source, target)) {
+      accept('error', 'Invalid parent-child relationship', {
+        node: el
+      })
+    }
+  })
+}
+
+export const relationBodyChecks = (_services: LikeC4Services): ValidationCheck<ast.RelationBody> => {
+  return tryOrLog((body, accept) => {
+    const relation = body.$container
+    if (relation.tags?.values && body.tags?.values) {
+      accept('error', 'Relation cannot have tags in both header and body', {
+        node: body.tags
+      })
     }
-  }
+  })
 }

package/src/validation/specification.ts

@@ -1,6 +1,7 @@
 import { AstUtils, type ValidationCheck } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
+import { RESERVED_WORDS, tryOrLog } from './_shared'
 
 export const specificationRuleChecks = (
   _: LikeC4Services
@@ -39,7 +40,13 @@ export const modelViewsChecks = (_: LikeC4Services): ValidationCheck<ast.ModelVi
 
 export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast.ElementKind> => {
   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'
+      })
+    }
     const sameKind = index
       .allElements(ast.ElementKind)
       .filter(n => n.name === node.name && n.node !== node)
@@ -62,7 +69,7 @@ export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast
         }
       })
     }
-  }
+  })
 }
 
 export const tagChecks = (services: LikeC4Services): ValidationCheck<ast.Tag> => {
@@ -103,6 +110,12 @@ export const relationshipChecks = (
 ): ValidationCheck<ast.RelationshipKind> => {
   const index = services.shared.workspace.IndexManager
   return (node, accept) => {
+    if (RESERVED_WORDS.includes(node.name)) {
+      accept('error', `Reserved word: ${node.name}`, {
+        node: node,
+        property: 'name'
+      })
+    }
     const sameKinds = index
       .allElements(ast.RelationshipKind)
       .filter(n => n.name === node.name)

package/src/validation/view.ts

@@ -1,6 +1,7 @@
 import { type ValidationCheck } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
+import { RESERVED_WORDS } from './_shared'
 
 export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4View> => {
   const index = services.shared.workspace.IndexManager
@@ -15,6 +16,12 @@ export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4
     if (!el.name) {
       return
     }
+    if (RESERVED_WORDS.includes(el.name)) {
+      accept('error', `Reserved word: ${el.name}`, {
+        node: el,
+        property: 'name'
+      })
+    }
     const anotherViews = index
       .allElements(ast.LikeC4View)
       .filter(n => n.name === el.name)