zenstack 1.0.0 → 1.0.1

package/packages/schema/src/language-server/generated/module.ts

@@ -1,24 +0,0 @@
-/******************************************************************************
- * This file was generated by langium-cli 0.4.0.
- * DO NOT EDIT MANUALLY!
- ******************************************************************************/
-
-import { LangiumGeneratedServices, LangiumGeneratedSharedServices, LangiumSharedServices, LangiumServices, LanguageMetaData, Module } from 'langium';
-import { ZModelAstReflection } from './ast';
-import { ZModelGrammar } from './grammar';
-
-export const ZModelLanguageMetaData: LanguageMetaData = {
-    languageId: 'zmodel',
-    fileExtensions: ['.zmodel'],
-    caseInsensitive: false
-};
-
-export const ZModelGeneratedSharedModule: Module<LangiumSharedServices, LangiumGeneratedSharedServices> = {
-    AstReflection: () => new ZModelAstReflection()
-};
-
-export const ZModelGeneratedModule: Module<LangiumServices, LangiumGeneratedServices> = {
-    Grammar: () => ZModelGrammar(),
-    LanguageMetaData: () => ZModelLanguageMetaData,
-    parser: {}
-};

package/packages/schema/src/language-server/main.ts

@@ -1,12 +0,0 @@
-import { startLanguageServer } from 'langium';
-import { createConnection, ProposedFeatures } from 'vscode-languageserver/node';
-import { createZModelServices } from './zmodel-module';
-
-// Create a connection to the client
-const connection = createConnection(ProposedFeatures.all);
-
-// Inject the shared services and language-specific services
-const { shared } = createZModelServices({ connection });
-
-// Start the language server with the shared services
-startLanguageServer(shared);

package/packages/schema/src/language-server/stdlib.zmodel

@@ -1,22 +0,0 @@
-enum ReferentialIntegrity {
-    Cascade
-}
-
-function env() String {}
-function auth() User {}
-function now() DateTime {}
-function uuid() String {}
-function cuid() String {}
-function autoincrement() Int {}
-
-attribute id()
-attribute index()
-attribute relation()
-attribute default()
-attribute updatedAt()
-attribute unique()
-attribute allow()
-attribute deny()
-attribute email()
-attribute url()
-attribute length()

package/packages/schema/src/language-server/types.ts

@@ -1,9 +0,0 @@
-import { AstNode } from 'langium';
-import { AbstractDeclaration } from './generated/ast';
-
-export type TypedNode = AstNode & {
-    $resolvedType?: {
-        decl?: string | AbstractDeclaration;
-        array?: boolean;
-    };
-};

package/packages/schema/src/language-server/zmodel-index.ts

@@ -1,33 +0,0 @@
-import {
-    AstNodeDescription,
-    DefaultAstNodeDescriptionProvider,
-    interruptAndCheck,
-    LangiumDocument,
-    LangiumServices,
-    streamAllContents,
-} from 'langium';
-import { CancellationToken } from 'vscode-languageserver';
-import { isEnumField } from './generated/ast';
-
-export class ZModelDescriptionProvider extends DefaultAstNodeDescriptionProvider {
-    constructor(services: LangiumServices) {
-        super(services);
-    }
-
-    async createDescriptions(
-        document: LangiumDocument,
-        cancelToken = CancellationToken.None
-    ): Promise<AstNodeDescription[]> {
-        const descr = await super.createDescriptions(document, cancelToken);
-        // add enum fields so they can be globally resolved across modules
-        for (const node of streamAllContents(document.parseResult.value)) {
-            await interruptAndCheck(cancelToken);
-            if (isEnumField(node)) {
-                await descr.push(
-                    this.createDescription(node, node.name, document)
-                );
-            }
-        }
-        return descr;
-    }
-}

package/packages/schema/src/language-server/zmodel-linker.ts

@@ -1,409 +0,0 @@
-import {
-    AstNode,
-    AstNodeDescription,
-    AstNodeDescriptionProvider,
-    DefaultLinker,
-    DocumentState,
-    interruptAndCheck,
-    isReference,
-    LangiumDocument,
-    LangiumServices,
-    LinkingError,
-    Reference,
-    streamContents,
-} from 'langium';
-import { CancellationToken } from 'vscode-jsonrpc';
-import {
-    AbstractDeclaration,
-    isDataModel,
-    Function,
-    FunctionParamType,
-    DataModelFieldType,
-    ReferenceTarget,
-    MemberAccessExpr,
-    DataModel,
-    LiteralExpr,
-    InvocationExpr,
-    ArrayExpr,
-    ReferenceExpr,
-    UnaryExpr,
-    BinaryExpr,
-    EnumField,
-    DataModelField,
-    FunctionParam,
-    ThisExpr,
-    NullExpr,
-} from './generated/ast';
-import { TypedNode } from './types';
-
-interface DefaultReference extends Reference {
-    _ref?: AstNode | LinkingError;
-    _nodeDescription?: AstNodeDescription;
-}
-
-type ScopeProvider = (name: string) => ReferenceTarget | undefined;
-
-export class ZModelLinker extends DefaultLinker {
-    private readonly descriptions: AstNodeDescriptionProvider;
-
-    constructor(services: LangiumServices) {
-        super(services);
-        this.descriptions = services.workspace.AstNodeDescriptionProvider;
-    }
-
-    async link(
-        document: LangiumDocument,
-        cancelToken = CancellationToken.None
-    ): Promise<void> {
-        if (
-            document.parseResult.lexerErrors?.length > 0 ||
-            document.parseResult.parserErrors?.length > 0
-        ) {
-            return;
-        }
-
-        for (const node of streamContents(document.parseResult.value)) {
-            await interruptAndCheck(cancelToken);
-            this.resolve(node, document);
-        }
-        document.state = DocumentState.Linked;
-    }
-
-    linkReference(
-        container: AstNode,
-        property: string,
-        document: LangiumDocument,
-        extraScopes: ScopeProvider[]
-    ) {
-        if (
-            !this.resolveFromScopeProviders(
-                container,
-                property,
-                document,
-                extraScopes
-            )
-        ) {
-            const reference: Reference<AstNode> = (container as any)[property];
-            this.doLink({ reference, container, property }, document);
-        }
-    }
-
-    resolveFromScopeProviders(
-        node: AstNode,
-        property: string,
-        document: LangiumDocument,
-        providers: ScopeProvider[]
-    ) {
-        const reference: DefaultReference = (node as any)[property];
-        for (const provider of providers) {
-            const target = provider(reference.$refText);
-            if (target) {
-                reference._ref = target;
-                reference._nodeDescription =
-                    this.descriptions.createDescription(
-                        target,
-                        target.name,
-                        document
-                    );
-                return target;
-            }
-        }
-        return null;
-    }
-
-    resolve(
-        node: AstNode,
-        document: LangiumDocument,
-        extraScopes: ScopeProvider[] = []
-    ) {
-        switch (node.$type) {
-            case LiteralExpr:
-                this.resolveLiteral(node as LiteralExpr);
-                break;
-
-            case InvocationExpr:
-                this.resolveInvocation(
-                    node as InvocationExpr,
-                    document,
-                    extraScopes
-                );
-                break;
-
-            case ArrayExpr:
-                this.resolveArray(node as ArrayExpr, document, extraScopes);
-                break;
-
-            case ReferenceExpr:
-                this.resolveReference(
-                    node as ReferenceExpr,
-                    document,
-                    extraScopes
-                );
-                break;
-
-            case MemberAccessExpr:
-                this.resolveMemberAccess(
-                    node as MemberAccessExpr,
-                    document,
-                    extraScopes
-                );
-                break;
-
-            case UnaryExpr:
-                this.resolveUnary(node as UnaryExpr, document, extraScopes);
-                break;
-
-            case BinaryExpr:
-                this.resolveBinary(node as BinaryExpr, document, extraScopes);
-                break;
-
-            case ThisExpr:
-                this.resolveThis(node as ThisExpr, document, extraScopes);
-                break;
-
-            case NullExpr:
-                this.resolveNull(node as NullExpr, document, extraScopes);
-                break;
-
-            default:
-                this.resolveDefault(node, document, extraScopes);
-                break;
-        }
-    }
-
-    resolveBinary(
-        node: BinaryExpr,
-        document: LangiumDocument<AstNode>,
-        extraScopes: ScopeProvider[]
-    ) {
-        switch (node.operator) {
-            // TODO: support arithmetics?
-            // case '+':
-            // case '-':
-            // case '*':
-            // case '/':
-            //     this.resolve(node.left, document, extraScopes);
-            //     this.resolve(node.right, document, extraScopes);
-            //     this.resolveToBuiltinTypeOrDecl(node, 'Int');
-            //     break;
-
-            case '>':
-            case '>=':
-            case '<':
-            case '<=':
-            case '==':
-            case '!=':
-            case '&&':
-            case '||':
-                this.resolve(node.left, document, extraScopes);
-                this.resolve(node.right, document, extraScopes);
-                this.resolveToBuiltinTypeOrDecl(node, 'Boolean');
-                break;
-
-            case '?':
-            case '!':
-            case '^':
-                this.resolveCollectionPredicate(node, document, extraScopes);
-                break;
-
-            default:
-                throw Error(`Unsupported binary operator: ${node.operator}`);
-        }
-    }
-
-    resolveUnary(
-        node: UnaryExpr,
-        document: LangiumDocument<AstNode>,
-        extraScopes: ScopeProvider[]
-    ) {
-        this.resolve(node.operand, document, extraScopes);
-        (node as TypedNode).$resolvedType = (
-            node.operand as TypedNode
-        ).$resolvedType;
-    }
-
-    resolveReference(
-        node: ReferenceExpr,
-        document: LangiumDocument<AstNode>,
-        extraScopes: ScopeProvider[]
-    ) {
-        this.linkReference(node, 'target', document, extraScopes);
-        node.args.forEach((arg) => this.resolve(arg, document, extraScopes));
-
-        if (node.target.ref) {
-            // resolve type
-            if (node.target.ref.$type === EnumField) {
-                this.resolveToBuiltinTypeOrDecl(
-                    node,
-                    node.target.ref.$container
-                );
-            } else {
-                this.resolveToDeclaredType(
-                    node,
-                    (node.target.ref as DataModelField | FunctionParam).type
-                );
-            }
-        }
-    }
-
-    resolveArray(
-        node: ArrayExpr,
-        document: LangiumDocument<AstNode>,
-        extraScopes: ScopeProvider[]
-    ) {
-        node.items.forEach((item) => this.resolve(item, document, extraScopes));
-
-        const itemType = (node.items[0] as TypedNode).$resolvedType;
-        if (itemType?.decl) {
-            this.resolveToBuiltinTypeOrDecl(node, itemType.decl, true);
-        }
-    }
-
-    resolveInvocation(
-        node: InvocationExpr,
-        document: LangiumDocument,
-        extraScopes: ScopeProvider[]
-    ) {
-        this.linkReference(node, 'function', document, extraScopes);
-        node.args.forEach((arg) => this.resolve(arg, document, extraScopes));
-        const funcDecl = node.function.ref as Function;
-        this.resolveToDeclaredType(node, funcDecl.returnType);
-    }
-
-    resolveLiteral(node: LiteralExpr) {
-        const type =
-            typeof node.value === 'string'
-                ? 'String'
-                : typeof node.value === 'boolean'
-                ? 'Boolean'
-                : typeof node.value === 'number'
-                ? 'Int'
-                : undefined;
-
-        if (type) {
-            this.resolveToBuiltinTypeOrDecl(node, type);
-        }
-    }
-
-    resolveMemberAccess(
-        node: MemberAccessExpr,
-        document: LangiumDocument<AstNode>,
-        extraScopes: ScopeProvider[]
-    ) {
-        this.resolve(node.operand, document, extraScopes);
-        const operandResolved = (node.operand as TypedNode).$resolvedType;
-
-        if (
-            operandResolved &&
-            !operandResolved.array &&
-            isDataModel(operandResolved.decl)
-        ) {
-            const modelDecl = operandResolved.decl as DataModel;
-            const provider = (name: string) =>
-                modelDecl.fields.find((f) => f.name === name);
-            extraScopes = [provider, ...extraScopes];
-        }
-
-        this.linkReference(node, 'member', document, extraScopes);
-        if (node.member.ref) {
-            this.resolveToDeclaredType(node, node.member.ref.type);
-        }
-    }
-
-    resolveCollectionPredicate(
-        node: BinaryExpr,
-        document: LangiumDocument,
-        extraScopes: ScopeProvider[]
-    ) {
-        this.resolve(node.left, document, extraScopes);
-
-        const resolvedType = this.getResolvedType(node.left);
-        if (
-            resolvedType &&
-            isDataModel(resolvedType.decl) &&
-            resolvedType.array
-        ) {
-            const dataModelDecl = resolvedType.decl;
-            const provider = (name: string) =>
-                dataModelDecl.fields.find((f) => f.name === name);
-            extraScopes = [provider, ...extraScopes];
-            this.resolve(node.right, document, extraScopes);
-            this.resolveToBuiltinTypeOrDecl(node, 'Boolean');
-        } else {
-            // TODO: how to attach type-checking error?
-            throw new Error(`Unresolved collection predicate`);
-        }
-    }
-
-    resolveThis(
-        node: ThisExpr,
-        document: LangiumDocument<AstNode>,
-        extraScopes: ScopeProvider[]
-    ) {
-        let decl: AstNode | undefined = node.$container;
-
-        while (decl && !isDataModel(decl)) {
-            decl = decl.$container;
-        }
-
-        if (decl) {
-            this.resolveToBuiltinTypeOrDecl(node, decl);
-        }
-    }
-
-    resolveNull(
-        node: NullExpr,
-        document: LangiumDocument<AstNode>,
-        extraScopes: ScopeProvider[]
-    ) {
-        // TODO: how to really resolve null?
-        this.resolveToBuiltinTypeOrDecl(node, 'Null');
-    }
-
-    resolveDefault(
-        node: AstNode,
-        document: LangiumDocument<AstNode>,
-        extraScopes: ScopeProvider[]
-    ) {
-        for (const property of Object.keys(node)) {
-            if (!property.startsWith('$')) {
-                const value = (node as any)[property];
-                if (isReference(value)) {
-                    this.linkReference(node, property, document, extraScopes);
-                }
-            }
-        }
-        for (const child of streamContents(node)) {
-            this.resolve(child, document, extraScopes);
-        }
-    }
-
-    // utils
-
-    getResolvedType(node: AstNode) {
-        return (node as TypedNode).$resolvedType;
-    }
-
-    resolveToDeclaredType(
-        node: AstNode,
-        type: FunctionParamType | DataModelFieldType
-    ) {
-        const _node: TypedNode = node;
-        if (type.type) {
-            _node.$resolvedType = { decl: type.type, array: type.array };
-        } else if (type.reference) {
-            _node.$resolvedType = {
-                decl: type.reference.ref,
-                array: type.array,
-            };
-        }
-    }
-
-    resolveToBuiltinTypeOrDecl(
-        node: AstNode,
-        type: string | AbstractDeclaration,
-        array = false
-    ) {
-        (node as TypedNode).$resolvedType = { decl: type, array };
-    }
-}

package/packages/schema/src/language-server/zmodel-module.ts

@@ -1,90 +0,0 @@
-import {
-    createDefaultModule,
-    createDefaultSharedModule,
-    DefaultSharedModuleContext,
-    inject,
-    LangiumServices,
-    LangiumSharedServices,
-    Module,
-    PartialLangiumServices,
-} from 'langium';
-import {
-    ZModelGeneratedModule,
-    ZModelGeneratedSharedModule,
-} from './generated/module';
-import { ZModelDescriptionProvider } from './zmodel-index';
-import { ZModelLinker } from './zmodel-linker';
-import { ZModelScopeComputation } from './zmodel-scope';
-import { ZModelValidationRegistry, ZModelValidator } from './zmodel-validator';
-
-/**
- * Declaration of custom services - add your own service classes here.
- */
-export type ZModelAddedServices = {
-    validation: {
-        ZModelValidator: ZModelValidator;
-    };
-};
-
-/**
- * Union of Langium default services and your custom services - use this as constructor parameter
- * of custom service classes.
- */
-export type ZModelServices = LangiumServices & ZModelAddedServices;
-
-/**
- * Dependency injection module that overrides Langium default services and contributes the
- * declared custom services. The Langium defaults can be partially specified to override only
- * selected services, while the custom services must be fully specified.
- */
-export const ZModelModule: Module<
-    ZModelServices,
-    PartialLangiumServices & ZModelAddedServices
-> = {
-    references: {
-        ScopeComputation: (services) => new ZModelScopeComputation(services),
-        Linker: (services) => new ZModelLinker(services),
-        // NameProvider: () => new ZModelNameProvider(),
-    },
-    validation: {
-        ValidationRegistry: (services) =>
-            new ZModelValidationRegistry(services),
-        ZModelValidator: () => new ZModelValidator(),
-    },
-    workspace: {
-        AstNodeDescriptionProvider: (services) =>
-            new ZModelDescriptionProvider(services),
-    },
-};
-
-/**
- * Create the full set of services required by Langium.
- *
- * First inject the shared services by merging two modules:
- *  - Langium default shared services
- *  - Services generated by langium-cli
- *
- * Then inject the language-specific services by merging three modules:
- *  - Langium default language-specific services
- *  - Services generated by langium-cli
- *  - Services specified in this file
- *
- * @param context Optional module context with the LSP connection
- * @returns An object wrapping the shared services and the language-specific services
- */
-export function createZModelServices(context?: DefaultSharedModuleContext): {
-    shared: LangiumSharedServices;
-    ZModel: ZModelServices;
-} {
-    const shared = inject(
-        createDefaultSharedModule(context),
-        ZModelGeneratedSharedModule
-    );
-    const ZModel = inject(
-        createDefaultModule({ shared }),
-        ZModelGeneratedModule,
-        ZModelModule
-    );
-    shared.ServiceRegistry.register(ZModel);
-    return { shared, ZModel };
-}

package/packages/schema/src/language-server/zmodel-scope.ts

@@ -1,21 +0,0 @@
-import {
-    DefaultScopeComputation,
-    LangiumDocument,
-    LangiumServices,
-    PrecomputedScopes,
-} from 'langium';
-import { CancellationToken } from 'vscode-jsonrpc';
-
-export class ZModelScopeComputation extends DefaultScopeComputation {
-    constructor(services: LangiumServices) {
-        super(services);
-    }
-
-    async computeScope(
-        document: LangiumDocument,
-        cancelToken = CancellationToken.None
-    ): Promise<PrecomputedScopes> {
-        // Dummy for now
-        return super.computeScope(document, cancelToken);
-    }
-}

package/packages/schema/src/language-server/zmodel-validator.ts

@@ -1,35 +0,0 @@
-import {
-    // ValidationAcceptor,
-    ValidationChecks,
-    ValidationRegistry,
-} from 'langium';
-import { ZModelAstType } from './generated/ast';
-import type { ZModelServices } from './zmodel-module';
-
-/**
- * Registry for validation checks.
- */
-export class ZModelValidationRegistry extends ValidationRegistry {
-    constructor(services: ZModelServices) {
-        super(services);
-        const validator = services.validation.ZModelValidator;
-        const checks: ValidationChecks<ZModelAstType> = {
-            // Person: validator.checkPersonStartsWithCapital
-        };
-        this.register(checks, validator);
-    }
-}
-
-/**
- * Implementation of custom validations.
- */
-export class ZModelValidator {
-    // checkPersonStartsWithCapital(person: Person, accept: ValidationAcceptor): void {
-    //     if (person.name) {
-    //         const firstChar = person.name.substring(0, 1);
-    //         if (firstChar.toUpperCase() !== firstChar) {
-    //             accept('warning', 'Person name should start with a capital.', { node: person, property: 'name' });
-    //         }
-    //     }
-    // }
-}