@likec4/language-server 0.45.0 → 0.46.0

package/dist/lsp/DocumentSymbolProvider.js

@@ -44,12 +44,15 @@ export class LikeC4DocumentSymbolProvider {
   constructor(services) {
     this.services = services;
   }
-  getSymbols(document) {
-    const { specification, model, views } = document.parseResult.value;
+  getSymbols({
+    parseResult: {
+      value: { specifications, models, views }
+    }
+  }) {
     return [
-      () => specification && this.getSpecSymbol(specification),
-      () => model && this.getModelSymbol(model),
-      () => views && this.getModelViewsSymbol(views)
+      ...specifications.map((s) => () => this.getSpecSymbol(s)),
+      ...models.map((s) => () => this.getModelSymbol(s)),
+      ...views.map((s) => () => this.getModelViewsSymbol(s))
     ].flatMap((fn) => {
       try {
         return fn() ?? [];

package/dist/lsp/SemanticTokenProvider.js

@@ -1,38 +1,21 @@
 import { AbstractSemanticTokenProvider } from "langium";
 import { SemanticTokenModifiers, SemanticTokenTypes } from "vscode-languageserver-protocol";
 import { ast } from "../ast.js";
-import { isElementRefHead } from "../elementRef.js";
 export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
   highlightElement(node, acceptor) {
-    const keyword = (keyword2, _index) => acceptor({
-      node,
-      keyword: keyword2,
-      type: SemanticTokenTypes.keyword,
-      modifier: [SemanticTokenModifiers.defaultLibrary]
-    });
-    if ("arr" in node) {
-      acceptor({
-        node,
-        property: "arr",
-        type: SemanticTokenTypes.keyword,
-        modifier: [SemanticTokenModifiers.defaultLibrary]
-      });
-    }
     if (ast.isRelation(node) && "kind" in node) {
-      keyword("-[");
       acceptor({
         node,
         property: "kind",
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
       });
-      keyword("]->");
     }
-    if (ast.isElementRef(node) || ast.isStrictElementRef(node)) {
+    if (ast.isElementRef(node) || ast.isFqnElementRef(node)) {
       acceptor({
         node,
         property: "el",
-        type: isElementRefHead(node) ? SemanticTokenTypes.variable : SemanticTokenTypes.property
+        type: node.parent ? SemanticTokenTypes.property : SemanticTokenTypes.variable
       });
     }
     if (ast.isElementViewRef(node)) {
@@ -42,6 +25,13 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.variable
       });
     }
+    if (ast.isElementRefExpression(node) && node.isDescedants) {
+      acceptor({
+        node,
+        keyword: ".*",
+        type: SemanticTokenTypes.variable
+      });
+    }
     if (ast.isWildcardExpression(node)) {
       acceptor({
         node,
@@ -49,40 +39,26 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.variable
       });
     }
-    if (ast.isElementKindExpression(node) || ast.isElementTagExpression(node)) {
-      keyword("element");
-      if (ast.isElementKindExpression(node)) {
-        keyword("kind");
-        acceptor({
-          node,
-          property: "kind",
-          type: SemanticTokenTypes.type,
-          modifier: [SemanticTokenModifiers.definition]
-        });
-      }
-      if (ast.isElementTagExpression(node)) {
-        keyword("tag");
-        acceptor({
-          node,
-          property: "tag",
-          type: SemanticTokenTypes.type,
-          modifier: [SemanticTokenModifiers.definition]
-        });
-      }
-    }
-    if (ast.isRelation(node)) {
-      if ("title" in node) {
-        acceptor({
-          node,
-          property: "title",
-          type: SemanticTokenTypes.string
-        });
-      }
-    }
-    if (ast.isElementKind(node)) {
+    if (ast.isElementKindExpression(node)) {
       acceptor({
         node,
-        property: "name",
+        property: "kind",
+        type: SemanticTokenTypes.type,
+        modifier: [SemanticTokenModifiers.definition]
+      });
+    }
+    if (ast.isElementTagExpression(node)) {
+      acceptor({
+        node,
+        property: "tag",
+        type: SemanticTokenTypes.type,
+        modifier: [SemanticTokenModifiers.definition]
+      });
+    }
+    if (ast.isSpecificationElementKind(node)) {
+      acceptor({
+        node,
+        property: "kind",
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
       });
@@ -103,20 +79,15 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         modifier: [SemanticTokenModifiers.definition]
       });
     }
-    if (ast.isRelationshipKind(node)) {
+    if (ast.isSpecificationRelationshipKind(node)) {
       acceptor({
         node,
-        property: "name",
+        property: "kind",
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
       });
     }
     if (ast.isColorProperty(node) || ast.isShapeProperty(node) || ast.isArrowProperty(node) || ast.isLineProperty(node)) {
-      acceptor({
-        node,
-        property: "key",
-        type: SemanticTokenTypes.keyword
-      });
       acceptor({
         node,
         property: "value",
@@ -124,11 +95,6 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       });
     }
     if (ast.isLinkProperty(node) || ast.isIconProperty(node)) {
-      acceptor({
-        node,
-        property: "key",
-        type: SemanticTokenTypes.keyword
-      });
       acceptor({
         node,
         property: "value",

package/dist/model/fqn-computation.js

@@ -2,15 +2,15 @@ import { AsFqn, nonexhaustive } from "@likec4/core";
 import { MultiMap } from "langium";
 import { isEmpty, isNil } from "remeda";
 import { ElementOps, ast } from "../ast.js";
-import { fqnElementRef } from "../elementRef.js";
+import { getFqnElementRef } from "../elementRef.js";
 export function computeDocumentFqn(document, services) {
   const c4fqns = document.c4fqns = new MultiMap();
-  const { model } = document.parseResult.value;
-  if (!model?.elements) {
+  const elements = document.parseResult.value.models.flatMap((m) => m.elements);
+  if (elements.length === 0) {
     return;
   }
   const locator = services.workspace.AstNodeLocator;
-  const traverseStack = model.elements.map((el) => [el, null]);
+  const traverseStack = elements.map((el) => [el, null]);
   let pair;
   while (pair = traverseStack.shift()) {
     const [el, parent] = pair;
@@ -19,7 +19,7 @@ export function computeDocumentFqn(document, services) {
     }
     if (ast.isExtendElement(el)) {
       if (!isNil(el.body) && !isEmpty(el.body.elements)) {
-        const fqn = fqnElementRef(el.element);
+        const fqn = getFqnElementRef(el.element);
         el.body.elements.forEach((child) => traverseStack.push([child, fqn]));
       }
       continue;

package/dist/model/fqn-index.d.ts

@@ -15,9 +15,10 @@ export interface FqnIndexEntry {
     path: string;
 }
 export declare class FqnIndex {
+    private services;
     protected langiumDocuments: LangiumDocuments;
     constructor(services: LikeC4Services);
-    private documents;
+    get documents(): Stream<FqnIndexedDocument>;
     private entries;
     getFqn(el: ast.Element): Fqn | null;
     byFqn(fqn: Fqn): Stream<FqnIndexEntry>;

package/dist/model/fqn-index.js

@@ -1,5 +1,5 @@
 import { nameFromFqn, parentFqn } from "@likec4/core";
-import { DONE_RESULT, DocumentState, MultiMap, StreamImpl, stream } from "langium";
+import { DONE_RESULT, DocumentState, MultiMap, StreamImpl, getDocument, stream } from "langium";
 import { isNil } from "remeda";
 import { ElementOps, isLikeC4LangiumDocument } from "../ast.js";
 import { logError, logger } from "../logger.js";
@@ -9,40 +9,21 @@ export function isFqnIndexedDocument(doc) {
   return isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.IndexedContent && !isNil(doc.c4fqns);
 }
 export class FqnIndex {
-  langiumDocuments;
   constructor(services) {
+    this.services = services;
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-    services.shared.workspace.DocumentBuilder.onUpdate((changed, deleted) => {
-      const message = [`[FqnIndex] onUpdate`];
-      if (changed.length > 0) {
-        message.push(` changed:`);
-        changed.forEach((u) => message.push(`  - ${u}`));
-      }
-      if (deleted.length > 0) {
-        message.push(` deleted:`);
-        deleted.forEach((u) => message.push(`  - ${u}`));
-      }
-      logger.debug(message.join("\n"));
-      for (const uri of changed) {
-        if (this.langiumDocuments.hasDocument(uri)) {
-          const doc = this.langiumDocuments.getOrCreateDocument(uri);
-          if (isLikeC4LangiumDocument(doc)) {
-            delete doc.c4fqns;
-            delete doc.c4Elements;
-            delete doc.c4Specification;
-            delete doc.c4Relations;
-            delete doc.c4Views;
-          }
-        }
-      }
-    });
     services.shared.workspace.DocumentBuilder.onBuildPhase(
       DocumentState.IndexedContent,
-      (docs, _cancelToken) => {
+      async (docs, _cancelToken) => {
         logger.debug(`[FqnIndex] onIndexedContent ${docs.length}:
 ` + 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) {
@@ -50,14 +31,17 @@ export class FqnIndex {
             }
           }
         }
+        return Promise.resolve();
       }
     );
+    logger.debug(`[FqnIndex] Created`);
   }
-  documents() {
+  langiumDocuments;
+  get documents() {
     return this.langiumDocuments.all.filter(isFqnIndexedDocument);
   }
   entries(filterByFqn = () => true) {
-    return this.documents().flatMap(
+    return this.documents.flatMap(
       (doc) => doc.c4fqns.entries().filter(([fqn]) => filterByFqn(fqn)).map(([fqn, entry]) => {
         const el = entry.el.deref();
         if (el) {
@@ -68,10 +52,21 @@ export class FqnIndex {
     );
   }
   getFqn(el) {
-    return el.fqn ?? 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;
   }
   byFqn(fqn) {
-    return this.documents().flatMap((doc) => {
+    return this.documents.flatMap((doc) => {
       return doc.c4fqns.get(fqn).flatMap((entry) => {
         const el = entry.el.deref();
         if (el) {

package/dist/model/model-builder.js

@@ -4,10 +4,7 @@ import {
   parentFqn
 } from "@likec4/core";
 import { LikeC4ModelGraph, computeView } from "@likec4/graph";
-import {
-  DocumentState,
-  interruptAndCheck
-} from "langium";
+import { DocumentState } from "langium";
 import * as R from "remeda";
 import { Disposable } from "vscode-languageserver";
 import { isValidLikeC4LangiumDocument } from "../ast.js";
@@ -161,16 +158,24 @@ export class LikeC4ModelBuilder {
     this.services = services;
     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) => {
+      async (docs, _cancelToken) => {
+        logger.debug(`[ModelBuilder] onValidated (${docs.length} docs)
+${printDocs(docs)}`);
         const parsed = parser.parse(docs).map((d) => d.uri);
-        await interruptAndCheck(cancelToken);
         if (parsed.length > 0) {
           this.notifyListeners(parsed);
         }
+        return Promise.resolve();
       }
     );
+    logger.debug(`[ModelBuilder] Created`);
   }
   langiumDocuments;
   listeners = [];
@@ -200,11 +205,15 @@ ${printDocs(docs)}`);
         return null;
       }
       const index = new LikeC4ModelGraph(model);
-      const views = R.pipe(
-        R.values(model.views),
-        R.map((view) => computeView(view, index).view),
-        R.compact
-      );
+      const views = [];
+      for (const view of R.values(model.views)) {
+        const result = computeView(view, index);
+        if (!result.isSuccess) {
+          logWarnError(result.error);
+          continue;
+        }
+        views.push(result.view);
+      }
       assignNavigateTo(views);
       return {
         elements: model.elements,

package/dist/model/model-locator.js

@@ -1,5 +1,4 @@
-import { InvalidModelError } from "@likec4/core";
-import { findNodeForProperty, getDocument } from "langium";
+import { findNodeForKeyword, findNodeForProperty, getDocument } from "langium";
 import { ast, isParsedLikeC4LangiumDocument } from "../ast.js";
 export class LikeC4ModelLocator {
   constructor(services) {
@@ -61,20 +60,14 @@ export class LikeC4ModelLocator {
           };
         }
       }
-      if (node.arr == null) {
-        throw new InvalidModelError("Relation.arr is not defined, but should be");
-      }
-      const targetNode = findNodeForProperty(node.$cstNode, "arr");
-      if (!targetNode) {
-        return null;
-      }
-      return {
+      const targetNode = (node.kind ? findNodeForProperty(node.$cstNode, "kind") : findNodeForKeyword(node.$cstNode, "->")) ?? findNodeForProperty(node.$cstNode, "target");
+      return targetNode ? {
         uri: doc.uri.toString(),
         range: {
           start: targetNode.range.start,
           end: targetNode.range.end
         }
-      };
+      } : null;
     }
     return null;
   }

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

@@ -1,6 +1,6 @@
 import { type c4 } from '@likec4/core';
 import type { LangiumDocument } from 'langium';
-import type { LikeC4LangiumDocument } from '../ast';
+import type { LikeC4LangiumDocument, ParsedLikeC4LangiumDocument } from '../ast';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export type ModelParsedListener = () => void;
@@ -8,10 +8,13 @@ export declare class LikeC4ModelParser {
     private services;
     private fqnIndex;
     constructor(services: LikeC4Services);
-    parse(doc: LangiumDocument | LangiumDocument[]): LikeC4LangiumDocument[];
-    protected parseLikeC4Document(doc: LikeC4LangiumDocument): void;
+    parse(doc: LangiumDocument | LangiumDocument[]): ParsedLikeC4LangiumDocument[];
+    protected parseLikeC4Document(_doc: LikeC4LangiumDocument): ParsedLikeC4LangiumDocument;
+    private parseSpecification;
+    private parseModel;
     private parseElement;
     private parseRelation;
+    private parseViews;
     private parseElementExpression;
     private parseExpression;
     private parseViewRule;

package/dist/model/model-parser.js

@@ -14,44 +14,47 @@ import {
   toElementStyleExcludeDefaults,
   toRelationshipStyleExcludeDefaults
 } from "../ast.js";
-import { elementRef, fqnElementRef } from "../elementRef.js";
+import { elementRef, getFqnElementRef } from "../elementRef.js";
 import { logError, logWarnError, logger } from "../logger.js";
-import { printDocs } from "../utils.js";
 export class LikeC4ModelParser {
   constructor(services) {
     this.services = services;
     this.fqnIndex = services.likec4.FqnIndex;
+    logger.debug(`[ModelParser] Created`);
   }
   fqnIndex;
   parse(doc) {
     const docs = Array.isArray(doc) ? doc : [doc];
-    logger.debug(`[ModelParser] onValidated (${docs.length} docs)
-${printDocs(docs)}`);
     const result = [];
     for (const doc2 of docs) {
       if (!isLikeC4LangiumDocument(doc2)) {
         continue;
       }
       try {
-        this.parseLikeC4Document(doc2);
-        result.push(doc2);
+        result.push(this.parseLikeC4Document(doc2));
       } catch (cause) {
         logError(new InvalidModelError(`Error parsing document ${doc2.uri.toString()}`, { cause }));
       }
     }
     return result;
   }
-  parseLikeC4Document(doc) {
-    const { elements, relations, views, specification } = cleanParsedModel(doc);
-    const specs = doc.parseResult.value.specification?.elements;
-    if (specs) {
-      for (const { kind, style } of specs) {
-        if (kind.name in specification.kinds) {
-          logger.warn(`Duplicate specification for kind ${kind.name}`);
+  parseLikeC4Document(_doc) {
+    const doc = cleanParsedModel(_doc);
+    this.parseSpecification(doc);
+    this.parseModel(doc);
+    this.parseViews(doc);
+    return doc;
+  }
+  parseSpecification({ parseResult, c4Specification }) {
+    const element_specs = parseResult.value.specifications.flatMap((s) => s.elements);
+    if (element_specs.length > 0) {
+      for (const { kind, style } of element_specs) {
+        if (kind.name in c4Specification.kinds) {
+          logger.warn(`Duplicate specification for element kind ${kind.name}`);
           continue;
         }
         try {
-          specification.kinds[kind.name] = toElementStyleExcludeDefaults(
+          c4Specification.kinds[kind.name] = toElementStyleExcludeDefaults(
             style?.props
           );
         } catch (e) {
@@ -59,24 +62,26 @@ ${printDocs(docs)}`);
         }
       }
     }
-    const relations_specs = doc.parseResult.value.specification?.relationships;
-    if (relations_specs) {
+    const relations_specs = parseResult.value.specifications.flatMap((s) => s.relationships);
+    if (relations_specs.length > 0) {
       for (const { kind, props } of relations_specs) {
-        if (kind.name in specification.relationships) {
-          logger.warn(`Duplicate specification for kind ${kind.name}`);
+        if (kind.name in c4Specification.relationships) {
+          logger.warn(`Duplicate specification for relationship kind ${kind.name}`);
           continue;
         }
         try {
-          specification.relationships[kind.name] = toRelationshipStyleExcludeDefaults(props);
+          c4Specification.relationships[kind.name] = toRelationshipStyleExcludeDefaults(props);
         } catch (e) {
           logWarnError(e);
         }
       }
     }
+  }
+  parseModel(doc) {
     for (const el of streamModel(doc)) {
       if (ast.isElement(el)) {
         try {
-          elements.push(this.parseElement(el));
+          doc.c4Elements.push(this.parseElement(el));
         } catch (e) {
           logWarnError(e);
         }
@@ -84,7 +89,7 @@ ${printDocs(docs)}`);
       }
       if (ast.isRelation(el)) {
         try {
-          relations.push(this.parseRelation(el));
+          doc.c4Relations.push(this.parseRelation(el));
         } catch (e) {
           logWarnError(e);
         }
@@ -92,18 +97,6 @@ ${printDocs(docs)}`);
       }
       nonexhaustive(el);
     }
-    const docviews = doc.parseResult.value.views?.views;
-    if (docviews) {
-      for (const view of docviews) {
-        try {
-          const v = this.parseElementView(view);
-          ElementViewOps.writeId(view, v.id);
-          views.push(v);
-        } catch (e) {
-          logWarnError(e);
-        }
-      }
-    }
   }
   parseElement(astNode) {
     const id = this.resolveFqn(astNode);
@@ -137,10 +130,10 @@ ${printDocs(docs)}`);
     const coupling = resolveRelationPoints(astNode);
     const target = this.resolveFqn(coupling.target);
     const source = this.resolveFqn(coupling.source);
-    const tags = this.convertTags(astNode.body);
+    const tags = this.convertTags(astNode);
     const kind = astNode.kind?.ref?.name;
     const astPath = this.getAstNodePath(astNode);
-    const title = astNode.title ?? astNode.body?.props.find((p) => p.key === "title")?.value ?? "";
+    const title = astNode.title ?? astNode.props.find((p) => p.key === "title")?.value ?? "";
     const id = objectHash({
       astPath,
       source,
@@ -156,6 +149,17 @@ ${printDocs(docs)}`);
       ...tags && { tags }
     };
   }
+  parseViews(doc) {
+    const views = doc.parseResult.value.views.flatMap((v) => v.views);
+    for (const view of views) {
+      try {
+        const v = this.parseElementView(view);
+        doc.c4Views.push(v);
+      } catch (e) {
+        logWarnError(e);
+      }
+    }
+  }
   parseElementExpression(astNode) {
     if (ast.isWildcardExpression(astNode)) {
       return {
@@ -275,6 +279,7 @@ ${printDocs(docs)}`);
         }
       })
     };
+    ElementViewOps.writeId(astNode, basic.id);
     if ("viewOf" in astNode) {
       const viewOfEl = elementRef(astNode.viewOf);
       const viewOf = viewOfEl && this.resolveFqn(viewOfEl);
@@ -296,7 +301,7 @@ ${printDocs(docs)}`);
   }
   resolveFqn(node) {
     if (ast.isExtendElement(node)) {
-      return fqnElementRef(node.element);
+      return getFqnElementRef(node.element);
     }
     const fqn = this.fqnIndex.getFqn(node);
     invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);

package/dist/module.js

@@ -16,6 +16,7 @@ import { Rpc } from "./Rpc.js";
 import { registerValidationChecks } from "./validation/index.js";
 import { logger } from "./logger.js";
 import { serializeError } from "@likec4/core";
+import { NodeKindProvider } from "./shared/NodeKindProvider.js";
 function bind(Type) {
   return (services) => new Type(services);
 }
@@ -41,6 +42,9 @@ export const LikeC4Module = {
   }
 };
 const LikeC4SharedModule = {
+  lsp: {
+    NodeKindProvider: () => new NodeKindProvider()
+  }
   // workspace: {
   //   WorkspaceManager: services => new LikeC4WorkspaceManager(services)
   // }

package/dist/protocol.d.ts

@@ -13,9 +13,6 @@ export declare const computeView: RequestType<{
 }, {
     view: ComputedView | null;
 }, void>;
-export declare const rebuild: RequestType0<{
-    docs: DocumentUri[];
-}, void>;
 interface BuildDocumentsParams {
     docs: DocumentUri[];
 }

package/dist/protocol.js

@@ -7,8 +7,5 @@ export const fetchModel = new RequestType0("likec4/fetchModel");
 export const computeView = new RequestType(
   "likec4/computeView"
 );
-export const rebuild = new RequestType0("likec4/rebuildModel");
-export const buildDocuments = new RequestType(
-  "likec4/buildDocuments"
-);
+export const buildDocuments = new RequestType("likec4/build");
 export const locate = new RequestType("likec4/locate");