@likec4/language-server 1.17.1 → 1.19.0

package/src/model/parser/ViewsParser.ts

@@ -0,0 +1,428 @@
+import type * as c4 from '@likec4/core'
+import { invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
+import { isArray, isDefined, isNonNullish, isTruthy } from 'remeda'
+import type { Writable } from 'type-fest'
+import {
+  ast,
+  type ParsedAstDynamicView,
+  type ParsedAstElementView,
+  toAutoLayout,
+  toColor,
+  toElementStyle,
+  ViewOps
+} from '../../ast'
+import type { NotationProperty } from '../../generated/ast'
+import { logger, logWarnError } from '../../logger'
+import { stringHash } from '../../utils'
+import { elementRef } from '../../utils/elementRef'
+import { parseViewManualLayout } from '../../view-utils/manual-layout'
+import { removeIndent, toSingleLine } from './Base'
+import type { WithDeploymentView } from './DeploymentViewParser'
+import type { WithPredicates } from './PredicatesParser'
+
+export type WithViewsParser = ReturnType<typeof ViewsParser>
+
+export function ViewsParser<TBase extends WithPredicates & WithDeploymentView>(B: TBase) {
+  return class ViewsParser extends B {
+    parseViews() {
+      const isValid = this.isValid
+      for (const viewBlock of this.doc.parseResult.value.views) {
+        const localStyles = viewBlock.styles.flatMap(s => {
+          try {
+            return isValid(s) ? this.parseViewRuleStyleOrGlobalRef(s) : []
+          } catch (e) {
+            logWarnError(e)
+            return []
+          }
+        })
+
+        for (const view of viewBlock.views) {
+          try {
+            if (!isValid(view)) {
+              continue
+            }
+            switch (true) {
+              case ast.isElementView(view):
+                this.doc.c4Views.push(this.parseElementView(view, localStyles))
+                break
+              case ast.isDynamicView(view):
+                this.doc.c4Views.push(this.parseDynamicElementView(view, localStyles))
+                break
+              case ast.isDeploymentView(view):
+                this.doc.c4Views.push(this.parseDeploymentView(view))
+                break
+              default:
+                nonexhaustive(view)
+            }
+          } catch (e) {
+            logWarnError(e)
+          }
+        }
+      }
+    }
+
+    parseElementView(astNode: ast.ElementView, additionalStyles: c4.ViewRuleStyleOrGlobalRef[]): ParsedAstElementView {
+      const body = astNode.body
+      invariant(body, 'ElementView body is not defined')
+      const astPath = this.getAstNodePath(astNode)
+
+      let viewOf = null as c4.Fqn | null
+      if ('viewOf' in astNode) {
+        const viewOfEl = elementRef(astNode.viewOf)
+        const _viewOf = viewOfEl && this.resolveFqn(viewOfEl)
+        if (!_viewOf) {
+          logger.warn('viewOf is not resolved: ' + astNode.$cstNode?.text)
+        } else {
+          viewOf = _viewOf
+        }
+      }
+
+      let id = astNode.name
+      if (!id) {
+        id = 'view_' + stringHash(
+          this.doc.uri.toString(),
+          astPath,
+          viewOf ?? ''
+        ) as c4.ViewId
+      }
+
+      const title = toSingleLine(body.props.find(p => p.key === 'title')?.value) ?? null
+      const description = removeIndent(body.props.find(p => p.key === 'description')?.value) ?? null
+
+      const tags = this.convertTags(body)
+      const links = this.convertLinks(body)
+
+      const manualLayout = parseViewManualLayout(astNode)
+
+      const view: ParsedAstElementView = {
+        __: 'element',
+        id: id as c4.ViewId,
+        astPath,
+        title,
+        description,
+        tags,
+        links: isNonEmptyArray(links) ? links : null,
+        rules: [
+          ...additionalStyles,
+          ...body.rules.flatMap(n => {
+            try {
+              return this.isValid(n) ? this.parseViewRule(n) : []
+            } catch (e) {
+              logWarnError(e)
+              return []
+            }
+          })
+        ],
+        ...(viewOf && { viewOf }),
+        ...(manualLayout && { manualLayout })
+      }
+      ViewOps.writeId(astNode, view.id)
+
+      if ('extends' in astNode) {
+        const extendsView = astNode.extends.view.ref
+        invariant(extendsView?.name, 'view extends is not resolved: ' + astNode.$cstNode?.text)
+        return Object.assign(view, {
+          extends: extendsView.name as c4.ViewId
+        })
+      }
+
+      return view
+    }
+
+    parseViewRule(astRule: ast.ViewRule): c4.ViewRule {
+      if (ast.isViewRulePredicate(astRule)) {
+        return this.parseViewRulePredicate(astRule)
+      }
+      if (ast.isViewRuleGlobalPredicateRef(astRule)) {
+        return this.parseViewRuleGlobalPredicateRef(astRule)
+      }
+      if (ast.isViewRuleStyleOrGlobalRef(astRule)) {
+        return this.parseViewRuleStyleOrGlobalRef(astRule)
+      }
+      if (ast.isViewRuleAutoLayout(astRule)) {
+        return toAutoLayout(astRule)
+      }
+      if (ast.isViewRuleGroup(astRule)) {
+        return this.parseViewRuleGroup(astRule)
+      }
+      nonexhaustive(astRule)
+    }
+
+    parseViewRulePredicate(astNode: ast.ViewRulePredicate): c4.ViewRulePredicate {
+      const exprs = [] as c4.Expression[]
+      let predicate = astNode.predicates
+      while (predicate) {
+        const { value, prev } = predicate
+        try {
+          if (isTruthy(value) && this.isValid(value as any)) {
+            exprs.unshift(this.parsePredicate(value))
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+        if (!prev) {
+          break
+        }
+        predicate = prev
+      }
+      return ast.isIncludePredicate(astNode) ? { include: exprs } : { exclude: exprs }
+    }
+
+    parseViewRuleGlobalPredicateRef(
+      astRule: ast.ViewRuleGlobalPredicateRef | ast.DynamicViewGlobalPredicateRef
+    ): c4.ViewRuleGlobalPredicateRef {
+      return {
+        predicateId: astRule.predicate.$refText as c4.GlobalPredicateId
+      }
+    }
+
+    parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): c4.ViewRuleStyleOrGlobalRef {
+      if (ast.isViewRuleStyle(astRule)) {
+        return this.parseViewRuleStyle(astRule)
+      }
+      if (ast.isViewRuleGlobalStyle(astRule)) {
+        return this.parseViewRuleGlobalStyle(astRule)
+      }
+      nonexhaustive(astRule)
+    }
+
+    parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ViewRuleGroup {
+      const groupRules = [] as c4.ViewRuleGroup['groupRules']
+      for (const rule of astNode.groupRules) {
+        try {
+          if (!this.isValid(rule)) {
+            continue
+          }
+          if (ast.isViewRulePredicate(rule)) {
+            groupRules.push(this.parseViewRulePredicate(rule))
+            continue
+          }
+          if (ast.isViewRuleGroup(rule)) {
+            groupRules.push(this.parseViewRuleGroup(rule))
+            continue
+          }
+          nonexhaustive(rule)
+        } catch (e) {
+          logWarnError(e)
+        }
+      }
+      return {
+        title: toSingleLine(astNode.title) ?? null,
+        groupRules,
+        ...toElementStyle(astNode.props, this.isValid)
+      }
+    }
+
+    parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ViewRuleStyle {
+      const styleProps = astRule.props.filter(ast.isStyleProperty)
+      const targets = astRule.target
+      const notation = astRule.props.find(ast.isNotationProperty)
+      return this.parseRuleStyle(styleProps, targets, notation)
+    }
+
+    parseRuleStyle(
+      styleProperties: ast.StyleProperty[],
+      elementExpressionsIterator: ast.ElementExpressionsIterator,
+      notationProperty?: NotationProperty
+    ): c4.ViewRuleStyle {
+      const styleProps = toElementStyle(styleProperties, this.isValid)
+      const notation = removeIndent(notationProperty?.value)
+      const targets = this.parseElementExpressionsIterator(elementExpressionsIterator)
+      return {
+        targets,
+        ...(notation && { notation }),
+        style: {
+          ...styleProps
+        }
+      }
+    }
+
+    parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle {
+      return {
+        styleId: astRule.style.$refText as c4.GlobalStyleID
+      }
+    }
+
+    parseDynamicElementView(
+      astNode: ast.DynamicView,
+      additionalStyles: c4.ViewRuleStyleOrGlobalRef[]
+    ): ParsedAstDynamicView {
+      const body = astNode.body
+      invariant(body, 'DynamicElementView body is not defined')
+      // only valid props
+      const isValid = this.isValid
+      const props = body.props.filter(isValid)
+      const astPath = this.getAstNodePath(astNode)
+
+      let id = astNode.name
+      if (!id) {
+        id = 'dynamic_' + stringHash(
+          this.doc.uri.toString(),
+          astPath
+        ) as c4.ViewId
+      }
+
+      const title = toSingleLine(props.find(p => p.key === 'title')?.value) ?? null
+      const description = removeIndent(props.find(p => p.key === 'description')?.value) ?? null
+
+      const tags = this.convertTags(body)
+      const links = this.convertLinks(body)
+
+      ViewOps.writeId(astNode, id as c4.ViewId)
+
+      const manualLayout = parseViewManualLayout(astNode)
+
+      return {
+        __: 'dynamic',
+        id: id as c4.ViewId,
+        astPath,
+        title,
+        description,
+        tags,
+        links: isNonEmptyArray(links) ? links : null,
+        rules: [
+          ...additionalStyles,
+          ...body.rules.flatMap(n => {
+            try {
+              return isValid(n) ? this.parseDynamicViewRule(n) : []
+            } catch (e) {
+              logWarnError(e)
+              return []
+            }
+          }, [] as Array<c4.DynamicViewRule>)
+        ],
+        steps: body.steps.reduce((acc, n) => {
+          try {
+            if (isValid(n)) {
+              if (ast.isDynamicViewParallelSteps(n)) {
+                acc.push(this.parseDynamicParallelSteps(n))
+              } else {
+                acc.push(this.parseDynamicStep(n))
+              }
+            }
+          } catch (e) {
+            logWarnError(e)
+          }
+          return acc
+        }, [] as c4.DynamicViewStepOrParallel[]),
+        ...(manualLayout && { manualLayout })
+      }
+    }
+
+    parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule {
+      if (ast.isDynamicViewIncludePredicate(astRule)) {
+        return this.parseDynamicViewIncludePredicate(astRule)
+      }
+      if (ast.isDynamicViewGlobalPredicateRef(astRule)) {
+        return this.parseViewRuleGlobalPredicateRef(astRule)
+      }
+      if (ast.isViewRuleStyleOrGlobalRef(astRule)) {
+        return this.parseViewRuleStyleOrGlobalRef(astRule)
+      }
+      if (ast.isViewRuleAutoLayout(astRule)) {
+        return toAutoLayout(astRule)
+      }
+      nonexhaustive(astRule)
+    }
+
+    parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule {
+      const include = [] as c4.ElementPredicateExpression[]
+      let iter: ast.DynamicViewPredicateIterator | undefined = astRule.predicates
+      while (iter) {
+        try {
+          if (isNonNullish(iter.value) && this.isValid(iter.value as any)) {
+            const c4expr = this.parseElementPredicate(iter.value)
+            include.unshift(c4expr)
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+        iter = iter.prev
+      }
+      return { include }
+    }
+
+    parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicViewParallelSteps {
+      return {
+        __parallel: node.steps.map(step => this.parseDynamicStep(step))
+      }
+    }
+
+    parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicViewStep {
+      const sourceEl = elementRef(node.source)
+      if (!sourceEl) {
+        throw new Error('Invalid reference to source')
+      }
+      const targetEl = elementRef(node.target)
+      if (!targetEl) {
+        throw new Error('Invalid reference to target')
+      }
+      let source = this.resolveFqn(sourceEl)
+      let target = this.resolveFqn(targetEl)
+      const title = removeIndent(node.title) ?? null
+
+      let step: Writable<c4.DynamicViewStep> = {
+        source,
+        target,
+        title
+      }
+      if (node.isBackward) {
+        step = {
+          source: target,
+          target: source,
+          title,
+          isBackward: true
+        }
+      }
+      if (!isArray(node.custom?.props)) {
+        return step
+      }
+      for (const prop of node.custom.props) {
+        try {
+          switch (true) {
+            case ast.isRelationNavigateToProperty(prop): {
+              const viewId = prop.value.view.ref?.name
+              if (isTruthy(viewId)) {
+                step.navigateTo = viewId as c4.ViewId
+              }
+              break
+            }
+            case ast.isRelationStringProperty(prop):
+            case ast.isNotationProperty(prop):
+            case ast.isNotesProperty(prop): {
+              if (isDefined(prop.value)) {
+                step[prop.key] = removeIndent(prop.value) ?? ''
+              }
+              break
+            }
+            case ast.isArrowProperty(prop): {
+              if (isDefined(prop.value)) {
+                step[prop.key] = prop.value
+              }
+              break
+            }
+            case ast.isColorProperty(prop): {
+              const value = toColor(prop)
+              if (isDefined(value)) {
+                step[prop.key] = value
+              }
+              break
+            }
+            case ast.isLineProperty(prop): {
+              if (isDefined(prop.value)) {
+                step[prop.key] = prop.value
+              }
+              break
+            }
+            default:
+              nonexhaustive(prop)
+          }
+        }
+        catch (e) {
+          logWarnError(e)
+        }
+      }
+      return step
+    }
+  }
+}

package/src/model-change/changeViewLayout.ts

@@ -1,6 +1,6 @@
 import { invariant, type ViewChange } from '@likec4/core'
 import { GrammarUtils } from 'langium'
-import { isNumber } from 'remeda'
+import { findLast, isNumber } from 'remeda'
 import { TextEdit } from 'vscode-languageserver-types'
 import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument, toAstViewLayoutDirection } from '../ast'
 import type { LikeC4Services } from '../module'
@@ -24,7 +24,7 @@ export function changeViewLayout(_services: LikeC4Services, {
   const viewCstNode = viewAst.$cstNode
   invariant(viewCstNode, 'viewCstNode')
   const newdirection = toAstViewLayoutDirection(layout.direction)
-  const existingRule = viewAst.body.rules.findLast(ast.isViewRuleAutoLayout) as ast.ViewRuleAutoLayout | undefined
+  const existingRule = findLast(viewAst.body.rules, ast.isViewRuleAutoLayout) as ast.ViewRuleAutoLayout | undefined
 
   let newRule = `autoLayout ${newdirection}`
 

package/src/module.ts

@@ -1,15 +1,16 @@
-import { EmptyFileSystem, inject, type Module, WorkspaceCache } from 'langium'
+import { type Module, DocumentCache, EmptyFileSystem, inject, WorkspaceCache } from 'langium'
 import {
-  createDefaultModule,
-  createDefaultSharedModule,
   type DefaultSharedModuleContext,
   type LangiumServices,
   type LangiumSharedServices,
   type PartialLangiumServices,
-  type PartialLangiumSharedServices
+  type PartialLangiumSharedServices,
+  createDefaultModule,
+  createDefaultSharedModule,
 } from 'langium/lsp'
+import { LikeC4Formatter } from './formatting/LikeC4Formatter'
 import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from './generated/module'
-import { logErrorToTelemetry, logToLspConnection } from './logger'
+import { logToLspConnection } from './logger'
 import {
   LikeC4CodeLensProvider,
   LikeC4CompletionProvider,
@@ -17,15 +18,14 @@ import {
   LikeC4DocumentLinkProvider,
   LikeC4DocumentSymbolProvider,
   LikeC4HoverProvider,
-  LikeC4SemanticTokenProvider
+  LikeC4SemanticTokenProvider,
 } from './lsp'
-import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model'
+import { DeploymentsIndex, FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model'
 import { LikeC4ModelChanges } from './model-change/ModelChanges'
-import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references'
+import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from './references'
 import { Rpc } from './Rpc'
 import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from './shared'
 import { registerValidationChecks } from './validation'
-import { LikeC4Formatter } from './formatting/LikeC4Formatter'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T
@@ -48,11 +48,11 @@ const LikeC4SharedModule: Module<
 > = {
   lsp: {
     NodeKindProvider: services => new NodeKindProvider(services),
-    WorkspaceSymbolProvider: services => new WorkspaceSymbolProvider(services)
+    WorkspaceSymbolProvider: services => new WorkspaceSymbolProvider(services),
   },
   workspace: {
-    WorkspaceManager: services => new LikeC4WorkspaceManager(services)
-  }
+    WorkspaceManager: services => new LikeC4WorkspaceManager(services),
+  },
 }
 
 /**
@@ -61,8 +61,10 @@ const LikeC4SharedModule: Module<
 export interface LikeC4AddedServices {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   WorkspaceCache: WorkspaceCache<string, any>
+  DocumentCache: DocumentCache<string, any>
   Rpc: Rpc
   likec4: {
+    DeploymentsIndex: DeploymentsIndex
     FqnIndex: FqnIndex
     ModelParser: LikeC4ModelParser
     ModelBuilder: LikeC4ModelBuilder
@@ -80,6 +82,7 @@ export interface LikeC4AddedServices {
     DocumentLinkProvider: LikeC4DocumentLinkProvider
   }
   references: {
+    NameProvider: LikeC4NameProvider
     ScopeComputation: LikeC4ScopeComputation
     ScopeProvider: LikeC4ScopeProvider
   }
@@ -94,13 +97,15 @@ function bind<T>(Type: Constructor<T, [LikeC4Services]>) {
 
 export const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices> = {
   WorkspaceCache: (services: LikeC4Services) => new WorkspaceCache(services.shared),
+  DocumentCache: (services: LikeC4Services) => new DocumentCache(services.shared),
   Rpc: bind(Rpc),
   likec4: {
+    DeploymentsIndex: bind(DeploymentsIndex),
     ModelChanges: bind(LikeC4ModelChanges),
     FqnIndex: bind(FqnIndex),
     ModelParser: bind(LikeC4ModelParser),
     ModelBuilder: bind(LikeC4ModelBuilder),
-    ModelLocator: bind(LikeC4ModelLocator)
+    ModelLocator: bind(LikeC4ModelLocator),
   },
   lsp: {
     // RenameProvider: bind(LikeC4RenameProvider),
@@ -111,12 +116,13 @@ export const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC
     HoverProvider: bind(LikeC4HoverProvider),
     CodeLensProvider: bind(LikeC4CodeLensProvider),
     DocumentLinkProvider: bind(LikeC4DocumentLinkProvider),
-    Formatter: bind(LikeC4Formatter)
+    Formatter: bind(LikeC4Formatter),
   },
   references: {
+    NameProvider: bind(LikeC4NameProvider),
     ScopeComputation: bind(LikeC4ScopeComputation),
-    ScopeProvider: bind(LikeC4ScopeProvider)
-  }
+    ScopeProvider: bind(LikeC4ScopeProvider),
+  },
 }
 
 export type LanguageServicesContext = Partial<DefaultSharedModuleContext>
@@ -125,7 +131,7 @@ export function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3
   context: LanguageServicesContext,
   module: Module<I, I1>,
   module2?: Module<I, I2>,
-  module3?: Module<I, I3>
+  module3?: Module<I, I3>,
 ): { shared: LikeC4SharedServices; likec4: I } {
   const shared = createSharedServices(context)
   const modules = [
@@ -134,7 +140,7 @@ export function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3
     LikeC4Module,
     module,
     module2,
-    module3
+    module3,
   ].reduce(_merge, {}) as Module<I>
 
   const likec4 = inject(modules)
@@ -155,17 +161,16 @@ export function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3
 export function createSharedServices(context: LanguageServicesContext = {}): LikeC4SharedServices {
   const moduleContext: DefaultSharedModuleContext = {
     ...EmptyFileSystem,
-    ...context
+    ...context,
   }
   if (context.connection) {
     logToLspConnection(context.connection)
-    logErrorToTelemetry(context.connection)
   }
 
   return inject(
     createDefaultSharedModule(moduleContext),
     LikeC4GeneratedSharedModule,
-    LikeC4SharedModule
+    LikeC4SharedModule,
   )
 }
 

package/src/protocol.ts

@@ -3,9 +3,9 @@ import type {
   ComputedView,
   Fqn,
   ParsedLikeC4Model,
-  RelationID,
+  RelationId,
   ViewChange,
-  ViewID
+  ViewId
 } from '@likec4/core'
 import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc'
 import type { DocumentUri, Location } from 'vscode-languageserver-types'
@@ -30,7 +30,7 @@ export const fetchComputedModel = new RequestType<
 )
 export type FetchComputedModelRequest = typeof fetchComputedModel
 
-export const computeView = new RequestType<{ viewId: ViewID }, { view: ComputedView | null }, void>(
+export const computeView = new RequestType<{ viewId: ViewId }, { view: ComputedView | null }, void>(
   'likec4/computeView'
 )
 export type ComputeViewRequest = typeof computeView
@@ -47,17 +47,21 @@ export type LocateParams =
     property?: string
   }
   | {
-    relation: RelationID
+    relation: RelationId
   }
   | {
-    view: ViewID
+    deployment: Fqn
+    property?: string
+  }
+  | {
+    view: ViewId
   }
 export const locate = new RequestType<LocateParams, Location | null, void>('likec4/locate')
 export type LocateRequest = typeof locate
 // #endregion
 
 export interface ChangeViewRequestParams {
-  viewId: ViewID
+  viewId: ViewId
   change: ViewChange
 }
 export const changeView = new RequestType<ChangeViewRequestParams, Location | null, void>('likec4/change-view')

package/src/references/index.ts

@@ -1,2 +1,3 @@
+export * from './name-provider'
 export * from './scope-computation'
 export * from './scope-provider'

package/src/references/name-provider.ts

@@ -0,0 +1,37 @@
+import { nonNullable } from '@likec4/core'
+import { type AstNode, type CstNode, DefaultNameProvider, isNamed, type NamedAstNode } from 'langium'
+import { ast } from '../ast'
+import type { LikeC4Services } from '../module'
+
+export class LikeC4NameProvider extends DefaultNameProvider {
+  constructor(protected services: LikeC4Services) {
+    super()
+  }
+
+  public getNameStrict(node: AstNode): string {
+    return nonNullable(
+      this.getName(node),
+      `Failed getName for ${this.services.workspace.AstNodeLocator.getAstNodePath(node)}`
+    )
+  }
+
+  override getName(node: AstNode): string | undefined {
+    if (isNamed(node)) {
+      return node.name
+    }
+    if (ast.isDeployedInstance(node)) {
+      return node.element.el.$refText
+    }
+    return undefined
+  }
+
+  override getNameNode(node: AstNode): CstNode | undefined {
+    if (isNamed(node)) {
+      return super.getNameNode(node)
+    }
+    if (ast.isDeployedInstance(node)) {
+      return node.element.el.$refNode
+    }
+    return undefined
+  }
+}