@likec4/language-server 0.50.0 → 0.52.0

package/dist/ast.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="react" />
 import { type c4 } from '@likec4/core';
-import type { LangiumDocument, MultiMap } from 'langium';
-import type { SetRequired } from 'type-fest';
+import type { AstNode, DiagnosticInfo, LangiumDocument, MultiMap } from 'langium';
+import type { ConditionalPick, SetRequired, ValueOf } from 'type-fest';
+import type { Diagnostic } from 'vscode-languageserver-protocol';
 import type { LikeC4Grammar } from './generated/ast';
 import * as ast from './generated/ast';
 export { ast };
@@ -73,23 +74,34 @@ export interface DocFqnIndexEntry {
     el: WeakRef<ast.Element>;
     path: string;
 }
+export type LikeC4AstNode = ValueOf<ConditionalPick<ast.LikeC4AstType, AstNode>>;
+type LikeC4DocumentDiagnostic = Diagnostic & DiagnosticInfo<LikeC4AstNode>;
 export interface LikeC4DocumentProps {
+    diagnostics?: Array<LikeC4DocumentDiagnostic>;
     c4Specification?: ParsedAstSpecification;
     c4Elements?: ParsedAstElement[];
     c4Relations?: ParsedAstRelation[];
     c4Views?: ParsedAstElementView[];
     c4fqns?: MultiMap<c4.Fqn, DocFqnIndexEntry>;
 }
-export interface LikeC4LangiumDocument extends LangiumDocument<LikeC4Grammar>, LikeC4DocumentProps {
+export interface LikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, LikeC4DocumentProps {
 }
-export interface FqnIndexedDocument extends LangiumDocument<LikeC4Grammar>, SetRequired<LikeC4DocumentProps, 'c4fqns'> {
+export interface FqnIndexedDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, SetRequired<LikeC4DocumentProps, 'c4fqns'> {
 }
-export interface ParsedLikeC4LangiumDocument extends LangiumDocument<LikeC4Grammar>, Required<LikeC4DocumentProps> {
+export interface ParsedLikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, Required<LikeC4DocumentProps> {
 }
 export declare function cleanParsedModel(doc: LikeC4LangiumDocument): ParsedLikeC4LangiumDocument;
 export declare function isFqnIndexedDocument(doc: LangiumDocument): doc is FqnIndexedDocument;
 export declare function isLikeC4LangiumDocument(doc: LangiumDocument): doc is LikeC4LangiumDocument;
 export declare function isParsedLikeC4LangiumDocument(doc: LangiumDocument): doc is ParsedLikeC4LangiumDocument;
+type Guard<N extends AstNode> = (n: AstNode) => n is N;
+type Guarded<G> = G extends Guard<infer N> ? N : never;
+declare const isValidatableAstNode: (n: AstNode) => n is ast.Relation | ast.SpecificationRelationshipKind | ast.SpecificationRule | ast.SpecificationElementKind | ast.Element | ast.Model | ast.ExtendElement | ast.ElementView | ast.ModelViews | ast.SpecificationTag;
+type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
+export declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
+    isValid: (n: ValidatableAstNode) => boolean;
+    invalidNodes: WeakSet<ast.ExplicitRelation | ast.ImplicitRelation | ast.SpecificationRelationshipKind | ast.SpecificationRule | ast.SpecificationElementKind | ast.Element | ast.Model | ast.ExtendElement | ast.ElementView | ast.ModelViews | ast.SpecificationTag>;
+};
 export declare const isValidLikeC4LangiumDocument: (doc: LangiumDocument) => doc is ParsedLikeC4LangiumDocument;
 export declare function streamModel(doc: LikeC4LangiumDocument): Generator<ast.Relation | ast.Element, void, unknown>;
 export declare function resolveRelationPoints(node: ast.Relation): {
@@ -113,7 +125,7 @@ export declare function toRelationshipStyle(props?: ast.SpecificationRelationshi
     tail?: c4.RelationshipArrowType;
 };
 export declare function toRelationshipStyleExcludeDefaults(props?: ast.SpecificationRelationshipKind['props']): {
-    tail?: "crow" | "diamond" | "none" | "odiamond" | "onormal" | "open" | "vee";
+    tail?: c4.RelationshipArrowType;
     head?: "crow" | "diamond" | "none" | "odiamond" | "onormal" | "open" | "vee";
     line?: "dotted" | "solid";
     color?: "amber" | "blue" | "green" | "indigo" | "muted" | "primary" | "red" | "secondary" | "sky" | "slate";

package/dist/ast.js

@@ -7,12 +7,12 @@ import {
   RelationRefError,
   nonexhaustive
 } from "@likec4/core";
-import { DocumentState } from "langium";
+import { DocumentState, getContainerOfType } from "langium";
 import { isNil } from "remeda";
+import { DiagnosticSeverity } from "vscode-languageserver-protocol";
 import { elementRef } from "./elementRef.js";
 import * as ast from "./generated/ast.js";
 import { LikeC4LanguageMetaData } from "./generated/module.js";
-import { DiagnosticSeverity } from "vscode-languageserver-protocol";
 export { ast };
 const idattr = Symbol.for("idattr");
 export const ElementViewOps = {
@@ -58,18 +58,52 @@ export function isLikeC4LangiumDocument(doc) {
 export function isParsedLikeC4LangiumDocument(doc) {
   return isLikeC4LangiumDocument(doc) && doc.state == DocumentState.Validated && !!doc.c4Specification && !!doc.c4Elements && !!doc.c4Relations && !!doc.c4Views && !!doc.c4fqns;
 }
+function validatableAstNodeGuards(predicates) {
+  return (n) => predicates.some((p) => p(n));
+}
+const isValidatableAstNode = validatableAstNodeGuards([
+  ast.isModel,
+  ast.isRelation,
+  ast.isElement,
+  ast.isExtendElement,
+  ast.isSpecificationRule,
+  ast.isSpecificationElementKind,
+  ast.isSpecificationRelationshipKind,
+  ast.isSpecificationTag,
+  ast.isElementView,
+  ast.isModelViews
+]);
+export function checksFromDiagnostics(doc) {
+  const invalidNodes = new WeakSet(
+    doc.diagnostics?.flatMap((d) => {
+      if (d.severity === DiagnosticSeverity.Error) {
+        return getContainerOfType(d.node, isValidatableAstNode) ?? [];
+      }
+      return [];
+    }) ?? []
+  );
+  const isValid = (n) => !invalidNodes.has(n);
+  return {
+    isValid,
+    invalidNodes
+  };
+}
 export const isValidLikeC4LangiumDocument = (doc) => {
   if (!isParsedLikeC4LangiumDocument(doc))
     return false;
   const { parseResult, diagnostics } = doc;
-  return parseResult.lexerErrors.length === 0 && (!diagnostics || diagnostics.every((d) => d.severity !== DiagnosticSeverity.Error));
+  return parseResult.lexerErrors.length === 0 && parseResult.parserErrors.length === 0 && (!diagnostics || diagnostics.length === 0 || diagnostics.every((d) => d.severity !== DiagnosticSeverity.Error));
 };
 export function* streamModel(doc) {
-  const elements = doc.parseResult.value.models.flatMap((m) => m.elements);
+  const { isValid } = checksFromDiagnostics(doc);
+  const elements = doc.parseResult.value.models.flatMap((m) => isValid(m) ? m.elements : []);
   const traverseStack = [...elements];
   const relations = [];
   let el;
   while (el = traverseStack.shift()) {
+    if (!isValid(el)) {
+      continue;
+    }
     if (ast.isRelation(el)) {
       relations.push(el);
       continue;
@@ -185,7 +219,7 @@ export function toRelationshipStyleExcludeDefaults(props) {
     ...color && color !== DefaultRelationshipColor ? { color } : {},
     ...line && line !== DefaultLineStyle ? { line } : {},
     ...head && head !== DefaultArrowType ? { head } : {},
-    ...tail && tail !== DefaultArrowType ? { tail } : {}
+    ...tail ? { tail } : {}
   };
 }
 export function toAutoLayout(direction) {

package/dist/model/model-builder.js

@@ -7,7 +7,7 @@ import { LikeC4ModelGraph, computeView } from "@likec4/graph";
 import { DocumentState } from "langium";
 import * as R from "remeda";
 import { Disposable } from "vscode-languageserver";
-import { isValidLikeC4LangiumDocument } from "../ast.js";
+import { isParsedLikeC4LangiumDocument } from "../ast.js";
 import { logError, logWarnError, logger } from "../logger.js";
 import { printDocs } from "../utils.js";
 import { assignNavigateTo, resolveRelativePaths, resolveRulesExtendedViews } from "../view-utils/index.js";
@@ -255,7 +255,7 @@ ${printDocs(docs)}`);
     });
   }
   documents() {
-    return this.langiumDocuments.all.filter(isValidLikeC4LangiumDocument).toArray();
+    return this.langiumDocuments.all.filter(isParsedLikeC4LangiumDocument).toArray();
   }
   notifyListeners(docs) {
     for (const listener of this.listeners) {

package/dist/model/model-parser.js

@@ -7,6 +7,7 @@ import {
   ElementViewOps,
   ast,
   cleanParsedModel,
+  checksFromDiagnostics,
   isFqnIndexedDocument,
   resolveRelationPoints,
   streamModel,
@@ -18,7 +19,7 @@ import {
 import { elementRef, getFqnElementRef } from "../elementRef.js";
 import { logError, logWarnError, logger } from "../logger.js";
 function toSingleLine(str) {
-  return str?.split("\n").join(" ").trim();
+  return str ? removeIndent(str).split("\n").join(" ") : void 0;
 }
 function removeIndent(str) {
   return str ? stripIndent(str).trim() : void 0;
@@ -53,35 +54,32 @@ export class LikeC4ModelParser {
     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 {
-          c4Specification.kinds[kind.name] = toElementStyleExcludeDefaults(
-            style?.props
-          );
-        } catch (e) {
-          logWarnError(e);
-        }
+  parseSpecification(doc) {
+    const { isValid } = checksFromDiagnostics(doc);
+    const { parseResult, c4Specification } = doc;
+    const specifications = parseResult.value.specifications.filter(isValid);
+    const element_specs = specifications.flatMap((s) => s.elements.filter(isValid));
+    for (const { kind, style } of element_specs) {
+      try {
+        const kindName = kind.name;
+        c4Specification.kinds[kindName] = {
+          ...c4Specification.kinds[kindName],
+          ...toElementStyleExcludeDefaults(style?.props)
+        };
+      } catch (e) {
+        logWarnError(e);
       }
     }
-    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 c4Specification.relationships) {
-          logger.warn(`Duplicate specification for relationship kind ${kind.name}`);
-          continue;
-        }
-        try {
-          c4Specification.relationships[kind.name] = toRelationshipStyleExcludeDefaults(props);
-        } catch (e) {
-          logWarnError(e);
-        }
+    const relations_specs = specifications.flatMap((s) => s.relationships.filter(isValid));
+    for (const { kind, props } of relations_specs) {
+      try {
+        const kindName = kind.name;
+        c4Specification.relationships[kindName] = {
+          ...c4Specification.relationships[kindName],
+          ...toRelationshipStyleExcludeDefaults(props)
+        };
+      } catch (e) {
+        logWarnError(e);
       }
     }
   }
@@ -155,7 +153,10 @@ export class LikeC4ModelParser {
     };
   }
   parseViews(doc) {
-    const views = doc.parseResult.value.views.flatMap((v) => v.views);
+    const { isValid } = checksFromDiagnostics(doc);
+    const views = doc.parseResult.value.views.flatMap(
+      (v) => isValid(v) ? v.views.filter(isValid) : []
+    );
     for (const view of views) {
       try {
         const v = this.parseElementView(view);

package/dist/module.d.ts

@@ -1,7 +1,8 @@
 import { WorkspaceCache, type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type Module, type PartialLangiumServices } from 'langium';
 import { Rpc } from './Rpc';
-import { LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider } from './lsp';
+import { LikeC4CodeLensProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
 import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
+import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
 import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from './shared';
 interface LikeC4AddedSharedServices {
     lsp: {
@@ -26,8 +27,15 @@ export interface LikeC4AddedServices {
         ModelLocator: LikeC4ModelLocator;
     };
     lsp: {
-        DocumentLinkProvider: LikeC4DocumentLinkProvider;
         DocumentSymbolProvider: LikeC4DocumentSymbolProvider;
+        SemanticTokenProvider: LikeC4SemanticTokenProvider;
+        HoverProvider: LikeC4HoverProvider;
+        CodeLensProvider: LikeC4CodeLensProvider;
+        DocumentLinkProvider: LikeC4DocumentLinkProvider;
+    };
+    references: {
+        ScopeComputation: LikeC4ScopeComputation;
+        ScopeProvider: LikeC4ScopeProvider;
     };
     shared?: LikeC4SharedServices;
 }

package/dist/references/scope-computation.d.ts

@@ -3,8 +3,8 @@ import type { CancellationToken } from 'vscode-languageserver';
 import { ast, type LikeC4LangiumDocument } from '../ast';
 type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;
 export declare class LikeC4ScopeComputation extends DefaultScopeComputation {
-    computeExports(document: LikeC4LangiumDocument, _cancelToken: CancellationToken): Promise<AstNodeDescription[]>;
-    computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken: CancellationToken): Promise<PrecomputedScopes>;
+    computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;
+    computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<PrecomputedScopes>;
     protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): MultiMap<string, AstNodeDescription>;
 }
 export {};

package/dist/references/scope-computation.js

@@ -2,74 +2,71 @@ import {
   DefaultScopeComputation,
   MultiMap
 } from "langium";
-import { isEmpty, isTruthy } from "remeda";
+import { isTruthy } from "remeda";
 import { ast } from "../ast.js";
 import { logError } from "../logger.js";
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
   computeExports(document, _cancelToken) {
-    const docExports = [];
-    const { specifications, models, views } = document.parseResult.value;
-    try {
-      for (const spec of specifications.flatMap((s) => s.elements)) {
-        if (spec.kind && isTruthy(spec.kind.name)) {
-          docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
-        }
-      }
-    } catch (e) {
-      logError(e);
-    }
-    try {
-      for (const spec of specifications.flatMap((s) => s.tags)) {
-        if (spec.tag && isTruthy(spec.tag.name)) {
-          docExports.push(
-            this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document)
-          );
-        }
-      }
-    } catch (e) {
-      logError(e);
-    }
-    try {
-      for (const spec of specifications.flatMap((s) => s.relationships)) {
-        if (spec.kind && isTruthy(spec.kind.name)) {
-          docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
+    return new Promise((resolve) => {
+      const docExports = [];
+      const { specifications, models, views } = document.parseResult.value;
+      try {
+        for (const spec of specifications.flatMap((s) => [...s.elements, ...s.relationships])) {
+          if (spec.kind && isTruthy(spec.kind.name)) {
+            docExports.push(
+              this.descriptions.createDescription(spec.kind, spec.kind.name, document)
+            );
+          }
         }
+      } catch (e) {
+        logError(e);
       }
-    } catch (e) {
-      logError(e);
-    }
-    try {
-      for (const elAst of models.flatMap((m) => m.elements)) {
-        if (ast.isElement(elAst) && !isEmpty(elAst.name)) {
-          docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
+      try {
+        for (const spec of specifications.flatMap((s) => s.tags)) {
+          if (spec.tag && isTruthy(spec.tag.name)) {
+            docExports.push(
+              this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document)
+            );
+          }
         }
+      } catch (e) {
+        logError(e);
       }
-    } catch (e) {
-      logError(e);
-    }
-    try {
-      for (const viewAst of views.flatMap((v) => v.views)) {
-        if (isTruthy(viewAst.name)) {
-          docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
+      try {
+        for (const elAst of models.flatMap((m) => m.elements)) {
+          if (ast.isElement(elAst) && isTruthy(elAst.name)) {
+            docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
+          }
         }
+      } catch (e) {
+        logError(e);
       }
-    } catch (e) {
-      logError(e);
-    }
-    return Promise.resolve(docExports);
-  }
-  async computeLocalScopes(document, _cancelToken) {
-    const root = document.parseResult.value;
-    const scopes = new MultiMap();
-    for (const model of root.models) {
       try {
-        const nested = this.processContainer(model, scopes, document);
-        scopes.addAll(root, nested.values());
+        for (const viewAst of views.flatMap((v) => v.views)) {
+          if (isTruthy(viewAst.name)) {
+            docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
+          }
+        }
       } catch (e) {
         logError(e);
       }
-    }
-    return Promise.resolve(scopes);
+      resolve(docExports);
+    });
+  }
+  computeLocalScopes(document, _cancelToken) {
+    return new Promise((resolve) => {
+      const root = document.parseResult.value;
+      const scopes = new MultiMap();
+      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);
+    });
   }
   processContainer(container, scopes, document) {
     const localScope = new MultiMap();
@@ -88,9 +85,13 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         subcontainer = el.body;
       }
       if (subcontainer && subcontainer.elements.length > 0) {
-        const nested = this.processContainer(subcontainer, scopes, document);
-        for (const [nestedName, desc] of nested) {
-          nestedScopes.add(nestedName, desc);
+        try {
+          const nested = this.processContainer(subcontainer, scopes, document);
+          for (const [nestedName, desc] of nested) {
+            nestedScopes.add(nestedName, desc);
+          }
+        } catch (e) {
+          logError(e);
         }
       }
     }

package/dist/references/scope-provider.js

@@ -101,22 +101,24 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
     const scopes = [];
     const doc = getDocument(context.container);
     const precomputed = doc.precomputedScopes;
-    const byReferenceType = (desc) => this.reflection.isSubtype(desc.type, referenceType);
-    let container = context.container;
-    while (container) {
-      const elements = precomputed?.get(container).filter(byReferenceType);
-      if (elements && elements.length > 0) {
-        scopes.push(stream(elements));
-      }
-      if (referenceType === ast.Element) {
-        if (ast.isExtendElementBody(container)) {
-          scopes.push(this.scopeExtendElement(container.$container));
+    if (precomputed) {
+      const byReferenceType = (desc) => this.reflection.isSubtype(desc.type, referenceType);
+      let container = context.container;
+      while (container) {
+        const elements = precomputed.get(container).filter(byReferenceType);
+        if (elements.length > 0) {
+          scopes.push(stream(elements));
         }
-        if (ast.isElementViewBody(container)) {
-          scopes.push(this.scopeElementView(container.$container));
+        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;
       }
-      container = container.$container;
     }
     return scopes.reduceRight((outerScope, elements) => {
       return this.createScope(elements, outerScope);

package/dist/shared/NodeKindProvider.js

@@ -47,10 +47,12 @@ export class NodeKindProvider {
         return CompletionItemKind.EnumMember;
       case SymbolKind.TypeParameter:
         return CompletionItemKind.TypeParameter;
+      case SymbolKind.Interface:
+        return CompletionItemKind.Interface;
       case SymbolKind.Event:
         return CompletionItemKind.Event;
       default:
-        return CompletionItemKind.Constant;
+        return CompletionItemKind.Keyword;
     }
   }
 }

package/dist/test/testServices.d.ts

@@ -4,7 +4,7 @@ export declare function createTestServices(workspace?: string): {
     parse: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
     validate: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<{
         document: LikeC4LangiumDocument;
-        diagnostics: import("vscode-languageserver-types").Diagnostic[];
+        diagnostics: (import("vscode-languageserver-types").Diagnostic & import("langium").DiagnosticInfo<import("../ast").LikeC4AstNode>)[];
         warnings: string[];
         errors: string[];
     }>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "0.50.0",
+  "version": "0.52.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -50,8 +50,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@likec4/core": "0.50.0",
-    "@likec4/graph": "0.50.0",
+    "@likec4/core": "0.52.0",
+    "@likec4/graph": "0.52.0",
     "langium": "^2.1.3",
     "object-hash": "^3.0.0",
     "p-debounce": "^4.0.0",
@@ -59,21 +59,21 @@
     "rambdax": "^9.1.1",
     "remeda": "^1.29.0",
     "strip-indent": "^4.0.0",
-    "type-fest": "^4.8.2",
+    "type-fest": "^4.8.3",
     "ufo": "^1.3.2",
     "vscode-languageserver": "9.0.1",
     "vscode-languageserver-protocol": "3.17.5",
     "vscode-uri": "3.0.8"
   },
   "devDependencies": {
-    "@types/node": "^20.10.1",
+    "@types/node": "^20.10.4",
     "@types/object-hash": "^3.0.6",
     "execa": "^8.0.1",
     "langium-cli": "^2.1.0",
     "npm-run-all": "^4.1.5",
-    "typescript": "^5.3.2",
+    "typescript": "^5.3.3",
     "unbuild": "^2.0.0",
-    "vitest": "^0.34.6"
+    "vitest": "^1.0.4"
   },
   "packageManager": "yarn@4.0.2",
   "volta": {