@likec4/language-server 1.6.1 → 1.7.1

package/src/model/model-locator.ts

@@ -1,7 +1,7 @@
 import type { likec4 as c4 } from '@likec4/core'
 import type { LangiumDocuments } from 'langium'
 import { AstUtils, GrammarUtils } from 'langium'
-import type { Location } from 'vscode-languageserver-protocol'
+import type { Location } from 'vscode-languageserver-types'
 import type { ParsedAstElement } from '../ast'
 import { ast, isParsedLikeC4LangiumDocument } from '../ast'
 import type { LikeC4Services } from '../module'
@@ -33,18 +33,15 @@ 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, _prop?: string): Location | null {
     const entry = this.fqnIndex.byFqn(fqn).head()
-    if (!entry) {
+    const docsegment = entry?.nameSegment ?? entry?.selectionSegment
+    if (!entry || !docsegment) {
       return null
     }
-    // const propertyNode = findNodeForProperty(entry.el.$cstNode, property) ?? entry.el.$cstNode
-    // if (!propertyNode) {
-    //   return null
-    // }
     return {
       uri: entry.documentUri.toString(),
-      range: entry.nameSegment?.range!
+      range: docsegment.range
     }
   }
 
@@ -61,20 +58,14 @@ export class LikeC4ModelLocator {
       if (!ast.isRelation(node)) {
         continue
       }
-      if (node.title) {
-        const targetNode = findNodeForProperty(node.$cstNode, 'title')
-        if (targetNode) {
-          return {
-            uri: doc.uri.toString(),
-            range: targetNode.range
-          }
-        }
-      }
-      let targetNode = node.kind ? findNodeForProperty(node.$cstNode, 'kind') : findNodeForKeyword(node.$cstNode, '->')
+
+      let targetNode = node.title ? findNodeForProperty(node.$cstNode, 'title') : undefined
+      targetNode ??= node.kind ? findNodeForProperty(node.$cstNode, 'kind') : undefined
       targetNode ??= findNodeForProperty(node.$cstNode, 'target')
+      targetNode ??= node.$cstNode
 
       if (!targetNode) {
-        return null
+        continue
       }
 
       return {
@@ -112,13 +103,9 @@ export class LikeC4ModelLocator {
       return null
     }
     const node = res.viewAst
-    let targetNode = node.$cstNode
-    if (node.name) {
-      targetNode = findNodeForProperty(node.$cstNode, 'name') ?? targetNode
-    } else if ('viewOf' in node) {
-      targetNode = findNodeForProperty(node.$cstNode, 'viewOf') ?? targetNode
-    }
+    let targetNode = node.name ? findNodeForProperty(node.$cstNode, 'name') : undefined
     targetNode ??= findNodeForKeyword(node.$cstNode, 'view')
+    targetNode ??= node.$cstNode
     if (!targetNode) {
       return null
     }

package/src/model/model-parser-where.ts

@@ -0,0 +1,75 @@
+import { type c4, invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
+import { isAndOperator, isOrOperator } from '@likec4/core/types'
+import { ast } from '../ast'
+
+const parseEquals = (
+  { operator, not }: ast.WhereKindEqual | ast.WhereTagEqual,
+  value: string
+): c4.EqualOperator<string> => {
+  if (operator.startsWith('!=')) {
+    return {
+      neq: value
+    }
+  }
+  if (operator.startsWith('=')) {
+    return {
+      eq: value
+    }
+  }
+  return not ? { neq: value } : { eq: value }
+}
+
+export function parseWhereClause(astNode: ast.WhereExpression): c4.WhereOperator {
+  switch (true) {
+    case ast.isWhereTagEqual(astNode): {
+      const tag = astNode.value?.ref?.name
+      invariant(tag, 'Expected tag name')
+      return {
+        tag: parseEquals(astNode, tag)
+      }
+    }
+    case ast.isWhereKindEqual(astNode): {
+      const kind = astNode.value?.ref?.name
+      invariant(kind, 'Expected kind name')
+      return {
+        kind: parseEquals(astNode, kind)
+      }
+    }
+    case ast.isWhereElementNegation(astNode) || ast.isWhereRelationNegation(astNode): {
+      return {
+        not: parseWhereClause(astNode.value)
+      }
+    }
+    case ast.isWhereBinaryExpression(astNode): {
+      const left = parseWhereClause(astNode.left)
+      const right = parseWhereClause(astNode.right)
+      const operator = astNode.operator.toLowerCase() as Lowercase<ast.WhereBinaryExpression['operator']>
+      switch (operator) {
+        case 'and': {
+          const operands = [
+            isAndOperator(left) ? left.and : left,
+            isAndOperator(right) ? right.and : right
+          ].flat()
+          invariant(isNonEmptyArray(operands), 'Expected non-empty array')
+          return {
+            and: operands
+          }
+        }
+        case 'or': {
+          const operands = [
+            isOrOperator(left) ? left.or : left,
+            isOrOperator(right) ? right.or : right
+          ].flat()
+          invariant(isNonEmptyArray(operands), 'Expected non-empty array')
+          return {
+            or: operands
+          }
+        }
+        default:
+          nonexhaustive(operator)
+      }
+    }
+    default:
+      nonexhaustive(astNode)
+  }
+}

package/src/model/model-parser.ts

@@ -3,6 +3,7 @@ import type { AstNode, LangiumDocument } from 'langium'
 import { AstUtils, CstUtils } from 'langium'
 import { isTruthy, mapToObj } from 'remeda'
 import stripIndent from 'strip-indent'
+import type { Writable } from 'type-fest'
 import type {
   ChecksFromDiagnostics,
   FqnIndexedDocument,
@@ -29,8 +30,9 @@ import { elementRef, getFqnElementRef } from '../elementRef'
 import { logError, logger, logWarnError } from '../logger'
 import type { LikeC4Services } from '../module'
 import { stringHash } from '../utils'
-import { deserializeFromComment } from '../view-utils/manual-layout'
+import { deserializeFromComment, hasManualLayout } from '../view-utils/manual-layout'
 import type { FqnIndex } from './fqn-index'
+import { parseWhereClause } from './model-parser-where'
 
 const { getDocument } = AstUtils
 
@@ -142,7 +144,10 @@ export class LikeC4ModelParser {
 
     let [title, description, technology] = astNode.props ?? []
 
-    const bodyProps = mapToObj(astNode.body?.props.filter(ast.isElementStringProperty) ?? [], p => [p.key, p.value])
+    const bodyProps = mapToObj(
+      astNode.body?.props.filter(ast.isElementStringProperty) ?? [],
+      p => [p.key, p.value || undefined]
+    )
 
     title = toSingleLine(title ?? bodyProps.title)
     description = removeIndent(bodyProps.description ?? description)
@@ -180,9 +185,16 @@ 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 = removeIndent(
-      astNode.title ?? astNode.body?.props.find((p): p is ast.RelationStringProperty => p.key === 'title')?.value
-    ) ?? ''
+
+    const bodyProps = mapToObj(
+      astNode.body?.props.filter(ast.isRelationStringProperty) ?? [],
+      p => [p.key, p.value || undefined]
+    )
+
+    const title = removeIndent(astNode.title ?? bodyProps.title) ?? ''
+    const description = removeIndent(bodyProps.description)
+    const technology = toSingleLine(bodyProps.technology)
+
     const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty)
     const id = stringHash(
       astPath,
@@ -195,6 +207,8 @@ export class LikeC4ModelParser {
       source,
       target,
       title,
+      ...(isTruthy(technology) && { technology }),
+      ...(isTruthy(description) && { description }),
       ...(kind && { kind }),
       ...(tags && { tags }),
       ...(isNonEmptyArray(links) && { links }),
@@ -221,23 +235,33 @@ export class LikeC4ModelParser {
   // TODO validate view rules
   private parseViewRulePredicate(astNode: ast.ViewRulePredicate, _isValid: IsValidFn): c4.ViewRulePredicate {
     const exprs = [] as c4.Expression[]
-    let exprNode: ast.Expressions | undefined = astNode.exprs
-    while (exprNode) {
+    let predicate: ast.Predicates | undefined = astNode.predicates
+    while (predicate) {
       try {
-        if (isTruthy(exprNode.value)) {
-          exprs.unshift(this.parseExpression(exprNode.value))
+        if (isTruthy(predicate.value) && _isValid(predicate.value as any)) {
+          exprs.unshift(this.parsePredicate(predicate.value, _isValid))
         }
       } catch (e) {
         logWarnError(e)
       }
-      exprNode = exprNode.prev
+      predicate = predicate.prev
     }
     return ast.isIncludePredicate(astNode) ? { include: exprs } : { exclude: exprs }
   }
 
+  private parsePredicate(astNode: ast.Predicate, _isValid: IsValidFn): c4.Expression {
+    if (ast.isElementPredicate(astNode)) {
+      return this.parseElementPredicate(astNode, _isValid)
+    }
+    if (ast.isRelationPredicate(astNode)) {
+      return this.parseRelationPredicate(astNode, _isValid)
+    }
+    nonexhaustive(astNode)
+  }
+
   private parseElementExpressionsIterator(astNode: ast.ElementExpressionsIterator): c4.ElementExpression[] {
     const exprs = [] as c4.ElementExpression[]
-    let iter: ast.ElementExpressionsIterator | undefined = astNode
+    let iter: ast.ElementExpressionsIterator['prev'] = astNode
     while (iter) {
       try {
         exprs.unshift(this.parseElementExpr(iter.value))
@@ -249,6 +273,19 @@ export class LikeC4ModelParser {
     return exprs
   }
 
+  private parseElementPredicate(astNode: ast.ElementPredicate, _isValid: IsValidFn): c4.ElementPredicateExpression {
+    if (ast.isElementPredicateWith(astNode)) {
+      return this.parseElementPredicateWith(astNode, _isValid)
+    }
+    if (ast.isElementPredicateWhere(astNode)) {
+      return this.parseElementPredicateWhere(astNode)
+    }
+    if (ast.isElementExpression(astNode)) {
+      return this.parseElementExpr(astNode)
+    }
+    nonexhaustive(astNode)
+  }
+
   private parseElementExpr(astNode: ast.ElementExpression): c4.ElementExpression {
     if (ast.isWildcardExpression(astNode)) {
       return {
@@ -301,25 +338,12 @@ export class LikeC4ModelParser {
     nonexhaustive(astNode)
   }
 
-  private parseCustomElementExpr(astNode: ast.CustomElementExpression): c4.CustomElementExpr {
-    let targetRef
-    switch (true) {
-      case ast.isElementRef(astNode.target):
-        targetRef = astNode.target
-        break
-      case ast.isExpandElementExpression(astNode.target):
-        targetRef = astNode.target.expand
-        break
-      case ast.isElementDescedantsExpression(astNode.target):
-        targetRef = astNode.target.parent
-        break
-      default:
-        throw new Error('Unsupported target of custom element')
-    }
-    const elementNode = elementRef(targetRef)
-    invariant(elementNode, 'element not found: ' + astNode.$cstNode?.text)
-    const element = this.resolveFqn(elementNode)
-    const props = astNode.custom.props ?? []
+  private parseElementPredicateWith(
+    astNode: ast.ElementPredicateWith,
+    _isValid: IsValidFn
+  ): c4.CustomElementExpr {
+    const expr = this.parseElementPredicate(astNode.subject, _isValid)
+    const props = astNode.custom?.props ?? []
     return props.reduce(
       (acc, prop) => {
         if (ast.isNavigateToProperty(prop)) {
@@ -362,21 +386,32 @@ export class LikeC4ModelParser {
       },
       {
         custom: {
-          element
+          expr
         }
       } as c4.CustomElementExpr
     )
   }
-
-  private parseExpression(astNode: ast.Expression): c4.Expression {
-    if (ast.isCustomRelationExpression(astNode)) {
-      return this.parseCustomRelationExpr(astNode)
+  private parseElementPredicateWhere(
+    astNode: ast.ElementPredicateWhere
+  ): c4.ElementWhereExpr {
+    const expr = this.parseElementExpr(astNode.subject)
+    return {
+      where: {
+        expr,
+        condition: astNode.where ? parseWhereClause(astNode.where) : {
+          kind: { neq: '--always-true--' }
+        }
+      }
     }
-    if (ast.isCustomElementExpression(astNode)) {
-      return this.parseCustomElementExpr(astNode)
+  }
+
+  private parseRelationPredicate(astNode: ast.RelationPredicate, _isValid: IsValidFn): c4.RelationPredicateExpression {
+    if (ast.isRelationPredicateWith(astNode)) {
+      const subject = ast.isRelationPredicateWhere(astNode.subject) ? astNode.subject.subject : astNode.subject
+      return this.parseRelationPredicateWith(astNode, subject)
     }
-    if (ast.isElementExpression(astNode)) {
-      return this.parseElementExpr(astNode)
+    if (ast.isRelationPredicateWhere(astNode)) {
+      return this.parseRelationPredicateWhere(astNode)
     }
     if (ast.isRelationExpression(astNode)) {
       return this.parseRelationExpr(astNode)
@@ -384,15 +419,32 @@ export class LikeC4ModelParser {
     nonexhaustive(astNode)
   }
 
-  private parseCustomRelationExpr(astNode: ast.CustomRelationExpression): c4.CustomRelationExpr {
-    const relation = this.parseRelationExpr(astNode.relation)
-    const props = astNode.custom.props ?? []
+  private parseRelationPredicateWhere(
+    astNode: ast.RelationPredicateWhere
+  ): c4.RelationWhereExpr {
+    const expr = this.parseRelationExpr(astNode.subject)
+    return {
+      where: {
+        expr,
+        condition: astNode.where ? parseWhereClause(astNode.where) : {
+          kind: { neq: '--always-true--' }
+        }
+      }
+    }
+  }
+
+  private parseRelationPredicateWith(
+    astNode: ast.RelationPredicateWith,
+    subject: ast.RelationExpression
+  ): c4.CustomRelationExpr {
+    const relation = this.parseRelationExpr(subject)
+    const props = astNode.custom?.props ?? []
     return props.reduce(
       (acc, prop) => {
         if (ast.isRelationStringProperty(prop)) {
           const value = removeIndent(prop.value)
           if (isTruthy(value)) {
-            acc.customRelation['title'] = value
+            acc.customRelation[prop.key] = value
           }
           return acc
         }
@@ -467,10 +519,21 @@ export class LikeC4ModelParser {
 
   private parseViewManualLaout(node: ast.DynamicView | ast.ElementView): c4.ViewManualLayout | undefined {
     const commentNode = CstUtils.findCommentNode(node.$cstNode, ['BLOCK_COMMENT'])
-    if (!commentNode) {
+    if (!commentNode || !hasManualLayout(commentNode.text)) {
+      return undefined
+    }
+    try {
+      return deserializeFromComment(commentNode.text)
+    } catch (e) {
+      const doc = getDocument(node)
+      logger.warn(e)
+      logger.warn(
+        `Ignoring manual layout of "${node.name ?? 'unnamed'}" at ${doc.uri.fsPath}:${
+          1 + (commentNode.range.start.line || 0)
+        }`
+      )
       return undefined
     }
-    return deserializeFromComment(commentNode.text)
   }
 
   private parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicViewStep {
@@ -482,23 +545,55 @@ 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)
+    const title = removeIndent(
+      node.title ?? node.custom?.props.find((p): p is ast.RelationStringProperty => p.key === 'title')?.value
+    ) ?? ''
+
+    let step: Writable<c4.DynamicViewStep> = {
+      source,
+      target,
+      title
+    }
     if (node.isBackward) {
-      return {
+      step = {
         source: target,
         target: source,
         title,
         isBackward: true
       }
     }
-
-    return {
-      source,
-      target,
-      title
+    if (Array.isArray(node.custom?.props)) {
+      for (const prop of node.custom.props) {
+        try {
+          if (ast.isRelationStringProperty(prop)) {
+            const value = removeIndent(prop.value)
+            if (isTruthy(value) && prop.key !== 'title') {
+              step[prop.key] = value
+            }
+            continue
+          }
+          if (ast.isArrowProperty(prop)) {
+            step[prop.key] = prop.value
+            continue
+          }
+          if (ast.isColorProperty(prop)) {
+            step[prop.key] = prop.value
+            continue
+          }
+          if (ast.isLineProperty(prop)) {
+            step[prop.key] = prop.value
+            continue
+          }
+          nonexhaustive(prop)
+        }
+        catch (e) {
+          logWarnError(e)
+        }
+      }
     }
+    return step
   }
 
   private parseElementView(astNode: ast.ElementView, isValid: IsValidFn): ParsedAstElementView {
@@ -568,7 +663,7 @@ export class LikeC4ModelParser {
 
   private parseDynamicElementView(astNode: ast.DynamicView, isValid: IsValidFn): ParsedAstDynamicView {
     const body = astNode.body
-    invariant(body, 'ElementView body is not defined')
+    invariant(body, 'DynamicElementView body is not defined')
     // only valid props
     const props = body.props.filter(isValid)
     const astPath = this.getAstNodePath(astNode)
@@ -604,21 +699,14 @@ export class LikeC4ModelParser {
           return acc
         }
         try {
-          if (ast.isDynamicViewRulePredicate(n)) {
-            const include = [] as (c4.ElementExpression | c4.CustomElementExpr)[]
-            let iter: ast.DynamicViewRulePredicateIterator | undefined = n.exprs
+          if (ast.isDynamicViewIncludePredicate(n)) {
+            const include = [] as c4.ElementPredicateExpression[]
+            let iter: ast.DynamicViewPredicateIterator | undefined = n.predicates
             while (iter) {
               try {
-                switch (true) {
-                  case ast.isElementExpression(iter.value):
-                    isValid(iter.value) && include.unshift(this.parseElementExpr(iter.value))
-                    break
-
-                  case ast.isCustomElementExpression(iter.value):
-                    isValid(iter.value) && include.unshift(this.parseCustomElementExpr(iter.value))
-                    break
-                  default:
-                    nonexhaustive(iter.value)
+                if (isValid(iter.value as any)) {
+                  const c4expr = this.parseElementPredicate(iter.value, isValid)
+                  include.unshift(c4expr)
                 }
               } catch (e) {
                 logWarnError(e)
@@ -683,10 +771,22 @@ export class LikeC4ModelParser {
   }
 
   private convertTags<E extends { tags?: ast.Tags }>(withTags?: E) {
-    if (!withTags) {
+    let iter = withTags?.tags
+    if (!iter) {
       return null
     }
-    const tags = withTags.tags?.value.flatMap(({ ref }) => (ref ? (ref.name as c4.Tag) : []))
+    const tags = [] as c4.Tag[]
+    while (iter) {
+      try {
+        const values = iter.values.map(t => t.ref?.name).filter(Boolean) as c4.Tag[]
+        if (values.length > 0) {
+          tags.unshift(...values)
+        }
+      } catch (e) {
+        // ignore
+      }
+      iter = iter.prev
+    }
     return isNonEmptyArray(tags) ? tags : null
   }
 }

package/src/model-change/ModelChanges.ts

@@ -1,5 +1,5 @@
 import { invariant, nonexhaustive } from '@likec4/core'
-import { Location, Range, TextEdit } from 'vscode-languageserver-protocol'
+import { Location, Range, TextEdit } from 'vscode-languageserver-types'
 import { type ParsedLikeC4LangiumDocument } from '../ast'
 import type { LikeC4ModelLocator } from '../model'
 import type { LikeC4Services } from '../module'
@@ -110,8 +110,7 @@ export class LikeC4ModelChanges {
       case 'save-manual-layout':
         const edit = saveManualLayout(this.services, {
           ...lookup,
-          nodes: change.nodes,
-          edges: change.edges
+          layout: change.layout
         })
         return {
           doc: lookup.doc,

package/src/model-change/changeElementStyle.ts

@@ -1,7 +1,7 @@
 import { type Fqn, invariant, isAncestor, type NonEmptyArray, nonNullable, type ViewChanges } from '@likec4/core'
 import { GrammarUtils } from 'langium'
 import { entries, filter, findLast, isTruthy, last } from 'remeda'
-import { type Range, TextEdit } from 'vscode-languageserver-protocol'
+import { type Range, TextEdit } from 'vscode-languageserver-types'
 import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast'
 import type { FqnIndex } from '../model'
 import type { LikeC4Services } from '../module'
@@ -55,6 +55,9 @@ export function changeElementStyle(services: LikeC4Services, {
   modifiedRange: Range
   edits: TextEdit[]
 } {
+  // Should never happen
+  invariant(viewAst.body, `View ${view.id} has no body`)
+
   const viewCstNode = viewAst.$cstNode
   invariant(viewCstNode, 'viewCstNode')
   const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end

package/src/model-change/changeViewLayout.ts

@@ -1,11 +1,10 @@
 import { type AutoLayoutDirection, invariant } from '@likec4/core'
 import { GrammarUtils } from 'langium'
-import { last } from 'remeda'
-import { TextEdit } from 'vscode-languageserver-protocol'
+import { TextEdit } from 'vscode-languageserver-types'
 import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument, toAstViewLayoutDirection } from '../ast'
 import type { LikeC4Services } from '../module'
 
-const { findNodeForProperty } = GrammarUtils
+const { findNodeForProperty, findNodeForKeyword } = GrammarUtils
 
 type ChangeViewLayoutArg = {
   view: ParsedAstView
@@ -15,9 +14,12 @@ type ChangeViewLayoutArg = {
 }
 
 export function changeViewLayout(_services: LikeC4Services, {
+  view,
   viewAst,
   layout
 }: ChangeViewLayoutArg): TextEdit {
+  // Should never happen
+  invariant(viewAst.body, `View ${view.id} has no body`)
   const viewCstNode = viewAst.$cstNode
   invariant(viewCstNode, 'viewCstNode')
   const newlayout = toAstViewLayoutDirection(layout)
@@ -31,11 +33,9 @@ export function changeViewLayout(_services: LikeC4Services, {
     return TextEdit.replace(existingRule.$cstNode.range, `autoLayout ${newlayout}`)
   }
 
-  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end
-    ?? viewAst.body.$cstNode?.range.end
-  invariant(insertPos, 'insertPos is not defined')
-  const indent = ' '.repeat(2 + viewCstNode.range.start.character)
-  const insert = `\n\n${indent}autoLayout ${newlayout}`
+  const insertPos = findNodeForKeyword(viewAst.body.$cstNode, '}')?.range.start
+  invariant(insertPos, 'Closing brace not found')
+  const insert = `\n  autoLayout ${newlayout}\n`
 
   return TextEdit.insert(insertPos, insert)
 }

package/src/model-change/saveManualLayout.ts

@@ -1,7 +1,7 @@
 import { invariant, type ViewChanges } from '@likec4/core'
 import indentString from 'indent-string'
 import { CstUtils, GrammarUtils } from 'langium'
-import { TextEdit } from 'vscode-languageserver-protocol'
+import { TextEdit } from 'vscode-languageserver-types'
 import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast'
 import type { LikeC4Services } from '../module'
 import { serializeToComment } from '../view-utils/manual-layout'
@@ -12,18 +12,16 @@ export type ManualLayoutArg = {
   view: ParsedAstView
   doc: ParsedLikeC4LangiumDocument
   viewAst: ast.LikeC4View
-  nodes: ViewChanges.SaveManualLayout['nodes']
-  edges: ViewChanges.SaveManualLayout['edges']
+  layout: ViewChanges.SaveManualLayout['layout']
 }
 
 export function saveManualLayout(_services: LikeC4Services, {
   viewAst,
-  nodes,
-  edges
+  layout
 }: ManualLayoutArg): TextEdit {
   invariant(viewAst.$cstNode, 'invalid view.$cstNode')
   const commentCst = CstUtils.findCommentNode(viewAst.$cstNode, ['BLOCK_COMMENT'])
-  let txt = serializeToComment({ nodes, edges })
+  let txt = serializeToComment(layout)
   if (viewAst.$cstNode.range.start.character > 0) {
     txt = indentString(txt, viewAst.$cstNode.range.start.character)
     // const indent = ' '.repeat(viewAst.$cstNode.range.start.character)