diff --git a/package.json b/package.json index 613f4bdcb..a4e71f89d 100644 --- a/package.json +++ b/package.json @@ -62,8 +62,7 @@ ], "overrides": { "cookie@<0.7.0": ">=0.7.0", - "lodash-es@>=4.0.0 <=4.17.22": ">=4.17.23", - "lodash@>=4.0.0 <=4.17.22": ">=4.17.23", + "lodash@>=4.0.0 <=4.17.23": ">=4.18.0", "@better-auth/core": "1.4.19" } }, diff --git a/packages/auth-adapters/better-auth/src/schema-generator.ts b/packages/auth-adapters/better-auth/src/schema-generator.ts index dee102dc2..bea59baa8 100644 --- a/packages/auth-adapters/better-auth/src/schema-generator.ts +++ b/packages/auth-adapters/better-auth/src/schema-generator.ts @@ -132,7 +132,7 @@ function addDefaultNow(df: DataField) { } as any; const nowExpr: InvocationExpr = { $type: 'InvocationExpr', - function: { $refText: 'now' }, + function: { $refText: 'now', ref: undefined }, args: [], $container: nowArg, }; @@ -221,6 +221,7 @@ function initializeZmodel(config: AdapterConfig) { $type: 'InvocationExpr', function: { $refText: 'env', + ref: undefined, }, args: [], $container: urlField, @@ -391,6 +392,7 @@ function addOrUpdateModel( $type: 'DataFieldType', reference: { $refText: upperCaseFirst(referencedCustomModelName), + ref: undefined, }, array: (field.type as string).endsWith('[]'), optional: !field.required, @@ -408,6 +410,7 @@ function addOrUpdateModel( $type: 'DataFieldAttribute', decl: { $refText: '@relation', + ref: undefined, }, args: [], $container: relationField, @@ -430,6 +433,7 @@ function addOrUpdateModel( $container: fieldsExpr, target: { $refText: fieldName, + ref: undefined, }, }; fieldsExpr.items.push(fkRefExpr); @@ -452,6 +456,7 @@ function addOrUpdateModel( $container: referencesExpr, target: { $refText: field.references.field, + ref: undefined, }, }; referencesExpr.items.push(pkRefExpr); @@ -465,7 +470,7 @@ function addOrUpdateModel( } as any; const onDeleteValueExpr: ReferenceExpr = { $type: 'ReferenceExpr', - target: { $refText: action }, + target: { $refText: action, ref: undefined }, args: [], $container: onDeleteArg, }; @@ -495,6 +500,7 @@ function addOrUpdateModel( $type: 'DataFieldType', reference: { $refText: relatedModel, + ref: undefined, }, array: true, optional: false, @@ -512,7 +518,7 @@ function addOrUpdateModel( function addModelAttribute(dataModel: DataModel, name: string, args: Omit[] = []) { const attr: DataModelAttribute = { $type: 'DataModelAttribute', - decl: { $refText: name }, + decl: { $refText: name, ref: undefined }, $container: dataModel, args: [], }; @@ -527,7 +533,7 @@ function addModelAttribute(dataModel: DataModel, name: string, args: Omit[] = []) { const attr: DataFieldAttribute = { $type: 'DataFieldAttribute', - decl: { $refText: name }, + decl: { $refText: name, ref: undefined }, $container: dataField, args: [], }; diff --git a/packages/cli/src/actions/check.ts b/packages/cli/src/actions/check.ts index 61f12c57f..c22e65468 100644 --- a/packages/cli/src/actions/check.ts +++ b/packages/cli/src/actions/check.ts @@ -30,7 +30,7 @@ async function checkPluginResolution(schemaFile: string, model: Model) { const provider = getPluginProvider(plugin); if (!provider.startsWith('@core/')) { const pluginSourcePath = - plugin.$cstNode?.parent?.element.$document?.uri?.fsPath ?? schemaFile; + plugin.$cstNode?.container?.astNode.$document?.uri?.fsPath ?? schemaFile; await loadPluginModule(provider, path.dirname(pluginSourcePath)); } } diff --git a/packages/cli/src/actions/db.ts b/packages/cli/src/actions/db.ts index 592f9888d..1a3325d73 100644 --- a/packages/cli/src/actions/db.ts +++ b/packages/cli/src/actions/db.ts @@ -267,7 +267,7 @@ async function runPull(options: PullOptions) { }); // Add/update models and their fields newModel.declarations - .filter((d) => [DataModel, Enum].includes(d.$type)) + .filter((d) => d.$type === DataModel.$type || d.$type === Enum.$type) .forEach((_declaration) => { const newDataModel = _declaration as DataModel | Enum; const declarations = services.shared.workspace.IndexManager.allElements(newDataModel.$type, docsSet).toArray(); diff --git a/packages/cli/src/actions/generate.ts b/packages/cli/src/actions/generate.ts index e65747405..8291d4d9d 100644 --- a/packages/cli/src/actions/generate.ts +++ b/packages/cli/src/actions/generate.ts @@ -63,10 +63,10 @@ export async function run(options: Options) { ( model.declarations.filter( (v) => - v.$cstNode?.parent?.element.$type === 'Model' && - !!v.$cstNode.parent.element.$document?.uri?.fsPath, + v.$cstNode?.container?.astNode.$type === 'Model' && + !!v.$cstNode.container.astNode.$document?.uri?.fsPath, ) as AbstractDeclaration[] - ).map((v) => v.$cstNode!.parent!.element.$document!.uri!.fsPath), + ).map((v) => v.$cstNode!.container!.astNode.$document!.uri!.fsPath), ); const watchedPaths = getRootModelWatchPaths(model); @@ -189,7 +189,7 @@ async function runPlugins(schemaFile: string, model: Model, outputPath: string, // resolve relative plugin paths against the schema file where the plugin is declared, // not the entry schema file const pluginSourcePath = - plugin.$cstNode?.parent?.element.$document?.uri?.fsPath ?? schemaFile; + plugin.$cstNode?.container?.astNode.$document?.uri?.fsPath ?? schemaFile; cliPlugin = await loadPluginModule(provider, path.dirname(pluginSourcePath)); } diff --git a/packages/language/package.json b/packages/language/package.json index fe7c1d818..f0d3667f4 100644 --- a/packages/language/package.json +++ b/packages/language/package.json @@ -81,6 +81,7 @@ "vscode-languageserver": "^9.0.1" }, "devDependencies": { + "@types/node": "catalog:", "@types/pluralize": "^0.0.33", "@types/tmp": "catalog:", "@zenstackhq/eslint-config": "workspace:*", diff --git a/packages/language/src/document.ts b/packages/language/src/document.ts index 87fc48564..dc58f93a7 100644 --- a/packages/language/src/document.ts +++ b/packages/language/src/document.ts @@ -251,7 +251,7 @@ function validationAfterImportMerge(model: Model) { export async function formatDocument(content: string) { const services = createZModelServices().ZModelLanguage; const langiumDocuments = services.shared.workspace.LangiumDocuments; - const document = langiumDocuments.createDocument(URI.parse('memory://schema.zmodel'), content); + const document = langiumDocuments.createDocument(URI.parse('memory:///schema.zmodel'), content); const formatter = services.lsp.Formatter as ZModelFormatter; const identifier = { uri: document.uri.toString() }; const options = formatter.getFormatOptions() ?? { diff --git a/packages/language/src/factory/attribute.ts b/packages/language/src/factory/attribute.ts index b59e35ef1..25bd55bc5 100644 --- a/packages/language/src/factory/attribute.ts +++ b/packages/language/src/factory/attribute.ts @@ -18,7 +18,7 @@ export class DataFieldAttributeFactory extends AstFactory { args: AttributeArgFactory[] = []; decl?: Reference; constructor() { - super({ type: DataFieldAttribute, node: { args: [] } }); + super({ type: DataFieldAttribute.$type, node: { args: [] } }); } setDecl(decl: Attribute) { if (!decl) { @@ -50,7 +50,7 @@ export class DataModelAttributeFactory extends AstFactory { args: AttributeArgFactory[] = []; decl?: Reference; constructor() { - super({ type: DataModelAttribute, node: { args: [] } }); + super({ type: DataModelAttribute.$type, node: { args: [] } }); } setDecl(decl: Attribute) { if (!decl) { @@ -83,7 +83,7 @@ export class AttributeArgFactory extends AstFactory { value?: AstFactory; constructor() { - super({ type: AttributeArg }); + super({ type: AttributeArg.$type }); } setName(name: RegularID) { @@ -108,7 +108,7 @@ export class InternalAttributeFactory extends AstFactory { args: AttributeArgFactory[] = []; constructor() { - super({ type: InternalAttribute, node: { args: [] } }); + super({ type: InternalAttribute.$type, node: { args: [] } }); } setDecl(decl: Attribute) { @@ -144,7 +144,7 @@ export class AttributeParamFactory extends AstFactory { constructor() { super({ - type: AttributeParam, + type: AttributeParam.$type, node: { comments: [], attributes: [], @@ -199,7 +199,7 @@ export class AttributeParamTypeFactory extends AstFactory { reference?: Reference; type?: AttributeParamType['type']; constructor() { - super({ type: AttributeParamType }); + super({ type: AttributeParamType.$type }); } setArray(array: boolean) { this.array = array; @@ -244,7 +244,7 @@ export class AttributeFactory extends AstFactory { params: AttributeParamFactory[] = []; constructor() { - super({ type: Attribute, node: { comments: [], attributes: [], params: [] } }); + super({ type: Attribute.$type, node: { comments: [], attributes: [], params: [] } }); } setName(name: string) { diff --git a/packages/language/src/factory/declaration.ts b/packages/language/src/factory/declaration.ts index a6f772a20..3351f9182 100644 --- a/packages/language/src/factory/declaration.ts +++ b/packages/language/src/factory/declaration.ts @@ -69,7 +69,7 @@ export class DataModelFactory extends AstFactory { constructor() { super({ - type: DataModel, + type: DataModel.$type, node: { attributes: [], comments: [], @@ -151,7 +151,7 @@ export class DataFieldFactory extends AstFactory { type?: DataFieldTypeFactory; constructor() { - super({ type: DataField, node: { attributes: [], comments: [] } }); + super({ type: DataField.$type, node: { attributes: [], comments: [] } }); } addAttribute( @@ -204,7 +204,7 @@ export class DataFieldTypeFactory extends AstFactory { unsupported?: UnsupportedFieldTypeFactory; constructor() { - super({ type: DataFieldType }); + super({ type: DataFieldType.$type }); } setArray(array: boolean) { @@ -254,7 +254,7 @@ export class DataFieldTypeFactory extends AstFactory { export class UnsupportedFieldTypeFactory extends AstFactory { value?: AstFactory; constructor() { - super({ type: UnsupportedFieldType }); + super({ type: UnsupportedFieldType.$type }); } setValue(builder: (value: ExpressionBuilder) => AstFactory) { this.value = builder(ExpressionBuilder()); @@ -269,7 +269,7 @@ export class ModelFactory extends AstFactory { declarations: AstFactory[] = []; imports: ModelImportFactory[] = []; constructor() { - super({ type: Model, node: { declarations: [], imports: [] } }); + super({ type: Model.$type, node: { declarations: [], imports: [] } }); } addImport(builder: (b: ModelImportFactory) => ModelImportFactory) { this.imports.push(builder(new ModelImportFactory()).setContainer(this.node)); @@ -291,7 +291,7 @@ export class ModelImportFactory extends AstFactory { path?: string | undefined; constructor() { - super({ type: ModelImport }); + super({ type: ModelImport.$type }); } setPath(path: string) { @@ -310,7 +310,7 @@ export class EnumFactory extends AstFactory { attributes: DataModelAttributeFactory[] = []; constructor() { - super({ type: Enum, node: { comments: [], fields: [], attributes: [] } }); + super({ type: Enum.$type, node: { comments: [], fields: [], attributes: [] } }); } addField(builder: (b: EnumFieldFactory) => EnumFieldFactory) { @@ -344,7 +344,7 @@ export class EnumFieldFactory extends AstFactory { attributes: DataFieldAttributeFactory[] = []; constructor() { - super({ type: EnumField, node: { comments: [], attributes: [] } }); + super({ type: EnumField.$type, node: { comments: [], attributes: [] } }); } setName(name: RegularIDWithTypeNames) { diff --git a/packages/language/src/factory/expression.ts b/packages/language/src/factory/expression.ts index 19fe16af1..fee479b8b 100644 --- a/packages/language/src/factory/expression.ts +++ b/packages/language/src/factory/expression.ts @@ -79,7 +79,7 @@ export class UnaryExprFactory extends AstFactory { operand?: AstFactory; constructor() { - super({ type: UnaryExpr, node: { operator: '!' } }); + super({ type: UnaryExpr.$type, node: { operator: '!' } }); } setOperand(builder: (a: ExpressionBuilder) => AstFactory) { @@ -96,7 +96,7 @@ export class ReferenceExprFactory extends AstFactory { args: ReferenceArgFactory[] = []; constructor() { - super({ type: ReferenceExpr, node: { args: [] } }); + super({ type: ReferenceExpr.$type, node: { args: [] } }); } setTarget(target: ReferenceTarget) { @@ -128,7 +128,7 @@ export class ReferenceArgFactory extends AstFactory { value?: AstFactory; constructor() { - super({ type: ReferenceArg }); + super({ type: ReferenceArg.$type }); } setName(name: string) { @@ -153,7 +153,7 @@ export class MemberAccessExprFactory extends AstFactory { operand?: AstFactory; constructor() { - super({ type: MemberAccessExpr }); + super({ type: MemberAccessExpr.$type }); } setMember(target: Reference) { @@ -177,7 +177,7 @@ export class ObjectExprFactory extends AstFactory { fields: FieldInitializerFactory[] = []; constructor() { - super({ type: ObjectExpr, node: { fields: [] } }); + super({ type: ObjectExpr.$type, node: { fields: [] } }); } addField(builder: (b: FieldInitializerFactory) => FieldInitializerFactory) { @@ -194,7 +194,7 @@ export class FieldInitializerFactory extends AstFactory { value?: AstFactory; constructor() { - super({ type: FieldInitializer }); + super({ type: FieldInitializer.$type }); } setName(name: RegularID) { @@ -219,7 +219,7 @@ export class InvocationExprFactory extends AstFactory { function?: Reference; constructor() { - super({ type: InvocationExpr, node: { args: [] } }); + super({ type: InvocationExpr.$type, node: { args: [] } }); } addArg(builder: (arg: ArgumentFactory) => ArgumentFactory) { @@ -246,7 +246,7 @@ export class ArgumentFactory extends AstFactory { value?: AstFactory; constructor() { - super({ type: Argument }); + super({ type: Argument.$type }); } setValue(builder: (a: ExpressionBuilder) => AstFactory) { @@ -262,7 +262,7 @@ export class ArrayExprFactory extends AstFactory { items: AstFactory[] = []; constructor() { - super({ type: ArrayExpr, node: { items: [] } }); + super({ type: ArrayExpr.$type, node: { items: [] } }); } addItem(builder: (a: ExpressionBuilder) => AstFactory) { @@ -281,7 +281,7 @@ export class BinaryExprFactory extends AstFactory { // TODO: add support for CollectionPredicateBinding constructor() { - super({ type: BinaryExpr }); + super({ type: BinaryExpr.$type }); } setOperator(operator: BinaryExpr['operator']) { diff --git a/packages/language/src/factory/primitives.ts b/packages/language/src/factory/primitives.ts index e97310d54..276ebaf8e 100644 --- a/packages/language/src/factory/primitives.ts +++ b/packages/language/src/factory/primitives.ts @@ -3,13 +3,13 @@ import { BooleanLiteral, NullExpr, NumberLiteral, StringLiteral, ThisExpr } from export class ThisExprFactory extends AstFactory { constructor() { - super({ type: ThisExpr, node: { value: 'this' } }); + super({ type: ThisExpr.$type, node: { value: 'this' } }); } } export class NullExprFactory extends AstFactory { constructor() { - super({ type: NullExpr, node: { value: 'null' } }); + super({ type: NullExpr.$type, node: { value: 'null' } }); } } @@ -17,7 +17,7 @@ export class NumberLiteralFactory extends AstFactory { value?: number | string; constructor() { - super({ type: NumberLiteral }); + super({ type: NumberLiteral.$type }); } setValue(value: number | string) { @@ -33,7 +33,7 @@ export class StringLiteralFactory extends AstFactory { value?: string; constructor() { - super({ type: StringLiteral }); + super({ type: StringLiteral.$type }); } setValue(value: string) { @@ -48,7 +48,7 @@ export class BooleanLiteralFactory extends AstFactory { value?: boolean; constructor() { - super({ type: BooleanLiteral }); + super({ type: BooleanLiteral.$type }); } setValue(value: boolean) { diff --git a/packages/language/src/generated/ast.ts b/packages/language/src/generated/ast.ts index 97431eccf..8609927f4 100644 --- a/packages/language/src/generated/ast.ts +++ b/packages/language/src/generated/ast.ts @@ -1,5 +1,5 @@ /****************************************************************************** - * This file was generated by langium-cli 3.5.0. + * This file was generated by langium-cli 4.2.1. * DO NOT EDIT MANUALLY! ******************************************************************************/ @@ -88,88 +88,12 @@ export type ZModelTokenNames = ZModelTerminalNames | ZModelKeywordNames; export type AbstractDeclaration = Attribute | DataModel | DataSource | Enum | FunctionDecl | GeneratorDecl | Plugin | Procedure | TypeDef; -export const AbstractDeclaration = 'AbstractDeclaration'; +export const AbstractDeclaration = { + $type: 'AbstractDeclaration' +} as const; export function isAbstractDeclaration(item: unknown): item is AbstractDeclaration { - return reflection.isInstance(item, AbstractDeclaration); -} - -export type Boolean = boolean; - -export function isBoolean(item: unknown): item is Boolean { - return typeof item === 'boolean'; -} - -export type BuiltinType = 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'String'; - -export function isBuiltinType(item: unknown): item is BuiltinType { - return item === 'String' || item === 'Boolean' || item === 'Int' || item === 'BigInt' || item === 'Float' || item === 'Decimal' || item === 'DateTime' || item === 'Json' || item === 'Bytes'; -} - -export type ConfigExpr = ConfigArrayExpr | InvocationExpr | LiteralExpr; - -export const ConfigExpr = 'ConfigExpr'; - -export function isConfigExpr(item: unknown): item is ConfigExpr { - return reflection.isInstance(item, ConfigExpr); -} - -export type Expression = ArrayExpr | BinaryExpr | InvocationExpr | LiteralExpr | MemberAccessExpr | NullExpr | ObjectExpr | ReferenceExpr | ThisExpr | UnaryExpr; - -export const Expression = 'Expression'; - -export function isExpression(item: unknown): item is Expression { - return reflection.isInstance(item, Expression); -} - -export type ExpressionType = 'Any' | 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'Null' | 'Object' | 'String' | 'Undefined' | 'Unsupported' | 'Void'; - -export function isExpressionType(item: unknown): item is ExpressionType { - return item === 'String' || item === 'Int' || item === 'Float' || item === 'Boolean' || item === 'BigInt' || item === 'Decimal' || item === 'DateTime' || item === 'Json' || item === 'Bytes' || item === 'Null' || item === 'Object' || item === 'Any' || item === 'Void' || item === 'Undefined' || item === 'Unsupported'; -} - -export type LiteralExpr = BooleanLiteral | NumberLiteral | StringLiteral; - -export const LiteralExpr = 'LiteralExpr'; - -export function isLiteralExpr(item: unknown): item is LiteralExpr { - return reflection.isInstance(item, LiteralExpr); -} - -export type MemberAccessTarget = DataField; - -export const MemberAccessTarget = 'MemberAccessTarget'; - -export function isMemberAccessTarget(item: unknown): item is MemberAccessTarget { - return reflection.isInstance(item, MemberAccessTarget); -} - -export type ReferenceTarget = CollectionPredicateBinding | DataField | EnumField | FunctionParam; - -export const ReferenceTarget = 'ReferenceTarget'; - -export function isReferenceTarget(item: unknown): item is ReferenceTarget { - return reflection.isInstance(item, ReferenceTarget); -} - -export type RegularID = 'abstract' | 'attribute' | 'datasource' | 'enum' | 'import' | 'in' | 'model' | 'plugin' | 'type' | 'view' | string; - -export function isRegularID(item: unknown): item is RegularID { - return item === 'model' || item === 'enum' || item === 'attribute' || item === 'datasource' || item === 'plugin' || item === 'abstract' || item === 'in' || item === 'view' || item === 'import' || item === 'type' || (typeof item === 'string' && (/[_a-zA-Z][\w_]*/.test(item))); -} - -export type RegularIDWithTypeNames = 'Any' | 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'Null' | 'Object' | 'String' | 'Unsupported' | 'Void' | RegularID; - -export function isRegularIDWithTypeNames(item: unknown): item is RegularIDWithTypeNames { - return isRegularID(item) || item === 'String' || item === 'Boolean' || item === 'Int' || item === 'BigInt' || item === 'Float' || item === 'Decimal' || item === 'DateTime' || item === 'Json' || item === 'Bytes' || item === 'Null' || item === 'Object' || item === 'Any' || item === 'Void' || item === 'Unsupported'; -} - -export type TypeDeclaration = DataModel | Enum | TypeDef; - -export const TypeDeclaration = 'TypeDeclaration'; - -export function isTypeDeclaration(item: unknown): item is TypeDeclaration { - return reflection.isInstance(item, TypeDeclaration); + return reflection.isInstance(item, AbstractDeclaration.$type); } export interface Argument extends langium.AstNode { @@ -178,10 +102,13 @@ export interface Argument extends langium.AstNode { value: Expression; } -export const Argument = 'Argument'; +export const Argument = { + $type: 'Argument', + value: 'value' +} as const; export function isArgument(item: unknown): item is Argument { - return reflection.isInstance(item, Argument); + return reflection.isInstance(item, Argument.$type); } export interface ArrayExpr extends langium.AstNode { @@ -190,10 +117,13 @@ export interface ArrayExpr extends langium.AstNode { items: Array; } -export const ArrayExpr = 'ArrayExpr'; +export const ArrayExpr = { + $type: 'ArrayExpr', + items: 'items' +} as const; export function isArrayExpr(item: unknown): item is ArrayExpr { - return reflection.isInstance(item, ArrayExpr); + return reflection.isInstance(item, ArrayExpr.$type); } export interface Attribute extends langium.AstNode { @@ -205,10 +135,16 @@ export interface Attribute extends langium.AstNode { params: Array; } -export const Attribute = 'Attribute'; +export const Attribute = { + $type: 'Attribute', + attributes: 'attributes', + comments: 'comments', + name: 'name', + params: 'params' +} as const; export function isAttribute(item: unknown): item is Attribute { - return reflection.isInstance(item, Attribute); + return reflection.isInstance(item, Attribute.$type); } export interface AttributeArg extends langium.AstNode { @@ -220,10 +156,14 @@ export interface AttributeArg extends langium.AstNode { $resolvedParam?: AttributeParam; } -export const AttributeArg = 'AttributeArg'; +export const AttributeArg = { + $type: 'AttributeArg', + name: 'name', + value: 'value' +} as const; export function isAttributeArg(item: unknown): item is AttributeArg { - return reflection.isInstance(item, AttributeArg); + return reflection.isInstance(item, AttributeArg.$type); } export interface AttributeParam extends langium.AstNode { @@ -236,10 +176,17 @@ export interface AttributeParam extends langium.AstNode { type: AttributeParamType; } -export const AttributeParam = 'AttributeParam'; +export const AttributeParam = { + $type: 'AttributeParam', + attributes: 'attributes', + comments: 'comments', + default: 'default', + name: 'name', + type: 'type' +} as const; export function isAttributeParam(item: unknown): item is AttributeParam { - return reflection.isInstance(item, AttributeParam); + return reflection.isInstance(item, AttributeParam.$type); } export interface AttributeParamType extends langium.AstNode { @@ -251,10 +198,16 @@ export interface AttributeParamType extends langium.AstNode { type?: 'ContextType' | 'FieldReference' | 'TransitiveFieldReference' | ExpressionType; } -export const AttributeParamType = 'AttributeParamType'; +export const AttributeParamType = { + $type: 'AttributeParamType', + array: 'array', + optional: 'optional', + reference: 'reference', + type: 'type' +} as const; export function isAttributeParamType(item: unknown): item is AttributeParamType { - return reflection.isInstance(item, AttributeParamType); + return reflection.isInstance(item, AttributeParamType.$type); } export interface BinaryExpr extends langium.AstNode { @@ -266,10 +219,22 @@ export interface BinaryExpr extends langium.AstNode { right: Expression; } -export const BinaryExpr = 'BinaryExpr'; +export const BinaryExpr = { + $type: 'BinaryExpr', + binding: 'binding', + left: 'left', + operator: 'operator', + right: 'right' +} as const; export function isBinaryExpr(item: unknown): item is BinaryExpr { - return reflection.isInstance(item, BinaryExpr); + return reflection.isInstance(item, BinaryExpr.$type); +} + +export type Boolean = boolean; + +export function isBoolean(item: unknown): item is Boolean { + return typeof item === 'boolean'; } export interface BooleanLiteral extends langium.AstNode { @@ -278,10 +243,19 @@ export interface BooleanLiteral extends langium.AstNode { value: Boolean; } -export const BooleanLiteral = 'BooleanLiteral'; +export const BooleanLiteral = { + $type: 'BooleanLiteral', + value: 'value' +} as const; export function isBooleanLiteral(item: unknown): item is BooleanLiteral { - return reflection.isInstance(item, BooleanLiteral); + return reflection.isInstance(item, BooleanLiteral.$type); +} + +export type BuiltinType = 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'String'; + +export function isBuiltinType(item: unknown): item is BuiltinType { + return item === 'String' || item === 'Boolean' || item === 'Int' || item === 'BigInt' || item === 'Float' || item === 'Decimal' || item === 'DateTime' || item === 'Json' || item === 'Bytes'; } export interface CollectionPredicateBinding extends langium.AstNode { @@ -290,10 +264,13 @@ export interface CollectionPredicateBinding extends langium.AstNode { name: RegularID; } -export const CollectionPredicateBinding = 'CollectionPredicateBinding'; +export const CollectionPredicateBinding = { + $type: 'CollectionPredicateBinding', + name: 'name' +} as const; export function isCollectionPredicateBinding(item: unknown): item is CollectionPredicateBinding { - return reflection.isInstance(item, CollectionPredicateBinding); + return reflection.isInstance(item, CollectionPredicateBinding.$type); } export interface ConfigArrayExpr extends langium.AstNode { @@ -302,10 +279,23 @@ export interface ConfigArrayExpr extends langium.AstNode { items: Array; } -export const ConfigArrayExpr = 'ConfigArrayExpr'; +export const ConfigArrayExpr = { + $type: 'ConfigArrayExpr', + items: 'items' +} as const; export function isConfigArrayExpr(item: unknown): item is ConfigArrayExpr { - return reflection.isInstance(item, ConfigArrayExpr); + return reflection.isInstance(item, ConfigArrayExpr.$type); +} + +export type ConfigExpr = ConfigArrayExpr | InvocationExpr | LiteralExpr; + +export const ConfigExpr = { + $type: 'ConfigExpr' +} as const; + +export function isConfigExpr(item: unknown): item is ConfigExpr { + return reflection.isInstance(item, ConfigExpr.$type); } export interface ConfigField extends langium.AstNode { @@ -315,10 +305,14 @@ export interface ConfigField extends langium.AstNode { value: ConfigExpr; } -export const ConfigField = 'ConfigField'; +export const ConfigField = { + $type: 'ConfigField', + name: 'name', + value: 'value' +} as const; export function isConfigField(item: unknown): item is ConfigField { - return reflection.isInstance(item, ConfigField); + return reflection.isInstance(item, ConfigField.$type); } export interface ConfigInvocationArg extends langium.AstNode { @@ -328,10 +322,14 @@ export interface ConfigInvocationArg extends langium.AstNode { value: LiteralExpr; } -export const ConfigInvocationArg = 'ConfigInvocationArg'; +export const ConfigInvocationArg = { + $type: 'ConfigInvocationArg', + name: 'name', + value: 'value' +} as const; export function isConfigInvocationArg(item: unknown): item is ConfigInvocationArg { - return reflection.isInstance(item, ConfigInvocationArg); + return reflection.isInstance(item, ConfigInvocationArg.$type); } export interface ConfigInvocationExpr extends langium.AstNode { @@ -341,10 +339,14 @@ export interface ConfigInvocationExpr extends langium.AstNode { name: string; } -export const ConfigInvocationExpr = 'ConfigInvocationExpr'; +export const ConfigInvocationExpr = { + $type: 'ConfigInvocationExpr', + args: 'args', + name: 'name' +} as const; export function isConfigInvocationExpr(item: unknown): item is ConfigInvocationExpr { - return reflection.isInstance(item, ConfigInvocationExpr); + return reflection.isInstance(item, ConfigInvocationExpr.$type); } export interface DataField extends langium.AstNode { @@ -356,10 +358,16 @@ export interface DataField extends langium.AstNode { type: DataFieldType; } -export const DataField = 'DataField'; +export const DataField = { + $type: 'DataField', + attributes: 'attributes', + comments: 'comments', + name: 'name', + type: 'type' +} as const; export function isDataField(item: unknown): item is DataField { - return reflection.isInstance(item, DataField); + return reflection.isInstance(item, DataField.$type); } export interface DataFieldAttribute extends langium.AstNode { @@ -369,10 +377,14 @@ export interface DataFieldAttribute extends langium.AstNode { decl: langium.Reference; } -export const DataFieldAttribute = 'DataFieldAttribute'; +export const DataFieldAttribute = { + $type: 'DataFieldAttribute', + args: 'args', + decl: 'decl' +} as const; export function isDataFieldAttribute(item: unknown): item is DataFieldAttribute { - return reflection.isInstance(item, DataFieldAttribute); + return reflection.isInstance(item, DataFieldAttribute.$type); } export interface DataFieldType extends langium.AstNode { @@ -385,10 +397,17 @@ export interface DataFieldType extends langium.AstNode { unsupported?: UnsupportedFieldType; } -export const DataFieldType = 'DataFieldType'; +export const DataFieldType = { + $type: 'DataFieldType', + array: 'array', + optional: 'optional', + reference: 'reference', + type: 'type', + unsupported: 'unsupported' +} as const; export function isDataFieldType(item: unknown): item is DataFieldType { - return reflection.isInstance(item, DataFieldType); + return reflection.isInstance(item, DataFieldType.$type); } export interface DataModel extends langium.AstNode { @@ -405,10 +424,19 @@ export interface DataModel extends langium.AstNode { $allFields?: DataField[]; } -export const DataModel = 'DataModel'; +export const DataModel = { + $type: 'DataModel', + attributes: 'attributes', + baseModel: 'baseModel', + comments: 'comments', + fields: 'fields', + isView: 'isView', + mixins: 'mixins', + name: 'name' +} as const; export function isDataModel(item: unknown): item is DataModel { - return reflection.isInstance(item, DataModel); + return reflection.isInstance(item, DataModel.$type); } export interface DataModelAttribute extends langium.AstNode { @@ -418,10 +446,14 @@ export interface DataModelAttribute extends langium.AstNode { decl: langium.Reference; } -export const DataModelAttribute = 'DataModelAttribute'; +export const DataModelAttribute = { + $type: 'DataModelAttribute', + args: 'args', + decl: 'decl' +} as const; export function isDataModelAttribute(item: unknown): item is DataModelAttribute { - return reflection.isInstance(item, DataModelAttribute); + return reflection.isInstance(item, DataModelAttribute.$type); } export interface DataSource extends langium.AstNode { @@ -431,10 +463,14 @@ export interface DataSource extends langium.AstNode { name: RegularID; } -export const DataSource = 'DataSource'; +export const DataSource = { + $type: 'DataSource', + fields: 'fields', + name: 'name' +} as const; export function isDataSource(item: unknown): item is DataSource { - return reflection.isInstance(item, DataSource); + return reflection.isInstance(item, DataSource.$type); } export interface Enum extends langium.AstNode { @@ -446,10 +482,16 @@ export interface Enum extends langium.AstNode { name: RegularID; } -export const Enum = 'Enum'; +export const Enum = { + $type: 'Enum', + attributes: 'attributes', + comments: 'comments', + fields: 'fields', + name: 'name' +} as const; export function isEnum(item: unknown): item is Enum { - return reflection.isInstance(item, Enum); + return reflection.isInstance(item, Enum.$type); } export interface EnumField extends langium.AstNode { @@ -460,10 +502,31 @@ export interface EnumField extends langium.AstNode { name: RegularIDWithTypeNames; } -export const EnumField = 'EnumField'; +export const EnumField = { + $type: 'EnumField', + attributes: 'attributes', + comments: 'comments', + name: 'name' +} as const; export function isEnumField(item: unknown): item is EnumField { - return reflection.isInstance(item, EnumField); + return reflection.isInstance(item, EnumField.$type); +} + +export type Expression = ArrayExpr | BinaryExpr | InvocationExpr | LiteralExpr | MemberAccessExpr | NullExpr | ObjectExpr | ReferenceExpr | ThisExpr | UnaryExpr; + +export const Expression = { + $type: 'Expression' +} as const; + +export function isExpression(item: unknown): item is Expression { + return reflection.isInstance(item, Expression.$type); +} + +export type ExpressionType = 'Any' | 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'Null' | 'Object' | 'String' | 'Undefined' | 'Unsupported' | 'Void'; + +export function isExpressionType(item: unknown): item is ExpressionType { + return item === 'String' || item === 'Int' || item === 'Float' || item === 'Boolean' || item === 'BigInt' || item === 'Decimal' || item === 'DateTime' || item === 'Json' || item === 'Bytes' || item === 'Null' || item === 'Object' || item === 'Any' || item === 'Void' || item === 'Undefined' || item === 'Unsupported'; } export interface FieldInitializer extends langium.AstNode { @@ -473,10 +536,14 @@ export interface FieldInitializer extends langium.AstNode { value: Expression; } -export const FieldInitializer = 'FieldInitializer'; +export const FieldInitializer = { + $type: 'FieldInitializer', + name: 'name', + value: 'value' +} as const; export function isFieldInitializer(item: unknown): item is FieldInitializer { - return reflection.isInstance(item, FieldInitializer); + return reflection.isInstance(item, FieldInitializer.$type); } export interface FunctionDecl extends langium.AstNode { @@ -489,10 +556,17 @@ export interface FunctionDecl extends langium.AstNode { returnType: FunctionParamType; } -export const FunctionDecl = 'FunctionDecl'; +export const FunctionDecl = { + $type: 'FunctionDecl', + attributes: 'attributes', + expression: 'expression', + name: 'name', + params: 'params', + returnType: 'returnType' +} as const; export function isFunctionDecl(item: unknown): item is FunctionDecl { - return reflection.isInstance(item, FunctionDecl); + return reflection.isInstance(item, FunctionDecl.$type); } export interface FunctionParam extends langium.AstNode { @@ -503,10 +577,15 @@ export interface FunctionParam extends langium.AstNode { type: FunctionParamType; } -export const FunctionParam = 'FunctionParam'; +export const FunctionParam = { + $type: 'FunctionParam', + name: 'name', + optional: 'optional', + type: 'type' +} as const; export function isFunctionParam(item: unknown): item is FunctionParam { - return reflection.isInstance(item, FunctionParam); + return reflection.isInstance(item, FunctionParam.$type); } export interface FunctionParamType extends langium.AstNode { @@ -517,10 +596,15 @@ export interface FunctionParamType extends langium.AstNode { type?: ExpressionType; } -export const FunctionParamType = 'FunctionParamType'; +export const FunctionParamType = { + $type: 'FunctionParamType', + array: 'array', + reference: 'reference', + type: 'type' +} as const; export function isFunctionParamType(item: unknown): item is FunctionParamType { - return reflection.isInstance(item, FunctionParamType); + return reflection.isInstance(item, FunctionParamType.$type); } export interface GeneratorDecl extends langium.AstNode { @@ -530,10 +614,14 @@ export interface GeneratorDecl extends langium.AstNode { name: RegularID; } -export const GeneratorDecl = 'GeneratorDecl'; +export const GeneratorDecl = { + $type: 'GeneratorDecl', + fields: 'fields', + name: 'name' +} as const; export function isGeneratorDecl(item: unknown): item is GeneratorDecl { - return reflection.isInstance(item, GeneratorDecl); + return reflection.isInstance(item, GeneratorDecl.$type); } export interface InternalAttribute extends langium.AstNode { @@ -543,10 +631,14 @@ export interface InternalAttribute extends langium.AstNode { decl: langium.Reference; } -export const InternalAttribute = 'InternalAttribute'; +export const InternalAttribute = { + $type: 'InternalAttribute', + args: 'args', + decl: 'decl' +} as const; export function isInternalAttribute(item: unknown): item is InternalAttribute { - return reflection.isInstance(item, InternalAttribute); + return reflection.isInstance(item, InternalAttribute.$type); } export interface InvocationExpr extends langium.AstNode { @@ -556,10 +648,24 @@ export interface InvocationExpr extends langium.AstNode { function: langium.Reference; } -export const InvocationExpr = 'InvocationExpr'; +export const InvocationExpr = { + $type: 'InvocationExpr', + args: 'args', + function: 'function' +} as const; export function isInvocationExpr(item: unknown): item is InvocationExpr { - return reflection.isInstance(item, InvocationExpr); + return reflection.isInstance(item, InvocationExpr.$type); +} + +export type LiteralExpr = BooleanLiteral | NumberLiteral | StringLiteral; + +export const LiteralExpr = { + $type: 'LiteralExpr' +} as const; + +export function isLiteralExpr(item: unknown): item is LiteralExpr { + return reflection.isInstance(item, LiteralExpr.$type); } export interface MemberAccessExpr extends langium.AstNode { @@ -569,10 +675,24 @@ export interface MemberAccessExpr extends langium.AstNode { operand: Expression; } -export const MemberAccessExpr = 'MemberAccessExpr'; +export const MemberAccessExpr = { + $type: 'MemberAccessExpr', + member: 'member', + operand: 'operand' +} as const; export function isMemberAccessExpr(item: unknown): item is MemberAccessExpr { - return reflection.isInstance(item, MemberAccessExpr); + return reflection.isInstance(item, MemberAccessExpr.$type); +} + +export type MemberAccessTarget = DataField; + +export const MemberAccessTarget = { + $type: 'MemberAccessTarget' +} as const; + +export function isMemberAccessTarget(item: unknown): item is MemberAccessTarget { + return reflection.isInstance(item, MemberAccessTarget.$type); } export interface Model extends langium.AstNode { @@ -581,10 +701,14 @@ export interface Model extends langium.AstNode { imports: Array; } -export const Model = 'Model'; +export const Model = { + $type: 'Model', + declarations: 'declarations', + imports: 'imports' +} as const; export function isModel(item: unknown): item is Model { - return reflection.isInstance(item, Model); + return reflection.isInstance(item, Model.$type); } export interface ModelImport extends langium.AstNode { @@ -593,10 +717,13 @@ export interface ModelImport extends langium.AstNode { path: string; } -export const ModelImport = 'ModelImport'; +export const ModelImport = { + $type: 'ModelImport', + path: 'path' +} as const; export function isModelImport(item: unknown): item is ModelImport { - return reflection.isInstance(item, ModelImport); + return reflection.isInstance(item, ModelImport.$type); } export interface NullExpr extends langium.AstNode { @@ -605,10 +732,13 @@ export interface NullExpr extends langium.AstNode { value: 'null'; } -export const NullExpr = 'NullExpr'; +export const NullExpr = { + $type: 'NullExpr', + value: 'value' +} as const; export function isNullExpr(item: unknown): item is NullExpr { - return reflection.isInstance(item, NullExpr); + return reflection.isInstance(item, NullExpr.$type); } export interface NumberLiteral extends langium.AstNode { @@ -617,10 +747,13 @@ export interface NumberLiteral extends langium.AstNode { value: string; } -export const NumberLiteral = 'NumberLiteral'; +export const NumberLiteral = { + $type: 'NumberLiteral', + value: 'value' +} as const; export function isNumberLiteral(item: unknown): item is NumberLiteral { - return reflection.isInstance(item, NumberLiteral); + return reflection.isInstance(item, NumberLiteral.$type); } export interface ObjectExpr extends langium.AstNode { @@ -629,10 +762,13 @@ export interface ObjectExpr extends langium.AstNode { fields: Array; } -export const ObjectExpr = 'ObjectExpr'; +export const ObjectExpr = { + $type: 'ObjectExpr', + fields: 'fields' +} as const; export function isObjectExpr(item: unknown): item is ObjectExpr { - return reflection.isInstance(item, ObjectExpr); + return reflection.isInstance(item, ObjectExpr.$type); } export interface Plugin extends langium.AstNode { @@ -642,10 +778,14 @@ export interface Plugin extends langium.AstNode { name: RegularID; } -export const Plugin = 'Plugin'; +export const Plugin = { + $type: 'Plugin', + fields: 'fields', + name: 'name' +} as const; export function isPlugin(item: unknown): item is Plugin { - return reflection.isInstance(item, Plugin); + return reflection.isInstance(item, Plugin.$type); } export interface PluginField extends langium.AstNode { @@ -655,10 +795,14 @@ export interface PluginField extends langium.AstNode { value: ArrayExpr | LiteralExpr | ObjectExpr; } -export const PluginField = 'PluginField'; +export const PluginField = { + $type: 'PluginField', + name: 'name', + value: 'value' +} as const; export function isPluginField(item: unknown): item is PluginField { - return reflection.isInstance(item, PluginField); + return reflection.isInstance(item, PluginField.$type); } export interface Procedure extends langium.AstNode { @@ -671,10 +815,17 @@ export interface Procedure extends langium.AstNode { returnType: FunctionParamType; } -export const Procedure = 'Procedure'; +export const Procedure = { + $type: 'Procedure', + attributes: 'attributes', + mutation: 'mutation', + name: 'name', + params: 'params', + returnType: 'returnType' +} as const; export function isProcedure(item: unknown): item is Procedure { - return reflection.isInstance(item, Procedure); + return reflection.isInstance(item, Procedure.$type); } export interface ProcedureParam extends langium.AstNode { @@ -685,10 +836,15 @@ export interface ProcedureParam extends langium.AstNode { type: FunctionParamType; } -export const ProcedureParam = 'ProcedureParam'; +export const ProcedureParam = { + $type: 'ProcedureParam', + name: 'name', + optional: 'optional', + type: 'type' +} as const; export function isProcedureParam(item: unknown): item is ProcedureParam { - return reflection.isInstance(item, ProcedureParam); + return reflection.isInstance(item, ProcedureParam.$type); } export interface ReferenceArg extends langium.AstNode { @@ -698,10 +854,14 @@ export interface ReferenceArg extends langium.AstNode { value: Expression; } -export const ReferenceArg = 'ReferenceArg'; +export const ReferenceArg = { + $type: 'ReferenceArg', + name: 'name', + value: 'value' +} as const; export function isReferenceArg(item: unknown): item is ReferenceArg { - return reflection.isInstance(item, ReferenceArg); + return reflection.isInstance(item, ReferenceArg.$type); } export interface ReferenceExpr extends langium.AstNode { @@ -711,10 +871,36 @@ export interface ReferenceExpr extends langium.AstNode { target: langium.Reference; } -export const ReferenceExpr = 'ReferenceExpr'; +export const ReferenceExpr = { + $type: 'ReferenceExpr', + args: 'args', + target: 'target' +} as const; export function isReferenceExpr(item: unknown): item is ReferenceExpr { - return reflection.isInstance(item, ReferenceExpr); + return reflection.isInstance(item, ReferenceExpr.$type); +} + +export type ReferenceTarget = CollectionPredicateBinding | DataField | EnumField | FunctionParam; + +export const ReferenceTarget = { + $type: 'ReferenceTarget' +} as const; + +export function isReferenceTarget(item: unknown): item is ReferenceTarget { + return reflection.isInstance(item, ReferenceTarget.$type); +} + +export type RegularID = 'abstract' | 'attribute' | 'datasource' | 'enum' | 'import' | 'in' | 'model' | 'plugin' | 'type' | 'view' | string; + +export function isRegularID(item: unknown): item is RegularID { + return item === 'model' || item === 'enum' || item === 'attribute' || item === 'datasource' || item === 'plugin' || item === 'abstract' || item === 'in' || item === 'view' || item === 'import' || item === 'type' || (typeof item === 'string' && (/[_a-zA-Z][\w_]*/.test(item))); +} + +export type RegularIDWithTypeNames = 'Any' | 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'Null' | 'Object' | 'String' | 'Unsupported' | 'Void' | RegularID; + +export function isRegularIDWithTypeNames(item: unknown): item is RegularIDWithTypeNames { + return isRegularID(item) || item === 'String' || item === 'Boolean' || item === 'Int' || item === 'BigInt' || item === 'Float' || item === 'Decimal' || item === 'DateTime' || item === 'Json' || item === 'Bytes' || item === 'Null' || item === 'Object' || item === 'Any' || item === 'Void' || item === 'Unsupported'; } export interface StringLiteral extends langium.AstNode { @@ -723,10 +909,13 @@ export interface StringLiteral extends langium.AstNode { value: string; } -export const StringLiteral = 'StringLiteral'; +export const StringLiteral = { + $type: 'StringLiteral', + value: 'value' +} as const; export function isStringLiteral(item: unknown): item is StringLiteral { - return reflection.isInstance(item, StringLiteral); + return reflection.isInstance(item, StringLiteral.$type); } export interface ThisExpr extends langium.AstNode { @@ -735,10 +924,23 @@ export interface ThisExpr extends langium.AstNode { value: 'this'; } -export const ThisExpr = 'ThisExpr'; +export const ThisExpr = { + $type: 'ThisExpr', + value: 'value' +} as const; export function isThisExpr(item: unknown): item is ThisExpr { - return reflection.isInstance(item, ThisExpr); + return reflection.isInstance(item, ThisExpr.$type); +} + +export type TypeDeclaration = DataModel | Enum | TypeDef; + +export const TypeDeclaration = { + $type: 'TypeDeclaration' +} as const; + +export function isTypeDeclaration(item: unknown): item is TypeDeclaration { + return reflection.isInstance(item, TypeDeclaration.$type); } export interface TypeDef extends langium.AstNode { @@ -751,10 +953,17 @@ export interface TypeDef extends langium.AstNode { name: RegularID; } -export const TypeDef = 'TypeDef'; +export const TypeDef = { + $type: 'TypeDef', + attributes: 'attributes', + comments: 'comments', + fields: 'fields', + mixins: 'mixins', + name: 'name' +} as const; export function isTypeDef(item: unknown): item is TypeDef { - return reflection.isInstance(item, TypeDef); + return reflection.isInstance(item, TypeDef.$type); } export interface UnaryExpr extends langium.AstNode { @@ -764,10 +973,14 @@ export interface UnaryExpr extends langium.AstNode { operator: '!'; } -export const UnaryExpr = 'UnaryExpr'; +export const UnaryExpr = { + $type: 'UnaryExpr', + operand: 'operand', + operator: 'operator' +} as const; export function isUnaryExpr(item: unknown): item is UnaryExpr { - return reflection.isInstance(item, UnaryExpr); + return reflection.isInstance(item, UnaryExpr.$type); } export interface UnsupportedFieldType extends langium.AstNode { @@ -776,10 +989,13 @@ export interface UnsupportedFieldType extends langium.AstNode { value: LiteralExpr; } -export const UnsupportedFieldType = 'UnsupportedFieldType'; +export const UnsupportedFieldType = { + $type: 'UnsupportedFieldType', + value: 'value' +} as const; export function isUnsupportedFieldType(item: unknown): item is UnsupportedFieldType { - return reflection.isInstance(item, UnsupportedFieldType); + return reflection.isInstance(item, UnsupportedFieldType.$type); } export type ZModelAstType = { @@ -838,534 +1054,716 @@ export type ZModelAstType = { } export class ZModelAstReflection extends langium.AbstractAstReflection { - - getAllTypes(): string[] { - return [AbstractDeclaration, Argument, ArrayExpr, Attribute, AttributeArg, AttributeParam, AttributeParamType, BinaryExpr, BooleanLiteral, CollectionPredicateBinding, ConfigArrayExpr, ConfigExpr, ConfigField, ConfigInvocationArg, ConfigInvocationExpr, DataField, DataFieldAttribute, DataFieldType, DataModel, DataModelAttribute, DataSource, Enum, EnumField, Expression, FieldInitializer, FunctionDecl, FunctionParam, FunctionParamType, GeneratorDecl, InternalAttribute, InvocationExpr, LiteralExpr, MemberAccessExpr, MemberAccessTarget, Model, ModelImport, NullExpr, NumberLiteral, ObjectExpr, Plugin, PluginField, Procedure, ProcedureParam, ReferenceArg, ReferenceExpr, ReferenceTarget, StringLiteral, ThisExpr, TypeDeclaration, TypeDef, UnaryExpr, UnsupportedFieldType]; - } - - protected override computeIsSubtype(subtype: string, supertype: string): boolean { - switch (subtype) { - case ArrayExpr: - case BinaryExpr: - case MemberAccessExpr: - case NullExpr: - case ObjectExpr: - case ReferenceExpr: - case ThisExpr: - case UnaryExpr: { - return this.isSubtype(Expression, supertype); - } - case Attribute: - case DataSource: - case FunctionDecl: - case GeneratorDecl: - case Plugin: - case Procedure: { - return this.isSubtype(AbstractDeclaration, supertype); - } - case BooleanLiteral: - case NumberLiteral: - case StringLiteral: { - return this.isSubtype(LiteralExpr, supertype); - } - case CollectionPredicateBinding: - case EnumField: - case FunctionParam: { - return this.isSubtype(ReferenceTarget, supertype); - } - case ConfigArrayExpr: { - return this.isSubtype(ConfigExpr, supertype); - } - case DataField: { - return this.isSubtype(MemberAccessTarget, supertype) || this.isSubtype(ReferenceTarget, supertype); - } - case DataModel: - case Enum: - case TypeDef: { - return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype); - } - case InvocationExpr: - case LiteralExpr: { - return this.isSubtype(ConfigExpr, supertype) || this.isSubtype(Expression, supertype); - } - default: { - return false; - } - } - } - - getReferenceType(refInfo: langium.ReferenceInfo): string { - const referenceId = `${refInfo.container.$type}:${refInfo.property}`; - switch (referenceId) { - case 'AttributeParamType:reference': - case 'DataFieldType:reference': - case 'FunctionParamType:reference': { - return TypeDeclaration; - } - case 'DataFieldAttribute:decl': - case 'DataModelAttribute:decl': - case 'InternalAttribute:decl': { - return Attribute; - } - case 'DataModel:baseModel': { - return DataModel; - } - case 'DataModel:mixins': - case 'TypeDef:mixins': { - return TypeDef; - } - case 'InvocationExpr:function': { - return FunctionDecl; - } - case 'MemberAccessExpr:member': { - return MemberAccessTarget; - } - case 'ReferenceExpr:target': { - return ReferenceTarget; - } - default: { - throw new Error(`${referenceId} is not a valid reference id.`); - } - } - } - - getTypeMetaData(type: string): langium.TypeMetaData { - switch (type) { - case Argument: { - return { - name: Argument, - properties: [ - { name: 'value' } - ] - }; - } - case ArrayExpr: { - return { - name: ArrayExpr, - properties: [ - { name: 'items', defaultValue: [] } - ] - }; - } - case Attribute: { - return { - name: Attribute, - properties: [ - { name: 'attributes', defaultValue: [] }, - { name: 'comments', defaultValue: [] }, - { name: 'name' }, - { name: 'params', defaultValue: [] } - ] - }; - } - case AttributeArg: { - return { - name: AttributeArg, - properties: [ - { name: 'name' }, - { name: 'value' } - ] - }; - } - case AttributeParam: { - return { - name: AttributeParam, - properties: [ - { name: 'attributes', defaultValue: [] }, - { name: 'comments', defaultValue: [] }, - { name: 'default', defaultValue: false }, - { name: 'name' }, - { name: 'type' } - ] - }; - } - case AttributeParamType: { - return { - name: AttributeParamType, - properties: [ - { name: 'array', defaultValue: false }, - { name: 'optional', defaultValue: false }, - { name: 'reference' }, - { name: 'type' } - ] - }; - } - case BinaryExpr: { - return { - name: BinaryExpr, - properties: [ - { name: 'binding' }, - { name: 'left' }, - { name: 'operator' }, - { name: 'right' } - ] - }; - } - case BooleanLiteral: { - return { - name: BooleanLiteral, - properties: [ - { name: 'value' } - ] - }; - } - case CollectionPredicateBinding: { - return { - name: CollectionPredicateBinding, - properties: [ - { name: 'name' } - ] - }; - } - case ConfigArrayExpr: { - return { - name: ConfigArrayExpr, - properties: [ - { name: 'items', defaultValue: [] } - ] - }; - } - case ConfigField: { - return { - name: ConfigField, - properties: [ - { name: 'name' }, - { name: 'value' } - ] - }; - } - case ConfigInvocationArg: { - return { - name: ConfigInvocationArg, - properties: [ - { name: 'name' }, - { name: 'value' } - ] - }; - } - case ConfigInvocationExpr: { - return { - name: ConfigInvocationExpr, - properties: [ - { name: 'args', defaultValue: [] }, - { name: 'name' } - ] - }; - } - case DataField: { - return { - name: DataField, - properties: [ - { name: 'attributes', defaultValue: [] }, - { name: 'comments', defaultValue: [] }, - { name: 'name' }, - { name: 'type' } - ] - }; - } - case DataFieldAttribute: { - return { - name: DataFieldAttribute, - properties: [ - { name: 'args', defaultValue: [] }, - { name: 'decl' } - ] - }; - } - case DataFieldType: { - return { - name: DataFieldType, - properties: [ - { name: 'array', defaultValue: false }, - { name: 'optional', defaultValue: false }, - { name: 'reference' }, - { name: 'type' }, - { name: 'unsupported' } - ] - }; - } - case DataModel: { - return { - name: DataModel, - properties: [ - { name: 'attributes', defaultValue: [] }, - { name: 'baseModel' }, - { name: 'comments', defaultValue: [] }, - { name: 'fields', defaultValue: [] }, - { name: 'isView', defaultValue: false }, - { name: 'mixins', defaultValue: [] }, - { name: 'name' } - ] - }; - } - case DataModelAttribute: { - return { - name: DataModelAttribute, - properties: [ - { name: 'args', defaultValue: [] }, - { name: 'decl' } - ] - }; - } - case DataSource: { - return { - name: DataSource, - properties: [ - { name: 'fields', defaultValue: [] }, - { name: 'name' } - ] - }; - } - case Enum: { - return { - name: Enum, - properties: [ - { name: 'attributes', defaultValue: [] }, - { name: 'comments', defaultValue: [] }, - { name: 'fields', defaultValue: [] }, - { name: 'name' } - ] - }; - } - case EnumField: { - return { - name: EnumField, - properties: [ - { name: 'attributes', defaultValue: [] }, - { name: 'comments', defaultValue: [] }, - { name: 'name' } - ] - }; - } - case FieldInitializer: { - return { - name: FieldInitializer, - properties: [ - { name: 'name' }, - { name: 'value' } - ] - }; - } - case FunctionDecl: { - return { - name: FunctionDecl, - properties: [ - { name: 'attributes', defaultValue: [] }, - { name: 'expression' }, - { name: 'name' }, - { name: 'params', defaultValue: [] }, - { name: 'returnType' } - ] - }; - } - case FunctionParam: { - return { - name: FunctionParam, - properties: [ - { name: 'name' }, - { name: 'optional', defaultValue: false }, - { name: 'type' } - ] - }; - } - case FunctionParamType: { - return { - name: FunctionParamType, - properties: [ - { name: 'array', defaultValue: false }, - { name: 'reference' }, - { name: 'type' } - ] - }; - } - case GeneratorDecl: { - return { - name: GeneratorDecl, - properties: [ - { name: 'fields', defaultValue: [] }, - { name: 'name' } - ] - }; - } - case InternalAttribute: { - return { - name: InternalAttribute, - properties: [ - { name: 'args', defaultValue: [] }, - { name: 'decl' } - ] - }; - } - case InvocationExpr: { - return { - name: InvocationExpr, - properties: [ - { name: 'args', defaultValue: [] }, - { name: 'function' } - ] - }; - } - case MemberAccessExpr: { - return { - name: MemberAccessExpr, - properties: [ - { name: 'member' }, - { name: 'operand' } - ] - }; - } - case Model: { - return { - name: Model, - properties: [ - { name: 'declarations', defaultValue: [] }, - { name: 'imports', defaultValue: [] } - ] - }; - } - case ModelImport: { - return { - name: ModelImport, - properties: [ - { name: 'path' } - ] - }; - } - case NullExpr: { - return { - name: NullExpr, - properties: [ - { name: 'value' } - ] - }; - } - case NumberLiteral: { - return { - name: NumberLiteral, - properties: [ - { name: 'value' } - ] - }; - } - case ObjectExpr: { - return { - name: ObjectExpr, - properties: [ - { name: 'fields', defaultValue: [] } - ] - }; - } - case Plugin: { - return { - name: Plugin, - properties: [ - { name: 'fields', defaultValue: [] }, - { name: 'name' } - ] - }; - } - case PluginField: { - return { - name: PluginField, - properties: [ - { name: 'name' }, - { name: 'value' } - ] - }; - } - case Procedure: { - return { - name: Procedure, - properties: [ - { name: 'attributes', defaultValue: [] }, - { name: 'mutation', defaultValue: false }, - { name: 'name' }, - { name: 'params', defaultValue: [] }, - { name: 'returnType' } - ] - }; - } - case ProcedureParam: { - return { - name: ProcedureParam, - properties: [ - { name: 'name' }, - { name: 'optional', defaultValue: false }, - { name: 'type' } - ] - }; - } - case ReferenceArg: { - return { - name: ReferenceArg, - properties: [ - { name: 'name' }, - { name: 'value' } - ] - }; - } - case ReferenceExpr: { - return { - name: ReferenceExpr, - properties: [ - { name: 'args', defaultValue: [] }, - { name: 'target' } - ] - }; - } - case StringLiteral: { - return { - name: StringLiteral, - properties: [ - { name: 'value' } - ] - }; - } - case ThisExpr: { - return { - name: ThisExpr, - properties: [ - { name: 'value' } - ] - }; - } - case TypeDef: { - return { - name: TypeDef, - properties: [ - { name: 'attributes', defaultValue: [] }, - { name: 'comments', defaultValue: [] }, - { name: 'fields', defaultValue: [] }, - { name: 'mixins', defaultValue: [] }, - { name: 'name' } - ] - }; - } - case UnaryExpr: { - return { - name: UnaryExpr, - properties: [ - { name: 'operand' }, - { name: 'operator' } - ] - }; - } - case UnsupportedFieldType: { - return { - name: UnsupportedFieldType, - properties: [ - { name: 'value' } - ] - }; - } - default: { - return { - name: type, - properties: [] - }; - } + override readonly types = { + AbstractDeclaration: { + name: AbstractDeclaration.$type, + properties: { + }, + superTypes: [] + }, + Argument: { + name: Argument.$type, + properties: { + value: { + name: Argument.value + } + }, + superTypes: [] + }, + ArrayExpr: { + name: ArrayExpr.$type, + properties: { + items: { + name: ArrayExpr.items, + defaultValue: [] + } + }, + superTypes: [Expression.$type] + }, + Attribute: { + name: Attribute.$type, + properties: { + attributes: { + name: Attribute.attributes, + defaultValue: [] + }, + comments: { + name: Attribute.comments, + defaultValue: [] + }, + name: { + name: Attribute.name + }, + params: { + name: Attribute.params, + defaultValue: [] + } + }, + superTypes: [AbstractDeclaration.$type] + }, + AttributeArg: { + name: AttributeArg.$type, + properties: { + name: { + name: AttributeArg.name + }, + value: { + name: AttributeArg.value + } + }, + superTypes: [] + }, + AttributeParam: { + name: AttributeParam.$type, + properties: { + attributes: { + name: AttributeParam.attributes, + defaultValue: [] + }, + comments: { + name: AttributeParam.comments, + defaultValue: [] + }, + default: { + name: AttributeParam.default, + defaultValue: false + }, + name: { + name: AttributeParam.name + }, + type: { + name: AttributeParam.type + } + }, + superTypes: [] + }, + AttributeParamType: { + name: AttributeParamType.$type, + properties: { + array: { + name: AttributeParamType.array, + defaultValue: false + }, + optional: { + name: AttributeParamType.optional, + defaultValue: false + }, + reference: { + name: AttributeParamType.reference, + referenceType: TypeDeclaration.$type + }, + type: { + name: AttributeParamType.type + } + }, + superTypes: [] + }, + BinaryExpr: { + name: BinaryExpr.$type, + properties: { + binding: { + name: BinaryExpr.binding + }, + left: { + name: BinaryExpr.left + }, + operator: { + name: BinaryExpr.operator + }, + right: { + name: BinaryExpr.right + } + }, + superTypes: [Expression.$type] + }, + BooleanLiteral: { + name: BooleanLiteral.$type, + properties: { + value: { + name: BooleanLiteral.value + } + }, + superTypes: [LiteralExpr.$type] + }, + CollectionPredicateBinding: { + name: CollectionPredicateBinding.$type, + properties: { + name: { + name: CollectionPredicateBinding.name + } + }, + superTypes: [ReferenceTarget.$type] + }, + ConfigArrayExpr: { + name: ConfigArrayExpr.$type, + properties: { + items: { + name: ConfigArrayExpr.items, + defaultValue: [] + } + }, + superTypes: [ConfigExpr.$type] + }, + ConfigExpr: { + name: ConfigExpr.$type, + properties: { + }, + superTypes: [] + }, + ConfigField: { + name: ConfigField.$type, + properties: { + name: { + name: ConfigField.name + }, + value: { + name: ConfigField.value + } + }, + superTypes: [] + }, + ConfigInvocationArg: { + name: ConfigInvocationArg.$type, + properties: { + name: { + name: ConfigInvocationArg.name + }, + value: { + name: ConfigInvocationArg.value + } + }, + superTypes: [] + }, + ConfigInvocationExpr: { + name: ConfigInvocationExpr.$type, + properties: { + args: { + name: ConfigInvocationExpr.args, + defaultValue: [] + }, + name: { + name: ConfigInvocationExpr.name + } + }, + superTypes: [] + }, + DataField: { + name: DataField.$type, + properties: { + attributes: { + name: DataField.attributes, + defaultValue: [] + }, + comments: { + name: DataField.comments, + defaultValue: [] + }, + name: { + name: DataField.name + }, + type: { + name: DataField.type + } + }, + superTypes: [MemberAccessTarget.$type, ReferenceTarget.$type] + }, + DataFieldAttribute: { + name: DataFieldAttribute.$type, + properties: { + args: { + name: DataFieldAttribute.args, + defaultValue: [] + }, + decl: { + name: DataFieldAttribute.decl, + referenceType: Attribute.$type + } + }, + superTypes: [] + }, + DataFieldType: { + name: DataFieldType.$type, + properties: { + array: { + name: DataFieldType.array, + defaultValue: false + }, + optional: { + name: DataFieldType.optional, + defaultValue: false + }, + reference: { + name: DataFieldType.reference, + referenceType: TypeDeclaration.$type + }, + type: { + name: DataFieldType.type + }, + unsupported: { + name: DataFieldType.unsupported + } + }, + superTypes: [] + }, + DataModel: { + name: DataModel.$type, + properties: { + attributes: { + name: DataModel.attributes, + defaultValue: [] + }, + baseModel: { + name: DataModel.baseModel, + referenceType: DataModel.$type + }, + comments: { + name: DataModel.comments, + defaultValue: [] + }, + fields: { + name: DataModel.fields, + defaultValue: [] + }, + isView: { + name: DataModel.isView, + defaultValue: false + }, + mixins: { + name: DataModel.mixins, + defaultValue: [], + referenceType: TypeDef.$type + }, + name: { + name: DataModel.name + } + }, + superTypes: [AbstractDeclaration.$type, TypeDeclaration.$type] + }, + DataModelAttribute: { + name: DataModelAttribute.$type, + properties: { + args: { + name: DataModelAttribute.args, + defaultValue: [] + }, + decl: { + name: DataModelAttribute.decl, + referenceType: Attribute.$type + } + }, + superTypes: [] + }, + DataSource: { + name: DataSource.$type, + properties: { + fields: { + name: DataSource.fields, + defaultValue: [] + }, + name: { + name: DataSource.name + } + }, + superTypes: [AbstractDeclaration.$type] + }, + Enum: { + name: Enum.$type, + properties: { + attributes: { + name: Enum.attributes, + defaultValue: [] + }, + comments: { + name: Enum.comments, + defaultValue: [] + }, + fields: { + name: Enum.fields, + defaultValue: [] + }, + name: { + name: Enum.name + } + }, + superTypes: [AbstractDeclaration.$type, TypeDeclaration.$type] + }, + EnumField: { + name: EnumField.$type, + properties: { + attributes: { + name: EnumField.attributes, + defaultValue: [] + }, + comments: { + name: EnumField.comments, + defaultValue: [] + }, + name: { + name: EnumField.name + } + }, + superTypes: [ReferenceTarget.$type] + }, + Expression: { + name: Expression.$type, + properties: { + }, + superTypes: [] + }, + FieldInitializer: { + name: FieldInitializer.$type, + properties: { + name: { + name: FieldInitializer.name + }, + value: { + name: FieldInitializer.value + } + }, + superTypes: [] + }, + FunctionDecl: { + name: FunctionDecl.$type, + properties: { + attributes: { + name: FunctionDecl.attributes, + defaultValue: [] + }, + expression: { + name: FunctionDecl.expression + }, + name: { + name: FunctionDecl.name + }, + params: { + name: FunctionDecl.params, + defaultValue: [] + }, + returnType: { + name: FunctionDecl.returnType + } + }, + superTypes: [AbstractDeclaration.$type] + }, + FunctionParam: { + name: FunctionParam.$type, + properties: { + name: { + name: FunctionParam.name + }, + optional: { + name: FunctionParam.optional, + defaultValue: false + }, + type: { + name: FunctionParam.type + } + }, + superTypes: [ReferenceTarget.$type] + }, + FunctionParamType: { + name: FunctionParamType.$type, + properties: { + array: { + name: FunctionParamType.array, + defaultValue: false + }, + reference: { + name: FunctionParamType.reference, + referenceType: TypeDeclaration.$type + }, + type: { + name: FunctionParamType.type + } + }, + superTypes: [] + }, + GeneratorDecl: { + name: GeneratorDecl.$type, + properties: { + fields: { + name: GeneratorDecl.fields, + defaultValue: [] + }, + name: { + name: GeneratorDecl.name + } + }, + superTypes: [AbstractDeclaration.$type] + }, + InternalAttribute: { + name: InternalAttribute.$type, + properties: { + args: { + name: InternalAttribute.args, + defaultValue: [] + }, + decl: { + name: InternalAttribute.decl, + referenceType: Attribute.$type + } + }, + superTypes: [] + }, + InvocationExpr: { + name: InvocationExpr.$type, + properties: { + args: { + name: InvocationExpr.args, + defaultValue: [] + }, + function: { + name: InvocationExpr.function, + referenceType: FunctionDecl.$type + } + }, + superTypes: [ConfigExpr.$type, Expression.$type] + }, + LiteralExpr: { + name: LiteralExpr.$type, + properties: { + }, + superTypes: [ConfigExpr.$type, Expression.$type] + }, + MemberAccessExpr: { + name: MemberAccessExpr.$type, + properties: { + member: { + name: MemberAccessExpr.member, + referenceType: MemberAccessTarget.$type + }, + operand: { + name: MemberAccessExpr.operand + } + }, + superTypes: [Expression.$type] + }, + MemberAccessTarget: { + name: MemberAccessTarget.$type, + properties: { + }, + superTypes: [] + }, + Model: { + name: Model.$type, + properties: { + declarations: { + name: Model.declarations, + defaultValue: [] + }, + imports: { + name: Model.imports, + defaultValue: [] + } + }, + superTypes: [] + }, + ModelImport: { + name: ModelImport.$type, + properties: { + path: { + name: ModelImport.path + } + }, + superTypes: [] + }, + NullExpr: { + name: NullExpr.$type, + properties: { + value: { + name: NullExpr.value + } + }, + superTypes: [Expression.$type] + }, + NumberLiteral: { + name: NumberLiteral.$type, + properties: { + value: { + name: NumberLiteral.value + } + }, + superTypes: [LiteralExpr.$type] + }, + ObjectExpr: { + name: ObjectExpr.$type, + properties: { + fields: { + name: ObjectExpr.fields, + defaultValue: [] + } + }, + superTypes: [Expression.$type] + }, + Plugin: { + name: Plugin.$type, + properties: { + fields: { + name: Plugin.fields, + defaultValue: [] + }, + name: { + name: Plugin.name + } + }, + superTypes: [AbstractDeclaration.$type] + }, + PluginField: { + name: PluginField.$type, + properties: { + name: { + name: PluginField.name + }, + value: { + name: PluginField.value + } + }, + superTypes: [] + }, + Procedure: { + name: Procedure.$type, + properties: { + attributes: { + name: Procedure.attributes, + defaultValue: [] + }, + mutation: { + name: Procedure.mutation, + defaultValue: false + }, + name: { + name: Procedure.name + }, + params: { + name: Procedure.params, + defaultValue: [] + }, + returnType: { + name: Procedure.returnType + } + }, + superTypes: [AbstractDeclaration.$type] + }, + ProcedureParam: { + name: ProcedureParam.$type, + properties: { + name: { + name: ProcedureParam.name + }, + optional: { + name: ProcedureParam.optional, + defaultValue: false + }, + type: { + name: ProcedureParam.type + } + }, + superTypes: [] + }, + ReferenceArg: { + name: ReferenceArg.$type, + properties: { + name: { + name: ReferenceArg.name + }, + value: { + name: ReferenceArg.value + } + }, + superTypes: [] + }, + ReferenceExpr: { + name: ReferenceExpr.$type, + properties: { + args: { + name: ReferenceExpr.args, + defaultValue: [] + }, + target: { + name: ReferenceExpr.target, + referenceType: ReferenceTarget.$type + } + }, + superTypes: [Expression.$type] + }, + ReferenceTarget: { + name: ReferenceTarget.$type, + properties: { + }, + superTypes: [] + }, + StringLiteral: { + name: StringLiteral.$type, + properties: { + value: { + name: StringLiteral.value + } + }, + superTypes: [LiteralExpr.$type] + }, + ThisExpr: { + name: ThisExpr.$type, + properties: { + value: { + name: ThisExpr.value + } + }, + superTypes: [Expression.$type] + }, + TypeDeclaration: { + name: TypeDeclaration.$type, + properties: { + }, + superTypes: [] + }, + TypeDef: { + name: TypeDef.$type, + properties: { + attributes: { + name: TypeDef.attributes, + defaultValue: [] + }, + comments: { + name: TypeDef.comments, + defaultValue: [] + }, + fields: { + name: TypeDef.fields, + defaultValue: [] + }, + mixins: { + name: TypeDef.mixins, + defaultValue: [], + referenceType: TypeDef.$type + }, + name: { + name: TypeDef.name + } + }, + superTypes: [AbstractDeclaration.$type, TypeDeclaration.$type] + }, + UnaryExpr: { + name: UnaryExpr.$type, + properties: { + operand: { + name: UnaryExpr.operand + }, + operator: { + name: UnaryExpr.operator + } + }, + superTypes: [Expression.$type] + }, + UnsupportedFieldType: { + name: UnsupportedFieldType.$type, + properties: { + value: { + name: UnsupportedFieldType.value + } + }, + superTypes: [] } - } + } as const satisfies langium.AstMetaData } export const reflection = new ZModelAstReflection(); diff --git a/packages/language/src/generated/grammar.ts b/packages/language/src/generated/grammar.ts index 925d4dcb6..27385931e 100644 --- a/packages/language/src/generated/grammar.ts +++ b/packages/language/src/generated/grammar.ts @@ -1,5 +1,5 @@ /****************************************************************************** - * This file was generated by langium-cli 3.5.0. + * This file was generated by langium-cli 4.2.1. * DO NOT EDIT MANUALLY! ******************************************************************************/ @@ -47,11 +47,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -82,12 +79,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -160,12 +154,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -220,12 +211,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -280,12 +268,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -331,12 +316,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -391,12 +373,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -461,12 +440,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -478,12 +454,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel }, "arguments": [] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -500,12 +473,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "arguments": [] } }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -522,12 +492,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "arguments": [] } }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -544,12 +511,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "arguments": [] } }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -580,12 +544,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -643,12 +604,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -692,12 +650,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -742,11 +697,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -784,12 +736,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -871,12 +820,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -907,12 +853,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -926,12 +869,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "value": "this" } }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -945,12 +885,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "value": "null" } }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -974,7 +911,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel }, "arguments": [] }, - "deprecatedSyntax": false + "deprecatedSyntax": false, + "isMulti": false } }, { @@ -1000,12 +938,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1050,11 +985,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1092,12 +1024,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1160,12 +1089,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1215,12 +1141,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1237,7 +1160,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "type": { "$ref": "#/rules@47" }, - "deprecatedSyntax": false + "deprecatedSyntax": false, + "isMulti": false } }, { @@ -1258,12 +1182,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1310,7 +1231,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "type": { "$ref": "#/types@1" }, - "deprecatedSyntax": false + "deprecatedSyntax": false, + "isMulti": false } } ] @@ -1320,12 +1242,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1356,12 +1275,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1461,12 +1377,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1483,12 +1396,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "arguments": [] } }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1545,12 +1455,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1624,12 +1531,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1695,12 +1599,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1766,12 +1667,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1861,12 +1759,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1911,11 +1806,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -1932,12 +1824,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "arguments": [] } }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2108,12 +1997,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2135,7 +2021,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "type": { "$ref": "#/rules@43" }, - "deprecatedSyntax": false + "deprecatedSyntax": false, + "isMulti": false } }, { @@ -2155,7 +2042,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "type": { "$ref": "#/rules@43" }, - "deprecatedSyntax": false + "deprecatedSyntax": false, + "isMulti": false } } ], @@ -2163,11 +2051,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2189,16 +2074,14 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "type": { "$ref": "#/rules@38" }, - "deprecatedSyntax": false + "deprecatedSyntax": false, + "isMulti": false } } ] }, - "definesHiddenTokens": false, "entry": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2258,12 +2141,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2314,7 +2194,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel }, "arguments": [] }, - "deprecatedSyntax": false + "deprecatedSyntax": false, + "isMulti": false } } ] @@ -2350,12 +2231,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2440,12 +2318,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2479,12 +2354,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2561,12 +2433,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2614,12 +2483,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2751,12 +2617,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2812,12 +2675,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2856,7 +2716,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel }, "arguments": [] }, - "deprecatedSyntax": false + "deprecatedSyntax": false, + "isMulti": false } } ] @@ -2882,12 +2743,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -2943,12 +2801,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3069,12 +2924,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3132,12 +2984,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3211,12 +3060,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3335,12 +3181,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3414,12 +3257,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3475,7 +3315,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel }, "arguments": [] }, - "deprecatedSyntax": false + "deprecatedSyntax": false, + "isMulti": false } } ] @@ -3511,12 +3352,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3540,7 +3378,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel }, "arguments": [] }, - "deprecatedSyntax": false + "deprecatedSyntax": false, + "isMulti": false } }, { @@ -3567,12 +3406,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3604,7 +3440,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel }, "arguments": [] }, - "deprecatedSyntax": false + "deprecatedSyntax": false, + "isMulti": false } }, { @@ -3631,12 +3468,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3660,7 +3494,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel }, "arguments": [] }, - "deprecatedSyntax": false + "deprecatedSyntax": false, + "isMulti": false } }, { @@ -3687,12 +3522,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3737,11 +3569,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3785,12 +3614,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3861,12 +3687,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3913,12 +3736,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "ParserRule", @@ -3937,12 +3757,9 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } ] }, - "definesHiddenTokens": false, "entry": false, "fragment": false, - "hiddenTokens": [], - "parameters": [], - "wildcard": false + "parameters": [] }, { "$type": "TerminalRule", @@ -3950,7 +3767,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "name": "WS", "definition": { "$type": "RegexToken", - "regex": "/\\\\s+/" + "regex": "/\\\\s+/", + "parenthesized": false }, "fragment": false }, @@ -3959,7 +3777,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "name": "INTERNAL_ATTRIBUTE_NAME", "definition": { "$type": "RegexToken", - "regex": "/@@@([_a-zA-Z][\\\\w_]*\\\\.)*[_a-zA-Z][\\\\w_]*/" + "regex": "/@@@([_a-zA-Z][\\\\w_]*\\\\.)*[_a-zA-Z][\\\\w_]*/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -3969,7 +3788,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "name": "MODEL_ATTRIBUTE_NAME", "definition": { "$type": "RegexToken", - "regex": "/@@([_a-zA-Z][\\\\w_]*\\\\.)*[_a-zA-Z][\\\\w_]*/" + "regex": "/@@([_a-zA-Z][\\\\w_]*\\\\.)*[_a-zA-Z][\\\\w_]*/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -3979,7 +3799,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "name": "FIELD_ATTRIBUTE_NAME", "definition": { "$type": "RegexToken", - "regex": "/@([_a-zA-Z][\\\\w_]*\\\\.)*[_a-zA-Z][\\\\w_]*/" + "regex": "/@([_a-zA-Z][\\\\w_]*\\\\.)*[_a-zA-Z][\\\\w_]*/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -3989,7 +3810,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "name": "ID", "definition": { "$type": "RegexToken", - "regex": "/[_a-zA-Z][\\\\w_]*/" + "regex": "/[_a-zA-Z][\\\\w_]*/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -3999,7 +3821,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "name": "STRING", "definition": { "$type": "RegexToken", - "regex": "/\\"(\\\\\\\\.|[^\\"\\\\\\\\])*\\"|'(\\\\\\\\.|[^'\\\\\\\\])*'/" + "regex": "/\\"(\\\\\\\\.|[^\\"\\\\\\\\])*\\"|'(\\\\\\\\.|[^'\\\\\\\\])*'/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -4009,7 +3832,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "name": "NUMBER", "definition": { "$type": "RegexToken", - "regex": "/[+-]?[0-9]+(\\\\.[0-9]+)?/" + "regex": "/[+-]?[0-9]+(\\\\.[0-9]+)?/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -4019,7 +3843,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "name": "TRIPLE_SLASH_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\/\\\\/[^\\\\n\\\\r]*/" + "regex": "/\\\\/\\\\/\\\\/[^\\\\n\\\\r]*/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -4030,7 +3855,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "name": "ML_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//" + "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//", + "parenthesized": false }, "fragment": false }, @@ -4040,7 +3866,8 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel "name": "SL_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/" + "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/", + "parenthesized": false }, "fragment": false } @@ -4117,9 +3944,6 @@ export const ZModelGrammar = (): Grammar => loadedZModelGrammar ?? (loadedZModel } } ], - "definesHiddenTokens": false, - "hiddenTokens": [], "imports": [], - "interfaces": [], - "usedGrammars": [] + "interfaces": [] }`)); diff --git a/packages/language/src/generated/module.ts b/packages/language/src/generated/module.ts index 0c621d00c..bc468edcf 100644 --- a/packages/language/src/generated/module.ts +++ b/packages/language/src/generated/module.ts @@ -1,5 +1,5 @@ /****************************************************************************** - * This file was generated by langium-cli 3.5.0. + * This file was generated by langium-cli 4.2.1. * DO NOT EDIT MANUALLY! ******************************************************************************/ diff --git a/packages/language/src/zmodel-code-generator.ts b/packages/language/src/zmodel-code-generator.ts index e68ba7735..b4f61e9f4 100644 --- a/packages/language/src/zmodel-code-generator.ts +++ b/packages/language/src/zmodel-code-generator.ts @@ -57,10 +57,10 @@ export interface ZModelCodeOptions { const generationHandlers = new Map(); // generation handler decorator -function gen(name: string) { +function gen(type: { $type: string }) { return function (_target: unknown, _propertyKey: string, descriptor: PropertyDescriptor) { - if (!generationHandlers.get(name)) { - generationHandlers.set(name, descriptor); + if (!generationHandlers.get(type.$type)) { + generationHandlers.set(type.$type, descriptor); } return descriptor; }; @@ -407,7 +407,7 @@ ${ast.fields.map((x) => this.indent + this.generate(x)).join('\n')}${ const currentPriority = BinaryExprOperatorPriority[operator]; if ( - ast.left.$type === BinaryExpr && + ast.left.$type === BinaryExpr.$type && BinaryExprOperatorPriority[(ast.left as BinaryExpr)['operator']] < currentPriority ) { result.left = true; @@ -418,7 +418,7 @@ ${ast.fields.map((x) => this.indent + this.generate(x)).join('\n')}${ **/ if ( !isCollectionPredicate && - ast.right.$type === BinaryExpr && + ast.right.$type === BinaryExpr.$type && BinaryExprOperatorPriority[(ast.right as BinaryExpr)['operator']] <= currentPriority ) { result.right = true; diff --git a/packages/language/src/zmodel-linker.ts b/packages/language/src/zmodel-linker.ts index fc3a7f0dd..6766a6afc 100644 --- a/packages/language/src/zmodel-linker.ts +++ b/packages/language/src/zmodel-linker.ts @@ -101,7 +101,7 @@ export class ZModelLinker extends DefaultLinker { // already linked return; } - if (this.resolveFromScopeProviders(refInfo.reference, document, extraScopes)) { + if (this.resolveFromScopeProviders(defaultRef, document, extraScopes)) { // resolved from additional scope provider return; } @@ -135,57 +135,57 @@ export class ZModelLinker extends DefaultLinker { private resolve(node: AstNode, document: LangiumDocument, extraScopes: ScopeProvider[] = []) { switch (node.$type) { - case StringLiteral: - case NumberLiteral: - case BooleanLiteral: + case StringLiteral.$type: + case NumberLiteral.$type: + case BooleanLiteral.$type: this.resolveLiteral(node as LiteralExpr); break; - case InvocationExpr: + case InvocationExpr.$type: this.resolveInvocation(node as InvocationExpr, document, extraScopes); break; - case ArrayExpr: + case ArrayExpr.$type: this.resolveArray(node as ArrayExpr, document, extraScopes); break; - case ReferenceExpr: + case ReferenceExpr.$type: this.resolveReference(node as ReferenceExpr, document, extraScopes); break; - case MemberAccessExpr: + case MemberAccessExpr.$type: this.resolveMemberAccess(node as MemberAccessExpr, document, extraScopes); break; - case UnaryExpr: + case UnaryExpr.$type: this.resolveUnary(node as UnaryExpr, document, extraScopes); break; - case BinaryExpr: + case BinaryExpr.$type: this.resolveBinary(node as BinaryExpr, document, extraScopes); break; - case ObjectExpr: + case ObjectExpr.$type: this.resolveObject(node as ObjectExpr, document, extraScopes); break; - case ThisExpr: + case ThisExpr.$type: this.resolveThis(node as ThisExpr, document, extraScopes); break; - case NullExpr: + case NullExpr.$type: this.resolveNull(node as NullExpr, document, extraScopes); break; - case AttributeArg: + case AttributeArg.$type: this.resolveAttributeArg(node as AttributeArg, document, extraScopes); break; - case DataModel: + case DataModel.$type: this.resolveDataModel(node as DataModel, document, extraScopes); break; - case DataField: + case DataField.$type: this.resolveDataField(node as DataField, document, extraScopes); break; diff --git a/packages/language/src/zmodel-scope.ts b/packages/language/src/zmodel-scope.ts index d05a30cfb..8dd3c4dab 100644 --- a/packages/language/src/zmodel-scope.ts +++ b/packages/language/src/zmodel-scope.ts @@ -4,6 +4,7 @@ import { DefaultScopeComputation, DefaultScopeProvider, EMPTY_SCOPE, + MultiMap, StreamScope, UriUtils, interruptAndCheck, @@ -11,7 +12,6 @@ import { type AstNodeDescription, type LangiumCoreServices, type LangiumDocument, - type PrecomputedScopes, type ReferenceInfo, type Scope, } from 'langium'; @@ -52,11 +52,11 @@ export class ZModelScopeComputation extends DefaultScopeComputation { super(services); } - override async computeExports( + override async collectExportedSymbols( document: LangiumDocument, cancelToken?: Cancellation.CancellationToken | undefined, ): Promise { - const result = await super.computeExports(document, cancelToken); + const result = await super.collectExportedSymbols(document, cancelToken); // add enum fields so they can be globally resolved across modules for (const node of AstUtils.streamAllContents(document.parseResult.value)) { @@ -76,14 +76,18 @@ export class ZModelScopeComputation extends DefaultScopeComputation { return result; } - override processNode(node: AstNode, document: LangiumDocument, scopes: PrecomputedScopes) { - super.processNode(node, document, scopes); + protected override addLocalSymbol( + node: AstNode, + document: LangiumDocument, + symbols: MultiMap, + ) { + super.addLocalSymbol(node, document, symbols); if (isDataModel(node) || isTypeDef(node)) { // add base fields to the scope recursively const bases = getRecursiveBases(node, true, this.services.shared.workspace.LangiumDocuments); for (const base of bases) { for (const field of base.fields) { - scopes.add(node, this.descriptions.createDescription(field, this.nameProvider.getName(field))); + symbols.add(node, this.descriptions.createDescription(field, this.nameProvider.getName(field))); } } } diff --git a/packages/language/tsconfig.json b/packages/language/tsconfig.json index accdce5ed..3948382f8 100644 --- a/packages/language/tsconfig.json +++ b/packages/language/tsconfig.json @@ -2,6 +2,7 @@ "extends": "@zenstackhq/typescript-config/base.json", "include": ["src/**/*.ts"], "compilerOptions": { - "noUnusedLocals": false + "noUnusedLocals": false, + "types": ["node"] } } diff --git a/packages/sdk/src/prisma/prisma-schema-generator.ts b/packages/sdk/src/prisma/prisma-schema-generator.ts index 57fd9c6e9..f15422678 100644 --- a/packages/sdk/src/prisma/prisma-schema-generator.ts +++ b/packages/sdk/src/prisma/prisma-schema-generator.ts @@ -90,19 +90,19 @@ export class PrismaSchemaGenerator { for (const decl of this.zmodel.declarations) { switch (decl.$type) { - case DataSource: + case DataSource.$type: this.generateDataSource(prisma, decl as DataSource); break; - case Enum: + case Enum.$type: this.generateEnum(prisma, decl as Enum); break; - case DataModel: + case DataModel.$type: this.generateModel(prisma, decl as DataModel); break; - case GeneratorDecl: + case GeneratorDecl.$type: this.generateGenerator(prisma, decl as GeneratorDecl); break; } @@ -351,9 +351,9 @@ export class PrismaSchemaGenerator { private makeAttributeArgValue(node: Expression): PrismaAttributeArgValue { if (isLiteralExpr(node)) { const argType = match(node.$type) - .with(StringLiteral, () => 'String' as const) - .with(NumberLiteral, () => 'Number' as const) - .with(BooleanLiteral, () => 'Boolean' as const) + .with(StringLiteral.$type, () => 'String' as const) + .with(NumberLiteral.$type, () => 'Number' as const) + .with(BooleanLiteral.$type, () => 'Boolean' as const) .exhaustive(); return new PrismaAttributeArgValue(argType, node.value); } else if (isArrayExpr(node)) { diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 0a13a2831..d765af777 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -46,11 +46,11 @@ catalogs: specifier: ~0.29.0 version: 0.29.0 langium: - specifier: 3.5.0 - version: 3.5.0 + specifier: 4.2.4 + version: 4.2.4 langium-cli: - specifier: 3.5.0 - version: 3.5.0 + specifier: 4.2.1 + version: 4.2.1 mysql2: specifier: ^3.16.1 version: 3.16.1 @@ -102,8 +102,7 @@ catalogs: overrides: cookie@<0.7.0: '>=0.7.0' - lodash-es@>=4.0.0 <=4.17.22: '>=4.17.23' - lodash@>=4.0.0 <=4.17.22: '>=4.17.23' + lodash@>=4.0.0 <=4.17.23: '>=4.18.0' '@better-auth/core': 1.4.19 importers: @@ -254,7 +253,7 @@ importers: version: 2.6.1 langium: specifier: 'catalog:' - version: 3.5.0 + version: 4.2.4 mixpanel: specifier: ^0.18.1 version: 0.18.1 @@ -535,7 +534,7 @@ importers: version: link:../../language langium: specifier: 'catalog:' - version: 3.5.0 + version: 4.2.4 mixpanel: specifier: ^0.18.0 version: 0.18.1 @@ -578,7 +577,7 @@ importers: version: link:../common-helpers langium: specifier: 'catalog:' - version: 3.5.0 + version: 4.2.4 pluralize: specifier: ^8.0.0 version: 8.0.0 @@ -589,6 +588,9 @@ importers: specifier: ^9.0.1 version: 9.0.1 devDependencies: + '@types/node': + specifier: 'catalog:' + version: 20.19.24 '@types/pluralize': specifier: ^0.0.33 version: 0.0.33 @@ -612,7 +614,7 @@ importers: version: 11.1.0 langium-cli: specifier: 'catalog:' - version: 3.5.0 + version: 4.2.1 tmp: specifier: 'catalog:' version: 0.2.5 @@ -811,7 +813,7 @@ importers: version: link:../language langium: specifier: 'catalog:' - version: 3.5.0 + version: 4.2.4 ts-pattern: specifier: 'catalog:' version: 5.7.1 @@ -1862,29 +1864,29 @@ packages: '@chevrotain/cst-dts-gen@10.5.0': resolution: {integrity: sha512-lhmC/FyqQ2o7pGK4Om+hzuDrm9rhFYIJ/AXoQBeongmn870Xeb0L6oGEiuR8nohFNL5sMaQEJWCxr1oIVIVXrw==} - '@chevrotain/cst-dts-gen@11.0.3': - resolution: {integrity: sha512-BvIKpRLeS/8UbfxXxgC33xOumsacaeCKAjAeLyOn7Pcp95HiRbrpl14S+9vaZLolnbssPIUuiUd8IvgkRyt6NQ==} + '@chevrotain/cst-dts-gen@12.0.0': + resolution: {integrity: sha512-fSL4KXjTl7cDgf0B5Rip9Q05BOrYvkJV/RrBTE/bKDN096E4hN/ySpcBK5B24T76dlQ2i32Zc3PAE27jFnFrKg==} '@chevrotain/gast@10.5.0': resolution: {integrity: sha512-pXdMJ9XeDAbgOWKuD1Fldz4ieCs6+nLNmyVhe2gZVqoO7v8HXuHYs5OV2EzUtbuai37TlOAQHrTDvxMnvMJz3A==} - '@chevrotain/gast@11.0.3': - resolution: {integrity: sha512-+qNfcoNk70PyS/uxmj3li5NiECO+2YKZZQMbmjTqRI3Qchu8Hig/Q9vgkHpI3alNjr7M+a2St5pw5w5F6NL5/Q==} + '@chevrotain/gast@12.0.0': + resolution: {integrity: sha512-1ne/m3XsIT8aEdrvT33so0GUC+wkctpUPK6zU9IlOyJLUbR0rg4G7ZiApiJbggpgPir9ERy3FRjT6T7lpgetnQ==} - '@chevrotain/regexp-to-ast@11.0.3': - resolution: {integrity: sha512-1fMHaBZxLFvWI067AVbGJav1eRY7N8DDvYCTwGBiE/ytKBgP8azTdgyrKyWZ9Mfh09eHWb5PgTSO8wi7U824RA==} + '@chevrotain/regexp-to-ast@12.0.0': + resolution: {integrity: sha512-p+EW9MaJwgaHguhoqwOtx/FwuGr+DnNn857sXWOi/mClXIkPGl3rn7hGNWvo31HA3vyeQxjqe+H36yZJwYU8cA==} '@chevrotain/types@10.5.0': resolution: {integrity: sha512-f1MAia0x/pAVPWH/T73BJVyO2XU5tI4/iE7cnxb7tqdNTNhQI3Uq3XkqcoteTmD4t1aM0LbHCJOhgIDn07kl2A==} - '@chevrotain/types@11.0.3': - resolution: {integrity: sha512-gsiM3G8b58kZC2HaWR50gu6Y1440cHiJ+i3JUvcp/35JchYejb2+5MVeJK0iKThYpAa/P2PYFV4hoi44HD+aHQ==} + '@chevrotain/types@12.0.0': + resolution: {integrity: sha512-S+04vjFQKeuYw0/eW3U52LkAHQsB1ASxsPGsLPUyQgrZ2iNNibQrsidruDzjEX2JYfespXMG0eZmXlhA6z7nWA==} '@chevrotain/utils@10.5.0': resolution: {integrity: sha512-hBzuU5+JjB2cqNZyszkDHZgOSrUUT8V3dhgRl8Q9Gp6dAj/H5+KILGjbhDpc3Iy9qmqlm/akuOI2ut9VUtzJxQ==} - '@chevrotain/utils@11.0.3': - resolution: {integrity: sha512-YslZMgtJUyuMbZ+aKvfF3x1f5liK4mWNxghFRv7jqRR9C3R3fAOGTTKvxXDa2Y1s9zSbcpuO0cAxDYsc9SrXoQ==} + '@chevrotain/utils@12.0.0': + resolution: {integrity: sha512-lB59uJoaGIfOOL9knQqQRfhl9g7x8/wqFkp13zTdkRu1huG9kg6IJs1O8hqj9rs6h7orGxHJUKb+mX3rPbWGhA==} '@clack/core@0.5.0': resolution: {integrity: sha512-p3y0FIOwaYRUPRcMO7+dlmLh8PSRcrjuTndsiA0WAFbWES0mLZlrjVoBRZ9DzkPFJZG6KGkJmoEAY0ZcVWTkow==} @@ -5202,24 +5204,21 @@ packages: resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} engines: {node: '>=10'} - chalk@5.3.0: - resolution: {integrity: sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==} - engines: {node: ^12.17.0 || ^14.13 || >=16.0.0} - chalk@5.6.2: resolution: {integrity: sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==} engines: {node: ^12.17.0 || ^14.13 || >=16.0.0} - chevrotain-allstar@0.3.1: - resolution: {integrity: sha512-b7g+y9A0v4mxCW1qUhf3BSVPg+/NvGErk/dOkrDaHA0nQIQGAtrOjlX//9OQtRlSCy+x9rfB5N8yC71lH1nvMw==} + chevrotain-allstar@0.4.3: + resolution: {integrity: sha512-2X4mkroolSMKqW+H22pyPMUVDqYZzPhephTmg/NODKb1IGYPHfxfhcW0EjS7wcPJNbze2i4vBWT7zT5FKF2lrQ==} peerDependencies: - chevrotain: ^11.0.0 + chevrotain: ^12.0.0 chevrotain@10.5.0: resolution: {integrity: sha512-Pkv5rBY3+CsHOYfV5g/Vs5JY9WTHHDEKOlohI2XeygaZhUeqhAlldZ8Hz9cRmxu709bvS08YzxHdTPHhffc13A==} - chevrotain@11.0.3: - resolution: {integrity: sha512-ci2iJH6LeIkvP9eJW6gpueU8cnZhv85ELY8w8WiFtNjMHA5ad6pQLaJo9mEly/9qUyCpvqX8/POVUTf18/HFdw==} + chevrotain@12.0.0: + resolution: {integrity: sha512-csJvb+6kEiQaqo1woTdSAuOWdN0WTLIydkKrBnS+V5gZz0oqBrp4kQ35519QgK6TpBThiG3V1vNSHlIkv4AglQ==} + engines: {node: '>=22.0.0'} chokidar@4.0.3: resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==} @@ -5297,10 +5296,6 @@ packages: resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} engines: {node: '>= 0.8'} - commander@11.0.0: - resolution: {integrity: sha512-9HMlXtt/BNoYr8ooyjjNRdIilOTkVJXB+GhxMTtOKwk0R4j4lS4NpjuqmRxroBfnfTSHQIHQB7wryHhXarNjmQ==} - engines: {node: '>=16'} - commander@11.1.0: resolution: {integrity: sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==} engines: {node: '>=16'} @@ -6243,8 +6238,8 @@ packages: fs-constants@1.0.0: resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==} - fs-extra@11.1.1: - resolution: {integrity: sha512-MGIE4HOvQCeUCzmlHs0vXpih4ysz4wg9qiSAu6cd42lVwPbTM1TjV7RusoyQqMmk/95gdQZX72u+YW+c3eEpFQ==} + fs-extra@11.3.5: + resolution: {integrity: sha512-eKpRKAovdpZtR1WopLHxlBWvAgPny3c4gX1G5Jhwmmw4XJj0ifSD5qB5TOo8hmA0wlRKDAOAhEE1yVPgs6Fgcg==} engines: {node: '>=14.14'} fsevents@2.3.3: @@ -6869,8 +6864,8 @@ packages: resolution: {integrity: sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==} engines: {node: '>=0.10.0'} - jsonschema@1.4.1: - resolution: {integrity: sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ==} + jsonschema@1.5.0: + resolution: {integrity: sha512-K+A9hhqbn0f3pJX17Q/7H6yQfD/5OXgdrR5UE12gMXCiN9D5Xq2o5mddV2QEcX/bjla99ASsAAQUyMCCRWAEhw==} jsx-ast-utils@3.3.5: resolution: {integrity: sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==} @@ -6908,17 +6903,17 @@ packages: resolution: {integrity: sha512-LrQfPUeTW7MXbMvT62moEMnpMTuj9TO3lqjCeLKjM975PJ4Alrl/43f2tlDX7xOsNptKgH4LSNGwIbXwEkLg4g==} engines: {node: '>=22.0.0'} - langium-cli@3.5.0: - resolution: {integrity: sha512-TPIzIiMAQwTPPphtHGSrFXo4t0orx3aRh0syg9jnOihvBkBDvsQdJP9fBo9hp5Qaosklpc2CfbH0wh/dkgZcJA==} - engines: {node: '>=18.0.0'} + langium-cli@4.2.1: + resolution: {integrity: sha512-npo1fSoP/wUf4cxUcKUYph48+jHFPEjeLQJ3pQ1UnA4QRuz8JpOxWsLHB/fdmViZSnI0mb98f06Wo7PKecqoUw==} + engines: {node: '>=20.10.0', npm: '>=10.2.3'} hasBin: true - langium-railroad@3.5.0: - resolution: {integrity: sha512-80Enc6bOR6oHZD18IQlVTdfCh07rbrM5SOsPUPc1kyh7n3zQbmLs5P2E9hV4SoWlkhOjGKL1I9Z6uORpgy+jTQ==} + langium-railroad@4.2.0: + resolution: {integrity: sha512-LYR22GV14iz0GTUtR91pZY6yNImYRk1HbAuHBP8k8GESMcSkCJh+iewJooH9k8H8dJOteXvvI7aFkz6rfU9oLQ==} - langium@3.5.0: - resolution: {integrity: sha512-tnqVzWOkUcoiY0bWlyE8diFrZjmGBCF7MesC1bjUaZM+YGQSfdPC+KkhmHM0DWFG+uLcPxidKaPP1SYGtg3J0Q==} - engines: {node: '>=18.0.0'} + langium@4.2.4: + resolution: {integrity: sha512-J0M9BkTOZ9Izee2YL0eXkUKFdWhrmTYYVLgiZTz6Z3KvK03ooM+vjVrfphKcdGVPWmM2cFYtDnNyIsIIZPrHNA==} + engines: {node: '>=20.10.0', npm: '>=10.2.3'} language-subtag-registry@0.3.23: resolution: {integrity: sha512-0K65Lea881pHotoGEa5gDlMxt3pctLi2RplBb7Ezh4rRdLEOtgi7n4EwK9lamnUCkKBqaeKRVebTq6BAxSkpXQ==} @@ -7046,8 +7041,8 @@ packages: resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} engines: {node: '>=10'} - lodash-es@4.17.23: - resolution: {integrity: sha512-kVI48u3PZr38HdYz98UmfPnXl2DXrpdctLrFLCd3kOx1xUkOmpFPx7gCWWM5MPkL/fD8zb+Ph0QzjGFs4+hHWg==} + lodash-es@4.18.1: + resolution: {integrity: sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A==} lodash.defaults@4.2.0: resolution: {integrity: sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==} @@ -7064,8 +7059,8 @@ packages: lodash.uniq@4.5.0: resolution: {integrity: sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==} - lodash@4.17.23: - resolution: {integrity: sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==} + lodash@4.18.1: + resolution: {integrity: sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==} log-symbols@4.1.0: resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==} @@ -9415,9 +9410,6 @@ packages: resolution: {integrity: sha512-woByF3PDpkHFUreUa7Hos7+pUWdeWMXRd26+ZX2A8cFx6v/JPTtd4/uN0/jB6XQHYaOlHbio03NTHCqrgG5n7g==} hasBin: true - vscode-uri@3.0.8: - resolution: {integrity: sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw==} - vscode-uri@3.1.0: resolution: {integrity: sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==} @@ -10323,33 +10315,31 @@ snapshots: dependencies: '@chevrotain/gast': 10.5.0 '@chevrotain/types': 10.5.0 - lodash: 4.17.23 + lodash: 4.18.1 - '@chevrotain/cst-dts-gen@11.0.3': + '@chevrotain/cst-dts-gen@12.0.0': dependencies: - '@chevrotain/gast': 11.0.3 - '@chevrotain/types': 11.0.3 - lodash-es: 4.17.23 + '@chevrotain/gast': 12.0.0 + '@chevrotain/types': 12.0.0 '@chevrotain/gast@10.5.0': dependencies: '@chevrotain/types': 10.5.0 - lodash: 4.17.23 + lodash: 4.18.1 - '@chevrotain/gast@11.0.3': + '@chevrotain/gast@12.0.0': dependencies: - '@chevrotain/types': 11.0.3 - lodash-es: 4.17.23 + '@chevrotain/types': 12.0.0 - '@chevrotain/regexp-to-ast@11.0.3': {} + '@chevrotain/regexp-to-ast@12.0.0': {} '@chevrotain/types@10.5.0': {} - '@chevrotain/types@11.0.3': {} + '@chevrotain/types@12.0.0': {} '@chevrotain/utils@10.5.0': {} - '@chevrotain/utils@11.0.3': {} + '@chevrotain/utils@12.0.0': {} '@clack/core@0.5.0': dependencies: @@ -13261,7 +13251,7 @@ snapshots: graceful-fs: 4.2.11 is-stream: 2.0.1 lazystream: 1.0.1 - lodash: 4.17.23 + lodash: 4.18.1 normalize-path: 3.0.0 readable-stream: 4.7.0 @@ -13735,14 +13725,12 @@ snapshots: ansi-styles: 4.3.0 supports-color: 7.2.0 - chalk@5.3.0: {} - chalk@5.6.2: {} - chevrotain-allstar@0.3.1(chevrotain@11.0.3): + chevrotain-allstar@0.4.3(chevrotain@12.0.0): dependencies: - chevrotain: 11.0.3 - lodash-es: 4.17.23 + chevrotain: 12.0.0 + lodash-es: 4.18.1 chevrotain@10.5.0: dependencies: @@ -13750,17 +13738,16 @@ snapshots: '@chevrotain/gast': 10.5.0 '@chevrotain/types': 10.5.0 '@chevrotain/utils': 10.5.0 - lodash: 4.17.23 + lodash: 4.18.1 regexp-to-ast: 0.5.0 - chevrotain@11.0.3: + chevrotain@12.0.0: dependencies: - '@chevrotain/cst-dts-gen': 11.0.3 - '@chevrotain/gast': 11.0.3 - '@chevrotain/regexp-to-ast': 11.0.3 - '@chevrotain/types': 11.0.3 - '@chevrotain/utils': 11.0.3 - lodash-es: 4.17.23 + '@chevrotain/cst-dts-gen': 12.0.0 + '@chevrotain/gast': 12.0.0 + '@chevrotain/regexp-to-ast': 12.0.0 + '@chevrotain/types': 12.0.0 + '@chevrotain/utils': 12.0.0 chokidar@4.0.3: dependencies: @@ -13826,8 +13813,6 @@ snapshots: dependencies: delayed-stream: 1.0.0 - commander@11.0.0: {} - commander@11.1.0: {} commander@12.1.0: {} @@ -14935,7 +14920,7 @@ snapshots: fs-constants@1.0.0: {} - fs-extra@11.1.1: + fs-extra@11.3.5: dependencies: graceful-fs: 4.2.11 jsonfile: 6.1.0 @@ -15580,7 +15565,7 @@ snapshots: jsonpointer@5.0.1: {} - jsonschema@1.4.1: {} + jsonschema@1.5.0: {} jsx-ast-utils@3.3.5: dependencies: @@ -15610,28 +15595,32 @@ snapshots: kysely@0.29.0: {} - langium-cli@3.5.0: + langium-cli@4.2.1: dependencies: - chalk: 5.3.0 - commander: 11.0.0 - fs-extra: 11.1.1 - jsonschema: 1.4.1 - langium: 3.5.0 - langium-railroad: 3.5.0 - lodash: 4.17.23 + chalk: 5.6.2 + commander: 14.0.3 + fs-extra: 11.3.5 + jsonschema: 1.5.0 + langium: 4.2.4 + langium-railroad: 4.2.0 + lodash: 4.18.1 - langium-railroad@3.5.0: + langium-railroad@4.2.0: dependencies: - langium: 3.5.0 + langium: 4.2.4 railroad-diagrams: 1.0.0 - langium@3.5.0: + langium@4.2.4: dependencies: - chevrotain: 11.0.3 - chevrotain-allstar: 0.3.1(chevrotain@11.0.3) + '@chevrotain/regexp-to-ast': 12.0.0 + chevrotain: 12.0.0 + chevrotain-allstar: 0.4.3(chevrotain@12.0.0) + vscode-jsonrpc: 8.2.0 vscode-languageserver: 9.0.1 + vscode-languageserver-protocol: 3.17.5 vscode-languageserver-textdocument: 1.0.12 - vscode-uri: 3.0.8 + vscode-languageserver-types: 3.17.5 + vscode-uri: 3.1.0 language-subtag-registry@0.3.23: {} @@ -15754,7 +15743,7 @@ snapshots: dependencies: p-locate: 5.0.0 - lodash-es@4.17.23: {} + lodash-es@4.18.1: {} lodash.defaults@4.2.0: {} @@ -15766,7 +15755,7 @@ snapshots: lodash.uniq@4.5.0: {} - lodash@4.17.23: {} + lodash@4.18.1: {} log-symbols@4.1.0: dependencies: @@ -18878,8 +18867,6 @@ snapshots: dependencies: vscode-languageserver-protocol: 3.17.5 - vscode-uri@3.0.8: {} - vscode-uri@3.1.0: {} vue-bundle-renderer@2.2.0: diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index 1db349ab4..f15d2e997 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -16,8 +16,8 @@ catalog: better-sqlite3: ^12.5.0 decimal.js: ^10.4.3 kysely: ~0.29.0 - langium: 3.5.0 - langium-cli: 3.5.0 + langium: 4.2.4 + langium-cli: 4.2.1 next: 16.1.6 nuxt: 4.3.1 '@sveltejs/kit': 2.53.2