@likec4/language-server 0.33.1 → 0.35.0

package/dist/test/testServices.js

@@ -1,27 +1,33 @@
 import { createLanguageServices } from '../module';
 import { EmptyFileSystem } from 'langium';
-import { URI } from 'vscode-uri';
+import { URI, Utils } from 'vscode-uri';
 import stripIndent from 'strip-indent';
-export function createTestServices() {
+export function createTestServices(workspace = 'file:///test/workspace') {
     const services = createLanguageServices(EmptyFileSystem).likec4;
     const metaData = services.LanguageMetaData;
     const langiumDocuments = services.shared.workspace.LangiumDocuments;
     const documentBuilder = services.shared.workspace.DocumentBuilder;
     const modelBuilder = services.likec4.ModelBuilder;
-    const initPromise = services.shared.workspace.WorkspaceManager.initializeWorkspace([]);
+    const workspaceUri = URI.parse(workspace);
+    const initPromise = services.shared.workspace.WorkspaceManager.initializeWorkspace([
+        {
+            name: 'test',
+            uri: workspaceUri.toString()
+        }
+    ]);
     let documentIndex = 1;
     const parse = async (input, uri) => {
         await initPromise;
-        uri = uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`;
-        const document = services.shared.workspace.LangiumDocumentFactory.fromString(stripIndent(input), URI.file(uri));
+        const docUri = Utils.joinPath(workspaceUri, '/src/', uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`);
+        const document = services.shared.workspace.LangiumDocumentFactory.fromString(stripIndent(input), docUri);
         langiumDocuments.addDocument(document);
-        await documentBuilder.build([document], { validationChecks: 'none' });
+        await documentBuilder.build([document], { validation: false });
         return document;
     };
-    const validate = async (input) => {
+    const validate = async (input, uri) => {
         await initPromise;
-        const document = typeof input === 'string' ? await parse(input) : input;
-        await documentBuilder.build([document], { validationChecks: 'all' });
+        const document = typeof input === 'string' ? await parse(input, uri) : input;
+        await documentBuilder.build([document], { validation: true });
         const diagnostics = document.diagnostics ?? [];
         const errors = diagnostics.map(d => d.message);
         return {
@@ -33,7 +39,7 @@ export function createTestServices() {
     const validateAll = async () => {
         await initPromise;
         const docs = langiumDocuments.all.toArray();
-        await documentBuilder.build(docs, { validationChecks: 'all' });
+        await documentBuilder.build(docs, { validation: true });
         const diagnostics = docs.flatMap(doc => doc.diagnostics ?? []);
         const errors = diagnostics.map(d => d.message);
         return {

package/dist/utils.d.ts

@@ -1,3 +1,3 @@
-export declare function failExpectedNever(arg: never): never;
-export declare function ignoreNeverInRuntime(arg: never): void;
+import type { LangiumDocument } from 'langium';
+export declare const printDocs: (docs: LangiumDocument[]) => string;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -1,8 +1,3 @@
-export function failExpectedNever(arg) {
-    throw new Error(`Unexpected value: ${JSON.stringify(arg)}`);
-}
-export function ignoreNeverInRuntime(arg) {
-    console.warn(`Unexpected and ignored value: ${JSON.stringify(arg)}`);
-    // throw new Error(`Unexpected value: ${arg}`);
-}
+import { Utils } from 'vscode-uri';
+export const printDocs = (docs) => docs.map(d => '  - ' + Utils.basename(d.uri)).join('\n');
 //# sourceMappingURL=utils.js.map

package/dist/validation/element.d.ts

@@ -1,4 +1,4 @@
-import type { ValidationCheck } from 'langium';
+import { type ValidationCheck } from 'langium';
 import type { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const elementChecks: (services: LikeC4Services) => ValidationCheck<ast.Element>;

package/dist/validation/element.js

@@ -1,3 +1,4 @@
+import { getDocument } from 'langium';
 export const elementChecks = (services) => {
     const fqnIndex = services.likec4.FqnIndex;
     return (el, accept) => {
@@ -9,13 +10,32 @@ export const elementChecks = (services) => {
             });
             return;
         }
-        const withSameFqn = fqnIndex.byFqn(fqn).limit(2).count();
-        if (withSameFqn > 1) {
+        const withSameFqn = fqnIndex
+            .byFqn(fqn)
+            .filter(v => v.el !== el)
+            .head();
+        if (withSameFqn) {
             accept('error', `Duplicate element name ${el.name !== fqn ? el.name + ' (' + fqn + ')' : el.name}`, {
                 node: el,
-                property: 'name'
+                property: 'name',
+                relatedInformation: [
+                    {
+                        location: {
+                            range: withSameFqn.el.$cstNode.range,
+                            uri: getDocument(withSameFqn.el).uri.toString()
+                        },
+                        message: `Already defined here`
+                    }
+                ]
             });
         }
+        // for (let i = 3; i < el.props.length; i++) {
+        //   accept('error', `Too many properties, max 3 allowed`, {
+        //     node: el,
+        //     property: 'props',
+        //     index: i
+        //   })
+        // }
     };
 };
 //# sourceMappingURL=element.js.map

package/dist/validation/index.js

@@ -1,8 +1,11 @@
+import { Utils } from 'vscode-uri';
+import { logger } from '../logger';
 import { elementChecks } from './element';
 import { relationChecks } from './relation';
 import { elementKindChecks, tagChecks } from './specification';
 import { viewChecks } from './view';
 export function registerValidationChecks(services) {
+    logger.info('registerValidationChecks');
     const registry = services.validation.ValidationRegistry;
     // const checks: ValidationChecks = {
     // Element: validator.checkElementNameDuplicates,
@@ -19,5 +22,28 @@ export function registerValidationChecks(services) {
         Relation: relationChecks(services),
         Tag: tagChecks(services)
     });
+    const connection = services.shared.lsp.Connection;
+    if (connection) {
+        logger.info('registerValidationChecks');
+        // wokraround for bug in langium
+        services.shared.workspace.DocumentBuilder.onUpdate((changed, deleted) => {
+            const message = [`[DocumentBuilder.onUpdate]`];
+            if (changed.length > 0) {
+                message.push(` changed:`);
+                changed.forEach(u => message.push(`  - ${Utils.basename(u)}`));
+            }
+            if (deleted.length > 0) {
+                message.push(` deleted:`);
+                deleted.forEach(u => message.push(`  - ${Utils.basename(u)}`));
+            }
+            logger.debug(message.join('\n'));
+            for (const uri of deleted) {
+                void connection.sendDiagnostics({
+                    uri: uri.toString(),
+                    diagnostics: []
+                });
+            }
+        });
+    }
 }
 //# sourceMappingURL=index.js.map

package/dist/validation/relation.d.ts

@@ -1,5 +1,5 @@
 import type { ValidationCheck } from 'langium';
-import type { ast } from '../ast';
+import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const relationChecks: (services: LikeC4Services) => ValidationCheck<ast.Relation>;
 //# sourceMappingURL=relation.d.ts.map

package/dist/validation/relation.js

@@ -1,43 +1,49 @@
-import { BaseError } from '@likec4/core';
-import { isSameHierarchy } from '@likec4/core/utils';
-import { resolveRelationPoints } from '../ast';
+import { isSameHierarchy } from '@likec4/core';
+import { ast } from '../ast';
+import { elementRef } from '../elementRef';
+import { logError } from '../logger';
 export const relationChecks = (services) => {
     const fqnIndex = services.likec4.FqnIndex;
     return (el, accept) => {
         try {
-            const coupling = resolveRelationPoints(el);
-            const target = fqnIndex.getFqn(coupling.target);
-            const source = fqnIndex.getFqn(coupling.source);
-            if (!target || !source) {
-                if (!target) {
-                    accept('error', 'Target not found', {
+            const targetEl = elementRef(el.target);
+            const target = targetEl && fqnIndex.getFqn(targetEl);
+            if (!target) {
+                accept('error', 'Target not found (not parsed/indexed yet)', {
+                    node: el,
+                    property: 'target'
+                });
+            }
+            let sourceEl;
+            if ('source' in 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,
-                        property: 'target'
+                        keyword: '->'
                     });
                 }
-                if (!source) {
-                    accept('error', 'Source not found', {
-                        node: el,
-                        property: 'source'
-                    });
+                else {
+                    sourceEl = el.$container.$container;
                 }
-                return;
             }
-            if (isSameHierarchy(source, target)) {
-                return accept('error', 'Invalid parent-child relation', {
-                    node: el
+            const source = sourceEl && fqnIndex.getFqn(sourceEl);
+            if (sourceEl && !source) {
+                accept('error', 'Source not found (not parsed/indexed yet)', {
+                    node: el,
+                    property: 'source'
                 });
             }
-        }
-        catch (e) {
-            if (e instanceof BaseError) {
-                return accept('error', e.message, {
+            if (source && target && isSameHierarchy(source, target)) {
+                return accept('error', 'Invalid parent-child relationship', {
                     node: el
                 });
             }
-            accept('error', 'Invalid relation', {
-                node: el
-            });
+        }
+        catch (e) {
+            logError(e);
         }
     };
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "0.33.1",
+  "version": "0.35.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -42,22 +42,24 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@likec4/core": "0.33.1",
-    "langium": "^1.2.1",
+    "@likec4/core": "0.35.0",
+    "langium": "^2.0.2",
     "nanoid": "^4.0.2",
     "object-hash": "^3.0.0",
     "rambdax": "^9.1.1",
     "remeda": "^1.24.0",
     "strip-indent": "^4.0.0",
     "vscode-languageserver": "~8.1.0",
-    "vscode-languageserver-protocol": "~3.17.3"
+    "vscode-languageserver-protocol": "~3.17.3",
+    "vscode-uri": "~3.0.7"
   },
   "devDependencies": {
     "@types/node": "^18.15.11",
     "@types/object-hash": "^3.0.2",
-    "langium-cli": "^1.2.1",
+    "langium-cli": "^2.0.1",
     "npm-run-all": "^4.1.5",
-    "typescript": "^5.1.6",
-    "vitest": "^0.34.1"
-  }
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.3"
+  },
+  "packageManager": "yarn@3.6.3"
 }