@likec4/language-server 0.2.0

package/dist/module.js

@@ -0,0 +1,57 @@
+import { createDefaultModule, inject, createDefaultSharedModule } from 'langium';
+import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from './generated/module';
+import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
+import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator } from './model';
+import { registerValidationChecks } from './validation';
+import { LikeC4CodeLensProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
+import { registerProtocolHandlers } from './registerProtocolHandlers';
+function bind(Type) {
+    return (services) => new Type(services);
+}
+export const LikeC4Module = {
+    likec4: {
+        FqnIndex: bind(FqnIndex),
+        ModelBuilder: bind(LikeC4ModelBuilder),
+        ModelLocator: bind(LikeC4ModelLocator),
+        // Model: bind(LikeC4Model),
+        // Model: bind(LikeC4Model),
+        // SpecIndex: bind(LikeC4SpecIndex),
+        // Validator: bind(LikeC4Validator)
+    },
+    lsp: {
+        DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
+        SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
+        HoverProvider: bind(LikeC4HoverProvider),
+    },
+    //
+    //   // Formatter: bind(LikeC4Formatter),
+    //
+    // },
+    references: {
+        ScopeComputation: bind(LikeC4ScopeComputation),
+        ScopeProvider: bind(LikeC4ScopeProvider)
+    }
+};
+const LikeC4SharedModule = {
+    ...LikeC4GeneratedSharedModule,
+    lsp: {
+        CodeLensProvider: (services) => new LikeC4CodeLensProvider(services)
+    }
+};
+export function createLanguageServices(context) {
+    // const connection = context.connection
+    // if (connection) {
+    //   logger.log = connection.console.log.bind(connection.console)
+    //   logger.info = connection.console.info.bind(connection.console)
+    //   logger.warn = connection.console.warn.bind(connection.console)
+    //   logger.error = connection.console.error.bind(connection.console)
+    //   logger.debug = connection.tracer.log.bind(connection.tracer)
+    //   logger.trace = connection.tracer.log.bind(connection.tracer)
+    // }
+    const shared = inject(createDefaultSharedModule(context), LikeC4SharedModule);
+    const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module);
+    shared.ServiceRegistry.register(likec4);
+    registerValidationChecks(likec4);
+    registerProtocolHandlers(likec4);
+    return { shared, likec4 };
+}

package/dist/protocol.d.ts

@@ -0,0 +1,35 @@
+import type { Fqn, LikeC4Model, RelationID, ViewID } from '@likec4/core/types';
+import type { Location } from 'vscode-languageserver-protocol';
+import { NotificationType, RequestType0, RequestType } from 'vscode-languageserver-protocol';
+export declare const onDidChangeLikeC4Model: NotificationType<unknown>;
+export declare const fetchLikeC4Model: RequestType0<{
+    model: LikeC4Model | null;
+}, unknown>;
+export declare const buildDocuments: RequestType<string[], void, unknown>;
+export declare const locateElement: RequestType<{
+    element: Fqn;
+    property?: string;
+}, Location | null, unknown>;
+export declare const locateRelation: RequestType<{
+    id: RelationID;
+}, Location | null, unknown>;
+export declare const locateView: RequestType<{
+    id: ViewID;
+}, Location | null, unknown>;
+export declare const Rpc: {
+    readonly onDidChangeModel: NotificationType<unknown>;
+    readonly fetchModel: RequestType0<{
+        model: LikeC4Model | null;
+    }, unknown>;
+    readonly buildDocuments: RequestType<string[], void, unknown>;
+    readonly locateElement: RequestType<{
+        element: Fqn;
+        property?: string;
+    }, Location | null, unknown>;
+    readonly locateRelation: RequestType<{
+        id: RelationID;
+    }, Location | null, unknown>;
+    readonly locateView: RequestType<{
+        id: ViewID;
+    }, Location | null, unknown>;
+};

package/dist/protocol.js

@@ -0,0 +1,19 @@
+import { NotificationType, RequestType0, RequestType } from 'vscode-languageserver-protocol';
+//#region From server
+export const onDidChangeLikeC4Model = new NotificationType('likec4/onDidChangeModel');
+//#endregion
+// //#region To server
+export const fetchLikeC4Model = new RequestType0('likec4/fetchModel');
+export const buildDocuments = new RequestType('likec4/buildDocuments');
+export const locateElement = new RequestType('likec4/locateElement');
+export const locateRelation = new RequestType('likec4/locateRelation');
+export const locateView = new RequestType('likec4/locateView');
+// //#endregion
+export const Rpc = {
+    onDidChangeModel: onDidChangeLikeC4Model,
+    fetchModel: fetchLikeC4Model,
+    buildDocuments,
+    locateElement,
+    locateRelation,
+    locateView
+};

package/dist/references/index.d.ts

@@ -0,0 +1,2 @@
+export * from './scope-computation';
+export * from './scope-provider';

package/dist/references/index.js

@@ -0,0 +1,2 @@
+export * from './scope-computation';
+export * from './scope-provider';

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

@@ -0,0 +1,10 @@
+import { DefaultScopeComputation, MultiMap, type AstNodeDescription, type PrecomputedScopes } from 'langium';
+import type { CancellationToken } from 'vscode-languageserver-protocol';
+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>;
+    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): MultiMap<string, AstNodeDescription>;
+}
+export {};

package/dist/references/scope-computation.js

@@ -0,0 +1,76 @@
+import { DefaultScopeComputation, MultiMap } from 'langium';
+import { ast } from '../ast';
+export class LikeC4ScopeComputation extends DefaultScopeComputation {
+    // constructor(services: LikeC4Services) {
+    //   super(services)
+    // }
+    computeExports(document, _cancelToken) {
+        const { specification, model, views } = document.parseResult.value;
+        const docExports = [];
+        if (specification) {
+            for (const { kind } of specification.elementKinds) {
+                docExports.push(this.descriptions.createDescription(kind, kind.name, document));
+            }
+            for (const { tag } of specification.tags) {
+                docExports.push(this.descriptions.createDescription(tag, tag.name, document));
+                docExports.push(this.descriptions.createDescription(tag, '#' + tag.name, document));
+            }
+        }
+        if (model) {
+            for (const elAst of model.elements) {
+                if (ast.isElement(elAst)) {
+                    docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
+                }
+            }
+        }
+        if (views) {
+            for (const viewAst of views.views) {
+                if ('name' in viewAst) {
+                    docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
+                }
+            }
+        }
+        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);
+            scopes.addAll(root, nested.values());
+        }
+        return Promise.resolve(scopes);
+    }
+    processContainer(container, scopes, document) {
+        const localScope = new MultiMap();
+        const nestedScopes = new MultiMap();
+        for (const el of container.elements) {
+            if (ast.isRelation(el)) {
+                continue;
+            }
+            let subcontainer;
+            if (ast.isElement(el)) {
+                localScope.add(el.name, this.descriptions.createDescription(el, el.name, document));
+                subcontainer = el.body;
+            }
+            else if (ast.isExtendElement(el)) {
+                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);
+                }
+            }
+        }
+        for (const [name, descriptions] of nestedScopes.entriesGroupedByKey()) {
+            // If name is unique for current scope
+            if (!localScope.has(name) && descriptions.length === 1) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                localScope.add(name, descriptions[0]);
+            }
+        }
+        scopes.addAll(container, localScope.values());
+        return localScope;
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { AstNode } from 'langium';
+import { DefaultScopeProvider, type ReferenceInfo, type Scope } from 'langium';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
+    private fqnIndex;
+    constructor(services: LikeC4Services);
+    private scopeElementRef;
+    private scopeElementView;
+    getScope(context: ReferenceInfo): Scope;
+    protected computeScope(node: AstNode, referenceType: string): Scope;
+    /**
+       * Create a global scope filtered for the given reference type.
+       */
+    protected getGlobalScope(referenceType: string): Scope;
+}

package/dist/references/scope-provider.js

@@ -0,0 +1,110 @@
+import { DONE_RESULT, DefaultScopeProvider, EMPTY_SCOPE, StreamImpl, StreamScope, getDocument, stream, EMPTY_STREAM } from 'langium';
+import { ast } from '../ast';
+import { elementRef, isElementRefHead, parentStrictElementRef, strictElementRefFqn } from '../elementRef';
+export class LikeC4ScopeProvider extends DefaultScopeProvider {
+    fqnIndex;
+    constructor(services) {
+        super(services);
+        this.fqnIndex = services.likec4.FqnIndex;
+    }
+    scopeElementRef(ref) {
+        const parentNode = ref.$container;
+        if (!ast.isElementRef(parentNode)) {
+            throw new Error('Expected be inside ElementRef');
+        }
+        return new StreamImpl(() => {
+            const parent = parentNode.el.ref;
+            const fqn = parent && this.fqnIndex.get(parent);
+            if (fqn) {
+                return this.fqnIndex.uniqueDescedants(fqn).iterator();
+            }
+            return null;
+        }, (iterator) => {
+            if (iterator) {
+                return iterator.next();
+            }
+            return DONE_RESULT;
+        });
+    }
+    scopeElementView({ viewOf }) {
+        if (!viewOf) {
+            return EMPTY_STREAM;
+        }
+        return new StreamImpl(() => {
+            const target = elementRef(viewOf);
+            const fqn = target && this.fqnIndex.get(target);
+            if (fqn) {
+                return this.fqnIndex.uniqueDescedants(fqn).iterator();
+            }
+            return null;
+        }, (iterator) => {
+            if (iterator) {
+                return iterator.next();
+            }
+            return DONE_RESULT;
+        });
+    }
+    getScope(context) {
+        try {
+            const referenceType = this.reflection.getReferenceType(context);
+            const node = context.container;
+            // const path = this.services.workspace.AstNodeLocator.getAstNodePath(node)
+            if (referenceType === ast.Element) {
+                if (ast.isStrictElementRef(node)) {
+                    if (isElementRefHead(node)) {
+                        return this.getGlobalScope(referenceType);
+                    }
+                    const parent = parentStrictElementRef(node);
+                    return new StreamScope(this.fqnIndex.directChildrenOf(parent));
+                }
+                if (ast.isElementRef(node) && !isElementRefHead(node)) {
+                    return new StreamScope(this.scopeElementRef(node));
+                }
+            }
+            return this.computeScope(node, referenceType);
+        }
+        catch (e) {
+            console.error(e);
+            // logger.error(e)
+            return EMPTY_SCOPE;
+        }
+    }
+    computeScope(node, referenceType) {
+        const scopes = [];
+        const doc = getDocument(node);
+        const precomputed = doc.precomputedScopes;
+        const byReferenceType = (desc) => this.reflection.isSubtype(desc.type, referenceType);
+        if (precomputed) {
+            const elements = precomputed.get(node).filter(byReferenceType);
+            if (elements.length > 0) {
+                scopes.push(stream(elements));
+            }
+            let container = node.$container;
+            while (container) {
+                const elements = precomputed.get(container).filter(byReferenceType);
+                if (elements.length > 0) {
+                    scopes.push(stream(elements));
+                }
+                if (referenceType === ast.Element) {
+                    if (ast.isExtendElementBody(container)) {
+                        const extendsOf = strictElementRefFqn(container.$container.element);
+                        scopes.push(this.fqnIndex.uniqueDescedants(extendsOf));
+                    }
+                    if (ast.isViewRule(container)) {
+                        scopes.push(this.scopeElementView(container.$container));
+                    }
+                }
+                container = container.$container;
+            }
+        }
+        return scopes.reduceRight((outerScope, elements) => {
+            return this.createScope(elements, outerScope);
+        }, this.getGlobalScope(referenceType));
+    }
+    /**
+       * Create a global scope filtered for the given reference type.
+       */
+    getGlobalScope(referenceType) {
+        return new StreamScope(this.indexManager.allElements(referenceType));
+    }
+}

package/dist/registerProtocolHandlers.d.ts

@@ -0,0 +1,2 @@
+import type { LikeC4Services } from './module';
+export declare function registerProtocolHandlers(services: LikeC4Services): void;

package/dist/registerProtocolHandlers.js

@@ -0,0 +1,49 @@
+import { logger } from './logger';
+import { Rpc } from './protocol';
+export function registerProtocolHandlers(services) {
+    const connection = services.shared.lsp.Connection;
+    if (!connection) {
+        return;
+    }
+    const modelBuilder = services.likec4.ModelBuilder;
+    const modelLocator = services.likec4.ModelLocator;
+    const LangiumDocuments = services.shared.workspace.LangiumDocuments;
+    connection.onRequest(Rpc.fetchModel, async (_cancelToken) => {
+        let model;
+        try {
+            model = modelBuilder.buildModel() ?? null;
+        }
+        catch (e) {
+            model = null;
+            logger.error(e);
+        }
+        return Promise.resolve({
+            model: model ?? null
+        });
+    });
+    connection.onRequest(Rpc.buildDocuments, async (docs, cancelToken) => {
+        const changed = [];
+        for (const d of docs) {
+            const uri = d;
+            if (LangiumDocuments.hasDocument(uri)) {
+                changed.push(uri);
+            }
+            else {
+                logger.error(`LangiumDocuments does not have document: ${uri.toString()}`);
+            }
+        }
+        logger.debug(`Received request to rebuild: [
+      ${changed.map(d => d.toString()).join('\n      ')}
+    ]`);
+        await services.shared.workspace.DocumentBuilder.update(changed, [], cancelToken);
+    });
+    connection.onRequest(Rpc.locateElement, ({ element, property }, _cancelToken) => {
+        return modelLocator.locateElement(element, property);
+    });
+    connection.onRequest(Rpc.locateRelation, ({ id }, _cancelToken) => {
+        return modelLocator.locateRelation(id);
+    });
+    connection.onRequest(Rpc.locateView, ({ id }, _cancelToken) => {
+        return modelLocator.locateView(id);
+    });
+}

package/dist/test/index.d.ts

@@ -0,0 +1 @@
+export * from './testServices';

package/dist/test/index.js

@@ -0,0 +1 @@
+export * from './testServices';

package/dist/test/testServices.d.ts

@@ -0,0 +1,15 @@
+import type { LikeC4LangiumDocument } from '../ast';
+export declare function createTestServices(): {
+    services: import("../module").LikeC4Services;
+    parse: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
+    validate: (input: string | LikeC4LangiumDocument) => Promise<{
+        document: LikeC4LangiumDocument;
+        diagnostics: import("vscode-languageserver-types").Diagnostic[];
+        errors: string[];
+    }>;
+    validateAll: () => Promise<{
+        diagnostics: import("vscode-languageserver-types").Diagnostic[];
+        errors: string[];
+    }>;
+    buildModel: () => Promise<import("@likec4/core/types").LikeC4Model>;
+};

package/dist/test/testServices.js

@@ -0,0 +1,53 @@
+import { createLanguageServices } from '../module';
+import { EmptyFileSystem } from 'langium';
+import { URI } from 'vscode-uri';
+export function createTestServices() {
+    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;
+    let documentIndex = 1;
+    const parse = async (input, uri) => {
+        uri = uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`;
+        const document = services.shared.workspace.LangiumDocumentFactory.fromString(input, URI.file(uri));
+        langiumDocuments.addDocument(document);
+        await documentBuilder.build([document], { validationChecks: 'none' });
+        return document;
+    };
+    const validate = async (input) => {
+        const document = typeof input === 'string' ? await parse(input) : input;
+        await documentBuilder.build([document], { validationChecks: 'all' });
+        const diagnostics = document.diagnostics ?? [];
+        const errors = diagnostics.map(d => d.message);
+        return {
+            document,
+            diagnostics,
+            errors
+        };
+    };
+    const validateAll = async () => {
+        const docs = langiumDocuments.all.toArray();
+        await documentBuilder.build(docs, { validationChecks: 'all' });
+        const diagnostics = docs.flatMap(doc => doc.diagnostics ?? []);
+        const errors = diagnostics.map(d => d.message);
+        return {
+            diagnostics,
+            errors
+        };
+    };
+    const buildModel = async () => {
+        await validateAll();
+        const model = modelBuilder.buildModel();
+        if (!model)
+            throw new Error('No model found');
+        return model;
+    };
+    return {
+        services,
+        parse,
+        validate,
+        validateAll,
+        buildModel
+    };
+}

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function failExpectedNever(arg: never): never;
+export declare function ignoreNeverInRuntime(arg: never): void;

package/dist/utils.js

@@ -0,0 +1,7 @@
+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}`);
+}

package/dist/validation/element.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+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

@@ -0,0 +1,20 @@
+export const elementChecks = (services) => {
+    const fqnIndex = services.likec4.FqnIndex;
+    return (el, accept) => {
+        const fqn = fqnIndex.get(el);
+        if (!fqn) {
+            accept('error', 'Not indexed', {
+                node: el,
+                property: 'name',
+            });
+            return;
+        }
+        const withSameFqn = fqnIndex.byFqn(fqn);
+        if (withSameFqn.length > 1) {
+            accept('error', `Duplicate element name ${el.name !== fqn ? el.name + ' (' + fqn + ')' : el.name}`, {
+                node: el,
+                property: 'name',
+            });
+        }
+    };
+};

package/dist/validation/index.d.ts

@@ -0,0 +1,2 @@
+import type { LikeC4Services } from '../module';
+export declare function registerValidationChecks(services: LikeC4Services): void;

package/dist/validation/index.js

@@ -0,0 +1,20 @@
+import { elementChecks } from './element';
+import { elementKindChecks, tagChecks } from './specification';
+import { viewChecks } from './view';
+export function registerValidationChecks(services) {
+    const registry = services.validation.ValidationRegistry;
+    // const checks: ValidationChecks = {
+    // Element: validator.checkElementNameDuplicates,
+    // Tag: validator.checkTagDuplicates,
+    // ElementKind: elementKindChecks(services),
+    // ElementStyleProperty: validator.checkElementStyleProperty,
+    // View: validator.checkViewNameDuplicates,
+    // ColorStyleProperty: validator.checkColorStyleProperty,
+    // }
+    registry.register({
+        ElementView: viewChecks(services),
+        Element: elementChecks(services),
+        ElementKind: elementKindChecks(services),
+        Tag: tagChecks(services),
+    });
+}

package/dist/validation/specification.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const elementKindChecks: (services: LikeC4Services) => ValidationCheck<ast.ElementKind>;
+export declare const tagChecks: (services: LikeC4Services) => ValidationCheck<ast.Tag>;

package/dist/validation/specification.js

@@ -0,0 +1,31 @@
+import { ast } from '../ast';
+export const elementKindChecks = (services) => {
+    const index = services.shared.workspace.IndexManager;
+    return (node, accept) => {
+        const sameKinds = index.allElements(ast.ElementKind)
+            .filter(n => n.name === node.name)
+            .limit(2)
+            .count();
+        if (sameKinds > 1) {
+            accept('error', `Duplicate element kind '${node.name}'`, {
+                node: node,
+                property: 'name',
+            });
+        }
+    };
+};
+export const tagChecks = (services) => {
+    const index = services.shared.workspace.IndexManager;
+    return (node, accept) => {
+        const sameKinds = index.allElements(ast.Tag)
+            .filter(n => n.name === node.name)
+            .limit(2)
+            .count();
+        if (sameKinds > 1) {
+            accept('error', `Duplicate tag '${node.name}'`, {
+                node: node,
+                property: 'name',
+            });
+        }
+    };
+};

package/dist/validation/view.d.ts

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

package/dist/validation/view.js

@@ -0,0 +1,19 @@
+import { ast } from '../ast';
+export const viewChecks = (services) => {
+    const index = services.shared.workspace.IndexManager;
+    return (el, accept) => {
+        if (!el.name) {
+            return;
+        }
+        const anotherViews = index.allElements(ast.View)
+            .filter(n => n.name === el.name)
+            .limit(2)
+            .count();
+        if (anotherViews > 1) {
+            accept('error', `Duplicate view '${el.name}'`, {
+                node: el,
+                property: 'name'
+            });
+        }
+    };
+};