@likec4/language-server 1.21.1 → 1.22.1

package/src/shared/WorkspaceManager.ts

@@ -1,48 +0,0 @@
-import { hasAtLeast, invariant } from '@likec4/core'
-import type { LangiumDocument, LangiumDocumentFactory } from 'langium'
-import { DefaultWorkspaceManager } from 'langium'
-import type { LangiumSharedServices } from 'langium/lsp'
-import type { WorkspaceFolder } from 'vscode-languageserver'
-import { URI } from 'vscode-uri'
-import * as BuiltIn from '../likec4lib'
-
-export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
-  private documentFactory: LangiumDocumentFactory
-
-  constructor(services: LangiumSharedServices) {
-    super(services)
-    this.documentFactory = services.workspace.LangiumDocumentFactory
-  }
-
-  /**
-   * Load all additional documents that shall be visible in the context of the given workspace
-   * folders and add them to the collector. This can be used to include built-in libraries of
-   * your language, which can be either loaded from provided files or constructed in memory.
-   */
-  protected override async loadAdditionalDocuments(
-    folders: WorkspaceFolder[],
-    collector: (document: LangiumDocument) => void
-  ): Promise<void> {
-    collector(this.documentFactory.fromString(BuiltIn.Content, URI.parse(BuiltIn.Uri)))
-    await super.loadAdditionalDocuments(folders, collector)
-  }
-
-  public workspace() {
-    if (this.folders && hasAtLeast(this.folders, 1)) {
-      return this.folders[0]
-    }
-    return null
-  }
-
-  public get workspaceUri() {
-    const workspace = this.workspace()
-    invariant(workspace, 'Workspace not initialized')
-    return URI.parse(workspace.uri)
-  }
-
-  public get workspaceURL() {
-    const workspace = this.workspace()
-    invariant(workspace, 'Workspace not initialized')
-    return new URL(workspace.uri)
-  }
-}

package/src/shared/WorkspaceSymbolProvider.ts

@@ -1,3 +0,0 @@
-import { DefaultWorkspaceSymbolProvider } from 'langium/lsp'
-
-export class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {}

package/src/shared/index.ts

@@ -1,3 +0,0 @@
-export * from './NodeKindProvider'
-export * from './WorkspaceManager'
-export * from './WorkspaceSymbolProvider'

package/src/test/index.ts

@@ -1 +0,0 @@
-export * from './testServices'

package/src/test/setup.ts

@@ -1,8 +0,0 @@
-import { consola } from '@likec4/log'
-import { beforeEach, vi } from 'vitest'
-import { logger } from '../logger'
-beforeEach(() => {
-  // Vitest
-  consola.mockTypes(() => vi.fn())
-  logger.mockTypes(() => vi.fn())
-})

package/src/test/testServices.ts

@@ -1,152 +0,0 @@
-import { LikeC4Model } from '@likec4/core'
-import { DocumentState, EmptyFileSystem, TextDocument } from 'langium'
-import * as assert from 'node:assert'
-import stripIndent from 'strip-indent'
-import { type Diagnostic, DiagnosticSeverity } from 'vscode-languageserver-types'
-import { URI, Utils } from 'vscode-uri'
-import type { LikeC4LangiumDocument } from '../ast'
-import { createLanguageServices } from '../module'
-
-export function createTestServices(workspace = 'file:///test/workspace') {
-  const services = createLanguageServices(EmptyFileSystem).likec4
-  const metaData = services.LanguageMetaData
-  const langiumDocuments = services.shared.workspace.LangiumDocuments
-  const documentBuilder = services.shared.workspace.DocumentBuilder
-  const modelBuilder = services.likec4.ModelBuilder
-  const workspaceUri = URI.parse(workspace)
-  const formatter = services.lsp.Formatter
-  const workspaceFolder = {
-    name: 'test',
-    uri: workspaceUri.toString(),
-  }
-  let isInitialized = false
-  let documentIndex = 1
-
-  const parse = async (input: string, uri?: string) => {
-    if (!isInitialized) {
-      await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-        if (isInitialized) {
-          return
-        }
-        isInitialized = true
-        services.shared.workspace.WorkspaceManager.initialize({
-          capabilities: {},
-          processId: null,
-          rootUri: null,
-          workspaceFolders: [workspaceFolder],
-        })
-        await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder])
-      })
-    }
-    const docUri = Utils.resolvePath(
-      workspaceUri,
-      './src/',
-      uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`,
-    )
-    const document = services.shared.workspace.LangiumDocumentFactory.fromString(
-      stripIndent(input),
-      docUri,
-    )
-    langiumDocuments.addDocument(document)
-    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-      await documentBuilder.build([document], { validation: false })
-    })
-    return document as LikeC4LangiumDocument
-  }
-
-  const validate = async (input: string | LikeC4LangiumDocument, uri?: string) => {
-    const document = typeof input === 'string' ? await parse(input, uri) : input
-    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-      await documentBuilder.build([document], { validation: true })
-    })
-    const diagnostics = document.diagnostics ?? []
-    const warnings = diagnostics.flatMap(d => d.severity === DiagnosticSeverity.Warning ? d.message : [])
-    const errors = diagnostics.flatMap(d => d.severity === DiagnosticSeverity.Error ? d.message : [])
-    return {
-      document,
-      diagnostics,
-      warnings,
-      errors,
-    }
-  }
-
-  const format = async (input: string | LikeC4LangiumDocument, uri?: string) => {
-    const document = typeof input === 'string' ? await parse(input, uri) : input
-    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-      await documentBuilder.build([document], { validation: true })
-    })
-
-    const edits = await formatter?.formatDocument(
-      document,
-      {
-        options: { tabSize: 2, insertSpaces: true },
-        textDocument: { uri: document.uri.toString() },
-      },
-    )
-
-    return TextDocument.applyEdits(document.textDocument, edits ?? [])
-  }
-
-  type ValidateAllResult = {
-    diagnostics: Diagnostic[]
-    errors: string[]
-    warnings: string[]
-  }
-
-  const validateAll = async () => {
-    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
-      const docs = langiumDocuments.all.toArray()
-      await documentBuilder.build(docs, { validation: true })
-    })
-    await documentBuilder.waitUntil(DocumentState.Validated)
-    const docs = langiumDocuments.all.toArray()
-    assert.ok(docs.length > 0, 'no documents to validate')
-    const diagnostics = docs.flatMap(doc => doc.diagnostics ?? [])
-    const warnings = diagnostics.flatMap(d => d.severity === DiagnosticSeverity.Warning ? d.message : [])
-    const errors = diagnostics.flatMap(d => d.severity === DiagnosticSeverity.Error ? d.message : [])
-    return {
-      diagnostics,
-      errors,
-      warnings,
-    }
-  }
-
-  const buildModel = async () => {
-    await validateAll()
-    const model = await modelBuilder.buildComputedModel()
-    if (!model) throw new Error('No model found')
-    return model
-  }
-
-  const buildLikeC4Model = async () => {
-    await validateAll()
-    const model = await modelBuilder.buildComputedModel()
-    if (!model) throw new Error('No model found')
-    return LikeC4Model.create(model)
-  }
-
-  /**
-   * This will clear all documents
-   */
-  const resetState = async () => {
-    await services.shared.workspace.WorkspaceLock.write(async (cancelToken) => {
-      const docs = langiumDocuments.all.toArray().map(doc => doc.uri)
-      await documentBuilder.update([], docs, cancelToken)
-    })
-  }
-
-  return {
-    services,
-    parse,
-    validate,
-    validateAll,
-    buildModel,
-    buildLikeC4Model,
-    resetState,
-    format,
-  }
-}
-
-export type TestServices = ReturnType<typeof createTestServices>
-export type TestParseFn = TestServices['validate']
-export type TestValidateFn = TestServices['validate']

package/src/utils/disposable.ts

@@ -1,30 +0,0 @@
-import { Disposable } from 'langium'
-import { logError } from '../logger'
-
-export abstract class ADisposable implements Disposable {
-  protected toDispose: Disposable[] = []
-  protected isDisposed = false
-
-  onDispose(...disposable: Disposable[]): void {
-    this.toDispose.push(...disposable)
-  }
-
-  dispose(): void {
-    this.throwIfDisposed()
-    this.isDisposed = true
-    let item: Disposable | undefined
-    while (item = this.toDispose.pop()) {
-      try {
-        item.dispose()
-      } catch (e) {
-        logError(e)
-      }
-    }
-  }
-
-  protected throwIfDisposed(): void {
-    if (this.isDisposed) {
-      throw new Error('This has already been disposed')
-    }
-  }
-}

package/src/utils/elementRef.ts

@@ -1,26 +0,0 @@
-import type * as c4 from '@likec4/core'
-import type { ast } from '../ast'
-/**
- * Returns referenced AST Element
- */
-export function elementRef(node: ast.ElementRef | ast.StrictFqnElementRef) {
-  return node.el.ref
-}
-
-/**
- * Returns FQN of StrictFqnElementRef
- * a.b.c.d - for c node returns a.b.c
- */
-export function getFqnElementRef(node: ast.StrictFqnElementRef): c4.Fqn {
-  // invariant(isElementRefHead(node), 'Expected head StrictElementRef')
-  const name = [node.el.$refText]
-  let parent = node.parent
-  while (parent) {
-    name.push(parent.el.$refText)
-    parent = parent.parent
-  }
-  if (name.length === 1) {
-    return name[0] as c4.Fqn
-  }
-  return name.reverse().join('.') as c4.Fqn
-}

package/src/utils/fqnRef.ts

@@ -1,56 +0,0 @@
-import { AstUtils } from 'langium'
-import { isNullish } from 'remeda'
-import { ast } from '../ast'
-
-export function instanceRef(deploymentRef: ast.FqnRef): ast.DeployedInstance | null {
-  let referenceable
-  while ((referenceable = deploymentRef.value?.ref)) {
-    if (ast.isDeploymentNode(referenceable)) {
-      return null
-    }
-    if (ast.isDeployedInstance(referenceable)) {
-      return referenceable
-    }
-    if (isNullish(deploymentRef.parent)) {
-      return null
-    }
-    deploymentRef = deploymentRef.parent
-  }
-  return null
-}
-
-export function deploymentNodeRef(deploymentRef: ast.FqnRef): ast.DeploymentNode | null {
-  let referenceable = deploymentRef.value.ref ?? null
-  if (!referenceable || ast.isDeploymentNode(referenceable)) {
-    return referenceable
-  }
-  const artifact = instanceRef(deploymentRef)
-  // Because path in deploymentRef may be omitted,
-  // we find artifact first and then its container
-  return artifact ? AstUtils.getContainerOfType(artifact, ast.isDeploymentNode) ?? null : null
-}
-
-export function isReferenceToLogicalModel(node: ast.FqnRef) {
-  // iterate up the root parent
-  while (node.parent) {
-    node = node.parent
-  }
-  return ast.isElement(node.value.ref)
-}
-
-/**
- * Returns true if node references deployment model
- */
-export function isReferenceToDeploymentModel(node: ast.FqnRef) {
-  let referenceable
-  while ((referenceable = node.value?.ref)) {
-    if (ast.isDeploymentElement(referenceable)) {
-      return true
-    }
-    if (isNullish(node.parent)) {
-      return false
-    }
-    node = node.parent
-  }
-  return false
-}

package/src/utils/index.ts

@@ -1,2 +0,0 @@
-export * from './disposable'
-export * from './stringHash'

package/src/utils/printDocs.ts

@@ -1,3 +0,0 @@
-import type { LangiumDocument } from 'langium'
-
-export const printDocs = (docs: LangiumDocument[]) => docs.map(d => '  - ' + d.uri.toString(true)).join('\n')

package/src/utils/stringHash.ts

@@ -1,6 +0,0 @@
-import { stringHash as hash } from '@likec4/core'
-
-export function stringHash(...str: [string, ...string[]]): string {
-  var s = str.length > 1 ? str.join(':::') : str[0]
-  return hash(s)
-}

package/src/validation/_shared.ts

@@ -1,29 +0,0 @@
-import { type AstNode, type ValidationAcceptor, type ValidationCheck } from 'langium'
-import { isPromise } from 'remeda'
-import type { CancellationToken } from 'vscode-jsonrpc'
-import { logWarnError } from '../logger'
-
-export const RESERVED_WORDS = [
-  'this',
-  'it',
-  'self',
-  'super',
-  'likec4lib',
-  'global',
-]
-
-export function tryOrLog<T extends AstNode>(fn: ValidationCheck<T>): ValidationCheck<T> {
-  return async function tryOrLogFn(node: T, accept: ValidationAcceptor, cancelToken: CancellationToken) {
-    try {
-      const result = fn(node, accept, cancelToken)
-      if (isPromise(result)) {
-        await result
-      }
-      return
-    } catch (e) {
-      const message = e instanceof Error ? e.message : String(e)
-      accept('error', `Validation failed: ${message}`, { node })
-      logWarnError(e)
-    }
-  }
-}

package/src/validation/deployment-checks.ts

@@ -1,131 +0,0 @@
-import { FqnRef, isSameHierarchy, nonNullable } from '@likec4/core'
-import { type ValidationCheck, AstUtils } from 'langium'
-import { ast } from '../ast'
-import type { LikeC4Services } from '../module'
-import type { LikeC4NameProvider } from '../references'
-import { RESERVED_WORDS, tryOrLog } from './_shared'
-
-const { getDocument } = AstUtils
-
-export const deploymentNodeChecks = (services: LikeC4Services): ValidationCheck<ast.DeploymentNode> => {
-  const DeploymentsIndex = services.likec4.DeploymentsIndex
-  const Names = services.references.NameProvider
-  return tryOrLog((el, accept) => {
-    const nodeName = Names.getName(el)
-    if (!nodeName) {
-      accept('error', 'DeploymentNode must be named', {
-        node: el,
-      })
-      return
-    }
-    const range = nonNullable(Names.getNameNode(el), 'name CstNode not found').range
-
-    if (RESERVED_WORDS.includes(nodeName)) {
-      accept('error', `Reserved word: ${nodeName}`, {
-        node: el,
-        range,
-      })
-    }
-    const fqnName = DeploymentsIndex.getFqn(el)
-
-    const withSameName = DeploymentsIndex.byFqn(fqnName).limit(2).toArray()
-    if (withSameName.length > 1) {
-      accept(
-        'error',
-        `Duplicate node name "${fqnName}"`,
-        {
-          node: el,
-          range,
-        },
-      )
-    }
-  })
-}
-
-export const deployedInstanceChecks = (services: LikeC4Services): ValidationCheck<ast.DeployedInstance> => {
-  const DeploymentsIndex = services.likec4.DeploymentsIndex
-  const Names = services.references.NameProvider as LikeC4NameProvider
-  // const Locator = services.workspace.AstNodeLocator
-  return tryOrLog((el, accept) => {
-    const artifactName = Names.getName(el)
-    if (!artifactName) {
-      accept('error', 'Deployed instance must be named, unique inside node', {
-        node: el,
-      })
-      return
-    }
-    const range = nonNullable(Names.getNameNode(el), 'name CstNode not found').range
-
-    if (RESERVED_WORDS.includes(artifactName)) {
-      accept('error', `Reserved word: ${artifactName}`, {
-        node: el,
-        range,
-      })
-    }
-
-    const fqnName = DeploymentsIndex.getFqn(el)
-
-    const withSameName = DeploymentsIndex.byFqn(fqnName).limit(2).toArray()
-    if (withSameName.length > 1) {
-      accept(
-        'error',
-        `Duplicate instance name "${fqnName}"`,
-        {
-          node: el,
-          range,
-        },
-      )
-    }
-  })
-}
-
-export const deploymentRelationChecks = (services: LikeC4Services): ValidationCheck<ast.DeploymentRelation> => {
-  const ModelParser = services.likec4.ModelParser
-  return tryOrLog((el, accept) => {
-    const source = el.source?.value?.ref
-    if (!source) {
-      let sourceCstText = el.source?.$cstNode?.text ?? ''
-      accept('error', `DeploymentRelation source '${sourceCstText}' not resolved`, {
-        node: el,
-        property: 'source',
-      })
-      return
-    }
-    const target = el.target?.value?.ref
-    if (!target) {
-      let targetCstText = el.target?.$cstNode?.text ?? ''
-      accept('error', `DeploymentRelation target '${targetCstText}' not resolved`, {
-        node: el,
-        property: 'target',
-      })
-      return
-    }
-
-    const doc = getDocument(el)
-    const parser = ModelParser.forDocument(doc)
-
-    const sourceFqnRef = parser.parseFqnRef(el.source)
-    if (FqnRef.isModelRef(sourceFqnRef)) {
-      accept('error', 'DeploymentRelation must refer deployment element', {
-        node: el,
-        property: 'source',
-      })
-      return
-    }
-
-    const targetFqnRef = parser.parseFqnRef(el.target)
-    if (FqnRef.isModelRef(targetFqnRef)) {
-      accept('error', 'DeploymentRelation must refer deployment element', {
-        node: el,
-        property: 'target',
-      })
-      return
-    }
-
-    if (isSameHierarchy(sourceFqnRef.deployment, targetFqnRef.deployment)) {
-      accept('error', 'Invalid parent-child relationship', {
-        node: el,
-      })
-    }
-  })
-}

package/src/validation/dynamic-view-rule.ts

@@ -1,23 +0,0 @@
-import { nonexhaustive } from '@likec4/core'
-import type { ValidationCheck } from 'langium'
-import { ast, elementExpressionFromPredicate } from '../ast'
-import type { LikeC4Services } from '../module'
-import { tryOrLog } from './_shared'
-
-export const dynamicViewRulePredicate = (
-  _services: LikeC4Services,
-): ValidationCheck<ast.DynamicViewPredicateIterator> => {
-  return tryOrLog((predicate, accept) => {
-    const expr = elementExpressionFromPredicate(predicate.value)
-    switch (true) {
-      case ast.isElementKindExpression(expr):
-      case ast.isElementTagExpression(expr):
-      case ast.isWildcardExpression(expr): {
-        accept('warning', `Predicate is ignored, as not supported in dynamic views`, {
-          node: predicate,
-        })
-        return
-      }
-    }
-  })
-}

package/src/validation/dynamic-view-step.ts

@@ -1,36 +0,0 @@
-import { isAncestor } from '@likec4/core'
-import type { ValidationCheck } from 'langium'
-import { ast } from '../ast'
-import { logError } from '../logger'
-import type { LikeC4Services } from '../module'
-import { elementRef } from '../utils/elementRef'
-import { tryOrLog } from './_shared'
-
-export const dynamicViewStep = (services: LikeC4Services): ValidationCheck<ast.DynamicViewStep> => {
-  const fqnIndex = services.likec4.FqnIndex
-  return tryOrLog((el, accept) => {
-    const sourceEl: ast.Element | undefined = elementRef(el.source)
-    const source = sourceEl && fqnIndex.getFqn(sourceEl)
-    if (!source) {
-      accept('error', 'Source not found (not parsed/indexed yet)', {
-        node: el,
-        property: 'source',
-      })
-    }
-
-    const targetEl: ast.Element | undefined = elementRef(el.target)
-    const target = targetEl && fqnIndex.getFqn(targetEl)
-    if (!target) {
-      accept('error', 'Target not found (not parsed/indexed yet)', {
-        node: el,
-        property: 'target',
-      })
-    }
-
-    if (source && target && (isAncestor(source, target) || isAncestor(target, source))) {
-      accept('error', 'Invalid parent-child relationship', {
-        node: el,
-      })
-    }
-  })
-}

package/src/validation/element.ts

@@ -1,56 +0,0 @@
-import { AstUtils, type ValidationCheck } from 'langium'
-import type { ast } from '../ast'
-import type { LikeC4Services } from '../module'
-import { RESERVED_WORDS, tryOrLog } from './_shared'
-
-const { getDocument } = AstUtils
-
-export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Element> => {
-  const fqnIndex = services.likec4.FqnIndex
-  const locator = services.workspace.AstNodeLocator
-  return tryOrLog((el, accept) => {
-    const fqn = fqnIndex.getFqn(el)
-    if (!fqn) {
-      accept('error', 'Not indexed element', {
-        node: el,
-        property: 'name'
-      })
-      return
-    }
-    if (RESERVED_WORDS.includes(el.name)) {
-      accept('error', `Reserved word: ${el.name}`, {
-        node: el,
-        property: 'name'
-      })
-    }
-    const doc = getDocument(el)
-    const docUri = doc.uri
-    const elPath = locator.getAstNodePath(el)
-    const withSameFqn = fqnIndex
-      .byFqn(fqn)
-      .filter(v => v.documentUri !== docUri || v.path !== elPath)
-      .head()
-    if (withSameFqn) {
-      const isAnotherDoc = withSameFqn.documentUri !== docUri
-      accept(
-        'error',
-        `Duplicate element name ${el.name !== fqn ? el.name + ' (' + fqn + ')' : el.name}`,
-        {
-          node: el,
-          property: 'name',
-          ...isAnotherDoc && {
-            relatedInformation: [
-              {
-                location: {
-                  range: (withSameFqn.nameSegment?.range ?? withSameFqn.selectionSegment?.range)!,
-                  uri: withSameFqn.documentUri.toString()
-                },
-                message: `conflicting element`
-              }
-            ]
-          }
-        }
-      )
-    }
-  })
-}