@likec4/language-server 1.4.0 → 1.5.0

package/src/lsp/SemanticTokenProvider.ts

@@ -23,16 +23,15 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.function
       })
     }
-    if (ast.isElementViewRef(node)) {
-      return acceptor({
+    if (ast.isNavigateToProperty(node)) {
+      acceptor({
         node,
-        property: 'view',
-        type: SemanticTokenTypes.variable
+        property: 'key',
+        type: SemanticTokenTypes.property
       })
-    }
-    if (ast.isDescedantsExpr(node) && node.$cstNode) {
       acceptor({
-        cst: node.$cstNode,
+        node,
+        property: 'value',
         type: SemanticTokenTypes.variable,
         modifier: [
           SemanticTokenModifiers.definition,
@@ -41,7 +40,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       })
       return 'prune'
     }
-    if (ast.isWildcardExpr(node) && node.$cstNode) {
+    if ((ast.isDescedantsExpr(node) || ast.isWildcardExpr(node)) && node.$cstNode) {
       acceptor({
         cst: node.$cstNode,
         type: SemanticTokenTypes.variable,
@@ -52,7 +51,6 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       })
       return 'prune'
     }
-
     if (ast.isElementKindExpr(node)) {
       acceptor({
         node,
@@ -98,6 +96,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         property: 'value',
         type: SemanticTokenTypes.interface
       })
+      return
     }
     if (ast.isTag(node)) {
       return acceptor({
@@ -134,6 +133,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         property: 'value',
         type: SemanticTokenTypes.enum
       })
+      return 'prune'
     }
     if (ast.isOpacityProperty(node)) {
       acceptor({
@@ -146,14 +146,12 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         property: 'value',
         type: SemanticTokenTypes.number
       })
-      return
+      return 'prune'
     }
     if (
       ast.isLinkProperty(node)
       || ast.isIconProperty(node)
-      || ast.isElementStringProperty(node)
-      || ast.isRelationStringProperty(node)
-      || ast.isViewStringProperty(node)
+      || ast.isStringProperty(node)
     ) {
       acceptor({
         node,
@@ -165,7 +163,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         property: 'value',
         type: SemanticTokenTypes.string
       })
-      return
+      return 'prune'
     }
     if (ast.isElement(node)) {
       return this.highlightAstElement(node, acceptor)

package/src/model/fqn-computation.ts

@@ -1,14 +1,38 @@
 import { AsFqn, type c4, nonexhaustive } from '@likec4/core'
-import { MultiMap } from 'langium'
+import { type AstNodeDescription, type AstNodeLocator, AstUtils, CstUtils, GrammarUtils, MultiMap } from 'langium'
 import { isEmpty, isNullish as isNil } from 'remeda'
 import { ast, ElementOps, type LikeC4LangiumDocument } from '../ast'
 import { getFqnElementRef } from '../elementRef'
 import type { LikeC4Services } from '../module'
 
+const { findNodeForProperty } = GrammarUtils
+const { toDocumentSegment } = CstUtils
+const { getDocument } = AstUtils
+
 type TraversePair = [el: ast.Element | ast.ExtendElement | ast.Relation, parent: c4.Fqn | null]
 
+function toAstNodeDescription(
+  locator: AstNodeLocator,
+  entry: ast.Element,
+  doc: LikeC4LangiumDocument
+): AstNodeDescription {
+  const $cstNode = findNodeForProperty(entry.$cstNode, 'name')
+  return {
+    documentUri: doc.uri,
+    name: entry.name,
+    ...(entry.$cstNode && {
+      selectionSegment: toDocumentSegment(entry.$cstNode)
+    }),
+    ...($cstNode && {
+      nameSegment: toDocumentSegment($cstNode)
+    }),
+    path: locator.getAstNodePath(entry),
+    type: ast.Element
+  }
+}
+
 export function computeDocumentFqn(document: LikeC4LangiumDocument, services: LikeC4Services) {
-  const c4fqns = (document.c4fqns = new MultiMap())
+  const c4fqnIndex = (document.c4fqnIndex = new MultiMap())
   const elements = document.parseResult.value.models.flatMap(m => m.elements)
   if (elements.length === 0) {
     return
@@ -30,11 +54,9 @@ export function computeDocumentFqn(document: LikeC4LangiumDocument, services: Li
     }
     if (ast.isElement(el)) {
       const fqn = AsFqn(el.name, parent)
-      const path = locator.getAstNodePath(el)
-      c4fqns.add(fqn, {
-        el: new WeakRef(el),
-        path,
-        name: el.name
+      c4fqnIndex.add(fqn, {
+        ...toAstNodeDescription(locator, el, document),
+        fqn
       })
       ElementOps.writeId(el, fqn)
       if (!isNil(el.body) && !isEmpty(el.body.elements)) {

package/src/model/fqn-index.ts

@@ -1,8 +1,8 @@
 import type { Fqn } from '@likec4/core'
 import { nameFromFqn, parentFqn } from '@likec4/core'
-import type { LangiumDocuments, Stream } from 'langium'
+import type { AstNodeDescription, LangiumDocuments, Stream } from 'langium'
 import { DocumentState, DONE_RESULT, MultiMap, stream, StreamImpl } from 'langium'
-import type { ast, FqnIndexedDocument } from '../ast'
+import type { ast, DocFqnIndexAstNodeDescription, FqnIndexedDocument } from '../ast'
 import { ElementOps, isFqnIndexedDocument, isLikeC4LangiumDocument } from '../ast'
 import { logError, logger } from '../logger'
 import type { LikeC4Services } from '../module'
@@ -17,8 +17,6 @@ export interface FqnIndexEntry {
   path: string
 }
 
-const True = () => true
-
 export class FqnIndex {
   protected langiumDocuments: LangiumDocuments
 
@@ -31,7 +29,7 @@ export class FqnIndex {
         logger.debug(`[FqnIndex] onIndexedContent ${docs.length}:\n` + printDocs(docs))
         for (const doc of docs) {
           if (isLikeC4LangiumDocument(doc)) {
-            delete doc.c4fqns
+            delete doc.c4fqnIndex
             delete doc.c4Elements
             delete doc.c4Specification
             delete doc.c4Relations
@@ -53,18 +51,13 @@ export class FqnIndex {
     return this.langiumDocuments.all.filter(isFqnIndexedDocument)
   }
 
-  private entries(filterByFqn: (fqn: Fqn) => boolean = True): Stream<FqnIndexEntry> {
-    return this.documents.flatMap(doc =>
-      doc.c4fqns.entries().flatMap(([fqn, entry]): FqnIndexEntry | FqnIndexEntry[] => {
-        if (filterByFqn(fqn)) {
-          const el = entry.el.deref()
-          if (el) {
-            return { ...entry, fqn, el, doc }
-          }
-        }
-        return []
-      })
-    )
+  private entries(filterByFqn?: (fqn: Fqn) => boolean): Stream<DocFqnIndexAstNodeDescription> {
+    return this.documents.flatMap(doc => {
+      if (filterByFqn) {
+        return doc.c4fqnIndex.keys().filter(filterByFqn).flatMap(fqn => doc.c4fqnIndex.get(fqn))
+      }
+      return doc.c4fqnIndex.values()
+    })
   }
 
   public getFqn(el: ast.Element): Fqn | null {
@@ -83,22 +76,16 @@ export class FqnIndex {
     // return fqn
   }
 
-  public byFqn(fqn: Fqn): Stream<FqnIndexEntry> {
+  public byFqn(fqn: Fqn): Stream<AstNodeDescription> {
     return this.documents.flatMap(doc => {
-      return doc.c4fqns.get(fqn).flatMap(entry => {
-        const el = entry.el.deref()
-        if (el) {
-          return { fqn, el, doc, path: entry.path, name: entry.name }
-        }
-        return []
-      })
+      return doc.c4fqnIndex.get(fqn)
     })
   }
 
-  public directChildrenOf(parent: Fqn): Stream<FqnIndexEntry> {
+  public directChildrenOf(parent: Fqn): Stream<AstNodeDescription> {
     return stream([parent]).flatMap(_parent => {
       const children = this.entries(fqn => parentFqn(fqn) === _parent)
-        .map((entry): [string, FqnIndexEntry] => [entry.name, entry])
+        .map((entry) => [entry.name, entry] as [string, AstNodeDescription])
         .toArray()
       if (children.length === 0) {
         return []
@@ -113,15 +100,15 @@ export class FqnIndex {
   /**
    * Returns descedant elements with unique names in the scope
    */
-  public uniqueDescedants(parent: Fqn): Stream<FqnIndexEntry> {
+  public uniqueDescedants(parent: Fqn): Stream<AstNodeDescription> {
     return new StreamImpl(
       () => {
         const prefix = `${parent}.`
 
         const childrenNames = new Set<string>()
-        const descedants = [] as FqnIndexEntry[]
+        const descedants = [] as AstNodeDescription[]
 
-        const nested = new MultiMap<string, FqnIndexEntry>()
+        const nested = new MultiMap<string, AstNodeDescription>()
 
         this.entries(f => f.startsWith(prefix)).forEach(e => {
           const name = nameFromFqn(e.fqn)
@@ -154,7 +141,7 @@ export class FqnIndex {
         if (iterator) {
           return iterator.next()
         }
-        return DONE_RESULT as IteratorResult<FqnIndexEntry>
+        return DONE_RESULT as IteratorResult<AstNodeDescription>
       }
     )
   }

package/src/model/model-builder.ts

@@ -2,9 +2,9 @@ import {
   type c4,
   compareByFqnHierarchically,
   isElementView,
-  isStrictElementView,
+  isScopedElementView,
   parentFqn,
-  type StrictElementView,
+  type ScopedElementView,
   type ViewID
 } from '@likec4/core'
 import { deepEqual as eq } from 'fast-equals'
@@ -26,7 +26,7 @@ import {
   sort,
   values
 } from 'remeda'
-import { type CancellationToken, Disposable } from 'vscode-languageserver'
+import { type CancellationToken, Disposable } from 'vscode-languageserver-protocol'
 import type {
   ParsedAstElement,
   ParsedAstRelation,
@@ -107,7 +107,7 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
 
   const elements = pipe(
     docs,
-    flatMap(d => d.c4Elements.map(toModelElement(d))),
+    flatMap(d => map(d.c4Elements, toModelElement(d))),
     filter(isTruthy),
     sort(compareByFqnHierarchically),
     reduce(
@@ -140,10 +140,13 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
       ...model
     }: ParsedAstRelation): c4.Relation | null => {
       if (isNullish(elements[source]) || isNullish(elements[target])) {
+        logger.warn(
+          `Invalid relation ${id}, source: ${source}(${!!elements[source]}), target: ${target}(${!!elements[target]})`
+        )
         return null
       }
 
-      if (!!kind && kind in c4Specification.relationships) {
+      if (!isNullish(kind) && kind in c4Specification.relationships) {
         return {
           ...(links && { links: resolveLinks(doc, links) }),
           ...c4Specification.relationships[kind],
@@ -165,14 +168,15 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
   }
 
   const relations = pipe(
-    flatMap(docs, d => map(d.c4Relations, toModelRelation(d))),
+    docs,
+    flatMap(d => map(d.c4Relations, toModelRelation(d))),
     filter(isTruthy),
     mapToObj(r => [r.id, r])
   )
 
   const toC4View = (doc: LangiumDocument) => {
     const docUri = doc.uri.toString()
-    return (parsedAstView: ParsedAstView): c4.View => {
+    return (parsedAstView: ParsedAstView): c4.LikeC4View => {
       let {
         id,
         title,
@@ -188,7 +192,7 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
       } = parsedAstView
 
       if (parsedAstView.__ === 'element' && isNullish(title) && 'viewOf' in parsedAstView) {
-        title ??= elements[parsedAstView.viewOf]?.title ?? null
+        title = elements[parsedAstView.viewOf]?.title ?? null
       }
 
       if (isNullish(title) && id === 'index') {
@@ -359,7 +363,7 @@ export class LikeC4ModelBuilder {
         }
 
         const allElementViews = values(model.views).filter(
-          (v): v is StrictElementView => isStrictElementView(v) && v.id !== viewId
+          (v): v is ScopedElementView => isScopedElementView(v) && v.id !== viewId
         )
 
         let computedView = result.view

package/src/model/model-locator.ts

@@ -33,18 +33,18 @@ export class LikeC4ModelLocator {
     return doc.c4Elements.find(e => e.id === fqn) ?? null
   }
 
-  public locateElement(fqn: c4.Fqn, property = 'name'): Location | null {
+  public locateElement(fqn: c4.Fqn, _property = 'name'): Location | null {
     const entry = this.fqnIndex.byFqn(fqn).head()
     if (!entry) {
       return null
     }
-    const propertyNode = findNodeForProperty(entry.el.$cstNode, property) ?? entry.el.$cstNode
-    if (!propertyNode) {
-      return null
-    }
+    // const propertyNode = findNodeForProperty(entry.el.$cstNode, property) ?? entry.el.$cstNode
+    // if (!propertyNode) {
+    //   return null
+    // }
     return {
-      uri: entry.doc.uri.toString(),
-      range: propertyNode.range
+      uri: entry.documentUri.toString(),
+      range: entry.nameSegment?.range!
     }
   }
 

package/src/model/model-parser.ts

@@ -1,7 +1,7 @@
 import { type c4, InvalidModelError, invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
 import type { AstNode, LangiumDocument } from 'langium'
 import { AstUtils, CstUtils } from 'langium'
-import { isTruthy } from 'remeda'
+import { isTruthy, mapToObj } from 'remeda'
 import stripIndent from 'strip-indent'
 import type {
   ChecksFromDiagnostics,
@@ -37,14 +37,14 @@ const { getDocument } = AstUtils
 export type ModelParsedListener = () => void
 
 function toSingleLine<T extends string | undefined>(str: T): T {
-  return (str ? removeIndent(str).split('\n').join(' ') : undefined) as T
+  return (isTruthy(str) ? removeIndent(str).split('\n').join(' ') : undefined) as T
 }
 
 function removeIndent<T extends string | undefined>(str: T): T {
-  return (str ? stripIndent(str).trim() : undefined) as T
+  return (isTruthy(str) ? stripIndent(str).trim() : undefined) as T
 }
 
-type IsValidFn = ChecksFromDiagnostics['isValid']
+export type IsValidFn = ChecksFromDiagnostics['isValid']
 
 export class LikeC4ModelParser {
   private fqnIndex: FqnIndex
@@ -142,11 +142,11 @@ export class LikeC4ModelParser {
 
     let [title, description, technology] = astNode.props ?? []
 
-    const bodyProps = astNode.body?.props.filter(ast.isElementStringProperty) ?? []
+    const bodyProps = mapToObj(astNode.body?.props.filter(ast.isElementStringProperty) ?? [], p => [p.key, p.value])
 
-    title = toSingleLine(title ?? bodyProps.find(p => p.key === 'title')?.value)
-    description = removeIndent(description ?? bodyProps.find(p => p.key === 'description')?.value)
-    technology = toSingleLine(technology ?? bodyProps.find(p => p.key === 'technology')?.value)
+    title = toSingleLine(title ?? bodyProps.title)
+    description = removeIndent(description ?? bodyProps.description)
+    technology = toSingleLine(technology ?? bodyProps.technology)
 
     const links = astNode.body?.props.filter(ast.isLinkProperty).map(p => p.value)
 
@@ -171,7 +171,7 @@ export class LikeC4ModelParser {
     const links = astNode.body?.props.filter(ast.isLinkProperty).map(p => p.value)
     const kind = astNode.kind?.ref?.name as c4.RelationshipKind
     const astPath = this.getAstNodePath(astNode)
-    const title = toSingleLine(
+    const title = removeIndent(
       astNode.title ?? astNode.body?.props.find((p): p is ast.RelationStringProperty => p.key === 'title')?.value
     ) ?? ''
     const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty)
@@ -321,12 +321,11 @@ export class LikeC4ModelParser {
   }
 
   private parsePredicateExpr(astNode: ast.ViewRulePredicateExpr): c4.Expression {
+    if (ast.isCustomRelationExpr(astNode)) {
+      return this.parseCustomRelationExpr(astNode)
+    }
     if (ast.isRelationExpr(astNode)) {
-      return {
-        source: this.parseElementExpr(astNode.source),
-        target: this.parseElementExpr(astNode.target),
-        isBidirectional: astNode.isBidirectional
-      }
+      return this.parseRelationExpr(astNode)
     }
     if (ast.isInOutExpr(astNode)) {
       return {
@@ -352,6 +351,48 @@ export class LikeC4ModelParser {
     nonexhaustive(astNode)
   }
 
+  private parseCustomRelationExpr(astNode: ast.CustomRelationExpr): c4.CustomRelationExpr {
+    const relation = this.parseRelationExpr(astNode.relation)
+    const props = astNode.body?.props ?? []
+    return props.reduce(
+      (acc, prop) => {
+        if (ast.isRelationStringProperty(prop)) {
+          const value = removeIndent(prop.value)
+          if (isTruthy(value)) {
+            acc.customRelation['title'] = value
+          }
+          return acc
+        }
+        if (ast.isArrowProperty(prop)) {
+          acc.customRelation[prop.key] = prop.value
+          return acc
+        }
+        if (ast.isColorProperty(prop)) {
+          acc.customRelation[prop.key] = prop.value
+          return acc
+        }
+        if (ast.isLineProperty(prop)) {
+          acc.customRelation[prop.key] = prop.value
+          return acc
+        }
+        nonexhaustive(prop)
+      },
+      {
+        customRelation: {
+          relation
+        }
+      } as c4.CustomRelationExpr
+    )
+  }
+
+  private parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr {
+    return {
+      source: this.parseElementExpr(astNode.source),
+      target: this.parseElementExpr(astNode.target),
+      isBidirectional: astNode.isBidirectional
+    }
+  }
+
   private parseViewRule(astRule: ast.ViewRule, isValid: IsValidFn): c4.ViewRule {
     if (ast.isIncludePredicate(astRule) || ast.isExcludePredicate(astRule)) {
       const exprs = astRule.expressions.flatMap(n => {
@@ -398,18 +439,22 @@ export class LikeC4ModelParser {
     if (!targetEl) {
       throw new Error('Invalid reference to target')
     }
+    const title = removeIndent(node.title) ?? null
     let source = this.resolveFqn(sourceEl)
     let target = this.resolveFqn(targetEl)
     if (node.isBackward) {
-      ;[source, target] = [target, source]
+      return {
+        source: target,
+        target: source,
+        title,
+        isBackward: true
+      }
     }
 
-    const title = toSingleLine(node.title) ?? null
     return {
       source,
       target,
-      title,
-      isBackward: node.isBackward
+      title
     }
   }
 

package/src/model-change/changeElementStyle.ts

@@ -12,7 +12,7 @@ const asViewStyleRule = (target: string, style: ViewChanges.ChangeElementStyle['
   const indentStr = indent > 0 ? ' '.repeat(indent) : ''
   return [
     indentStr + `style ${target} {`,
-    ...entries.strict(style).map(([key, value]) =>
+    ...entries(style).map(([key, value]) =>
       indentStr + `  ${key} ${key === 'opacity' ? value.toString() + '%' : value}`
     ),
     indentStr + `}`
@@ -125,7 +125,7 @@ export function changeElementStyle(services: LikeC4Services, {
     for (const { rule } of existing) {
       const ruleCstNode = rule.$cstNode
       invariant(ruleCstNode, 'RuleCstNode not found')
-      for (const [key, _value] of entries.strict(style)) {
+      for (const [key, _value] of entries(style)) {
         const value = key === 'opacity' ? _value.toString() + '%' : _value
         const ruleProp = rule.styleprops.find(p => p.key === key)
         // replace existing  property