@likec4/language-server 0.6.2 → 0.8.0

package/dist/module.js

@@ -0,0 +1,66 @@
+import { createDefaultModule, createDefaultSharedModule, EmptyFileSystem, inject } from 'langium';
+import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from './generated/module';
+import { LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
+import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator } from './model';
+import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
+import { registerProtocolHandlers } from './registerProtocolHandlers';
+import { LikeC4CodeLensProvider, LikeC4WorkspaceManager } from './shared';
+import { registerValidationChecks } from './validation';
+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,
+    workspace: {
+        WorkspaceManager: services => new LikeC4WorkspaceManager(services)
+    },
+    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 moduleContext = {
+        ...EmptyFileSystem,
+        ...context
+    };
+    const shared = inject(createDefaultSharedModule(moduleContext), LikeC4SharedModule);
+    const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module);
+    shared.ServiceRegistry.register(likec4);
+    registerValidationChecks(likec4);
+    registerProtocolHandlers(likec4);
+    return { shared, likec4 };
+}
+//# sourceMappingURL=module.js.map

package/dist/protocol.d.ts

@@ -0,0 +1,37 @@
+import type { Fqn, LikeC4Model, RelationID, ViewID } from '@likec4/core';
+import type { DocumentUri, Location } from 'vscode-languageserver-protocol';
+import { NotificationType0, RequestType0, RequestType } from 'vscode-languageserver-protocol';
+export declare const onDidChangeModel: NotificationType0;
+export declare const fetchModel: RequestType0<{
+    model: LikeC4Model | null;
+}, void>;
+export interface BuildDocumentsParams {
+    docs: DocumentUri[];
+}
+export declare const buildDocuments: RequestType<BuildDocumentsParams, void, void>;
+export interface LocateElementParams {
+    element: Fqn;
+    property?: string;
+}
+export declare const locateElement: RequestType<LocateElementParams, Location | null, void>;
+export declare const locateRelation: RequestType<{
+    id: RelationID;
+}, Location | null, void>;
+export declare const locateView: RequestType<{
+    id: ViewID;
+}, Location | null, void>;
+export declare const Rpc: {
+    readonly onDidChangeModel: NotificationType0;
+    readonly fetchModel: RequestType0<{
+        model: LikeC4Model | null;
+    }, void>;
+    readonly buildDocuments: RequestType<BuildDocumentsParams, void, void>;
+    readonly locateElement: RequestType<LocateElementParams, Location | null, void>;
+    readonly locateRelation: RequestType<{
+        id: RelationID;
+    }, Location | null, void>;
+    readonly locateView: RequestType<{
+        id: ViewID;
+    }, Location | null, void>;
+};
+//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.js

@@ -0,0 +1,20 @@
+import { NotificationType0, RequestType0, RequestType } from 'vscode-languageserver-protocol';
+//#region From server
+export const onDidChangeModel = new NotificationType0('likec4/onDidChangeModel');
+//#endregion
+//#region To server
+export const fetchModel = 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,
+    fetchModel,
+    buildDocuments,
+    locateElement,
+    locateRelation,
+    locateView
+};
+//# sourceMappingURL=protocol.js.map

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

@@ -0,0 +1,4 @@
+import { type LikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare function computeDocumentFqn(document: LikeC4LangiumDocument, services: LikeC4Services): void;
+//# sourceMappingURL=fqn-computation.d.ts.map

package/dist/references/fqn-computation.js

@@ -0,0 +1,41 @@
+import { failExpectedNever } from '@likec4/core';
+import { Fqn } from '@likec4/core/types';
+import { MultiMap } from 'langium';
+import { isEmpty, isNil } from 'rambdax';
+import { ElementOps, ast } from '../ast';
+import { strictElementRefFqn } from '../elementRef';
+export function computeDocumentFqn(document, services) {
+    const { model } = document.parseResult.value;
+    if (!model?.elements) {
+        return;
+    }
+    const c4fqns = document.c4fqns = new MultiMap();
+    const locator = services.workspace.AstNodeLocator;
+    const traverseStack = model.elements.map(el => [el, null]);
+    let pair;
+    while ((pair = traverseStack.shift())) {
+        const [el, parent] = pair;
+        if (ast.isRelation(el)) {
+            continue;
+        }
+        if (ast.isExtendElement(el)) {
+            if (!isNil(el.body) && !isEmpty(el.body.elements)) {
+                const fqn = strictElementRefFqn(el.element);
+                el.body.elements.forEach(child => traverseStack.push([child, fqn]));
+            }
+            continue;
+        }
+        if (ast.isElement(el)) {
+            const fqn = Fqn(el.name, parent);
+            const path = locator.getAstNodePath(el);
+            c4fqns.add(fqn, path);
+            ElementOps.writeId(el, fqn);
+            if (!isNil(el.body) && !isEmpty(el.body.elements)) {
+                el.body.elements.forEach(child => traverseStack.push([child, fqn]));
+            }
+            continue;
+        }
+        failExpectedNever(el);
+    }
+}
+//# sourceMappingURL=fqn-computation.js.map

package/dist/references/index.d.ts

@@ -0,0 +1,3 @@
+export * from './scope-computation';
+export * from './scope-provider';
+//# sourceMappingURL=index.d.ts.map

package/dist/references/index.js

@@ -0,0 +1,3 @@
+export * from './scope-computation';
+export * from './scope-provider';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,14 @@
+import { DefaultScopeComputation, MultiMap, type AstNodeDescription, type PrecomputedScopes } from 'langium';
+import type { CancellationToken } from 'vscode-languageserver';
+import { ast, type LikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;
+export declare class LikeC4ScopeComputation extends DefaultScopeComputation {
+    private services;
+    constructor(services: LikeC4Services);
+    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 {};
+//# sourceMappingURL=scope-computation.d.ts.map

package/dist/references/scope-computation.js

@@ -0,0 +1,86 @@
+import { DefaultScopeComputation, MultiMap } from 'langium';
+import { ast } from '../ast';
+import { computeDocumentFqn } from './fqn-computation';
+export class LikeC4ScopeComputation extends DefaultScopeComputation {
+    services;
+    constructor(services) {
+        super(services);
+        this.services = 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));
+            }
+        }
+        document.c4fqns = undefined;
+        if (model) {
+            for (const elAst of model.elements) {
+                if (ast.isElement(elAst)) {
+                    docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
+                }
+            }
+            computeDocumentFqn(document, this.services);
+        }
+        // const c4fqns = document.c4fqns
+        // logger.debug(`doc ${document.uri.path}:
+        //  fqns: ${c4fqns ? Array.from(c4fqns.keys()).join(', ') : '--'}
+        // `)
+        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;
+    }
+}
+//# sourceMappingURL=scope-computation.js.map

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

@@ -0,0 +1,19 @@
+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 directChildrenOf;
+    private uniqueDescedants;
+    private scopeElementRef;
+    private scopeExtendElement;
+    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;
+}
+//# sourceMappingURL=scope-provider.d.ts.map

package/dist/references/scope-provider.js

@@ -0,0 +1,120 @@
+import { DONE_RESULT, DefaultScopeProvider, EMPTY_STREAM, StreamImpl, StreamScope, getDocument, stream } from 'langium';
+import { ast } from '../ast';
+import { elementRef, isElementRefHead, parentStrictElementRef } from '../elementRef';
+import { logger } from '../logger';
+function toAstNodeDescription(entry) {
+    return {
+        documentUri: entry.doc.uri,
+        name: entry.name,
+        path: entry.path,
+        type: ast.Element
+    };
+}
+export class LikeC4ScopeProvider extends DefaultScopeProvider {
+    fqnIndex;
+    constructor(services) {
+        super(services);
+        this.fqnIndex = services.likec4.FqnIndex;
+    }
+    directChildrenOf(parent) {
+        return this.fqnIndex
+            .directChildrenOf(parent)
+            .map(toAstNodeDescription);
+    }
+    uniqueDescedants(of) {
+        return new StreamImpl(() => {
+            const element = of();
+            const fqn = element && this.fqnIndex.get(element);
+            if (fqn) {
+                return this.fqnIndex.uniqueDescedants(fqn)
+                    .map(toAstNodeDescription)
+                    .iterator();
+            }
+            return null;
+        }, iterator => {
+            if (iterator) {
+                return iterator.next();
+            }
+            return DONE_RESULT;
+        });
+    }
+    scopeElementRef(ref) {
+        const parentNode = ref.$container;
+        if (!ast.isElementRef(parentNode)) {
+            throw new Error('Expected be inside ElementRef');
+        }
+        return this.uniqueDescedants(() => parentNode.el.ref);
+    }
+    scopeExtendElement(extend) {
+        return this.uniqueDescedants(() => elementRef(extend.element));
+    }
+    scopeElementView({ viewOf }) {
+        if (!viewOf) {
+            return EMPTY_STREAM;
+        }
+        return this.uniqueDescedants(() => elementRef(viewOf));
+    }
+    getScope(context) {
+        const referenceType = this.reflection.getReferenceType(context);
+        try {
+            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.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 this.getGlobalScope(referenceType);
+        }
+    }
+    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)) {
+                        scopes.push(this.scopeExtendElement(container.$container));
+                    }
+                    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));
+    }
+}
+//# sourceMappingURL=scope-provider.js.map

package/dist/registerProtocolHandlers.d.ts

@@ -0,0 +1,3 @@
+import type { LikeC4Services } from './module';
+export declare function registerProtocolHandlers(services: LikeC4Services): void;
+//# sourceMappingURL=registerProtocolHandlers.d.ts.map

package/dist/registerProtocolHandlers.js

@@ -0,0 +1,65 @@
+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, async ({ element, property }, _cancelToken) => {
+        try {
+            return Promise.resolve(modelLocator.locateElement(element, property ?? 'name'));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    });
+    connection.onRequest(Rpc.locateRelation, ({ id }, _cancelToken) => {
+        try {
+            return Promise.resolve(modelLocator.locateRelation(id));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    });
+    connection.onRequest(Rpc.locateView, ({ id }, _cancelToken) => {
+        try {
+            return Promise.resolve(modelLocator.locateView(id));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    });
+}
+//# sourceMappingURL=registerProtocolHandlers.js.map

package/dist/shared/CodeLensProvider.d.ts

@@ -0,0 +1,9 @@
+import type { LangiumDocument, LangiumSharedServices, MaybePromise } from 'langium';
+import type { CodeLensProvider } from 'langium/lib/lsp/code-lens-provider';
+import type { CancellationToken, CodeLens, CodeLensParams } from 'vscode-languageserver';
+export declare class LikeC4CodeLensProvider implements CodeLensProvider {
+    private services;
+    constructor(services: LangiumSharedServices);
+    provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, _cancelToken?: CancellationToken): MaybePromise<CodeLens[] | undefined>;
+}
+//# sourceMappingURL=CodeLensProvider.d.ts.map

package/dist/shared/CodeLensProvider.js

@@ -0,0 +1,36 @@
+import { ElementViewOps, isParsedLikeC4LangiumDocument } from '../ast';
+export class LikeC4CodeLensProvider {
+    services;
+    constructor(services) {
+        this.services = services;
+        //
+    }
+    provideCodeLens(doc, _params, _cancelToken) {
+        if (!isParsedLikeC4LangiumDocument(doc)) {
+            return;
+        }
+        return doc.parseResult.value.views?.views.flatMap(ast => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const viewId = ElementViewOps.readId(ast);
+            const range = ast.$cstNode?.range;
+            if (!range || !viewId) {
+                return [];
+            }
+            return {
+                range: {
+                    start: range.start,
+                    end: {
+                        line: range.start.line,
+                        character: range.start.character + 4
+                    }
+                },
+                command: {
+                    command: 'likec4.open-preview',
+                    arguments: [viewId],
+                    title: 'open preview'
+                }
+            };
+        });
+    }
+}
+//# sourceMappingURL=CodeLensProvider.js.map

package/dist/shared/WorkspaceManager.d.ts

@@ -0,0 +1,14 @@
+import type { LangiumDocument, LangiumDocumentFactory, LangiumSharedServices } from 'langium';
+import { DefaultWorkspaceManager } from 'langium';
+import type { WorkspaceFolder } from 'vscode-languageserver';
+export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+    protected readonly documentFactory: LangiumDocumentFactory;
+    constructor(services: LangiumSharedServices);
+    /**
+     * Load all additional documents that shall be visible in the context of the given workspace
+     * folders and add them to the collector. This can be used to include built-in libraries of
+     * your language, which can be either loaded from provided files or constructed in memory.
+     */
+    protected loadAdditionalDocuments(_folders: WorkspaceFolder[], _collector: (document: LangiumDocument) => void): Promise<void>;
+}
+//# sourceMappingURL=WorkspaceManager.d.ts.map

package/dist/shared/WorkspaceManager.js

@@ -0,0 +1,18 @@
+import { DefaultWorkspaceManager } from 'langium';
+export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+    documentFactory;
+    constructor(services) {
+        super(services);
+        this.documentFactory = services.workspace.LangiumDocumentFactory;
+    }
+    /**
+     * Load all additional documents that shall be visible in the context of the given workspace
+     * folders and add them to the collector. This can be used to include built-in libraries of
+     * your language, which can be either loaded from provided files or constructed in memory.
+     */
+    loadAdditionalDocuments(_folders, _collector) {
+        // collector(this.documentFactory.fromString(builtin.specification.document, URI.parse(builtin.specification.uri)))
+        return Promise.resolve();
+    }
+}
+//# sourceMappingURL=WorkspaceManager.js.map

package/dist/shared/index.d.ts

@@ -0,0 +1,3 @@
+export * from './CodeLensProvider';
+export * from './WorkspaceManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/index.js

@@ -0,0 +1,3 @@
+export * from './CodeLensProvider';
+export * from './WorkspaceManager';
+//# sourceMappingURL=index.js.map

package/dist/test/index.d.ts

@@ -0,0 +1,2 @@
+export * from './testServices';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/index.js

@@ -0,0 +1,2 @@
+export * from './testServices';
+//# sourceMappingURL=index.js.map

package/dist/test/testServices.d.ts

@@ -0,0 +1,16 @@
+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").LikeC4Model>;
+};
+//# sourceMappingURL=testServices.d.ts.map