@likec4/language-server 1.23.1 → 1.24.1

package/dist/model/fqn-index.js

@@ -1,103 +1,210 @@
-import { nameFromFqn, parentFqn } from "@likec4/core";
-import { DocumentState, DONE_RESULT, MultiMap, stream, StreamImpl } from "langium";
-import { ElementOps, isFqnIndexedDocument, isLikeC4LangiumDocument } from "../ast.js";
-import { logger, logWarnError } from "../logger.js";
+import { invariant, nonNullable } from "@likec4/core";
+import { AsFqn } from "@likec4/core/types";
+import { ancestorsFqn, compareNatural, DefaultWeakMap, MultiMap, sortNaturalByFqn } from "@likec4/core/utils";
+import {
+  AstUtils,
+  DocumentState,
+  stream,
+  WorkspaceCache
+} from "langium";
+import { isDefined, isEmpty, isTruthy } from "remeda";
+import {
+  ast,
+  ElementOps,
+  isLikeC4LangiumDocument
+} from "../ast.js";
+import { logWarnError } from "../logger.js";
 import { ADisposable } from "../utils/index.js";
-import { computeDocumentFqn } from "./fqn-computation.js";
+import { readStrictFqn } from "../utils/elementRef.js";
 export class FqnIndex extends ADisposable {
-  constructor(services) {
+  constructor(services, cachePrefix = "fqn-index") {
     super();
     this.services = services;
+    this.cachePrefix = cachePrefix;
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+    this.documentCache = new DefaultWeakMap((doc) => this.createDocumentIndex(doc));
+    this.workspaceCache = new WorkspaceCache(services.shared, DocumentState.IndexedContent);
     this.onDispose(
-      services.shared.workspace.DocumentBuilder.onBuildPhase(
+      services.shared.workspace.DocumentBuilder.onDocumentPhase(
         DocumentState.IndexedContent,
-        async (docs, _cancelToken) => {
-          for (const doc of docs) {
-            if (isLikeC4LangiumDocument(doc)) {
-              delete doc.c4fqnIndex;
-              delete doc.c4Elements;
-              delete doc.c4Specification;
-              delete doc.c4Relations;
-              delete doc.c4Deployments;
-              delete doc.c4DeploymentRelations;
-              delete doc.c4Globals;
-              delete doc.c4Views;
-              try {
-                computeDocumentFqn(doc, services);
-              } catch (e) {
-                logWarnError(e);
-              }
-            }
+        async (doc, _cancelToken) => {
+          if (isLikeC4LangiumDocument(doc)) {
+            this.documentCache.set(doc, this.createDocumentIndex(doc));
           }
           return await Promise.resolve();
         }
       )
     );
-    logger.debug(`[FqnIndex] Created`);
   }
   langiumDocuments;
-  get documents() {
-    return this.langiumDocuments.all.filter(isFqnIndexedDocument);
+  documentCache;
+  workspaceCache;
+  documents() {
+    return this.langiumDocuments.all.filter(
+      (d) => isLikeC4LangiumDocument(d) && d.state >= DocumentState.IndexedContent
+    );
   }
-  entries(filterByFqn) {
-    return this.documents.flatMap((doc) => {
-      return doc.c4fqnIndex.keys().filter(filterByFqn).flatMap((fqn) => doc.c4fqnIndex.get(fqn));
-    });
+  get(document) {
+    if (document.state < DocumentState.IndexedContent) {
+      logWarnError(`Document ${document.uri.path} is not indexed`);
+    }
+    return this.documentCache.get(document);
   }
   getFqn(el) {
-    return ElementOps.readId(el) ?? null;
+    invariant(ast.isElement(el) || ast.isDeploymentElement(el));
+    let id = ElementOps.readId(el);
+    if (isTruthy(id)) {
+      return id;
+    }
+    const doc = AstUtils.getDocument(el);
+    invariant(isLikeC4LangiumDocument(doc));
+    logWarnError(`Document ${doc.uri.path} is not indexed, but getFqn was called`);
+    this.get(doc);
+    return nonNullable(ElementOps.readId(el), "Element fqn must be set, invalid state");
   }
   byFqn(fqn) {
-    return this.documents.flatMap((doc) => {
-      return doc.c4fqnIndex.get(fqn);
-    });
+    return stream(this.workspaceCache.get(`${this.cachePrefix}:${fqn}`, () => {
+      return this.documents().toArray().flatMap((doc) => {
+        return this.get(doc).byFqn(fqn);
+      });
+    }));
   }
   directChildrenOf(parent) {
-    return stream([parent]).flatMap((_parent) => {
-      const children = this.entries((fqn) => parentFqn(fqn) === _parent).map((entry) => [entry.name, entry]).toArray();
-      if (children.length === 0) {
-        return [];
-      }
-      return new MultiMap(children).entriesGroupedByKey().flatMap(([_name, descrs]) => descrs.length === 1 ? descrs : []).iterator();
-    });
+    return stream(
+      this.workspaceCache.get(`${this.cachePrefix}:directChildrenOf:${parent}`, () => {
+        const allchildren = this.documents().reduce((map, doc) => {
+          this.get(doc).children(parent).forEach((desc) => {
+            map.set(desc.name, desc);
+          });
+          return map;
+        }, new MultiMap());
+        return uniqueByName(allchildren).sort((a, b) => compareNatural(a.name, b.name));
+      })
+    );
   }
   /**
    * Returns descedant elements with unique names in the scope
    */
   uniqueDescedants(parent) {
-    return new StreamImpl(
-      () => {
-        const prefix = `${parent}.`;
-        const childrenNames = /* @__PURE__ */ new Set();
-        const descedants = [];
-        const nested = new MultiMap();
-        this.entries((f) => f.startsWith(prefix)).forEach((e) => {
-          const name = nameFromFqn(e.fqn);
-          const entry = { ...e, name };
-          if (parentFqn(e.fqn) === parent) {
-            childrenNames.add(name);
-            nested.add(name, entry);
-          } else {
-            descedants.push(entry);
-          }
+    return stream(
+      this.workspaceCache.get(`${this.cachePrefix}:uniqueDescedants:${parent}`, () => {
+        const { children, descendants } = this.documents().reduce((map, doc) => {
+          const docIndex = this.get(doc);
+          docIndex.children(parent).forEach((desc) => {
+            map.children.set(desc.name, desc);
+          });
+          docIndex.descendants(parent).forEach((desc) => {
+            map.descendants.set(desc.name, desc);
+          });
+          return map;
+        }, {
+          children: new MultiMap(),
+          descendants: new MultiMap()
         });
-        if (nested.size + descedants.length === 0) {
-          return null;
+        const uniqueChildren = uniqueByName(children).sort((a, b) => compareNatural(a.name, b.name));
+        const uniqueDescendants = [...descendants.associations()].flatMap(([_name, descs]) => descs.length === 1 && !children.has(_name) ? descs : []);
+        return [
+          ...uniqueChildren,
+          ...sortNaturalByFqn(uniqueDescendants)
+        ];
+      })
+    );
+  }
+  createDocumentIndex(document) {
+    const rootElements = document.parseResult.value.models.flatMap((m) => m.elements);
+    if (rootElements.length === 0) {
+      return DocumentFqnIndex.EMPTY;
+    }
+    const root = new Array();
+    const children = new MultiMap();
+    const descendants = new MultiMap();
+    const byfqn = new MultiMap();
+    const Descriptions = this.services.workspace.AstNodeDescriptionProvider;
+    const createAndSaveDescription = (node, name, fqn) => {
+      const desc = {
+        ...Descriptions.createDescription(node, name, document),
+        id: fqn
+      };
+      ElementOps.writeId(node, fqn);
+      byfqn.set(fqn, desc);
+      return desc;
+    };
+    const traverseNode = (el, parentFqn) => {
+      let thisFqn;
+      if (ast.isElement(el)) {
+        thisFqn = AsFqn(el.name, parentFqn);
+        const desc = createAndSaveDescription(el, el.name, thisFqn);
+        if (!parentFqn) {
+          root.push(desc);
+        } else {
+          children.set(parentFqn, desc);
         }
-        for (const descedant of descedants) {
-          if (!childrenNames.has(descedant.name)) {
-            nested.add(descedant.name, descedant);
+      } else {
+        thisFqn = readStrictFqn(el.element);
+      }
+      let _nested = [];
+      if (isDefined(el.body) && !isEmpty(el.body.elements)) {
+        for (const child of el.body.elements) {
+          if (!ast.isRelation(child)) {
+            try {
+              _nested.push(...traverseNode(child, thisFqn));
+            } catch (e) {
+              logWarnError(e);
+            }
           }
         }
-        return nested.entriesGroupedByKey().flatMap(([_name, descrs]) => descrs.length === 1 ? descrs : []).iterator();
-      },
-      (iterator) => {
-        if (iterator) {
-          return iterator.next();
+      }
+      const directChildren = children.get(thisFqn) ?? [];
+      _nested = [
+        ...directChildren,
+        ..._nested
+      ];
+      for (const child of _nested) {
+        descendants.set(thisFqn, child);
+      }
+      if (ast.isExtendElement(el)) {
+        for (const ancestor of ancestorsFqn(thisFqn)) {
+          for (const child of _nested) {
+            descendants.set(ancestor, child);
+          }
         }
-        return DONE_RESULT;
       }
-    );
+      return descendants.get(thisFqn) ?? [];
+    };
+    for (const node of rootElements) {
+      try {
+        if (ast.isRelation(node)) {
+          continue;
+        }
+        traverseNode(node, null);
+      } catch (e) {
+        logWarnError(e);
+      }
+    }
+    return new DocumentFqnIndex(root, children, descendants, byfqn);
+  }
+}
+function uniqueByName(multimap) {
+  return [...multimap.associations()].flatMap(([_name, descs]) => descs.length === 1 ? descs : []);
+}
+export class DocumentFqnIndex {
+  constructor(_rootElements, _children, _descendants, _byfqn) {
+    this._rootElements = _rootElements;
+    this._children = _children;
+    this._descendants = _descendants;
+    this._byfqn = _byfqn;
+  }
+  static EMPTY = new DocumentFqnIndex([], new MultiMap(), new MultiMap(), new MultiMap());
+  rootElements() {
+    return this._rootElements;
+  }
+  byFqn(fqn) {
+    return this._byfqn.get(fqn) ?? [];
+  }
+  children(parent) {
+    return this._children.get(parent) ?? [];
+  }
+  descendants(nodeName) {
+    return this._descendants.get(nodeName) ?? [];
   }
 }

package/dist/model/index.d.ts

@@ -1,5 +1,4 @@
 export * from './deployments-index';
-export * from './fqn-computation';
 export * from './fqn-index';
 export * from './model-builder';
 export * from './model-locator';

package/dist/model/index.js

@@ -1,5 +1,4 @@
 export * from "./deployments-index.js";
-export * from "./fqn-computation.js";
 export * from "./fqn-index.js";
 export * from "./model-builder.js";
 export * from "./model-locator.js";

package/dist/model/model-builder.d.ts

@@ -1,30 +1,31 @@
 import type * as c4 from '@likec4/core';
-import { type ViewId } from '@likec4/core';
-import type { Cancellation, URI } from 'langium';
-import { Disposable } from 'langium';
+import { type ViewId, LikeC4Model } from '@likec4/core';
+import { type Cancellation, type URI, Disposable } from 'langium';
 import type { LikeC4Services } from '../module';
 import { ADisposable } from '../utils';
 type ModelParsedListener = (docs: URI[]) => void;
 export declare class LikeC4ModelBuilder extends ADisposable {
-    private services;
-    private langiumDocuments;
+    private parser;
     private listeners;
+    private cache;
+    private DocumentBuilder;
+    private LangiumDocuments;
     constructor(services: LikeC4Services);
     /**
      * WARNING:
      * This method is internal and should to be called only when all documents are known to be parsed.
      * Otherwise, the model may be incomplete.
      */
-    unsafeSyncBuildModel(): c4.ParsedLikeC4Model | null;
-    buildModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ParsedLikeC4Model | null>;
+    private unsafeSyncParseModel;
+    parseModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ParsedLikeC4Model | null>;
     private previousViews;
     /**
      * WARNING:
      * This method is internal and should to be called only when all documents are known to be parsed.
      * Otherwise, the model may be incomplete.
      */
-    unsafeSyncBuildComputedModel(model: c4.ParsedLikeC4Model): c4.ComputedLikeC4Model;
-    buildComputedModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ComputedLikeC4Model | null>;
+    unsafeSyncBuildModel(): LikeC4Model.Computed;
+    buildLikeC4Model(cancelToken?: Cancellation.CancellationToken): Promise<LikeC4Model.Computed>;
     computeView(viewId: ViewId, cancelToken?: Cancellation.CancellationToken): Promise<c4.ComputedView | null>;
     onModelParsed(callback: ModelParsedListener): Disposable;
     private documents;