@likec4/language-server 1.18.0 → 1.19.1

package/src/index.ts

@@ -1,26 +1,30 @@
 import { startLanguageServer as startLanguim } from 'langium/lsp'
 import { createConnection, ProposedFeatures } from 'vscode-languageserver/node'
 import { LikeC4FileSystem } from './LikeC4FileSystem'
-import { createLanguageServices } from './module'
+import { type LikeC4Services, type LikeC4SharedServices, createCustomLanguageServices } from './module'
+import { ConfigurableLayouter } from './views/configurable-layouter'
 
 export { logger as lspLogger, setLogLevel } from './logger'
-export type * from './model'
-export type * from './module'
+
+export type { DocumentParser, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model'
+
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from './module'
+export type { LikeC4Services, LikeC4SharedServices } from './module'
+export type { LikeC4Views } from './views'
 export { LikeC4FileSystem }
 
-export function startLanguageServer() {
+export function startLanguageServer(): {
+  shared: LikeC4SharedServices
+  likec4: LikeC4Services
+} {
   /* browser specific setup code */
   const connection = createConnection(ProposedFeatures.all)
 
   // Inject the shared services and language-specific services
-  const services = createLanguageServices({ connection, ...LikeC4FileSystem })
+  const services = createCustomLanguageServices({ connection, ...LikeC4FileSystem }, ConfigurableLayouter)
 
   // Start the language server with the shared services
   startLanguim(services.shared)
 
-  return {
-    ...services,
-    connection
-  }
+  return services
 }

package/src/like-c4.langium

@@ -545,7 +545,7 @@ DeploymentNodeBody: '{'
 
 DeployedInstance:
   (name=Id Eq)?
-  ('instanceOf' | 'instance' 'of')
+  'instanceOf'
   element=ElementRef
   title=String?
   body=DeployedInstanceBody?
@@ -557,18 +557,20 @@ DeployedInstanceBody: '{'
   props+=ElementProperty*
 '}';
 
-// Rules:
-// - DeployedInstance can be referenced from DeploymentNode
-// - Element can be referenced from DeployedInstance
-// Forced by scope computation
-type DeploymentReferenceable = DeploymentNode | DeployedInstance | Element;
-DeploymentRef:
-  value=[DeploymentReferenceable:Id] ({infer DeploymentRef.parent=current} StickyDot value=[DeploymentReferenceable:Id])*;
+type Referenceable = DeploymentNode | DeployedInstance | Element;
+// Reference to Elements in logical or deployment model
+// Scope computation is based on the parent element:
+//  - If parent is DeploymentNode, then it can reference nested DeploymentNodes and DeployedInstances
+//  - If parent is DeployedInstance, then it can reference  nested  Element
+//  - If parent is Element, then it can reference  nested  Element
+//  Mix of DeploymentRef and ElementRef
+FqnRef:
+  value=[Referenceable:Id] ({infer FqnRef.parent=current} StickyDot value=[Referenceable:Id])*;
 
 DeploymentRelation:
-  source=DeploymentRef
+  source=FqnRef
   ('->' | '-[' kind=[RelationshipKind:Id] ']->' | kind=[RelationshipKind:DotId])
-  target=DeploymentRef
+  target=FqnRef
   (
     title=String
     technology=String?
@@ -600,7 +602,7 @@ DeploymentViewRule:
 ;
 
 DeploymentViewRuleStyle:
-  'style' target=DeploymentExpressionIterator '{'
+  'style' targets=FqnExpressions '{'
     props+=(
       StyleProperty |
       NotationProperty
@@ -614,46 +616,47 @@ DeploymentViewRulePredicate:
 ;
 
 DeploymentViewRulePredicateExpression:
-  value=DeploymentExpression ({infer DeploymentViewRulePredicateExpression.prev=current} ',' (value=DeploymentExpression)?)*
+  value=ExpressionV2 ({infer DeploymentViewRulePredicateExpression.prev=current} ',' (value=ExpressionV2)?)*
 ;
 
-DeploymentExpression:
-  DeploymentRelationExpression |
-  DeploymentElementExpression
+ExpressionV2:
+  RelationExpr |
+  FqnExpr
 ;
 
-DeploymentElementExpression:
+
+FqnExpr:
   {infer WildcardExpression} isWildcard?='*' |
-  DeploymentRefExpression
+  FqnRefExpr
 ;
 
-DeploymentRefExpression:
-  ref=DeploymentRef selector=(DotUnderscore | DotWildcard)?
+FqnRefExpr:
+  ref=FqnRef selector=(DotUnderscore | DotWildcard)?
 ;
 
-DeploymentRelationExpression:
-  InOutDeploymentRelationExpression |
-  DirectedDeploymentRelationExpression
+RelationExpr:
+  InOutRelationExpr |
+  DirectedRelationExpr
 ;
 
-InOutDeploymentRelationExpression infers DeploymentRelationExpression:
-  IncomingDeploymentRelationExpression ({infer InOutDeploymentRelationExpression.inout=current} '->')?
+InOutRelationExpr infers RelationExpr:
+  IncomingRelationExpr ({infer InOutRelationExpr.inout=current} '->')?
 ;
 
-IncomingDeploymentRelationExpression:
-  '->' to=DeploymentElementExpression;
+IncomingRelationExpr:
+  '->' to=FqnExpr;
 
-DirectedDeploymentRelationExpression infers DeploymentRelationExpression:
-  OutgoingDeploymentRelationExpression ({infer DirectedDeploymentRelationExpression.source=current} target=DeploymentElementExpression)?
+DirectedRelationExpr infers RelationExpr:
+  OutgoingRelationExpr ({infer DirectedRelationExpr.source=current} target=FqnExpr)?
 ;
 
-OutgoingDeploymentRelationExpression:
-  from=DeploymentElementExpression
+OutgoingRelationExpr:
+  from=FqnExpr
   (isBidirectional?='<->' | '->' | '-[' kind=[RelationshipKind:Id] ']->' | kind=[RelationshipKind:DotId])
 ;
 
-DeploymentExpressionIterator:
-  value=DeploymentElementExpression ({infer DeploymentExpressionIterator.prev=current} ',' (value=DeploymentElementExpression)?)*
+FqnExpressions:
+  value=FqnExpr ({infer FqnExpressions.prev=current} ',' (value=FqnExpr)?)*
 ;
 // Global -------------------------------------
 
@@ -691,7 +694,7 @@ GlobalStyleGroup:
     styles+=ViewRuleStyle*
   '}';
 
-type FqnReferenceable = DeploymentReferenceable | Element | ExtendElement;
+type FqnReferenceable = Referenceable | Element | ExtendElement;
 
 // Common properties -------------------------------------
 
@@ -783,7 +786,7 @@ CustomColorId returns string:
   IdTerminal | ElementShape | ArrowType | LineOptions | 'element' | 'model';
 
 Id returns string:
-  IdTerminal | ElementShape | ThemeColor | ArrowType | LineOptions | 'element' | 'model' | 'group' | 'node' | 'deployment';
+  IdTerminal | ElementShape | ThemeColor | ArrowType | LineOptions | 'element' | 'model' | 'group' | 'node' | 'deployment' | 'instance';
 
 fragment EqOperator:
   (

package/src/logger.ts

@@ -1,6 +1,6 @@
-import { type ConsolaReporter, LogLevels, rootLogger as root } from '@likec4/log'
+import { nonexhaustive } from '@likec4/core'
+import { type ConsolaReporter, formatLogObj, LogLevels, rootLogger as root } from '@likec4/log'
 import { BROWSER } from 'esm-env'
-import { isError } from 'remeda'
 import type { Connection } from 'vscode-languageserver'
 
 export const logger = root.withTag('lsp')
@@ -22,76 +22,55 @@ export function setLogLevel(level: keyof typeof LogLevels): void {
   logger.level = LogLevels[level]
 }
 
-export function logErrorToTelemetry(connection: Connection): void {
-  const reporter: ConsolaReporter = {
-    log: ({ level, ...logObj }, ctx) => {
-      if (level !== LogLevels.error && level !== LogLevels.fatal) {
-        return
-      }
-      const tag = logObj.tag || ''
-      const parts = logObj.args.map((arg) => {
-        if (isError(arg)) {
-          return arg.stack ?? arg.message
-        }
-        if (typeof arg === 'string') {
-          return arg
-        }
-        return '' + arg
-      })
-      if (tag) {
-        parts.unshift(`[${tag}]`)
-      }
-      const message = parts.join(' ')
-      connection.telemetry.logEvent({ eventName: 'error', error: message })
-    }
-  }
-  root.addReporter(reporter)
-  logger.setReporters(root.options.reporters)
-}
-
 export function logToLspConnection(connection: Connection): void {
   const reporter: ConsolaReporter = {
-    log: ({ level, ...logObj }, ctx) => {
-      const tag = logObj.tag || ''
-      const parts = logObj.args.map((arg) => {
-        if (isError(arg)) {
-          return arg.stack ?? arg.message
+    log: (logObj, _ctx) => {
+      const { message, error } = formatLogObj(logObj)
+      switch (logObj.type) {
+        case 'silent': {
+          // ignore
+          break
         }
-        if (typeof arg === 'string') {
-          return arg
+        case 'verbose':
+        case 'trace': {
+          connection.tracer.log(message)
+          break
         }
-        return '' + arg
-      })
-      if (tag) {
-        parts.unshift(`[${tag}]`)
-      }
-      const message = parts.join(' ')
-      switch (true) {
-        case level >= LogLevels.debug: {
+        case 'debug': {
           connection.console.debug(message)
           break
         }
-        // case level >= LogLevels.info: {
-        //   connection.console.info(message)
-        //   break
-        // }
-        case level >= LogLevels.log: {
+        case 'log': {
+          connection.console.log(message)
+          break
+        }
+        case 'info':
+        case 'box':
+        case 'ready':
+        case 'start':
+        case 'success': {
           connection.console.info(message)
           break
         }
-        case level >= LogLevels.warn: {
+        case 'warn': {
           connection.console.warn(message)
           break
         }
-        case level >= LogLevels.fatal: {
+        case 'fail':
+        case 'error':
+        case 'fatal': {
           connection.console.error(message)
+          if (error) {
+            connection.telemetry.logEvent({ eventName: 'error', ...error })
+          } else {
+            connection.telemetry.logEvent({ eventName: 'error', message })
+          }
           break
         }
-        default: {
-          connection.console.log(message)
-        }
+        default:
+          nonexhaustive(logObj.type)
       }
-    }
+    },
   }
   if (BROWSER) {
     root.addReporter(reporter)

package/src/lsp/CompletionProvider.ts

@@ -32,7 +32,7 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
           'deployment view ${1:view_${TM_FILENAME_BASE}_${CURRENT_SECOND}} {',
           '\ttitle \'${2:Untitled}\'',
           '\t',
-          '\t$0',
+          '\tinclude $0',
           '}'
         ].join('\n')
       })
@@ -89,7 +89,7 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
           detail: `Insert ${keyword.value} block`,
           kind: CompletionItemKind.Module,
           insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} \${1:name} \${2:*} {\n\t\${3|color,shape,border,opacity,icon|} \$0\n}`
+          insertText: `${keyword.value} \${1:name} \${2:*} {\n\t\${3|color,shape,border,opacity,icon|} $0\n}`
         })
       }
       if (AstUtils.hasContainerOfType(context.node, anyPass([ast.isModelViews, ast.isGlobalStyleGroup]))) {
@@ -98,7 +98,7 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
           detail: `Insert ${keyword.value} block`,
           kind: CompletionItemKind.Module,
           insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} \${1:*} {\n\t\${2|color,shape,border,opacity,icon|} \$0\n}`
+          insertText: `${keyword.value} \${1:*} {\n\t\${2|color,shape,border,opacity,icon|} $0\n}`
         })
       }
       return acceptor(context, {
@@ -106,7 +106,7 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
         detail: `Insert ${keyword.value} block`,
         kind: CompletionItemKind.Module,
         insertTextFormat: InsertTextFormat.Snippet,
-        insertText: `${keyword.value} {\n\t\${1|color,shape,border,opacity,icon|} \$0\n}`
+        insertText: `${keyword.value} {\n\t\${1|color,shape,border,opacity,icon|} $0\n}`
       })
     }
     if (keyword.value === 'extend') {

package/src/lsp/DocumentSymbolProvider.ts

@@ -1,35 +1,44 @@
 import { nonexhaustive } from '@likec4/core'
-import { type AstNode, GrammarUtils, type MaybePromise } from 'langium'
+import { type AstNode, type MaybePromise, AstUtils, GrammarUtils } from 'langium'
 import type { DocumentSymbolProvider, NodeKindProvider } from 'langium/lsp'
 import { filter, isEmpty, isTruthy, map, pipe } from 'remeda'
 import { type DocumentSymbol, SymbolKind } from 'vscode-languageserver-types'
-import { ast, type LikeC4LangiumDocument } from '../ast'
-import { logError } from '../logger'
+import { type LikeC4LangiumDocument, ast } from '../ast'
+import { logError, logWarnError } from '../logger'
+import type { LikeC4ModelLocator, LikeC4ModelParser } from '../model'
 import type { LikeC4Services } from '../module'
+import type { LikeC4NameProvider } from '../references'
 import { getFqnElementRef } from '../utils/elementRef'
 
 export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
   protected readonly nodeKindProvider: NodeKindProvider
+  protected readonly nameProvider: LikeC4NameProvider
+  protected readonly parser: LikeC4ModelParser
+  protected readonly locator: LikeC4ModelLocator
 
   constructor(private services: LikeC4Services) {
     this.nodeKindProvider = services.shared.lsp.NodeKindProvider
+    this.parser = services.likec4.ModelParser
+    this.locator = services.likec4.ModelLocator
+    this.nameProvider = services.references.NameProvider
   }
 
   getSymbols({
     parseResult: {
-      value: { specifications, models, views, likec4lib }
-    }
+      value: { specifications, models, deployments, views, likec4lib },
+    },
   }: LikeC4LangiumDocument): MaybePromise<DocumentSymbol[]> {
     return [
       ...likec4lib.map(l => () => this.getLikec4LibSymbol(l)),
       ...specifications.map(s => () => this.getSpecSymbol(s)),
       ...models.map(s => () => this.getModelSymbol(s)),
-      ...views.map(s => () => this.getModelViewsSymbol(s))
+      ...deployments.map(s => () => this.getDeploymentModelSymbol(s)),
+      ...views.map(s => () => this.getModelViewsSymbol(s)),
     ].flatMap(fn => {
       try {
         return fn() ?? []
       } catch (e) {
-        logError(e)
+        logWarnError(e)
         return []
       }
     })
@@ -46,8 +55,8 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
         name: 'icons',
         range: cstModel.range,
         selectionRange: GrammarUtils.findNodeForKeyword(cstModel, 'icons')?.range ?? cstModel.range,
-        children
-      }
+        children,
+      },
     ]
   }
 
@@ -71,12 +80,12 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
             return this.getTagSymbol(nd)
           }
         } catch (e) {
-          logError(e)
+          logWarnError(e)
           return null
         }
         nonexhaustive(nd)
       }),
-      filter(isTruthy)
+      filter(isTruthy),
     )
 
     if (specSymbols.length === 0) return []
@@ -87,8 +96,8 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
         name: astSpec.name,
         range: cstModel.range,
         selectionRange: specKeywordNode.range,
-        children: specSymbols
-      }
+        children: specSymbols,
+      },
     ]
   }
 
@@ -103,13 +112,29 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
         name: astModel.name,
         range: cstModel.range,
         selectionRange: nameNode.range,
-        children: astModel.elements.flatMap(e => this.getElementsSymbol(e))
-      }
+        children: astModel.elements.flatMap(e => this.getElementsSymbol(e)),
+      },
+    ]
+  }
+
+  protected getDeploymentModelSymbol(astModel: ast.ModelDeployments): DocumentSymbol[] {
+    const cstModel = astModel.$cstNode
+    if (!cstModel) return []
+    const nameNode = GrammarUtils.findNodeForProperty(cstModel, 'name')
+    if (!nameNode) return []
+    return [
+      {
+        kind: this.symbolKind(astModel),
+        name: astModel.name,
+        range: cstModel.range,
+        selectionRange: nameNode.range,
+        children: astModel.elements.flatMap(e => this.getDeploymentElementSymbol(e)),
+      },
     ]
   }
 
   protected getElementsSymbol(
-    el: ast.Element | ast.Relation | ast.ExtendElement
+    el: ast.Element | ast.Relation | ast.ExtendElement,
   ): DocumentSymbol[] {
     try {
       if (ast.isExtendElement(el)) {
@@ -119,7 +144,7 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
         return this.getElementSymbol(el)
       }
     } catch (e) {
-      logError(e)
+      logWarnError(e)
     }
     return []
   }
@@ -136,8 +161,8 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
         name: getFqnElementRef(astElement.element),
         range: cst.range,
         selectionRange: nameNode.range,
-        children: body.elements.flatMap(e => this.getElementsSymbol(e))
-      }
+        children: body.elements.flatMap(e => this.getElementsSymbol(e)),
+      },
     ]
   }
 
@@ -157,8 +182,8 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
         range: cst.range,
         selectionRange: nameNode.range,
         detail,
-        children: astElement.body?.elements.flatMap(e => this.getElementsSymbol(e)) ?? []
-      }
+        children: astElement.body?.elements.flatMap(e => this.getElementsSymbol(e)) ?? [],
+      },
     ]
   }
   protected getModelViewsSymbol(astViews: ast.ModelViews): DocumentSymbol[] {
@@ -171,13 +196,13 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
         name: astViews.name,
         range: cst.range,
         selectionRange: nameNode.range,
-        children: astViews.views.flatMap(e => this.getViewSymbol(e))
-      }
+        children: astViews.views.flatMap(e => this.getViewSymbol(e)),
+      },
     ]
   }
 
   protected getKindSymbol(
-    astKind: ast.SpecificationElementKind | ast.SpecificationRelationshipKind
+    astKind: ast.SpecificationElementKind | ast.SpecificationRelationshipKind,
   ): DocumentSymbol | null {
     if (!astKind.$cstNode || !astKind.kind.$cstNode || isEmpty(astKind.kind.name)) return null
 
@@ -185,7 +210,7 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
       kind: this.symbolKind(astKind),
       name: astKind.kind.name,
       range: astKind.$cstNode.range,
-      selectionRange: astKind.kind.$cstNode.range
+      selectionRange: astKind.kind.$cstNode.range,
     }
   }
 
@@ -195,7 +220,7 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
       kind: this.symbolKind(astTag),
       name: '#' + astTag.tag.name,
       range: astTag.$cstNode.range,
-      selectionRange: astTag.tag.$cstNode.range
+      selectionRange: astTag.tag.$cstNode.range,
     }
   }
 
@@ -205,7 +230,7 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
       kind: this.symbolKind(astTag),
       name: astTag.name,
       range: astTag.$cstNode.range,
-      selectionRange: astTag.$cstNode.range
+      selectionRange: astTag.$cstNode.range,
     }
   }
 
@@ -220,8 +245,65 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
         name: nameNode.text,
         range: cst.range,
         selectionRange: nameNode.range,
-        children: []
+        children: [],
+      },
+    ]
+  }
+
+  protected getDeploymentElementSymbol(el: ast.DeploymentElement | ast.DeploymentRelation): DocumentSymbol[] {
+    try {
+      if (ast.isDeploymentNode(el)) {
+        return this.getDeploymentNodeSymbol(el)
       }
+      if (ast.isDeployedInstance(el)) {
+        return this.getDeployedInstanceSymbol(el)
+      }
+    } catch (e) {
+      logWarnError(e)
+    }
+    return []
+  }
+
+  protected getDeploymentNodeSymbol(astElement: ast.DeploymentNode): DocumentSymbol[] {
+    const cst = astElement.$cstNode
+    const nameNode = this.nameProvider.getNameNode(astElement)
+    if (!nameNode || !cst) return []
+
+    const name = this.nameProvider.getNameStrict(astElement)
+    const kind = astElement.kind.$refText
+    // TODO: return the title as well
+    const detail = kind // + (astElement.title ? ': ' + astElement.title : '').replaceAll('\n', ' ').trim()
+    return [
+      {
+        kind: this.symbolKind(astElement),
+        name: name,
+        range: cst.range,
+        selectionRange: nameNode.range,
+        detail,
+        children: astElement.body?.elements.flatMap(e => this.getDeploymentElementSymbol(e)) ?? [],
+      },
+    ]
+  }
+
+  protected getDeployedInstanceSymbol(astElement: ast.DeployedInstance): DocumentSymbol[] {
+    const cst = astElement.$cstNode
+    const nameNode = this.nameProvider.getNameNode(astElement)
+    if (!nameNode || !cst) return []
+
+    const doc = AstUtils.getDocument(astElement)
+    const instance = this.parser.forDocument(doc).parseDeployedInstance(astElement)
+
+    const name = this.nameProvider.getNameStrict(astElement)
+    const detail = 'instance of ' + instance.element
+    return [
+      {
+        kind: this.symbolKind(astElement),
+        name: name,
+        range: cst.range,
+        selectionRange: nameNode.range,
+        detail,
+        children: [],
+      },
     ]
   }
 

package/src/lsp/HoverProvider.ts

@@ -1,4 +1,4 @@
-import { type AstNode, type MaybePromise } from 'langium'
+import { type AstNode, AstUtils, type MaybePromise } from 'langium'
 import { AstNodeHoverProvider } from 'langium/lsp'
 import { isTruthy } from 'remeda'
 import stripIndent from 'strip-indent'
@@ -30,7 +30,8 @@ export class LikeC4HoverProvider extends AstNodeHoverProvider {
     }
 
     if (ast.isDeploymentNode(node)) {
-      const el = this.parser.parseDeploymentNode(node, () => true)
+      const doc = AstUtils.getDocument(node)
+      const el = this.parser.forDocument(doc).parseDeploymentNode(node)
       const lines = [el.id as string + '  ']
       if (el.title !== node.name) {
         lines.push(`### ${el.title}`)
@@ -45,7 +46,8 @@ export class LikeC4HoverProvider extends AstNodeHoverProvider {
     }
 
     if (ast.isDeployedInstance(node)) {
-      const instance = this.parser.parseDeployedInstance(node, () => true)
+      const doc = AstUtils.getDocument(node)
+      const instance = this.parser.forDocument(doc).parseDeployedInstance(node)
       const el = this.locator.getParsedElement(instance.element)
       const lines = [instance.id + '  ', `instance of \`${instance.element}\``]
       if (el) {

package/src/lsp/SemanticTokenProvider.ts

@@ -90,7 +90,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       })
       return 'prune'
     }
-    if (ast.isDeploymentRefExpression(node)) {
+    if (ast.isFqnRefExpr(node)) {
       if (node.selector) {
         acceptor({
           node,
@@ -142,7 +142,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       })
       return 'prune'
     }
-    if (ast.isDeploymentRef(node)) {
+    if (ast.isFqnRef(node)) {
       acceptor({
         node,
         property: 'value',