@likec4/language-server 1.2.0 → 1.2.1

package/src/references/scope-computation.ts

@@ -0,0 +1,142 @@
+import {
+  type AstNode,
+  type AstNodeDescription,
+  DefaultScopeComputation,
+  MultiMap,
+  type PrecomputedScopes
+} from 'langium'
+import { isTruthy } from 'remeda'
+import type { CancellationToken } from 'vscode-languageserver'
+import { ast, type LikeC4LangiumDocument } from '../ast'
+import { logError } from '../logger'
+
+type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody
+
+export class LikeC4ScopeComputation extends DefaultScopeComputation {
+  override async computeExports(
+    document: LikeC4LangiumDocument,
+    _cancelToken?: CancellationToken
+  ): Promise<AstNodeDescription[]> {
+    const docExports: AstNodeDescription[] = []
+    try {
+      const { specifications, models, views } = document.parseResult.value
+
+      // Process specification
+      for (
+        const spec of specifications.flatMap(s => [
+          ...s.elements,
+          ...s.relationships,
+          ...s.tags
+        ])
+      ) {
+        try {
+          if (ast.isSpecificationTag(spec)) {
+            if (spec.tag && isTruthy(spec.tag.name)) {
+              docExports.push(
+                this.descriptions.createDescription(spec.tag, '#' + spec.tag.name, document)
+              )
+            }
+            continue
+          }
+          if (spec.kind && isTruthy(spec.kind.name)) {
+            docExports.push(
+              this.descriptions.createDescription(spec.kind, spec.kind.name, document)
+            )
+          }
+        } catch (e) {
+          logError(e)
+        }
+      }
+
+      // Process models
+      for (const elAst of models.flatMap(m => m.elements)) {
+        try {
+          if (ast.isElement(elAst) && isTruthy(elAst.name)) {
+            docExports.push(this.descriptions.createDescription(elAst, elAst.name, document))
+          }
+        } catch (e) {
+          logError(e)
+        }
+      }
+
+      // Process views
+      for (const viewAst of views.flatMap(v => v.views)) {
+        try {
+          if (isTruthy(viewAst.name)) {
+            docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document))
+          }
+        } catch (e) {
+          logError(e)
+        }
+      }
+    } catch (e) {
+      logError(e)
+    }
+    return docExports
+  }
+
+  override computeLocalScopes(
+    document: LikeC4LangiumDocument,
+    _cancelToken?: CancellationToken
+  ): Promise<PrecomputedScopes> {
+    return new Promise(resolve => {
+      const root = document.parseResult.value
+      const scopes = new MultiMap<AstNode, AstNodeDescription>()
+      for (const model of root.models) {
+        try {
+          const nested = this.processContainer(model, scopes, document)
+          scopes.addAll(root, nested.values())
+        } catch (e) {
+          logError(e)
+        }
+      }
+      resolve(scopes)
+    })
+  }
+
+  protected processContainer(
+    container: ElementsContainer,
+    scopes: PrecomputedScopes,
+    document: LikeC4LangiumDocument
+  ) {
+    const localScope = new MultiMap<string, AstNodeDescription>()
+    const nestedScopes = new MultiMap<string, AstNodeDescription>()
+    for (const el of container.elements) {
+      if (ast.isRelation(el)) {
+        continue
+      }
+
+      let subcontainer
+      if (ast.isElement(el)) {
+        if (isTruthy(el.name)) {
+          localScope.add(el.name, this.descriptions.createDescription(el, el.name, document))
+        }
+        subcontainer = el.body
+      } else if (ast.isExtendElement(el)) {
+        subcontainer = el.body
+      }
+
+      if (subcontainer && subcontainer.elements.length > 0) {
+        try {
+          const nested = this.processContainer(subcontainer, scopes, document)
+          for (const [nestedName, desc] of nested) {
+            nestedScopes.add(nestedName, desc)
+          }
+        } catch (e) {
+          logError(e)
+        }
+      }
+    }
+
+    if (nestedScopes.size > 0) {
+      for (const [name, descriptions] of nestedScopes.entriesGroupedByKey()) {
+        // If name is unique for current scope
+        if (!localScope.has(name) && descriptions.length === 1) {
+          localScope.add(name, descriptions[0]!)
+        }
+      }
+    }
+    scopes.addAll(container, localScope.values())
+    return localScope
+  }
+}

package/src/references/scope-provider.ts

@@ -0,0 +1,166 @@
+import type { likec4 as c4 } from '@likec4/core'
+import type { AstNode } from 'langium'
+import {
+  type AstNodeDescription,
+  AstUtils,
+  CstUtils,
+  DefaultScopeProvider,
+  DONE_RESULT,
+  EMPTY_STREAM,
+  GrammarUtils,
+  type ReferenceInfo,
+  type Scope,
+  type Stream,
+  stream,
+  StreamImpl,
+  StreamScope
+} from 'langium'
+import { ast } from '../ast'
+import { elementRef, getFqnElementRef } from '../elementRef'
+import { logError } from '../logger'
+import type { FqnIndex, FqnIndexEntry } from '../model/fqn-index'
+import type { LikeC4Services } from '../module'
+
+const { findNodeForProperty } = GrammarUtils
+const { toDocumentSegment } = CstUtils
+const { getDocument } = AstUtils
+
+function toAstNodeDescription(entry: FqnIndexEntry): AstNodeDescription {
+  const $cstNode = findNodeForProperty(entry.el.$cstNode, 'name')
+  return {
+    documentUri: entry.doc.uri,
+    name: entry.name,
+    ...(entry.el.$cstNode && {
+      selectionSegment: toDocumentSegment(entry.el.$cstNode)
+    }),
+    ...($cstNode && {
+      nameSegment: toDocumentSegment($cstNode)
+    }),
+    path: entry.path,
+    type: ast.Element
+  }
+}
+
+export class LikeC4ScopeProvider extends DefaultScopeProvider {
+  private fqnIndex: FqnIndex
+
+  constructor(services: LikeC4Services) {
+    super(services)
+    this.fqnIndex = services.likec4.FqnIndex
+  }
+
+  private directChildrenOf(parent: c4.Fqn): Stream<AstNodeDescription> {
+    return this.fqnIndex.directChildrenOf(parent).map(toAstNodeDescription)
+  }
+
+  // we need lazy resolving here
+  private uniqueDescedants(of: () => ast.Element | undefined): Stream<AstNodeDescription> {
+    return new StreamImpl(
+      () => {
+        const element = of()
+        const fqn = element && this.fqnIndex.getFqn(element)
+        if (fqn) {
+          return this.fqnIndex.uniqueDescedants(fqn).map(toAstNodeDescription).iterator()
+        }
+        return null
+      },
+      iterator => {
+        if (iterator) {
+          return iterator.next()
+        }
+        return DONE_RESULT
+      }
+    )
+  }
+
+  private scopeElementRef(ref: ast.ElementRef): Stream<AstNodeDescription> {
+    return this.uniqueDescedants(() => ref.el.ref)
+  }
+
+  private scopeExtendElement({ element }: ast.ExtendElement): Stream<AstNodeDescription> {
+    // we make extended element resolvable inside ExtendElementBody
+    return stream([element.el.$nodeDescription])
+      .nonNullable()
+      .concat(this.uniqueDescedants(() => elementRef(element)))
+  }
+
+  private scopeElementView({ viewOf, extends: ext }: ast.ElementView): Stream<AstNodeDescription> {
+    if (viewOf) {
+      // If we have "view of parent.target"
+      // we make "target" resolvable inside ElementView
+      return stream([viewOf.el.$nodeDescription])
+        .nonNullable()
+        .concat(this.uniqueDescedants(() => elementRef(viewOf)))
+    }
+    if (ext) {
+      return stream([ext]).flatMap(v => {
+        const view = v.view.ref
+        return view ? this.scopeElementView(view) : EMPTY_STREAM
+      })
+    }
+    return EMPTY_STREAM
+  }
+
+  override getScope(context: ReferenceInfo): Scope {
+    const referenceType = this.reflection.getReferenceType(context)
+    try {
+      const container = context.container
+      if (ast.isFqnElementRef(container) && context.property === 'el') {
+        const parent = container.parent
+        if (!parent) {
+          return this.getGlobalScope(referenceType)
+        }
+        return new StreamScope(this.directChildrenOf(getFqnElementRef(parent)))
+      }
+      if (ast.isElementRef(container) && context.property === 'el') {
+        const parent = container.parent
+        if (parent) {
+          return new StreamScope(this.scopeElementRef(parent))
+        }
+      }
+      return this.computeScope(context)
+    } catch (e) {
+      logError(e)
+      return this.getGlobalScope(referenceType)
+    }
+  }
+
+  protected computeScope(context: ReferenceInfo) {
+    const referenceType = this.reflection.getReferenceType(context)
+    const scopes: Stream<AstNodeDescription>[] = []
+    const doc = getDocument(context.container)
+    const precomputed = doc.precomputedScopes
+
+    if (precomputed) {
+      const byReferenceType = (desc: AstNodeDescription) => this.reflection.isSubtype(desc.type, referenceType)
+
+      let container: AstNode | undefined = context.container
+      while (container) {
+        const elements = precomputed.get(container).filter(byReferenceType)
+        if (elements.length > 0) {
+          scopes.push(stream(elements))
+        }
+        if (referenceType === ast.Element) {
+          if (ast.isExtendElementBody(container)) {
+            scopes.push(this.scopeExtendElement(container.$container))
+          }
+          if (ast.isElementViewBody(container)) {
+            scopes.push(this.scopeElementView(container.$container))
+          }
+        }
+        container = container.$container
+      }
+    }
+
+    return scopes.reduceRight((outerScope, elements) => {
+      return this.createScope(elements, outerScope)
+    }, this.getGlobalScope(referenceType))
+  }
+
+  /**
+   * Create a global scope filtered for the given reference type.
+   */
+  protected override getGlobalScope(referenceType: string): Scope {
+    return new StreamScope(this.indexManager.allElements(referenceType))
+  }
+}

package/src/shared/NodeKindProvider.ts

@@ -0,0 +1,67 @@
+import { type AstNode, type AstNodeDescription } from 'langium'
+import type { LangiumSharedServices, NodeKindProvider as LspNodeKindProvider } from 'langium/lsp'
+import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-protocol'
+import { ast } from '../ast'
+
+export class NodeKindProvider implements LspNodeKindProvider {
+  constructor(private services: LangiumSharedServices) {}
+
+  /**
+   * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
+   */
+  // prettier-ignore
+  getSymbolKind(node: AstNode | AstNodeDescription): SymbolKind {
+    const hasType = (type: string) => 'type' in node && this.services.AstReflection.isSubtype(node.type, type)
+    switch (true) {
+      case (ast.isElement(node) || hasType(ast.Element))
+        || (ast.isExtendElement(node) || hasType(ast.ExtendElement)): {
+        return SymbolKind.Constructor
+      }
+      case ast.isModel(node) || ast.isModelViews(node) || ast.isSpecificationRule(node)
+        || hasType(ast.Model) || hasType(ast.ModelViews) || hasType(ast.SpecificationRule): {
+        return SymbolKind.Namespace
+      }
+      case (ast.isLikeC4View(node) || hasType(ast.LikeC4View)): {
+        return SymbolKind.Class
+      }
+      case (ast.isTag(node) || hasType(ast.Tag))
+        || (ast.isSpecificationTag(node) || hasType(ast.SpecificationTag)): {
+        return SymbolKind.EnumMember
+      }
+      case (ast.isRelationshipKind(node) || hasType(ast.RelationshipKind))
+        || (ast.isSpecificationRelationshipKind(node) || hasType(ast.SpecificationRelationshipKind)): {
+        return SymbolKind.Event
+      }
+      case (ast.isElementKind(node) || hasType(ast.ElementKind))
+        || (ast.isSpecificationElementKind(node) || hasType(ast.SpecificationElementKind)): {
+        return SymbolKind.TypeParameter
+      }
+    }
+    return SymbolKind.Constant
+  }
+  /**
+   * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
+   */
+  getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind {
+    switch (this.getSymbolKind(node)) {
+      case SymbolKind.Constructor:
+        return CompletionItemKind.Constructor
+      case SymbolKind.Namespace:
+        return CompletionItemKind.Module
+      case SymbolKind.Class:
+        return CompletionItemKind.Class
+      case SymbolKind.Enum:
+        return CompletionItemKind.Enum
+      case SymbolKind.EnumMember:
+        return CompletionItemKind.EnumMember
+      case SymbolKind.TypeParameter:
+        return CompletionItemKind.TypeParameter
+      case SymbolKind.Interface:
+        return CompletionItemKind.Interface
+      case SymbolKind.Event:
+        return CompletionItemKind.Event
+      default:
+        return CompletionItemKind.Reference
+    }
+  }
+}

package/src/shared/WorkspaceManager.ts

@@ -0,0 +1,39 @@
+import { hasAtLeast, invariant } from '@likec4/core'
+import type { LangiumDocument } from 'langium'
+import { DefaultWorkspaceManager } from 'langium'
+import type { WorkspaceFolder } from 'vscode-languageserver'
+import { URI } from 'vscode-uri'
+
+export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+  /**
+   * 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 loadAdditionalDocuments(
+    _folders: WorkspaceFolder[],
+    _collector: (document: LangiumDocument) => void
+  ): Promise<void> {
+    // collector(this.documentFactory.fromString(builtin.specification.document, URI.parse(builtin.specification.uri)))
+    return Promise.resolve()
+  }
+
+  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

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

package/src/shared/index.ts

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

package/src/test/index.ts

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

package/src/test/testServices.ts

@@ -0,0 +1,119 @@
+import { DocumentState, EmptyFileSystem } from 'langium'
+import * as assert from 'node:assert'
+import stripIndent from 'strip-indent'
+import { type Diagnostic, DiagnosticSeverity } from 'vscode-languageserver-protocol'
+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 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
+        await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder])
+        // Workaround to set protected folders property
+        Object.assign(services.shared.workspace.WorkspaceManager, {
+          folders: [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
+    }
+  }
+
+  type ValidateAllResult = {
+    diagnostics: Diagnostic[]
+    errors: string[]
+    warnings: string[]
+  }
+  let previousPromise = Promise.resolve() as Promise<any>
+  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 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,
+    resetState
+  }
+}
+
+export type TestServices = ReturnType<typeof createTestServices>
+export type TestParseFn = TestServices['validate']
+export type TestValidateFn = TestServices['validate']

package/src/utils/index.ts

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

package/src/utils/printDocs.ts

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

package/src/utils/stringHash.ts

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

package/{dist/validation/dynamic-view-rule.js → src/validation/dynamic-view-rule.ts}

@@ -1,7 +1,10 @@
-import { nonexhaustive } from "@likec4/core";
-import { ast } from "../ast.js";
-import { logError } from "../logger.js";
-export const dynamicViewRulePredicate = (_services) => {
+import { nonexhaustive } from '@likec4/core'
+import type { ValidationCheck } from 'langium'
+import { ast } from '../ast'
+import { logError } from '../logger'
+import type { LikeC4Services } from '../module'
+
+export const dynamicViewRulePredicate = (_services: LikeC4Services): ValidationCheck<ast.DynamicViewRulePredicate> => {
   return (el, accept) => {
     try {
       for (const expr of el.expressions) {
@@ -10,7 +13,7 @@ export const dynamicViewRulePredicate = (_services) => {
           case ast.isDescedantsExpr(expr):
           case ast.isCustomElementExpr(expr):
           case ast.isExpandElementExpr(expr):
-            return;
+            return
           case ast.isRelationExpr(expr):
           case ast.isInOutExpr(expr):
           case ast.isIncomingExpr(expr):
@@ -18,15 +21,15 @@ export const dynamicViewRulePredicate = (_services) => {
           case ast.isElementKindExpr(expr):
           case ast.isElementTagExpr(expr):
           case ast.isWildcardExpr(expr):
-            return accept("warning", `Expression is not supported by dynamic views`, {
+            return accept('warning', `Expression is not supported by dynamic views`, {
               node: expr
-            });
+            })
           default:
-            nonexhaustive(expr);
+            nonexhaustive(expr)
         }
       }
     } catch (e) {
-      logError(e);
+      logError(e)
     }
-  };
-};
+  }
+}

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

@@ -0,0 +1,39 @@
+import { isAncestor } from '@likec4/core'
+import type { ValidationCheck } from 'langium'
+import { ast } from '../ast'
+import { elementRef } from '../elementRef'
+import { logError } from '../logger'
+import type { LikeC4Services } from '../module'
+
+export const dynamicViewStep = (services: LikeC4Services): ValidationCheck<ast.DynamicViewStep> => {
+  const fqnIndex = services.likec4.FqnIndex
+  return (el, accept) => {
+    try {
+      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
+        })
+      }
+    } catch (e) {
+      logError(e)
+    }
+  }
+}