@likec4/language-server 0.45.0 → 0.46.1

package/dist/references/scope-computation.js

@@ -2,51 +2,53 @@ import {
   DefaultScopeComputation,
   MultiMap
 } from "langium";
-import { isEmpty } from "remeda";
+import { hasAtLeast, isEmpty } from "remeda";
 import { ast } from "../ast.js";
+import { logError } from "../logger.js";
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
   computeExports(document, _cancelToken) {
-    const { specification, model, views } = document.parseResult.value;
-    const docExports = [];
-    if (specification) {
-      for (const spec of specification.elements) {
+    try {
+      const { specifications, models, views } = document.parseResult.value;
+      const docExports = [];
+      for (const spec of specifications.flatMap((s) => s.elements)) {
         if (spec.kind && !isEmpty(spec.kind.name)) {
           docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
         }
       }
-      for (const spec of specification.tags) {
+      for (const spec of specifications.flatMap((s) => s.tags)) {
         if (spec.tag && !isEmpty(spec.tag.name)) {
           docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
-          docExports.push(this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document));
+          docExports.push(
+            this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document)
+          );
         }
       }
-      for (const spec of specification.relationships) {
+      for (const spec of specifications.flatMap((s) => s.relationships)) {
         if (spec.kind && !isEmpty(spec.kind.name)) {
           docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
         }
       }
-    }
-    if (model && model.elements.length > 0) {
-      for (const elAst of model.elements) {
+      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));
         }
       }
-    }
-    if (views && views.views.length > 0) {
-      for (const viewAst of views.views) {
+      for (const viewAst of views.flatMap((v) => v.views)) {
         if (viewAst.name && !isEmpty(viewAst.name)) {
           docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
         }
       }
+      return Promise.resolve(docExports);
+    } catch (e) {
+      logError(e);
+      return Promise.reject(e);
     }
-    return Promise.resolve(docExports);
   }
   async computeLocalScopes(document, _cancelToken) {
     const root = document.parseResult.value;
     const scopes = new MultiMap();
-    if (root.model) {
-      const nested = this.processContainer(root.model, scopes, document);
+    if (hasAtLeast(root.models, 1)) {
+      const nested = this.processContainer(root.models[0], scopes, document);
       scopes.addAll(root, nested.values());
     }
     return Promise.resolve(scopes);

package/dist/references/scope-provider.js

@@ -4,13 +4,13 @@ import {
   EMPTY_STREAM,
   StreamImpl,
   StreamScope,
+  findNodeForProperty,
   getDocument,
   stream,
-  findNodeForProperty,
   toDocumentSegment
 } from "langium";
 import { ast } from "../ast.js";
-import { elementRef, isElementRefHead, parentFqnElementRef } from "../elementRef.js";
+import { elementRef, getFqnElementRef } from "../elementRef.js";
 import { logError } from "../logger.js";
 function toAstNodeDescription(entry) {
   const $cstNode = findNodeForProperty(entry.el.$cstNode, "name");
@@ -56,41 +56,41 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
     );
   }
   scopeElementRef(ref) {
-    const parentNode = ref.$container;
-    if (!ast.isElementRef(parentNode)) {
-      throw new Error("Expected be inside ElementRef");
-    }
-    return this.uniqueDescedants(() => parentNode.el.ref);
+    return this.uniqueDescedants(() => ref.el.ref);
   }
   scopeExtendElement(extend) {
     return this.uniqueDescedants(() => elementRef(extend.element));
   }
   scopeElementView({ viewOf, extends: ext }) {
+    if (viewOf) {
+      return stream([viewOf]).flatMap((v) => {
+        const el = elementRef(v);
+        return el ? this.descriptions.createDescription(el, el.name) : [];
+      }).concat(this.uniqueDescedants(() => elementRef(viewOf)));
+    }
     if (ext) {
       return stream([ext]).flatMap((v) => {
         const view = v.view.ref;
         return view ? this.scopeElementView(view) : EMPTY_STREAM;
       });
     }
-    if (viewOf) {
-      return this.uniqueDescedants(() => elementRef(viewOf));
-    }
     return EMPTY_STREAM;
   }
   getScope(context) {
     const referenceType = this.reflection.getReferenceType(context);
     try {
       const container = context.container;
-      if (referenceType === ast.Element) {
-        if (ast.isStrictElementRef(container)) {
-          if (isElementRefHead(container)) {
-            return this.getGlobalScope(referenceType);
-          }
-          const parent = parentFqnElementRef(container);
-          return new StreamScope(this.directChildrenOf(parent));
+      if (ast.isFqnElementRef(container) && context.property === "el") {
+        const parent = container.parent;
+        if (!parent) {
+          return this.getGlobalScope(referenceType);
         }
-        if (ast.isElementRef(container) && !isElementRefHead(container)) {
-          return new StreamScope(this.scopeElementRef(container));
+        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));
         }
       }
       return this.computeScope(container, referenceType);

package/dist/shared/NodeKindProvider.d.ts

@@ -0,0 +1,13 @@
+import { type AstNode, type AstNodeDescription } from 'langium';
+import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-protocol';
+export declare class NodeKindProvider implements NodeKindProvider {
+    /**
+     * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
+     */
+    getSymbolKind(_node: AstNode | AstNodeDescription): SymbolKind;
+    /**
+     * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
+     */
+    getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind;
+}
+//# sourceMappingURL=NodeKindProvider.d.ts.map

package/dist/shared/NodeKindProvider.js

@@ -0,0 +1,29 @@
+import { isAstNode } from "langium";
+import { CompletionItemKind, SymbolKind } from "vscode-languageserver-protocol";
+import { ast } from "../ast.js";
+export class NodeKindProvider {
+  /**
+   * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
+   */
+  getSymbolKind(_node) {
+    return SymbolKind.Field;
+  }
+  /**
+   * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
+   */
+  getCompletionItemKind(node) {
+    const hasType = (type) => "type" in node && node.type === type;
+    switch (true) {
+      case (isAstNode(node) ? ast.isElement(node) : node.type === ast.Element): {
+        return CompletionItemKind.Variable;
+      }
+      case (ast.isElementKind(node) || ast.isRelationshipKind(node) || hasType(ast.ElementKind) || hasType(ast.RelationshipKind)): {
+        return CompletionItemKind.Class;
+      }
+      case (ast.isTag(node) || hasType(ast.Tag)): {
+        return CompletionItemKind.EnumMember;
+      }
+    }
+    return CompletionItemKind.Reference;
+  }
+}

package/dist/test/testServices.js

@@ -13,17 +13,19 @@ export function createTestServices(workspace = "file:///test/workspace") {
     name: "test",
     uri: workspaceUri.toString()
   };
-  const initPromise = services.shared.workspace.WorkspaceManager.initializeWorkspace([
-    workspaceFolder
-  ]);
-  void initPromise.finally(() => {
+  let isInitialized = false;
+  const init = async () => {
+    if (isInitialized)
+      return Promise.resolve();
+    isInitialized = true;
+    await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
     Object.assign(services.shared.workspace.WorkspaceManager, {
       folders: [workspaceFolder]
     });
-  });
+  };
   let documentIndex = 1;
   const parse = async (input, uri) => {
-    await initPromise;
+    await init();
     const docUri = Utils.resolvePath(
       workspaceUri,
       "./src/",
@@ -38,7 +40,6 @@ export function createTestServices(workspace = "file:///test/workspace") {
     return document;
   };
   const validate = async (input, uri) => {
-    await initPromise;
     const document = typeof input === "string" ? await parse(input, uri) : input;
     await documentBuilder.build([document], { validation: true });
     const diagnostics = document.diagnostics ?? [];
@@ -50,7 +51,6 @@ export function createTestServices(workspace = "file:///test/workspace") {
     };
   };
   const validateAll = async () => {
-    await initPromise;
     const docs = langiumDocuments.all.toArray();
     await documentBuilder.build(docs, { validation: true });
     const diagnostics = docs.flatMap((doc) => doc.diagnostics ?? []);

package/dist/utils.js

@@ -1,4 +1,4 @@
-export const printDocs = (docs) => docs.map((d) => "  - " + d.uri.path).join("\n");
+export const printDocs = (docs) => docs.map((d) => "  - " + d.uri).join("\n");
 export function queueMicrotask(cb) {
   return Promise.resolve().then(cb);
 }

package/dist/validation/index.js

@@ -1,13 +1,23 @@
 import { logger } from "../logger.js";
 import { elementChecks } from "./element.js";
 import { relationChecks } from "./relation.js";
-import { elementKindChecks, relationshipChecks, tagChecks } from "./specification.js";
+import {
+  elementKindChecks,
+  modelRuleChecks,
+  modelViewsChecks,
+  relationshipChecks,
+  specificationRuleChecks,
+  tagChecks
+} from "./specification.js";
 import { viewChecks } from "./view.js";
 import { incomingExpressionChecks, outgoingExpressionChecks } from "./view-predicates/index.js";
 export function registerValidationChecks(services) {
   logger.info("registerValidationChecks");
   const registry = services.validation.ValidationRegistry;
   registry.register({
+    SpecificationRule: specificationRuleChecks(services),
+    Model: modelRuleChecks(services),
+    ModelViews: modelViewsChecks(services),
     ElementView: viewChecks(services),
     Element: elementChecks(services),
     ElementKind: elementKindChecks(services),
@@ -16,10 +26,10 @@ export function registerValidationChecks(services) {
     RelationshipKind: relationshipChecks(services),
     IncomingExpression: incomingExpressionChecks(services),
     OutgoingExpression: outgoingExpressionChecks(services)
-  });
+  }, "slow");
   const connection = services.shared.lsp.Connection;
   if (connection) {
-    services.shared.workspace.DocumentBuilder.onUpdate((changed, deleted) => {
+    services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {
       for (const uri of deleted) {
         void connection.sendDiagnostics({
           uri: uri.toString(),

package/dist/validation/relation.js

@@ -15,31 +15,25 @@ export const relationChecks = (services) => {
         });
       }
       let sourceEl;
-      if ("source" in el) {
+      if (ast.isExplicitRelation(el)) {
         sourceEl = elementRef(el.source);
-      } else {
-        if (!ast.isElementBody(el.$container)) {
-          accept(
-            "error",
-            "Invalid relation, expected to have source defined or be inside the element",
-            {
-              node: el,
-              keyword: "->"
-            }
-          );
-        } else {
-          sourceEl = el.$container.$container;
+        if (!sourceEl) {
+          return accept("error", "Source not found (not parsed/indexed yet)", {
+            node: el,
+            property: "source"
+          });
         }
+      } else {
+        sourceEl = el.$container.$container;
       }
-      const source = sourceEl && fqnIndex.getFqn(sourceEl);
-      if (sourceEl && !source) {
+      const source = fqnIndex.getFqn(sourceEl);
+      if (!source) {
         accept("error", "Source not found (not parsed/indexed yet)", {
-          node: el,
-          property: "source"
+          node: el
         });
       }
       if (source && target && isSameHierarchy(source, target)) {
-        return accept("error", "Invalid parent-child relationship", {
+        accept("error", "Invalid parent-child relationship", {
           node: el
         });
       }

package/dist/validation/specification.d.ts

@@ -1,6 +1,9 @@
 import type { ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
+export declare const specificationRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.SpecificationRule>;
+export declare const modelRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.Model>;
+export declare const modelViewsChecks: (_: LikeC4Services) => ValidationCheck<ast.ModelViews>;
 export declare const elementKindChecks: (services: LikeC4Services) => ValidationCheck<ast.ElementKind>;
 export declare const tagChecks: (services: LikeC4Services) => ValidationCheck<ast.Tag>;
 export declare const relationshipChecks: (services: LikeC4Services) => ValidationCheck<ast.RelationshipKind>;

package/dist/validation/specification.js

@@ -1,4 +1,34 @@
 import { ast } from "../ast.js";
+export const specificationRuleChecks = (_) => {
+  return (node, accept) => {
+    if (node.$containerIndex && node.$containerIndex > 0) {
+      accept("error", `Only one specification per document is allowed`, {
+        node,
+        property: "name"
+      });
+    }
+  };
+};
+export const modelRuleChecks = (_) => {
+  return (node, accept) => {
+    if (node.$containerIndex && node.$containerIndex > 0) {
+      accept("error", `Only one model per document is allowed`, {
+        node,
+        property: "name"
+      });
+    }
+  };
+};
+export const modelViewsChecks = (_) => {
+  return (node, accept) => {
+    if (node.$containerIndex && node.$containerIndex > 0) {
+      accept("error", `Only one views block per document is allowed`, {
+        node,
+        property: "name"
+      });
+    }
+  };
+};
 export const elementKindChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
   return (node, accept) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "0.45.0",
+  "version": "0.46.1",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -50,24 +50,24 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@likec4/core": "0.45.0",
-    "@likec4/graph": "0.45.0",
-    "langium": "^2.0.2",
+    "@likec4/core": "0.46.1",
+    "@likec4/graph": "0.46.1",
+    "langium": "^2.1.2",
     "object-hash": "^3.0.0",
     "p-debounce": "^4.0.0",
     "p-throttle": "^5.1.0",
     "rambdax": "^9.1.1",
-    "remeda": "^1.28.0",
+    "remeda": "^1.29.0",
     "strip-indent": "^4.0.0",
-    "vscode-languageserver": "~8.1.0",
-    "vscode-languageserver-protocol": "~3.17.3",
-    "vscode-uri": "~3.0.7"
+    "vscode-languageserver": "9.0.1",
+    "vscode-languageserver-protocol": "3.17.5",
+    "vscode-uri": "3.0.8"
   },
   "devDependencies": {
     "@types/node": "^20.8.7",
     "@types/object-hash": "^3.0.5",
     "execa": "^8.0.1",
-    "langium-cli": "^2.0.1",
+    "langium-cli": "^2.1.0",
     "npm-run-all": "^4.1.5",
     "typescript": "^5.2.2",
     "unbuild": "^2.0.0",