@likec4/language-server 1.2.0 → 1.2.2

package/src/logger.ts

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { normalizeError } from '@likec4/core'
+
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
+let isSilent = false
+
+export const logger = {
+  trace(message: string) {
+    if (isSilent) return
+    console.trace(message)
+  },
+  debug(message: string) {
+    if (isSilent) return
+    console.debug(message)
+  },
+  info(message: string) {
+    if (isSilent) return
+    console.info(message)
+  },
+  warn(message: string) {
+    if (isSilent) return
+    console.warn(message)
+  },
+  error(message: any) {
+    if (isSilent) return
+    if (typeof message === 'string') {
+      console.error(message)
+      return
+    }
+    console.error(normalizeError(message))
+  },
+  silent(silent = true) {
+    isSilent = silent
+  }
+}
+
+export type Logger = typeof logger
+
+export function logError(error: unknown): void {
+  logger.error(error)
+}
+
+export function logWarnError(err: unknown): void {
+  if (typeof err === 'string') {
+    logger.warn(err)
+    return
+  }
+  if (err instanceof Error) {
+    logger.warn(err.stack ?? err.message)
+    return
+  }
+  const error = normalizeError(err)
+  logger.warn(`${error.name}: ${error.message}`)
+}

package/src/lsp/CodeLensProvider.ts

@@ -0,0 +1,51 @@
+import { DocumentState, type LangiumDocument, type MaybePromise } from 'langium'
+import type { CodeLensProvider } from 'langium/lsp'
+import type { CancellationToken, CodeLens, CodeLensParams } from 'vscode-languageserver'
+import { isParsedLikeC4LangiumDocument, ViewOps } from '../ast'
+import { logger } from '../logger'
+import type { LikeC4Services } from '../module'
+
+export class LikeC4CodeLensProvider implements CodeLensProvider {
+  constructor(private services: LikeC4Services) {
+    //
+  }
+
+  async provideCodeLens(
+    doc: LangiumDocument,
+    _params: CodeLensParams,
+    cancelToken?: CancellationToken
+  ): Promise<CodeLens[] | undefined> {
+    if (doc.state !== DocumentState.Validated) {
+      logger.debug(`Waiting for document ${doc.uri.path} to be validated`)
+      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated, doc.uri, cancelToken)
+      logger.debug(`Document ${doc.uri.path} is validated`)
+    }
+    if (!isParsedLikeC4LangiumDocument(doc)) {
+      return
+    }
+    const views = doc.parseResult.value.views.flatMap(v => v.views)
+    return views.flatMap<CodeLens>(ast => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const viewId = ViewOps.readId(ast)
+      const range = ast.$cstNode?.range
+      if (!range || !viewId) {
+        return []
+      }
+
+      return {
+        range: {
+          start: range.start,
+          end: {
+            line: range.start.line,
+            character: range.start.character + 4
+          }
+        },
+        command: {
+          command: 'likec4.open-preview',
+          arguments: [viewId],
+          title: 'open preview'
+        }
+      }
+    })
+  }
+}

package/src/lsp/DocumentHighlightProvider.ts

@@ -0,0 +1,12 @@
+import type { ReferenceDescription } from 'langium'
+import { DefaultDocumentHighlightProvider } from 'langium/lsp'
+import { DocumentHighlight, DocumentHighlightKind } from 'vscode-languageserver'
+
+export class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
+  /**
+   * Override this method to determine the highlight kind of the given reference.
+   */
+  protected override createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight {
+    return DocumentHighlight.create(reference.segment.range, DocumentHighlightKind.Read)
+  }
+}

package/src/lsp/DocumentLinkProvider.test.ts

@@ -0,0 +1,66 @@
+import { beforeAll, describe, expect, it, vi } from 'vitest'
+import type { LikeC4LangiumDocument } from '../ast'
+import type { LikeC4Services } from '../module'
+import { createTestServices } from '../test'
+import type { LikeC4DocumentLinkProvider } from './DocumentLinkProvider'
+
+vi.mock('../logger')
+
+describe('DocumentLinkProvider', () => {
+  let services: LikeC4Services
+  let doc: LikeC4LangiumDocument
+  let documentLinkProvider: LikeC4DocumentLinkProvider
+
+  beforeAll(async () => {
+    const test = createTestServices('vscode-vfs://host/virtual')
+    services = test.services
+    documentLinkProvider = services.lsp.DocumentLinkProvider
+    doc = await test.parse(
+      `
+      specification {
+        element component
+      }
+    `,
+      'dir1/doc.c4'
+    )
+  })
+
+  it('test should have correct doc uri and workspace uri', () => {
+    expect(services.shared.workspace.WorkspaceManager.workspaceUri.toString()).toBe(
+      'vscode-vfs://host/virtual'
+    )
+    expect(services.shared.workspace.WorkspaceManager.workspaceURL.toString()).toBe(
+      'vscode-vfs://host/virtual'
+    )
+    expect(doc.uri.toString()).toBe('vscode-vfs://host/virtual/src/dir1/doc.c4')
+  })
+
+  it('should return the link unchanged if it has a protocol', () => {
+    const link = 'http://example.com/link'
+    expect(documentLinkProvider.resolveLink(doc, link)).toBe(link)
+  })
+
+  it('should resolve a relative link against the document URI', () => {
+    const link = './relative/link#fragment'
+    const expected = 'vscode-vfs://host/virtual/src/dir1/relative/link#fragment'
+    expect(documentLinkProvider.resolveLink(doc, link)).toBe(expected)
+  })
+
+  it('should resolve a parent relative link against the document URI', () => {
+    const link = '../dir2/link?query=1#L1=22'
+    const expected = 'vscode-vfs://host/virtual/src/dir2/link?query=1#L1=22'
+    expect(documentLinkProvider.resolveLink(doc, link)).toBe(expected)
+  })
+
+  it('should resolve a link against the workspace URL', () => {
+    const link = '/root'
+    const expected = 'vscode-vfs://host/virtual/root'
+    expect(documentLinkProvider.resolveLink(doc, link)).toBe(expected)
+  })
+
+  it('should resolve a link with quary and hash against the workspace URL', () => {
+    const link = '/root/a/b/c/link?query=1#L1=22'
+    const expected = 'vscode-vfs://host/virtual/root/a/b/c/link?query=1#L1=22'
+    expect(documentLinkProvider.resolveLink(doc, link)).toBe(expected)
+  })
+})

package/src/lsp/DocumentLinkProvider.ts

@@ -0,0 +1,53 @@
+import type { LangiumDocument, MaybePromise } from 'langium'
+import { AstUtils, GrammarUtils } from 'langium'
+import type { DocumentLinkProvider } from 'langium/lsp'
+import { hasProtocol, isRelative, withBase } from 'ufo'
+import type { DocumentLink, DocumentLinkParams } from 'vscode-languageserver-protocol'
+import { ast, isParsedLikeC4LangiumDocument } from '../ast'
+import { logError } from '../logger'
+import type { LikeC4Services } from '../module'
+
+export class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
+  constructor(private services: LikeC4Services) {
+    //
+  }
+  getDocumentLinks(
+    doc: LangiumDocument,
+    _params: DocumentLinkParams
+  ): MaybePromise<DocumentLink[]> {
+    if (!isParsedLikeC4LangiumDocument(doc)) {
+      return []
+    }
+    return AstUtils.streamAllContents(doc.parseResult.value)
+      .filter(ast.isLinkProperty)
+      .flatMap((n): DocumentLink | Iterable<DocumentLink> => {
+        try {
+          const range = GrammarUtils.findNodeForProperty(n.$cstNode, 'value')?.range
+          if (!range) {
+            return []
+          }
+          const target = this.resolveLink(doc, n.value)
+          return {
+            range,
+            target
+          }
+        } catch (e) {
+          logError(e)
+          return []
+        }
+      })
+      .toArray()
+  }
+
+  resolveLink(doc: LangiumDocument, link: string): string {
+    if (hasProtocol(link)) {
+      return link
+    }
+    if (isRelative(link)) {
+      const base = new URL(doc.uri.toString(true))
+      return new URL(link, base).toString()
+    }
+    const workspace = this.services.shared.workspace.WorkspaceManager.workspaceURL
+    return withBase(link, workspace.toString())
+  }
+}

package/src/lsp/DocumentSymbolProvider.ts

@@ -0,0 +1,201 @@
+import { nonexhaustive } from '@likec4/core'
+import { type AstNode, GrammarUtils, type MaybePromise } from 'langium'
+import type { DocumentSymbolProvider, NodeKindProvider } from 'langium/lsp'
+import { filter, isEmpty, isTruthy, map, pipe } from 'remeda'
+import { type DocumentSymbol, SymbolKind } from 'vscode-languageserver-protocol'
+import { ast, type LikeC4LangiumDocument } from '../ast'
+import { getFqnElementRef } from '../elementRef'
+import { logError } from '../logger'
+import type { LikeC4Services } from '../module'
+
+export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
+  protected readonly nodeKindProvider: NodeKindProvider
+
+  constructor(private services: LikeC4Services) {
+    this.nodeKindProvider = services.shared.lsp.NodeKindProvider
+  }
+
+  getSymbols({
+    parseResult: {
+      value: { specifications, models, views }
+    }
+  }: LikeC4LangiumDocument): MaybePromise<DocumentSymbol[]> {
+    return [
+      ...specifications.map(s => () => this.getSpecSymbol(s)),
+      ...models.map(s => () => this.getModelSymbol(s)),
+      ...views.map(s => () => this.getModelViewsSymbol(s))
+    ].flatMap(fn => {
+      try {
+        return fn() ?? []
+      } catch (e) {
+        logError(e)
+        return []
+      }
+    })
+  }
+
+  protected getSpecSymbol(astSpec: ast.SpecificationRule): DocumentSymbol[] {
+    const cstModel = astSpec?.$cstNode
+    if (!cstModel) return []
+    const specKeywordNode = GrammarUtils.findNodeForProperty(cstModel, 'name')
+    if (!specKeywordNode) return []
+
+    const specSymbols = pipe(
+      [...astSpec.elements, ...astSpec.tags, ...astSpec.relationships],
+      map(nd => {
+        try {
+          if (ast.isSpecificationElementKind(nd) || ast.isSpecificationRelationshipKind(nd)) {
+            return this.getKindSymbol(nd)
+          }
+          if (ast.isSpecificationTag(nd)) {
+            return this.getTagSymbol(nd)
+          }
+        } catch (e) {
+          logError(e)
+          return null
+        }
+        nonexhaustive(nd)
+      }),
+      filter(isTruthy)
+    )
+
+    if (specSymbols.length === 0) return []
+
+    return [
+      {
+        kind: SymbolKind.Namespace,
+        name: astSpec.name,
+        range: cstModel.range,
+        selectionRange: specKeywordNode.range,
+        children: specSymbols
+      }
+    ]
+  }
+
+  protected getModelSymbol(astModel: ast.Model): 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.getElementsSymbol(e))
+      }
+    ]
+  }
+
+  protected getElementsSymbol(
+    el: ast.Element | ast.Relation | ast.ExtendElement
+  ): DocumentSymbol[] {
+    try {
+      if (ast.isExtendElement(el)) {
+        return this.getExtendElementSymbol(el)
+      }
+      if (ast.isElement(el)) {
+        return this.getElementSymbol(el)
+      }
+    } catch (e) {
+      logError(e)
+    }
+    return []
+  }
+
+  protected getExtendElementSymbol(astElement: ast.ExtendElement): DocumentSymbol[] {
+    const cst = astElement.$cstNode
+    const nameNode = astElement.element.$cstNode
+    const body = astElement.body
+    if (!cst || !nameNode) return []
+
+    return [
+      {
+        kind: this.symbolKind(astElement),
+        name: getFqnElementRef(astElement.element),
+        range: cst.range,
+        selectionRange: nameNode.range,
+        children: body.elements.flatMap(e => this.getElementsSymbol(e))
+      }
+    ]
+  }
+
+  protected getElementSymbol(astElement: ast.Element): DocumentSymbol[] {
+    const cst = astElement.$cstNode
+    const nameNode = GrammarUtils.findNodeForProperty(cst, 'name')
+    if (!nameNode || !cst) return []
+
+    const name = astElement.name
+    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.getElementsSymbol(e)) ?? []
+      }
+    ]
+  }
+  protected getModelViewsSymbol(astViews: ast.ModelViews): DocumentSymbol[] {
+    const cst = astViews.$cstNode
+    const nameNode = GrammarUtils.findNodeForProperty(cst, 'name')
+    if (!nameNode || !cst) return []
+    return [
+      {
+        kind: this.symbolKind(astViews),
+        name: astViews.name,
+        range: cst.range,
+        selectionRange: nameNode.range,
+        children: astViews.views.flatMap(e => this.getViewSymbol(e))
+      }
+    ]
+  }
+
+  protected getKindSymbol(
+    astKind: ast.SpecificationElementKind | ast.SpecificationRelationshipKind
+  ): DocumentSymbol | null {
+    if (!astKind.$cstNode || !astKind.kind.$cstNode || isEmpty(astKind.kind.name)) return null
+
+    return {
+      kind: this.symbolKind(astKind),
+      name: astKind.kind.name,
+      range: astKind.$cstNode.range,
+      selectionRange: astKind.kind.$cstNode.range
+    }
+  }
+
+  protected getTagSymbol(astTag: ast.SpecificationTag): DocumentSymbol | null {
+    if (!astTag.$cstNode || !astTag.tag.$cstNode || isEmpty(astTag.tag.name)) return null
+    return {
+      kind: this.symbolKind(astTag),
+      name: '#' + astTag.tag.name,
+      range: astTag.$cstNode.range,
+      selectionRange: astTag.tag.$cstNode.range
+    }
+  }
+
+  protected getViewSymbol(astView: ast.LikeC4View): DocumentSymbol[] {
+    const cst = astView?.$cstNode
+    if (!cst) return []
+    const nameNode = astView.name ? GrammarUtils.findNodeForProperty(cst, 'name') : null
+    if (!nameNode) return []
+    return [
+      {
+        kind: this.symbolKind(astView),
+        name: nameNode.text,
+        range: cst.range,
+        selectionRange: nameNode.range,
+        children: []
+      }
+    ]
+  }
+
+  protected symbolKind(node: AstNode): SymbolKind {
+    return this.nodeKindProvider.getSymbolKind(node)
+  }
+}

package/src/lsp/HoverProvider.ts

@@ -0,0 +1,58 @@
+import { type AstNode, type MaybePromise } from 'langium'
+import { AstNodeHoverProvider } from 'langium/lsp'
+import { isTruthy } from 'remeda'
+import stripIndent from 'strip-indent'
+import type { Hover } from 'vscode-languageserver-protocol'
+import { ast } from '../ast'
+import type { LikeC4ModelLocator } from '../model'
+import type { LikeC4Services } from '../module'
+
+export class LikeC4HoverProvider extends AstNodeHoverProvider {
+  private locator: LikeC4ModelLocator
+
+  constructor(services: LikeC4Services) {
+    super(services)
+    this.locator = services.likec4.ModelLocator
+  }
+
+  protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined> {
+    if (ast.isTag(node)) {
+      return {
+        contents: {
+          kind: 'markdown',
+          value: stripIndent(`
+            tag: \`${node.name}\`
+          `)
+        }
+      }
+    }
+
+    // if (ast.isElementKind(node)) {
+    //   const spec = this.specIndex.get(node.name as ElementKind)
+    //   return {
+    //     contents: {
+    //       kind: 'markdown',
+    //       value: stripIndent(`
+    //         kind: **${spec.id}**
+    //         shape: ${spec.style.shape}
+    //       `)
+    //     }
+    //   }
+    // }
+
+    if (ast.isElement(node)) {
+      const el = this.locator.getParsedElement(node)
+      if (!el) {
+        return
+      }
+      const lines = [el.id, `### ${el.title}`, '`' + el.kind + '` ']
+      return {
+        contents: {
+          kind: 'markdown',
+          value: lines.join('\n')
+        }
+      }
+    }
+    return
+  }
+}

package/{dist/lsp/SemanticTokenProvider.js → src/lsp/SemanticTokenProvider.ts}

@@ -1,134 +1,149 @@
-import { AbstractSemanticTokenProvider } from "langium/lsp";
-import { SemanticTokenModifiers, SemanticTokenTypes } from "vscode-languageserver-protocol";
-import { ast } from "../ast.js";
+import type { AstNode } from 'langium'
+import { AbstractSemanticTokenProvider, type SemanticTokenAcceptor } from 'langium/lsp'
+import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver-protocol'
+import { ast } from '../ast'
+
 export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
   // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  highlightElement(node, acceptor) {
-    if (ast.isRelation(node) && "kind" in node) {
+  protected override highlightElement(
+    node: AstNode,
+    acceptor: SemanticTokenAcceptor
+  ): void | undefined | 'prune' {
+    if (ast.isRelation(node) && 'kind' in node) {
       acceptor({
         node,
-        property: "kind",
+        property: 'kind',
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
-      });
+      })
     }
+
     if (ast.isElementViewRef(node)) {
       acceptor({
         node,
-        property: "view",
+        property: 'view',
         type: SemanticTokenTypes.variable
-      });
+      })
     }
     if (ast.isDescedantsExpr(node) && node.$cstNode) {
       acceptor({
         cst: node.$cstNode,
         type: SemanticTokenTypes.variable
-      });
-      return "prune";
+      })
+      return 'prune'
     }
     if (ast.isWildcardExpr(node) && node.$cstNode) {
       acceptor({
         cst: node.$cstNode,
         type: SemanticTokenTypes.variable
-      });
+      })
     }
+
     if (ast.isElementKindExpr(node)) {
       acceptor({
         node,
-        property: "kind",
+        property: 'kind',
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
-      });
+      })
     }
     if (ast.isElementTagExpr(node)) {
       acceptor({
         node,
-        property: "tag",
+        property: 'tag',
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
-      });
+      })
     }
     if (ast.isElementRef(node) || ast.isFqnElementRef(node)) {
       acceptor({
         node,
-        property: "el",
+        property: 'el',
         type: node.parent ? SemanticTokenTypes.property : SemanticTokenTypes.variable
-      });
+      })
     }
     if (ast.isSpecificationElementKind(node) || ast.isSpecificationRelationshipKind(node)) {
       acceptor({
         node,
-        property: "kind",
+        property: 'kind',
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
-      });
+      })
     }
     if (ast.isTags(node)) {
       acceptor({
         node,
-        property: "value",
+        property: 'value',
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
-      });
+      })
     }
     if (ast.isTag(node)) {
       acceptor({
         node,
-        property: "name",
+        property: 'name',
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
-      });
-    }
-    if (ast.isColorProperty(node) || ast.isShapeProperty(node) || ast.isArrowProperty(node) || ast.isLineProperty(node) || ast.isBorderProperty(node)) {
+      })
+    }
+    if (
+      ast.isColorProperty(node)
+      || ast.isShapeProperty(node)
+      || ast.isArrowProperty(node)
+      || ast.isLineProperty(node)
+      || ast.isBorderProperty(node)
+    ) {
       acceptor({
         node,
-        property: "value",
+        property: 'value',
         type: SemanticTokenTypes.enum
-      });
+      })
     }
     if (ast.isOpacityProperty(node)) {
       acceptor({
         node,
-        property: "value",
+        property: 'value',
         type: SemanticTokenTypes.number
-      });
+      })
     }
     if (ast.isLinkProperty(node) || ast.isIconProperty(node)) {
       acceptor({
         node,
-        property: "value",
+        property: 'value',
         type: SemanticTokenTypes.string
-      });
+      })
     }
     if (ast.isElement(node)) {
-      this.highlightAstElement(node, acceptor);
+      this.highlightAstElement(node, acceptor)
     }
     if (ast.isLikeC4View(node)) {
-      this.highlightView(node, acceptor);
+      this.highlightView(node, acceptor)
     }
   }
-  highlightAstElement(node, acceptor) {
+
+  private highlightAstElement(node: ast.Element, acceptor: SemanticTokenAcceptor) {
     acceptor({
       node,
-      property: "name",
+      property: 'name',
       type: SemanticTokenTypes.variable,
       modifier: [SemanticTokenModifiers.declaration]
-    });
+    })
     acceptor({
       node,
-      property: "kind",
+      property: 'kind',
       type: SemanticTokenTypes.keyword,
       modifier: []
-    });
+    })
   }
-  highlightView(node, acceptor) {
+
+  private highlightView(node: ast.LikeC4View, acceptor: SemanticTokenAcceptor) {
     if (node.name) {
       acceptor({
         node,
-        property: "name",
+        property: 'name',
         type: SemanticTokenTypes.variable,
         modifier: [SemanticTokenModifiers.declaration]
-      });
+      })
     }
   }
 }