@likec4/language-server 1.2.0 → 1.2.2

package/src/lsp/index.ts

@@ -0,0 +1,6 @@
+export * from './CodeLensProvider'
+export * from './DocumentHighlightProvider'
+export * from './DocumentLinkProvider'
+export * from './DocumentSymbolProvider'
+export * from './HoverProvider'
+export * from './SemanticTokenProvider'

package/src/model/fqn-computation.ts

@@ -0,0 +1,47 @@
+import { AsFqn, type c4, nonexhaustive } from '@likec4/core'
+import { MultiMap } from 'langium'
+import { isEmpty, isNullish as isNil } from 'remeda'
+import { ast, ElementOps, type LikeC4LangiumDocument } from '../ast'
+import { getFqnElementRef } from '../elementRef'
+import type { LikeC4Services } from '../module'
+
+type TraversePair = [el: ast.Element | ast.ExtendElement | ast.Relation, parent: c4.Fqn | null]
+
+export function computeDocumentFqn(document: LikeC4LangiumDocument, services: LikeC4Services) {
+  const c4fqns = (document.c4fqns = new MultiMap())
+  const elements = document.parseResult.value.models.flatMap(m => m.elements)
+  if (elements.length === 0) {
+    return
+  }
+  const locator = services.workspace.AstNodeLocator
+  const traverseStack: TraversePair[] = elements.map(el => [el, null])
+  let pair
+  while ((pair = traverseStack.shift())) {
+    const [el, parent] = pair
+    if (ast.isRelation(el)) {
+      continue
+    }
+    if (ast.isExtendElement(el)) {
+      if (!isNil(el.body) && !isEmpty(el.body.elements)) {
+        const fqn = getFqnElementRef(el.element)
+        el.body.elements.forEach(child => traverseStack.push([child, fqn]))
+      }
+      continue
+    }
+    if (ast.isElement(el)) {
+      const fqn = AsFqn(el.name, parent)
+      const path = locator.getAstNodePath(el)
+      c4fqns.add(fqn, {
+        el: new WeakRef(el),
+        path,
+        name: el.name
+      })
+      ElementOps.writeId(el, fqn)
+      if (!isNil(el.body) && !isEmpty(el.body.elements)) {
+        el.body.elements.forEach(child => traverseStack.push([child, fqn]))
+      }
+      continue
+    }
+    nonexhaustive(el)
+  }
+}

package/src/model/fqn-index.ts

@@ -0,0 +1,161 @@
+import type { Fqn } from '@likec4/core'
+import { nameFromFqn, parentFqn } from '@likec4/core'
+import type { LangiumDocuments, Stream } from 'langium'
+import { DocumentState, DONE_RESULT, MultiMap, stream, StreamImpl } from 'langium'
+import type { ast, FqnIndexedDocument } from '../ast'
+import { ElementOps, isFqnIndexedDocument, isLikeC4LangiumDocument } from '../ast'
+import { logError, logger } from '../logger'
+import type { LikeC4Services } from '../module'
+import { printDocs } from '../utils/printDocs'
+import { computeDocumentFqn } from './fqn-computation'
+
+export interface FqnIndexEntry {
+  fqn: Fqn
+  name: string
+  el: ast.Element
+  doc: FqnIndexedDocument
+  path: string
+}
+
+const True = () => true
+
+export class FqnIndex {
+  protected langiumDocuments: LangiumDocuments
+
+  constructor(private services: LikeC4Services) {
+    this.langiumDocuments = services.shared.workspace.LangiumDocuments
+
+    services.shared.workspace.DocumentBuilder.onBuildPhase(
+      DocumentState.IndexedContent,
+      async (docs, _cancelToken) => {
+        logger.debug(`[FqnIndex] onIndexedContent ${docs.length}:\n` + printDocs(docs))
+        for (const doc of docs) {
+          if (isLikeC4LangiumDocument(doc)) {
+            delete doc.c4fqns
+            delete doc.c4Elements
+            delete doc.c4Specification
+            delete doc.c4Relations
+            delete doc.c4Views
+            try {
+              computeDocumentFqn(doc, services)
+            } catch (e) {
+              logError(e)
+            }
+          }
+        }
+        return Promise.resolve()
+      }
+    )
+    logger.debug(`[FqnIndex] Created`)
+  }
+
+  get documents() {
+    return this.langiumDocuments.all.filter(isFqnIndexedDocument)
+  }
+
+  private entries(filterByFqn: (fqn: Fqn) => boolean = True): Stream<FqnIndexEntry> {
+    return this.documents.flatMap(doc =>
+      doc.c4fqns.entries().flatMap(([fqn, entry]): FqnIndexEntry | FqnIndexEntry[] => {
+        if (filterByFqn(fqn)) {
+          const el = entry.el.deref()
+          if (el) {
+            return { ...entry, fqn, el, doc }
+          }
+        }
+        return []
+      })
+    )
+  }
+
+  public getFqn(el: ast.Element): Fqn | null {
+    return ElementOps.readId(el) ?? null
+    // let fqn = ElementOps.readId(el) ?? null
+    // if (fqn) {
+    //   const doc = getDocument(el)
+    //   if (isFqnIndexedDocument(doc) && doc.c4fqns.has(fqn)) {
+    //     return fqn
+    //   }
+    //   const path = this.services.workspace.AstNodeLocator.getAstNodePath(el)
+    //   logError(`Clean cached FQN ${fqn} at ${path}`)
+    //   ElementOps.writeId(el, null)
+    //   fqn = null
+    // }
+    // return fqn
+  }
+
+  public byFqn(fqn: Fqn): Stream<FqnIndexEntry> {
+    return this.documents.flatMap(doc => {
+      return doc.c4fqns.get(fqn).flatMap(entry => {
+        const el = entry.el.deref()
+        if (el) {
+          return { fqn, el, doc, path: entry.path, name: entry.name }
+        }
+        return []
+      })
+    })
+  }
+
+  public directChildrenOf(parent: Fqn): Stream<FqnIndexEntry> {
+    return stream([parent]).flatMap(_parent => {
+      const children = this.entries(fqn => parentFqn(fqn) === _parent)
+        .map((entry): [string, FqnIndexEntry] => [entry.name, entry])
+        .toArray()
+      if (children.length === 0) {
+        return []
+      }
+      return new MultiMap(children)
+        .entriesGroupedByKey()
+        .flatMap(([_name, descrs]) => (descrs.length === 1 ? descrs : []))
+        .iterator()
+    })
+  }
+
+  /**
+   * Returns descedant elements with unique names in the scope
+   */
+  public uniqueDescedants(parent: Fqn): Stream<FqnIndexEntry> {
+    return new StreamImpl(
+      () => {
+        const prefix = `${parent}.`
+
+        const childrenNames = new Set<string>()
+        const descedants = [] as FqnIndexEntry[]
+
+        const nested = new MultiMap<string, FqnIndexEntry>()
+
+        this.entries(f => f.startsWith(prefix)).forEach(e => {
+          const name = nameFromFqn(e.fqn)
+          const entry = { ...e, name }
+          // To keep direct children always
+          if (parentFqn(e.fqn) === parent) {
+            childrenNames.add(name)
+            nested.add(name, entry)
+          } else {
+            descedants.push(entry)
+          }
+        })
+
+        if (nested.size + descedants.length === 0) {
+          return null
+        }
+
+        for (const descedant of descedants) {
+          if (!childrenNames.has(descedant.name)) {
+            nested.add(descedant.name, descedant)
+          }
+        }
+
+        return nested
+          .entriesGroupedByKey()
+          .flatMap(([_name, descrs]) => (descrs.length === 1 ? descrs : []))
+          .iterator()
+      },
+      iterator => {
+        if (iterator) {
+          return iterator.next()
+        }
+        return DONE_RESULT as IteratorResult<FqnIndexEntry>
+      }
+    )
+  }
+}

package/src/model/index.ts

@@ -0,0 +1,5 @@
+export * from './fqn-computation'
+export * from './fqn-index'
+export * from './model-builder'
+export * from './model-locator'
+export * from './model-parser'

package/src/model/model-builder.ts

@@ -0,0 +1,447 @@
+import {
+  type c4,
+  compareByFqnHierarchically,
+  isElementView,
+  isStrictElementView,
+  parentFqn,
+  type StrictElementView,
+  type ViewID
+} from '@likec4/core'
+import { computeDynamicView, computeView, LikeC4ModelGraph } from '@likec4/graph'
+import { deepEqual as eq } from 'fast-equals'
+import type { URI, WorkspaceCache } from 'langium'
+import { DocumentState, interruptAndCheck, type LangiumDocument, type LangiumDocuments } from 'langium'
+import {
+  filter,
+  find,
+  flatMap,
+  forEach,
+  isNullish,
+  isTruthy,
+  map,
+  mapToObj,
+  pipe,
+  prop,
+  reduce,
+  sort,
+  values
+} from 'remeda'
+import { type CancellationToken, Disposable } from 'vscode-languageserver'
+import type {
+  ParsedAstElement,
+  ParsedAstRelation,
+  ParsedAstSpecification,
+  ParsedAstView,
+  ParsedLikeC4LangiumDocument
+} from '../ast'
+import { isParsedLikeC4LangiumDocument } from '../ast'
+import { logError, logger, logWarnError } from '../logger'
+import type { LikeC4Services } from '../module'
+import { printDocs } from '../utils/printDocs'
+import { assignNavigateTo, resolveRelativePaths, resolveRulesExtendedViews } from '../view-utils'
+
+function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[]) {
+  const c4Specification: ParsedAstSpecification = {
+    kinds: {},
+    relationships: {}
+  }
+  forEach(map(docs, prop('c4Specification')), spec => {
+    Object.assign(c4Specification.kinds, spec.kinds)
+    Object.assign(c4Specification.relationships, spec.relationships)
+  })
+  const resolveLinks = (doc: LangiumDocument, links: c4.NonEmptyArray<string>) => {
+    return links.map(l => services.lsp.DocumentLinkProvider.resolveLink(doc, l)) as c4.NonEmptyArray<string>
+  }
+
+  const toModelElement = (doc: LangiumDocument) => {
+    return ({
+      tags,
+      links,
+      style: {
+        color,
+        shape,
+        icon,
+        opacity,
+        border
+      },
+      id,
+      kind,
+      title,
+      description,
+      technology
+    }: ParsedAstElement): c4.Element | null => {
+      try {
+        const __kind = c4Specification.kinds[kind]
+        if (!__kind) {
+          logger.warn(`No kind '${kind}' found for ${id}`)
+          return null
+        }
+        color ??= __kind.color
+        shape ??= __kind.shape
+        icon ??= __kind.icon
+        opacity ??= __kind.opacity
+        border ??= __kind.border
+        return {
+          ...(color && { color }),
+          ...(shape && { shape }),
+          ...(icon && { icon }),
+          style: {
+            ...(border && { border }),
+            ...(opacity && { opacity })
+          },
+          links: links ? resolveLinks(doc, links) : null,
+          tags: tags ?? null,
+          technology: technology ?? null,
+          description: description ?? null,
+          title,
+          kind,
+          id
+        }
+      } catch (e) {
+        logWarnError(e)
+      }
+      return null
+    }
+  }
+
+  const elements = pipe(
+    docs,
+    flatMap(d => d.c4Elements.map(toModelElement(d))),
+    filter(isTruthy),
+    sort(compareByFqnHierarchically),
+    reduce(
+      (acc, el) => {
+        const parent = parentFqn(el.id)
+        if (parent && isNullish(acc[parent])) {
+          logWarnError(`No parent found for ${el.id}`)
+          return acc
+        }
+        if (el.id in acc) {
+          // should not happen, as validated
+          logWarnError(`Duplicate element id: ${el.id}`)
+          return acc
+        }
+        acc[el.id] = el
+        return acc
+      },
+      {} as c4.LikeC4Model['elements']
+    )
+  )
+
+  const toModelRelation = (doc: LangiumDocument) => {
+    return ({
+      astPath,
+      source,
+      target,
+      kind,
+      links,
+      id,
+      ...model
+    }: ParsedAstRelation): c4.Relation | null => {
+      if (isNullish(elements[source]) || isNullish(elements[target])) {
+        return null
+      }
+
+      if (!!kind && kind in c4Specification.relationships) {
+        return {
+          ...(links && { links: resolveLinks(doc, links) }),
+          ...c4Specification.relationships[kind],
+          ...model,
+          source,
+          target,
+          kind,
+          id
+        }
+      }
+      return {
+        ...(links && { links: resolveLinks(doc, links) }),
+        ...model,
+        source,
+        target,
+        id
+      }
+    }
+  }
+
+  const relations = pipe(
+    flatMap(docs, d => map(d.c4Relations, toModelRelation(d))),
+    filter(isTruthy),
+    mapToObj(r => [r.id, r])
+  )
+
+  // const toElementView = (view: ParsedAstElementView, doc: LangiumDocument): c4.ElementView => {
+  //   let { astPath, rules, title, description, tags, links, id, __, ...model } = view
+
+  //   if ('viewOf' in view) {
+  //     title ??= elements[view.viewOf]?.title ?? null
+  //   }
+  //   if (!title && view.id === 'index') {
+  //     title = 'Landscape view'
+  //   }
+  //   return {
+  //     __,
+  //     id,
+  //     ...model,
+  //     title,
+  //     description,
+  //     tags,
+  //     links: links ? resolveLinks(doc, links) : null,
+  //     docUri: '',
+  //     rules
+  //   }
+  // }
+
+  // const toDynamicView = (view: ParsedAstDynamicView, doc: LangiumDocument): c4.DynamicView => {
+  //   let { rules, steps, title, description, tags, links, id, __ } = view
+  //   return {
+  //     __,
+  //     id,
+  //     title,
+  //     description,
+  //     tags,
+  //     links: links ? resolveLinks(doc, links) : null,
+  //     docUri: '',
+  //     rules,
+  //     steps
+  //   }
+  // }
+
+  const toC4View = (doc: LangiumDocument) => {
+    const docUri = doc.uri.toString()
+    return (parsedAstView: ParsedAstView): c4.View => {
+      let {
+        id,
+        title,
+        description,
+        tags,
+        links,
+
+        // ignore this property
+        astPath: _ignore,
+
+        // model should include discriminant __
+        ...model
+      } = parsedAstView
+
+      if (parsedAstView.__ === 'element' && isNullish(title) && 'viewOf' in parsedAstView) {
+        title ??= elements[parsedAstView.viewOf]?.title ?? null
+      }
+
+      if (isNullish(title) && id === 'index') {
+        title = 'Landscape view'
+      }
+
+      return {
+        id,
+        title,
+        description,
+        tags,
+        links: links ? resolveLinks(doc, links) : null,
+        docUri,
+        ...model
+      }
+    }
+  }
+
+  const views = pipe(
+    docs,
+    flatMap(d => map(d.c4Views, toC4View(d))),
+    resolveRelativePaths,
+    mapToObj(v => [v.id, v]),
+    resolveRulesExtendedViews
+  )
+  // add index view if not present
+  if (!('index' in views)) {
+    views['index' as ViewID] = {
+      __: 'element',
+      id: 'index' as ViewID,
+      title: 'Landscape',
+      description: null,
+      tags: null,
+      links: null,
+      rules: [
+        {
+          include: [
+            {
+              wildcard: true
+            }
+          ]
+        }
+      ]
+    }
+  }
+
+  return {
+    elements,
+    relations,
+    views
+  }
+}
+
+const RAW_MODEL_CACHE = 'LikeC4RawModel'
+const MODEL_CACHE = 'LikeC4Model'
+
+type ModelParsedListener = (docs: URI[]) => void
+
+export class LikeC4ModelBuilder {
+  private langiumDocuments: LangiumDocuments
+  private listeners: ModelParsedListener[] = []
+
+  constructor(private services: LikeC4Services) {
+    this.langiumDocuments = services.shared.workspace.LangiumDocuments
+    const parser = services.likec4.ModelParser
+
+    services.shared.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {
+      if (deleted.length > 0) {
+        this.notifyListeners(deleted)
+      }
+    })
+
+    services.shared.workspace.DocumentBuilder.onBuildPhase(
+      DocumentState.Validated,
+      async (docs, _cancelToken) => {
+        let parsed = [] as URI[]
+        logger.debug(`[ModelBuilder] onValidated (${docs.length} docs)\n${printDocs(docs)}`)
+        for (const doc of parser.parse(docs)) {
+          parsed.push(doc.uri)
+        }
+        if (parsed.length > 0) {
+          this.notifyListeners(parsed)
+        }
+        return await Promise.resolve()
+      }
+    )
+    logger.debug(`[ModelBuilder] Created`)
+  }
+
+  public async buildModel(cancelToken?: CancellationToken): Promise<c4.LikeC4Model | null> {
+    return await this.services.shared.workspace.WorkspaceLock.read(async () => {
+      if (cancelToken) {
+        await interruptAndCheck(cancelToken)
+      }
+      const cache = this.services.WorkspaceCache as WorkspaceCache<string, c4.LikeC4Model | null>
+      return cache.get(RAW_MODEL_CACHE, () => {
+        const docs = this.documents()
+        if (docs.length === 0) {
+          logger.debug('[ModelBuilder] No documents to build model from')
+          return null
+        }
+        logger.debug(`[ModelBuilder] buildModel from ${docs.length} docs:\n${printDocs(docs)}`)
+        return buildModel(this.services, docs)
+      })
+    })
+  }
+
+  private previousViews: Record<ViewID, c4.ComputedView> = {}
+
+  public async buildComputedModel(cancelToken?: CancellationToken): Promise<c4.LikeC4ComputedModel | null> {
+    const model = await this.buildModel(cancelToken)
+    if (!model) {
+      return null
+    }
+    return await this.services.shared.workspace.WorkspaceLock.read(async () => {
+      if (cancelToken) {
+        await interruptAndCheck(cancelToken)
+      }
+      const cache = this.services.WorkspaceCache as WorkspaceCache<string, c4.LikeC4ComputedModel | null>
+      const viewsCache = this.services.WorkspaceCache as WorkspaceCache<string, c4.ComputedView | null>
+      return cache.get(MODEL_CACHE, () => {
+        const index = new LikeC4ModelGraph(model)
+
+        const allViews = [] as c4.ComputedView[]
+        for (const view of values(model.views)) {
+          const result = isElementView(view) ? computeView(view, index) : computeDynamicView(view, index)
+          if (!result.isSuccess) {
+            logWarnError(result.error)
+            continue
+          }
+          allViews.push(result.view)
+        }
+        assignNavigateTo(allViews)
+        const views = mapToObj(allViews, v => {
+          const previous = this.previousViews[v.id]
+          const view = previous && eq(v, previous) ? previous : v
+          viewsCache.set(computedViewKey(v.id), view)
+          return [v.id, view] as const
+        })
+        this.previousViews = { ...views }
+        return {
+          elements: model.elements,
+          relations: model.relations,
+          views
+        }
+      })
+    })
+  }
+
+  public async computeView(viewId: ViewID, cancelToken?: CancellationToken): Promise<c4.ComputedView | null> {
+    const model = await this.buildModel(cancelToken)
+    const view = model?.views[viewId]
+    if (!view) {
+      logger.warn(`[ModelBuilder] Cannot find view ${viewId}`)
+      return null
+    }
+    return await this.services.shared.workspace.WorkspaceLock.read(async () => {
+      if (cancelToken) {
+        await interruptAndCheck(cancelToken)
+      }
+      const cache = this.services.WorkspaceCache as WorkspaceCache<string, c4.ComputedView | null>
+      return cache.get(computedViewKey(viewId), () => {
+        const index = new LikeC4ModelGraph(model)
+        const result = isElementView(view) ? computeView(view, index) : computeDynamicView(view, index)
+        if (!result.isSuccess) {
+          logError(result.error)
+          return null
+        }
+
+        const allElementViews = values(model.views).filter(
+          (v): v is StrictElementView => isStrictElementView(v) && v.id !== viewId
+        )
+
+        let computedView = result.view
+        computedView.nodes.forEach(node => {
+          if (!node.navigateTo) {
+            // find first element view that is not the current one
+            const navigateTo = find(allElementViews, v => v.viewOf === node.id)
+            if (navigateTo) {
+              node.navigateTo = navigateTo.id
+            }
+          }
+        })
+
+        const previous = this.previousViews[viewId]
+        computedView = previous && eq(computedView, previous) ? previous : computedView
+        this.previousViews[viewId] = computedView
+
+        return computedView
+      })
+    })
+  }
+
+  public onModelParsed(callback: ModelParsedListener): Disposable {
+    this.listeners.push(callback)
+    return Disposable.create(() => {
+      const index = this.listeners.indexOf(callback)
+      if (index >= 0) {
+        this.listeners.splice(index, 1)
+      }
+    })
+  }
+
+  private documents() {
+    return this.langiumDocuments.all.filter(isParsedLikeC4LangiumDocument).toArray()
+  }
+
+  private notifyListeners(docs: URI[]) {
+    for (const listener of this.listeners) {
+      try {
+        listener(docs)
+      } catch (e) {
+        logError(e)
+      }
+    }
+  }
+}
+function computedViewKey(viewId: string): string {
+  return `computed-view-${viewId}`
+}