diff --git a/VERSION b/VERSION index 1d5e9e0bad105584234c61dfafdc163fc6bdcbc9..5ebba4f08adf9a2c65bd6a54d3ed17792d5fe285 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.5.3 \ No newline at end of file +1.5.5 \ No newline at end of file diff --git a/arkoala-arkts/arkui/src/Application.ts b/arkoala-arkts/arkui/src/Application.ts index a60c065a043bdfbab3baf7906dae109210191f56..afa0423cd9b761b14fa525b8a564c4a69dc05ba9 100644 --- a/arkoala-arkts/arkui/src/Application.ts +++ b/arkoala-arkts/arkui/src/Application.ts @@ -306,7 +306,7 @@ export class Application { } // TODO: make [emitEvent] suitable to get string argument - emitEvent(type: int32, target: int32, arg0: int32, arg1: int32) { + emitEvent(type: int32, target: int32, arg0: int32, arg1: int32): string { const node = PeerNode.findPeerByNativeId(target) if (node != undefined) { try { @@ -332,6 +332,7 @@ export class Application { InteropNativeModule._NativeLog("emitEvent error: " + errorInfo(error as Object)) } } + return "0" } static createApplication(appUrl: string, params: string, useNativeLog: boolean): Application { diff --git a/arkoala-arkts/arkui/src/ArkComponentRoot.ts b/arkoala-arkts/arkui/src/ArkComponentRoot.ts index 3af4b9281d6db658754ccb58b8aae58456e3c46b..27ddb6c47960ded90ff80aca378a99b655b8a028 100644 --- a/arkoala-arkts/arkui/src/ArkComponentRoot.ts +++ b/arkoala-arkts/arkui/src/ArkComponentRoot.ts @@ -43,12 +43,10 @@ export function ArkComponentRoot( }) } ) - console.log("Going to attach") NodeAttach( () => ArkComponentRootPeer.create(), (node: PeerNode) => { content() - console.log("TODO: ArkComponentRoot routing") // const state = CurrentRouterTransitionState() // if (state) { // RunEffect(state.visibility, visibility => { diff --git a/arkoala-arkts/arkui/src/ArkStructBase.ts b/arkoala-arkts/arkui/src/ArkStructBase.ts index 5c40d5e86a2d8b6032d5d44ef07202c6fcdc0db7..ce99fe7eecafb59ad6c3849021116b0502d38530 100644 --- a/arkoala-arkts/arkui/src/ArkStructBase.ts +++ b/arkoala-arkts/arkui/src/ArkStructBase.ts @@ -18,7 +18,6 @@ export abstract class ArkStructBase extends ArkCustomComponentImpl arg1?: () => void, arg2?: T_Options ): void { - console.log("_instantiate()") const receiver = remember(() => { const instance = factory(); instance.__initializeStruct(arg1, arg2); @@ -43,8 +42,6 @@ export abstract class ArkStructBase extends ArkCustomComponentImpl content?: () => void, initializers?: T_Options ): void { - console.log("_buildWrapper()") - ArkComponentRoot(this, () => { this.__updateStruct(initializers) this.__build(attributes, content, initializers) diff --git a/arkoala-arkts/arkui/src/peers/ArkTestComponentPeer.ts b/arkoala-arkts/arkui/src/peers/ArkTestComponentPeer.ts index 431e97dff35b652f3edd28789c7205917037a342..3a7ba1c6caddfe386c9a21c4d75c743fb085084e 100644 --- a/arkoala-arkts/arkui/src/peers/ArkTestComponentPeer.ts +++ b/arkoala-arkts/arkui/src/peers/ArkTestComponentPeer.ts @@ -43,7 +43,7 @@ export class ArkTestComponentPeer extends ArkCommonMethodPeer { this.onChangeCallback = callback } logAttribute(message: string): void { - InteropNativeModule._AppendGroupedLog(1, message) + InteropNativeModule._AppendGroupedLog(0, message + "\n") } } export interface ArkTestComponentAttributes extends ArkCommonMethodAttributes { diff --git a/arkoala-arkts/arkui/src/sts/arkui.sts b/arkoala-arkts/arkui/src/sts/arkui.sts index 69aa97eceb68694645131f7c72d189853e4f7c1e..58a5b1b1a086011f649f6d5a61032d2240641850 100644 --- a/arkoala-arkts/arkui/src/sts/arkui.sts +++ b/arkoala-arkts/arkui/src/sts/arkui.sts @@ -29,9 +29,15 @@ export abstract class StructBase { console.log("Struct instantiate redirected") const instance = factory() if (builder !== undefined) builder(instance) - instance.build() + instance._build(builder, content, options) + } + build() { + throw new Error("The struct build() should never be executed directly") + } + + protected _build(style: ((instance: T)=>T)|undefined, content: (() => void)|undefined, options: OptionsT|undefined) { + throw new Error("The struct _build() must have a valid override") } - abstract build() } export enum Color { @@ -141,7 +147,7 @@ export class Text extends CommonMethod { style(instance) //content() } - + fontColor(value: Color): this { console.log("\.fontColor(", Color[value], ")") return this diff --git a/arkoala-arkts/ets-harness/src/EtsHarnessApplication.ts b/arkoala-arkts/ets-harness/src/EtsHarnessApplication.ts index 38bf4ba7c26a5b59ed2dc621fa254747539fb0e0..83016e900be785d53f0d86b590edce4597fec9ce 100644 --- a/arkoala-arkts/ets-harness/src/EtsHarnessApplication.ts +++ b/arkoala-arkts/ets-harness/src/EtsHarnessApplication.ts @@ -113,8 +113,9 @@ export class EtsHarnessApplication { return true } - emitEvent(type: int32, target: int32, arg0: int32, arg1: int32) { + emitEvent(type: int32, target: int32, arg0: int32, arg1: int32): string { const node = PeerNode.findPeerByNativeId(target) + let result = "0" switch (type) { case 1: { if (node != undefined) { @@ -124,11 +125,15 @@ export class EtsHarnessApplication { break } case 2: { - UserView.startNativeLog(1) + UserView.startNativeLog(0) break; } case 3: { - UserView.stopNativeLog(1) + UserView.stopNativeLog(0) + break; + } + case 4: { + result = UserView.getNativeLog(0) break; } default: { @@ -136,6 +141,7 @@ export class EtsHarnessApplication { break; } } + return result } updateStates(manager: StateManager, root: ComputableState ) { diff --git a/arkoala-arkts/ets-harness/src/ets/pages/case1.ets b/arkoala-arkts/ets-harness/src/ets/pages/case1.ets index 8594a52146b8ff833d3da9c834e46f83d0e43903..98f08cc78f917d946f3d32e72ad1e1411dac2a8e 100644 --- a/arkoala-arkts/ets-harness/src/ets/pages/case1.ets +++ b/arkoala-arkts/ets-harness/src/ets/pages/case1.ets @@ -5,7 +5,6 @@ struct Case1 { build() { TestComponent({ id: 42 }).onChange(() => { this.x++ - console.log("Case1 - value:" + this.x) }) .log("Case1 - value:" + this.x) } diff --git a/arkoala-arkts/ets-harness/src/ets/pages/case2.ets b/arkoala-arkts/ets-harness/src/ets/pages/case2.ets index 30529d8ff43399e65a4711f9e977a7b44a7bf47b..392f423b721054a3cb977c33ac769cf3d6a414c2 100644 --- a/arkoala-arkts/ets-harness/src/ets/pages/case2.ets +++ b/arkoala-arkts/ets-harness/src/ets/pages/case2.ets @@ -5,7 +5,6 @@ struct Case2 { build() { TestComponent({ id: 42 }).onChange(() => { this.x-- - console.log("Case2 - value:" + this.x) }) .log("Case2 - value:" + this.x) } diff --git a/arkoala-arkts/ets-harness/src/loader.ts b/arkoala-arkts/ets-harness/src/loader.ts index 586a48ad776d73d7c0253693835eb97f636d4636..4fabe956a1c2248e01cfcdcbd257aaef9e5b53e0 100644 --- a/arkoala-arkts/ets-harness/src/loader.ts +++ b/arkoala-arkts/ets-harness/src/loader.ts @@ -26,7 +26,7 @@ export interface LoaderOps { } export interface NativeControl extends LoaderOps { - _EmitEvent(type: int32, target: int32, arg0: int32, arg1: int32): void + _EmitEvent(type: int32, target: int32, arg0: int32, arg1: int32): string _RestartWith(page: string): void } @@ -46,20 +46,27 @@ export function nativeModule(): NativeControl { return theModule } +export enum TaskType { + OnChange = 1, + StartLog = 2, + StopLog = 3, + GetLog = 4, +} + export class AppControl { getLog(): string { - return "" + return nativeModule()._EmitEvent(TaskType.GetLog, -1, 0, 0) } - emitTask(type: int32, target: int32, arg1: int32, arg2: int32): AppControl { + emitTask(type: int32, target: int32, arg1: int32 = 0, arg2: int32 = 0): AppControl { nativeModule()._EmitEvent(type, target, arg1, arg2) return this } start(): AppControl { - nativeModule()._EmitEvent(2, -1, 0, 0) + nativeModule()._EmitEvent(TaskType.StartLog, -1, 0, 0) return this } stop(): AppControl { - nativeModule()._EmitEvent(3, -1, 0, 0) + nativeModule()._EmitEvent(TaskType.StopLog, -1, 0, 0) return this } nextFrame(): AppControl { diff --git a/arkoala-arkts/ets-harness/src/test_entry.ts b/arkoala-arkts/ets-harness/src/test_entry.ts index ec112fe5e519d4085f3f10c7974bb5992df68cb7..47cd0f1566f4573dda8c84920a92c6a3d06db363 100644 --- a/arkoala-arkts/ets-harness/src/test_entry.ts +++ b/arkoala-arkts/ets-harness/src/test_entry.ts @@ -1,33 +1,37 @@ import { Assert } from "@koalaui/harness" -import { AppControl } from "./loader" +import { AppControl, TaskType } from "./loader" export function entry(control: AppControl) { suite("Case1", () => { test("StateChange:Increment", () => { + const expected = "Case1 - value:1\nCase1 - value:2\nCase1 - value:3\n" + const componentId = 42 // id from Case1.TestComponent // onChange - control + const actual = control .loadPage("Case1") .start() - .emitTask(1, 42, 0, 0).nextFrame() - .emitTask(1, 42, 0, 0).nextFrame() - .emitTask(1, 42, 0, 0).nextFrame() + .emitTask(TaskType.OnChange, componentId).nextFrame() + .emitTask(TaskType.OnChange, componentId).nextFrame() + .emitTask(TaskType.OnChange, componentId).nextFrame() .stop() - let x = 3 - Assert.equal(x, 3, "StateChange test is failed!\n expected: " + 3 + "\ncurrent: " + x) + .getLog() + Assert.equal(expected, actual, "StateChange: Case1 test is failed!") }) }) suite("Case2", () => { test("StateChange:Decrement", () => { + const expected = "Case2 - value:-1\nCase2 - value:-2\nCase2 - value:-3\n" + const componentId = 42 // id from Case2.TestComponent // onChange - control + const actual = control .loadPage("Case2") .start() - .emitTask(1, 42, 0, 0).nextFrame() - .emitTask(1, 42, 0, 0).nextFrame() - .emitTask(1, 42, 0, 0).nextFrame() + .emitTask(TaskType.OnChange, componentId).nextFrame() + .emitTask(TaskType.OnChange, componentId).nextFrame() + .emitTask(TaskType.OnChange, componentId).nextFrame() .stop() - let x = -3 - Assert.equal(x, -3, "StateChange test is failed!\n expected: " + (-3) + "\ncurrent: " + x) + .getLog() + Assert.equal(expected, actual, "StateChange: Case2 test is failed!") }) }) } diff --git a/arkoala-arkts/libarkts/.mocharc.json b/arkoala-arkts/libarkts/.mocharc.json index 1799d0fb2caa05fbd6ee3c0208a4ad21b4a5a95d..62699a6cd93955182895f22cca7ca55823ac97d6 100644 --- a/arkoala-arkts/libarkts/.mocharc.json +++ b/arkoala-arkts/libarkts/.mocharc.json @@ -1,7 +1,6 @@ { "ui": "tdd", - "spec": "./test/**/*.test.ts", - "exclude": "./test/ts-api/**/*", + "spec": "./test/arkts-api/**/*.test.ts", "extension": [ "ts" ], diff --git a/arkoala-arkts/libarkts/native/src/bridges.cc b/arkoala-arkts/libarkts/native/src/bridges.cc index 4250b79081d434b8ff41d507e66f64c13be0c7a6..1ee0b055df23f48b29912c48c27c2e2a3b9db7d2 100644 --- a/arkoala-arkts/libarkts/native/src/bridges.cc +++ b/arkoala-arkts/libarkts/native/src/bridges.cc @@ -50,6 +50,15 @@ KNativePointer impl_AnnotationAllowedAnnotations(KNativePointer contextPtr, KNat } KOALA_INTEROP_3(AnnotationAllowedAnnotations, KNativePointer, KNativePointer, KNativePointer, KNativePointer) +KNativePointer impl_AnnotationAllowedAnnotationsConst(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + std::size_t params_len = 0; + auto annotations = GetImpl()->AnnotationAllowedAnnotationsConst(context, node, ¶ms_len); + return new std::vector(annotations, annotations + params_len); +} +KOALA_INTEROP_3(AnnotationAllowedAnnotationsConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + KNativePointer impl_AstNodeVariableConst(KNativePointer contextPtr, KNativePointer nodePtr) { auto context = reinterpret_cast(contextPtr); auto node = reinterpret_cast(nodePtr); diff --git a/arkoala-arkts/libarkts/package.json b/arkoala-arkts/libarkts/package.json index c635b15b27fa04c5dcf191943fb0f177ca1c27e0..fd2fb932606fbbed41389e5d346eeb1ba2e5e5cd 100644 --- a/arkoala-arkts/libarkts/package.json +++ b/arkoala-arkts/libarkts/package.json @@ -11,7 +11,7 @@ "./build/*" ], "config": { - "gen_version": "3.0.18", + "gen_version": "3.0.19", "input_file": "../../incremental/tools/panda/node_modules/@panda/sdk/ohos_arm64/include/tools/es2panda/generated/es2panda_lib/es2panda_lib.idl" }, "dependencies": { diff --git a/arkoala-arkts/libarkts/plugins/input/library.sts b/arkoala-arkts/libarkts/plugins/input/library.sts index 9d7a1f0e13cbef43c547d3047989555cab2c8ef0..84aa6aac1e9833171a875dbc184d5761468fd98f 100644 --- a/arkoala-arkts/libarkts/plugins/input/library.sts +++ b/arkoala-arkts/libarkts/plugins/input/library.sts @@ -1 +1,3 @@ export @interface Component {} + +export @interface memo {} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/plugins/input/main.sts b/arkoala-arkts/libarkts/plugins/input/main.sts index bff61711a10b1179cc5d2bb790e60205e1c1d937..0a64cf195fc7de11e24bc95a5909a3ef8ac76dc3 100644 --- a/arkoala-arkts/libarkts/plugins/input/main.sts +++ b/arkoala-arkts/libarkts/plugins/input/main.sts @@ -1,4 +1,4 @@ -import { Component } from "./library" +import { Component, memo } from "./library" @interface BuilderLambda { value: string diff --git a/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts b/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..e6201eda84de0e6bf21f9d8818bb51e756531f74 --- /dev/null +++ b/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts @@ -0,0 +1,28 @@ +import * as arkts from "@koalaui/libarkts" + +export function annotation(name: string): arkts.AnnotationUsage { + const ident: arkts.Identifier = arkts.factory.createIdentifier(name).setAnnotationUsage(); + const annotation: arkts.AnnotationUsage = arkts.factory.createAnnotationUsage(ident); + + annotation.modifiers = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_ANNOTATION_USAGE; + ident.parent = annotation; + + return annotation; +} + +export function mangle(value: string): string { + return `__${value}`; +} + +export function backingField(originalName: string): string { + return mangle(`backing_${originalName}`); +} + +export function filterDefined(value: (T | undefined)[]): T[] { + return value.filter((it: T | undefined): it is T => it != undefined); +} + +export function collect(...value: (ReadonlyArray | T | undefined)[]): T[] { + const empty: (T | undefined)[] = [] + return filterDefined(empty.concat(...value)) +} diff --git a/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts b/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts index 6be93bccdffd798db15b5b2012d3d0f0fb0c7cc7..ab1fc833e15da862ebd1b65b6494c80751940253 100644 --- a/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts +++ b/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts @@ -31,7 +31,7 @@ function getLambdaArg(lambdaBody: arkts.AstNode, typeName: string|undefined): ar arkts.factory.createIdentifier( builderLambdaInstanceName, // TODO: it should be the return type of the function annotated with the @BuilderLambda - typeName ? arkts.factory.createTypeReference( + typeName ? arkts.factory.createTypeReferenceFromId( arkts.factory.createIdentifier( typeName ) @@ -45,7 +45,7 @@ function getLambdaArg(lambdaBody: arkts.AstNode, typeName: string|undefined): ar param ], // TODO: it should be the return type of the function annotated with the @BuilderLambda - typeName ? arkts.factory.createTypeReference( + typeName ? arkts.factory.createTypeReferenceFromId( arkts.factory.createIdentifier( typeName ) @@ -66,22 +66,25 @@ function getLambdaArg(lambdaBody: arkts.AstNode, typeName: string|undefined): ar ) } -function isBuilderLambdaAnnotation(annotation: arkts.AnnotationUsageIr): boolean { +function isBuilderLambdaAnnotation(annotation: arkts.AnnotationUsage): boolean { + if (annotation.expr === undefined) { + return false + } if (!arkts.isIdentifier(annotation.expr)) { return false } return annotation.expr.name !== "BuilderLambda" } -function builderLambdaArgumentName(annotation: arkts.AnnotationUsageIr): string | undefined { +function builderLambdaArgumentName(annotation: arkts.AnnotationUsage): string | undefined { if (!isBuilderLambdaAnnotation(annotation)) return undefined + const property = annotation.properties[0] + if (property === undefined) return undefined + if (!arkts.isClassProperty(property)) return undefined + if (property.value === undefined) return undefined + if (!arkts.isStringLiteral(property.value)) return undefined - if (!annotation.properties[0].value || - !arkts.isStringLiteral(annotation.properties[0].value) - ) { - return undefined - } - return annotation.properties[0].value.str + return property.value.str } /* function builderLambdaTypeName(annotation: arkts.AnnotationUsageIr): string | undefined { @@ -95,8 +98,7 @@ function builderLambdaTypeName(annotation: arkts.AnnotationUsageIr): string | un return annotation.properties[1].value.str } */ -function findBuilderLambdaAnnotation(node: arkts.CallExpression): arkts.AnnotationUsageIr|undefined { - +function findBuilderLambdaAnnotation(node: arkts.CallExpression): arkts.AnnotationUsage | undefined { let decl: arkts.AstNode|undefined = undefined if (arkts.isIdentifier(node.expression)) { decl = arkts.getDecl(node.expression) @@ -172,93 +174,160 @@ function builderLambdaReplace(leaf: arkts.CallExpression): arkts.Identifier|arkt } if (arkts.isIdentifier(node)) { - return arkts.factory.createIdentifier( - funcName - ) + return arkts.factory.createIdentifier( + funcName + ) } if (arkts.isMemberExpression(node)) { - return arkts.factory.createMemberExpression( - node.object, - arkts.factory.createIdentifier( - funcName - ), - arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, - false, - false - ) + return arkts.factory.createMemberExpression( + node.object, + arkts.factory.createIdentifier( + funcName + ), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ) } return undefined } -export class BuilderLambdaTransformer extends AbstractVisitor { - visitor(beforeChildren: arkts.AstNode): arkts.AstNode { - const node = this.visitEachChild(beforeChildren) +function builderLambdaBodyRewrite(node: arkts.AstNode): arkts.AstNode { + if (!arkts.isArrowFunctionExpression(node)) return node; - if (!arkts.isCallExpression(node)) { - return node - } + const scriptFunc: arkts.ScriptFunction = node.scriptFunction; + if (!scriptFunc || !scriptFunc.body) return node; - if (true - && arkts.isMemberExpression(node.parent) - && arkts.isIdentifier(node.parent.property) - && arkts.isCallExpression(node.parent.parent) + const body: arkts.BlockStatement = scriptFunc.body; + const statements: arkts.AstNode[] = body.statements.map((statement: arkts.AstNode) => { + if ( + arkts.isExpressionStatement(statement) + && statement.expression + && arkts.isCallExpression(statement.expression) ) { - return node + return transformBuilderLambda(statement.expression); } + return statement; + }); + const updateBody = arkts.factory.updateBlock(body, statements); + + const signature: arkts.FunctionSignature = arkts.FunctionSignature.create(undefined, [], undefined); + const updateFunc: arkts.ScriptFunction = arkts.factory.updateScriptFunction( + scriptFunc, + updateBody, + signature, // TODO: Cannot get signature from original ScriptFunction node + scriptFunc.scriptFunctionFlags, + scriptFunc.modifiers, + false, + undefined + ); - let instanceCalls: arkts.CallExpression[] = [] - let leaf: arkts.CallExpression = node + return arkts.factory.updateArrowFunction(node, updateFunc); +} - while (true - && arkts.isMemberExpression(leaf.expression) - && arkts.isIdentifier(leaf.expression.property) - && arkts.isCallExpression(leaf.expression.object) - ) { - instanceCalls.push( - arkts.factory.createCallExpression( - leaf.expression.property, - undefined, - leaf.arguments - ) - ) - leaf = leaf.expression.object - } +function transformBuilderLambda(node: arkts.CallExpression): arkts.AstNode { + let instanceCalls: arkts.CallExpression[] = [] + let leaf: arkts.CallExpression = node - const replace = builderLambdaReplace(leaf) - if (replace === undefined) { - return node - } - - instanceCalls = instanceCalls.reverse() - let lambdaBody: arkts.Identifier | arkts.CallExpression = arkts.factory.createIdentifier(builderLambdaInstanceName) - instanceCalls.forEach((call)=> { - if (!arkts.isIdentifier(call.expression)) { - throw new Error('call expression should be identifier') - } - lambdaBody = arkts.factory.createCallExpression( - arkts.factory.createMemberExpression( - lambdaBody, - call.expression, - arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, - false, - false - ), + while (true + && arkts.isMemberExpression(leaf.expression) + && arkts.isIdentifier(leaf.expression.property) + && arkts.isCallExpression(leaf.expression.object) + ) { + instanceCalls.push( + arkts.factory.createCallExpression( + leaf.expression.property, undefined, - call.arguments + leaf.arguments ) - }) + ) + leaf = leaf.expression.object + } - const typeName = builderLambdaTypeName(leaf) - const lambdaArg = getLambdaArg(lambdaBody, typeName) + const replace = builderLambdaReplace(leaf) + if (replace === undefined) { + return node + } - return arkts.factory.updateCallExpression( - node, - replace, + instanceCalls = instanceCalls.reverse() + let lambdaBody: arkts.Identifier | arkts.CallExpression = arkts.factory.createIdentifier(builderLambdaInstanceName) + instanceCalls.forEach((call)=> { + if (!arkts.isIdentifier(call.expression)) { + throw new Error('call expression should be identifier') + } + lambdaBody = arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + lambdaBody, + call.expression, + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), undefined, - [ - lambdaArg, - ...leaf.arguments - ] + call.arguments ) + }) + + const typeName = builderLambdaTypeName(leaf) + const lambdaArg = getLambdaArg(lambdaBody, typeName) + + let args: arkts.AstNode[] = leaf.arguments.length < 3 + ? leaf.arguments as arkts.AstNode[] + : [ + ...leaf.arguments.slice(0, 2), + builderLambdaBodyRewrite(leaf.arguments.at(2)!), + ...leaf.arguments.slice(3) // Currently, this is never reached since the maximum length of arguments is 3 + ]; + + return arkts.factory.updateCallExpression( + node, + replace, + undefined, + [ + lambdaArg, + ...args + ] + ) +} + +function isBuilderLambda(node: arkts.AstNode): boolean { + const builderLambda: arkts.AstNode | undefined = _getDeclForBuilderLambda(node); + return !!builderLambda; +} + +// TODO: temporary solution for get declaration of a builder lambda +function _getDeclForBuilderLambda(node: arkts.AstNode): arkts.AstNode | undefined { + if (!node || !arkts.isCallExpression(node)) return undefined; + + if (node.expression && arkts.isMemberExpression(node.expression)) { + const _node: arkts.MemberExpression = node.expression; + if (_node.property && arkts.isIdentifier(_node.property) && _node.property.name === "$_instantiate") { + return node; + } + if (_node.object && arkts.isCallExpression(_node.object)) { + return _getDeclForBuilderLambda(_node.object); + } + } + + return undefined; +} + +export class BuilderLambdaTransformer extends AbstractVisitor { + visitEachChild(node: arkts.AstNode): arkts.AstNode { + if (arkts.isCallExpression(node) && isBuilderLambda(node)) { + return node; + } + + return super.visitEachChild(node); + } + + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren) + + if (arkts.isCallExpression(node) && isBuilderLambda(node)) { + return transformBuilderLambda(node); + } + + return node; } } diff --git a/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts b/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts index ec0578ffde3afe67fb6a161e67b9d9e6a0123bfb..c7b9f14634019ca286b7452a70577082e3a213c2 100644 --- a/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts +++ b/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts @@ -2,6 +2,7 @@ import * as ts from "@koalaui/libarkts" import { PrintVisitor } from './print-visitor' import { BuilderLambdaTransformer } from './builder-lambda-transformer' import { ComponentTransformer } from './component-transformer' +import { StructTransformer } from './struct-transformer' export interface TransformerOptions { trace?: boolean, @@ -11,6 +12,13 @@ export default function exampleTransformer( userPluginOptions?: TransformerOptions ) { return (node: ts.EtsScript) => { - return new BuilderLambdaTransformer().visitor(node) + const builderLambdaTransformer = new BuilderLambdaTransformer(); + const structTransformer = new StructTransformer(); + + let script: ts.EtsScript = node; + script = builderLambdaTransformer.visitor(script) as ts.EtsScript; + script = structTransformer.visitor(script) as ts.EtsScript; + + return script; } } diff --git a/arkoala-arkts/libarkts/plugins/src/component-transformer.ts b/arkoala-arkts/libarkts/plugins/src/component-transformer.ts index eb9dea77434d7c2286f31896f1a5a76c4137f03d..10b2a6d0eafd7699766fdf15693bd79e51ec6a6a 100644 --- a/arkoala-arkts/libarkts/plugins/src/component-transformer.ts +++ b/arkoala-arkts/libarkts/plugins/src/component-transformer.ts @@ -71,6 +71,7 @@ export class ComponentTransformer extends AbstractVisitor { processComponent(node: arkts.ClassDeclaration | arkts.StructDeclaration): arkts.ClassDeclaration { const className = node.definition.name.name + arkts.GlobalInfo.getInfoInstance().add(className); this.context.componentNames.push(className) const newDefinition = arkts.factory.updateClassDefinition( @@ -85,10 +86,10 @@ export class ComponentTransformer extends AbstractVisitor { arkts.factory.createIdentifier('StructBase'), arkts.factory.createTSTypeParameterInstantiation( [ - arkts.factory.createTypeReference( + arkts.factory.createTypeReferenceFromId( arkts.factory.createIdentifier(className) ), - arkts.factory.createTypeReference( + arkts.factory.createTypeReferenceFromId( arkts.factory.createIdentifier(`__Options_${className}`) ), ] diff --git a/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts b/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..1243e1c914829e87f3edf093cbf01365e32d411f --- /dev/null +++ b/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts @@ -0,0 +1,183 @@ +import * as arkts from "@koalaui/libarkts" +import { AbstractVisitor } from "./AbstractVisitor"; +import { annotation } from "./arkts-utils"; + +function isCustomComponentClass(node: arkts.ClassDeclaration): boolean { + const structCollection: Set = arkts.GlobalInfo.getInfoInstance().getStructCollection(); + if (structCollection.has(node.definition.name.name)) { + return true; + } + return false; +} + +function isKnownMethodDefinition(method: arkts.MethodDefinition, name: string): boolean { + if (!method || !arkts.isMethodDefinition(method)) return false; + + // For now, we only considered matched method name. + const isNameMatched: boolean = method.name?.name === name; + return isNameMatched; +} + +function createStyleArgInBuildMethod(className: string): arkts.ETSParameterExpression { + const styleLambdaParams: arkts.ETSParameterExpression = arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier( + 'instance', + arkts.factory.createIdentifier(className), + ), + undefined + ); + + const styleLambda: arkts.ETSFunctionType = arkts.factory.createFunctionType( + arkts.FunctionSignature.create( + undefined, + [ + styleLambdaParams + ], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID) + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW + ); + + const optionalStyleLambda: arkts.ETSUnionType = arkts.factory.createUnionType([ + styleLambda, + arkts.factory.createUndefinedLiteral() + ]); + + const styleParam: arkts.Identifier = arkts.factory.createIdentifier( + 'style', + optionalStyleLambda + ); + + const param = arkts.factory.createParameterDeclaration(styleParam, undefined); + param.annotations = [annotation("memo")]; + + return param; +} + +function createContentArgInBuildMethod(): arkts.ETSParameterExpression { + const contentLambda: arkts.ETSFunctionType = arkts.factory.createFunctionType( + arkts.FunctionSignature.create( + undefined, + [], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID) + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW + ); + + const optionalContentLambda: arkts.ETSUnionType = arkts.factory.createUnionType([ + contentLambda, + arkts.factory.createUndefinedLiteral() + ]); + + const contentParam: arkts.Identifier = arkts.factory.createIdentifier( + 'content', + optionalContentLambda + ); + + const param = arkts.factory.createParameterDeclaration(contentParam, undefined); + param.annotations = [annotation("memo")]; + + return param; +} + +function createInitializerArgInBuildMethod(className: string): arkts.ETSParameterExpression { + return arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier( + 'initializers', + arkts.factory.createTypeReferenceFromId( + arkts.factory.createIdentifier(`__Options_${className}`) + ) + ).setOptional(true), + undefined + ); +} + +function prepareArgsInBuildMethod(className: string): arkts.ETSParameterExpression[] { + return [ + createStyleArgInBuildMethod(className), + createContentArgInBuildMethod(), + createInitializerArgInBuildMethod(className) + ]; +} + +function transformBuildMethod( + method: arkts.MethodDefinition, + className: string +): arkts.MethodDefinition { + const updateKey: arkts.Identifier = arkts.factory.createIdentifier( + '_build' + ); + + const scriptFunction: arkts.ScriptFunction = method.scriptFunction; + + const params: arkts.ETSParameterExpression[] = prepareArgsInBuildMethod(className); + + const signature: arkts.FunctionSignature = arkts.FunctionSignature.create( + undefined, + params, + undefined + ); + const updateScriptFunction = arkts.factory.createScriptFunction( + scriptFunction.body, + signature, + scriptFunction.scriptFunctionFlags, + scriptFunction.modifiers, + false, + undefined + ); + + updateScriptFunction.annotations = [annotation("memo")]; + + // TODO: Currently, just return method itself. Remove this once createMethodDefinition is ready. + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + updateKey, + arkts.factory.createFunctionExpression(updateScriptFunction), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PROTECTED, + false + ); +} + +function tranformClassMembers(node: arkts.ClassDeclaration): arkts.ClassDeclaration { + const definition: arkts.ClassDefinition = node.definition; + const className: string = node.definition.name.name; + + const updateMembers: arkts.AstNode[] = definition.members.map((member: arkts.AstNode) => { + if (arkts.isMethodDefinition(member) && isKnownMethodDefinition(member, "constructor")) { + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_CONSTRUCTOR, + member.name, + arkts.factory.createFunctionExpression(member.scriptFunction), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR, + false + ); + } + if (arkts.isMethodDefinition(member) && isKnownMethodDefinition(member, "build")) { + return transformBuildMethod(member, className); + } + + return member; + }); + + const updateClassDef: arkts.ClassDefinition = arkts.factory.updateClassDefinition( + definition, + definition.name, + updateMembers, + definition.modifiers, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + definition.typeParamsDecl, + definition.superClass + ); + + return arkts.factory.updateClassDeclaration(node, updateClassDef); +} + +export class StructTransformer extends AbstractVisitor { + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren); + if (arkts.isClassDeclaration(node) && isCustomComponentClass(node)) { + return tranformClassMembers(node); + } + return node; + } +} diff --git a/arkoala-arkts/libarkts/plugins/tsconfig.json b/arkoala-arkts/libarkts/plugins/tsconfig.json index d0ce6f2228dd65d7edd13be46f938c0f80e98558..a460c9048c088fdb8c876ec39edb9be7214c9c71 100644 --- a/arkoala-arkts/libarkts/plugins/tsconfig.json +++ b/arkoala-arkts/libarkts/plugins/tsconfig.json @@ -14,5 +14,7 @@ "./src/print-visitor.ts", "./src/builder-lambda-transformer.ts", "./src/component-transformer.ts", + "./src/struct-transformer.ts", + "./src/arkts-utils.ts", ] } diff --git a/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts b/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts index e62809f69870d79fb9ddeab09c92f0c51464216b..f3fe48606fcdec90e0d1406ceee7f92707b8e280 100644 --- a/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts +++ b/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts @@ -53,6 +53,9 @@ export class Es2pandaNativeModule { _AnnotationAllowedAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { throw new Error("Not implemented") } + _AnnotationAllowedAnnotationsConst(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error("Not implemented") + } _AstNodeRebind(context: KPtr, node: KPtr): void { throw new Error("Not implemented") } @@ -164,6 +167,9 @@ export class Es2pandaNativeModule { _ScriptFunctionBody(context: KPtr, node: KPtr): KPtr { throw new Error("Not implemented") } + _ScriptFunctionAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error("Not implemented") + } _ScriptFunctionSetIdent(context: KPtr, ast: KPtr, id: KPtr): KPtr { throw new Error("Not implemented") } @@ -176,6 +182,9 @@ export class Es2pandaNativeModule { _ScriptFunctionSetScope(context: KPtr, ast: KPtr, scope: KPtr): KPtr { throw new Error("Not implemented") } + _ScriptFunctionSetAnnotations(context: KPtr, ast: KPtr, annotations: KPtrArray, annotationsLen: KInt): KPtr { + throw new Error("Not implemented") + } _ScriptFunctionDeclareConst(context: KPtr, node: KPtr): KBoolean { throw new Error("Not implemented") } @@ -191,6 +200,12 @@ export class Es2pandaNativeModule { _ScriptFunctionAddFlag(context: KPtr, node: KPtr, flags: KInt): void { throw new Error("Not implemented") } + _ClassPropertyAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error("Not implemented") + } + _ClassPropertySetAnnotations(context: KPtr, ast: KPtr, annotations: KPtrArray, annotationsLen: KInt): KPtr { + throw new Error("Not implemented") + } _UpdateBlockStatement(context: KPtr, original: KPtr, statementList: KPtrArray, statementListLen: KInt): KPtr { throw new Error("Not implemented") } @@ -392,6 +407,12 @@ export class Es2pandaNativeModule { _ETSParameterExpressionIdent(context: KPtr, node: KPtr): KPtr { throw new Error("Not implemented") } + _ETSParameterExpressionAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error("Not implemented") + } + _ETSParameterExpressionSetAnnotations(context: KPtr, ast: KPtr, annotations: KPtrArray, annotationsLen: KInt): KPtr { + throw new Error("Not implemented") + } _CreateTSTypeParameterDeclaration(context: KPtr, params: KPtrArray, paramsLen: KInt, requiredParams: KInt): KPtr { throw new Error("Not implemented") } @@ -551,6 +572,25 @@ export class Es2pandaNativeModule { _DeclarationFromIdentifier(context: KPtr, identifier: KPtr): KPtr { throw new Error("Not implemented") } + _IsTSInterfaceDeclaration(ast: KNativePointer): KBoolean { + throw new Error("Not implemented") + } + + _IsAnnotationDeclaration(ast: KNativePointer): KBoolean { + throw new Error("Not implemented") + } + + _IsAnnotationUsage(ast: KNativePointer): KBoolean { + throw new Error("Not implemented") + } + + _IsClassProperty(ast: KNativePointer): KBoolean { + throw new Error("Not implemented") + } + + _CreateAnnotationUsageIr(context: KPtr, ast: KPtr): KPtr { + throw new Error("Not implemented") + } } export function initEs2panda(): Es2pandaNativeModule { diff --git a/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts b/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts index 212f6a30c5b642fa31bfa5fb13c7737c578bf7c6..fa2a83a5a7d9c9917032bb43c2a7c7e9d4fc7dad 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts @@ -13,103 +13,19 @@ * limitations under the License. */ -import { - AnnotationUsageIr, - ArrowFunctionExpression, - AssignmentExpression, - BinaryExpression, - BlockStatement, - CallExpression, - ClassDeclaration, - ClassDefinition, - ClassProperty, - ClassStaticBlock, - ETSFunctionType, - EtsImportDeclaration, - ETSParameterExpression, - ETSPrimitiveType, - EtsScript, - ETSTypeReference, - ETSTypeReferencePart, - ETSUndefinedType, - ETSUnionType, - ExpressionStatement, - FunctionDeclaration, - FunctionExpression, - Identifier, - IfStatement, - ImportSpecifier, - MethodDefinition, - NumberLiteral, - ReturnStatement, - ScriptFunction, - StringLiteral, - StructDeclaration, - SuperExpression, - TSTypeParameter, - TSTypeParameterDeclaration, - UndefinedLiteral, - UnsupportedNode, - VariableDeclaration, - VariableDeclarator -} from "./types" import { Es2pandaAstNodeType } from "../Es2pandaEnums" -import { MemberExpression } from "./to-be-generated/MemberExpression" import { throwError } from "../utils" import { global } from "./static/global" import { KNativePointer, nullptr } from "@koalaui/interop" -import { AstNode } from "./peers/AstNode" -import { nodes as generatedNodes } from "../generated/node-map" +import { AstNode, UnsupportedNode } from "./peers/AstNode" -export function classByPeer(peer: KNativePointer): AstNode { - const nodes = new Map([ - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, EtsScript], - [Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, Identifier], - [Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, StringLiteral], - [Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, NumberLiteral], - [Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, ExpressionStatement], - [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, FunctionDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, ScriptFunction], - [Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, BlockStatement], - [Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, ReturnStatement], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, ETSParameterExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, ETSTypeReference], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART, ETSTypeReferencePart], - [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, TSTypeParameterDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, ETSPrimitiveType], - [Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, CallExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, MemberExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, TSTypeParameter], - [Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, IfStatement], - [Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, BinaryExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, ETSUnionType], - [Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, ArrowFunctionExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION, StructDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, ClassDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, ClassDefinition], - [Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, MethodDefinition], - [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, ClassProperty], - [Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, AssignmentExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, VariableDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, VariableDeclarator], - [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION, FunctionExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, ETSFunctionType], - [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, ClassStaticBlock], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, ETSUndefinedType], - [Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL, UndefinedLiteral], - [Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, SuperExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, EtsImportDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, ImportSpecifier], - [Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, AnnotationUsageIr], - ]) +export const nodeByType = new Map([]) +export function classByPeer(peer: KNativePointer): T { if (peer === nullptr) { throwError('classByPeer: peer is NULLPTR') } const type = global.generatedEs2panda._AstNodeTypeConst(global.context, peer) - const node = nodes.get(type) ?? generatedNodes.get(type) - if (node === undefined) { - return new UnsupportedNode(peer) - } - return new node(peer) + const node = nodeByType.get(type) ?? UnsupportedNode + return new node(peer) as T } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts index ff36ada6fe71586ed48aadfffa6919ab11c5a85b..4f3f39b21ed6f865cb99939815cf43941294bd3a 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts @@ -21,6 +21,7 @@ import { CallExpression, ClassDeclaration, ClassDefinition, + ClassProperty, ETSFunctionType, EtsImportDeclaration, ETSParameterExpression, @@ -46,11 +47,13 @@ import { TSTypeParameter, TSTypeParameterDeclaration, TSTypeParameterInstantiation, + UndefinedLiteral, VariableDeclaration, VariableDeclarator } from "../types" import { MemberExpression } from "../to-be-generated/MemberExpression" import { AstNode } from "../peers/AstNode" +import { AnnotationUsage } from "../../generated" function compose( create: (...args: ARGS) => T, @@ -238,6 +241,12 @@ export const factory = { get updateClassDefinition() { return compose(ClassDefinition.create) }, + get createClassProperty() { + return ClassProperty.create + }, + get updateClassProperty() { + return compose(ClassProperty.create) + }, get createFunctionType() { return ETSFunctionType.create }, @@ -274,4 +283,16 @@ export const factory = { get updateInterfaceDeclaration() { return compose(TSInterfaceDeclaration.create) }, + get createUndefinedLiteral() { + return UndefinedLiteral.create + }, + get updateUndefinedLiteral() { + return compose(UndefinedLiteral.create) + }, + get createAnnotationUsage() { + return AnnotationUsage.createAnnotationUsage + }, + get updateAnnotationUsageIr() { + return compose(UndefinedLiteral.create) + }, } diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts index 07750fe2ffb1e9e3c7d35614b9f4485866415eaf..dd87fe0c4eabe05660f900240f9a7f71f882e664 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts @@ -1,4 +1,6 @@ +import { global } from "../static/global" import { + AnnotationDeclaration, ArrowFunctionExpression, BlockStatement, CallExpression, @@ -14,11 +16,21 @@ import { ScriptFunction, StringLiteral, StructDeclaration, + TSInterfaceDeclaration, VariableDeclaration, + ClassProperty } from "../types" import { MemberExpression } from "../to-be-generated/MemberExpression" import { AstNode } from "../peers/AstNode" +export function isAnnotationDeclaration(node: AstNode): node is AnnotationDeclaration { + return global.es2panda._IsAnnotationDeclaration(node.peer); +} + +export function isTSInterfaceDeclaration(node: AstNode): node is TSInterfaceDeclaration { + return global.es2panda._IsTSInterfaceDeclaration(node.peer); +} + export function isIdentifier(node: AstNode): node is Identifier { return node instanceof Identifier } @@ -86,3 +98,7 @@ export function isStringLiteral(node: AstNode): node is StringLiteral { export function isClassDefinition(node: AstNode): node is ClassDefinition { return node instanceof ClassDefinition } + +export function isClassProperty(node: AstNode): node is ClassProperty { + return node instanceof ClassProperty +} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/index.ts b/arkoala-arkts/libarkts/src/arkts-api/index.ts index 8e444fc04a7647378c791a084ade7cc4ec62d1b7..b6926ba0fe3f2263f046b4811a2dd382e75c4117 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/index.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/index.ts @@ -15,6 +15,7 @@ export * from "../Es2pandaEnums" export * from "../generated/Es2pandaEnums" +export * from "../generated/peers/AnnotationUsage" export * from "./types" export * from "./utilities/private" @@ -22,7 +23,8 @@ export * from "./utilities/public" export * from "./factory/nodeFactory" export * from "./factory/nodeTests" export * from "./visitor" -export * from "./peers/AstNode" +export type { AstNode } from "./peers/AstNode" +import "../generated" export * from "./peers/Config" export * from "./peers/Context" export * from "./to-be-generated/MemberExpression" diff --git a/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts b/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts index 5fc86f1882be071cef9206e6e8648b1a33013ecc..2ba4dfb1e1872e832a60ec4ab0bdbf7e983dd3af 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts @@ -13,29 +13,23 @@ * limitations under the License. */ -import { KNativePointer } from "@koalaui/interop" +import { isNullPtr, KInt, KNativePointer as KPtr, KNativePointer, nullptr } from "@koalaui/interop" import { global } from "../static/global" -import { Es2pandaAstNodeType } from "../../Es2pandaEnums" -import { unpackNodeArray, unpackNonNullableNode, unpackString } from "../utilities/private" +import { allFlags, nodeType, unpackNodeArray, unpackNonNullableNode, unpackString } from "../utilities/private" import { throwError } from "../../utils" import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums" -import { allFlags } from "../types" -import { KInt } from "@koalaui/interop" -import { isNullPtr, nullptr } from "@koalaui/interop" import { ArktsObject } from "./ArktsObject" +import { Es2pandaAstNodeType } from "../../Es2pandaEnums" export abstract class AstNode extends ArktsObject { protected constructor(peer: KNativePointer) { if (isNullPtr(peer)) { - throw new Error('trying to create new Node on NULLPTR') + throwError(`attempted to create AstNode from nullptr`) } super(peer) - this.type = global.generatedEs2panda._AstNodeTypeConst(global.context, this.peer) this.updateChildren() } - readonly type: Es2pandaAstNodeType - public get originalPeer(): KNativePointer { return global.generatedEs2panda._AstNodeOriginalNodeConst(global.context, this.peer) } @@ -50,7 +44,7 @@ export abstract class AstNode extends ArktsObject { public getSubtree(): readonly AstNode[] { return this.getChildren().reduce( - (prev: readonly AstNode[], curr: AstNode): readonly AstNode[] => { + (prev: readonly AstNode[], curr) => { return prev.concat(curr.getSubtree()) }, [this] @@ -75,7 +69,6 @@ export abstract class AstNode extends ArktsObject { .map((it) => it.dump(indentation + 1)) const msg = `${indentation}_` - + Es2pandaAstNodeType[this.type] + ` ` + this.dumpMessage() return "> " + " ".repeat(4 * indentation) + msg + "\n" + children.join("") @@ -98,11 +91,11 @@ export abstract class AstNode extends ArktsObject { } public get parent(): AstNode { - const _parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer) - if (_parent === nullptr) { - throwError('BAD ACCESS: PARENT IS NULLPTR') + const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer) + if (parent === nullptr) { + throwError(`no parent`) } - return unpackNonNullableNode(_parent) + return unpackNonNullableNode(parent) } public set parent(node: AstNode) { @@ -118,3 +111,11 @@ export abstract class AstNode extends ArktsObject { global.generatedEs2panda._AstNodeAddModifier(global.context, this.peer, flags ?? Es2pandaModifierFlags.MODIFIER_FLAGS_NONE) } } + + +export class UnsupportedNode extends AstNode { + constructor(peer: KPtr) { + super(peer) + console.warn(`Warning: unsupported node ${Es2pandaAstNodeType[nodeType(this)]}`) + } +} diff --git a/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts b/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts index 07fede2a8f024ee5ecad4c826e688476c4dc2ba2..e6ee16f0b1f705725e1efcd60310da806aee762e 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts @@ -24,9 +24,6 @@ export class Context extends ArktsObject { super(peer) } - // TODO: - // static create - static createFromString( source: string ): Context { diff --git a/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts b/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts index f760db27aae26ba2f6e15dc5598e0bb4dd1943e4..ac8213680266d3c21d870fa8db30698870834973 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts @@ -13,13 +13,17 @@ * limitations under the License. */ -import { global } from "../static/global" -import { assertValidPeer } from "../types" -import { Es2pandaMemberExpressionKind } from "../../generated/Es2pandaEnums" -import { passNode, unpackNonNullableNode } from "../utilities/private" -import { KNativePointer } from "@koalaui/interop" -import { Es2pandaAstNodeType } from "../../Es2pandaEnums" -import { AstNode } from "../peers/AstNode" + +import { + assertValidPeer, + AstNode, + Es2pandaAstNodeType, + Es2pandaMemberExpressionKind, + KNativePointer, + passNode, + unpackNonNullableNode, + global +} from "../../reexport-for-generated" export class MemberExpression extends AstNode { constructor(peer: KNativePointer) { diff --git a/arkoala-arkts/libarkts/src/arkts-api/types.ts b/arkoala-arkts/libarkts/src/arkts-api/types.ts index 10b6b5197ea8d416e498ade67fe08e32b860a421..e546bff6ec8c0dba3b2f5e1e80cf1b52b1bb7639 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/types.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/types.ts @@ -12,13 +12,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - import { global } from "./static/global" -import { throwError } from "../utils" -import { KBoolean, KInt, KNativePointer as KPtr, nullptr } from "@koalaui/interop" +import { KBoolean, KInt, KNativePointer, KNativePointer as KPtr, nullptr } from "@koalaui/interop" import { - Es2pandaClassDefinitionModifiers, Es2pandaContextState, + Es2pandaExpressionParseFlags, Es2pandaIdentifierFlags, Es2pandaImportKinds, Es2pandaMethodDefinitionKind, @@ -30,10 +28,13 @@ import { Es2pandaVariableDeclaratorFlag, } from "../generated/Es2pandaEnums" import { + allFlags, + arrayOfNullptr, + assertValidPeer, + nodeType, passNode, passNodeArray, passString, - resolveSource, unpackNode, unpackNodeArray, unpackNonNullableNode, @@ -46,34 +47,10 @@ import { AstNode } from "./peers/AstNode" import { ArktsObject } from "./peers/ArktsObject" import { Config } from "./peers/Config" import { Context } from "./peers/Context" -import { factory } from "@koalaui/ets-tsc" - -export const arrayOfNullptr = new BigUint64Array([nullptr]) - -export const allFlags: KInt = - Object.values(Es2pandaModifierFlags).filter( - (value: any) => { return (typeof value) === 'number' } - ).reduce( - (prev: KInt, next: KInt): KInt => (prev | next), - 0 as KInt - ) - -export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): void { - if (peer === nullptr) { - throwError(`invalid peer: NULLPTR`) - } - const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer) - if (peerType !== expectedKind) { - throwError(`actual type of peer: ${peerType} expected: ${expectedKind}`) - } -} - -export class UnsupportedNode extends AstNode { - constructor(peer: KPtr) { - super(peer) - console.log(`WARNING: UNSUPPORTED NODE (arkts): ${Es2pandaAstNodeType[this.type]}`) - } -} +import * as path from "node:path" +import { nodeByType } from "./class-by-peer" +import { MemberExpression } from "./to-be-generated/MemberExpression" +import { AnnotationUsage, Expression } from "../generated" export class EtsScript extends AstNode { constructor(peer: KPtr) { @@ -254,10 +231,6 @@ export class ETSPrimitiveType extends AstNode { ) } - protected override dumpMessage(): string { - return ` ` - } - readonly primitiveType: Es2pandaPrimitiveType } @@ -298,6 +271,7 @@ export class ETSTypeReferencePart extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART) super(peer) + this.typeName = unpackNonNullableNode(global.generatedEs2panda._ETSTypeReferencePartName(global.context, this.peer)); } // TODO: support type params and prev @@ -317,7 +291,7 @@ export class ETSTypeReferencePart extends AstNode { ) } - // readonly typeName: Identifier + readonly typeName: Identifier } export class TSUnionType extends AstNode { @@ -388,7 +362,7 @@ export class ETSFunctionType extends AstNode { } } -export class Identifier extends AstNode { +export class Identifier extends Expression { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER) super(peer) @@ -396,17 +370,21 @@ export class Identifier extends AstNode { static create( name: string, - typeAnnotation?: AstNode + typeAnnotation?: AstNode, ): Identifier { - if (typeAnnotation === undefined) { - return new Identifier( - global.es2panda._CreateIdentifier1(global.context, passString(name)) - ) - } else { - return new Identifier( - global.es2panda._CreateIdentifier2(global.context, passString(name), typeAnnotation.peer) - ) - } + return new Identifier( + global.es2panda._CreateIdentifier2(global.context, passString(name), passNode(typeAnnotation)) + ) + } + + setOptional(optional: boolean): Identifier { + global.generatedEs2panda._IdentifierSetOptional(global.context, this.peer, optional) + return this + } + + setAnnotationUsage(): Identifier { + global.generatedEs2panda._IdentifierSetAnnotationUsage(global.context, this.peer); + return this; } protected override dumpMessage(): string { @@ -554,6 +532,12 @@ export class ScriptFunction extends AstNode { return new ScriptFunction(peer) } + setIdent(id: Identifier): ScriptFunction { + assertValidPeer(id.peer, Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER); + global.generatedEs2panda._ScriptFunctionSetIdent(global.context, this.peer, id.peer); + return this; + } + protected override dumpMessage(): string { const scriptFunctionFlags = global.generatedEs2panda._ScriptFunctionFlagsConst(global.context, this.peer) return ` ` @@ -580,7 +564,7 @@ export class ScriptFunction extends AstNode { // TODO: goes through whole subtree, optimizable (unnecessary now) this.body.getSubtree().forEach( (node: AstNode) => { - hasReturn = hasReturn || (node.type === Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT) + hasReturn = hasReturn || nodeType(node) === Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT } ) return hasReturn @@ -596,6 +580,23 @@ export class ScriptFunction extends AstNode { // readonly signature: FunctionSignature readonly scriptFunctionFlags: KInt readonly ident?: Identifier + + get annotations(): AnnotationUsage[] { + return unpackNodeArray(global.es2panda._ScriptFunctionAnnotations( + global.context, + this.peer, + nullptr + )) + } + + set annotations(newAnnotations: AnnotationUsage[]) { + global.es2panda._ScriptFunctionSetAnnotations( + global.context, + this.peer, + passNodeArray(newAnnotations), + newAnnotations.length + ); + } } export class ArrowFunctionExpression extends AstNode { @@ -721,6 +722,23 @@ export class ETSParameterExpression extends AstNode { ) ) } + + get annotations(): AnnotationUsage[] { + return unpackNodeArray(global.es2panda._ETSParameterExpressionAnnotations( + global.context, + this.peer, + nullptr + )) + } + + set annotations(newAnnotations: AnnotationUsage[]) { + global.es2panda._ETSParameterExpressionSetAnnotations( + global.context, + this.peer, + passNodeArray(newAnnotations), + newAnnotations.length + ); + } } export class TSTypeParameterDeclaration extends AstNode { @@ -933,10 +951,20 @@ export class ClassStaticBlock extends AstNode { } export class MethodDefinition extends AstNode { - constructor(peer: KPtr) { + constructor(peer: KPtr, key?: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION) super(peer) + this.kind = global.generatedEs2panda._MethodDefinitionKindConst(global.context, this.peer); this.scriptFunction = unpackNonNullableNode(global.generatedEs2panda._MethodDefinitionFunction(global.context, this.peer)) + assertValidPeer(this.scriptFunction.peer, Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION); + + // Somehow the scriptFunction cannot attach method's key to its ident after checker + if (key) { + assertValidPeer(key, Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER); + const _name = unpackNonNullableNode(key); + this.scriptFunction = this.scriptFunction.setIdent(_name as Identifier); + } + this.name = unpackNonNullableNode(global.generatedEs2panda._ScriptFunctionId(global.context, this.scriptFunction.peer)) this.kind = global.generatedEs2panda._MethodDefinitionKindConst(global.context, this.peer) } @@ -956,13 +984,19 @@ export class MethodDefinition extends AstNode { passNode(value), modifiers, isComputed - ) + ), + key.peer ) } + // TODO: does not work + isConstructor(): boolean { + return global.generatedEs2panda._MethodDefinitionIsConstructorConst(global.context, this.peer); + } + + readonly kind: Es2pandaMethodDefinitionKind; readonly scriptFunction: ScriptFunction readonly name: Identifier - readonly kind: Es2pandaMethodDefinitionKind } export class ClassElement extends AstNode { @@ -980,6 +1014,7 @@ export class ClassProperty extends ClassElement { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY) super(peer) + this.typeAnnotation = unpackNonNullableNode(global.generatedEs2panda._ClassPropertyTypeAnnotationConst(global.context, this.peer)); } static create( @@ -1000,6 +1035,27 @@ export class ClassProperty extends ClassElement { ) ) } + + get annotations(): AnnotationUsage[] { + return unpackNodeArray( + global.es2panda._ScriptFunctionAnnotations( + global.context, + this.peer, + nullptr + ) + ) + } + + set annotations(newAnnotations: AnnotationUsage[]) { + global.es2panda._ScriptFunctionSetAnnotations( + global.context, + this.peer, + passNodeArray(newAnnotations), + newAnnotations.length + ); + } + + readonly typeAnnotation: ETSTypeReference; } export class VariableDeclaration extends AstNode { @@ -1067,6 +1123,7 @@ export class SuperExpression extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION) super(peer) + this.id = unpackNonNullableNode(global.generatedEs2panda._TSInterfaceDeclarationId(global.context, this.peer)); } static create( @@ -1077,6 +1134,8 @@ export class SuperExpression extends AstNode { ) ) } + + readonly id?: Identifier; } export class ImportSource extends ArktsObject { @@ -1092,7 +1151,9 @@ export class ImportSource extends ArktsObject { global.es2panda._CreateImportSource( global.context, source.peer, - resolveSource(source).peer, + StringLiteral.create( + path.resolve(source.str).toString() + ).peer, hasDecl ) ) @@ -1157,21 +1218,6 @@ export class ImportSpecifier extends AstNode { } } -export class AnnotationUsageIr extends AstNode { - constructor(peer: KPtr) { - assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE) - super(peer) - this.expr = unpackNonNullableNode(global.generatedEs2panda._AnnotationUsageIrExpr(global.context, this.peer)) - this.properties = unpackNodeArray(global.generatedEs2panda._AnnotationUsageIrPropertiesConst(global.context, this.peer)) - } - - // TODO: - // static create - - readonly expr: AstNode - readonly properties: readonly ClassProperty[] -} - export class TSTypeParameterInstantiation extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION) @@ -1225,4 +1271,69 @@ export class UndefinedLiteral extends AstNode { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL) super(peer) } + + static create(): UndefinedLiteral { + return new UndefinedLiteral( + global.generatedEs2panda._CreateUndefinedLiteral(global.context) + ) + } +} + +export class AnnotationDeclaration extends AstNode { + constructor(peer: KPtr) { + assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION); + super(peer) + } + + static create( + expr: AstNode + ): AnnotationDeclaration { + return new AnnotationDeclaration ( + global.generatedEs2panda._CreateAnnotationDeclaration( + global.context, + passNode(expr) + ) + ) + } } + +const pairs: [Es2pandaAstNodeType, { new(peer: KNativePointer): AstNode }][] = [ + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, EtsScript], + [Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, Identifier], + [Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, StringLiteral], + [Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, NumberLiteral], + [Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, ExpressionStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, FunctionDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, ScriptFunction], + [Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, BlockStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, ReturnStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, ETSParameterExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, ETSTypeReference], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART, ETSTypeReferencePart], + [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, TSTypeParameterDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, ETSPrimitiveType], + [Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, CallExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, MemberExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, TSTypeParameter], + [Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, IfStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, BinaryExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, ETSUnionType], + [Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, ArrowFunctionExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION, StructDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, ClassDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, ClassDefinition], + [Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, MethodDefinition], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, ClassProperty], + [Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, AssignmentExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, VariableDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, VariableDeclarator], + [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION, FunctionExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, ETSFunctionType], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, ClassStaticBlock], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, ETSUndefinedType], + [Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL, UndefinedLiteral], + [Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, SuperExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, EtsImportDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, ImportSpecifier], +] +pairs.forEach(([tp, cctor]) => nodeByType.set(tp, cctor)) \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts index c6ec7acdc97ad40f98c9c6c5eadeed19372adf3c..9f5d10457c3c3b35647cd0ec287b122a9ed3e409 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts @@ -14,16 +14,43 @@ */ import { global } from "../static/global" -import { throwError } from "../../utils" -import { KInt, KNativePointer, nullptr, withString, withStringArray, withStringResult } from "@koalaui/interop" +import { isNumber, throwError } from "../../utils" +import { + KInt, + KNativePointer as KPtr, + KNativePointer, + nullptr, + withString, + withStringArray, + withStringResult +} from "@koalaui/interop" import { NativePtrDecoder } from "./nativePtrDecoder" -import * as path from "node:path" -import { allFlags, StringLiteral } from "../types" -import { Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums" -import { factory } from "../factory/nodeFactory" +import { Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums" import { classByPeer } from "../class-by-peer" -import { AstNode } from "../peers/AstNode" +import type { AstNode } from "../peers/AstNode" import { ArktsObject } from "../peers/ArktsObject" +import { Es2pandaAstNodeType } from "../../Es2pandaEnums" + +export const arrayOfNullptr = new BigUint64Array([nullptr]) + +export const allFlags = + Object.values(Es2pandaModifierFlags) + .filter(isNumber) + .reduce( + (prev, next) => (prev | next), + 0 + + ) + +export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): void { + if (peer === nullptr) { + throwError(`invalid peer`) + } + const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer) + if (peerType !== expectedKind) { + throwError(`expected: ${Es2pandaAstNodeType[expectedKind]}, got: ${Es2pandaAstNodeType[peerType]}`) + } +} export function unpackNonNullableNode(peer: KNativePointer): T { if (peer === nullptr) { @@ -130,8 +157,6 @@ export function updateNodeByNode(node: T, original: AstNode): return node } -export function resolveSource(source: StringLiteral): StringLiteral { - return factory.createStringLiteral( - path.resolve(source.str).toString() - ) +export function nodeType(node: AstNode): Es2pandaAstNodeType { + return global.generatedEs2panda._AstNodeTypeConst(global.context, passNode(node)) } diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts index dbea933f3c14c53834281e4863a39e766a3d4279..de723054eecd7cb658e4770a6acfbc4efbe6879e 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts @@ -15,13 +15,12 @@ import { global } from "../static/global" import { throwError } from "../../utils" -import { KNativePointer, nullptr, withStringResult } from "@koalaui/interop" -import { AnnotationUsageIr, MethodDefinition } from "../types" +import { nullptr, withStringResult } from "@koalaui/interop" import { passNode, unpackNodeArray, unpackNonNullableNode } from "./private" import { isClassDefinition, isFunctionDeclaration, isScriptFunction } from "../factory/nodeTests" import { Es2pandaContextState } from "../../generated/Es2pandaEnums" -import { AstNode } from "../peers/AstNode" -import { Identifier } from "../types" +import type { AstNode } from "../peers/AstNode" +import type { AnnotationUsage } from "../../generated" export function proceedToState(state: Es2pandaContextState): void { if (state <= global.es2panda._ContextState(global.context)) { @@ -32,9 +31,15 @@ export function proceedToState(state: Es2pandaContextState): void { if (global.es2panda._ContextState(global.context) === Es2pandaContextState.ES2PANDA_STATE_ERROR) { const errorMessage = withStringResult(global.es2panda._ContextErrorMessage(global.context)) if (errorMessage === undefined) { - throwError(`COULDN'T GET ContextErrorMessage`) + throwError(`Could not get ContextErrorMessage`) } - throwError("FAILED PROCEED TO: " + Es2pandaContextState[state] + "\n" + errorMessage) + throwError( + [ + `Failed to proceed to ${Es2pandaContextState[state]}`, + errorMessage + ] + .join(`\n`) + ) } } catch (e) { global.es2panda._DestroyContext(global.context) @@ -62,7 +67,7 @@ export function getDecl(node: AstNode): AstNode | undefined { return unpackNonNullableNode(decl) } -export function getAnnotations(node: AstNode): readonly AnnotationUsageIr[] { +export function getAnnotations(node: AstNode): readonly AnnotationUsage[] { if (!isFunctionDeclaration(node) && !isScriptFunction(node) && !isClassDefinition(node)) { throwError('for now annotations allowed only for: functionDeclaration, scriptFunction, classDefinition') } diff --git a/arkoala-arkts/libarkts/src/arkts-api/visitor.ts b/arkoala-arkts/libarkts/src/arkts-api/visitor.ts index f114ccef781eca77d431c1a79213f0a06b1baa31..622448e3856bc4dc82e6cbe07fc5dee781e4896b 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/visitor.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/visitor.ts @@ -38,6 +38,53 @@ import { MemberExpression } from "./to-be-generated/MemberExpression" type Visitor = (node: AstNode) => AstNode +export interface DoubleNode { + originNode: AstNode; + translatedNode: AstNode; +} + +export class StructInfo { + stateVariables: Set = new Set(); +} + +export class GlobalInfo { + private _structCollection: Set; + private static instance: GlobalInfo; + private _structMap: Map; + + private constructor() { + this._structCollection = new Set(); + this._structMap = new Map(); + } + + public static getInfoInstance(): GlobalInfo { + if (!this.instance) { + this.instance = new GlobalInfo(); + } + return this.instance; + } + + public add(str: string): void { + this._structCollection.add(str); + } + + public getStructCollection(): Set { + return this._structCollection; + } + + public getStructInfo(structName: string): StructInfo { + const structInfo = this._structMap.get(structName); + if (!structInfo) { + return new StructInfo(); + } + return structInfo; + } + + public setStructInfo(structName: string, info: StructInfo): void { + this._structMap.set(structName, info); + } +} + // TODO: rethink (remove as) function nodeVisitor(node: T, visitor: Visitor): T { if (node === undefined) { diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts index 07b9fbc43ffee8074ebe8c9751fdd9a6f0ac5686..36938c6ccd77e534b024160f2a07b1193e758ab1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" export abstract class AnnotatedAstNode extends AstNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts index e6bdfee720fab07637b81d6a773298711e4b6691..63624f801ca193f0f9008410bcc1a0d3e24f83a4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts index 171ecd6255d8aab423f89b2ada5de94c2d028693..679236e02c8690947a3d38eee8bdfac55c319cd8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts index aad6adc04e4a1e77e9a64523199dab625fb01f39..17c10a02ccfb3578e943183e52b5e78a0a716ebc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,16 +35,16 @@ export class AnnotationDeclaration extends Statement { super(pointer) console.warn("Warning: stub node AnnotationDeclaration") } - static createAnnotationDeclaration(expr?: Expression): AnnotationDeclaration | undefined { + static createAnnotationDeclaration(expr?: Expression): AnnotationDeclaration { return new AnnotationDeclaration(global.generatedEs2panda._CreateAnnotationDeclaration(global.context, passNode(expr))) } - static updateAnnotationDeclaration(original?: AnnotationDeclaration, expr?: Expression): AnnotationDeclaration | undefined { + static updateAnnotationDeclaration(original?: AnnotationDeclaration, expr?: Expression): AnnotationDeclaration { return new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration(global.context, passNode(original), passNode(expr))) } - static create1AnnotationDeclaration(expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationDeclaration | undefined { + static create1AnnotationDeclaration(expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationDeclaration { return new AnnotationDeclaration(global.generatedEs2panda._CreateAnnotationDeclaration1(global.context, passNode(expr), passNodeArray(properties), propertiesLen)) } - static update1AnnotationDeclaration(original: AnnotationDeclaration | undefined, expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationDeclaration | undefined { + static update1AnnotationDeclaration(original: AnnotationDeclaration | undefined, expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationDeclaration { return new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration1(global.context, passNode(original), passNode(expr), passNodeArray(properties), propertiesLen)) } get internalNameConst(): string { @@ -67,4 +68,7 @@ export class AnnotationDeclaration extends Statement { } export function isAnnotationDeclaration(node: AstNode): node is AnnotationDeclaration { return node instanceof AnnotationDeclaration +} +if (!nodeByType.has(1)) { + nodeByType.set(1, AnnotationDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts index 326159dd18604c8376243829977aa009cfdda716..8e324f9da55bb4f9a561edf4c0f25caa969017cb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,16 +35,16 @@ export class AnnotationUsage extends Statement { super(pointer) console.warn("Warning: stub node AnnotationUsage") } - static createAnnotationUsage(expr?: Expression): AnnotationUsage | undefined { + static createAnnotationUsage(expr?: Expression): AnnotationUsage { return new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsageIr(global.context, passNode(expr))) } - static updateAnnotationUsage(original?: AnnotationUsage, expr?: Expression): AnnotationUsage | undefined { + static updateAnnotationUsage(original?: AnnotationUsage, expr?: Expression): AnnotationUsage { return new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsageIr(global.context, passNode(original), passNode(expr))) } - static create1AnnotationUsage(expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationUsage | undefined { + static create1AnnotationUsage(expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationUsage { return new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsageIr1(global.context, passNode(expr), passNodeArray(properties), propertiesLen)) } - static update1AnnotationUsage(original: AnnotationUsage | undefined, expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationUsage | undefined { + static update1AnnotationUsage(original: AnnotationUsage | undefined, expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationUsage { return new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsageIr1(global.context, passNode(original), passNode(expr), passNodeArray(properties), propertiesLen)) } get expr(): Expression | undefined { @@ -61,4 +62,7 @@ export class AnnotationUsage extends Statement { } export function isAnnotationUsage(node: AstNode): node is AnnotationUsage { return node instanceof AnnotationUsage +} +if (!nodeByType.has(2)) { + nodeByType.set(2, AnnotationUsage) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts index 56113fd26eaded6d9e39b6a609a3e1194a93b522..fbdef94850d102d13ae69571f5c8ed33b7bc22be 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedExpression } from "./AnnotatedExpression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts index 2e6d050e7dacda46505f4785d5fc6ff45178bc92..90de76f6aaf494d8e56b7d70ebcd1682b4bc5c88 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -35,16 +36,16 @@ export class ArrowFunctionExpression extends Expression { super(pointer) console.warn("Warning: stub node ArrowFunctionExpression") } - static createArrowFunctionExpression(func?: ScriptFunction): ArrowFunctionExpression | undefined { + static createArrowFunctionExpression(func?: ScriptFunction): ArrowFunctionExpression { return new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression(global.context, passNode(func))) } - static updateArrowFunctionExpression(original?: ArrowFunctionExpression, func?: ScriptFunction): ArrowFunctionExpression | undefined { + static updateArrowFunctionExpression(original?: ArrowFunctionExpression, func?: ScriptFunction): ArrowFunctionExpression { return new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression(global.context, passNode(original), passNode(func))) } - static create1ArrowFunctionExpression(other?: ArrowFunctionExpression): ArrowFunctionExpression | undefined { + static create1ArrowFunctionExpression(other?: ArrowFunctionExpression): ArrowFunctionExpression { return new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression1(global.context, passNode(other))) } - static update1ArrowFunctionExpression(original?: ArrowFunctionExpression, other?: ArrowFunctionExpression): ArrowFunctionExpression | undefined { + static update1ArrowFunctionExpression(original?: ArrowFunctionExpression, other?: ArrowFunctionExpression): ArrowFunctionExpression { return new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression1(global.context, passNode(original), passNode(other))) } get functionConst(): ScriptFunction | undefined { @@ -62,4 +63,7 @@ export class ArrowFunctionExpression extends Expression { } export function isArrowFunctionExpression(node: AstNode): node is ArrowFunctionExpression { return node instanceof ArrowFunctionExpression +} +if (!nodeByType.has(0)) { + nodeByType.set(0, ArrowFunctionExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts index b21e36baff40e080967397e96f30dc96ad2aa744..d9ff4e1d559a1172e5a9f7e901e56112c3b0ce1b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,10 +35,10 @@ export class AssertStatement extends Statement { super(pointer) console.warn("Warning: stub node AssertStatement") } - static createAssertStatement(test?: Expression, second?: Expression): AssertStatement | undefined { + static createAssertStatement(test?: Expression, second?: Expression): AssertStatement { return new AssertStatement(global.generatedEs2panda._CreateAssertStatement(global.context, passNode(test), passNode(second))) } - static updateAssertStatement(original?: AssertStatement, test?: Expression, second?: Expression): AssertStatement | undefined { + static updateAssertStatement(original?: AssertStatement, test?: Expression, second?: Expression): AssertStatement { return new AssertStatement(global.generatedEs2panda._UpdateAssertStatement(global.context, passNode(original), passNode(test), passNode(second))) } get testConst(): Expression | undefined { @@ -52,4 +53,7 @@ export class AssertStatement extends Statement { } export function isAssertStatement(node: AstNode): node is AssertStatement { return node instanceof AssertStatement +} +if (!nodeByType.has(3)) { + nodeByType.set(3, AssertStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts index 84f10656d77a31d2f86984ca331d21f1601053cd..75085e0f2ae7aee722db441b871cfb7432eee7f1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts index e1981e7dc2a22e72a42f5dd0740e6b2a85f26785..47492db2d1cd8654ba0a94d4040ad7dbcf800f83 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,10 +34,10 @@ export class AwaitExpression extends Expression { super(pointer) console.warn("Warning: stub node AwaitExpression") } - static createAwaitExpression(argument?: Expression): AwaitExpression | undefined { + static createAwaitExpression(argument?: Expression): AwaitExpression { return new AwaitExpression(global.generatedEs2panda._CreateAwaitExpression(global.context, passNode(argument))) } - static updateAwaitExpression(original?: AwaitExpression, argument?: Expression): AwaitExpression | undefined { + static updateAwaitExpression(original?: AwaitExpression, argument?: Expression): AwaitExpression { return new AwaitExpression(global.generatedEs2panda._UpdateAwaitExpression(global.context, passNode(original), passNode(argument))) } get argumentConst(): Expression | undefined { @@ -45,4 +46,7 @@ export class AwaitExpression extends Expression { } export function isAwaitExpression(node: AstNode): node is AwaitExpression { return node instanceof AwaitExpression +} +if (!nodeByType.has(4)) { + nodeByType.set(4, AwaitExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts index 1d6b844be43c2381c2504997efe6e01fa69190ed..5138e43be05c99bb25d09ddd69eaa18418dc6a16 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -33,10 +34,10 @@ export class BigIntLiteral extends Literal { super(pointer) console.warn("Warning: stub node BigIntLiteral") } - static createBigIntLiteral(src: string): BigIntLiteral | undefined { + static createBigIntLiteral(src: string): BigIntLiteral { return new BigIntLiteral(global.generatedEs2panda._CreateBigIntLiteral(global.context, src)) } - static updateBigIntLiteral(original: BigIntLiteral | undefined, src: string): BigIntLiteral | undefined { + static updateBigIntLiteral(original: BigIntLiteral | undefined, src: string): BigIntLiteral { return new BigIntLiteral(global.generatedEs2panda._UpdateBigIntLiteral(global.context, passNode(original), src)) } get strConst(): string { @@ -45,4 +46,7 @@ export class BigIntLiteral extends Literal { } export function isBigIntLiteral(node: AstNode): node is BigIntLiteral { return node instanceof BigIntLiteral +} +if (!nodeByType.has(5)) { + nodeByType.set(5, BigIntLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts index 9a74606438fa1f5583a7ac8e04333be4d98ea401..ac197bf482c8615731614d0c5f9a87349ee60910 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class BinaryExpression extends Expression { super(pointer) console.warn("Warning: stub node BinaryExpression") } - static createBinaryExpression(left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression | undefined { + static createBinaryExpression(left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression { return new BinaryExpression(global.generatedEs2panda._CreateBinaryExpression(global.context, passNode(left), passNode(right), operatorType)) } - static updateBinaryExpression(original: BinaryExpression | undefined, left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression | undefined { + static updateBinaryExpression(original: BinaryExpression | undefined, left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression { return new BinaryExpression(global.generatedEs2panda._UpdateBinaryExpression(global.context, passNode(original), passNode(left), passNode(right), operatorType)) } get leftConst(): Expression | undefined { @@ -76,4 +77,7 @@ export class BinaryExpression extends Expression { } export function isBinaryExpression(node: AstNode): node is BinaryExpression { return node instanceof BinaryExpression +} +if (!nodeByType.has(6)) { + nodeByType.set(6, BinaryExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts index 39d766831341729f2e66377725b7644e8845f462..0a1465641e3b32da436da2490e8848cc7fb950a7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -43,4 +44,7 @@ export class BlockExpression extends Expression { } export function isBlockExpression(node: AstNode): node is BlockExpression { return node instanceof BlockExpression +} +if (!nodeByType.has(154)) { + nodeByType.set(154, BlockExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts index d6711fb0483bed8dff0d693bd33335ba1f8bc184..0a7b0b1aa7db37eff72a318f164122c2be965e17 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -42,4 +43,7 @@ export class BlockStatement extends Statement { } export function isBlockStatement(node: AstNode): node is BlockStatement { return node instanceof BlockStatement +} +if (!nodeByType.has(7)) { + nodeByType.set(7, BlockStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts index 9390b9ae6bcb4c26df975986796b57e9e7b12f21..d31f4b5a449fb59e8b53eae5401ac2e17091670a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -33,10 +34,10 @@ export class BooleanLiteral extends Literal { super(pointer) console.warn("Warning: stub node BooleanLiteral") } - static createBooleanLiteral(value: boolean): BooleanLiteral | undefined { + static createBooleanLiteral(value: boolean): BooleanLiteral { return new BooleanLiteral(global.generatedEs2panda._CreateBooleanLiteral(global.context, value)) } - static updateBooleanLiteral(original: BooleanLiteral | undefined, value: boolean): BooleanLiteral | undefined { + static updateBooleanLiteral(original: BooleanLiteral | undefined, value: boolean): BooleanLiteral { return new BooleanLiteral(global.generatedEs2panda._UpdateBooleanLiteral(global.context, passNode(original), value)) } get valueConst(): boolean { @@ -45,4 +46,7 @@ export class BooleanLiteral extends Literal { } export function isBooleanLiteral(node: AstNode): node is BooleanLiteral { return node instanceof BooleanLiteral +} +if (!nodeByType.has(8)) { + nodeByType.set(8, BooleanLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts index 8fb8051b59f934920f7887acd68427ad38d46978..44785b47a9f5c11d753c434a21d17b3abdd7b86e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,16 +35,16 @@ export class BreakStatement extends Statement { super(pointer) console.warn("Warning: stub node BreakStatement") } - static createBreakStatement(): BreakStatement | undefined { + static createBreakStatement(): BreakStatement { return new BreakStatement(global.generatedEs2panda._CreateBreakStatement(global.context)) } - static updateBreakStatement(original?: BreakStatement): BreakStatement | undefined { + static updateBreakStatement(original?: BreakStatement): BreakStatement { return new BreakStatement(global.generatedEs2panda._UpdateBreakStatement(global.context, passNode(original))) } - static create1BreakStatement(ident?: Identifier): BreakStatement | undefined { + static create1BreakStatement(ident?: Identifier): BreakStatement { return new BreakStatement(global.generatedEs2panda._CreateBreakStatement1(global.context, passNode(ident))) } - static update1BreakStatement(original?: BreakStatement, ident?: Identifier): BreakStatement | undefined { + static update1BreakStatement(original?: BreakStatement, ident?: Identifier): BreakStatement { return new BreakStatement(global.generatedEs2panda._UpdateBreakStatement1(global.context, passNode(original), passNode(ident))) } get identConst(): Identifier | undefined { @@ -58,4 +59,7 @@ export class BreakStatement extends Statement { } export function isBreakStatement(node: AstNode): node is BreakStatement { return node instanceof BreakStatement +} +if (!nodeByType.has(9)) { + nodeByType.set(9, BreakStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts index 495b700fcb5e62884d7076e448bacda88f47a5b1..b8673949859e05c3c5f40593198f0b6bc7b0ad70 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { MaybeOptionalExpression } from "./MaybeOptionalExpression" @@ -36,13 +37,13 @@ export class CallExpression extends MaybeOptionalExpression { super(pointer) console.warn("Warning: stub node CallExpression") } - static createCallExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, trailingComma: boolean): CallExpression | undefined { + static createCallExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, trailingComma: boolean): CallExpression { return new CallExpression(global.generatedEs2panda._CreateCallExpression(global.context, passNode(callee), passNodeArray(_arguments), argumentsLen, passNode(typeParams), optional_arg, trailingComma)) } - static create1CallExpression(other?: CallExpression): CallExpression | undefined { + static create1CallExpression(other?: CallExpression): CallExpression { return new CallExpression(global.generatedEs2panda._CreateCallExpression1(global.context, passNode(other))) } - static update1CallExpression(original?: CallExpression, other?: CallExpression): CallExpression | undefined { + static update1CallExpression(original?: CallExpression, other?: CallExpression): CallExpression { return new CallExpression(global.generatedEs2panda._UpdateCallExpression1(global.context, passNode(original), passNode(other))) } get calleeConst(): Expression | undefined { @@ -75,4 +76,7 @@ export class CallExpression extends MaybeOptionalExpression { } export function isCallExpression(node: AstNode): node is CallExpression { return node instanceof CallExpression +} +if (!nodeByType.has(10)) { + nodeByType.set(10, CallExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts b/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts index c22e26d9225423cba4385d6a57121798addc8bd6..6e214900d38e5108878e9ea9b80c93bdf39f64c2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedStatement } from "./TypedStatement" @@ -35,10 +36,10 @@ export class CatchClause extends TypedStatement { super(pointer) console.warn("Warning: stub node CatchClause") } - static createCatchClause(param?: Expression, body?: BlockStatement): CatchClause | undefined { + static createCatchClause(param?: Expression, body?: BlockStatement): CatchClause { return new CatchClause(global.generatedEs2panda._CreateCatchClause(global.context, passNode(param), passNode(body))) } - static updateCatchClause(original?: CatchClause, param?: Expression, body?: BlockStatement): CatchClause | undefined { + static updateCatchClause(original?: CatchClause, param?: Expression, body?: BlockStatement): CatchClause { return new CatchClause(global.generatedEs2panda._UpdateCatchClause(global.context, passNode(original), passNode(param), passNode(body))) } get param(): Expression | undefined { @@ -56,4 +57,7 @@ export class CatchClause extends TypedStatement { } export function isCatchClause(node: AstNode): node is CatchClause { return node instanceof CatchClause +} +if (!nodeByType.has(11)) { + nodeByType.set(11, CatchClause) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts index da0e9826c60b6d500f38de8be67883eb93ac3fe7..992c8db0ef98968bd45fb74b51fa8a82d9cc54f5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,10 +34,10 @@ export class ChainExpression extends Expression { super(pointer) console.warn("Warning: stub node ChainExpression") } - static createChainExpression(expression?: Expression): ChainExpression | undefined { + static createChainExpression(expression?: Expression): ChainExpression { return new ChainExpression(global.generatedEs2panda._CreateChainExpression(global.context, passNode(expression))) } - static updateChainExpression(original?: ChainExpression, expression?: Expression): ChainExpression | undefined { + static updateChainExpression(original?: ChainExpression, expression?: Expression): ChainExpression { return new ChainExpression(global.generatedEs2panda._UpdateChainExpression(global.context, passNode(original), passNode(expression))) } get getExpressionConst(): Expression | undefined { @@ -48,4 +49,7 @@ export class ChainExpression extends Expression { } export function isChainExpression(node: AstNode): node is ChainExpression { return node instanceof ChainExpression +} +if (!nodeByType.has(12)) { + nodeByType.set(12, ChainExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts index 73108082d26c0dafa2c898f8e104921bc6fc04e9..cc0c0d2b785fc984c836f6c580eaab55b5dfa530 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -33,13 +34,16 @@ export class CharLiteral extends Literal { super(pointer) console.warn("Warning: stub node CharLiteral") } - static createCharLiteral(): CharLiteral | undefined { + static createCharLiteral(): CharLiteral { return new CharLiteral(global.generatedEs2panda._CreateCharLiteral(global.context)) } - static updateCharLiteral(original?: CharLiteral): CharLiteral | undefined { + static updateCharLiteral(original?: CharLiteral): CharLiteral { return new CharLiteral(global.generatedEs2panda._UpdateCharLiteral(global.context, passNode(original))) } } export function isCharLiteral(node: AstNode): node is CharLiteral { return node instanceof CharLiteral +} +if (!nodeByType.has(13)) { + nodeByType.set(13, CharLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts index 7a126b6cd35b882fbd710bc52efd930e55311786..ba2f553011368e6b530d8e043876852c21ce0adf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -35,10 +36,10 @@ export class ClassDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ClassDeclaration") } - static createClassDeclaration(def?: ClassDefinition): ClassDeclaration | undefined { + static createClassDeclaration(def?: ClassDefinition): ClassDeclaration { return new ClassDeclaration(global.generatedEs2panda._CreateClassDeclaration(global.context, passNode(def))) } - static updateClassDeclaration(original?: ClassDeclaration, def?: ClassDefinition): ClassDeclaration | undefined { + static updateClassDeclaration(original?: ClassDeclaration, def?: ClassDefinition): ClassDeclaration { return new ClassDeclaration(global.generatedEs2panda._UpdateClassDeclaration(global.context, passNode(original), passNode(def))) } get definition(): ClassDefinition | undefined { @@ -53,4 +54,7 @@ export class ClassDeclaration extends Statement { } export function isClassDeclaration(node: AstNode): node is ClassDeclaration { return node instanceof ClassDeclaration +} +if (!nodeByType.has(15)) { + nodeByType.set(15, ClassDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts index e46a32592a5532eeeb75b0ff010d21fce60f1bc6..7a55b8e1683b375a6a636efe26b45d64303faa58 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedAstNode } from "./TypedAstNode" @@ -44,22 +45,22 @@ export class ClassDefinition extends TypedAstNode { super(pointer) console.warn("Warning: stub node ClassDefinition") } - static createClassDefinition(ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], implementsLen: number, ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { + static createClassDefinition(ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], implementsLen: number, ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { return new ClassDefinition(global.generatedEs2panda._CreateClassDefinition(global.context, passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), implementsLen, passNode(ctor), passNode(superClass), passNodeArray(body), bodyLen, modifiers, flags)) } - static updateClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], implementsLen: number, ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { + static updateClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], implementsLen: number, ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { return new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition(global.context, passNode(original), passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), implementsLen, passNode(ctor), passNode(superClass), passNodeArray(body), bodyLen, modifiers, flags)) } - static create1ClassDefinition(ident: Identifier | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { + static create1ClassDefinition(ident: Identifier | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { return new ClassDefinition(global.generatedEs2panda._CreateClassDefinition1(global.context, passNode(ident), passNodeArray(body), bodyLen, modifiers, flags)) } - static update1ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { + static update1ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { return new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition1(global.context, passNode(original), passNode(ident), passNodeArray(body), bodyLen, modifiers, flags)) } - static create2ClassDefinition(ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { + static create2ClassDefinition(ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { return new ClassDefinition(global.generatedEs2panda._CreateClassDefinition2(global.context, passNode(ident), modifiers, flags)) } - static update2ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { + static update2ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { return new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition2(global.context, passNode(original), passNode(ident), modifiers, flags)) } get identConst(): Identifier | undefined { @@ -161,4 +162,7 @@ export class ClassDefinition extends TypedAstNode { } export function isClassDefinition(node: AstNode): node is ClassDefinition { return node instanceof ClassDefinition +} +if (!nodeByType.has(14)) { + nodeByType.set(14, ClassDefinition) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts index f61e0aad01c4245b2e990474c40c7ff20ba72df7..64378b2968ea3158626940624d530f27057c28ba 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedStatement } from "./TypedStatement" diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts index 888be069ff4d8a0cb89d820bbd042fd7372df114..503561f90518c552100c7ee8b7403e8f3d9dafe0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class ClassExpression extends Expression { super(pointer) console.warn("Warning: stub node ClassExpression") } - static createClassExpression(def?: ClassDefinition): ClassExpression | undefined { + static createClassExpression(def?: ClassDefinition): ClassExpression { return new ClassExpression(global.generatedEs2panda._CreateClassExpression(global.context, passNode(def))) } - static updateClassExpression(original?: ClassExpression, def?: ClassDefinition): ClassExpression | undefined { + static updateClassExpression(original?: ClassExpression, def?: ClassDefinition): ClassExpression { return new ClassExpression(global.generatedEs2panda._UpdateClassExpression(global.context, passNode(original), passNode(def))) } get definitionConst(): ClassDefinition | undefined { @@ -46,4 +47,7 @@ export class ClassExpression extends Expression { } export function isClassExpression(node: AstNode): node is ClassExpression { return node instanceof ClassExpression +} +if (!nodeByType.has(16)) { + nodeByType.set(16, ClassExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts index 65083a584215fda1ae51503b9296cac24603ba00..fb7de87a5b5ab02d69d2b9251ed8787594844c70 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ClassElement } from "./ClassElement" @@ -37,10 +38,10 @@ export class ClassProperty extends ClassElement { super(pointer) console.warn("Warning: stub node ClassProperty") } - static createClassProperty(key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty | undefined { + static createClassProperty(key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty { return new ClassProperty(global.generatedEs2panda._CreateClassProperty(global.context, passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed)) } - static updateClassProperty(original: ClassProperty | undefined, key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty | undefined { + static updateClassProperty(original: ClassProperty | undefined, key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty { return new ClassProperty(global.generatedEs2panda._UpdateClassProperty(global.context, passNode(original), passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed)) } get typeAnnotationConst(): TypeNode | undefined { @@ -55,4 +56,7 @@ export class ClassProperty extends ClassElement { } export function isClassProperty(node: AstNode): node is ClassProperty { return node instanceof ClassProperty +} +if (!nodeByType.has(17)) { + nodeByType.set(17, ClassProperty) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts index 880888735d5e7fa51f34260982193f597e5bfc4b..4772fea2b74001ed5a9cef7fd8f9882efb289224 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ClassElement } from "./ClassElement" @@ -34,13 +35,16 @@ export class ClassStaticBlock extends ClassElement { super(pointer) console.warn("Warning: stub node ClassStaticBlock") } - static createClassStaticBlock(value?: Expression): ClassStaticBlock | undefined { + static createClassStaticBlock(value?: Expression): ClassStaticBlock { return new ClassStaticBlock(global.generatedEs2panda._CreateClassStaticBlock(global.context, passNode(value))) } - static updateClassStaticBlock(original?: ClassStaticBlock, value?: Expression): ClassStaticBlock | undefined { + static updateClassStaticBlock(original?: ClassStaticBlock, value?: Expression): ClassStaticBlock { return new ClassStaticBlock(global.generatedEs2panda._UpdateClassStaticBlock(global.context, passNode(original), passNode(value))) } } export function isClassStaticBlock(node: AstNode): node is ClassStaticBlock { return node instanceof ClassStaticBlock +} +if (!nodeByType.has(18)) { + nodeByType.set(18, ClassStaticBlock) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts index d92ad39b524f2d47404f6f2313f57a7d7bee590a..b9e7fba20c8b1f2076c8c88835cc37bb4b546936 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,10 +34,10 @@ export class ConditionalExpression extends Expression { super(pointer) console.warn("Warning: stub node ConditionalExpression") } - static createConditionalExpression(test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression | undefined { + static createConditionalExpression(test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression { return new ConditionalExpression(global.generatedEs2panda._CreateConditionalExpression(global.context, passNode(test), passNode(consequent), passNode(alternate))) } - static updateConditionalExpression(original?: ConditionalExpression, test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression | undefined { + static updateConditionalExpression(original?: ConditionalExpression, test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression { return new ConditionalExpression(global.generatedEs2panda._UpdateConditionalExpression(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate))) } get testConst(): Expression | undefined { @@ -60,4 +61,7 @@ export class ConditionalExpression extends Expression { } export function isConditionalExpression(node: AstNode): node is ConditionalExpression { return node instanceof ConditionalExpression +} +if (!nodeByType.has(19)) { + nodeByType.set(19, ConditionalExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts index 51ad34eb0c564b0b533bfab5b19f7b351891d161..52c66fd961a39ee86635026ae31cb1280006d50a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,16 +35,16 @@ export class ContinueStatement extends Statement { super(pointer) console.warn("Warning: stub node ContinueStatement") } - static createContinueStatement(): ContinueStatement | undefined { + static createContinueStatement(): ContinueStatement { return new ContinueStatement(global.generatedEs2panda._CreateContinueStatement(global.context)) } - static updateContinueStatement(original?: ContinueStatement): ContinueStatement | undefined { + static updateContinueStatement(original?: ContinueStatement): ContinueStatement { return new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement(global.context, passNode(original))) } - static create1ContinueStatement(ident?: Identifier): ContinueStatement | undefined { + static create1ContinueStatement(ident?: Identifier): ContinueStatement { return new ContinueStatement(global.generatedEs2panda._CreateContinueStatement1(global.context, passNode(ident))) } - static update1ContinueStatement(original?: ContinueStatement, ident?: Identifier): ContinueStatement | undefined { + static update1ContinueStatement(original?: ContinueStatement, ident?: Identifier): ContinueStatement { return new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement1(global.context, passNode(original), passNode(ident))) } get identConst(): Identifier | undefined { @@ -58,4 +59,7 @@ export class ContinueStatement extends Statement { } export function isContinueStatement(node: AstNode): node is ContinueStatement { return node instanceof ContinueStatement +} +if (!nodeByType.has(20)) { + nodeByType.set(20, ContinueStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts index b4f3c236aa0cba83c73bec3c4dbcc2c3666b668a..a22d4fe298ec5084a065f181dee32a2d9af96855 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -33,13 +34,16 @@ export class DebuggerStatement extends Statement { super(pointer) console.warn("Warning: stub node DebuggerStatement") } - static createDebuggerStatement(): DebuggerStatement | undefined { + static createDebuggerStatement(): DebuggerStatement { return new DebuggerStatement(global.generatedEs2panda._CreateDebuggerStatement(global.context)) } - static updateDebuggerStatement(original?: DebuggerStatement): DebuggerStatement | undefined { + static updateDebuggerStatement(original?: DebuggerStatement): DebuggerStatement { return new DebuggerStatement(global.generatedEs2panda._UpdateDebuggerStatement(global.context, passNode(original))) } } export function isDebuggerStatement(node: AstNode): node is DebuggerStatement { return node instanceof DebuggerStatement +} +if (!nodeByType.has(21)) { + nodeByType.set(21, DebuggerStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts b/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts index 87db27b5d61f0d3d8ce6aed93307330e893c6508..1bef25a96df867e4c7f5fb2cdd7cdfbc3c4d744a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,10 +35,10 @@ export class Decorator extends Statement { super(pointer) console.warn("Warning: stub node Decorator") } - static createDecorator(expr?: Expression): Decorator | undefined { + static createDecorator(expr?: Expression): Decorator { return new Decorator(global.generatedEs2panda._CreateDecorator(global.context, passNode(expr))) } - static updateDecorator(original?: Decorator, expr?: Expression): Decorator | undefined { + static updateDecorator(original?: Decorator, expr?: Expression): Decorator { return new Decorator(global.generatedEs2panda._UpdateDecorator(global.context, passNode(original), passNode(expr))) } get exprConst(): Expression | undefined { @@ -46,4 +47,7 @@ export class Decorator extends Statement { } export function isDecorator(node: AstNode): node is Decorator { return node instanceof Decorator +} +if (!nodeByType.has(22)) { + nodeByType.set(22, Decorator) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts index 314fc25224e53b7a57f8fafa728287b8a9483d47..8892919d0dac0f6e785c7b510f2c62d3595bc47c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { CallExpression } from "./CallExpression" @@ -35,13 +36,16 @@ export class DirectEvalExpression extends CallExpression { super(pointer) console.warn("Warning: stub node DirectEvalExpression") } - static createDirectEvalExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression | undefined { + static createDirectEvalExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression { return new DirectEvalExpression(global.generatedEs2panda._CreateDirectEvalExpression(global.context, passNode(callee), passNodeArray(_arguments), argumentsLen, passNode(typeParams), optional_arg, parserStatus)) } - static updateDirectEvalExpression(original: DirectEvalExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression | undefined { + static updateDirectEvalExpression(original: DirectEvalExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression { return new DirectEvalExpression(global.generatedEs2panda._UpdateDirectEvalExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), argumentsLen, passNode(typeParams), optional_arg, parserStatus)) } } export function isDirectEvalExpression(node: AstNode): node is DirectEvalExpression { return node instanceof DirectEvalExpression +} +if (!nodeByType.has(23)) { + nodeByType.set(23, DirectEvalExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts index f69393d1759945e47c9f8a3ca406332514527edf..c6f8f061530ac7100afcaf1a52fe9cda6f9726bd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { LoopStatement } from "./LoopStatement" @@ -50,4 +51,7 @@ export class DoWhileStatement extends LoopStatement { } export function isDoWhileStatement(node: AstNode): node is DoWhileStatement { return node instanceof DoWhileStatement +} +if (!nodeByType.has(24)) { + nodeByType.set(24, DoWhileStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts index 30f74e4f508c1bcf3377487f0b454b7dd408353c..2090b961feaadc5edbf4074488ef439ef5512300 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class ETSClassLiteral extends Expression { super(pointer) console.warn("Warning: stub node ETSClassLiteral") } - static createETSClassLiteral(expr?: TypeNode): ETSClassLiteral | undefined { + static createETSClassLiteral(expr?: TypeNode): ETSClassLiteral { return new ETSClassLiteral(global.generatedEs2panda._CreateETSClassLiteral(global.context, passNode(expr))) } - static updateETSClassLiteral(original?: ETSClassLiteral, expr?: TypeNode): ETSClassLiteral | undefined { + static updateETSClassLiteral(original?: ETSClassLiteral, expr?: TypeNode): ETSClassLiteral { return new ETSClassLiteral(global.generatedEs2panda._UpdateETSClassLiteral(global.context, passNode(original), passNode(expr))) } get exprConst(): TypeNode | undefined { @@ -46,4 +47,7 @@ export class ETSClassLiteral extends Expression { } export function isETSClassLiteral(node: AstNode): node is ETSClassLiteral { return node instanceof ETSClassLiteral +} +if (!nodeByType.has(70)) { + nodeByType.set(70, ETSClassLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts index 4a24d4bfa7650a216f96dfc254f4179e4fbf6d39..3a37dd0fa1c505c89015ac3f4b1eba7f8ea06ccc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ETSFunctionType } from "./ETSFunctionType" diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts index 3456e57b91dfdc4e6d5f9e97e2ac3b9e197cd863..627678b97ac26b3122cc65412ed42fd707524792 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -73,4 +74,7 @@ export class ETSFunctionType extends TypeNode { } export function isETSFunctionType(node: AstNode): node is ETSFunctionType { return node instanceof ETSFunctionType +} +if (!nodeByType.has(66)) { + nodeByType.set(66, ETSFunctionType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts index 7143ac0b8313934de062deeb03dbde9aa8b2d04c..16205bfaa860fc47c5ea3b0e6f1ee2598d1ce3c3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ImportDeclaration } from "./ImportDeclaration" @@ -58,4 +59,7 @@ export class ETSImportDeclaration extends ImportDeclaration { } export function isETSImportDeclaration(node: AstNode): node is ETSImportDeclaration { return node instanceof ETSImportDeclaration +} +if (!nodeByType.has(78)) { + nodeByType.set(78, ETSImportDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts index af9f15d70d3b346429dcbda3586ecfb7972af810..24c8748f7bba19f805582f9162ecabb76b93dcb6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class ETSLaunchExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSLaunchExpression") } - static createETSLaunchExpression(expr?: CallExpression): ETSLaunchExpression | undefined { + static createETSLaunchExpression(expr?: CallExpression): ETSLaunchExpression { return new ETSLaunchExpression(global.generatedEs2panda._CreateETSLaunchExpression(global.context, passNode(expr))) } - static updateETSLaunchExpression(original?: ETSLaunchExpression, expr?: CallExpression): ETSLaunchExpression | undefined { + static updateETSLaunchExpression(original?: ETSLaunchExpression, expr?: CallExpression): ETSLaunchExpression { return new ETSLaunchExpression(global.generatedEs2panda._UpdateETSLaunchExpression(global.context, passNode(original), passNode(expr))) } get callConst(): CallExpression | undefined { @@ -46,4 +47,7 @@ export class ETSLaunchExpression extends Expression { } export function isETSLaunchExpression(node: AstNode): node is ETSLaunchExpression { return node instanceof ETSLaunchExpression +} +if (!nodeByType.has(74)) { + nodeByType.set(74, ETSLaunchExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts index f7fc73b629a6231c4ecce087c9f1cec2e5afa974..18df46b998b70110feb345e56fca4d5d8075021d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { BlockStatement } from "./BlockStatement" @@ -59,4 +60,7 @@ export class ETSModule extends BlockStatement { } export function isETSModule(node: AstNode): node is ETSModule { return node instanceof ETSModule +} +if (!nodeByType.has(81)) { + nodeByType.set(81, ETSModule) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts index 5d2dfca72bc8d5a1af18bfbc113c07d15adc9441..bc727dd58c07ad52ce87795238891b7318c378fe 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class ETSNewArrayInstanceExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSNewArrayInstanceExpression") } - static createETSNewArrayInstanceExpression(typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression | undefined { + static createETSNewArrayInstanceExpression(typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression { return new ETSNewArrayInstanceExpression(global.generatedEs2panda._CreateETSNewArrayInstanceExpression(global.context, passNode(typeReference), passNode(dimension))) } - static updateETSNewArrayInstanceExpression(original?: ETSNewArrayInstanceExpression, typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression | undefined { + static updateETSNewArrayInstanceExpression(original?: ETSNewArrayInstanceExpression, typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression { return new ETSNewArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNode(dimension))) } get typeReference(): TypeNode | undefined { @@ -55,4 +56,7 @@ export class ETSNewArrayInstanceExpression extends Expression { } export function isETSNewArrayInstanceExpression(node: AstNode): node is ETSNewArrayInstanceExpression { return node instanceof ETSNewArrayInstanceExpression +} +if (!nodeByType.has(75)) { + nodeByType.set(75, ETSNewArrayInstanceExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts index b75bab62634694993f63e047f2c8e87a58b8cb08..65dfaf041ae272e718e3e969d078fedbf9b96293 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,16 +34,16 @@ export class ETSNewClassInstanceExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSNewClassInstanceExpression") } - static createETSNewClassInstanceExpression(typeReference: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression | undefined { + static createETSNewClassInstanceExpression(typeReference: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression { return new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression(global.context, passNode(typeReference), passNodeArray(_arguments), argumentsLen)) } - static updateETSNewClassInstanceExpression(original: ETSNewClassInstanceExpression | undefined, typeReference: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression | undefined { + static updateETSNewClassInstanceExpression(original: ETSNewClassInstanceExpression | undefined, typeReference: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression { return new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(_arguments), argumentsLen)) } - static create1ETSNewClassInstanceExpression(other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression | undefined { + static create1ETSNewClassInstanceExpression(other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression { return new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression1(global.context, passNode(other))) } - static update1ETSNewClassInstanceExpression(original?: ETSNewClassInstanceExpression, other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression | undefined { + static update1ETSNewClassInstanceExpression(original?: ETSNewClassInstanceExpression, other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression { return new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression1(global.context, passNode(original), passNode(other))) } get getTypeRefConst(): Expression | undefined { @@ -54,4 +55,7 @@ export class ETSNewClassInstanceExpression extends Expression { } export function isETSNewClassInstanceExpression(node: AstNode): node is ETSNewClassInstanceExpression { return node instanceof ETSNewClassInstanceExpression +} +if (!nodeByType.has(77)) { + nodeByType.set(77, ETSNewClassInstanceExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts index 88a7b6be6a3939dc178984ea6110384c1e50b50d..fa74403f136876bfb080d0afed048dc8db1010c9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,16 +35,16 @@ export class ETSNewMultiDimArrayInstanceExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSNewMultiDimArrayInstanceExpression") } - static createETSNewMultiDimArrayInstanceExpression(typeReference: TypeNode | undefined, dimensions: readonly Expression[], dimensionsLen: number): ETSNewMultiDimArrayInstanceExpression | undefined { + static createETSNewMultiDimArrayInstanceExpression(typeReference: TypeNode | undefined, dimensions: readonly Expression[], dimensionsLen: number): ETSNewMultiDimArrayInstanceExpression { return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._CreateETSNewMultiDimArrayInstanceExpression(global.context, passNode(typeReference), passNodeArray(dimensions), dimensionsLen)) } - static updateETSNewMultiDimArrayInstanceExpression(original: ETSNewMultiDimArrayInstanceExpression | undefined, typeReference: TypeNode | undefined, dimensions: readonly Expression[], dimensionsLen: number): ETSNewMultiDimArrayInstanceExpression | undefined { + static updateETSNewMultiDimArrayInstanceExpression(original: ETSNewMultiDimArrayInstanceExpression | undefined, typeReference: TypeNode | undefined, dimensions: readonly Expression[], dimensionsLen: number): ETSNewMultiDimArrayInstanceExpression { return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(dimensions), dimensionsLen)) } - static create1ETSNewMultiDimArrayInstanceExpression(other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression | undefined { + static create1ETSNewMultiDimArrayInstanceExpression(other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression { return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._CreateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(other))) } - static update1ETSNewMultiDimArrayInstanceExpression(original?: ETSNewMultiDimArrayInstanceExpression, other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression | undefined { + static update1ETSNewMultiDimArrayInstanceExpression(original?: ETSNewMultiDimArrayInstanceExpression, other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression { return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(original), passNode(other))) } get typeReference(): TypeNode | undefined { @@ -61,4 +62,7 @@ export class ETSNewMultiDimArrayInstanceExpression extends Expression { } export function isETSNewMultiDimArrayInstanceExpression(node: AstNode): node is ETSNewMultiDimArrayInstanceExpression { return node instanceof ETSNewMultiDimArrayInstanceExpression +} +if (!nodeByType.has(76)) { + nodeByType.set(76, ETSNewMultiDimArrayInstanceExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts index 279fc847200dcf8850c3df0293afd7aec2a7c37e..0f551fd829a49bade3b3f4d784e6ba757d9bdd4f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class ETSNullType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSNullType") } - static createETSNullType(): ETSNullType | undefined { + static createETSNullType(): ETSNullType { return new ETSNullType(global.generatedEs2panda._CreateETSNullTypeIr(global.context)) } - static updateETSNullType(original?: ETSNullType): ETSNullType | undefined { + static updateETSNullType(original?: ETSNullType): ETSNullType { return new ETSNullType(global.generatedEs2panda._UpdateETSNullTypeIr(global.context, passNode(original))) } } export function isETSNullType(node: AstNode): node is ETSNullType { return node instanceof ETSNullType +} +if (!nodeByType.has(62)) { + nodeByType.set(62, ETSNullType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts index f784110d9fe889297d73dc52c0be0bc64a7ea7e2..f651e034c07629d4a9c9a68f11b7637c5fd6b574 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,13 +35,16 @@ export class ETSPackageDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ETSPackageDeclaration") } - static createETSPackageDeclaration(name?: Expression): ETSPackageDeclaration | undefined { + static createETSPackageDeclaration(name?: Expression): ETSPackageDeclaration { return new ETSPackageDeclaration(global.generatedEs2panda._CreateETSPackageDeclaration(global.context, passNode(name))) } - static updateETSPackageDeclaration(original?: ETSPackageDeclaration, name?: Expression): ETSPackageDeclaration | undefined { + static updateETSPackageDeclaration(original?: ETSPackageDeclaration, name?: Expression): ETSPackageDeclaration { return new ETSPackageDeclaration(global.generatedEs2panda._UpdateETSPackageDeclaration(global.context, passNode(original), passNode(name))) } } export function isETSPackageDeclaration(node: AstNode): node is ETSPackageDeclaration { return node instanceof ETSPackageDeclaration +} +if (!nodeByType.has(69)) { + nodeByType.set(69, ETSPackageDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts index 44a6f7f486fe8945ef17ee955f5d223ec1bf6d04..5820b193d4cc17bcf656bd9b122f2301c57627d1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -35,10 +36,10 @@ export class ETSParameterExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSParameterExpression") } - static createETSParameterExpression(identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression | undefined { + static createETSParameterExpression(identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression { return new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression(global.context, passNode(identOrSpread), passNode(initializer))) } - static updateETSParameterExpression(original?: ETSParameterExpression, identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression | undefined { + static updateETSParameterExpression(original?: ETSParameterExpression, identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression { return new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression(global.context, passNode(original), passNode(identOrSpread), passNode(initializer))) } get isDefaultConst(): boolean { @@ -59,4 +60,7 @@ export class ETSParameterExpression extends Expression { } export function isETSParameterExpression(node: AstNode): node is ETSParameterExpression { return node instanceof ETSParameterExpression +} +if (!nodeByType.has(79)) { + nodeByType.set(79, ETSParameterExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts index 761c6f1b9881906d5308f3ef3d8b7548c77a95b0..49428e2abe0485256053bfd28de0ead627ad5a85 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -34,10 +35,10 @@ export class ETSPrimitiveType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSPrimitiveType") } - static createETSPrimitiveType(type: Es2pandaPrimitiveType): ETSPrimitiveType | undefined { + static createETSPrimitiveType(type: Es2pandaPrimitiveType): ETSPrimitiveType { return new ETSPrimitiveType(global.generatedEs2panda._CreateETSPrimitiveType(global.context, type)) } - static updateETSPrimitiveType(original: ETSPrimitiveType | undefined, type: Es2pandaPrimitiveType): ETSPrimitiveType | undefined { + static updateETSPrimitiveType(original: ETSPrimitiveType | undefined, type: Es2pandaPrimitiveType): ETSPrimitiveType { return new ETSPrimitiveType(global.generatedEs2panda._UpdateETSPrimitiveType(global.context, passNode(original), type)) } get getPrimitiveTypeConst(): Es2pandaPrimitiveType { @@ -46,4 +47,7 @@ export class ETSPrimitiveType extends TypeNode { } export function isETSPrimitiveType(node: AstNode): node is ETSPrimitiveType { return node instanceof ETSPrimitiveType +} +if (!nodeByType.has(68)) { + nodeByType.set(68, ETSPrimitiveType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts index f9df26fee496189dfa3fd59659ea6dbb4a657826..ec203d068b78a5d2453d71c1b04bdee693b7f751 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -46,4 +47,7 @@ export class ETSReExportDeclaration extends Statement { } export function isETSReExportDeclaration(node: AstNode): node is ETSReExportDeclaration { return node instanceof ETSReExportDeclaration +} +if (!nodeByType.has(57)) { + nodeByType.set(57, ETSReExportDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts index b341a7ed377930f31f24676996487df3b87e3026..0d5dabfee8b7b0671a1ac26a37f3da5cee5eb536 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ClassDeclaration } from "./ClassDeclaration" @@ -34,13 +35,16 @@ export class ETSStructDeclaration extends ClassDeclaration { super(pointer) console.warn("Warning: stub node ETSStructDeclaration") } - static createETSStructDeclaration(def?: ClassDefinition): ETSStructDeclaration | undefined { + static createETSStructDeclaration(def?: ClassDefinition): ETSStructDeclaration { return new ETSStructDeclaration(global.generatedEs2panda._CreateETSStructDeclaration(global.context, passNode(def))) } - static updateETSStructDeclaration(original?: ETSStructDeclaration, def?: ClassDefinition): ETSStructDeclaration | undefined { + static updateETSStructDeclaration(original?: ETSStructDeclaration, def?: ClassDefinition): ETSStructDeclaration { return new ETSStructDeclaration(global.generatedEs2panda._UpdateETSStructDeclaration(global.context, passNode(original), passNode(def))) } } export function isETSStructDeclaration(node: AstNode): node is ETSStructDeclaration { return node instanceof ETSStructDeclaration +} +if (!nodeByType.has(83)) { + nodeByType.set(83, ETSStructDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts index fbcee5019f54c14fe664315be1be2472f8957a90..1b8e467415a9539c0fff5b93902694c04c6ac90d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,22 +34,22 @@ export class ETSTuple extends TypeNode { super(pointer) console.warn("Warning: stub node ETSTuple") } - static createETSTuple(): ETSTuple | undefined { + static createETSTuple(): ETSTuple { return new ETSTuple(global.generatedEs2panda._CreateETSTuple(global.context)) } - static updateETSTuple(original?: ETSTuple): ETSTuple | undefined { + static updateETSTuple(original?: ETSTuple): ETSTuple { return new ETSTuple(global.generatedEs2panda._UpdateETSTuple(global.context, passNode(original))) } - static create1ETSTuple(size: number): ETSTuple | undefined { + static create1ETSTuple(size: number): ETSTuple { return new ETSTuple(global.generatedEs2panda._CreateETSTuple1(global.context, size)) } - static update1ETSTuple(original: ETSTuple | undefined, size: number): ETSTuple | undefined { + static update1ETSTuple(original: ETSTuple | undefined, size: number): ETSTuple { return new ETSTuple(global.generatedEs2panda._UpdateETSTuple1(global.context, passNode(original), size)) } - static create2ETSTuple(typeList: readonly TypeNode[], typeListLen: number): ETSTuple | undefined { + static create2ETSTuple(typeList: readonly TypeNode[], typeListLen: number): ETSTuple { return new ETSTuple(global.generatedEs2panda._CreateETSTuple2(global.context, passNodeArray(typeList), typeListLen)) } - static update2ETSTuple(original: ETSTuple | undefined, typeList: readonly TypeNode[], typeListLen: number): ETSTuple | undefined { + static update2ETSTuple(original: ETSTuple | undefined, typeList: readonly TypeNode[], typeListLen: number): ETSTuple { return new ETSTuple(global.generatedEs2panda._UpdateETSTuple2(global.context, passNode(original), passNodeArray(typeList), typeListLen)) } get getTupleSizeConst(): number { @@ -63,4 +64,7 @@ export class ETSTuple extends TypeNode { } export function isETSTuple(node: AstNode): node is ETSTuple { return node instanceof ETSTuple +} +if (!nodeByType.has(80)) { + nodeByType.set(80, ETSTuple) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts index eb65893c4e732ea8f45b1fcd5b14e9a21fe52f99..850ddc4eb57971dc97be65a49579c4eab9ec893e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -34,10 +35,10 @@ export class ETSTypeReference extends TypeNode { super(pointer) console.warn("Warning: stub node ETSTypeReference") } - static createETSTypeReference(part?: ETSTypeReferencePart): ETSTypeReference | undefined { + static createETSTypeReference(part?: ETSTypeReferencePart): ETSTypeReference { return new ETSTypeReference(global.generatedEs2panda._CreateETSTypeReference(global.context, passNode(part))) } - static updateETSTypeReference(original?: ETSTypeReference, part?: ETSTypeReferencePart): ETSTypeReference | undefined { + static updateETSTypeReference(original?: ETSTypeReference, part?: ETSTypeReferencePart): ETSTypeReference { return new ETSTypeReference(global.generatedEs2panda._UpdateETSTypeReference(global.context, passNode(original), passNode(part))) } get part(): ETSTypeReferencePart | undefined { @@ -49,4 +50,7 @@ export class ETSTypeReference extends TypeNode { } export function isETSTypeReference(node: AstNode): node is ETSTypeReference { return node instanceof ETSTypeReference +} +if (!nodeByType.has(71)) { + nodeByType.set(71, ETSTypeReference) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts index 9d33ec09ba0c9c90bbeef7bacaada940ef91a0a3..6e6f029b61dcfac01b50d57e3165e9810e29ccfa 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -35,16 +36,16 @@ export class ETSTypeReferencePart extends TypeNode { super(pointer) console.warn("Warning: stub node ETSTypeReferencePart") } - static createETSTypeReferencePart(name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart | undefined { + static createETSTypeReferencePart(name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart { return new ETSTypeReferencePart(global.generatedEs2panda._CreateETSTypeReferencePart(global.context, passNode(name), passNode(typeParams), passNode(prev))) } - static updateETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart | undefined { + static updateETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart { return new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart(global.context, passNode(original), passNode(name), passNode(typeParams), passNode(prev))) } - static create1ETSTypeReferencePart(name?: Expression): ETSTypeReferencePart | undefined { + static create1ETSTypeReferencePart(name?: Expression): ETSTypeReferencePart { return new ETSTypeReferencePart(global.generatedEs2panda._CreateETSTypeReferencePart1(global.context, passNode(name))) } - static update1ETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression): ETSTypeReferencePart | undefined { + static update1ETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression): ETSTypeReferencePart { return new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart1(global.context, passNode(original), passNode(name))) } get previous(): ETSTypeReferencePart | undefined { @@ -65,4 +66,7 @@ export class ETSTypeReferencePart extends TypeNode { } export function isETSTypeReferencePart(node: AstNode): node is ETSTypeReferencePart { return node instanceof ETSTypeReferencePart +} +if (!nodeByType.has(72)) { + nodeByType.set(72, ETSTypeReferencePart) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts index ac8aa77c6885a08b97153533bb121602fa4111d2..967d6b1756c20b2c292513266f82af33d02d59cf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class ETSUndefinedType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSUndefinedType") } - static createETSUndefinedType(): ETSUndefinedType | undefined { + static createETSUndefinedType(): ETSUndefinedType { return new ETSUndefinedType(global.generatedEs2panda._CreateETSUndefinedTypeIr(global.context)) } - static updateETSUndefinedType(original?: ETSUndefinedType): ETSUndefinedType | undefined { + static updateETSUndefinedType(original?: ETSUndefinedType): ETSUndefinedType { return new ETSUndefinedType(global.generatedEs2panda._UpdateETSUndefinedTypeIr(global.context, passNode(original))) } } export function isETSUndefinedType(node: AstNode): node is ETSUndefinedType { return node instanceof ETSUndefinedType +} +if (!nodeByType.has(63)) { + nodeByType.set(63, ETSUndefinedType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts index ab58232f12a1baf292a219604eff3cc5fd03f8f7..4c84dd484aac613a95b0696dd4961961179819e4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,10 +34,10 @@ export class ETSUnionType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSUnionType") } - static createETSUnionType(types: readonly TypeNode[], typesLen: number): ETSUnionType | undefined { + static createETSUnionType(types: readonly TypeNode[], typesLen: number): ETSUnionType { return new ETSUnionType(global.generatedEs2panda._CreateETSUnionTypeIr(global.context, passNodeArray(types), typesLen)) } - static updateETSUnionType(original: ETSUnionType | undefined, types: readonly TypeNode[], typesLen: number): ETSUnionType | undefined { + static updateETSUnionType(original: ETSUnionType | undefined, types: readonly TypeNode[], typesLen: number): ETSUnionType { return new ETSUnionType(global.generatedEs2panda._UpdateETSUnionTypeIr(global.context, passNode(original), passNodeArray(types), typesLen)) } get typesConst(): readonly TypeNode[] { @@ -45,4 +46,7 @@ export class ETSUnionType extends TypeNode { } export function isETSUnionType(node: AstNode): node is ETSUnionType { return node instanceof ETSUnionType +} +if (!nodeByType.has(73)) { + nodeByType.set(73, ETSUnionType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts index ae5dbb3b42202ddd1e23493fd23b714f73e7d36f..c1ad2314da74195a640f411276a5fe1ff61795b2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -35,10 +36,10 @@ export class ETSWildcardType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSWildcardType") } - static createETSWildcardType(typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType | undefined { + static createETSWildcardType(typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType { return new ETSWildcardType(global.generatedEs2panda._CreateETSWildcardType(global.context, passNode(typeReference), flags)) } - static updateETSWildcardType(original: ETSWildcardType | undefined, typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType | undefined { + static updateETSWildcardType(original: ETSWildcardType | undefined, typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType { return new ETSWildcardType(global.generatedEs2panda._UpdateETSWildcardType(global.context, passNode(original), passNode(typeReference), flags)) } get typeReference(): ETSTypeReference | undefined { @@ -50,4 +51,7 @@ export class ETSWildcardType extends TypeNode { } export function isETSWildcardType(node: AstNode): node is ETSWildcardType { return node instanceof ETSWildcardType +} +if (!nodeByType.has(67)) { + nodeByType.set(67, ETSWildcardType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts index a74af4e3a7792a3c894114f0317f35acb3dc5021..d3dc1d031299354a9a9a20fe6c92cc6d189fcbcd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -33,13 +34,16 @@ export class EmptyStatement extends Statement { super(pointer) console.warn("Warning: stub node EmptyStatement") } - static createEmptyStatement(): EmptyStatement | undefined { + static createEmptyStatement(): EmptyStatement { return new EmptyStatement(global.generatedEs2panda._CreateEmptyStatement(global.context)) } - static updateEmptyStatement(original?: EmptyStatement): EmptyStatement | undefined { + static updateEmptyStatement(original?: EmptyStatement): EmptyStatement { return new EmptyStatement(global.generatedEs2panda._UpdateEmptyStatement(global.context, passNode(original))) } } export function isEmptyStatement(node: AstNode): node is EmptyStatement { return node instanceof EmptyStatement +} +if (!nodeByType.has(25)) { + nodeByType.set(25, EmptyStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts index d827b1a94919b6e0b7e38378a6b566f5b060de84..43a236881ac2795a22f504e99801cf47371ca38a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -35,10 +36,10 @@ export class ExportAllDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ExportAllDeclaration") } - static createExportAllDeclaration(source?: StringLiteral, exported?: Identifier): ExportAllDeclaration | undefined { + static createExportAllDeclaration(source?: StringLiteral, exported?: Identifier): ExportAllDeclaration { return new ExportAllDeclaration(global.generatedEs2panda._CreateExportAllDeclaration(global.context, passNode(source), passNode(exported))) } - static updateExportAllDeclaration(original?: ExportAllDeclaration, source?: StringLiteral, exported?: Identifier): ExportAllDeclaration | undefined { + static updateExportAllDeclaration(original?: ExportAllDeclaration, source?: StringLiteral, exported?: Identifier): ExportAllDeclaration { return new ExportAllDeclaration(global.generatedEs2panda._UpdateExportAllDeclaration(global.context, passNode(original), passNode(source), passNode(exported))) } get sourceConst(): StringLiteral | undefined { @@ -50,4 +51,7 @@ export class ExportAllDeclaration extends Statement { } export function isExportAllDeclaration(node: AstNode): node is ExportAllDeclaration { return node instanceof ExportAllDeclaration +} +if (!nodeByType.has(26)) { + nodeByType.set(26, ExportAllDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts index 4da8c11d487a8b55632d6914359c57f0f1a82796..8f0f435099007a385e9cdc3885c0b3143ec5e641 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -33,10 +34,10 @@ export class ExportDefaultDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ExportDefaultDeclaration") } - static createExportDefaultDeclaration(decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration | undefined { + static createExportDefaultDeclaration(decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration { return new ExportDefaultDeclaration(global.generatedEs2panda._CreateExportDefaultDeclaration(global.context, passNode(decl), exportEquals)) } - static updateExportDefaultDeclaration(original: ExportDefaultDeclaration | undefined, decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration | undefined { + static updateExportDefaultDeclaration(original: ExportDefaultDeclaration | undefined, decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration { return new ExportDefaultDeclaration(global.generatedEs2panda._UpdateExportDefaultDeclaration(global.context, passNode(original), passNode(decl), exportEquals)) } get decl(): AstNode | undefined { @@ -51,4 +52,7 @@ export class ExportDefaultDeclaration extends Statement { } export function isExportDefaultDeclaration(node: AstNode): node is ExportDefaultDeclaration { return node instanceof ExportDefaultDeclaration +} +if (!nodeByType.has(27)) { + nodeByType.set(27, ExportDefaultDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts index a90bb6bbdf5540815a4c51cfe79a1cd53124f04b..d7f7a23dbf7a9ed0d610539035ac9438af57fb9c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -35,22 +36,22 @@ export class ExportNamedDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ExportNamedDeclaration") } - static createExportNamedDeclaration(source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration | undefined { + static createExportNamedDeclaration(source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiersLen)) } - static updateExportNamedDeclaration(original: ExportNamedDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration | undefined { + static updateExportNamedDeclaration(original: ExportNamedDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { return new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiersLen)) } - static create1ExportNamedDeclaration(decl: AstNode | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration | undefined { + static create1ExportNamedDeclaration(decl: AstNode | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration1(global.context, passNode(decl), passNodeArray(specifiers), specifiersLen)) } - static update1ExportNamedDeclaration(original: ExportNamedDeclaration | undefined, decl: AstNode | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration | undefined { + static update1ExportNamedDeclaration(original: ExportNamedDeclaration | undefined, decl: AstNode | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { return new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration1(global.context, passNode(original), passNode(decl), passNodeArray(specifiers), specifiersLen)) } - static create2ExportNamedDeclaration(decl?: AstNode): ExportNamedDeclaration | undefined { + static create2ExportNamedDeclaration(decl?: AstNode): ExportNamedDeclaration { return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration2(global.context, passNode(decl))) } - static update2ExportNamedDeclaration(original?: ExportNamedDeclaration, decl?: AstNode): ExportNamedDeclaration | undefined { + static update2ExportNamedDeclaration(original?: ExportNamedDeclaration, decl?: AstNode): ExportNamedDeclaration { return new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration2(global.context, passNode(original), passNode(decl))) } get declConst(): AstNode | undefined { @@ -65,4 +66,7 @@ export class ExportNamedDeclaration extends Statement { } export function isExportNamedDeclaration(node: AstNode): node is ExportNamedDeclaration { return node instanceof ExportNamedDeclaration +} +if (!nodeByType.has(28)) { + nodeByType.set(28, ExportNamedDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts index 382c890546875b3820e10f12254512c3c6101ab3..e5a2f111d7238cc4cdaaf52160ef542fe4c35560 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,10 +35,10 @@ export class ExportSpecifier extends Statement { super(pointer) console.warn("Warning: stub node ExportSpecifier") } - static createExportSpecifier(local?: Identifier, exported?: Identifier): ExportSpecifier | undefined { + static createExportSpecifier(local?: Identifier, exported?: Identifier): ExportSpecifier { return new ExportSpecifier(global.generatedEs2panda._CreateExportSpecifier(global.context, passNode(local), passNode(exported))) } - static updateExportSpecifier(original?: ExportSpecifier, local?: Identifier, exported?: Identifier): ExportSpecifier | undefined { + static updateExportSpecifier(original?: ExportSpecifier, local?: Identifier, exported?: Identifier): ExportSpecifier { return new ExportSpecifier(global.generatedEs2panda._UpdateExportSpecifier(global.context, passNode(original), passNode(local), passNode(exported))) } get localConst(): Identifier | undefined { @@ -49,4 +50,7 @@ export class ExportSpecifier extends Statement { } export function isExportSpecifier(node: AstNode): node is ExportSpecifier { return node instanceof ExportSpecifier +} +if (!nodeByType.has(29)) { + nodeByType.set(29, ExportSpecifier) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Expression.ts b/arkoala-arkts/libarkts/src/generated/peers/Expression.ts index 29c10a05b42e157520fd784f51c0205e418301ea..a10db93e73326e696cefa9c657824cf98c412c0c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Expression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Expression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedAstNode } from "./TypedAstNode" diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts index bbc0cfb2ecef314bf1ff58f522cbb1c57ff16155..e5df62dc1837ce5e9b6ee9f341249a65ee07d8a2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,10 +35,10 @@ export class ExpressionStatement extends Statement { super(pointer) console.warn("Warning: stub node ExpressionStatement") } - static createExpressionStatement(expr?: Expression): ExpressionStatement | undefined { + static createExpressionStatement(expr?: Expression): ExpressionStatement { return new ExpressionStatement(global.generatedEs2panda._CreateExpressionStatement(global.context, passNode(expr))) } - static updateExpressionStatement(original?: ExpressionStatement, expr?: Expression): ExpressionStatement | undefined { + static updateExpressionStatement(original?: ExpressionStatement, expr?: Expression): ExpressionStatement { return new ExpressionStatement(global.generatedEs2panda._UpdateExpressionStatement(global.context, passNode(original), passNode(expr))) } get getExpressionConst(): Expression | undefined { @@ -49,4 +50,7 @@ export class ExpressionStatement extends Statement { } export function isExpressionStatement(node: AstNode): node is ExpressionStatement { return node instanceof ExpressionStatement +} +if (!nodeByType.has(30)) { + nodeByType.set(30, ExpressionStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts index 832fed72cb09ec76b3917cb93e6d8862e7596928..6bfbe4adfc4b28b026fdbd2c40d69ec22c92fe95 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { LoopStatement } from "./LoopStatement" @@ -56,4 +57,7 @@ export class ForInStatement extends LoopStatement { } export function isForInStatement(node: AstNode): node is ForInStatement { return node instanceof ForInStatement +} +if (!nodeByType.has(31)) { + nodeByType.set(31, ForInStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts index affdb4ed3cc4cafbe3c9e4ca07d2518b642f01d2..cbde8c02a998d7eb67b3c8076de56779f940939d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { LoopStatement } from "./LoopStatement" @@ -59,4 +60,7 @@ export class ForOfStatement extends LoopStatement { } export function isForOfStatement(node: AstNode): node is ForOfStatement { return node instanceof ForOfStatement +} +if (!nodeByType.has(32)) { + nodeByType.set(32, ForOfStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts index 509fe7646c479040afaa4fe624b834003fd7f952..ad9600df400a4e1538353a01aa02f7e9b73dbf75 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { LoopStatement } from "./LoopStatement" @@ -59,4 +60,7 @@ export class ForUpdateStatement extends LoopStatement { } export function isForUpdateStatement(node: AstNode): node is ForUpdateStatement { return node instanceof ForUpdateStatement +} +if (!nodeByType.has(33)) { + nodeByType.set(33, ForUpdateStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts index e11cd95f94ea4f8435f308e798988a4ad98a5603..44d73ed8e31f556e61a18226e9fc6984316d0db6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ScriptFunction } from "./ScriptFunction" diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts index 2a71f9ee206a9d23b428f8f5941ef1b333309de2..a1e8986a605fc9901d1412768b4c1070f4edeae5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -35,16 +36,16 @@ export class FunctionDeclaration extends Statement { super(pointer) console.warn("Warning: stub node FunctionDeclaration") } - static createFunctionDeclaration(func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration | undefined { + static createFunctionDeclaration(func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration { return new FunctionDeclaration(global.generatedEs2panda._CreateFunctionDeclaration(global.context, passNode(func), passNodeArray(annotations), annotationsLen, isAnonymous)) } - static updateFunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration | undefined { + static updateFunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration { return new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration(global.context, passNode(original), passNode(func), passNodeArray(annotations), annotationsLen, isAnonymous)) } - static create1FunctionDeclaration(func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration | undefined { + static create1FunctionDeclaration(func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration { return new FunctionDeclaration(global.generatedEs2panda._CreateFunctionDeclaration1(global.context, passNode(func), isAnonymous)) } - static update1FunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration | undefined { + static update1FunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration { return new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration1(global.context, passNode(original), passNode(func), isAnonymous)) } get function(): ScriptFunction | undefined { @@ -65,4 +66,7 @@ export class FunctionDeclaration extends Statement { } export function isFunctionDeclaration(node: AstNode): node is FunctionDeclaration { return node instanceof FunctionDeclaration +} +if (!nodeByType.has(34)) { + nodeByType.set(34, FunctionDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts index 549488ee30cda6700fd9d60c09fbadd4e44963bf..44ad0227aa3e2a1f69927f4049380f6c74068544 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -35,16 +36,16 @@ export class FunctionExpression extends Expression { super(pointer) console.warn("Warning: stub node FunctionExpression") } - static createFunctionExpression(func?: ScriptFunction): FunctionExpression | undefined { + static createFunctionExpression(func?: ScriptFunction): FunctionExpression { return new FunctionExpression(global.generatedEs2panda._CreateFunctionExpression(global.context, passNode(func))) } - static updateFunctionExpression(original?: FunctionExpression, func?: ScriptFunction): FunctionExpression | undefined { + static updateFunctionExpression(original?: FunctionExpression, func?: ScriptFunction): FunctionExpression { return new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression(global.context, passNode(original), passNode(func))) } - static create1FunctionExpression(namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression | undefined { + static create1FunctionExpression(namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression { return new FunctionExpression(global.generatedEs2panda._CreateFunctionExpression1(global.context, passNode(namedExpr), passNode(func))) } - static update1FunctionExpression(original?: FunctionExpression, namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression | undefined { + static update1FunctionExpression(original?: FunctionExpression, namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression { return new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression1(global.context, passNode(original), passNode(namedExpr), passNode(func))) } get functionConst(): ScriptFunction | undefined { @@ -62,4 +63,7 @@ export class FunctionExpression extends Expression { } export function isFunctionExpression(node: AstNode): node is FunctionExpression { return node instanceof FunctionExpression +} +if (!nodeByType.has(35)) { + nodeByType.set(35, FunctionExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts b/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts index 04b8cb47f5fce718682e5adf7b933af48d59b18f..f1962692dbbf0f2772fe5a158b69af22beebe231 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedExpression } from "./AnnotatedExpression" @@ -35,22 +36,22 @@ export class Identifier extends AnnotatedExpression { super(pointer) console.warn("Warning: stub node Identifier") } - static createIdentifier(): Identifier | undefined { + static createIdentifier(): Identifier { return new Identifier(global.generatedEs2panda._CreateIdentifier(global.context)) } - static updateIdentifier(original?: Identifier): Identifier | undefined { + static updateIdentifier(original?: Identifier): Identifier { return new Identifier(global.generatedEs2panda._UpdateIdentifier(global.context, passNode(original))) } - static create1Identifier(name: string): Identifier | undefined { + static create1Identifier(name: string): Identifier { return new Identifier(global.generatedEs2panda._CreateIdentifier1(global.context, name)) } - static update1Identifier(original: Identifier | undefined, name: string): Identifier | undefined { + static update1Identifier(original: Identifier | undefined, name: string): Identifier { return new Identifier(global.generatedEs2panda._UpdateIdentifier1(global.context, passNode(original), name)) } - static create2Identifier(name: string, typeAnnotation?: TypeNode): Identifier | undefined { + static create2Identifier(name: string, typeAnnotation?: TypeNode): Identifier { return new Identifier(global.generatedEs2panda._CreateIdentifier2(global.context, name, passNode(typeAnnotation))) } - static update2Identifier(original: Identifier | undefined, name: string, typeAnnotation?: TypeNode): Identifier | undefined { + static update2Identifier(original: Identifier | undefined, name: string, typeAnnotation?: TypeNode): Identifier { return new Identifier(global.generatedEs2panda._UpdateIdentifier2(global.context, passNode(original), name, passNode(typeAnnotation))) } get nameConst(): string { @@ -101,4 +102,7 @@ export class Identifier extends AnnotatedExpression { } export function isIdentifier(node: AstNode): node is Identifier { return node instanceof Identifier +} +if (!nodeByType.has(36)) { + nodeByType.set(36, Identifier) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts index 688ea8080e5ba4c759a4a1f08d2c56049667ed98..e2c428239128e0d6ed9e23ad3e7b82471136b360 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -55,4 +56,7 @@ export class IfStatement extends Statement { } export function isIfStatement(node: AstNode): node is IfStatement { return node instanceof IfStatement +} +if (!nodeByType.has(38)) { + nodeByType.set(38, IfStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts index 38a6ff2af402a62a888fab97ddf753cfb6bec953..8426d022df0f7c084bc8462e1ad41f04b3ef37a8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -35,10 +36,10 @@ export class ImportDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ImportDeclaration") } - static createImportDeclaration(source: StringLiteral | undefined, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration | undefined { + static createImportDeclaration(source: StringLiteral | undefined, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration { return new ImportDeclaration(global.generatedEs2panda._CreateImportDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiersLen, importKind)) } - static updateImportDeclaration(original: ImportDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration | undefined { + static updateImportDeclaration(original: ImportDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration { return new ImportDeclaration(global.generatedEs2panda._UpdateImportDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiersLen, importKind)) } get sourceConst(): StringLiteral | undefined { @@ -59,4 +60,7 @@ export class ImportDeclaration extends Statement { } export function isImportDeclaration(node: AstNode): node is ImportDeclaration { return node instanceof ImportDeclaration +} +if (!nodeByType.has(39)) { + nodeByType.set(39, ImportDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts index 28d39da3958330959b4be4a67f7abb055b18ab84..d0e1af48135c02988ada0b1ad382f1ecf350cb01 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,10 +35,10 @@ export class ImportDefaultSpecifier extends Statement { super(pointer) console.warn("Warning: stub node ImportDefaultSpecifier") } - static createImportDefaultSpecifier(local?: Identifier): ImportDefaultSpecifier | undefined { + static createImportDefaultSpecifier(local?: Identifier): ImportDefaultSpecifier { return new ImportDefaultSpecifier(global.generatedEs2panda._CreateImportDefaultSpecifier(global.context, passNode(local))) } - static updateImportDefaultSpecifier(original?: ImportDefaultSpecifier, local?: Identifier): ImportDefaultSpecifier | undefined { + static updateImportDefaultSpecifier(original?: ImportDefaultSpecifier, local?: Identifier): ImportDefaultSpecifier { return new ImportDefaultSpecifier(global.generatedEs2panda._UpdateImportDefaultSpecifier(global.context, passNode(original), passNode(local))) } get localConst(): Identifier | undefined { @@ -49,4 +50,7 @@ export class ImportDefaultSpecifier extends Statement { } export function isImportDefaultSpecifier(node: AstNode): node is ImportDefaultSpecifier { return node instanceof ImportDefaultSpecifier +} +if (!nodeByType.has(41)) { + nodeByType.set(41, ImportDefaultSpecifier) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts index 489f8b840e8c75ff1e08dc6365542142c67e204b..239332713703d6f506f6adf947692e174a785ffb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,10 +34,10 @@ export class ImportExpression extends Expression { super(pointer) console.warn("Warning: stub node ImportExpression") } - static createImportExpression(source?: Expression): ImportExpression | undefined { + static createImportExpression(source?: Expression): ImportExpression { return new ImportExpression(global.generatedEs2panda._CreateImportExpression(global.context, passNode(source))) } - static updateImportExpression(original?: ImportExpression, source?: Expression): ImportExpression | undefined { + static updateImportExpression(original?: ImportExpression, source?: Expression): ImportExpression { return new ImportExpression(global.generatedEs2panda._UpdateImportExpression(global.context, passNode(original), passNode(source))) } get source(): Expression | undefined { @@ -48,4 +49,7 @@ export class ImportExpression extends Expression { } export function isImportExpression(node: AstNode): node is ImportExpression { return node instanceof ImportExpression +} +if (!nodeByType.has(40)) { + nodeByType.set(40, ImportExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts index b50dd642c7a888ac853f902365cfaea118f81c44..8f31b6bdde963f7b96fdd8ac6f2fac155fa9e581 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,10 +35,10 @@ export class ImportNamespaceSpecifier extends Statement { super(pointer) console.warn("Warning: stub node ImportNamespaceSpecifier") } - static createImportNamespaceSpecifier(local?: Identifier): ImportNamespaceSpecifier | undefined { + static createImportNamespaceSpecifier(local?: Identifier): ImportNamespaceSpecifier { return new ImportNamespaceSpecifier(global.generatedEs2panda._CreateImportNamespaceSpecifier(global.context, passNode(local))) } - static updateImportNamespaceSpecifier(original?: ImportNamespaceSpecifier, local?: Identifier): ImportNamespaceSpecifier | undefined { + static updateImportNamespaceSpecifier(original?: ImportNamespaceSpecifier, local?: Identifier): ImportNamespaceSpecifier { return new ImportNamespaceSpecifier(global.generatedEs2panda._UpdateImportNamespaceSpecifier(global.context, passNode(original), passNode(local))) } get local(): Identifier | undefined { @@ -49,4 +50,7 @@ export class ImportNamespaceSpecifier extends Statement { } export function isImportNamespaceSpecifier(node: AstNode): node is ImportNamespaceSpecifier { return node instanceof ImportNamespaceSpecifier +} +if (!nodeByType.has(42)) { + nodeByType.set(42, ImportNamespaceSpecifier) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts index 54ea216c9c09ccecee9c2cab47aeb8bda605cc35..ed85cc9ff893e2416231fa5ae54f369753216aac 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,10 +35,10 @@ export class ImportSpecifier extends Statement { super(pointer) console.warn("Warning: stub node ImportSpecifier") } - static createImportSpecifier(imported?: Identifier, local?: Identifier): ImportSpecifier | undefined { + static createImportSpecifier(imported?: Identifier, local?: Identifier): ImportSpecifier { return new ImportSpecifier(global.generatedEs2panda._CreateImportSpecifier(global.context, passNode(imported), passNode(local))) } - static updateImportSpecifier(original?: ImportSpecifier, imported?: Identifier, local?: Identifier): ImportSpecifier | undefined { + static updateImportSpecifier(original?: ImportSpecifier, imported?: Identifier, local?: Identifier): ImportSpecifier { return new ImportSpecifier(global.generatedEs2panda._UpdateImportSpecifier(global.context, passNode(original), passNode(imported), passNode(local))) } get imported(): Identifier | undefined { @@ -55,4 +56,7 @@ export class ImportSpecifier extends Statement { } export function isImportSpecifier(node: AstNode): node is ImportSpecifier { return node instanceof ImportSpecifier +} +if (!nodeByType.has(43)) { + nodeByType.set(43, ImportSpecifier) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts b/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts index 4bfb4ab119510debbd7d12ea2e07268bc845f28d..53d42c93ed24f3d1826e648bc8ea25cef3b79936 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TSInterfaceDeclaration } from "./TSInterfaceDeclaration" diff --git a/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts index 255075d6efdf83a5b37026f067286554d0557d81..04137ff53a028faeaa3ed27b6ca7b5222f39325e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -46,4 +47,7 @@ export class LabelledStatement extends Statement { } export function isLabelledStatement(node: AstNode): node is LabelledStatement { return node instanceof LabelledStatement +} +if (!nodeByType.has(44)) { + nodeByType.set(44, LabelledStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Literal.ts b/arkoala-arkts/libarkts/src/generated/peers/Literal.ts index 8b2a0410611e6d86978bc3aed2ca780e2b1770aa..1ea75b77c04866df04917942511c924fa85d442a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Literal.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Literal.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts index 73b0ba8049ccd52000af83f505f9a6ba63e7d815..b8e4df54ccb4ade72ab060cf5e6c45e0cb9790d8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" diff --git a/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts index 1759731487fe313342c7122c21e3720e28fb851a..9269c8186c4aa952e600d4c7677afc3eeedc5efd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts index fc70b945f8e120d48742830f6d6d0c48d6ea5f66..f37fa993b63d8248aaffc8ec16bd09274128f37e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { MaybeOptionalExpression } from "./MaybeOptionalExpression" @@ -35,10 +36,10 @@ export class MemberExpression extends MaybeOptionalExpression { super(pointer) console.warn("Warning: stub node MemberExpression") } - static createMemberExpression(object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression | undefined { + static createMemberExpression(object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression { return new MemberExpression(global.generatedEs2panda._CreateMemberExpression(global.context, passNode(object_arg), passNode(property), kind, computed, optional_arg)) } - static updateMemberExpression(original: MemberExpression | undefined, object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression | undefined { + static updateMemberExpression(original: MemberExpression | undefined, object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression { return new MemberExpression(global.generatedEs2panda._UpdateMemberExpression(global.context, passNode(original), passNode(object_arg), passNode(property), kind, computed, optional_arg)) } get object(): Expression | undefined { @@ -65,4 +66,7 @@ export class MemberExpression extends MaybeOptionalExpression { } export function isMemberExpression(node: AstNode): node is MemberExpression { return node instanceof MemberExpression +} +if (!nodeByType.has(45)) { + nodeByType.set(45, MemberExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts index 6d02a0c56892da42a11ec9282560a7c4a31e624a..4bb2da92c207343a28e974909b0bfff70de558af 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class MetaProperty extends Expression { super(pointer) console.warn("Warning: stub node MetaProperty") } - static createMetaProperty(kind: Es2pandaMetaPropertyKind): MetaProperty | undefined { + static createMetaProperty(kind: Es2pandaMetaPropertyKind): MetaProperty { return new MetaProperty(global.generatedEs2panda._CreateMetaProperty(global.context, kind)) } - static updateMetaProperty(original: MetaProperty | undefined, kind: Es2pandaMetaPropertyKind): MetaProperty | undefined { + static updateMetaProperty(original: MetaProperty | undefined, kind: Es2pandaMetaPropertyKind): MetaProperty { return new MetaProperty(global.generatedEs2panda._UpdateMetaProperty(global.context, passNode(original), kind)) } get kindConst(): Es2pandaMetaPropertyKind { @@ -46,4 +47,7 @@ export class MetaProperty extends Expression { } export function isMetaProperty(node: AstNode): node is MetaProperty { return node instanceof MetaProperty +} +if (!nodeByType.has(46)) { + nodeByType.set(46, MetaProperty) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts b/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts index 502e8f193e9ba51bc6e841180634c47f7e9057ad..060bfa53bb6a60ecb120974ccdb396be6c6ccb40 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ClassElement } from "./ClassElement" @@ -36,10 +37,10 @@ export class MethodDefinition extends ClassElement { super(pointer) console.warn("Warning: stub node MethodDefinition") } - static createMethodDefinition(kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition | undefined { + static createMethodDefinition(kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition { return new MethodDefinition(global.generatedEs2panda._CreateMethodDefinition(global.context, kind, passNode(key), passNode(value), modifiers, isComputed)) } - static updateMethodDefinition(original: MethodDefinition | undefined, kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition | undefined { + static updateMethodDefinition(original: MethodDefinition | undefined, kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition { return new MethodDefinition(global.generatedEs2panda._UpdateMethodDefinition(global.context, passNode(original), kind, passNode(key), passNode(value), modifiers, isComputed)) } get kindConst(): Es2pandaMethodDefinitionKind { @@ -69,4 +70,7 @@ export class MethodDefinition extends ClassElement { } export function isMethodDefinition(node: AstNode): node is MethodDefinition { return node instanceof MethodDefinition +} +if (!nodeByType.has(47)) { + nodeByType.set(47, MethodDefinition) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts b/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts index a8060bb1b7f6bdb45f207876dc1febd08e080234..c94085776200c456d5d6adfea490f4781c0e8be3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -35,10 +36,10 @@ export class NamedType extends TypeNode { super(pointer) console.warn("Warning: stub node NamedType") } - static createNamedType(name?: Identifier): NamedType | undefined { + static createNamedType(name?: Identifier): NamedType { return new NamedType(global.generatedEs2panda._CreateNamedType(global.context, passNode(name))) } - static updateNamedType(original?: NamedType, name?: Identifier): NamedType | undefined { + static updateNamedType(original?: NamedType, name?: Identifier): NamedType { return new NamedType(global.generatedEs2panda._UpdateNamedType(global.context, passNode(original), passNode(name))) } get nameConst(): Identifier | undefined { @@ -53,4 +54,7 @@ export class NamedType extends TypeNode { } export function isNamedType(node: AstNode): node is NamedType { return node instanceof NamedType +} +if (!nodeByType.has(48)) { + nodeByType.set(48, NamedType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts index 1c43309d01be1ba4da901d7a6240fcdd8eb38773..a303f11b0bde75a6cb06119dc802bb7900c2c585 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,10 +34,10 @@ export class NewExpression extends Expression { super(pointer) console.warn("Warning: stub node NewExpression") } - static createNewExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): NewExpression | undefined { + static createNewExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): NewExpression { return new NewExpression(global.generatedEs2panda._CreateNewExpression(global.context, passNode(callee), passNodeArray(_arguments), argumentsLen)) } - static updateNewExpression(original: NewExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): NewExpression | undefined { + static updateNewExpression(original: NewExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): NewExpression { return new NewExpression(global.generatedEs2panda._UpdateNewExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), argumentsLen)) } get calleeConst(): Expression | undefined { @@ -48,4 +49,7 @@ export class NewExpression extends Expression { } export function isNewExpression(node: AstNode): node is NewExpression { return node instanceof NewExpression +} +if (!nodeByType.has(49)) { + nodeByType.set(49, NewExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts index b61e7aa8ced4ab836c3201c84df443ea0055ea7f..138dca3e5a1224a4a1d23ce6c76d939cb8bd1ff1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -33,13 +34,16 @@ export class NullLiteral extends Literal { super(pointer) console.warn("Warning: stub node NullLiteral") } - static createNullLiteral(): NullLiteral | undefined { + static createNullLiteral(): NullLiteral { return new NullLiteral(global.generatedEs2panda._CreateNullLiteral(global.context)) } - static updateNullLiteral(original?: NullLiteral): NullLiteral | undefined { + static updateNullLiteral(original?: NullLiteral): NullLiteral { return new NullLiteral(global.generatedEs2panda._UpdateNullLiteral(global.context, passNode(original))) } } export function isNullLiteral(node: AstNode): node is NullLiteral { return node instanceof NullLiteral +} +if (!nodeByType.has(50)) { + nodeByType.set(50, NullLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts index 0677d42de75a66042c9f3cb0d0f4bde1da4eb3fb..25df8b1f076e42c7593f1dc0873543b8e321b5f6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -39,4 +40,7 @@ export class NumberLiteral extends Literal { } export function isNumberLiteral(node: AstNode): node is NumberLiteral { return node instanceof NumberLiteral +} +if (!nodeByType.has(52)) { + nodeByType.set(52, NumberLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts index 1c8e9eea739e5736c623b645051cef026e2759ef..5191506def15dae266236ef32ec6469583d246e8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedExpression } from "./AnnotatedExpression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts index ec426f5fcbeddd36c04bab308a31d6a787029c3d..0b7bb2292e19a1b3b20a6a69a66597e6aa4c0334 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,13 +34,16 @@ export class OmittedExpression extends Expression { super(pointer) console.warn("Warning: stub node OmittedExpression") } - static createOmittedExpression(): OmittedExpression | undefined { + static createOmittedExpression(): OmittedExpression { return new OmittedExpression(global.generatedEs2panda._CreateOmittedExpression(global.context)) } - static updateOmittedExpression(original?: OmittedExpression): OmittedExpression | undefined { + static updateOmittedExpression(original?: OmittedExpression): OmittedExpression { return new OmittedExpression(global.generatedEs2panda._UpdateOmittedExpression(global.context, passNode(original))) } } export function isOmittedExpression(node: AstNode): node is OmittedExpression { return node instanceof OmittedExpression +} +if (!nodeByType.has(53)) { + nodeByType.set(53, OmittedExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts b/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts index 2dde8584eb07243086b894ee7ef8ad8dcbc65310..402149a3b015e0e8fd8b5cdeeb47c2928989f493 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class OpaqueTypeNode extends TypeNode { super(pointer) console.warn("Warning: stub node OpaqueTypeNode") } - static create1OpaqueTypeNode(): OpaqueTypeNode | undefined { + static create1OpaqueTypeNode(): OpaqueTypeNode { return new OpaqueTypeNode(global.generatedEs2panda._CreateOpaqueTypeNode1(global.context)) } - static update1OpaqueTypeNode(original?: OpaqueTypeNode): OpaqueTypeNode | undefined { + static update1OpaqueTypeNode(original?: OpaqueTypeNode): OpaqueTypeNode { return new OpaqueTypeNode(global.generatedEs2panda._UpdateOpaqueTypeNode1(global.context, passNode(original))) } } export function isOpaqueTypeNode(node: AstNode): node is OpaqueTypeNode { return node instanceof OpaqueTypeNode +} +if (!nodeByType.has(153)) { + nodeByType.set(153, OpaqueTypeNode) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts index 115f28cb4665c82239f48e36302eaaa621228a10..0f0f3b40b502b99274c6b6766615f17d8a9d2e20 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class PrefixAssertionExpression extends Expression { super(pointer) console.warn("Warning: stub node PrefixAssertionExpression") } - static createPrefixAssertionExpression(expr?: Expression, type?: TypeNode): PrefixAssertionExpression | undefined { + static createPrefixAssertionExpression(expr?: Expression, type?: TypeNode): PrefixAssertionExpression { return new PrefixAssertionExpression(global.generatedEs2panda._CreatePrefixAssertionExpression(global.context, passNode(expr), passNode(type))) } - static updatePrefixAssertionExpression(original?: PrefixAssertionExpression, expr?: Expression, type?: TypeNode): PrefixAssertionExpression | undefined { + static updatePrefixAssertionExpression(original?: PrefixAssertionExpression, expr?: Expression, type?: TypeNode): PrefixAssertionExpression { return new PrefixAssertionExpression(global.generatedEs2panda._UpdatePrefixAssertionExpression(global.context, passNode(original), passNode(expr), passNode(type))) } get exprConst(): Expression | undefined { @@ -49,4 +50,7 @@ export class PrefixAssertionExpression extends Expression { } export function isPrefixAssertionExpression(node: AstNode): node is PrefixAssertionExpression { return node instanceof PrefixAssertionExpression +} +if (!nodeByType.has(54)) { + nodeByType.set(54, PrefixAssertionExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Property.ts b/arkoala-arkts/libarkts/src/generated/peers/Property.ts index 67f37e128a0ea62ace6b9167fa2809993e1edb15..79ad82d32284a2e087e190b54f47277670de971c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Property.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Property.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,16 +35,16 @@ export class Property extends Expression { super(pointer) console.warn("Warning: stub node Property") } - static createProperty(key?: Expression, value?: Expression): Property | undefined { + static createProperty(key?: Expression, value?: Expression): Property { return new Property(global.generatedEs2panda._CreateProperty(global.context, passNode(key), passNode(value))) } - static updateProperty(original?: Property, key?: Expression, value?: Expression): Property | undefined { + static updateProperty(original?: Property, key?: Expression, value?: Expression): Property { return new Property(global.generatedEs2panda._UpdateProperty(global.context, passNode(original), passNode(key), passNode(value))) } - static create1Property(kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property | undefined { + static create1Property(kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property { return new Property(global.generatedEs2panda._CreateProperty1(global.context, kind, passNode(key), passNode(value), isMethod, isComputed)) } - static update1Property(original: Property | undefined, kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property | undefined { + static update1Property(original: Property | undefined, kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property { return new Property(global.generatedEs2panda._UpdateProperty1(global.context, passNode(original), kind, passNode(key), passNode(value), isMethod, isComputed)) } get key(): Expression | undefined { @@ -76,4 +77,7 @@ export class Property extends Expression { } export function isProperty(node: AstNode): node is Property { return node instanceof Property +} +if (!nodeByType.has(55)) { + nodeByType.set(55, Property) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts index 002fab2986a23aaacb1bbe143f1a652a7129f4df..e5d7aca88d0c19fe72d9434bf766d98c4cdbe04b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -34,10 +35,10 @@ export class RegExpLiteral extends Literal { super(pointer) console.warn("Warning: stub node RegExpLiteral") } - static createRegExpLiteral(pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral | undefined { + static createRegExpLiteral(pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral { return new RegExpLiteral(global.generatedEs2panda._CreateRegExpLiteral(global.context, pattern, flags, flagsStr)) } - static updateRegExpLiteral(original: RegExpLiteral | undefined, pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral | undefined { + static updateRegExpLiteral(original: RegExpLiteral | undefined, pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral { return new RegExpLiteral(global.generatedEs2panda._UpdateRegExpLiteral(global.context, passNode(original), pattern, flags, flagsStr)) } get patternConst(): string { @@ -49,4 +50,7 @@ export class RegExpLiteral extends Literal { } export function isRegExpLiteral(node: AstNode): node is RegExpLiteral { return node instanceof RegExpLiteral +} +if (!nodeByType.has(56)) { + nodeByType.set(56, RegExpLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts index 6d416cdbe8724869c8fc1846619080fcc824b018..066ed62b620b5ae601ed333c078a74680457452e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,16 +35,16 @@ export class ReturnStatement extends Statement { super(pointer) console.warn("Warning: stub node ReturnStatement") } - static createReturnStatement(): ReturnStatement | undefined { + static createReturnStatement(): ReturnStatement { return new ReturnStatement(global.generatedEs2panda._CreateReturnStatement(global.context)) } - static updateReturnStatement(original?: ReturnStatement): ReturnStatement | undefined { + static updateReturnStatement(original?: ReturnStatement): ReturnStatement { return new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement(global.context, passNode(original))) } - static create1ReturnStatement(argument?: Expression): ReturnStatement | undefined { + static create1ReturnStatement(argument?: Expression): ReturnStatement { return new ReturnStatement(global.generatedEs2panda._CreateReturnStatement1(global.context, passNode(argument))) } - static update1ReturnStatement(original?: ReturnStatement, argument?: Expression): ReturnStatement | undefined { + static update1ReturnStatement(original?: ReturnStatement, argument?: Expression): ReturnStatement { return new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement1(global.context, passNode(original), passNode(argument))) } get argument(): Expression | undefined { @@ -55,4 +56,7 @@ export class ReturnStatement extends Statement { } export function isReturnStatement(node: AstNode): node is ReturnStatement { return node instanceof ReturnStatement +} +if (!nodeByType.has(58)) { + nodeByType.set(58, ReturnStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts b/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts index 062ae458e80fd923af6683186f35398a6386d4e3..ec0eff15a85a8ed027432838157525496e0204ef 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Identifier } from "./Identifier" @@ -168,4 +169,7 @@ export class ScriptFunction extends AstNode { } export function isScriptFunction(node: AstNode): node is ScriptFunction { return node instanceof ScriptFunction +} +if (!nodeByType.has(59)) { + nodeByType.set(59, ScriptFunction) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts index df3665420b0d3c40ea7297d36c70d90d1861dfc7..db6bbc5e515739042fc8441736716102ef09ae5c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,10 +34,10 @@ export class SequenceExpression extends Expression { super(pointer) console.warn("Warning: stub node SequenceExpression") } - static createSequenceExpression(sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression | undefined { + static createSequenceExpression(sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression { return new SequenceExpression(global.generatedEs2panda._CreateSequenceExpression(global.context, passNodeArray(sequence_arg), sequenceLen)) } - static updateSequenceExpression(original: SequenceExpression | undefined, sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression | undefined { + static updateSequenceExpression(original: SequenceExpression | undefined, sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression { return new SequenceExpression(global.generatedEs2panda._UpdateSequenceExpression(global.context, passNode(original), passNodeArray(sequence_arg), sequenceLen)) } get sequenceConst(): readonly Expression[] { @@ -48,4 +49,7 @@ export class SequenceExpression extends Expression { } export function isSequenceExpression(node: AstNode): node is SequenceExpression { return node instanceof SequenceExpression +} +if (!nodeByType.has(60)) { + nodeByType.set(60, SequenceExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts b/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts index 85b1a750c81f71dea40e65d41673680646c3e4f0..b8b5489ec97a9db90ffafecefdc2596fb91c8586 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedExpression } from "./AnnotatedExpression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/Statement.ts b/arkoala-arkts/libarkts/src/generated/peers/Statement.ts index b3c39e95dbd6df53a11318884bf35f31ecd40b4b..f1d2849fa617972365bcb4c56f16d5ac798da7e4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Statement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Statement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" export abstract class Statement extends AstNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts index cec3d65cd074c6ac7eef24689c230f4ae37df547..877d51956c0e1c75ca249e5e04614a7ed294a939 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -33,13 +34,13 @@ export class StringLiteral extends Literal { super(pointer) console.warn("Warning: stub node StringLiteral") } - static updateStringLiteral(original?: StringLiteral): StringLiteral | undefined { + static updateStringLiteral(original?: StringLiteral): StringLiteral { return new StringLiteral(global.generatedEs2panda._UpdateStringLiteral(global.context, passNode(original))) } - static create1StringLiteral(str: string): StringLiteral | undefined { + static create1StringLiteral(str: string): StringLiteral { return new StringLiteral(global.generatedEs2panda._CreateStringLiteral1(global.context, str)) } - static update1StringLiteral(original: StringLiteral | undefined, str: string): StringLiteral | undefined { + static update1StringLiteral(original: StringLiteral | undefined, str: string): StringLiteral { return new StringLiteral(global.generatedEs2panda._UpdateStringLiteral1(global.context, passNode(original), str)) } get strConst(): string { @@ -48,4 +49,7 @@ export class StringLiteral extends Literal { } export function isStringLiteral(node: AstNode): node is StringLiteral { return node instanceof StringLiteral +} +if (!nodeByType.has(61)) { + nodeByType.set(61, StringLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts index cfd0c78cae68ce5dfef2dc94a006a83c408fe868..7257a67a9a2a78c7d5c17f1ecf73d1d53f37db21 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,13 +34,16 @@ export class SuperExpression extends Expression { super(pointer) console.warn("Warning: stub node SuperExpression") } - static createSuperExpression(): SuperExpression | undefined { + static createSuperExpression(): SuperExpression { return new SuperExpression(global.generatedEs2panda._CreateSuperExpression(global.context)) } - static updateSuperExpression(original?: SuperExpression): SuperExpression | undefined { + static updateSuperExpression(original?: SuperExpression): SuperExpression { return new SuperExpression(global.generatedEs2panda._UpdateSuperExpression(global.context, passNode(original))) } } export function isSuperExpression(node: AstNode): node is SuperExpression { return node instanceof SuperExpression +} +if (!nodeByType.has(82)) { + nodeByType.set(82, SuperExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts index 64bcdb304c7c4e95f96a787b1350705f6bb3c03e..a56fdb3cc3bbec4e9234c2d4e8762af4c9365c6a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -46,4 +47,7 @@ export class SwitchCaseStatement extends Statement { } export function isSwitchCaseStatement(node: AstNode): node is SwitchCaseStatement { return node instanceof SwitchCaseStatement +} +if (!nodeByType.has(84)) { + nodeByType.set(84, SwitchCaseStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts index 824fc4be83599893eded98ff277add86c445847c..e2dec77098e67e21968c68231abe7ec92388a7bb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -35,10 +36,10 @@ export class SwitchStatement extends Statement { super(pointer) console.warn("Warning: stub node SwitchStatement") } - static createSwitchStatement(discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement | undefined { + static createSwitchStatement(discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement { return new SwitchStatement(global.generatedEs2panda._CreateSwitchStatement(global.context, passNode(discriminant), passNodeArray(cases), casesLen)) } - static updateSwitchStatement(original: SwitchStatement | undefined, discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement | undefined { + static updateSwitchStatement(original: SwitchStatement | undefined, discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement { return new SwitchStatement(global.generatedEs2panda._UpdateSwitchStatement(global.context, passNode(original), passNode(discriminant), passNodeArray(cases), casesLen)) } get discriminantConst(): Expression | undefined { @@ -56,4 +57,7 @@ export class SwitchStatement extends Statement { } export function isSwitchStatement(node: AstNode): node is SwitchStatement { return node instanceof SwitchStatement +} +if (!nodeByType.has(85)) { + nodeByType.set(85, SwitchStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts index a9e9bc5c4322f6b9fc5778960994d6648a9d5e87..0554e0ec060b56d1db08e9aca4f11e70b43eb42d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class TSAnyKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSAnyKeyword") } - static createTSAnyKeyword(): TSAnyKeyword | undefined { + static createTSAnyKeyword(): TSAnyKeyword { return new TSAnyKeyword(global.generatedEs2panda._CreateTSAnyKeyword(global.context)) } - static updateTSAnyKeyword(original?: TSAnyKeyword): TSAnyKeyword | undefined { + static updateTSAnyKeyword(original?: TSAnyKeyword): TSAnyKeyword { return new TSAnyKeyword(global.generatedEs2panda._UpdateTSAnyKeyword(global.context, passNode(original))) } } export function isTSAnyKeyword(node: AstNode): node is TSAnyKeyword { return node instanceof TSAnyKeyword +} +if (!nodeByType.has(90)) { + nodeByType.set(90, TSAnyKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts index 7c08bd7bc197bf6882dd9a0ecff297105f45fbd2..5b83f3e2e3272a304bfe118c838bb7a3c32653b4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,10 +34,10 @@ export class TSArrayType extends TypeNode { super(pointer) console.warn("Warning: stub node TSArrayType") } - static createTSArrayType(elementType?: TypeNode): TSArrayType | undefined { + static createTSArrayType(elementType?: TypeNode): TSArrayType { return new TSArrayType(global.generatedEs2panda._CreateTSArrayType(global.context, passNode(elementType))) } - static updateTSArrayType(original?: TSArrayType, elementType?: TypeNode): TSArrayType | undefined { + static updateTSArrayType(original?: TSArrayType, elementType?: TypeNode): TSArrayType { return new TSArrayType(global.generatedEs2panda._UpdateTSArrayType(global.context, passNode(original), passNode(elementType))) } get elementTypeConst(): TypeNode | undefined { @@ -45,4 +46,7 @@ export class TSArrayType extends TypeNode { } export function isTSArrayType(node: AstNode): node is TSArrayType { return node instanceof TSArrayType +} +if (!nodeByType.has(101)) { + nodeByType.set(101, TSArrayType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts index 6d892689c0f17a2c4b269ca419acbdc1d1713edd..e2e94a6892f6f684c29c4994470373ba9b4eadef 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedExpression } from "./AnnotatedExpression" @@ -35,10 +36,10 @@ export class TSAsExpression extends AnnotatedExpression { super(pointer) console.warn("Warning: stub node TSAsExpression") } - static createTSAsExpression(expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression | undefined { + static createTSAsExpression(expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression { return new TSAsExpression(global.generatedEs2panda._CreateTSAsExpression(global.context, passNode(expression), passNode(typeAnnotation), isConst)) } - static updateTSAsExpression(original: TSAsExpression | undefined, expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression | undefined { + static updateTSAsExpression(original: TSAsExpression | undefined, expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression { return new TSAsExpression(global.generatedEs2panda._UpdateTSAsExpression(global.context, passNode(original), passNode(expression), passNode(typeAnnotation), isConst)) } get exprConst(): Expression | undefined { @@ -53,4 +54,7 @@ export class TSAsExpression extends AnnotatedExpression { } export function isTSAsExpression(node: AstNode): node is TSAsExpression { return node instanceof TSAsExpression +} +if (!nodeByType.has(137)) { + nodeByType.set(137, TSAsExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts index 5c5e0204e9c41d5c1f948c62dd5b7dff8394f664..7b09d8a028b052d115540c77fc550e14d1ac74be 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class TSBigintKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSBigintKeyword") } - static createTSBigintKeyword(): TSBigintKeyword | undefined { + static createTSBigintKeyword(): TSBigintKeyword { return new TSBigintKeyword(global.generatedEs2panda._CreateTSBigintKeyword(global.context)) } - static updateTSBigintKeyword(original?: TSBigintKeyword): TSBigintKeyword | undefined { + static updateTSBigintKeyword(original?: TSBigintKeyword): TSBigintKeyword { return new TSBigintKeyword(global.generatedEs2panda._UpdateTSBigintKeyword(global.context, passNode(original))) } } export function isTSBigintKeyword(node: AstNode): node is TSBigintKeyword { return node instanceof TSBigintKeyword +} +if (!nodeByType.has(97)) { + nodeByType.set(97, TSBigintKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts index 25fd5d2b42417492f0d5bd3b0db136fd23a849e9..f5310ed5f56c1555d91a218a47762c32833b7df4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class TSBooleanKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSBooleanKeyword") } - static createTSBooleanKeyword(): TSBooleanKeyword | undefined { + static createTSBooleanKeyword(): TSBooleanKeyword { return new TSBooleanKeyword(global.generatedEs2panda._CreateTSBooleanKeyword(global.context)) } - static updateTSBooleanKeyword(original?: TSBooleanKeyword): TSBooleanKeyword | undefined { + static updateTSBooleanKeyword(original?: TSBooleanKeyword): TSBooleanKeyword { return new TSBooleanKeyword(global.generatedEs2panda._UpdateTSBooleanKeyword(global.context, passNode(original))) } } export function isTSBooleanKeyword(node: AstNode): node is TSBooleanKeyword { return node instanceof TSBooleanKeyword +} +if (!nodeByType.has(92)) { + nodeByType.set(92, TSBooleanKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts b/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts index a5e43b62a4c66deb2a63e3cfd6c503c0a9142a93..2580d32a61d7065283c7e145afa97c091193a682 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,16 +35,16 @@ export class TSClassImplements extends Expression { super(pointer) console.warn("Warning: stub node TSClassImplements") } - static createTSClassImplements(expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements | undefined { + static createTSClassImplements(expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements { return new TSClassImplements(global.generatedEs2panda._CreateTSClassImplements(global.context, passNode(expression), passNode(typeParameters))) } - static updateTSClassImplements(original?: TSClassImplements, expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements | undefined { + static updateTSClassImplements(original?: TSClassImplements, expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements { return new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements(global.context, passNode(original), passNode(expression), passNode(typeParameters))) } - static create1TSClassImplements(expression?: Expression): TSClassImplements | undefined { + static create1TSClassImplements(expression?: Expression): TSClassImplements { return new TSClassImplements(global.generatedEs2panda._CreateTSClassImplements1(global.context, passNode(expression))) } - static update1TSClassImplements(original?: TSClassImplements, expression?: Expression): TSClassImplements | undefined { + static update1TSClassImplements(original?: TSClassImplements, expression?: Expression): TSClassImplements { return new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements1(global.context, passNode(original), passNode(expression))) } get expr(): Expression | undefined { @@ -58,4 +59,7 @@ export class TSClassImplements extends Expression { } export function isTSClassImplements(node: AstNode): node is TSClassImplements { return node instanceof TSClassImplements +} +if (!nodeByType.has(138)) { + nodeByType.set(138, TSClassImplements) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts index 21f9982bd636f8a4b2797e7f9745bb35dd911dd0..d65e3496c757fadfb641d7d67c7339c02265b24f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -34,10 +35,10 @@ export class TSConditionalType extends TypeNode { super(pointer) console.warn("Warning: stub node TSConditionalType") } - static createTSConditionalType(checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType | undefined { + static createTSConditionalType(checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType { return new TSConditionalType(global.generatedEs2panda._CreateTSConditionalType(global.context, passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType))) } - static updateTSConditionalType(original?: TSConditionalType, checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType | undefined { + static updateTSConditionalType(original?: TSConditionalType, checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType { return new TSConditionalType(global.generatedEs2panda._UpdateTSConditionalType(global.context, passNode(original), passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType))) } get checkTypeConst(): Expression | undefined { @@ -55,4 +56,7 @@ export class TSConditionalType extends TypeNode { } export function isTSConditionalType(node: AstNode): node is TSConditionalType { return node instanceof TSConditionalType +} +if (!nodeByType.has(110)) { + nodeByType.set(110, TSConditionalType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts index eeb36fa8ad564562ec2d1e54e5740b76d0d8b5d2..daf1cc7540f9a8e8ec42cda6e0be33d9b58c95ac 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -56,4 +57,7 @@ export class TSConstructorType extends TypeNode { } export function isTSConstructorType(node: AstNode): node is TSConstructorType { return node instanceof TSConstructorType +} +if (!nodeByType.has(125)) { + nodeByType.set(125, TSConstructorType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts index d02c582043331054233888b369eb0406aafdb49d..a53d96c14d0b0a0182233028d4bfd3babeb1aa18 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedStatement } from "./TypedStatement" @@ -36,10 +37,10 @@ export class TSEnumDeclaration extends TypedStatement { super(pointer) console.warn("Warning: stub node TSEnumDeclaration") } - static createTSEnumDeclaration(key: Identifier | undefined, members: readonly AstNode[], membersLen: number, isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration | undefined { + static createTSEnumDeclaration(key: Identifier | undefined, members: readonly AstNode[], membersLen: number, isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration { return new TSEnumDeclaration(global.generatedEs2panda._CreateTSEnumDeclaration(global.context, passNode(key), passNodeArray(members), membersLen, isConst, isStatic, isDeclare)) } - static updateTSEnumDeclaration(original: TSEnumDeclaration | undefined, key: Identifier | undefined, members: readonly AstNode[], membersLen: number, isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration | undefined { + static updateTSEnumDeclaration(original: TSEnumDeclaration | undefined, key: Identifier | undefined, members: readonly AstNode[], membersLen: number, isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration { return new TSEnumDeclaration(global.generatedEs2panda._UpdateTSEnumDeclaration(global.context, passNode(original), passNode(key), passNodeArray(members), membersLen, isConst, isStatic, isDeclare)) } get keyConst(): Identifier | undefined { @@ -66,4 +67,7 @@ export class TSEnumDeclaration extends TypedStatement { } export function isTSEnumDeclaration(node: AstNode): node is TSEnumDeclaration { return node instanceof TSEnumDeclaration +} +if (!nodeByType.has(86)) { + nodeByType.set(86, TSEnumDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts b/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts index 30fd92c709b0511488f46ceddaaf887b5dff9cec..2dada9d1d8057bfd9f305879093877b2493ff7a4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,16 +35,16 @@ export class TSEnumMember extends Statement { super(pointer) console.warn("Warning: stub node TSEnumMember") } - static createTSEnumMember(key?: Expression, init?: Expression): TSEnumMember | undefined { + static createTSEnumMember(key?: Expression, init?: Expression): TSEnumMember { return new TSEnumMember(global.generatedEs2panda._CreateTSEnumMember(global.context, passNode(key), passNode(init))) } - static updateTSEnumMember(original?: TSEnumMember, key?: Expression, init?: Expression): TSEnumMember | undefined { + static updateTSEnumMember(original?: TSEnumMember, key?: Expression, init?: Expression): TSEnumMember { return new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember(global.context, passNode(original), passNode(key), passNode(init))) } - static create1TSEnumMember(key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember | undefined { + static create1TSEnumMember(key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember { return new TSEnumMember(global.generatedEs2panda._CreateTSEnumMember1(global.context, passNode(key), passNode(init), isGenerated)) } - static update1TSEnumMember(original: TSEnumMember | undefined, key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember | undefined { + static update1TSEnumMember(original: TSEnumMember | undefined, key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember { return new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember1(global.context, passNode(original), passNode(key), passNode(init), isGenerated)) } get keyConst(): Expression | undefined { @@ -64,4 +65,7 @@ export class TSEnumMember extends Statement { } export function isTSEnumMember(node: AstNode): node is TSEnumMember { return node instanceof TSEnumMember +} +if (!nodeByType.has(87)) { + nodeByType.set(87, TSEnumMember) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts b/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts index 68f06199e0a8bd11065f6114d13b6f865a440d47..09292e1a8bb3710946007d98df89a4322b11d716 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,10 +34,10 @@ export class TSExternalModuleReference extends Expression { super(pointer) console.warn("Warning: stub node TSExternalModuleReference") } - static createTSExternalModuleReference(expr?: Expression): TSExternalModuleReference | undefined { + static createTSExternalModuleReference(expr?: Expression): TSExternalModuleReference { return new TSExternalModuleReference(global.generatedEs2panda._CreateTSExternalModuleReference(global.context, passNode(expr))) } - static updateTSExternalModuleReference(original?: TSExternalModuleReference, expr?: Expression): TSExternalModuleReference | undefined { + static updateTSExternalModuleReference(original?: TSExternalModuleReference, expr?: Expression): TSExternalModuleReference { return new TSExternalModuleReference(global.generatedEs2panda._UpdateTSExternalModuleReference(global.context, passNode(original), passNode(expr))) } get exprConst(): Expression | undefined { @@ -45,4 +46,7 @@ export class TSExternalModuleReference extends Expression { } export function isTSExternalModuleReference(node: AstNode): node is TSExternalModuleReference { return node instanceof TSExternalModuleReference +} +if (!nodeByType.has(88)) { + nodeByType.set(88, TSExternalModuleReference) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts index a69de43ee62aa432a17934b72feaa7db5f60d613..aa112e1bfbdc556c4506352f3c2f2ffc7a9d382e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -53,4 +54,7 @@ export class TSFunctionType extends TypeNode { } export function isTSFunctionType(node: AstNode): node is TSFunctionType { return node instanceof TSFunctionType +} +if (!nodeByType.has(124)) { + nodeByType.set(124, TSFunctionType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts index 15d08992426095abe3af08948ea54a0e48c496f4..4439807d15ba529e01c0d9ff2b9acdcbd11957b9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -35,10 +36,10 @@ export class TSImportEqualsDeclaration extends Statement { super(pointer) console.warn("Warning: stub node TSImportEqualsDeclaration") } - static createTSImportEqualsDeclaration(id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration | undefined { + static createTSImportEqualsDeclaration(id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration { return new TSImportEqualsDeclaration(global.generatedEs2panda._CreateTSImportEqualsDeclaration(global.context, passNode(id), passNode(moduleReference), isExport)) } - static updateTSImportEqualsDeclaration(original: TSImportEqualsDeclaration | undefined, id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration | undefined { + static updateTSImportEqualsDeclaration(original: TSImportEqualsDeclaration | undefined, id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration { return new TSImportEqualsDeclaration(global.generatedEs2panda._UpdateTSImportEqualsDeclaration(global.context, passNode(original), passNode(id), passNode(moduleReference), isExport)) } get idConst(): Identifier | undefined { @@ -53,4 +54,7 @@ export class TSImportEqualsDeclaration extends Statement { } export function isTSImportEqualsDeclaration(node: AstNode): node is TSImportEqualsDeclaration { return node instanceof TSImportEqualsDeclaration +} +if (!nodeByType.has(123)) { + nodeByType.set(123, TSImportEqualsDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts index d3baf27b2c88575b7b951b891111f906c922220a..01cce76615889d5c97e4c7495c69bcf5d3c82f8d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -35,10 +36,10 @@ export class TSImportType extends TypeNode { super(pointer) console.warn("Warning: stub node TSImportType") } - static createTSImportType(param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType | undefined { + static createTSImportType(param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType { return new TSImportType(global.generatedEs2panda._CreateTSImportType(global.context, passNode(param), passNode(typeParams), passNode(qualifier), isTypeof)) } - static updateTSImportType(original: TSImportType | undefined, param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType | undefined { + static updateTSImportType(original: TSImportType | undefined, param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType { return new TSImportType(global.generatedEs2panda._UpdateTSImportType(global.context, passNode(original), passNode(param), passNode(typeParams), passNode(qualifier), isTypeof)) } get paramConst(): Expression | undefined { @@ -56,4 +57,7 @@ export class TSImportType extends TypeNode { } export function isTSImportType(node: AstNode): node is TSImportType { return node instanceof TSImportType +} +if (!nodeByType.has(111)) { + nodeByType.set(111, TSImportType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts index 929d213b3fc729cd808772f7b3805f12395eeeee..cc1ae8a705708f6f67cb22461d834fddb5313432 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedAstNode } from "./TypedAstNode" @@ -35,10 +36,10 @@ export class TSIndexSignature extends TypedAstNode { super(pointer) console.warn("Warning: stub node TSIndexSignature") } - static createTSIndexSignature(param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature | undefined { + static createTSIndexSignature(param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature { return new TSIndexSignature(global.generatedEs2panda._CreateTSIndexSignature(global.context, passNode(param), passNode(typeAnnotation), readonly_arg)) } - static updateTSIndexSignature(original: TSIndexSignature | undefined, param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature | undefined { + static updateTSIndexSignature(original: TSIndexSignature | undefined, param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature { return new TSIndexSignature(global.generatedEs2panda._UpdateTSIndexSignature(global.context, passNode(original), passNode(param), passNode(typeAnnotation), readonly_arg)) } get paramConst(): Expression | undefined { @@ -53,4 +54,7 @@ export class TSIndexSignature extends TypedAstNode { } export function isTSIndexSignature(node: AstNode): node is TSIndexSignature { return node instanceof TSIndexSignature +} +if (!nodeByType.has(135)) { + nodeByType.set(135, TSIndexSignature) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts index f1792697d82acd951e6fb5c9011f6e51e5ee8d6f..3a4735dc748cdf67be586343714e91c4b2f7295e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,10 +34,10 @@ export class TSIndexedAccessType extends TypeNode { super(pointer) console.warn("Warning: stub node TSIndexedAccessType") } - static createTSIndexedAccessType(objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType | undefined { + static createTSIndexedAccessType(objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType { return new TSIndexedAccessType(global.generatedEs2panda._CreateTSIndexedAccessType(global.context, passNode(objectType), passNode(indexType))) } - static updateTSIndexedAccessType(original?: TSIndexedAccessType, objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType | undefined { + static updateTSIndexedAccessType(original?: TSIndexedAccessType, objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType { return new TSIndexedAccessType(global.generatedEs2panda._UpdateTSIndexedAccessType(global.context, passNode(original), passNode(objectType), passNode(indexType))) } get objectTypeConst(): TypeNode | undefined { @@ -48,4 +49,7 @@ export class TSIndexedAccessType extends TypeNode { } export function isTSIndexedAccessType(node: AstNode): node is TSIndexedAccessType { return node instanceof TSIndexedAccessType +} +if (!nodeByType.has(129)) { + nodeByType.set(129, TSIndexedAccessType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts index f0b45fdbfcd5b54d615a001b7da25f9c7962bffb..fd155eb7653679b505a0e80362a83591efcfea7f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -34,10 +35,10 @@ export class TSInferType extends TypeNode { super(pointer) console.warn("Warning: stub node TSInferType") } - static createTSInferType(typeParam?: TSTypeParameter): TSInferType | undefined { + static createTSInferType(typeParam?: TSTypeParameter): TSInferType { return new TSInferType(global.generatedEs2panda._CreateTSInferType(global.context, passNode(typeParam))) } - static updateTSInferType(original?: TSInferType, typeParam?: TSTypeParameter): TSInferType | undefined { + static updateTSInferType(original?: TSInferType, typeParam?: TSTypeParameter): TSInferType { return new TSInferType(global.generatedEs2panda._UpdateTSInferType(global.context, passNode(original), passNode(typeParam))) } get typeParamConst(): TSTypeParameter | undefined { @@ -46,4 +47,7 @@ export class TSInferType extends TypeNode { } export function isTSInferType(node: AstNode): node is TSInferType { return node instanceof TSInferType +} +if (!nodeByType.has(109)) { + nodeByType.set(109, TSInferType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts index 284f288096f967fa5589ac9422d41e84d57cba9e..73133678ff3ff9a5bf93300dd99db2bd2f498ff8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,10 +34,10 @@ export class TSInterfaceBody extends Expression { super(pointer) console.warn("Warning: stub node TSInterfaceBody") } - static createTSInterfaceBody(body: readonly AstNode[], bodyLen: number): TSInterfaceBody | undefined { + static createTSInterfaceBody(body: readonly AstNode[], bodyLen: number): TSInterfaceBody { return new TSInterfaceBody(global.generatedEs2panda._CreateTSInterfaceBody(global.context, passNodeArray(body), bodyLen)) } - static updateTSInterfaceBody(original: TSInterfaceBody | undefined, body: readonly AstNode[], bodyLen: number): TSInterfaceBody | undefined { + static updateTSInterfaceBody(original: TSInterfaceBody | undefined, body: readonly AstNode[], bodyLen: number): TSInterfaceBody { return new TSInterfaceBody(global.generatedEs2panda._UpdateTSInterfaceBody(global.context, passNode(original), passNodeArray(body), bodyLen)) } get bodyPtr(): readonly AstNode[] { @@ -51,4 +52,7 @@ export class TSInterfaceBody extends Expression { } export function isTSInterfaceBody(node: AstNode): node is TSInterfaceBody { return node instanceof TSInterfaceBody +} +if (!nodeByType.has(131)) { + nodeByType.set(131, TSInterfaceBody) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts index f9bea725335d3b090ce8eeebcd938505d4a1264b..d015665ef080fea80bfdf2812548ec455ed5af41 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedStatement } from "./TypedStatement" @@ -40,10 +41,10 @@ export class TSInterfaceDeclaration extends TypedStatement { super(pointer) console.warn("Warning: stub node TSInterfaceDeclaration") } - static createTSInterfaceDeclaration(_extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration | undefined { + static createTSInterfaceDeclaration(_extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration { return new TSInterfaceDeclaration(global.generatedEs2panda._CreateTSInterfaceDeclaration(global.context, passNodeArray(_extends), extendsLen, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal)) } - static updateTSInterfaceDeclaration(original: TSInterfaceDeclaration | undefined, _extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration | undefined { + static updateTSInterfaceDeclaration(original: TSInterfaceDeclaration | undefined, _extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration { return new TSInterfaceDeclaration(global.generatedEs2panda._UpdateTSInterfaceDeclaration(global.context, passNode(original), passNodeArray(_extends), extendsLen, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal)) } get body(): TSInterfaceBody | undefined { @@ -97,4 +98,7 @@ export class TSInterfaceDeclaration extends TypedStatement { } export function isTSInterfaceDeclaration(node: AstNode): node is TSInterfaceDeclaration { return node instanceof TSInterfaceDeclaration +} +if (!nodeByType.has(130)) { + nodeByType.set(130, TSInterfaceDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts index d7b6336931ff864ad9780a03fa31e900f4e619ca..8e59d11af0644517e11a718fa7243a3de97be655 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class TSInterfaceHeritage extends Expression { super(pointer) console.warn("Warning: stub node TSInterfaceHeritage") } - static createTSInterfaceHeritage(expr?: TypeNode): TSInterfaceHeritage | undefined { + static createTSInterfaceHeritage(expr?: TypeNode): TSInterfaceHeritage { return new TSInterfaceHeritage(global.generatedEs2panda._CreateTSInterfaceHeritage(global.context, passNode(expr))) } - static updateTSInterfaceHeritage(original?: TSInterfaceHeritage, expr?: TypeNode): TSInterfaceHeritage | undefined { + static updateTSInterfaceHeritage(original?: TSInterfaceHeritage, expr?: TypeNode): TSInterfaceHeritage { return new TSInterfaceHeritage(global.generatedEs2panda._UpdateTSInterfaceHeritage(global.context, passNode(original), passNode(expr))) } get expr(): TypeNode | undefined { @@ -49,4 +50,7 @@ export class TSInterfaceHeritage extends Expression { } export function isTSInterfaceHeritage(node: AstNode): node is TSInterfaceHeritage { return node instanceof TSInterfaceHeritage +} +if (!nodeByType.has(132)) { + nodeByType.set(132, TSInterfaceHeritage) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts index e3cc6b9592b681d3ec0b57d8dec34e3407c93f17..b4f3807184f3d634bc9d769e35726ade7425850b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -34,10 +35,10 @@ export class TSIntersectionType extends TypeNode { super(pointer) console.warn("Warning: stub node TSIntersectionType") } - static createTSIntersectionType(types: readonly Expression[], typesLen: number): TSIntersectionType | undefined { + static createTSIntersectionType(types: readonly Expression[], typesLen: number): TSIntersectionType { return new TSIntersectionType(global.generatedEs2panda._CreateTSIntersectionType(global.context, passNodeArray(types), typesLen)) } - static updateTSIntersectionType(original: TSIntersectionType | undefined, types: readonly Expression[], typesLen: number): TSIntersectionType | undefined { + static updateTSIntersectionType(original: TSIntersectionType | undefined, types: readonly Expression[], typesLen: number): TSIntersectionType { return new TSIntersectionType(global.generatedEs2panda._UpdateTSIntersectionType(global.context, passNode(original), passNodeArray(types), typesLen)) } get typesConst(): readonly Expression[] { @@ -46,4 +47,7 @@ export class TSIntersectionType extends TypeNode { } export function isTSIntersectionType(node: AstNode): node is TSIntersectionType { return node instanceof TSIntersectionType +} +if (!nodeByType.has(112)) { + nodeByType.set(112, TSIntersectionType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts index 558cbcc679883f1e6dd0d281451a1357d8d44241..514a5e1b80457b4257e0c409a3a17ec918104e55 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -34,10 +35,10 @@ export class TSLiteralType extends TypeNode { super(pointer) console.warn("Warning: stub node TSLiteralType") } - static createTSLiteralType(literal?: Expression): TSLiteralType | undefined { + static createTSLiteralType(literal?: Expression): TSLiteralType { return new TSLiteralType(global.generatedEs2panda._CreateTSLiteralType(global.context, passNode(literal))) } - static updateTSLiteralType(original?: TSLiteralType, literal?: Expression): TSLiteralType | undefined { + static updateTSLiteralType(original?: TSLiteralType, literal?: Expression): TSLiteralType { return new TSLiteralType(global.generatedEs2panda._UpdateTSLiteralType(global.context, passNode(original), passNode(literal))) } get literalConst(): Expression | undefined { @@ -46,4 +47,7 @@ export class TSLiteralType extends TypeNode { } export function isTSLiteralType(node: AstNode): node is TSLiteralType { return node instanceof TSLiteralType +} +if (!nodeByType.has(108)) { + nodeByType.set(108, TSLiteralType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts index 4bec564d2b9047767c53d5a3b6b673ee3fe02328..df7036c6870b3c79d6ea52a83e07a240a6df0337 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -35,10 +36,10 @@ export class TSMappedType extends TypeNode { super(pointer) console.warn("Warning: stub node TSMappedType") } - static createTSMappedType(typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType | undefined { + static createTSMappedType(typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType { return new TSMappedType(global.generatedEs2panda._CreateTSMappedType(global.context, passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg)) } - static updateTSMappedType(original: TSMappedType | undefined, typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType | undefined { + static updateTSMappedType(original: TSMappedType | undefined, typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType { return new TSMappedType(global.generatedEs2panda._UpdateTSMappedType(global.context, passNode(original), passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg)) } get typeParameter(): TSTypeParameter | undefined { @@ -56,4 +57,7 @@ export class TSMappedType extends TypeNode { } export function isTSMappedType(node: AstNode): node is TSMappedType { return node instanceof TSMappedType +} +if (!nodeByType.has(113)) { + nodeByType.set(113, TSMappedType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts index 96072c65e7354337dba75cc26bd1ce4f5d71c246..cb1219662d69f072afaa5d50a357f8d2588730f4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -65,4 +66,7 @@ export class TSMethodSignature extends AstNode { } export function isTSMethodSignature(node: AstNode): node is TSMethodSignature { return node instanceof TSMethodSignature +} +if (!nodeByType.has(105)) { + nodeByType.set(105, TSMethodSignature) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts b/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts index dd276c7882104af498ab3878333480054f6f0b7c..99b04712e61c2ad2496294c8c398bbac2a6e58aa 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -39,4 +40,7 @@ export class TSModuleBlock extends Statement { } export function isTSModuleBlock(node: AstNode): node is TSModuleBlock { return node instanceof TSModuleBlock +} +if (!nodeByType.has(114)) { + nodeByType.set(114, TSModuleBlock) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts index 98adfc7ccd702b7f28d80149a6d515347802b873..6dd73bc7eae44f83c77adeb446c8b3abf4df5701 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -49,4 +50,7 @@ export class TSModuleDeclaration extends Statement { } export function isTSModuleDeclaration(node: AstNode): node is TSModuleDeclaration { return node instanceof TSModuleDeclaration +} +if (!nodeByType.has(122)) { + nodeByType.set(122, TSModuleDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts index b7d1d4663b956930309bcb04ac330e37f0acb12d..d71cc25a284ec0b94f7fad0e481aefbaa6f9a7c5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -34,10 +35,10 @@ export class TSNamedTupleMember extends TypeNode { super(pointer) console.warn("Warning: stub node TSNamedTupleMember") } - static createTSNamedTupleMember(label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember | undefined { + static createTSNamedTupleMember(label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember { return new TSNamedTupleMember(global.generatedEs2panda._CreateTSNamedTupleMember(global.context, passNode(label), passNode(elementType), optional_arg)) } - static updateTSNamedTupleMember(original: TSNamedTupleMember | undefined, label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember | undefined { + static updateTSNamedTupleMember(original: TSNamedTupleMember | undefined, label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember { return new TSNamedTupleMember(global.generatedEs2panda._UpdateTSNamedTupleMember(global.context, passNode(original), passNode(label), passNode(elementType), optional_arg)) } get labelConst(): Expression | undefined { @@ -55,4 +56,7 @@ export class TSNamedTupleMember extends TypeNode { } export function isTSNamedTupleMember(node: AstNode): node is TSNamedTupleMember { return node instanceof TSNamedTupleMember +} +if (!nodeByType.has(134)) { + nodeByType.set(134, TSNamedTupleMember) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts index f5dff1d60ede44d1503aaf851edc9e6f09583d58..61a9a3eb2e7dadd4e05d3c171ea75edabc578be6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class TSNeverKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSNeverKeyword") } - static createTSNeverKeyword(): TSNeverKeyword | undefined { + static createTSNeverKeyword(): TSNeverKeyword { return new TSNeverKeyword(global.generatedEs2panda._CreateTSNeverKeyword(global.context)) } - static updateTSNeverKeyword(original?: TSNeverKeyword): TSNeverKeyword | undefined { + static updateTSNeverKeyword(original?: TSNeverKeyword): TSNeverKeyword { return new TSNeverKeyword(global.generatedEs2panda._UpdateTSNeverKeyword(global.context, passNode(original))) } } export function isTSNeverKeyword(node: AstNode): node is TSNeverKeyword { return node instanceof TSNeverKeyword +} +if (!nodeByType.has(98)) { + nodeByType.set(98, TSNeverKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts index c349ead31cfca19d8a6e60002b2660aeb6d39634..a154667c2c2edb3e632c523c33d82bff37e2bf64 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,10 +34,10 @@ export class TSNonNullExpression extends Expression { super(pointer) console.warn("Warning: stub node TSNonNullExpression") } - static createTSNonNullExpression(expr?: Expression): TSNonNullExpression | undefined { + static createTSNonNullExpression(expr?: Expression): TSNonNullExpression { return new TSNonNullExpression(global.generatedEs2panda._CreateTSNonNullExpression(global.context, passNode(expr))) } - static updateTSNonNullExpression(original?: TSNonNullExpression, expr?: Expression): TSNonNullExpression | undefined { + static updateTSNonNullExpression(original?: TSNonNullExpression, expr?: Expression): TSNonNullExpression { return new TSNonNullExpression(global.generatedEs2panda._UpdateTSNonNullExpression(global.context, passNode(original), passNode(expr))) } get exprConst(): Expression | undefined { @@ -48,4 +49,7 @@ export class TSNonNullExpression extends Expression { } export function isTSNonNullExpression(node: AstNode): node is TSNonNullExpression { return node instanceof TSNonNullExpression +} +if (!nodeByType.has(99)) { + nodeByType.set(99, TSNonNullExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts index fdb0363c9645e806920b6855fe7bd1aaccbb9c1b..a338f0527e3b6a0de8720538f07e447c959b2e35 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class TSNullKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSNullKeyword") } - static createTSNullKeyword(): TSNullKeyword | undefined { + static createTSNullKeyword(): TSNullKeyword { return new TSNullKeyword(global.generatedEs2panda._CreateTSNullKeyword(global.context)) } - static updateTSNullKeyword(original?: TSNullKeyword): TSNullKeyword | undefined { + static updateTSNullKeyword(original?: TSNullKeyword): TSNullKeyword { return new TSNullKeyword(global.generatedEs2panda._UpdateTSNullKeyword(global.context, passNode(original))) } } export function isTSNullKeyword(node: AstNode): node is TSNullKeyword { return node instanceof TSNullKeyword +} +if (!nodeByType.has(100)) { + nodeByType.set(100, TSNullKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts index 14c7a45c0a94551c2bacffd651b180f918fe0c0a..ef48ea57c0aad56b4a45dabf83ba98e8d3b931cf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class TSNumberKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSNumberKeyword") } - static createTSNumberKeyword(): TSNumberKeyword | undefined { + static createTSNumberKeyword(): TSNumberKeyword { return new TSNumberKeyword(global.generatedEs2panda._CreateTSNumberKeyword(global.context)) } - static updateTSNumberKeyword(original?: TSNumberKeyword): TSNumberKeyword | undefined { + static updateTSNumberKeyword(original?: TSNumberKeyword): TSNumberKeyword { return new TSNumberKeyword(global.generatedEs2panda._UpdateTSNumberKeyword(global.context, passNode(original))) } } export function isTSNumberKeyword(node: AstNode): node is TSNumberKeyword { return node instanceof TSNumberKeyword +} +if (!nodeByType.has(89)) { + nodeByType.set(89, TSNumberKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts index ee05fa5042745a9a9b3984441f4f28e93c42514a..f8bfb3d1e0e8407a675d04ba91e583df6dafc0ab 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class TSObjectKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSObjectKeyword") } - static createTSObjectKeyword(): TSObjectKeyword | undefined { + static createTSObjectKeyword(): TSObjectKeyword { return new TSObjectKeyword(global.generatedEs2panda._CreateTSObjectKeyword(global.context)) } - static updateTSObjectKeyword(original?: TSObjectKeyword): TSObjectKeyword | undefined { + static updateTSObjectKeyword(original?: TSObjectKeyword): TSObjectKeyword { return new TSObjectKeyword(global.generatedEs2panda._UpdateTSObjectKeyword(global.context, passNode(original))) } } export function isTSObjectKeyword(node: AstNode): node is TSObjectKeyword { return node instanceof TSObjectKeyword +} +if (!nodeByType.has(96)) { + nodeByType.set(96, TSObjectKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts index 4206b7b5c8d48ad5d75b8c218fe135b5bf4642c7..18d1991d84d678366f37f45cbafc127703d06aa4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class TSParameterProperty extends Expression { super(pointer) console.warn("Warning: stub node TSParameterProperty") } - static createTSParameterProperty(accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty | undefined { + static createTSParameterProperty(accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty { return new TSParameterProperty(global.generatedEs2panda._CreateTSParameterProperty(global.context, accessibility, passNode(parameter), readonly_arg, isStatic, isExport)) } - static updateTSParameterProperty(original: TSParameterProperty | undefined, accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty | undefined { + static updateTSParameterProperty(original: TSParameterProperty | undefined, accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty { return new TSParameterProperty(global.generatedEs2panda._UpdateTSParameterProperty(global.context, passNode(original), accessibility, passNode(parameter), readonly_arg, isStatic, isExport)) } get accessibilityConst(): Es2pandaAccessibilityOption { @@ -58,4 +59,7 @@ export class TSParameterProperty extends Expression { } export function isTSParameterProperty(node: AstNode): node is TSParameterProperty { return node instanceof TSParameterProperty +} +if (!nodeByType.has(121)) { + nodeByType.set(121, TSParameterProperty) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts index 1e091bef95d72976ee1710e7742292db2b9bc769..cdfc0257ee39bf51c837f5d38fc822771929a6aa 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -34,10 +35,10 @@ export class TSParenthesizedType extends TypeNode { super(pointer) console.warn("Warning: stub node TSParenthesizedType") } - static createTSParenthesizedType(type?: TypeNode): TSParenthesizedType | undefined { + static createTSParenthesizedType(type?: TypeNode): TSParenthesizedType { return new TSParenthesizedType(global.generatedEs2panda._CreateTSParenthesizedType(global.context, passNode(type))) } - static updateTSParenthesizedType(original?: TSParenthesizedType, type?: TypeNode): TSParenthesizedType | undefined { + static updateTSParenthesizedType(original?: TSParenthesizedType, type?: TypeNode): TSParenthesizedType { return new TSParenthesizedType(global.generatedEs2panda._UpdateTSParenthesizedType(global.context, passNode(original), passNode(type))) } get typeConst(): Expression | undefined { @@ -46,4 +47,7 @@ export class TSParenthesizedType extends TypeNode { } export function isTSParenthesizedType(node: AstNode): node is TSParenthesizedType { return node instanceof TSParenthesizedType +} +if (!nodeByType.has(107)) { + nodeByType.set(107, TSParenthesizedType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts index d14000f2a6757ae3ebc758e1b13191887f001cc8..fb9f0eead3385c8a154e35433ec2e9b664db29c8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedAstNode } from "./AnnotatedAstNode" @@ -35,10 +36,10 @@ export class TSPropertySignature extends AnnotatedAstNode { super(pointer) console.warn("Warning: stub node TSPropertySignature") } - static createTSPropertySignature(key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature | undefined { + static createTSPropertySignature(key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature { return new TSPropertySignature(global.generatedEs2panda._CreateTSPropertySignature(global.context, passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg)) } - static updateTSPropertySignature(original: TSPropertySignature | undefined, key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature | undefined { + static updateTSPropertySignature(original: TSPropertySignature | undefined, key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature { return new TSPropertySignature(global.generatedEs2panda._UpdateTSPropertySignature(global.context, passNode(original), passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg)) } get keyConst(): Expression | undefined { @@ -62,4 +63,7 @@ export class TSPropertySignature extends AnnotatedAstNode { } export function isTSPropertySignature(node: AstNode): node is TSPropertySignature { return node instanceof TSPropertySignature +} +if (!nodeByType.has(104)) { + nodeByType.set(104, TSPropertySignature) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts b/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts index d7c41cff3f5e48970828ed85feff01ed57a60edb..8a23a42752228f77fec803d88e4dc3260eb1d8c6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class TSQualifiedName extends Expression { super(pointer) console.warn("Warning: stub node TSQualifiedName") } - static createTSQualifiedName(left?: Expression, right?: Identifier): TSQualifiedName | undefined { + static createTSQualifiedName(left?: Expression, right?: Identifier): TSQualifiedName { return new TSQualifiedName(global.generatedEs2panda._CreateTSQualifiedName(global.context, passNode(left), passNode(right))) } - static updateTSQualifiedName(original?: TSQualifiedName, left?: Expression, right?: Identifier): TSQualifiedName | undefined { + static updateTSQualifiedName(original?: TSQualifiedName, left?: Expression, right?: Identifier): TSQualifiedName { return new TSQualifiedName(global.generatedEs2panda._UpdateTSQualifiedName(global.context, passNode(original), passNode(left), passNode(right))) } get leftConst(): Expression | undefined { @@ -55,4 +56,7 @@ export class TSQualifiedName extends Expression { } export function isTSQualifiedName(node: AstNode): node is TSQualifiedName { return node instanceof TSQualifiedName +} +if (!nodeByType.has(128)) { + nodeByType.set(128, TSQualifiedName) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts index 4fc3e85cbb22e28058c7b3a23d25bf09b0021d79..8f3335b4a8a1ca16df33935d561de850358b56ed 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedAstNode } from "./TypedAstNode" @@ -58,4 +59,7 @@ export class TSSignatureDeclaration extends TypedAstNode { } export function isTSSignatureDeclaration(node: AstNode): node is TSSignatureDeclaration { return node instanceof TSSignatureDeclaration +} +if (!nodeByType.has(106)) { + nodeByType.set(106, TSSignatureDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts index 6638b1b3e138e4c77759ca57065800e0cb8c97ae..e0e7a8ac2a06f1f690e55b8e68be950ab3bf5852 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class TSStringKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSStringKeyword") } - static createTSStringKeyword(): TSStringKeyword | undefined { + static createTSStringKeyword(): TSStringKeyword { return new TSStringKeyword(global.generatedEs2panda._CreateTSStringKeyword(global.context)) } - static updateTSStringKeyword(original?: TSStringKeyword): TSStringKeyword | undefined { + static updateTSStringKeyword(original?: TSStringKeyword): TSStringKeyword { return new TSStringKeyword(global.generatedEs2panda._UpdateTSStringKeyword(global.context, passNode(original))) } } export function isTSStringKeyword(node: AstNode): node is TSStringKeyword { return node instanceof TSStringKeyword +} +if (!nodeByType.has(91)) { + nodeByType.set(91, TSStringKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts index c5a813ea9236cc4ed6c0add9195c384764c934f7..f41c0b7f1858a0dcd254303c01e0c0c45140841c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class TSThisType extends TypeNode { super(pointer) console.warn("Warning: stub node TSThisType") } - static createTSThisType(): TSThisType | undefined { + static createTSThisType(): TSThisType { return new TSThisType(global.generatedEs2panda._CreateTSThisType(global.context)) } - static updateTSThisType(original?: TSThisType): TSThisType | undefined { + static updateTSThisType(original?: TSThisType): TSThisType { return new TSThisType(global.generatedEs2panda._UpdateTSThisType(global.context, passNode(original))) } } export function isTSThisType(node: AstNode): node is TSThisType { return node instanceof TSThisType +} +if (!nodeByType.has(115)) { + nodeByType.set(115, TSThisType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts index f780da7468a4eb4f92169748ba79539b991b1b56..4189b9d065ad5649b8368aeef97e17742c9160d7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,10 +34,10 @@ export class TSTupleType extends TypeNode { super(pointer) console.warn("Warning: stub node TSTupleType") } - static createTSTupleType(elementTypes: readonly TypeNode[], elementTypesLen: number): TSTupleType | undefined { + static createTSTupleType(elementTypes: readonly TypeNode[], elementTypesLen: number): TSTupleType { return new TSTupleType(global.generatedEs2panda._CreateTSTupleType(global.context, passNodeArray(elementTypes), elementTypesLen)) } - static updateTSTupleType(original: TSTupleType | undefined, elementTypes: readonly TypeNode[], elementTypesLen: number): TSTupleType | undefined { + static updateTSTupleType(original: TSTupleType | undefined, elementTypes: readonly TypeNode[], elementTypesLen: number): TSTupleType { return new TSTupleType(global.generatedEs2panda._UpdateTSTupleType(global.context, passNode(original), passNodeArray(elementTypes), elementTypesLen)) } get elementTypeConst(): readonly TypeNode[] { @@ -45,4 +46,7 @@ export class TSTupleType extends TypeNode { } export function isTSTupleType(node: AstNode): node is TSTupleType { return node instanceof TSTupleType +} +if (!nodeByType.has(133)) { + nodeByType.set(133, TSTupleType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts index cc5654dfb09a51c33103d6e7cb7baa55d9b8c3ef..e9ff06a0f59c821a79b5a94f26df5fffee12d45c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedStatement } from "./AnnotatedStatement" @@ -38,16 +39,16 @@ export class TSTypeAliasDeclaration extends AnnotatedStatement { super(pointer) console.warn("Warning: stub node TSTypeAliasDeclaration") } - static createTSTypeAliasDeclaration(id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration | undefined { + static createTSTypeAliasDeclaration(id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration { return new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration(global.context, passNode(id), passNode(typeParams), passNode(typeAnnotation))) } - static updateTSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration | undefined { + static updateTSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration { return new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration(global.context, passNode(original), passNode(id), passNode(typeParams), passNode(typeAnnotation))) } - static create1TSTypeAliasDeclaration(id?: Identifier): TSTypeAliasDeclaration | undefined { + static create1TSTypeAliasDeclaration(id?: Identifier): TSTypeAliasDeclaration { return new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration1(global.context, passNode(id))) } - static update1TSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier): TSTypeAliasDeclaration | undefined { + static update1TSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier): TSTypeAliasDeclaration { return new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration1(global.context, passNode(original), passNode(id))) } get id(): Identifier | undefined { @@ -74,4 +75,7 @@ export class TSTypeAliasDeclaration extends AnnotatedStatement { } export function isTSTypeAliasDeclaration(node: AstNode): node is TSTypeAliasDeclaration { return node instanceof TSTypeAliasDeclaration +} +if (!nodeByType.has(126)) { + nodeByType.set(126, TSTypeAliasDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts index 8d1915b7da6ffd9f24e8f21c4ba6d1b3a39362ee..ad6d47764ec668d18ab285d167b7d15e87a9f907 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedExpression } from "./AnnotatedExpression" @@ -35,10 +36,10 @@ export class TSTypeAssertion extends AnnotatedExpression { super(pointer) console.warn("Warning: stub node TSTypeAssertion") } - static createTSTypeAssertion(typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion | undefined { + static createTSTypeAssertion(typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion { return new TSTypeAssertion(global.generatedEs2panda._CreateTSTypeAssertion(global.context, passNode(typeAnnotation), passNode(expression))) } - static updateTSTypeAssertion(original?: TSTypeAssertion, typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion | undefined { + static updateTSTypeAssertion(original?: TSTypeAssertion, typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion { return new TSTypeAssertion(global.generatedEs2panda._UpdateTSTypeAssertion(global.context, passNode(original), passNode(typeAnnotation), passNode(expression))) } get getExpressionConst(): Expression | undefined { @@ -50,4 +51,7 @@ export class TSTypeAssertion extends AnnotatedExpression { } export function isTSTypeAssertion(node: AstNode): node is TSTypeAssertion { return node instanceof TSTypeAssertion +} +if (!nodeByType.has(139)) { + nodeByType.set(139, TSTypeAssertion) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts index db04fb73b9c808d3733d89592b25be7f2a369e8d..0f66760cf9d199b0446ef731a64338c185839110 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,10 +34,10 @@ export class TSTypeLiteral extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypeLiteral") } - static createTSTypeLiteral(members: readonly AstNode[], membersLen: number): TSTypeLiteral | undefined { + static createTSTypeLiteral(members: readonly AstNode[], membersLen: number): TSTypeLiteral { return new TSTypeLiteral(global.generatedEs2panda._CreateTSTypeLiteral(global.context, passNodeArray(members), membersLen)) } - static updateTSTypeLiteral(original: TSTypeLiteral | undefined, members: readonly AstNode[], membersLen: number): TSTypeLiteral | undefined { + static updateTSTypeLiteral(original: TSTypeLiteral | undefined, members: readonly AstNode[], membersLen: number): TSTypeLiteral { return new TSTypeLiteral(global.generatedEs2panda._UpdateTSTypeLiteral(global.context, passNode(original), passNodeArray(members), membersLen)) } get membersConst(): readonly AstNode[] { @@ -45,4 +46,7 @@ export class TSTypeLiteral extends TypeNode { } export function isTSTypeLiteral(node: AstNode): node is TSTypeLiteral { return node instanceof TSTypeLiteral +} +if (!nodeByType.has(103)) { + nodeByType.set(103, TSTypeLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts index 0245e44c46f90a4e72ec1a4b370e2bc29024b525..c69211c1dd9c2535f92d0c84df389c35f2b9c8b0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -34,10 +35,10 @@ export class TSTypeOperator extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypeOperator") } - static createTSTypeOperator(type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator | undefined { + static createTSTypeOperator(type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator { return new TSTypeOperator(global.generatedEs2panda._CreateTSTypeOperator(global.context, passNode(type), operatorType)) } - static updateTSTypeOperator(original: TSTypeOperator | undefined, type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator | undefined { + static updateTSTypeOperator(original: TSTypeOperator | undefined, type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator { return new TSTypeOperator(global.generatedEs2panda._UpdateTSTypeOperator(global.context, passNode(original), passNode(type), operatorType)) } get typeConst(): TypeNode | undefined { @@ -55,4 +56,7 @@ export class TSTypeOperator extends TypeNode { } export function isTSTypeOperator(node: AstNode): node is TSTypeOperator { return node instanceof TSTypeOperator +} +if (!nodeByType.has(116)) { + nodeByType.set(116, TSTypeOperator) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts index df61b3d5e8ad15e5b4450e01c89387cd0099cd32..69d217e48b42378a3be0eea5304e43ac06600b9f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -37,16 +38,16 @@ export class TSTypeParameter extends Expression { super(pointer) console.warn("Warning: stub node TSTypeParameter") } - static createTSTypeParameter(name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter | undefined { + static createTSTypeParameter(name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter { return new TSTypeParameter(global.generatedEs2panda._CreateTSTypeParameter(global.context, passNode(name), passNode(constraint), passNode(defaultType))) } - static updateTSTypeParameter(original?: TSTypeParameter, name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter | undefined { + static updateTSTypeParameter(original?: TSTypeParameter, name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter { return new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType))) } - static create1TSTypeParameter(name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter | undefined { + static create1TSTypeParameter(name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter { return new TSTypeParameter(global.generatedEs2panda._CreateTSTypeParameter1(global.context, passNode(name), passNode(constraint), passNode(defaultType), flags)) } - static update1TSTypeParameter(original: TSTypeParameter | undefined, name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter | undefined { + static update1TSTypeParameter(original: TSTypeParameter | undefined, name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter { return new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter1(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType), flags)) } get nameConst(): Identifier | undefined { @@ -73,4 +74,7 @@ export class TSTypeParameter extends Expression { } export function isTSTypeParameter(node: AstNode): node is TSTypeParameter { return node instanceof TSTypeParameter +} +if (!nodeByType.has(117)) { + nodeByType.set(117, TSTypeParameter) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts index 649b62924c5d05772dc1a040d41945331de99e89..2be0b6bff6935ccd67f2e66f01ea56ae583b35d0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class TSTypeParameterDeclaration extends Expression { super(pointer) console.warn("Warning: stub node TSTypeParameterDeclaration") } - static createTSTypeParameterDeclaration(params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration | undefined { + static createTSTypeParameterDeclaration(params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration { return new TSTypeParameterDeclaration(global.generatedEs2panda._CreateTSTypeParameterDeclaration(global.context, passNodeArray(params), paramsLen, requiredParams)) } - static updateTSTypeParameterDeclaration(original: TSTypeParameterDeclaration | undefined, params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration | undefined { + static updateTSTypeParameterDeclaration(original: TSTypeParameterDeclaration | undefined, params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration { return new TSTypeParameterDeclaration(global.generatedEs2panda._UpdateTSTypeParameterDeclaration(global.context, passNode(original), passNodeArray(params), paramsLen, requiredParams)) } get paramsConst(): readonly TSTypeParameter[] { @@ -49,4 +50,7 @@ export class TSTypeParameterDeclaration extends Expression { } export function isTSTypeParameterDeclaration(node: AstNode): node is TSTypeParameterDeclaration { return node instanceof TSTypeParameterDeclaration +} +if (!nodeByType.has(118)) { + nodeByType.set(118, TSTypeParameterDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts index bb571ed29720f5b0c135c4902168a2a98ded3df8..faeb4299a55401a0986de59c3cf9a3a173235430 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class TSTypeParameterInstantiation extends Expression { super(pointer) console.warn("Warning: stub node TSTypeParameterInstantiation") } - static createTSTypeParameterInstantiation(params: readonly TypeNode[], paramsLen: number): TSTypeParameterInstantiation | undefined { + static createTSTypeParameterInstantiation(params: readonly TypeNode[], paramsLen: number): TSTypeParameterInstantiation { return new TSTypeParameterInstantiation(global.generatedEs2panda._CreateTSTypeParameterInstantiation(global.context, passNodeArray(params), paramsLen)) } - static updateTSTypeParameterInstantiation(original: TSTypeParameterInstantiation | undefined, params: readonly TypeNode[], paramsLen: number): TSTypeParameterInstantiation | undefined { + static updateTSTypeParameterInstantiation(original: TSTypeParameterInstantiation | undefined, params: readonly TypeNode[], paramsLen: number): TSTypeParameterInstantiation { return new TSTypeParameterInstantiation(global.generatedEs2panda._UpdateTSTypeParameterInstantiation(global.context, passNode(original), passNodeArray(params), paramsLen)) } get paramsConst(): readonly TypeNode[] { @@ -46,4 +47,7 @@ export class TSTypeParameterInstantiation extends Expression { } export function isTSTypeParameterInstantiation(node: AstNode): node is TSTypeParameterInstantiation { return node instanceof TSTypeParameterInstantiation +} +if (!nodeByType.has(119)) { + nodeByType.set(119, TSTypeParameterInstantiation) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts index 0af99af2944d529263fe32117215596c544b324f..5c605d7958b4d1203ed9ff2c6900aedfb1f5d837 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -34,10 +35,10 @@ export class TSTypePredicate extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypePredicate") } - static createTSTypePredicate(parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate | undefined { + static createTSTypePredicate(parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate { return new TSTypePredicate(global.generatedEs2panda._CreateTSTypePredicate(global.context, passNode(parameterName), passNode(typeAnnotation), asserts)) } - static updateTSTypePredicate(original: TSTypePredicate | undefined, parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate | undefined { + static updateTSTypePredicate(original: TSTypePredicate | undefined, parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate { return new TSTypePredicate(global.generatedEs2panda._UpdateTSTypePredicate(global.context, passNode(original), passNode(parameterName), passNode(typeAnnotation), asserts)) } get parameterNameConst(): Expression | undefined { @@ -52,4 +53,7 @@ export class TSTypePredicate extends TypeNode { } export function isTSTypePredicate(node: AstNode): node is TSTypePredicate { return node instanceof TSTypePredicate +} +if (!nodeByType.has(120)) { + nodeByType.set(120, TSTypePredicate) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts index e4be5cc263f1d7923329e4372ff61a1b37ff5dcb..8cc40264c5ab755be8a7570109a40d7273232aed 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -34,10 +35,10 @@ export class TSTypeQuery extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypeQuery") } - static createTSTypeQuery(exprName?: Expression): TSTypeQuery | undefined { + static createTSTypeQuery(exprName?: Expression): TSTypeQuery { return new TSTypeQuery(global.generatedEs2panda._CreateTSTypeQuery(global.context, passNode(exprName))) } - static updateTSTypeQuery(original?: TSTypeQuery, exprName?: Expression): TSTypeQuery | undefined { + static updateTSTypeQuery(original?: TSTypeQuery, exprName?: Expression): TSTypeQuery { return new TSTypeQuery(global.generatedEs2panda._UpdateTSTypeQuery(global.context, passNode(original), passNode(exprName))) } get exprNameConst(): Expression | undefined { @@ -46,4 +47,7 @@ export class TSTypeQuery extends TypeNode { } export function isTSTypeQuery(node: AstNode): node is TSTypeQuery { return node instanceof TSTypeQuery +} +if (!nodeByType.has(136)) { + nodeByType.set(136, TSTypeQuery) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts index 286229070c5df3eb64bccc31626b5d97b60381ab..53215db151a078afbd1f284700ce2b11051d62f8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -35,10 +36,10 @@ export class TSTypeReference extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypeReference") } - static createTSTypeReference(typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference | undefined { + static createTSTypeReference(typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference { return new TSTypeReference(global.generatedEs2panda._CreateTSTypeReference(global.context, passNode(typeName), passNode(typeParams))) } - static updateTSTypeReference(original?: TSTypeReference, typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference | undefined { + static updateTSTypeReference(original?: TSTypeReference, typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference { return new TSTypeReference(global.generatedEs2panda._UpdateTSTypeReference(global.context, passNode(original), passNode(typeName), passNode(typeParams))) } get typeParamsConst(): TSTypeParameterInstantiation | undefined { @@ -50,4 +51,7 @@ export class TSTypeReference extends TypeNode { } export function isTSTypeReference(node: AstNode): node is TSTypeReference { return node instanceof TSTypeReference +} +if (!nodeByType.has(127)) { + nodeByType.set(127, TSTypeReference) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts index 617f53697ca99a8be4c4647b335f1408fe85c2fc..895f5f82cb88d6851e3b427fdc6450c12f19845d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class TSUndefinedKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSUndefinedKeyword") } - static createTSUndefinedKeyword(): TSUndefinedKeyword | undefined { + static createTSUndefinedKeyword(): TSUndefinedKeyword { return new TSUndefinedKeyword(global.generatedEs2panda._CreateTSUndefinedKeyword(global.context)) } - static updateTSUndefinedKeyword(original?: TSUndefinedKeyword): TSUndefinedKeyword | undefined { + static updateTSUndefinedKeyword(original?: TSUndefinedKeyword): TSUndefinedKeyword { return new TSUndefinedKeyword(global.generatedEs2panda._UpdateTSUndefinedKeyword(global.context, passNode(original))) } } export function isTSUndefinedKeyword(node: AstNode): node is TSUndefinedKeyword { return node instanceof TSUndefinedKeyword +} +if (!nodeByType.has(94)) { + nodeByType.set(94, TSUndefinedKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts index 7602a8fbe5e12a12afd89e9a455e0a269c16f329..9b696f94c69c447829882dc86788c4e458a26833 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,10 +34,10 @@ export class TSUnionType extends TypeNode { super(pointer) console.warn("Warning: stub node TSUnionType") } - static createTSUnionType(types: readonly TypeNode[], typesLen: number): TSUnionType | undefined { + static createTSUnionType(types: readonly TypeNode[], typesLen: number): TSUnionType { return new TSUnionType(global.generatedEs2panda._CreateTSUnionType(global.context, passNodeArray(types), typesLen)) } - static updateTSUnionType(original: TSUnionType | undefined, types: readonly TypeNode[], typesLen: number): TSUnionType | undefined { + static updateTSUnionType(original: TSUnionType | undefined, types: readonly TypeNode[], typesLen: number): TSUnionType { return new TSUnionType(global.generatedEs2panda._UpdateTSUnionType(global.context, passNode(original), passNodeArray(types), typesLen)) } get typesConst(): readonly TypeNode[] { @@ -45,4 +46,7 @@ export class TSUnionType extends TypeNode { } export function isTSUnionType(node: AstNode): node is TSUnionType { return node instanceof TSUnionType +} +if (!nodeByType.has(102)) { + nodeByType.set(102, TSUnionType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts index 0b40302310dcde6831fcab124cd88536fd3002ca..b7d88e15bf64ad68b32da199c9b1e12678af534a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class TSUnknownKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSUnknownKeyword") } - static createTSUnknownKeyword(): TSUnknownKeyword | undefined { + static createTSUnknownKeyword(): TSUnknownKeyword { return new TSUnknownKeyword(global.generatedEs2panda._CreateTSUnknownKeyword(global.context)) } - static updateTSUnknownKeyword(original?: TSUnknownKeyword): TSUnknownKeyword | undefined { + static updateTSUnknownKeyword(original?: TSUnknownKeyword): TSUnknownKeyword { return new TSUnknownKeyword(global.generatedEs2panda._UpdateTSUnknownKeyword(global.context, passNode(original))) } } export function isTSUnknownKeyword(node: AstNode): node is TSUnknownKeyword { return node instanceof TSUnknownKeyword +} +if (!nodeByType.has(95)) { + nodeByType.set(95, TSUnknownKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts index 392412c70c3db158451b3b8a11df07415a84b60e..8197ebb738d06930e3f28430cde3574750e6914f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -33,13 +34,16 @@ export class TSVoidKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSVoidKeyword") } - static createTSVoidKeyword(): TSVoidKeyword | undefined { + static createTSVoidKeyword(): TSVoidKeyword { return new TSVoidKeyword(global.generatedEs2panda._CreateTSVoidKeyword(global.context)) } - static updateTSVoidKeyword(original?: TSVoidKeyword): TSVoidKeyword | undefined { + static updateTSVoidKeyword(original?: TSVoidKeyword): TSVoidKeyword { return new TSVoidKeyword(global.generatedEs2panda._UpdateTSVoidKeyword(global.context, passNode(original))) } } export function isTSVoidKeyword(node: AstNode): node is TSVoidKeyword { return node instanceof TSVoidKeyword +} +if (!nodeByType.has(93)) { + nodeByType.set(93, TSVoidKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts index 991244956d89e5290ee5d94b92eab6346dabbf07..00cd6f6dc00108f4703423230721a36dd50b1848 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -35,10 +36,10 @@ export class TaggedTemplateExpression extends Expression { super(pointer) console.warn("Warning: stub node TaggedTemplateExpression") } - static createTaggedTemplateExpression(tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression | undefined { + static createTaggedTemplateExpression(tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression { return new TaggedTemplateExpression(global.generatedEs2panda._CreateTaggedTemplateExpression(global.context, passNode(tag), passNode(quasi), passNode(typeParams))) } - static updateTaggedTemplateExpression(original?: TaggedTemplateExpression, tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression | undefined { + static updateTaggedTemplateExpression(original?: TaggedTemplateExpression, tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression { return new TaggedTemplateExpression(global.generatedEs2panda._UpdateTaggedTemplateExpression(global.context, passNode(original), passNode(tag), passNode(quasi), passNode(typeParams))) } get tagConst(): Expression | undefined { @@ -53,4 +54,7 @@ export class TaggedTemplateExpression extends Expression { } export function isTaggedTemplateExpression(node: AstNode): node is TaggedTemplateExpression { return node instanceof TaggedTemplateExpression +} +if (!nodeByType.has(140)) { + nodeByType.set(140, TaggedTemplateExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts b/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts index 0d505f70fcb80f359966176ec62daeed459a9f05..cb05a99e0530e116136d8b4045c123d2a7bf7bf3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,16 +34,16 @@ export class TemplateElement extends Expression { super(pointer) console.warn("Warning: stub node TemplateElement") } - static createTemplateElement(): TemplateElement | undefined { + static createTemplateElement(): TemplateElement { return new TemplateElement(global.generatedEs2panda._CreateTemplateElement(global.context)) } - static updateTemplateElement(original?: TemplateElement): TemplateElement | undefined { + static updateTemplateElement(original?: TemplateElement): TemplateElement { return new TemplateElement(global.generatedEs2panda._UpdateTemplateElement(global.context, passNode(original))) } - static create1TemplateElement(raw: string, cooked: string): TemplateElement | undefined { + static create1TemplateElement(raw: string, cooked: string): TemplateElement { return new TemplateElement(global.generatedEs2panda._CreateTemplateElement1(global.context, raw, cooked)) } - static update1TemplateElement(original: TemplateElement | undefined, raw: string, cooked: string): TemplateElement | undefined { + static update1TemplateElement(original: TemplateElement | undefined, raw: string, cooked: string): TemplateElement { return new TemplateElement(global.generatedEs2panda._UpdateTemplateElement1(global.context, passNode(original), raw, cooked)) } get rawConst(): string { @@ -54,4 +55,7 @@ export class TemplateElement extends Expression { } export function isTemplateElement(node: AstNode): node is TemplateElement { return node instanceof TemplateElement +} +if (!nodeByType.has(141)) { + nodeByType.set(141, TemplateElement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts index 952583ba0e116e6a6fc370c23445883cf91177e1..227569f5d8a456b62b277c186d645985979d864c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class TemplateLiteral extends Expression { super(pointer) console.warn("Warning: stub node TemplateLiteral") } - static createTemplateLiteral(quasis: readonly TemplateElement[], quasisLen: number, expressions: readonly Expression[], expressionsLen: number, multilineString: string): TemplateLiteral | undefined { + static createTemplateLiteral(quasis: readonly TemplateElement[], quasisLen: number, expressions: readonly Expression[], expressionsLen: number, multilineString: string): TemplateLiteral { return new TemplateLiteral(global.generatedEs2panda._CreateTemplateLiteral(global.context, passNodeArray(quasis), quasisLen, passNodeArray(expressions), expressionsLen, multilineString)) } - static updateTemplateLiteral(original: TemplateLiteral | undefined, quasis: readonly TemplateElement[], quasisLen: number, expressions: readonly Expression[], expressionsLen: number, multilineString: string): TemplateLiteral | undefined { + static updateTemplateLiteral(original: TemplateLiteral | undefined, quasis: readonly TemplateElement[], quasisLen: number, expressions: readonly Expression[], expressionsLen: number, multilineString: string): TemplateLiteral { return new TemplateLiteral(global.generatedEs2panda._UpdateTemplateLiteral(global.context, passNode(original), passNodeArray(quasis), quasisLen, passNodeArray(expressions), expressionsLen, multilineString)) } get quasisConst(): readonly TemplateElement[] { @@ -49,4 +50,7 @@ export class TemplateLiteral extends Expression { } export function isTemplateLiteral(node: AstNode): node is TemplateLiteral { return node instanceof TemplateLiteral +} +if (!nodeByType.has(142)) { + nodeByType.set(142, TemplateLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts index 28563e464c5e7132b2308c1a74d5717d4097815d..d622b5e563b0db9137bc9d54f9f66a096ef61af1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,13 +34,16 @@ export class ThisExpression extends Expression { super(pointer) console.warn("Warning: stub node ThisExpression") } - static createThisExpression(): ThisExpression | undefined { + static createThisExpression(): ThisExpression { return new ThisExpression(global.generatedEs2panda._CreateThisExpression(global.context)) } - static updateThisExpression(original?: ThisExpression): ThisExpression | undefined { + static updateThisExpression(original?: ThisExpression): ThisExpression { return new ThisExpression(global.generatedEs2panda._UpdateThisExpression(global.context, passNode(original))) } } export function isThisExpression(node: AstNode): node is ThisExpression { return node instanceof ThisExpression +} +if (!nodeByType.has(143)) { + nodeByType.set(143, ThisExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts index c2468f34cca341347f643a794368df7f3a57dc17..46ece221f35ab2545329e433b8708d59bcf5b85b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -34,10 +35,10 @@ export class ThrowStatement extends Statement { super(pointer) console.warn("Warning: stub node ThrowStatement") } - static createThrowStatement(argument?: Expression): ThrowStatement | undefined { + static createThrowStatement(argument?: Expression): ThrowStatement { return new ThrowStatement(global.generatedEs2panda._CreateThrowStatement(global.context, passNode(argument))) } - static updateThrowStatement(original?: ThrowStatement, argument?: Expression): ThrowStatement | undefined { + static updateThrowStatement(original?: ThrowStatement, argument?: Expression): ThrowStatement { return new ThrowStatement(global.generatedEs2panda._UpdateThrowStatement(global.context, passNode(original), passNode(argument))) } get argumentConst(): Expression | undefined { @@ -46,4 +47,7 @@ export class ThrowStatement extends Statement { } export function isThrowStatement(node: AstNode): node is ThrowStatement { return node instanceof ThrowStatement +} +if (!nodeByType.has(145)) { + nodeByType.set(145, ThrowStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts index cbf22f6dcdbc309a3ce5593ec5c1fba8ed1e3495..b790a1d19b0a0b52849fe4d37fd8d974ba5598e7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -53,4 +54,7 @@ export class TryStatement extends Statement { } export function isTryStatement(node: AstNode): node is TryStatement { return node instanceof TryStatement +} +if (!nodeByType.has(146)) { + nodeByType.set(146, TryStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts b/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts index bd893051b98cca5c6d75beeec8bc4203fa57fa58..789c66b72903815f43da6eb4652b8c9b608a5725 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts b/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts index a93cec213fe1604f1f409278c35a8a31224757a7..2e92127278cf729e2499d635eeb284ef3689886a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" export abstract class TypedAstNode extends AstNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts index f277f2845bdf4aba3b8e69195a95ec2a5908248b..d3efbbbab31217e93016867319f45539bc697a05 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts index e12144926f4858e208b86449be1766fa08fac4bb..541ef9675e7f589f6bb3dcf4af4b1818c2be71ff 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,10 +34,10 @@ export class TypeofExpression extends Expression { super(pointer) console.warn("Warning: stub node TypeofExpression") } - static createTypeofExpression(argument?: Expression): TypeofExpression | undefined { + static createTypeofExpression(argument?: Expression): TypeofExpression { return new TypeofExpression(global.generatedEs2panda._CreateTypeofExpression(global.context, passNode(argument))) } - static updateTypeofExpression(original?: TypeofExpression, argument?: Expression): TypeofExpression | undefined { + static updateTypeofExpression(original?: TypeofExpression, argument?: Expression): TypeofExpression { return new TypeofExpression(global.generatedEs2panda._UpdateTypeofExpression(global.context, passNode(original), passNode(argument))) } get argumentConst(): Expression | undefined { @@ -45,4 +46,7 @@ export class TypeofExpression extends Expression { } export function isTypeofExpression(node: AstNode): node is TypeofExpression { return node instanceof TypeofExpression +} +if (!nodeByType.has(144)) { + nodeByType.set(144, TypeofExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts index 3664948fc90478ef3e4f80433eb72e4f6034b2cb..d0ab980f35f5807be78045bc73c7f93efa93eef3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class UnaryExpression extends Expression { super(pointer) console.warn("Warning: stub node UnaryExpression") } - static createUnaryExpression(argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression | undefined { + static createUnaryExpression(argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression { return new UnaryExpression(global.generatedEs2panda._CreateUnaryExpression(global.context, passNode(argument), unaryOperator)) } - static updateUnaryExpression(original: UnaryExpression | undefined, argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression | undefined { + static updateUnaryExpression(original: UnaryExpression | undefined, argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression { return new UnaryExpression(global.generatedEs2panda._UpdateUnaryExpression(global.context, passNode(original), passNode(argument), unaryOperator)) } get operatorTypeConst(): Es2pandaTokenType { @@ -52,4 +53,7 @@ export class UnaryExpression extends Expression { } export function isUnaryExpression(node: AstNode): node is UnaryExpression { return node instanceof UnaryExpression +} +if (!nodeByType.has(147)) { + nodeByType.set(147, UnaryExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts index ff60f1550fcdd7ec73115183d339d63085d3b58c..7928c351141eb4752e55fd694acf212aa0d1c2e0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -33,13 +34,16 @@ export class UndefinedLiteral extends Literal { super(pointer) console.warn("Warning: stub node UndefinedLiteral") } - static createUndefinedLiteral(): UndefinedLiteral | undefined { + static createUndefinedLiteral(): UndefinedLiteral { return new UndefinedLiteral(global.generatedEs2panda._CreateUndefinedLiteral(global.context)) } - static updateUndefinedLiteral(original?: UndefinedLiteral): UndefinedLiteral | undefined { + static updateUndefinedLiteral(original?: UndefinedLiteral): UndefinedLiteral { return new UndefinedLiteral(global.generatedEs2panda._UpdateUndefinedLiteral(global.context, passNode(original))) } } export function isUndefinedLiteral(node: AstNode): node is UndefinedLiteral { return node instanceof UndefinedLiteral +} +if (!nodeByType.has(51)) { + nodeByType.set(51, UndefinedLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts index e0f3f13748e47d689559d8d3662b11f161e95212..14ad0b275ae96a7310c104f041d32d9fd0998145 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -34,10 +35,10 @@ export class UpdateExpression extends Expression { super(pointer) console.warn("Warning: stub node UpdateExpression") } - static createUpdateExpression(argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression | undefined { + static createUpdateExpression(argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression { return new UpdateExpression(global.generatedEs2panda._CreateUpdateExpression(global.context, passNode(argument), updateOperator, isPrefix)) } - static updateUpdateExpression(original: UpdateExpression | undefined, argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression | undefined { + static updateUpdateExpression(original: UpdateExpression | undefined, argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression { return new UpdateExpression(global.generatedEs2panda._UpdateUpdateExpression(global.context, passNode(original), passNode(argument), updateOperator, isPrefix)) } get operatorTypeConst(): Es2pandaTokenType { @@ -55,4 +56,7 @@ export class UpdateExpression extends Expression { } export function isUpdateExpression(node: AstNode): node is UpdateExpression { return node instanceof UpdateExpression +} +if (!nodeByType.has(148)) { + nodeByType.set(148, UpdateExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts index b145115d863d89ef003b39950280af92739251db..2d562e5fee0692cf7e6cc57a9259cd2dd77d9a84 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -37,10 +38,10 @@ export class VariableDeclaration extends Statement { super(pointer) console.warn("Warning: stub node VariableDeclaration") } - static createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration | undefined { + static createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration { return new VariableDeclaration(global.generatedEs2panda._CreateVariableDeclaration(global.context, kind, passNodeArray(declarators), declaratorsLen)) } - static updateVariableDeclaration(original: VariableDeclaration | undefined, kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration | undefined { + static updateVariableDeclaration(original: VariableDeclaration | undefined, kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration { return new VariableDeclaration(global.generatedEs2panda._UpdateVariableDeclaration(global.context, passNode(original), kind, passNodeArray(declarators), declaratorsLen)) } get declaratorsConst(): readonly VariableDeclarator[] { @@ -61,4 +62,7 @@ export class VariableDeclaration extends Statement { } export function isVariableDeclaration(node: AstNode): node is VariableDeclaration { return node instanceof VariableDeclaration +} +if (!nodeByType.has(149)) { + nodeByType.set(149, VariableDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts index 9d46bd03519f4604b57bd87d112f5d44d76f6d30..bebada215f0c778e99ca1d0b1b2f5240eeed8ee8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedStatement } from "./TypedStatement" @@ -35,16 +36,16 @@ export class VariableDeclarator extends TypedStatement { super(pointer) console.warn("Warning: stub node VariableDeclarator") } - static createVariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator | undefined { + static createVariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator { return new VariableDeclarator(global.generatedEs2panda._CreateVariableDeclarator(global.context, flag, passNode(ident))) } - static updateVariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator | undefined { + static updateVariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator { return new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator(global.context, passNode(original), flag, passNode(ident))) } - static create1VariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator | undefined { + static create1VariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator { return new VariableDeclarator(global.generatedEs2panda._CreateVariableDeclarator1(global.context, flag, passNode(ident), passNode(init))) } - static update1VariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator | undefined { + static update1VariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator { return new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator1(global.context, passNode(original), flag, passNode(ident), passNode(init))) } get init(): Expression | undefined { @@ -65,4 +66,7 @@ export class VariableDeclarator extends TypedStatement { } export function isVariableDeclarator(node: AstNode): node is VariableDeclarator { return node instanceof VariableDeclarator +} +if (!nodeByType.has(150)) { + nodeByType.set(150, VariableDeclarator) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts index b5ca5e0be18b2b9d8f1906174c74a98aa36effd8..d2b24f274c41715f35df585a11f913fecd778dfa 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { LoopStatement } from "./LoopStatement" @@ -50,4 +51,7 @@ export class WhileStatement extends LoopStatement { } export function isWhileStatement(node: AstNode): node is WhileStatement { return node instanceof WhileStatement +} +if (!nodeByType.has(151)) { + nodeByType.set(151, WhileStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts index 6a1279f7bb1de2a72de8335b8eb580c8cd2f20bd..5de301724dd4e60c6fff7a170a33ab3a78b40fd2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -33,10 +34,10 @@ export class YieldExpression extends Expression { super(pointer) console.warn("Warning: stub node YieldExpression") } - static createYieldExpression(argument: Expression | undefined, isDelegate: boolean): YieldExpression | undefined { + static createYieldExpression(argument: Expression | undefined, isDelegate: boolean): YieldExpression { return new YieldExpression(global.generatedEs2panda._CreateYieldExpression(global.context, passNode(argument), isDelegate)) } - static updateYieldExpression(original: YieldExpression | undefined, argument: Expression | undefined, isDelegate: boolean): YieldExpression | undefined { + static updateYieldExpression(original: YieldExpression | undefined, argument: Expression | undefined, isDelegate: boolean): YieldExpression { return new YieldExpression(global.generatedEs2panda._UpdateYieldExpression(global.context, passNode(original), passNode(argument), isDelegate)) } get hasDelegateConst(): boolean { @@ -48,4 +49,7 @@ export class YieldExpression extends Expression { } export function isYieldExpression(node: AstNode): node is YieldExpression { return node instanceof YieldExpression +} +if (!nodeByType.has(152)) { + nodeByType.set(152, YieldExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/reexport-for-generated.ts b/arkoala-arkts/libarkts/src/reexport-for-generated.ts index 4fc36e32752e85638e525de64939901c6d1d32c2..648817510dd0407dd42b4f5a1ee0b343099449ef 100644 --- a/arkoala-arkts/libarkts/src/reexport-for-generated.ts +++ b/arkoala-arkts/libarkts/src/reexport-for-generated.ts @@ -12,10 +12,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - export { KNativePointer } from "@koalaui/interop" +export { AstNode } from "./arkts-api/peers/AstNode" export { Es2pandaAstNodeType } from "./Es2pandaEnums" -export { assertValidPeer } from "./arkts-api//types" export { passNode, unpackNonNullableNode, @@ -24,8 +23,9 @@ export { unpackNode, unpackNonNullableObject, unpackString, - unpackObject + unpackObject, + assertValidPeer } from "./arkts-api/utilities/private" +export { nodeByType } from "./arkts-api/class-by-peer" export { global } from "./arkts-api/static/global" export { Es2pandaMemberExpressionKind } from "./generated/Es2pandaEnums" -export { AstNode } from "./arkts-api/peers/AstNode" diff --git a/arkoala-arkts/libarkts/src/utils.ts b/arkoala-arkts/libarkts/src/utils.ts index c30d3b0f576dea3fcd3e30617d4262ed5de25672..15cc29473c8c52b4d363c511949366d52fbfb2c9 100644 --- a/arkoala-arkts/libarkts/src/utils.ts +++ b/arkoala-arkts/libarkts/src/utils.ts @@ -26,10 +26,11 @@ export function isNumber(value: any): value is number { return typeof value === `number` } -// TODO: the lowerings insert %% and other special symbols -// into names of temporary variables. -// Until we keep feeding ast dumps back to the parser -// this function is needed. +/* + TODO: + The lowerings insert %% and other special symbols into names of temporary variables. + Until we keep feeding ast dumps back to the parser this function is needed. + */ export function filterSource(text: string): string { return text .replaceAll(/%/g, "_") diff --git a/arkoala-arkts/libarkts/test/arkts-api/general/annotations.test.ts b/arkoala-arkts/libarkts/test/arkts-api/general/annotations.test.ts index 1f1335b877c023d7004ccf25fec13f8a6b06e193..b4d4b3611cc27152ba34872078e7dca4465cd1b3 100644 --- a/arkoala-arkts/libarkts/test/arkts-api/general/annotations.test.ts +++ b/arkoala-arkts/libarkts/test/arkts-api/general/annotations.test.ts @@ -19,6 +19,9 @@ suite(util.basename(__filename), () => { const annotations = arkts.getAnnotations(script.statements[0]) const names = annotations.map((annot) => { + if (annot.expr === undefined) { + throw new Error('annotation expression is undefined') + } if (!arkts.isIdentifier(annot.expr)) { throw new Error('annotation expected to be Identifier') } diff --git a/arkoala-arkts/libarkts/test/test-util.ts b/arkoala-arkts/libarkts/test/test-util.ts index 3d85b1ea1faf5f8514ef64a04c61778fa15c053a..c065bbe359e32dcf0966772266cca8241b16d828 100644 --- a/arkoala-arkts/libarkts/test/test-util.ts +++ b/arkoala-arkts/libarkts/test/test-util.ts @@ -14,7 +14,6 @@ */ import { global } from "../src/arkts-api/static/global" -import * as ts from "../src/ts-api" import * as arkts from "../src/arkts-api" import * as pth from "path" @@ -24,13 +23,6 @@ import { exec, execSync } from "child_process" export { Es2pandaNativeModule } from "../src/Es2pandaNativeModule" export { assert } from "chai" -class defaultTransformationContext implements ts.TransformationContext { -} - -export function getDefaultTransformationContext(): ts.TransformationContext { - return new defaultTransformationContext() -} - export function alignText(text: string): string { const lines = text.replace(/\t/gy, ' ').split('\n') @@ -63,19 +55,15 @@ export function assertEqualsSource(sourceResult: string, sourceExpect: string, m ) } -export function TS_TEST_ASSERTION(node: ts.SourceFile, source: string, state?: ts.ContextState) { - ARKTS_TEST_ASSERTION(node.node, source, state) -} - -export function ARKTS_TEST_ASSERTION(node: arkts.EtsScript, source: string, state?: ts.ContextState) { - const finalState: ts.ContextState = (() => { +export function ARKTS_TEST_ASSERTION(node: arkts.EtsScript, source: string, state?: arkts.Es2pandaContextState) { + const finalState: arkts.Es2pandaContextState = (() => { if (state !== undefined) { return state } if (process.env.STATE_CHECKED !== undefined) { - return ts.ContextState.ES2PANDA_STATE_CHECKED + return arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED } - return ts.ContextState.ES2PANDA_STATE_PARSED + return arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED })() arkts.proceedToState(finalState) @@ -94,40 +82,7 @@ export function ARKTS_TEST_ASSERTION(node: arkts.EtsScript, source: string, stat } } -export function addMemoParamsToFunctionDeclaration(func: ts.FunctionDeclaration): ts.FunctionDeclaration { - return ts.factory.updateFunctionDeclaration( - func, - undefined, - undefined, - func.name, - undefined, - [ - ts.factory.createParameterDeclaration( - undefined, - undefined, - ts.factory.createIdentifier("__memo_context"), - undefined, - ts.factory.createTypeReferenceNode( - ts.factory.createIdentifier("__memo_context_type") - ), - undefined - ), - ts.factory.createParameterDeclaration( - undefined, - undefined, - ts.factory.createIdentifier("__memo_id"), - undefined, - ts.factory.createTypeReferenceNode( - ts.factory.createIdentifier("__memo_id_type") - ), - undefined - ), - ...func.parameters - ], - undefined, - func.body - ) -} + export function cleanGenerated(): void { exec('npm run clean:generated') @@ -142,7 +97,7 @@ export function fileToAbc(path: string, isModule?: boolean): void { } export function contextToAbc(): void { - arkts.proceedToState(ts.ContextState.ES2PANDA_STATE_BIN_GENERATED) + arkts.proceedToState(arkts.Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) // TODO: get name of file execSync('mkdir -p ./generated') execSync('mv ./main.abc ./generated/main.abc') diff --git a/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/create-function-declaration.test.ts b/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/create-function-declaration.test.ts index 0071bb839224de786ca0cde793917fe4a77e6709..120ce494953514b8087fe857fd5535c60d1c5a67 100644 --- a/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/create-function-declaration.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/create-function-declaration.test.ts @@ -2,7 +2,7 @@ import * as util from "../../../test-util" import * as ts from "../../../../src/ts-api" import { factory } from "../../../../src/ts-api" -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { test("empty-function", function() { // function test_func() { // // empty diff --git a/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/update-function-declaration.test.ts b/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/update-function-declaration.test.ts index 2c2229a8a523b1dced177302b6ae3e72d48d196c..ca2966d4d754e498809a46cee57c993e686d101f 100644 --- a/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/update-function-declaration.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/update-function-declaration.test.ts @@ -1,7 +1,7 @@ import * as util from "../../../test-util" import * as ts from "../../../../src/ts-api" -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { // adding y: string to signature test("update-name-and-add-param-to-function", function() { // function new_test_func(x: number, y: string) { diff --git a/arkoala-arkts/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts b/arkoala-arkts/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts index 470141df7df77c649c7507189347b5a9e301c5ce..bfad65152a4601c5d0eed778a716b4691690e054 100644 --- a/arkoala-arkts/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts @@ -1,7 +1,7 @@ import * as util from "../../../test-util" import * as ts from "../../../../src/ts-api" -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { // full memo rewrite test("memo-function-with-lambda-memo-param", function() { // function foo( diff --git a/arkoala-arkts/libarkts/test/ts-api/general/abc-gen.test.ts b/arkoala-arkts/libarkts/test/ts-api/general/abc-gen.test.ts index 05106f2a2de5e1a84d70c2b38d909d3bdb2cdd2b..00c60f8de599a7b51dd2eda5a537f1d9e442c0bb 100644 --- a/arkoala-arkts/libarkts/test/ts-api/general/abc-gen.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/general/abc-gen.test.ts @@ -2,7 +2,7 @@ import * as util from "../../test-util" import * as ts from "../../../src/ts-api" // tests for abc generation (now failing on CI) -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { test("updating-expression-statement", function() { const sample_in = ` diff --git a/arkoala-arkts/libarkts/test/ts-api/general/basic.test.ts b/arkoala-arkts/libarkts/test/ts-api/general/basic.test.ts index 62c53242fbb46b481a2dfc8d7e76c8592c4b578a..72f8253b94c0b544257a045c0da636ed5700acc7 100644 --- a/arkoala-arkts/libarkts/test/ts-api/general/basic.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/general/basic.test.ts @@ -2,7 +2,7 @@ import * as util from "../../test-util" import * as ts from "../../../src/ts-api" import { factory } from "../../../src/ts-api" -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { test("sample-1", function() { const sample_in = ` diff --git a/arkoala-arkts/libarkts/test/ts-api/variables/create-variable.test.ts b/arkoala-arkts/libarkts/test/ts-api/variables/create-variable.test.ts index 33a83fe9b72c32540b101747812d11f8e8e00aae..66369eefa31b5ff6ef3809e1be4381c3ab3a22e0 100644 --- a/arkoala-arkts/libarkts/test/ts-api/variables/create-variable.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/variables/create-variable.test.ts @@ -2,7 +2,7 @@ import * as util from "../../test-util" import * as ts from "../../../src/ts-api" import { factory } from "../../../src/ts-api" -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { test("const-number", function() { const sample_in = ` diff --git a/arkoala-arkts/libarkts/test/ts-api/visitors-and-transformers/memo-rewrite.test.ts b/arkoala-arkts/libarkts/test/ts-api/visitors-and-transformers/memo-rewrite.test.ts index 9bdc32742ee5a27a42ca0d32ed47e38c2f2c5f56..1ece5e82a4aacc6fdcad2690a340e738cbb1afb9 100644 --- a/arkoala-arkts/libarkts/test/ts-api/visitors-and-transformers/memo-rewrite.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/visitors-and-transformers/memo-rewrite.test.ts @@ -2,7 +2,7 @@ import * as util from "../../test-util" import * as ts from "../../../src/ts-api" import { MemoTransformer } from "../../../plugins/src/memo-transformer" -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { test("memo-transformer-sample-1", function() { const sample_in = ` diff --git a/arkoala-arkts/loader/src/loader.ts b/arkoala-arkts/loader/src/loader.ts index 8936e229e7ea669915fc0c9c0b484149afd0acc5..f66b0a9775d09a10bf5c11fe79d032e68ed46984 100644 --- a/arkoala-arkts/loader/src/loader.ts +++ b/arkoala-arkts/loader/src/loader.ts @@ -46,7 +46,7 @@ export interface NativeControl extends LoaderOps { _SetVsyncCallback(pipeline: KPointer): void _VSyncAwait(pipeline: KPointer): Promise _UnblockVsyncWait(pipeline: KPointer): void - _EmitEvent(type: int32, target: int32, arg0: int32, arg1: int32): void + _EmitEvent(type: int32, target: int32, arg0: int32, arg1: int32): string } function callCallback(id: int32, args: KUint8ArrayPtr, length: int32): int32 { diff --git a/arkoala-arkts/memo-plugin/src/function-transformer.ts b/arkoala-arkts/memo-plugin/src/function-transformer.ts index 0c86fe39ae503404e5e28b4189b89e677cf89374..b42df68bd2c52440cad22cbf299fd0629e380c63 100644 --- a/arkoala-arkts/memo-plugin/src/function-transformer.ts +++ b/arkoala-arkts/memo-plugin/src/function-transformer.ts @@ -15,11 +15,18 @@ import * as arkts from "@koalaui/libarkts" import { AbstractVisitor } from "./AbstractVisitor" -import { createContextParameter, createIdParameter, createContextArgument, createIdArgument, RuntimeNames, PositionalIdTracker } from "./utils" +import { + createContextArgument, + createContextParameter, + createIdArgument, + createIdParameter, + PositionalIdTracker, + RuntimeNames +} from "./utils" function hasMemoAnnotation(node: arkts.ScriptFunction) { return arkts.getAnnotations(node).some((it) => - arkts.isIdentifier(it.expr) && it.expr.name === RuntimeNames.ANNOTATION + it.expr !== undefined && arkts.isIdentifier(it.expr) && it.expr.name === RuntimeNames.ANNOTATION ) } @@ -34,7 +41,7 @@ function createHiddenArguments(hash: arkts.NumberLiteral | arkts.StringLiteral): function updateFunctionBody(node: arkts.BlockStatement | undefined, hash: arkts.NumberLiteral | arkts.StringLiteral): arkts.BlockStatement | undefined { if (node === undefined) return node - const scopeDeclaraion = arkts.factory.createVariableDeclaration( + const scopeDeclaration = arkts.factory.createVariableDeclaration( 0, arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_CONST, [ @@ -93,7 +100,7 @@ function updateFunctionBody(node: arkts.BlockStatement | undefined, hash: arkts. return arkts.factory.updateBlock( node, [ - scopeDeclaraion, + scopeDeclaration, unchangedCheck, ...node.statements, recache @@ -115,7 +122,7 @@ export class FunctionTransformer extends AbstractVisitor { if (node instanceof arkts.MethodDefinition) { if (methodDefinitionHasMemoAnnotation) { // TODO: fix - const updatedNode = arkts.factory.updateMethodDefinition( + return arkts.factory.updateMethodDefinition( node, 2, node.name, @@ -134,7 +141,6 @@ export class FunctionTransformer extends AbstractVisitor { node.modifiers, false ) - return updatedNode } } if (node instanceof arkts.CallExpression) { diff --git a/arkoala-arkts/package.json b/arkoala-arkts/package.json index ee2066012bc889a8045bbd7ff77c1a9f3ae9ae4b..bcae4f45deae78b4fb1636f6510468091c898afb 100644 --- a/arkoala-arkts/package.json +++ b/arkoala-arkts/package.json @@ -65,12 +65,13 @@ "build:arkoala": "npm run panda:sdk:check-install && npm run build:arkoala:components && npm run link:arkoala", "build:arkoala:inc": "npm run build:arkoala:components:inc && npm run link:arkoala", "link:arkoala": "mkdir -p build && ../incremental/tools/panda/arkts/arklink --output build/arkoala.abc -- ./arkui/build/arkui-no-common.abc ../arkoala/arkui-common/build/arkui-common.abc ../incremental/runtime/build/incremental.abc ../interop/build/interop.abc", - "aot:host:arkoala": "npm run link:arkoala && npm run -C ../incremental/tools/fast-arktsc compile && node ../incremental/tools/fast-arktsc --only-aot build/arkoala.abc", + "aot:host:arkoala": "npm run link:arkoala && npm run -C ../incremental/tools/fast-arktsc compile && npm run aot:host:stdlib && node ../incremental/tools/fast-arktsc --only-aot build/arkoala.abc", "aot:arm32:arkoala": "npm run link:arkoala && npm run -C ../incremental/tools/fast-arktsc compile && node ../incremental/tools/fast-arktsc --only-aot build/arkoala.abc --aot-target arm", "aot:arm64:arkoala": "npm run link:arkoala && npm run -C ../incremental/tools/fast-arktsc compile && node ../incremental/tools/fast-arktsc --only-aot build/arkoala.abc --aot-target arm64", "build:user": "npm run build:user --prefix trivial/user && mkdir -p ./build && cp -r trivial/user/build/user.abc ./build/", "build:navigation": "npm run build:user --prefix navigation/user && mkdir -p ./build && cp -r navigation/user/build/user.abc ./build/navigation.abc", "build:shopping": "npm run build:user --prefix shopping/user && mkdir -p ./build && cp -r shopping/user/build/user.abc ./build/shopping.abc", + "aot:host:stdlib": "node ../incremental/tools/fast-arktsc --only-aot ../incremental/tools/panda/node_modules/@panda/sdk/ets/etsstdlib.abc", "aot:host:shopping": "npm run build:shopping && npm run -C ../incremental/tools/fast-arktsc compile && npm run aot:host:arkoala && node ../incremental/tools/fast-arktsc --only-aot build/shopping.abc --aot-libs ./build/arkoala.abc", "aot:arm32:shopping": "npm run build:shopping && npm run -C ../incremental/tools/fast-arktsc compile && npm run aot:host:arkoala && node ../incremental/tools/fast-arktsc --only-aot build/shopping.abc --aot-libs ./build/arkoala.abc --aot-target arm", "aot:arm64:shopping": "npm run build:shopping && npm run -C ../incremental/tools/fast-arktsc compile && npm run aot:host:arkoala && node ../incremental/tools/fast-arktsc --only-aot build/shopping.abc --aot-libs ./build/arkoala.abc --aot-target arm64", diff --git a/arkoala-arkts/shopping/user/src/ets/pages/homePage/main.ets b/arkoala-arkts/shopping/user/src/ets/pages/homePage/main.ets index 4ddc9ed53c5efefd5c2b195462f7681b868c26dd..a57b795dd42cc589c7f614d216ceab426473574c 100644 --- a/arkoala-arkts/shopping/user/src/ets/pages/homePage/main.ets +++ b/arkoala-arkts/shopping/user/src/ets/pages/homePage/main.ets @@ -31,7 +31,28 @@ export struct MainPage { @Prop num: number @Prop ratio: number @Consume('pathInfos') pathInfos: NavPathStack + + isPerf: boolean = false + build() { + if (this.isPerf) { + const count = 100 + let perfData = new Array(count) + for (let i = 0; i < count; i++) perfData[i] = i + let now = Date.now() + console.log(`Measuring...`) + ForEach(perfData, (item: number, index: number) => { + this.buildReal() + }, (item: number, index: number) => String(item)) + let passed = Date.now() - now + console.log(`Passed ${passed}ms, ${passed / count}ms per iteration`) + } else { + this.buildReal() + } + } + + @Builder + buildReal() { Column() { Flex({ justifyContent: FlexAlign.SpaceAround, alignItems: ItemAlign.Center }) { Column() { diff --git a/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/color.json b/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/color.json index 3c712962da3c2751c2b9ddb53559afcbd2b54a02..c813809cb3c9a876776b70f49b619f96457cf112 100644 --- a/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/color.json +++ b/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/color.json @@ -3,6 +3,10 @@ { "name": "start_window_background", "value": "#FFFFFF" + }, + { + "name": "my_color", + "value": "#114bbf" } ] } \ No newline at end of file diff --git a/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/string.json b/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/string.json index f94595515a99e0c828807e243494f57f09251930..d1c869602797ec927e55d7c7ca6e4633d8430acb 100644 --- a/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/string.json +++ b/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/string.json @@ -11,6 +11,10 @@ { "name": "EntryAbility_label", "value": "label" + }, + { + "name": "my_text", + "value": "some_text" } ] } \ No newline at end of file diff --git a/arkoala-arkts/trivial/application/entry/src/main/resources/rawfile/koala.png b/arkoala-arkts/trivial/application/entry/src/main/resources/rawfile/koala.png new file mode 100644 index 0000000000000000000000000000000000000000..04c21efeca88b0eea5f17e89fb4a8e1c7bb30892 Binary files /dev/null and b/arkoala-arkts/trivial/application/entry/src/main/resources/rawfile/koala.png differ diff --git a/arkoala-arkts/trivial/trivial/entry/src/main/resources/rawfile/phone.png b/arkoala-arkts/trivial/trivial/entry/src/main/resources/rawfile/phone.png deleted file mode 100644 index 75f9a36d17ae87c9fbb5cc6673a7420488016d11..0000000000000000000000000000000000000000 Binary files a/arkoala-arkts/trivial/trivial/entry/src/main/resources/rawfile/phone.png and /dev/null differ diff --git a/arkoala-arkts/trivial/user/src/ets/page1.ets b/arkoala-arkts/trivial/user/src/ets/page1.ets index 7d28ff27e9c15233acdcbf6ef9b52f28f24ffd12..7495a440b13d11fe83e95fd762f985f54e363d89 100644 --- a/arkoala-arkts/trivial/user/src/ets/page1.ets +++ b/arkoala-arkts/trivial/user/src/ets/page1.ets @@ -116,7 +116,7 @@ struct Page1 { console.log("#### Set Button onClick! #" + this.state) }) Image($r('app.media.startIcon')).width(60).height(60) - Image($rawfile('phone.png')).width(400) + Image($rawfile('koala.png')).width(400) Text("Set Button onClick! #" + this.state) .width(200).height(100) TestProvide() diff --git a/arkoala-arkts/trivial/user/src/sts/hello.sts b/arkoala-arkts/trivial/user/src/sts/hello.sts index 41c42c50e77df8a917c5b8494489635b438fcf3a..1923eb273dc52ae930be03dfe16adb20d8893518 100644 --- a/arkoala-arkts/trivial/user/src/sts/hello.sts +++ b/arkoala-arkts/trivial/user/src/sts/hello.sts @@ -1,7 +1,7 @@ import { Text } from "@ohos.arkui" import { Column, ColumnOptions } from "@ohos.arkui" import { Button } from "@ohos.arkui" -import { Component, State, Entry } from "@ohos.arkui" +import { Component, State, Entry, memo } from "@ohos.arkui" import { Color } from "@ohos.arkui" @Entry diff --git a/arkoala/arkui-common/package.json b/arkoala/arkui-common/package.json index eaf72b00b033defba402371845e920017305e761..f67bcb9d5b8c78d3fd59b510a1a56a89607729f1 100644 --- a/arkoala/arkui-common/package.json +++ b/arkoala/arkui-common/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/arkui-common", - "version": "1.5.3+devel", + "version": "1.5.5+devel", "description": "", "main": "build/lib/src/index.js", "exports": { @@ -53,9 +53,9 @@ }, "keywords": [], "dependencies": { - "@koalaui/common": "1.5.3+devel", - "@koalaui/compat": "1.5.3+devel", - "@koalaui/runtime": "1.5.3+devel", + "@koalaui/common": "1.5.5+devel", + "@koalaui/compat": "1.5.5+devel", + "@koalaui/runtime": "1.5.5+devel", "@koalaui/ets-tsc": "4.9.5-r4", "@koalaui/fast-arktsc": "next" } diff --git a/arkoala/arkui/package.json b/arkoala/arkui/package.json index d7f5d0a206169fed8c0c0337a6292733cdab41d3..55c80acfa8a88843479ab8a0b16a2a68975d39b4 100644 --- a/arkoala/arkui/package.json +++ b/arkoala/arkui/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/arkoala-arkui", - "version": "1.5.3+devel", + "version": "1.5.5+devel", "description": "", "main": "build/lib/src/index.js", "exports": { @@ -45,10 +45,10 @@ }, "keywords": [], "dependencies": { - "@koalaui/common": "1.5.3+devel", - "@koalaui/runtime": "1.5.3+devel", + "@koalaui/common": "1.5.5+devel", + "@koalaui/runtime": "1.5.5+devel", "@koalaui/arkoala": "1.4.1+devel", - "@koalaui/arkui-common": "1.5.3+devel", + "@koalaui/arkui-common": "1.5.5+devel", "@koalaui/ets-tsc": "4.9.5-r4", "media-query-parser": "^2.0.2", "commander": "10.0.1" diff --git a/arkoala/ets-plugin/package.json b/arkoala/ets-plugin/package.json index 1672624374e1b264c82ac8a589a41f7bb946ebf4..aa39e9813b7f109c2ae5d328acec934b789df76d 100644 --- a/arkoala/ets-plugin/package.json +++ b/arkoala/ets-plugin/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/ets-plugin", - "version": "1.5.3+devel", + "version": "1.5.5+devel", "description": "", "main": "build/lib/src/index.js", "types": "build/lib/src/index.d.ts", diff --git a/incremental/build-common/package.json b/incremental/build-common/package.json index 4fbd620d677ea15797fddfdb24bf48eff22957be..6c39c39b5f592863ffa4fbb6501f93db529be0af 100644 --- a/incremental/build-common/package.json +++ b/incremental/build-common/package.json @@ -1,8 +1,11 @@ { "name": "@koalaui/build-common", - "version": "1.5.3+devel", + "version": "1.5.5+devel", "description": "", "files": [ "tsconfig.json" - ] + ], + "scripts": { + "compile": "" + } } \ No newline at end of file diff --git a/incremental/common/package.json b/incremental/common/package.json index 5eb5658c8229b3796c602e7abe37f1d5925be2a8..5a948a90bde5941757a5b78591aee956d0a169c6 100644 --- a/incremental/common/package.json +++ b/incremental/common/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/common", - "version": "1.5.3+devel", + "version": "1.5.5+devel", "description": "", "main": "build/lib/src/index.js", "types": "./index.d.ts", @@ -43,7 +43,7 @@ }, "keywords": [], "dependencies": { - "@koalaui/compat": "1.5.3+devel" + "@koalaui/compat": "1.5.5+devel" }, "devDependencies": { "@ohos/hypium": "1.0.6", diff --git a/incremental/compat/package.json b/incremental/compat/package.json index 62ad8d61d6236a456fcfba402e31904d411ef367..81a3dea9b011f9a01f003539edefc7188f42dce3 100644 --- a/incremental/compat/package.json +++ b/incremental/compat/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/compat", - "version": "1.5.3+devel", + "version": "1.5.5+devel", "description": "", "main": "build/src/index.js", "types": "build/src/index.d.ts", diff --git a/incremental/compiler-plugin/package.json b/incremental/compiler-plugin/package.json index 8f29b81dbce44dcf097b0cd658e669f273bfa3cc..a81d998eec0dad71f41a57332df947b3a75bf73b 100644 --- a/incremental/compiler-plugin/package.json +++ b/incremental/compiler-plugin/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/compiler-plugin", - "version": "1.5.3+devel", + "version": "1.5.5+devel", "description": "", "main": "build/lib/src/index.js", "types": "build/lib/src/index.d.ts", @@ -10,7 +10,7 @@ ], "keywords": [], "dependencies": { - "@koalaui/common": "1.5.3+devel" + "@koalaui/common": "1.5.5+devel" }, "devDependencies": { "@types/chai": "^4.3.1", diff --git a/incremental/harness/package.json b/incremental/harness/package.json index 257c87491e6079340a52e18298ac30901322ecfe..399333031c979e4e1160bad4cf8b042c6c9b8644 100644 --- a/incremental/harness/package.json +++ b/incremental/harness/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/harness", - "version": "1.5.3+devel", + "version": "1.5.5+devel", "description": "A harness library compatible with OHOS and ArkTS", "main": "build/src/index.js", "types": "build/src/index.d.ts", @@ -35,8 +35,8 @@ }, "keywords": [], "dependencies": { - "@koalaui/common": "1.5.3+devel", - "@koalaui/compat": "1.5.3+devel" + "@koalaui/common": "1.5.5+devel", + "@koalaui/compat": "1.5.5+devel" }, "devDependencies": { "@ohos/hypium": "1.0.6", diff --git a/incremental/runtime/package.json b/incremental/runtime/package.json index e20c6e8fd05ad09cc9d6ef73254148065755d41b..a0f66505624793327a3b08c1e8bb6ed948280a35 100644 --- a/incremental/runtime/package.json +++ b/incremental/runtime/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/runtime", - "version": "1.5.3+devel", + "version": "1.5.5+devel", "description": "", "main": "./build/lib/src/index.js", "types": "./build/lib/src/index.d.ts", @@ -41,9 +41,9 @@ }, "keywords": [], "dependencies": { - "@koalaui/common": "1.5.3+devel", - "@koalaui/compat": "1.5.3+devel", - "@koalaui/harness": "1.5.3+devel" + "@koalaui/common": "1.5.5+devel", + "@koalaui/compat": "1.5.5+devel", + "@koalaui/harness": "1.5.5+devel" }, "devDependencies": { "@types/chai": "^4.3.1", diff --git a/incremental/tools/fast-arktsc/src/main.ts b/incremental/tools/fast-arktsc/src/main.ts index 2e8bc7cf3dba45c484a27f87b160e5528a9511d7..b9b066a0b2c4d386f461852262f508c23a69231b 100644 --- a/incremental/tools/fast-arktsc/src/main.ts +++ b/incremental/tools/fast-arktsc/src/main.ts @@ -177,7 +177,7 @@ function mainAot(abc: string) { let sdk = options.sdk ?? path.resolve(path.join(__dirname, '..', '..', 'panda', 'node_modules', '@panda', 'sdk')) let aot = path.join(sdk, archDir(), 'bin', 'ark_aot') let stdlib = path.resolve(path.join(sdk, "ets", "etsstdlib.abc")) - const aotLibs = [stdlib] + const aotLibs = abc.indexOf("etsstdlib") == -1 ? [stdlib] : [] if (options.aotLibs) aotLibs.push(... options.aotLibs.split(",")) let args: string[] = [] if (process.platform == "darwin") { @@ -185,15 +185,16 @@ function mainAot(abc: string) { args.push(aot) aot = "echo" } - let result = abc.replace('.abc', '.an') + let dir = options.outputDir ?? path.dirname(abc) + let result = path.join(dir, path.basename(abc).replace('.abc', '.an')) args.push(... options.aotTarget ? [`--compiler-cross-arch=${options.aotTarget}`] : []) args.push(... [ `--load-runtimes=ets`, - `--boot-panda-files=${aotLibs.join(':')}:${abc}`, + `--boot-panda-files=${aotLibs.map(it => path.resolve(it)).concat(abc).join(':')}`, `--paoc-panda-files=${abc}`, `--paoc-output=${result}` ]) - console.log(`AOT compile ${abc}...`) + console.log(`AOT compile ${abc} to ${result}...`) const child = child_process.spawn(aot, args) child.stdout.on('data', (data) => { process.stdout.write(data); diff --git a/interop/package.json b/interop/package.json index 511ad48a36547acc1d7f44faf013bc175635bef1..7f0af0df812fac5630f90641754300139049db37 100644 --- a/interop/package.json +++ b/interop/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/interop", - "version": "1.5.3+devel", + "version": "1.5.5+devel", "description": "", "workspaces": [ "../incremental/build-common", @@ -57,7 +57,7 @@ "keywords": [], "dependencies": { "@types/node": "^18.0.0", - "@koalaui/common": "1.5.3+devel" + "@koalaui/common": "1.5.5+devel" }, "devDependencies": { "@ohos/hypium": "1.0.6", diff --git a/interop/src/cpp/ani/convertors-ani.h b/interop/src/cpp/ani/convertors-ani.h index 6ca8e43d990c62afc5b239db7ec577c4c4216754..c6aaaf46c992f103244d96a99a32a44e05453895 100644 --- a/interop/src/cpp/ani/convertors-ani.h +++ b/interop/src/cpp/ani/convertors-ani.h @@ -1367,11 +1367,11 @@ void getKoalaEtsNapiCallbackDispatcher(ani_class* clazz, ani_method* method); #else #define KOALA_INTEROP_CALL_VOID(venv, id, length, args) -#define KOALA_INTEROP_CALL_INT(venv, id, length, args) -#define KOALA_INTEROP_CALL_VOID_INTS32(venv, id, argc, args) -#define KOALA_INTEROP_CALL_INT_INTS32(venv, id, argc, args) -#define KOALA_INTEROP_THROW(vmContext, object, ...) -#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) +#define KOALA_INTEROP_CALL_INT(venv, id, length, args) { return 0; } +#define KOALA_INTEROP_CALL_VOID_INTS32(venv, id, argc, args) { return; } +#define KOALA_INTEROP_CALL_INT_INTS32(venv, id, argc, args) { return 0; } +#define KOALA_INTEROP_THROW(vmContext, object, ...) { return __VA_ARGS__; } +#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) { return __VA_ARGS__; } #endif #endif // KOALA_ETS_NAPI diff --git a/interop/src/cpp/common-interop.cc b/interop/src/cpp/common-interop.cc index c522cc84ab0bd84559822dbc4005e071c0c42f42..f7f5b74a6196f0e029b4b70a37b20ae0d8580e51 100644 --- a/interop/src/cpp/common-interop.cc +++ b/interop/src/cpp/common-interop.cc @@ -259,7 +259,7 @@ struct ForeignVMContext { typedef KInt (*LoadVirtualMachine_t)(KInt vmKind, const char* classPath, const char* libraryPath, const struct ForeignVMContext* foreignVM); typedef KNativePointer (*StartApplication_t)(const char* appUrl, const char* appParams); typedef KBoolean (*RunApplication_t)(const KInt arg0, const KInt arg1); -typedef void (*EmitEvent_t)(const KInt type, const KInt target, const KInt arg0, const KInt arg1); +typedef const char* (*EmitEvent_t)(const KInt type, const KInt target, const KInt arg0, const KInt arg1); typedef void (*RestartWith_t)(const char* page); void* getImpl(const char* path, const char* name) { @@ -310,12 +310,15 @@ KBoolean impl_RunApplication(const KInt arg0, const KInt arg1) { } KOALA_INTEROP_2(RunApplication, KBoolean, KInt, KInt) -void impl_EmitEvent(const KInt type, const KInt target, const KInt arg0, const KInt arg1) { +KStringPtr impl_EmitEvent(KVMContext vmContext, KInt type, KInt target, KInt arg0, KInt arg1) { static EmitEvent_t impl = nullptr; if (!impl) impl = reinterpret_cast(getImpl(nullptr, "EmitEvent")); - impl(type, target, arg0, arg1); + const char* out = impl(type, target, arg0, arg1); + auto size = std::string(out).size(); + KStringPtr result(out, size, true); + return result; } -KOALA_INTEROP_V4(EmitEvent, KInt, KInt, KInt, KInt) +KOALA_INTEROP_CTX_4(EmitEvent, KStringPtr, KInt, KInt, KInt, KInt) void impl_RestartWith(const KStringPtr& page) { static RestartWith_t impl = nullptr; diff --git a/interop/src/cpp/vmloader.cc b/interop/src/cpp/vmloader.cc index d409a87809cda49b24ca74dfb50627c35307f5f4..e7eda0d423f7ca522c28c57f70d23030254936fd 100644 --- a/interop/src/cpp/vmloader.cc +++ b/interop/src/cpp/vmloader.cc @@ -310,7 +310,7 @@ const AppInfo javaAppInfo = { "enter", "(IIJ)Z", "emitEvent", - "(IIII)V", + "(IIII)Ljava/lang/String;", }; #endif @@ -324,7 +324,7 @@ const AppInfo pandaAppInfo = { "enter", "IIJ:Z", "emitEvent", - "IIII:V", + "IIII:Lstd/core/String;", }; const AppInfo harnessAppInfo = { "@koalaui/ets-harness/src/EtsHarnessApplication/EtsHarnessApplication", @@ -335,7 +335,7 @@ const AppInfo harnessAppInfo = { "enter", "II:Z", "emitEvent", - "IIII:V", + "IIII:Lstd/core/String;", "restartWith", "Lstd/core/String;:V" }; @@ -509,15 +509,15 @@ extern "C" DLL_EXPORT KBoolean RunApplication(const KInt arg0, const KInt arg1) return 1; } -extern "C" DLL_EXPORT void EmitEvent(const KInt type, const KInt target, const KInt arg0, const KInt arg1) { +extern "C" DLL_EXPORT const char* EmitEvent(const KInt type, const KInt target, const KInt arg0, const KInt arg1) { #ifdef KOALA_JNI if (g_vmEntry.vmKind == JAVA_VM_KIND) { JNIEnv* jEnv = (JNIEnv*)(g_vmEntry.env); if (!g_vmEntry.emitEvent) { LOGE("Cannot find emitEvent method"); - return; + return "-1"; } - jEnv->CallVoidMethod( + auto rv = (jstring)jEnv->CallObjectMethod( (jobject)(g_vmEntry.app), (jmethodID)(g_vmEntry.emitEvent), (jint)type, @@ -529,6 +529,8 @@ extern "C" DLL_EXPORT void EmitEvent(const KInt type, const KInt target, const K jEnv->ExceptionDescribe(); jEnv->ExceptionClear(); } + const char *result = jEnv->GetStringUTFChars(rv, 0); + return result; } #endif #ifdef KOALA_ETS_NAPI @@ -536,9 +538,9 @@ extern "C" DLL_EXPORT void EmitEvent(const KInt type, const KInt target, const K EtsEnv* etsEnv = (EtsEnv*)(g_vmEntry.env); if (!g_vmEntry.emitEvent) { LOGE("Cannot find emitEvent method"); - return; + return "-1"; } - etsEnv->CallVoidMethod( + auto rv = (ets_string)etsEnv->CallObjectMethod( (ets_object)(g_vmEntry.app), (ets_method)(g_vmEntry.emitEvent), (ets_int)type, @@ -551,8 +553,11 @@ extern "C" DLL_EXPORT void EmitEvent(const KInt type, const KInt target, const K etsEnv->ErrorDescribe(); etsEnv->ErrorClear(); } + const char *result = etsEnv->GetStringUTFChars(rv, 0); + return result; } #endif + return "-1"; } extern "C" DLL_EXPORT void RestartWith(const char* page) {