@likec4/language-server 1.21.1 → 1.22.1

package/src/references/scope-computation.ts

@@ -1,364 +0,0 @@
-import { nonexhaustive } from '@likec4/core'
-import {
-  type AstNode,
-  type AstNodeDescription,
-  type PrecomputedScopes,
-  DefaultScopeComputation,
-  MultiMap,
-} from 'langium'
-import { entries, filter, flatMap, forEachObj, groupBy, isNullish, isTruthy, pipe } from 'remeda'
-import type { CancellationToken } from 'vscode-languageserver'
-import { type LikeC4LangiumDocument, ast } from '../ast'
-import { logWarnError } from '../logger'
-import type { LikeC4Services } from '../module'
-
-type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody
-type DeploymentsContainer = ast.ModelDeployments | ast.DeploymentNodeBody
-
-function uniqueDescriptions(
-  descs: AstNodeDescription[],
-): AstNodeDescription[] {
-  return pipe(
-    descs,
-    groupBy(desc => `${desc.type}.${desc.name}`),
-    entries(),
-    flatMap(([_, descs]) => descs.length === 1 ? descs : []),
-  )
-}
-
-export class LikeC4ScopeComputation extends DefaultScopeComputation {
-  constructor(services: LikeC4Services) {
-    super(services)
-  }
-
-  override async computeExports(
-    document: LikeC4LangiumDocument,
-    _cancelToken?: CancellationToken,
-  ): Promise<AstNodeDescription[]> {
-    const docExports: AstNodeDescription[] = []
-    try {
-      const { specifications, models, views, globals, likec4lib, deployments } = document.parseResult.value
-
-      // Process library
-      this.exportLibrary(likec4lib, docExports, document)
-
-      // Process specification
-      this.exportSpecification(specifications, docExports, document)
-
-      // Process models
-      this.exportModel(models, docExports, document)
-
-      // Process views
-      this.exportViews(views, docExports, document)
-
-      // Process global
-      this.exportGlobals(globals, docExports, document)
-
-      this.exportDeployments(deployments, docExports, document)
-    } catch (e) {
-      logWarnError(e)
-    }
-    return docExports
-  }
-
-  private exportViews(
-    modelViews: ast.ModelViews[] | undefined,
-    docExports: AstNodeDescription[],
-    document: LikeC4LangiumDocument,
-  ) {
-    const views = modelViews?.flatMap(m => m.views)
-    if (isNullish(views) || views.length === 0) {
-      return
-    }
-    for (const viewAst of views) {
-      try {
-        if (isTruthy(viewAst.name)) {
-          docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document))
-        }
-      } catch (e) {
-        logWarnError(e)
-      }
-    }
-  }
-
-  private exportGlobals(
-    globals: ast.Globals[] | undefined,
-    docExports: AstNodeDescription[],
-    document: LikeC4LangiumDocument,
-  ) {
-    if (isNullish(globals) || globals.length === 0) {
-      return
-    }
-    for (const globalPredicateAst of globals.flatMap(g => g.predicates)) {
-      try {
-        const id = globalPredicateAst
-        if (isTruthy(id.name)) {
-          docExports.push(this.descriptions.createDescription(id, id.name, document))
-        }
-      } catch (e) {
-        logWarnError(e)
-      }
-    }
-    for (const globalStyleAst of globals.flatMap(g => g.styles)) {
-      try {
-        const id = globalStyleAst.id
-        if (isTruthy(id.name)) {
-          docExports.push(this.descriptions.createDescription(id, id.name, document))
-        }
-      } catch (e) {
-        logWarnError(e)
-      }
-    }
-  }
-
-  private exportModel(
-    models: ast.Model[] | undefined,
-    docExports: AstNodeDescription[],
-    document: LikeC4LangiumDocument,
-  ) {
-    if (isNullish(models) || models.length === 0) {
-      return
-    }
-    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) {
-        logWarnError(e)
-      }
-    }
-  }
-
-  private exportLibrary(
-    likec4lib: ast.LikeC4Lib[] | undefined,
-    docExports: AstNodeDescription[],
-    document: LikeC4LangiumDocument,
-  ) {
-    if (isNullish(likec4lib)) {
-      return
-    }
-    try {
-      for (const iconAst of likec4lib.flatMap(l => l.icons)) {
-        docExports.push(this.descriptions.createDescription(iconAst, iconAst.name, document))
-      }
-    } catch (e) {
-      logWarnError(e)
-    }
-  }
-
-  private exportSpecification(
-    specifications: ast.SpecificationRule[] | undefined,
-    docExports: AstNodeDescription[],
-    document: LikeC4LangiumDocument,
-  ) {
-    if (isNullish(specifications) || specifications.length === 0) {
-      return
-    }
-    for (
-      const spec of specifications.flatMap(s => [
-        ...s.elements,
-        ...s.relationships,
-        ...s.deploymentNodes,
-        ...s.tags,
-        ...s.colors,
-      ])
-    ) {
-      try {
-        switch (true) {
-          case ast.isSpecificationDeploymentNodeKind(spec):
-          case ast.isSpecificationElementKind(spec): {
-            if (isTruthy(spec.kind.name)) {
-              docExports.push(
-                this.descriptions.createDescription(spec.kind, spec.kind.name, document),
-              )
-            }
-            continue
-          }
-          case ast.isSpecificationTag(spec): {
-            if (isTruthy(spec.tag.name)) {
-              docExports.push(
-                this.descriptions.createDescription(spec.tag, '#' + spec.tag.name, document),
-              )
-            }
-            continue
-          }
-          case ast.isSpecificationRelationshipKind(spec): {
-            if (isTruthy(spec.kind.name)) {
-              docExports.push(
-                this.descriptions.createDescription(spec.kind, spec.kind.name, document),
-                this.descriptions.createDescription(spec.kind, '.' + spec.kind.name, document),
-              )
-            }
-            continue
-          }
-          case ast.isSpecificationColor(spec): {
-            if (isTruthy(spec.name.name)) {
-              docExports.push(
-                this.descriptions.createDescription(spec.name, spec.name.name, document),
-              )
-            }
-            continue
-          }
-          // Thow error if not exhaustive
-          default:
-            nonexhaustive(spec)
-        }
-      } catch (e) {
-        logWarnError(e)
-      }
-    }
-  }
-
-  private exportDeployments(
-    modelDeployments: ast.ModelDeployments[] | undefined,
-    docExports: AstNodeDescription[],
-    document: LikeC4LangiumDocument,
-  ) {
-    const nodes = modelDeployments?.flatMap(m => m.elements)
-    if (isNullish(nodes) || nodes.length === 0) {
-      return
-    }
-    for (const node of nodes) {
-      try {
-        if (ast.isDeploymentNode(node) && isTruthy(node.name)) {
-          docExports.push(this.descriptions.createDescription(node, node.name, document))
-        }
-      } catch (e) {
-        logWarnError(e)
-      }
-    }
-  }
-
-  override computeLocalScopes(
-    document: LikeC4LangiumDocument,
-    _cancelToken?: CancellationToken,
-  ): Promise<PrecomputedScopes> {
-    return new Promise(resolve => {
-      const root = document.parseResult.value
-      const descendants = [] as AstNodeDescription[]
-      const scopes = new MultiMap<AstNode, AstNodeDescription>()
-
-      for (const model of root.models) {
-        try {
-          descendants.push(
-            ...this.processContainer(model, scopes, document),
-          )
-        } catch (e) {
-          logWarnError(e)
-        }
-      }
-      for (const deployment of root.deployments) {
-        try {
-          descendants.push(
-            ...this.processDeployments(deployment, scopes, document),
-          )
-        } catch (e) {
-          logWarnError(e)
-        }
-      }
-
-      uniqueDescriptions(descendants).forEach(desc => {
-        scopes.add(root, desc)
-      })
-
-      resolve(scopes)
-    })
-  }
-
-  protected processContainer(
-    container: ElementsContainer,
-    scopes: PrecomputedScopes,
-    document: LikeC4LangiumDocument,
-  ): AstNodeDescription[] {
-    const localScope = new MultiMap<string, AstNodeDescription>()
-    const descedants = [] as 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 {
-          descedants.push(
-            ...this.processContainer(subcontainer, scopes, document),
-          )
-        } catch (e) {
-          logWarnError(e)
-        }
-      }
-    }
-
-    if (descedants.length) {
-      pipe(
-        descedants,
-        filter(desc => !localScope.has(desc.name)),
-        groupBy(desc => desc.name),
-        forEachObj((descs, name) => {
-          if (descs.length === 1) {
-            localScope.add(name, descs[0])
-          }
-        }),
-      )
-    }
-    const local = [...localScope.values()]
-    scopes.addAll(container, local)
-    return local
-  }
-
-  protected processDeployments(
-    container: DeploymentsContainer,
-    scopes: PrecomputedScopes,
-    document: LikeC4LangiumDocument,
-  ): AstNodeDescription[] {
-    const localnames = new Set<string>()
-    const descedants = [] as AstNodeDescription[]
-
-    for (const el of container.elements) {
-      if (ast.isDeploymentRelation(el)) {
-        continue
-      }
-
-      let name = this.nameProvider.getName(el)
-      if (isTruthy(name)) {
-        const desc = this.descriptions.createDescription(el, name, document)
-        scopes.add(container, desc)
-        localnames.add(desc.name)
-      }
-
-      if (ast.isDeploymentNode(el) && el.body) {
-        try {
-          descedants.push(
-            ...this.processDeployments(el.body, scopes, document),
-          )
-        } catch (e) {
-          logWarnError(e)
-        }
-      }
-    }
-    if (descedants.length > 0) {
-      pipe(
-        descedants,
-        filter(desc => !localnames.has(desc.name)),
-        groupBy(desc => desc.name),
-        forEachObj((descs, name) => {
-          if (descs.length === 1) {
-            scopes.add(container, descs[0])
-          }
-        }),
-      )
-    }
-    return [...scopes.get(container).values()]
-  }
-}

package/src/references/scope-provider.ts

@@ -1,201 +0,0 @@
-import type * as c4 from '@likec4/core'
-import { nonexhaustive } from '@likec4/core'
-import type { AstNode } from 'langium'
-import {
-  type AstNodeDescription,
-  type ReferenceInfo,
-  type Scope,
-  type Stream,
-  AstUtils,
-  DefaultScopeProvider,
-  DONE_RESULT,
-  EMPTY_SCOPE,
-  EMPTY_STREAM,
-  MapScope,
-  stream,
-  StreamImpl,
-  StreamScope,
-} from 'langium'
-import { ast } from '../ast'
-import { logger } from '../logger'
-import type { DeploymentsIndex, FqnIndex } from '../model'
-import type { LikeC4Services } from '../module'
-import { elementRef, getFqnElementRef } from '../utils/elementRef'
-
-const { getDocument } = AstUtils
-
-export class LikeC4ScopeProvider extends DefaultScopeProvider {
-  private deploymentsIndex: DeploymentsIndex
-  private fqnIndex: FqnIndex
-
-  constructor(services: LikeC4Services) {
-    super(services)
-    this.fqnIndex = services.likec4.FqnIndex
-    this.deploymentsIndex = services.likec4.DeploymentsIndex
-  }
-
-  private directChildrenOf(parent: c4.Fqn): Stream<AstNodeDescription> {
-    return this.fqnIndex.directChildrenOf(parent)
-  }
-
-  // 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).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 {
-    try {
-      const referenceType = this.reflection.getReferenceType(context)
-      try {
-        const container = context.container
-        if (ast.isFqnRef(container)) {
-          return this.getScopeForFqnRef(container, context)
-        }
-
-        if (referenceType !== ast.Element) {
-          return this.getGlobalScope(referenceType, context)
-        }
-
-        if (ast.isStrictFqnElementRef(container) && context.property === 'el') {
-          const parent = container.parent
-          if (!parent) {
-            return this.getGlobalScope(referenceType, context)
-          }
-          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))
-          }
-          // if we have elementRef "this" or "it" we resolve it to the closest element
-          if (context.reference.$refText === 'this' || context.reference.$refText === 'it') {
-            const closestElement = AstUtils.getContainerOfType(container, ast.isElement)
-            if (closestElement) {
-              return new MapScope([
-                this.descriptions.createDescription(closestElement, context.reference.$refText),
-              ])
-            } else {
-              return EMPTY_SCOPE
-            }
-          }
-        }
-        return this.computeScope(context)
-      } catch (e) {
-        logger.warn(e)
-        return this.getGlobalScope(referenceType, context)
-      }
-    } catch (e) {
-      logger.warn(e)
-      return EMPTY_SCOPE
-    }
-  }
-
-  protected getScopeForFqnRef(container: ast.FqnRef, context: ReferenceInfo) {
-    const parent = container.parent
-    if (!parent) {
-      return this.createScope(
-        // First preference for deployment nodes
-        this.computeScope(context, ast.DeploymentNode).getAllElements(),
-        this.createScope(
-          // Second preference for deployed instances
-          this.computeScope(context, ast.DeployedInstance).getAllElements(),
-          // Third preference for elements if we are in deployment view
-          AstUtils.hasContainerOfType(container, ast.isDeploymentView)
-            ? this.computeScope(context, ast.Element)
-            : EMPTY_SCOPE,
-        ),
-      )
-    }
-    const parentRef = parent.value.ref
-    if (!parentRef) {
-      return EMPTY_SCOPE
-    }
-    if (ast.isDeploymentNode(parentRef)) {
-      return new StreamScope(this.deploymentsIndex.nested(parentRef))
-    }
-    if (ast.isDeployedInstance(parentRef)) {
-      return new StreamScope(this.scopeElementRef(parentRef.element))
-    }
-    if (ast.isElement(parentRef)) {
-      return new StreamScope(this.uniqueDescedants(() => parentRef))
-    }
-    return nonexhaustive(parentRef)
-  }
-
-  protected computeScope(context: ReferenceInfo, referenceType = this.reflection.getReferenceType(context)) {
-    const isElementReference = this.reflection.isSubtype(referenceType, ast.Element)
-
-    const scopes: Stream<AstNodeDescription>[] = []
-    const doc = getDocument(context.container)
-    const precomputed = doc.precomputedScopes
-
-    if (!precomputed) {
-      return this.getGlobalScope(referenceType, context)
-    }
-
-    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 (isElementReference && ast.isExtendElementBody(container)) {
-        scopes.push(this.scopeExtendElement(container.$container))
-      }
-      if (isElementReference && 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, context))
-  }
-}

package/src/shared/NodeKindProvider.ts

@@ -1,121 +0,0 @@
-import { type AstNode, type AstNodeDescription, isAstNode } from 'langium'
-import type { LangiumSharedServices, NodeKindProvider as LspNodeKindProvider } from 'langium/lsp'
-import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-types'
-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 nodeType = isAstNode(node) ? node.$type : node.type
-    const hasType = (...types: string[]) => types.some(t => this.services.AstReflection.isSubtype(nodeType, t))
-    switch (true) {
-      case hasType(
-        ast.Element,
-        ast.ExtendElement,
-        ast.DeploymentNode,
-        ast.DeployedInstance
-      ):
-        return SymbolKind.Constructor
-
-      case hasType(
-        ast.Model,
-        ast.ModelViews,
-        ast.ModelDeployments,
-        ast.Globals,
-        ast.SpecificationRule
-      ):
-        return SymbolKind.Namespace
-
-      case hasType(ast.LikeC4View):
-        return SymbolKind.Class
-
-      case hasType(
-        ast.Tag,
-        ast.LibIcon,
-        ast.CustomColor,
-        ast.SpecificationTag
-      ):
-        return SymbolKind.EnumMember
-
-      case hasType(
-        ast.RelationshipKind,
-        ast.SpecificationRelationshipKind
-      ):
-        return SymbolKind.Event
-
-      case hasType(
-        ast.ElementKind,
-        ast.DeploymentNodeKind,
-        ast.SpecificationElementKind,
-        ast.SpecificationDeploymentNodeKind
-      ):
-        return SymbolKind.TypeParameter
-    }
-    return SymbolKind.Field
-  }
-  /**
-   * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
-   */
-  getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind {
-    const nodeType = isAstNode(node) ? node.$type : node.type
-    const hasType = (...types: string[]) => types.some(t => this.services.AstReflection.isSubtype(nodeType, t))
-    switch (true) {
-      case hasType(
-        ast.CustomColor
-      ):
-        return CompletionItemKind.Color
-
-      case hasType(
-        ast.Element,
-        ast.DeploymentNode,
-        ast.DeployedInstance,
-        ast.ExtendElement
-      ):
-        return CompletionItemKind.Constructor
-
-      case hasType(
-        ast.Model,
-        ast.ModelViews,
-        ast.ModelDeployments,
-        ast.Globals,
-        ast.SpecificationRule
-      ):
-        return CompletionItemKind.Module
-
-      case hasType(
-        ast.LikeC4View
-      ):
-        return CompletionItemKind.Class
-
-      case hasType(
-        ast.Tag,
-        ast.LibIcon,
-        ast.CustomColor,
-        ast.SpecificationTag
-      ):
-        return CompletionItemKind.EnumMember
-
-      case hasType(
-        ast.RelationshipKind,
-        ast.SpecificationRelationshipKind
-      ):
-        return CompletionItemKind.Event
-
-      case hasType(
-        ast.ElementKind,
-        ast.SpecificationElementKind,
-        ast.DeploymentNodeKind,
-        ast.SpecificationDeploymentNodeKind
-      ):
-        return CompletionItemKind.TypeParameter
-
-      default:
-        return CompletionItemKind.Reference
-    }
-  }
-}