diff --git a/arkoala-arkts/libarkts/native/src/bridges.cc b/arkoala-arkts/libarkts/native/src/bridges.cc index 78ad5321f76e29006cc349337868e0ea0b1e3d4e..d7d313b737c2436367d0fb52153c8878cc3cb090 100644 --- a/arkoala-arkts/libarkts/native/src/bridges.cc +++ b/arkoala-arkts/libarkts/native/src/bridges.cc @@ -194,18 +194,6 @@ KNativePointer impl_CreateAstDumper( } KOALA_INTEROP_3(CreateAstDumper, KNativePointer, KNativePointer, KNativePointer, KStringPtr) -KNativePointer impl_CreateETSUnionTypeIr( - KNativePointer contextPtr, - KNativePointerArray typesPtr, - KInt typesLen -) { - auto context = reinterpret_cast(contextPtr); - auto types = reinterpret_cast(typesPtr); - - return GetImpl()->CreateETSUnionTypeIr(context, types, typesLen); -} -KOALA_INTEROP_3(CreateETSUnionTypeIr, KNativePointer, KNativePointer, KNativePointerArray, KInt) - KNativePointer impl_CreateFunctionSignature( KNativePointer contextPtr, KNativePointer typeParamsPtr, @@ -239,15 +227,6 @@ KNativePointer impl_CreateIdentifier2(KNativePointer contextPtr, KStringPtr& nam } KOALA_INTEROP_3(CreateIdentifier2, KNativePointer, KNativePointer, KStringPtr, KNativePointer) -KNativePointer impl_CreateETSFunctionTypeIr(KNativePointer contextPtr, KNativePointer signaturePtr, KInt funcFlagsT) { - auto context = reinterpret_cast(contextPtr); - auto signature = reinterpret_cast(signaturePtr); - auto funcFlags = Es2pandaScriptFunctionFlags(funcFlagsT); - - return GetImpl()->CreateETSFunctionTypeIr(context, signature, funcFlags); -} -KOALA_INTEROP_3(CreateETSFunctionTypeIr, KNativePointer, KNativePointer, KNativePointer, KInt) - KNativePointer impl_CreateNumberLiteral(KNativePointer contextPtr, KDouble value) { auto context = reinterpret_cast(contextPtr); diff --git a/arkoala-arkts/libarkts/native/src/generated/bridges.cc b/arkoala-arkts/libarkts/native/src/generated/bridges.cc index a9faf06d198946c3191db1efdf3b1ea0aa3b1051..2a17ab86d56777e1f0b5b001f8cbd77f24debaca 100644 --- a/arkoala-arkts/libarkts/native/src/generated/bridges.cc +++ b/arkoala-arkts/libarkts/native/src/generated/bridges.cc @@ -163,6 +163,27 @@ KNativePointer impl_UpdateTSVoidKeyword(KNativePointer context, KNativePointer o } KOALA_INTEROP_2(UpdateTSVoidKeyword, KNativePointer, KNativePointer, KNativePointer); +KNativePointer impl_CreateETSFunctionTypeIr(KNativePointer context, KNativePointer signature, KInt funcFlags) +{ + const auto _context = reinterpret_cast(context); + const auto _signature = reinterpret_cast(signature); + const auto _funcFlags = static_cast(funcFlags); + auto result = GetImpl()->CreateETSFunctionTypeIr(_context, _signature, _funcFlags); + return result; +} +KOALA_INTEROP_3(CreateETSFunctionTypeIr, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateETSFunctionTypeIr(KNativePointer context, KNativePointer original, KNativePointer signature, KInt funcFlags) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _signature = reinterpret_cast(signature); + const auto _funcFlags = static_cast(funcFlags); + auto result = GetImpl()->UpdateETSFunctionTypeIr(_context, _original, _signature, _funcFlags); + return result; +} +KOALA_INTEROP_4(UpdateETSFunctionTypeIr, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt); + KNativePointer impl_ETSFunctionTypeIrTypeParamsConst(KNativePointer context, KNativePointer receiver) { const auto _context = reinterpret_cast(context); @@ -2176,6 +2197,27 @@ KNativePointer impl_UpdateTSObjectKeyword(KNativePointer context, KNativePointer } KOALA_INTEROP_2(UpdateTSObjectKeyword, KNativePointer, KNativePointer, KNativePointer); +KNativePointer impl_CreateETSUnionTypeIr(KNativePointer context, KNativePointerArray types, KUInt typesLen) +{ + const auto _context = reinterpret_cast(context); + const auto _types = reinterpret_cast(types); + const auto _typesLen = static_cast(typesLen); + auto result = GetImpl()->CreateETSUnionTypeIr(_context, _types, _typesLen); + return result; +} +KOALA_INTEROP_3(CreateETSUnionTypeIr, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateETSUnionTypeIr(KNativePointer context, KNativePointer original, KNativePointerArray types, KUInt typesLen) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _types = reinterpret_cast(types); + const auto _typesLen = static_cast(typesLen); + auto result = GetImpl()->UpdateETSUnionTypeIr(_context, _original, _types, _typesLen); + return result; +} +KOALA_INTEROP_4(UpdateETSUnionTypeIr, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + KNativePointer impl_ETSUnionTypeIrTypesConst(KNativePointer context, KNativePointer receiver) { const auto _context = reinterpret_cast(context); @@ -5165,6 +5207,24 @@ KNativePointer impl_BinaryExpressionRight(KNativePointer context, KNativePointer } KOALA_INTEROP_2(BinaryExpressionRight, KNativePointer, KNativePointer, KNativePointer); +KNativePointer impl_BinaryExpressionResultConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionResultConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(BinaryExpressionResultConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BinaryExpressionResult(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionResult(_context, _receiver); + return result; +} +KOALA_INTEROP_2(BinaryExpressionResult, KNativePointer, KNativePointer, KNativePointer); + KInt impl_BinaryExpressionOperatorTypeConst(KNativePointer context, KNativePointer receiver) { const auto _context = reinterpret_cast(context); @@ -5422,6 +5482,24 @@ void impl_AssignmentExpressionSetLeft(KNativePointer context, KNativePointer rec } KOALA_INTEROP_V3(AssignmentExpressionSetLeft, KNativePointer, KNativePointer, KNativePointer); +KNativePointer impl_AssignmentExpressionResultConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssignmentExpressionResultConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AssignmentExpressionResultConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AssignmentExpressionResult(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssignmentExpressionResult(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AssignmentExpressionResult, KNativePointer, KNativePointer, KNativePointer); + KInt impl_AssignmentExpressionOperatorTypeConst(KNativePointer context, KNativePointer receiver) { const auto _context = reinterpret_cast(context); @@ -6506,6 +6584,25 @@ KNativePointer impl_AnnotationDeclarationGetBaseNameConst(KNativePointer context } KOALA_INTEROP_2(AnnotationDeclarationGetBaseNameConst, KNativePointer, KNativePointer, KNativePointer); +KNativePointer impl_CreateAnnotationUsageIr(KNativePointer context, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->CreateAnnotationUsageIr(_context, _expr); + return result; +} +KOALA_INTEROP_2(CreateAnnotationUsageIr, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateAnnotationUsageIr(KNativePointer context, KNativePointer original, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->UpdateAnnotationUsageIr(_context, _original, _expr); + return result; +} +KOALA_INTEROP_3(UpdateAnnotationUsageIr, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + KNativePointer impl_AnnotationUsageIrExpr(KNativePointer context, KNativePointer receiver) { const auto _context = reinterpret_cast(context); @@ -6545,6 +6642,16 @@ KNativePointer impl_AnnotationUsageIrPropertiesPtrConst(KNativePointer context, } KOALA_INTEROP_2(AnnotationUsageIrPropertiesPtrConst, KNativePointer, KNativePointer, KNativePointer); +void impl_AnnotationUsageIrAddProperty(KNativePointer context, KNativePointer receiver, KNativePointer property) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _property = reinterpret_cast(property); + GetImpl()->AnnotationUsageIrAddProperty(_context, _receiver, _property); + return ; +} +KOALA_INTEROP_V3(AnnotationUsageIrAddProperty, KNativePointer, KNativePointer, KNativePointer); + void impl_AnnotationUsageIrSetProperties(KNativePointer context, KNativePointer receiver, KNativePointerArray properties, KUInt propertiesLen) { const auto _context = reinterpret_cast(context); @@ -9424,6 +9531,40 @@ KNativePointer impl_ImportExpressionSourceConst(KNativePointer context, KNativeP } KOALA_INTEROP_2(ImportExpressionSourceConst, KNativePointer, KNativePointer, KNativePointer); +KNativePointer impl_CreateETSNullTypeIr(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateETSNullTypeIr(_context); + return result; +} +KOALA_INTEROP_1(CreateETSNullTypeIr, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSNullTypeIr(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateETSNullTypeIr(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateETSNullTypeIr, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSUndefinedTypeIr(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateETSUndefinedTypeIr(_context); + return result; +} +KOALA_INTEROP_1(CreateETSUndefinedTypeIr, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSUndefinedTypeIr(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateETSUndefinedTypeIr(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateETSUndefinedTypeIr, KNativePointer, KNativePointer, KNativePointer); + KNativePointer impl_CreateTypeofExpression(KNativePointer context, KNativePointer argument) { const auto _context = reinterpret_cast(context); @@ -10298,3 +10439,22 @@ KNativePointer impl_UpdateTSThisType(KNativePointer context, KNativePointer orig } KOALA_INTEROP_2(UpdateTSThisType, KNativePointer, KNativePointer, KNativePointer); +KNativePointer impl_CreateInterfaceDecl(KNativePointer context, KStringPtr& name) +{ + const auto _context = reinterpret_cast(context); + const auto _name = getStringCopy(name); + auto result = GetImpl()->CreateInterfaceDecl(_context, _name); + return result; +} +KOALA_INTEROP_2(CreateInterfaceDecl, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_CreateFunctionDecl(KNativePointer context, KStringPtr& name, KNativePointer node) +{ + const auto _context = reinterpret_cast(context); + const auto _name = getStringCopy(name); + const auto _node = reinterpret_cast(node); + auto result = GetImpl()->CreateFunctionDecl(_context, _name, _node); + return result; +} +KOALA_INTEROP_3(CreateFunctionDecl, KNativePointer, KNativePointer, KStringPtr, KNativePointer); + diff --git a/arkoala-arkts/libarkts/package.json b/arkoala-arkts/libarkts/package.json index 7aec984c997868dd552cc76a07e144935565618e..c5edbbda6eee08a0dd9b414ff3415c78dbb188ea 100644 --- a/arkoala-arkts/libarkts/package.json +++ b/arkoala-arkts/libarkts/package.json @@ -11,7 +11,7 @@ "./build/*" ], "config": { - "gen_version": "3.0.10", + "gen_version": "3.0.11", "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/src/generated/Es2pandaNativeModule.ts b/arkoala-arkts/libarkts/src/generated/Es2pandaNativeModule.ts index a807a7416353b552141b8eda8a457a46185cdb6a..d0bd3c8049222380555d2acaebd536f2d4d28c68 100644 --- a/arkoala-arkts/libarkts/src/generated/Es2pandaNativeModule.ts +++ b/arkoala-arkts/libarkts/src/generated/Es2pandaNativeModule.ts @@ -73,6 +73,12 @@ export class Es2pandaNativeModule { _UpdateTSVoidKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { throw new Error("This methods was not overloaded by native module initialization") } + _CreateETSFunctionTypeIr(context: KNativePointer, signature: KNativePointer, funcFlags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSFunctionTypeIr(context: KNativePointer, original: KNativePointer, signature: KNativePointer, funcFlags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } _ETSFunctionTypeIrTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { throw new Error("This methods was not overloaded by native module initialization") } @@ -697,6 +703,12 @@ export class Es2pandaNativeModule { _UpdateTSObjectKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { throw new Error("This methods was not overloaded by native module initialization") } + _CreateETSUnionTypeIr(context: KNativePointer, types: BigUint64Array, typesLen: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSUnionTypeIr(context: KNativePointer, original: KNativePointer, types: BigUint64Array, typesLen: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } _ETSUnionTypeIrTypesConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { throw new Error("This methods was not overloaded by native module initialization") } @@ -1636,6 +1648,12 @@ export class Es2pandaNativeModule { _BinaryExpressionRight(context: KNativePointer, receiver: KNativePointer): KNativePointer { throw new Error("This methods was not overloaded by native module initialization") } + _BinaryExpressionResultConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionResult(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } _BinaryExpressionOperatorTypeConst(context: KNativePointer, receiver: KNativePointer): KInt { throw new Error("This methods was not overloaded by native module initialization") } @@ -1717,6 +1735,12 @@ export class Es2pandaNativeModule { _AssignmentExpressionSetLeft(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { throw new Error("This methods was not overloaded by native module initialization") } + _AssignmentExpressionResultConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionResult(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } _AssignmentExpressionOperatorTypeConst(context: KNativePointer, receiver: KNativePointer): KInt { throw new Error("This methods was not overloaded by native module initialization") } @@ -2053,6 +2077,12 @@ export class Es2pandaNativeModule { _AnnotationDeclarationGetBaseNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { throw new Error("This methods was not overloaded by native module initialization") } + _CreateAnnotationUsageIr(context: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateAnnotationUsageIr(context: KNativePointer, original: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } _AnnotationUsageIrExpr(context: KNativePointer, receiver: KNativePointer): KNativePointer { throw new Error("This methods was not overloaded by native module initialization") } @@ -2065,6 +2095,9 @@ export class Es2pandaNativeModule { _AnnotationUsageIrPropertiesPtrConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { throw new Error("This methods was not overloaded by native module initialization") } + _AnnotationUsageIrAddProperty(context: KNativePointer, receiver: KNativePointer, property: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } _AnnotationUsageIrSetProperties(context: KNativePointer, receiver: KNativePointer, properties: BigUint64Array, propertiesLen: KUInt): void { throw new Error("This methods was not overloaded by native module initialization") } @@ -2962,6 +2995,18 @@ export class Es2pandaNativeModule { _ImportExpressionSourceConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { throw new Error("This methods was not overloaded by native module initialization") } + _CreateETSNullTypeIr(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSNullTypeIr(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSUndefinedTypeIr(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSUndefinedTypeIr(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } _CreateTypeofExpression(context: KNativePointer, argument: KNativePointer): KNativePointer { throw new Error("This methods was not overloaded by native module initialization") } @@ -3232,4 +3277,10 @@ export class Es2pandaNativeModule { _UpdateTSThisType(context: KNativePointer, original: KNativePointer): KNativePointer { throw new Error("This methods was not overloaded by native module initialization") } + _CreateInterfaceDecl(context: KNativePointer, name: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateFunctionDecl(context: KNativePointer, name: KStringPtr, node: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/index.ts b/arkoala-arkts/libarkts/src/generated/index.ts index 0c4fb3eb3837fed7a92617718f28399a2103459e..a73b4eb872530442f73dee845c2ca3f486ade421 100644 --- a/arkoala-arkts/libarkts/src/generated/index.ts +++ b/arkoala-arkts/libarkts/src/generated/index.ts @@ -180,4 +180,7 @@ export * from "./peers/TypeNode" export * from "./peers/NewExpression" export * from "./peers/TSParameterProperty" export * from "./peers/ETSWildcardType" -export * from "./peers/TSThisType" \ No newline at end of file +export * from "./peers/TSThisType" +export * from "./peers/ETSDynamicFunctionType" +export * from "./peers/InterfaceDecl" +export * from "./peers/FunctionDecl" \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts index 06b587bdd5957451f416bc485dd139681817c40c..70875a74e15051af21453e9eb6ef796bb66bc9ce 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,8 +26,8 @@ import { } from "../../reexport-for-generated" export abstract class AnnotatedAstNode extends AstNode { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node AnnotatedAstNode") } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts index de14fdb105de84df6a4f5acf78412601cde19d20..243a46204c015f0b8eca6c441cf63023eaeebbde 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,8 +27,8 @@ import { import { Expression } from "./Expression" export abstract class AnnotatedExpression extends Expression { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node AnnotatedExpression") } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts index 320e90b5d0a5bd1c96649a99a651d17b142874e0..387cd8557dd2e75868cb97cb74ebd95edc061935 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,8 +27,8 @@ import { import { Statement } from "./Statement" export abstract class AnnotatedStatement extends Statement { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node AnnotatedStatement") } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts index 06a0ae78577c130103c56c30ef68c23b811cc0a2..2951971c4aadce03c4f3df3a7c37d550f22d030e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Expression } from "./Expression" export class AnnotationDeclaration extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 1) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 1) + super(pointer) console.warn("Warning: stub node AnnotationDeclaration") } + createAnnotationDeclaration(expr: Expression): AnnotationDeclaration { + return new AnnotationDeclaration(global.generatedEs2panda._CreateAnnotationDeclaration(global.context, passNode(expr))) + } get internalNameConst(): string { return global.generatedEs2panda._AnnotationDeclarationInternalNameConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts index f8782c29a21ccb0d91eb3fcda8df3956d788fc6f..a5daeeb6568348d12cf7ef099472a260ff7c8ad3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,21 +28,24 @@ import { import { Statement } from "./Statement" import { Expression } from "./Expression" export class AnnotationUsage extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 2) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 2) + super(pointer) console.warn("Warning: stub node AnnotationUsage") } - get irExpr(): Expression { + createAnnotationUsage(expr: Expression): AnnotationUsage { + return new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsageIr(global.context, passNode(expr))) + } + get expr(): Expression { return unpackNonNullableNode(global.generatedEs2panda._AnnotationUsageIrExpr(global.context, this.peer)) } - get irProperties(): readonly AstNode[] { + get properties(): readonly AstNode[] { return unpackNodeArray(global.generatedEs2panda._AnnotationUsageIrProperties(global.context, this.peer)) } - get irPropertiesConst(): readonly AstNode[] { + get propertiesConst(): readonly AstNode[] { return unpackNodeArray(global.generatedEs2panda._AnnotationUsageIrPropertiesConst(global.context, this.peer)) } - get irPropertiesPtrConst(): readonly AstNode[] { + get propertiesPtrConst(): readonly AstNode[] { return unpackNodeArray(global.generatedEs2panda._AnnotationUsageIrPropertiesPtrConst(global.context, this.peer)) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts index 51bd99b4a9df36f237de9d2c3185cc223eb90407..59448bb76e5aaed96ab2386533eedf4658745e4e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,8 +29,8 @@ import { AnnotatedExpression } from "./AnnotatedExpression" import { Expression } from "./Expression" import { Decorator } from "./Decorator" export abstract class ArrayExpression extends AnnotatedExpression { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node ArrayExpression") } get elementsConst(): readonly Expression[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts index 89389b871351364c0071cd1880dfb8717f174b9b..0bde392768165870daf30354f910ed2be7b65672 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Expression } from "./Expression" import { ScriptFunction } from "./ScriptFunction" export class ArrowFunctionExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 0) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 0) + super(pointer) console.warn("Warning: stub node ArrowFunctionExpression") } + createArrowFunctionExpression(func: ScriptFunction): ArrowFunctionExpression { + return new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression(global.context, passNode(func))) + } get functionConst(): ScriptFunction { return unpackNonNullableNode(global.generatedEs2panda._ArrowFunctionExpressionFunctionConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts index ce1476d38847a2b3f12089316247b213921c4265..e7496b8f60da403230935574706851803960ebb9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Expression } from "./Expression" export class AssertStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 3) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 3) + super(pointer) console.warn("Warning: stub node AssertStatement") } + createAssertStatement(test: Expression, second: Expression): AssertStatement { + return new AssertStatement(global.generatedEs2panda._CreateAssertStatement(global.context, passNode(test), passNode(second))) + } get testConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._AssertStatementTestConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts index f6a0341343d70ce086f6ff925742fcb939c39f8e..4938155ee04157e320801526e4fd2e7a9094a912 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,10 +26,10 @@ import { } from "../../reexport-for-generated" import { Expression } from "./Expression" -import { Es2pandaTokenType } from "../Es2pandaEnums" +import { Es2pandaTokenType } from "./../Es2pandaEnums" export abstract class AssignmentExpression extends Expression { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node AssignmentExpression") } get leftConst(): Expression { @@ -43,6 +44,12 @@ export abstract class AssignmentExpression extends Expression { get rightConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._AssignmentExpressionRightConst(global.context, this.peer)) } + get resultConst(): Expression { + return unpackNonNullableNode(global.generatedEs2panda._AssignmentExpressionResultConst(global.context, this.peer)) + } + get result(): Expression { + return unpackNonNullableNode(global.generatedEs2panda._AssignmentExpressionResult(global.context, this.peer)) + } get operatorTypeConst(): Es2pandaTokenType { return global.generatedEs2panda._AssignmentExpressionOperatorTypeConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts index 3c3e9d50f76d0e51515837ac8a777b3a8d037bb0..4288b413c758d69feb6b79691ee081dfcc1492fb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class AwaitExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 4) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 4) + super(pointer) console.warn("Warning: stub node AwaitExpression") } + createAwaitExpression(argument: Expression): AwaitExpression { + return new AwaitExpression(global.generatedEs2panda._CreateAwaitExpression(global.context, passNode(argument))) + } get argumentConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._AwaitExpressionArgumentConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts index 500cd1731c60b799db7cfb116c3955306a08c368..dbdbfbd81dafe5a2c7789fb93fae273dcc37eeac 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Literal } from "./Literal" export class BigIntLiteral extends Literal { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 5) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 5) + super(pointer) console.warn("Warning: stub node BigIntLiteral") } + createBigIntLiteral(src: string): BigIntLiteral { + return new BigIntLiteral(global.generatedEs2panda._CreateBigIntLiteral(global.context, src)) + } get strConst(): string { return global.generatedEs2panda._BigIntLiteralStrConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts index b504f2f9b980d2edfa579270ac9a3ee896b9ac74..5c812488ba4f8b73138203972a9ea881bb7dd25f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,13 +26,16 @@ import { } from "../../reexport-for-generated" import { Expression } from "./Expression" -import { Es2pandaTokenType } from "../Es2pandaEnums" +import { Es2pandaTokenType } from "./../Es2pandaEnums" export class BinaryExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 6) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 6) + super(pointer) console.warn("Warning: stub node BinaryExpression") } + createBinaryExpression(left: Expression, right: Expression, operatorType: Es2pandaTokenType): BinaryExpression { + return new BinaryExpression(global.generatedEs2panda._CreateBinaryExpression(global.context, passNode(left), passNode(right), operatorType)) + } get leftConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._BinaryExpressionLeftConst(global.context, this.peer)) } @@ -44,6 +48,12 @@ export class BinaryExpression extends Expression { get right(): Expression { return unpackNonNullableNode(global.generatedEs2panda._BinaryExpressionRight(global.context, this.peer)) } + get resultConst(): Expression { + return unpackNonNullableNode(global.generatedEs2panda._BinaryExpressionResultConst(global.context, this.peer)) + } + get result(): Expression { + return unpackNonNullableNode(global.generatedEs2panda._BinaryExpressionResult(global.context, this.peer)) + } get operatorTypeConst(): Es2pandaTokenType { return global.generatedEs2panda._BinaryExpressionOperatorTypeConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts index fb24816d9ee7b26aaf2fb02086ab2847f4883cea..011893654cb0ad4135d9e29a6ba20e584310cf58 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { Expression } from "./Expression" import { Statement } from "./Statement" export class BlockExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 154) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 154) + super(pointer) console.warn("Warning: stub node BlockExpression") } get statementsConst(): readonly Statement[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts index 1e73be90df966228f9d15dd8f6c1aa4187f251c1..f1ed56f2364bc0bea50dd22ed9cb0527fc7627d6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,9 +27,9 @@ import { import { Statement } from "./Statement" export class BlockStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 7) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 7) + super(pointer) console.warn("Warning: stub node BlockStatement") } get statementsConst(): readonly Statement[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts index 0f5f62eb86994b05cfa2b48205e80f7b3430ff94..d796d1d0483314f78aec6e1b8c79e6981435c475 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Literal } from "./Literal" export class BooleanLiteral extends Literal { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 8) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 8) + super(pointer) console.warn("Warning: stub node BooleanLiteral") } + createBooleanLiteral(value: boolean): BooleanLiteral { + return new BooleanLiteral(global.generatedEs2panda._CreateBooleanLiteral(global.context, value)) + } get valueConst(): boolean { return global.generatedEs2panda._BooleanLiteralValueConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts index 8884167e5657bf0ed7600e9ff0bf01564271b12e..e637be489811cbddf2aef3ed293a6006cd203758 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Identifier } from "./Identifier" export class BreakStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 9) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 9) + super(pointer) console.warn("Warning: stub node BreakStatement") } + createBreakStatement(): BreakStatement { + return new BreakStatement(global.generatedEs2panda._CreateBreakStatement(global.context)) + } get identConst(): Identifier { return unpackNonNullableNode(global.generatedEs2panda._BreakStatementIdentConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts index f2abbb103c81ed44894065ddd7571cbabec659ca..a8d899e3f2771d9a4e6615d2ee91c82498b8f034 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -29,11 +30,14 @@ import { Expression } from "./Expression" import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" import { BlockStatement } from "./BlockStatement" export class CallExpression extends MaybeOptionalExpression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 10) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 10) + super(pointer) console.warn("Warning: stub node CallExpression") } + createCallExpression(callee: Expression, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation, optional_arg: boolean, trailingComma: boolean): CallExpression { + return new CallExpression(global.generatedEs2panda._CreateCallExpression(global.context, passNode(callee), passNodeArray(_arguments), argumentsLen, passNode(typeParams), optional_arg, trailingComma)) + } get calleeConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._CallExpressionCalleeConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts b/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts index 6a7af6434ef3c8bd7b4860959e99365c7b24e3ff..ccaa905c34c54012f96ee12b7cd9d55a875eaaca 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,11 +29,14 @@ import { TypedStatement } from "./TypedStatement" import { Expression } from "./Expression" import { BlockStatement } from "./BlockStatement" export class CatchClause extends TypedStatement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 11) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 11) + super(pointer) console.warn("Warning: stub node CatchClause") } + createCatchClause(param: Expression, body: BlockStatement): CatchClause { + return new CatchClause(global.generatedEs2panda._CreateCatchClause(global.context, passNode(param), passNode(body))) + } get param(): Expression { return unpackNonNullableNode(global.generatedEs2panda._CatchClauseParam(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts index 95f05d8d7be4dbfd4d8a715c28578b218ac7c291..9f87c3be4183bef4f28a324de184c887f392829b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class ChainExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 12) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 12) + super(pointer) console.warn("Warning: stub node ChainExpression") } + createChainExpression(expression: Expression): ChainExpression { + return new ChainExpression(global.generatedEs2panda._CreateChainExpression(global.context, passNode(expression))) + } get getExpressionConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._ChainExpressionGetExpressionConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts index dd10f3cc1a221f574ac52ec15868d99697da0a66..eae6038b3a8a855e2344e92e1fbe139f39b03002 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Literal } from "./Literal" export class CharLiteral extends Literal { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 13) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 13) + super(pointer) console.warn("Warning: stub node CharLiteral") } + createCharLiteral(): CharLiteral { + return new CharLiteral(global.generatedEs2panda._CreateCharLiteral(global.context)) + } } export function isCharLiteral(node: AstNode): node is CharLiteral { return node instanceof CharLiteral diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts index 895f77bb5dc5290ab5ca26a0fb4e8bf99886a345..616eb5e4b5af00b0ca0245bde796c3e707a88cf4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,11 +29,14 @@ import { Statement } from "./Statement" import { ClassDefinition } from "./ClassDefinition" import { Decorator } from "./Decorator" export class ClassDeclaration extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 15) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 15) + super(pointer) console.warn("Warning: stub node ClassDeclaration") } + createClassDeclaration(def: ClassDefinition): ClassDeclaration { + return new ClassDeclaration(global.generatedEs2panda._CreateClassDeclaration(global.context, passNode(def))) + } get definition(): ClassDefinition { return unpackNonNullableNode(global.generatedEs2panda._ClassDeclarationDefinition(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts index 4ef163a72cfb4955ecf871e83b4ca1198f1f4fcf..001a8e6cb9b5c73f7bdb67e77f26f82a89efbc72 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,20 +27,24 @@ import { import { TypedAstNode } from "./TypedAstNode" import { Identifier } from "./Identifier" -import { Expression } from "./Expression" -import { Es2pandaClassDefinitionModifiers } from "../Es2pandaEnums" -import { MethodDefinition } from "./MethodDefinition" -import { TSClassImplements } from "./TSClassImplements" import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" +import { TSClassImplements } from "./TSClassImplements" +import { MethodDefinition } from "./MethodDefinition" +import { Expression } from "./Expression" +import { Es2pandaClassDefinitionModifiers } from "./../Es2pandaEnums" +import { Es2pandaModifierFlags } from "./../Es2pandaEnums" import { TSEnumDeclaration } from "./TSEnumDeclaration" import { ClassDeclaration } from "./ClassDeclaration" export class ClassDefinition extends TypedAstNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 14) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 14) + super(pointer) console.warn("Warning: stub node ClassDefinition") } + createClassDefinition(ident: Identifier, typeParams: TSTypeParameterDeclaration, superTypeParams: TSTypeParameterInstantiation, _implements: readonly TSClassImplements[], implementsLen: number, ctor: MethodDefinition, superClass: Expression, 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)) + } get identConst(): Identifier { return unpackNonNullableNode(global.generatedEs2panda._ClassDefinitionIdentConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts index d78a8e9400d4fa7c69dc4c3eff4b546a3e3d3a3b..4dc4a2d54c7d16b2819649d8764cdee87526771a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,8 +29,8 @@ import { TypedStatement } from "./TypedStatement" import { Expression } from "./Expression" import { Decorator } from "./Decorator" export abstract class ClassElement extends TypedStatement { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node ClassElement") } get key(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts index 310123432fbb41ec43c195394681ccf177c76ed2..47ec06b628481beed36c30eef8a4712882a2ee49 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Expression } from "./Expression" import { ClassDefinition } from "./ClassDefinition" export class ClassExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 16) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 16) + super(pointer) console.warn("Warning: stub node ClassExpression") } + createClassExpression(def: ClassDefinition): ClassExpression { + return new ClassExpression(global.generatedEs2panda._CreateClassExpression(global.context, passNode(def))) + } get definitionConst(): ClassDefinition { return unpackNonNullableNode(global.generatedEs2panda._ClassExpressionDefinitionConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts index b856babd5b53d74a203e34e06ad25d16cc256e14..fe328cf8eda8f9700050d5ceefd68d3935690710 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { ClassElement } from "./ClassElement" import { TypeNode } from "./TypeNode" export class ClassProperty extends ClassElement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 17) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 17) + super(pointer) console.warn("Warning: stub node ClassProperty") } get typeAnnotationConst(): TypeNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts index eb2d7f8ee6a3855ade532cc852ef2bd0674ac8bd..2e91078711e844ba4ee50ceb871f7ce74465c2dd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,12 +26,16 @@ import { } from "../../reexport-for-generated" import { ClassElement } from "./ClassElement" +import { Expression } from "./Expression" export class ClassStaticBlock extends ClassElement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 18) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 18) + super(pointer) console.warn("Warning: stub node ClassStaticBlock") } + createClassStaticBlock(value: Expression): ClassStaticBlock { + return new ClassStaticBlock(global.generatedEs2panda._CreateClassStaticBlock(global.context, passNode(value))) + } } export function isClassStaticBlock(node: AstNode): node is ClassStaticBlock { return node instanceof ClassStaticBlock diff --git a/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts index 53a37a16df2a6f9ebc3713ef5e013e2db481596c..8a6e7cf28fff6fc3717db2222b890193e3c53d54 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class ConditionalExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 19) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 19) + super(pointer) console.warn("Warning: stub node ConditionalExpression") } + createConditionalExpression(test: Expression, consequent: Expression, alternate: Expression): ConditionalExpression { + return new ConditionalExpression(global.generatedEs2panda._CreateConditionalExpression(global.context, passNode(test), passNode(consequent), passNode(alternate))) + } get testConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._ConditionalExpressionTestConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts index e88aac8aad43c501270962c92059db7cca88080b..d80b60f3b6de79a41803c97bb6225d604dc9f1cd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Identifier } from "./Identifier" export class ContinueStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 20) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 20) + super(pointer) console.warn("Warning: stub node ContinueStatement") } + createContinueStatement(): ContinueStatement { + return new ContinueStatement(global.generatedEs2panda._CreateContinueStatement(global.context)) + } get identConst(): Identifier { return unpackNonNullableNode(global.generatedEs2panda._ContinueStatementIdentConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts index 7bcf25da18976ac00e2cef025c5070881acd69e9..9c26521b10de1effe43a4fb21455b774f399e618 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Statement } from "./Statement" export class DebuggerStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 21) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 21) + super(pointer) console.warn("Warning: stub node DebuggerStatement") } + createDebuggerStatement(): DebuggerStatement { + return new DebuggerStatement(global.generatedEs2panda._CreateDebuggerStatement(global.context)) + } } export function isDebuggerStatement(node: AstNode): node is DebuggerStatement { return node instanceof DebuggerStatement diff --git a/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts b/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts index 0d2bc56da4f0722ea25b6bb2c3b434ec0b80c42f..c78b3a4f46e50166b0074b6f7063a291c7c74a11 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Expression } from "./Expression" export class Decorator extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 22) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 22) + super(pointer) console.warn("Warning: stub node Decorator") } + createDecorator(expr: Expression): Decorator { + return new Decorator(global.generatedEs2panda._CreateDecorator(global.context, passNode(expr))) + } get exprConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._DecoratorExprConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts index f8fc24ac23e712ebac809287b8e09156e8ee36b2..6bbff443c1b5c56898d6ca4a3c0a4b50aff83ad6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,12 +26,17 @@ import { } from "../../reexport-for-generated" import { CallExpression } from "./CallExpression" +import { Expression } from "./Expression" +import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" export class DirectEvalExpression extends CallExpression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 23) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 23) + super(pointer) console.warn("Warning: stub node DirectEvalExpression") } + createDirectEvalExpression(callee: Expression, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation, optional_arg: boolean, parserStatus: number): DirectEvalExpression { + return new DirectEvalExpression(global.generatedEs2panda._CreateDirectEvalExpression(global.context, passNode(callee), passNodeArray(_arguments), argumentsLen, passNode(typeParams), optional_arg, parserStatus)) + } } export function isDirectEvalExpression(node: AstNode): node is DirectEvalExpression { return node instanceof DirectEvalExpression diff --git a/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts index 6f79904c4649b338f8ae982bb889b18065a1bf84..1b6225555dd7037b37a92baa2e0e0a44d80eeb23 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,9 +29,9 @@ import { LoopStatement } from "./LoopStatement" import { Statement } from "./Statement" import { Expression } from "./Expression" export class DoWhileStatement extends LoopStatement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 24) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 24) + super(pointer) console.warn("Warning: stub node DoWhileStatement") } get bodyConst(): Statement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts index f6e3a517e57b4399a459b2c1bc3a8df9568c1d79..f1f0836e0c1e23dfcdb67fde9e426c369840535c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { Expression } from "./Expression" import { TypeNode } from "./TypeNode" export class ETSClassLiteral extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 70) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 70) + super(pointer) console.warn("Warning: stub node ETSClassLiteral") } get exprConst(): TypeNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts new file mode 100644 index 0000000000000000000000000000000000000000..56fe11d77a0e97d38ac873d9b4a53aa67407e6c9 --- /dev/null +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNodeArray, + assertValidPeer, + AstNode, + Es2pandaAstNodeType, + KNativePointer +} from "../../reexport-for-generated" + +import { ETSFunctionType } from "./ETSFunctionType" +export abstract class ETSDynamicFunctionType extends ETSFunctionType { + constructor(pointer: KNativePointer) { + super(pointer) + console.warn("Warning: stub node ETSDynamicFunctionType") + } +} +export function isETSDynamicFunctionType(node: AstNode): node is ETSDynamicFunctionType { + return node instanceof ETSDynamicFunctionType +} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts index 86bc28343efa6b5688cb482f4b13f50dc076aae8..d8fe47ad8f9668964b45de60c9bea2f327ad36e2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,44 +29,44 @@ import { TypeNode } from "./TypeNode" import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" import { Expression } from "./Expression" import { TSInterfaceDeclaration } from "./TSInterfaceDeclaration" -import { Es2pandaScriptFunctionFlags } from "../Es2pandaEnums" +import { Es2pandaScriptFunctionFlags } from "./../Es2pandaEnums" export class ETSFunctionType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 66) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 66) + super(pointer) console.warn("Warning: stub node ETSFunctionType") } - get irTypeParamsConst(): TSTypeParameterDeclaration { + get typeParamsConst(): TSTypeParameterDeclaration { return unpackNonNullableNode(global.generatedEs2panda._ETSFunctionTypeIrTypeParamsConst(global.context, this.peer)) } - get irTypeParams(): TSTypeParameterDeclaration { + get typeParams(): TSTypeParameterDeclaration { return unpackNonNullableNode(global.generatedEs2panda._ETSFunctionTypeIrTypeParams(global.context, this.peer)) } - get irParamsConst(): readonly Expression[] { + get paramsConst(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._ETSFunctionTypeIrParamsConst(global.context, this.peer)) } - get irReturnTypeConst(): TypeNode { + get returnTypeConst(): TypeNode { return unpackNonNullableNode(global.generatedEs2panda._ETSFunctionTypeIrReturnTypeConst(global.context, this.peer)) } - get irReturnType(): TypeNode { + get returnType(): TypeNode { return unpackNonNullableNode(global.generatedEs2panda._ETSFunctionTypeIrReturnType(global.context, this.peer)) } - get irFunctionalInterface(): TSInterfaceDeclaration { + get functionalInterface(): TSInterfaceDeclaration { return unpackNonNullableNode(global.generatedEs2panda._ETSFunctionTypeIrFunctionalInterface(global.context, this.peer)) } - get irFunctionalInterfaceConst(): TSInterfaceDeclaration { + get functionalInterfaceConst(): TSInterfaceDeclaration { return unpackNonNullableNode(global.generatedEs2panda._ETSFunctionTypeIrFunctionalInterfaceConst(global.context, this.peer)) } - get irFlags(): Es2pandaScriptFunctionFlags { + get flags(): Es2pandaScriptFunctionFlags { return global.generatedEs2panda._ETSFunctionTypeIrFlags(global.context, this.peer) } - get irIsThrowingConst(): boolean { + get isThrowingConst(): boolean { return global.generatedEs2panda._ETSFunctionTypeIrIsThrowingConst(global.context, this.peer) } - get irIsRethrowingConst(): boolean { + get isRethrowingConst(): boolean { return global.generatedEs2panda._ETSFunctionTypeIrIsRethrowingConst(global.context, this.peer) } - get irIsExtensionFunctionConst(): boolean { + get isExtensionFunctionConst(): boolean { return global.generatedEs2panda._ETSFunctionTypeIrIsExtensionFunctionConst(global.context, this.peer) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts index 580bab39c81c41b4f573eacc5e35b19981706518..d6c2bea5a1c1ad67bc3b5b2faf3abacde6d4385a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { ImportDeclaration } from "./ImportDeclaration" import { StringLiteral } from "./StringLiteral" export class ETSImportDeclaration extends ImportDeclaration { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 78) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 78) + super(pointer) console.warn("Warning: stub node ETSImportDeclaration") } get hasDeclConst(): boolean { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts index f3d77f5402f6fa9aa54521d070d4a92f1604a2dd..a7d84f0ee6100844222898b56380240820f7da4e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Expression } from "./Expression" import { CallExpression } from "./CallExpression" export class ETSLaunchExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 74) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 74) + super(pointer) console.warn("Warning: stub node ETSLaunchExpression") } + createETSLaunchExpression(expr: CallExpression): ETSLaunchExpression { + return new ETSLaunchExpression(global.generatedEs2panda._CreateETSLaunchExpression(global.context, passNode(expr))) + } get callConst(): CallExpression { return unpackNonNullableNode(global.generatedEs2panda._ETSLaunchExpressionCallConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts index 17a26ea2086c4e1a28b7fe38f82517e0af6d9307..94ec25eb617cc50744103cf811d729339d288101 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { BlockStatement } from "./BlockStatement" import { Identifier } from "./Identifier" export class ETSModule extends BlockStatement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 81) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 81) + super(pointer) console.warn("Warning: stub node ETSModule") } get ident(): Identifier { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts index ddd9f11cff18d3375fbdaf9765bc34bfe6afeab5..f6d6912e68d9b72602ced370d6ec3a36b8586dad 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { Expression } from "./Expression" import { TypeNode } from "./TypeNode" export class ETSNewArrayInstanceExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 75) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 75) + super(pointer) console.warn("Warning: stub node ETSNewArrayInstanceExpression") } get typeReference(): TypeNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts index f31e538ae26a4e3392abe0ae0b4c4e4101de9fb3..d5a48a5d1bac4e7bf01aaab6c5a6312c81d10a8f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class ETSNewClassInstanceExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 77) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 77) + super(pointer) console.warn("Warning: stub node ETSNewClassInstanceExpression") } + createETSNewClassInstanceExpression(typeReference: Expression, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression { + return new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression(global.context, passNode(typeReference), passNodeArray(_arguments), argumentsLen)) + } get getTypeRefConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._ETSNewClassInstanceExpressionGetTypeRefConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts index d09b97de5aabc445fcef2c929a8a6b380cfede58..f34f7c658eaa644d9c5b8eb2bc6461baec557cb3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { Expression } from "./Expression" import { TypeNode } from "./TypeNode" export class ETSNewMultiDimArrayInstanceExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 76) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 76) + super(pointer) console.warn("Warning: stub node ETSNewMultiDimArrayInstanceExpression") } get typeReference(): TypeNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts index f2553c1139c0cb2234f5cd752613be0c4f19b7b4..ad6ee013ec7dbc59dbb119c8f2bd6a517cdbdc69 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class ETSNullType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 62) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 62) + super(pointer) console.warn("Warning: stub node ETSNullType") } + createETSNullType(): ETSNullType { + return new ETSNullType(global.generatedEs2panda._CreateETSNullTypeIr(global.context)) + } } export function isETSNullType(node: AstNode): node is ETSNullType { return node instanceof ETSNullType diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts index 8c0898b4f5a0ef170985d4d9153714bd89cd24e2..f5c4c45d42b15166c9b83df93791cf036a86e2fb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,12 +26,16 @@ import { } from "../../reexport-for-generated" import { Statement } from "./Statement" +import { Expression } from "./Expression" export class ETSPackageDeclaration extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 69) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 69) + super(pointer) console.warn("Warning: stub node ETSPackageDeclaration") } + createETSPackageDeclaration(name: Expression): ETSPackageDeclaration { + return new ETSPackageDeclaration(global.generatedEs2panda._CreateETSPackageDeclaration(global.context, passNode(name))) + } } export function isETSPackageDeclaration(node: AstNode): node is ETSPackageDeclaration { return node instanceof ETSPackageDeclaration diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts index 43cbb38333e7f56e3c49ae7b914c1689332306d1..92d43d8c3d723424593f3a30b0ae12539335a627 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,9 +27,9 @@ import { import { Expression } from "./Expression" export class ETSParameterExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 79) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 79) + super(pointer) console.warn("Warning: stub node ETSParameterExpression") } get isDefaultConst(): boolean { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts index ca5ef8ef97cb7be54fd8bfdbf0c8aef982a93027..c771d687e414f29a9fe6cb8971b0259212612856 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,13 +26,16 @@ import { } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" -import { Es2pandaPrimitiveType } from "../Es2pandaEnums" +import { Es2pandaPrimitiveType } from "./../Es2pandaEnums" export class ETSPrimitiveType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 68) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 68) + super(pointer) console.warn("Warning: stub node ETSPrimitiveType") } + createETSPrimitiveType(type: Es2pandaPrimitiveType): ETSPrimitiveType { + return new ETSPrimitiveType(global.generatedEs2panda._CreateETSPrimitiveType(global.context, type)) + } get getPrimitiveTypeConst(): Es2pandaPrimitiveType { return global.generatedEs2panda._ETSPrimitiveTypeGetPrimitiveTypeConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts index 859c84e9f9ff084fcbcad83ee6d95b6815900a04..178ba7df087127e08d7d1e207c1e6eec0bf1d0a6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { Statement } from "./Statement" import { ETSImportDeclaration } from "./ETSImportDeclaration" export class ETSReExportDeclaration extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 57) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 57) + super(pointer) console.warn("Warning: stub node ETSReExportDeclaration") } get getETSImportDeclarationsConst(): ETSImportDeclaration { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts index b5fcfd84d6f467e1d8dfee489c74e10499f42ce0..95c829aa5585466b4f7025d502e9dbfc838b1257 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,12 +26,16 @@ import { } from "../../reexport-for-generated" import { ClassDeclaration } from "./ClassDeclaration" +import { ClassDefinition } from "./ClassDefinition" export class ETSStructDeclaration extends ClassDeclaration { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 83) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 83) + super(pointer) console.warn("Warning: stub node ETSStructDeclaration") } + createETSStructDeclaration(def: ClassDefinition): ETSStructDeclaration { + return new ETSStructDeclaration(global.generatedEs2panda._CreateETSStructDeclaration(global.context, passNode(def))) + } } export function isETSStructDeclaration(node: AstNode): node is ETSStructDeclaration { return node instanceof ETSStructDeclaration diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts index 26b898bde2d1b4810f0d0bf6930bcb9f65735b20..e5440c96a966bb5fa38797cd9da8ba081141512b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class ETSTuple extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 80) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 80) + super(pointer) console.warn("Warning: stub node ETSTuple") } + createETSTuple(): ETSTuple { + return new ETSTuple(global.generatedEs2panda._CreateETSTuple(global.context)) + } get getTupleSizeConst(): number { return global.generatedEs2panda._ETSTupleGetTupleSizeConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts index bcd62627255fdfe1458374db85ff7f1606c46e9d..42af7432fbf12fc7ba33ccdbd023bcd3a27eef2e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { TypeNode } from "./TypeNode" import { ETSTypeReferencePart } from "./ETSTypeReferencePart" export class ETSTypeReference extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 71) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 71) + super(pointer) console.warn("Warning: stub node ETSTypeReference") } + createETSTypeReference(part: ETSTypeReferencePart): ETSTypeReference { + return new ETSTypeReference(global.generatedEs2panda._CreateETSTypeReference(global.context, passNode(part))) + } get part(): ETSTypeReferencePart { return unpackNonNullableNode(global.generatedEs2panda._ETSTypeReferencePart(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts index 328b1d3f4daf36fc82de5bcefbb2f9303ee05042..2735585d1b547652961f21b7b0dc618f235671f6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,11 +29,14 @@ import { TypeNode } from "./TypeNode" import { Expression } from "./Expression" import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" export class ETSTypeReferencePart extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 72) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 72) + super(pointer) console.warn("Warning: stub node ETSTypeReferencePart") } + createETSTypeReferencePart(name: Expression, typeParams: TSTypeParameterInstantiation, prev: ETSTypeReferencePart): ETSTypeReferencePart { + return new ETSTypeReferencePart(global.generatedEs2panda._CreateETSTypeReferencePart(global.context, passNode(name), passNode(typeParams), passNode(prev))) + } get previous(): ETSTypeReferencePart { return unpackNonNullableNode(global.generatedEs2panda._ETSTypeReferencePartPrevious(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts index 0bd676408ff3d961db7d01fcf30ddc4c42193a27..609c63b89c5459e8126536d9f054fd76d04885f1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class ETSUndefinedType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 63) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 63) + super(pointer) console.warn("Warning: stub node ETSUndefinedType") } + createETSUndefinedType(): ETSUndefinedType { + return new ETSUndefinedType(global.generatedEs2panda._CreateETSUndefinedTypeIr(global.context)) + } } export function isETSUndefinedType(node: AstNode): node is ETSUndefinedType { return node instanceof ETSUndefinedType diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts index 8f54c2034b1832153bb0c0c38bb8aaf52fdae7d7..25fea681fb85044d7ad33af60df97ed119291545 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,12 +27,12 @@ import { import { TypeNode } from "./TypeNode" export class ETSUnionType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 73) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 73) + super(pointer) console.warn("Warning: stub node ETSUnionType") } - get irTypesConst(): readonly TypeNode[] { + get typesConst(): readonly TypeNode[] { return unpackNodeArray(global.generatedEs2panda._ETSUnionTypeIrTypesConst(global.context, this.peer)) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts index 7813c9e3726e5a64154bb689769fa94dde11066b..7d49600bdd162f2636d867eb7a0aa346ac4bb4cb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,12 +27,16 @@ import { import { TypeNode } from "./TypeNode" import { ETSTypeReference } from "./ETSTypeReference" +import { Es2pandaModifierFlags } from "./../Es2pandaEnums" export class ETSWildcardType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 67) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 67) + super(pointer) console.warn("Warning: stub node ETSWildcardType") } + createETSWildcardType(typeReference: ETSTypeReference, flags: Es2pandaModifierFlags): ETSWildcardType { + return new ETSWildcardType(global.generatedEs2panda._CreateETSWildcardType(global.context, passNode(typeReference), flags)) + } get typeReference(): ETSTypeReference { return unpackNonNullableNode(global.generatedEs2panda._ETSWildcardTypeTypeReference(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts index 25256380a86c51787c186153ab46d4654c8d9208..97d9b3f0ffc236259064a27a3c79195e7415a00f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Statement } from "./Statement" export class EmptyStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 25) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 25) + super(pointer) console.warn("Warning: stub node EmptyStatement") } + createEmptyStatement(): EmptyStatement { + return new EmptyStatement(global.generatedEs2panda._CreateEmptyStatement(global.context)) + } } export function isEmptyStatement(node: AstNode): node is EmptyStatement { return node instanceof EmptyStatement diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts index e8030b02da3e583b571b6ba2f1f14b0b8f6a9414..85c0886ecee973b261332f791c1540d3a6ee387f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,11 +29,14 @@ import { Statement } from "./Statement" import { StringLiteral } from "./StringLiteral" import { Identifier } from "./Identifier" export class ExportAllDeclaration extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 26) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 26) + super(pointer) console.warn("Warning: stub node ExportAllDeclaration") } + createExportAllDeclaration(source: StringLiteral, exported: Identifier): ExportAllDeclaration { + return new ExportAllDeclaration(global.generatedEs2panda._CreateExportAllDeclaration(global.context, passNode(source), passNode(exported))) + } get sourceConst(): StringLiteral { return unpackNonNullableNode(global.generatedEs2panda._ExportAllDeclarationSourceConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts index 3318ac7ffd57fc48c891d1dad5dee6d8a072d49d..9e73c61f3c488857dd5d35d87d32db4ab157bfa0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Statement } from "./Statement" export class ExportDefaultDeclaration extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 27) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 27) + super(pointer) console.warn("Warning: stub node ExportDefaultDeclaration") } + createExportDefaultDeclaration(decl: AstNode, exportEquals: boolean): ExportDefaultDeclaration { + return new ExportDefaultDeclaration(global.generatedEs2panda._CreateExportDefaultDeclaration(global.context, passNode(decl), exportEquals)) + } get decl(): AstNode { return unpackNonNullableNode(global.generatedEs2panda._ExportDefaultDeclarationDecl(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts index b4e8ecd03b5405bf0a9e49389b3ed5e94f391cbe..2cd3d3ff18fc33d4876d08eae7c1a618c0b34251 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,11 +29,14 @@ import { Statement } from "./Statement" import { StringLiteral } from "./StringLiteral" import { ExportSpecifier } from "./ExportSpecifier" export class ExportNamedDeclaration extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 28) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 28) + super(pointer) console.warn("Warning: stub node ExportNamedDeclaration") } + createExportNamedDeclaration(source: StringLiteral, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { + return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiersLen)) + } get declConst(): AstNode { return unpackNonNullableNode(global.generatedEs2panda._ExportNamedDeclarationDeclConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts index 3762ef53a7c54eab5a083a3c23f2fce8c664e3cc..43d3268c000f052db7e158d1a26e635f53e861da 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Identifier } from "./Identifier" export class ExportSpecifier extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 29) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 29) + super(pointer) console.warn("Warning: stub node ExportSpecifier") } + createExportSpecifier(local: Identifier, exported: Identifier): ExportSpecifier { + return new ExportSpecifier(global.generatedEs2panda._CreateExportSpecifier(global.context, passNode(local), passNode(exported))) + } get localConst(): Identifier { return unpackNonNullableNode(global.generatedEs2panda._ExportSpecifierLocalConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/Expression.ts b/arkoala-arkts/libarkts/src/generated/peers/Expression.ts index a0ed5db6e894029cf20da57870f7a52dded72419..3da37221a4dc59860ad2231e4024eed8c48e086a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Expression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Expression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,8 +27,8 @@ import { import { TypedAstNode } from "./TypedAstNode" export abstract class Expression extends TypedAstNode { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node Expression") } get isGroupedConst(): boolean { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts index 52e3df2220fa0dfda28feed62daf1aa9836948e0..a7a37b351a3931b249cf4b19ab0797cae5a3e102 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Expression } from "./Expression" export class ExpressionStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 30) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 30) + super(pointer) console.warn("Warning: stub node ExpressionStatement") } + createExpressionStatement(expr: Expression): ExpressionStatement { + return new ExpressionStatement(global.generatedEs2panda._CreateExpressionStatement(global.context, passNode(expr))) + } get getExpressionConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._ExpressionStatementGetExpressionConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts index f87776b5e61ec31a2220dc205467ebf7b9e02d21..dbd948c7e2c75e69a30dadadbc32cf9fc9c86948 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,9 +29,9 @@ import { LoopStatement } from "./LoopStatement" import { Expression } from "./Expression" import { Statement } from "./Statement" export class ForInStatement extends LoopStatement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 31) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 31) + super(pointer) console.warn("Warning: stub node ForInStatement") } get left(): AstNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts index 8623c8ae9ed7f7fa3c6365334ae672d29f6a2efe..ab86b5e6ad86475f5d395740a02c7ad56588a41a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,9 +29,9 @@ import { LoopStatement } from "./LoopStatement" import { Expression } from "./Expression" import { Statement } from "./Statement" export class ForOfStatement extends LoopStatement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 32) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 32) + super(pointer) console.warn("Warning: stub node ForOfStatement") } get left(): AstNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts index bf64460bfbb32f141db8378e82e9b64c8dbb1535..3be5ed0eeab21856050272255b3ae9a4818d4b38 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,9 +29,9 @@ import { LoopStatement } from "./LoopStatement" import { Expression } from "./Expression" import { Statement } from "./Statement" export class ForUpdateStatement extends LoopStatement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 33) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 33) + super(pointer) console.warn("Warning: stub node ForUpdateStatement") } get init(): AstNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/AstNode.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts similarity index 66% rename from arkoala-arkts/libarkts/src/generated/peers/AstNode.ts rename to arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts index 25a24324c7e2f72226f451388e96e3df47bb986f..ca69f5c8ff5969b2acd9ed86e8a2a4265976f44e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AstNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts @@ -16,11 +16,22 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, - Es2pandaMemberExpressionKind, + unpackNodeArray, assertValidPeer, AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" +import { ScriptFunction } from "./ScriptFunction" +export abstract class FunctionDecl extends ScriptFunction { + constructor(pointer: KNativePointer) { + super(pointer) + console.warn("Warning: stub node FunctionDecl") + } +} +export function isFunctionDecl(node: AstNode): node is FunctionDecl { + return node instanceof FunctionDecl +} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts index cf3ea6486bbfde76e9cdd818e1e986ede1c41f8d..fe6b7cc043102d080680fcc0e8bcd74ac6fb30d5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,12 +27,16 @@ import { import { Statement } from "./Statement" import { ScriptFunction } from "./ScriptFunction" +import { AnnotationUsage } from "./AnnotationUsage" export class FunctionDeclaration extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 34) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 34) + super(pointer) console.warn("Warning: stub node FunctionDeclaration") } + createFunctionDeclaration(func: ScriptFunction, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration { + return new FunctionDeclaration(global.generatedEs2panda._CreateFunctionDeclaration(global.context, passNode(func), passNodeArray(annotations), annotationsLen, isAnonymous)) + } get function(): ScriptFunction { return unpackNonNullableNode(global.generatedEs2panda._FunctionDeclarationFunction(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts index 69871b68ed853ebce006af350a52407930c277b4..6777295855d97f701682217fcbd9132adbb9cd0b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,11 +29,14 @@ import { Expression } from "./Expression" import { ScriptFunction } from "./ScriptFunction" import { Identifier } from "./Identifier" export class FunctionExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 35) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 35) + super(pointer) console.warn("Warning: stub node FunctionExpression") } + createFunctionExpression(func: ScriptFunction): FunctionExpression { + return new FunctionExpression(global.generatedEs2panda._CreateFunctionExpression(global.context, passNode(func))) + } get functionConst(): ScriptFunction { return unpackNonNullableNode(global.generatedEs2panda._FunctionExpressionFunctionConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts b/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts index b9d3426e3f3e1029fd3dc7fa51d2230d870d61fc..033bfd35fa0d52794ffd4ea827d1556d023b4f10 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { AnnotatedExpression } from "./AnnotatedExpression" import { Decorator } from "./Decorator" export class Identifier extends AnnotatedExpression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 36) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 36) + super(pointer) console.warn("Warning: stub node Identifier") } + createIdentifier(): Identifier { + return new Identifier(global.generatedEs2panda._CreateIdentifier(global.context)) + } get nameConst(): string { return global.generatedEs2panda._IdentifierNameConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts index 6483899a4a12a17f1e834639ed7722c94c54f495..fb22ed9b083e049b8c2ebb21fa4ecebb5d63bb1b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { Statement } from "./Statement" import { Expression } from "./Expression" export class IfStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 38) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 38) + super(pointer) console.warn("Warning: stub node IfStatement") } get testConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts index 8c5151e19e3a9dd4d0d48d9d883c88c15bf6e4d6..befe5b7c3b4d29ace677e66fcdbb268da7f3f8cb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,12 +27,16 @@ import { import { Statement } from "./Statement" import { StringLiteral } from "./StringLiteral" +import { Es2pandaImportKinds } from "./../Es2pandaEnums" export class ImportDeclaration extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 39) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 39) + super(pointer) console.warn("Warning: stub node ImportDeclaration") } + createImportDeclaration(source: StringLiteral, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration { + return new ImportDeclaration(global.generatedEs2panda._CreateImportDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiersLen, importKind)) + } get sourceConst(): StringLiteral { return unpackNonNullableNode(global.generatedEs2panda._ImportDeclarationSourceConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts index 632768068cb76b3eb72c6b68d73c55ad368e88cd..04b12af60f3384ef0068644b71d351e379774a26 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Identifier } from "./Identifier" export class ImportDefaultSpecifier extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 41) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 41) + super(pointer) console.warn("Warning: stub node ImportDefaultSpecifier") } + createImportDefaultSpecifier(local: Identifier): ImportDefaultSpecifier { + return new ImportDefaultSpecifier(global.generatedEs2panda._CreateImportDefaultSpecifier(global.context, passNode(local))) + } get localConst(): Identifier { return unpackNonNullableNode(global.generatedEs2panda._ImportDefaultSpecifierLocalConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts index cb9fadf3f7404bd11ea9c8a45a6639694c1d798b..6dea79c24d5084b323640473bcc40c7ae2f34e7e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class ImportExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 40) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 40) + super(pointer) console.warn("Warning: stub node ImportExpression") } + createImportExpression(source: Expression): ImportExpression { + return new ImportExpression(global.generatedEs2panda._CreateImportExpression(global.context, passNode(source))) + } get source(): Expression { return unpackNonNullableNode(global.generatedEs2panda._ImportExpressionSource(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts index 7091d4e013e7b98686669c383d8750612d843045..369343db169cbd84b9d294144c2bf9682547afa7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Identifier } from "./Identifier" export class ImportNamespaceSpecifier extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 42) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 42) + super(pointer) console.warn("Warning: stub node ImportNamespaceSpecifier") } + createImportNamespaceSpecifier(local: Identifier): ImportNamespaceSpecifier { + return new ImportNamespaceSpecifier(global.generatedEs2panda._CreateImportNamespaceSpecifier(global.context, passNode(local))) + } get local(): Identifier { return unpackNonNullableNode(global.generatedEs2panda._ImportNamespaceSpecifierLocal(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts index 6c99c031a4c2335656f7144e31da2a3e6eee26bf..7f3dc2071cecf9233c267ce8f2570fe7d455320b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Identifier } from "./Identifier" export class ImportSpecifier extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 43) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 43) + super(pointer) console.warn("Warning: stub node ImportSpecifier") } + createImportSpecifier(imported: Identifier, local: Identifier): ImportSpecifier { + return new ImportSpecifier(global.generatedEs2panda._CreateImportSpecifier(global.context, passNode(imported), passNode(local))) + } get imported(): Identifier { return unpackNonNullableNode(global.generatedEs2panda._ImportSpecifierImported(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts b/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts new file mode 100644 index 0000000000000000000000000000000000000000..6de64492322dae993f8210c24495fa70562c6dd2 --- /dev/null +++ b/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNodeArray, + assertValidPeer, + AstNode, + Es2pandaAstNodeType, + KNativePointer +} from "../../reexport-for-generated" + +import { TSInterfaceDeclaration } from "./TSInterfaceDeclaration" +export abstract class InterfaceDecl extends TSInterfaceDeclaration { + constructor(pointer: KNativePointer) { + super(pointer) + console.warn("Warning: stub node InterfaceDecl") + } +} +export function isInterfaceDecl(node: AstNode): node is InterfaceDecl { + return node instanceof InterfaceDecl +} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts index 5ad53f257cb5fca19169a82642b15b3b065a1bc3..a5e4043c288a67efb92ef9ecdb20efd63b2ce540 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { Statement } from "./Statement" import { Identifier } from "./Identifier" export class LabelledStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 44) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 44) + super(pointer) console.warn("Warning: stub node LabelledStatement") } get bodyConst(): Statement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/Literal.ts b/arkoala-arkts/libarkts/src/generated/peers/Literal.ts index ad0e9d2a2c3bfaeb5f4bffbd4614b5eaa8de196a..b1a3ed8b7f04914138048c3af5e1d93f6f8e0bae 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Literal.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Literal.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,8 +27,8 @@ import { import { Expression } from "./Expression" export abstract class Literal extends Expression { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node Literal") } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts index ccc2e37072f792af818a22c4e59055f2d007cb26..ece9429a3ac6c8e4058802106809b3a81dacb0e7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,8 +27,8 @@ import { import { Statement } from "./Statement" export abstract class LoopStatement extends Statement { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node LoopStatement") } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts index 297ebe5349b24597a0f5a03c2f00d9e17537e056..765543372f9d57cff6d3798157cedbef9730eb66 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,8 +27,8 @@ import { import { Expression } from "./Expression" export abstract class MaybeOptionalExpression extends Expression { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node MaybeOptionalExpression") } get isOptionalConst(): boolean { diff --git a/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts index 054bab1ae231d299761276a24bf445007031ac56..5a161cfa973bf7c66eddc19be7f0c30f0ccdb298 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,13 +27,16 @@ import { import { MaybeOptionalExpression } from "./MaybeOptionalExpression" import { Expression } from "./Expression" -import { Es2pandaMemberExpressionKind } from "../Es2pandaEnums" +import { Es2pandaMemberExpressionKind } from "./../Es2pandaEnums" export class MemberExpression extends MaybeOptionalExpression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 45) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 45) + super(pointer) console.warn("Warning: stub node MemberExpression") } + createMemberExpression(object_arg: Expression, property: Expression, 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)) + } get object(): Expression { return unpackNonNullableNode(global.generatedEs2panda._MemberExpressionObject(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts index b2ce596de326211846cc634ee08bb2a324f367c0..25f8bdc113278b4ef77af57e6886de25cf6a013e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,13 +26,16 @@ import { } from "../../reexport-for-generated" import { Expression } from "./Expression" -import { Es2pandaMetaPropertyKind } from "../Es2pandaEnums" +import { Es2pandaMetaPropertyKind } from "./../Es2pandaEnums" export class MetaProperty extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 46) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 46) + super(pointer) console.warn("Warning: stub node MetaProperty") } + createMetaProperty(kind: Es2pandaMetaPropertyKind): MetaProperty { + return new MetaProperty(global.generatedEs2panda._CreateMetaProperty(global.context, kind)) + } get kindConst(): Es2pandaMetaPropertyKind { return global.generatedEs2panda._MetaPropertyKindConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts b/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts index 3d2af3311ecf20efbfa256cb9fd4d31642055c1d..041332bbf7379a42795fb369774f534f240b6ac9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,13 +26,18 @@ import { } from "../../reexport-for-generated" import { ClassElement } from "./ClassElement" -import { Es2pandaMethodDefinitionKind } from "../Es2pandaEnums" +import { Es2pandaMethodDefinitionKind } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Es2pandaModifierFlags } from "./../Es2pandaEnums" export class MethodDefinition extends ClassElement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 47) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 47) + super(pointer) console.warn("Warning: stub node MethodDefinition") } + createMethodDefinition(kind: Es2pandaMethodDefinitionKind, key: Expression, value: Expression, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition { + return new MethodDefinition(global.generatedEs2panda._CreateMethodDefinition(global.context, kind, passNode(key), passNode(value), modifiers, isComputed)) + } get kindConst(): Es2pandaMethodDefinitionKind { return global.generatedEs2panda._MethodDefinitionKindConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts b/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts index 770278dc38bfcb6df12421ed064c5b8c51ed6665..9f526ed5094e47d257cf5e5f5a50663b261902bc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,11 +29,14 @@ import { TypeNode } from "./TypeNode" import { Identifier } from "./Identifier" import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" export class NamedType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 48) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 48) + super(pointer) console.warn("Warning: stub node NamedType") } + createNamedType(name: Identifier): NamedType { + return new NamedType(global.generatedEs2panda._CreateNamedType(global.context, passNode(name))) + } get nameConst(): Identifier { return unpackNonNullableNode(global.generatedEs2panda._NamedTypeNameConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts index 5f6f0e52b70dcb86f4db20b77b41bc2e00a93860..3b9102f74c75fe6d3c756e00ddac2444712c3b02 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class NewExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 49) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 49) + super(pointer) console.warn("Warning: stub node NewExpression") } + createNewExpression(callee: Expression, _arguments: readonly Expression[], argumentsLen: number): NewExpression { + return new NewExpression(global.generatedEs2panda._CreateNewExpression(global.context, passNode(callee), passNodeArray(_arguments), argumentsLen)) + } get calleeConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._NewExpressionCalleeConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts index c5b6aa846c0db8b7a431b9643e8248a9aeca4d81..8a5c36e4004b7b791bbef81fd7c2ce76ab395d5d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Literal } from "./Literal" export class NullLiteral extends Literal { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 50) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 50) + super(pointer) console.warn("Warning: stub node NullLiteral") } + createNullLiteral(): NullLiteral { + return new NullLiteral(global.generatedEs2panda._CreateNullLiteral(global.context)) + } } export function isNullLiteral(node: AstNode): node is NullLiteral { return node instanceof NullLiteral diff --git a/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts index 1fe84a9a436f1023fdb239682e6653a5c95418ae..ec7bbd5cc5102e5f11ff55c8b1459e9d306bc12a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,9 +27,9 @@ import { import { Literal } from "./Literal" export class NumberLiteral extends Literal { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 52) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 52) + super(pointer) console.warn("Warning: stub node NumberLiteral") } get strConst(): string { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts index 34ccfe29403b8d0db181bd6f3de8b3f8939e527c..36d126ffe2f1a5f9574a6562e9d395e88c2acdba 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,8 +29,8 @@ import { AnnotatedExpression } from "./AnnotatedExpression" import { Expression } from "./Expression" import { Decorator } from "./Decorator" export abstract class ObjectExpression extends AnnotatedExpression { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node ObjectExpression") } get propertiesConst(): readonly Expression[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts index 20e2c5b4196d8ccf45a57041efd57548001a3347..7bbba96071654d38485d567af793c3d14e731c0c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class OmittedExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 53) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 53) + super(pointer) console.warn("Warning: stub node OmittedExpression") } + createOmittedExpression(): OmittedExpression { + return new OmittedExpression(global.generatedEs2panda._CreateOmittedExpression(global.context)) + } } export function isOmittedExpression(node: AstNode): node is OmittedExpression { return node instanceof OmittedExpression diff --git a/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts b/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts index 86535e6a63924638dab2da86fc4efa805886a109..4567c567e8ef0c2b0e292e82a68283bef9053263 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,9 +27,9 @@ import { import { TypeNode } from "./TypeNode" export class OpaqueTypeNode extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 153) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 153) + super(pointer) console.warn("Warning: stub node OpaqueTypeNode") } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts index 1ba00f08973d78d21147b91da601f2762b7942d3..ec068ff08f9122101bee1926940677f4c4c643e0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { Expression } from "./Expression" import { TypeNode } from "./TypeNode" export class PrefixAssertionExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 54) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 54) + super(pointer) console.warn("Warning: stub node PrefixAssertionExpression") } get exprConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/Property.ts b/arkoala-arkts/libarkts/src/generated/peers/Property.ts index c16fc3614888304c971c59dd3d7caf064e241300..aad38ada602a0d97db9dc3e7d14ffbdc7d4ad796 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Property.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Property.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,13 +26,16 @@ import { } from "../../reexport-for-generated" import { Expression } from "./Expression" -import { Es2pandaPropertyKind } from "../Es2pandaEnums" +import { Es2pandaPropertyKind } from "./../Es2pandaEnums" export class Property extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 55) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 55) + super(pointer) console.warn("Warning: stub node Property") } + createProperty(key: Expression, value: Expression): Property { + return new Property(global.generatedEs2panda._CreateProperty(global.context, passNode(key), passNode(value))) + } get key(): Expression { return unpackNonNullableNode(global.generatedEs2panda._PropertyKey(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts index ee57539867b09ab47c006d6a36dcc0cda0fbde61..22541eace96acd043d5ff3d8c49225642d836f9e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,13 +26,16 @@ import { } from "../../reexport-for-generated" import { Literal } from "./Literal" -import { Es2pandaRegExpFlags } from "../Es2pandaEnums" +import { Es2pandaRegExpFlags } from "./../Es2pandaEnums" export class RegExpLiteral extends Literal { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 56) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 56) + super(pointer) console.warn("Warning: stub node RegExpLiteral") } + createRegExpLiteral(pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral { + return new RegExpLiteral(global.generatedEs2panda._CreateRegExpLiteral(global.context, pattern, flags, flagsStr)) + } get patternConst(): string { return global.generatedEs2panda._RegExpLiteralPatternConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts index f0066083fe63ca8e731dfcb379be683f064ac607..61368fb73d82cf57264ec884d0acd9bc44a15cad 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Expression } from "./Expression" export class ReturnStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 58) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 58) + super(pointer) console.warn("Warning: stub node ReturnStatement") } + createReturnStatement(): ReturnStatement { + return new ReturnStatement(global.generatedEs2panda._CreateReturnStatement(global.context)) + } get argument(): Expression { return unpackNonNullableNode(global.generatedEs2panda._ReturnStatementArgument(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts b/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts index 6a592f177c4eb21f94c8664854d09304c0ea8b30..f1e0289b41cd1705d325e07260f36dd829767212 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -29,11 +30,11 @@ import { Expression } from "./Expression" import { ReturnStatement } from "./ReturnStatement" import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" import { TypeNode } from "./TypeNode" -import { Es2pandaScriptFunctionFlags } from "../Es2pandaEnums" +import { Es2pandaScriptFunctionFlags } from "./../Es2pandaEnums" export class ScriptFunction extends AstNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 59) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 59) + super(pointer) console.warn("Warning: stub node ScriptFunction") } get idConst(): Identifier { diff --git a/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts index 959e627e4bb95c55423b3fd61972ae2f13d4f89f..fdf4b7033db5cd7f41edde01c9b731c78cf8c924 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class SequenceExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 60) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 60) + super(pointer) console.warn("Warning: stub node SequenceExpression") } + createSequenceExpression(sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression { + return new SequenceExpression(global.generatedEs2panda._CreateSequenceExpression(global.context, passNodeArray(sequence_arg), sequenceLen)) + } get sequenceConst(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._SequenceExpressionSequenceConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts b/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts index 0b3b311e2ae3f6b19f89ce65396f624b8fa4f5e2..548549815acaff0331311daa30c1266345038f7c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,8 +29,8 @@ import { AnnotatedExpression } from "./AnnotatedExpression" import { Expression } from "./Expression" import { Decorator } from "./Decorator" export abstract class SpreadElement extends AnnotatedExpression { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node SpreadElement") } get argumentConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/Statement.ts b/arkoala-arkts/libarkts/src/generated/peers/Statement.ts index 789f3d751345600838b5458945f17d61eccc19fa..b8d2f60453a3a789fc31c9820fa10f71eddf20a8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Statement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Statement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,8 +26,8 @@ import { } from "../../reexport-for-generated" export abstract class Statement extends AstNode { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node Statement") } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts index d141688f63592f25ac702ae17b60d69006001cb0..5499a5f498698f29803e4b3f5a85cacf92474c37 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,9 +27,9 @@ import { import { Literal } from "./Literal" export class StringLiteral extends Literal { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 61) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 61) + super(pointer) console.warn("Warning: stub node StringLiteral") } get strConst(): string { diff --git a/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts index 459eaa3f247a889756a797c0aa5ac25b5face9ca..dbd1bc85feff26a5c5572bdfdf20bee0b76d4388 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class SuperExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 82) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 82) + super(pointer) console.warn("Warning: stub node SuperExpression") } + createSuperExpression(): SuperExpression { + return new SuperExpression(global.generatedEs2panda._CreateSuperExpression(global.context)) + } } export function isSuperExpression(node: AstNode): node is SuperExpression { return node instanceof SuperExpression diff --git a/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts index 1bc3cad46e1eeb339acc47b146595a3f55573ab1..2b45262e6a99875025e522ecdd4e13b5857d6af2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { Statement } from "./Statement" import { Expression } from "./Expression" export class SwitchCaseStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 84) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 84) + super(pointer) console.warn("Warning: stub node SwitchCaseStatement") } get test(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts index c08190d10f806a88c38d7a931a526e6227b4d812..679277fa66b4e342899ba9cfba3349daa4bfbbef 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,11 +29,14 @@ import { Statement } from "./Statement" import { Expression } from "./Expression" import { SwitchCaseStatement } from "./SwitchCaseStatement" export class SwitchStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 85) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 85) + super(pointer) console.warn("Warning: stub node SwitchStatement") } + createSwitchStatement(discriminant: Expression, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement { + return new SwitchStatement(global.generatedEs2panda._CreateSwitchStatement(global.context, passNode(discriminant), passNodeArray(cases), casesLen)) + } get discriminantConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._SwitchStatementDiscriminantConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts index 987036db36aefede1bd1cbd9e5b5a28626aa0dd3..025f76aa6d4f2e76fc15f1e81eb92139d994cfd4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSAnyKeyword extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 90) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 90) + super(pointer) console.warn("Warning: stub node TSAnyKeyword") } + createTSAnyKeyword(): TSAnyKeyword { + return new TSAnyKeyword(global.generatedEs2panda._CreateTSAnyKeyword(global.context)) + } } export function isTSAnyKeyword(node: AstNode): node is TSAnyKeyword { return node instanceof TSAnyKeyword diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts index 7ba255ed0f0ac961f55674731b025546c68e6e86..d74eed9081e662354682739c469d45876056c0f2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,9 +27,9 @@ import { import { TypeNode } from "./TypeNode" export class TSArrayType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 101) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 101) + super(pointer) console.warn("Warning: stub node TSArrayType") } get elementTypeConst(): TypeNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts index bd6fa114f834332c01dbf787659c7d93e72aa919..93ecffd31a75a724badc9684f57a9eda49c6037e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { AnnotatedExpression } from "./AnnotatedExpression" import { Expression } from "./Expression" export class TSAsExpression extends AnnotatedExpression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 137) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 137) + super(pointer) console.warn("Warning: stub node TSAsExpression") } get exprConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts index 9d42f1a0c54f508f5a65bd41ee6e37bdb413190d..0eb4bc1c25a5ac8ea812bfa0a43b3a543c03d077 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSBigintKeyword extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 97) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 97) + super(pointer) console.warn("Warning: stub node TSBigintKeyword") } + createTSBigintKeyword(): TSBigintKeyword { + return new TSBigintKeyword(global.generatedEs2panda._CreateTSBigintKeyword(global.context)) + } } export function isTSBigintKeyword(node: AstNode): node is TSBigintKeyword { return node instanceof TSBigintKeyword diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts index 2b8e49a605e8c43b63193fc351e2b8b7f394f3e1..dbbb2d45bc99b487f3eb5b94d138272ac5a5cb39 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSBooleanKeyword extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 92) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 92) + super(pointer) console.warn("Warning: stub node TSBooleanKeyword") } + createTSBooleanKeyword(): TSBooleanKeyword { + return new TSBooleanKeyword(global.generatedEs2panda._CreateTSBooleanKeyword(global.context)) + } } export function isTSBooleanKeyword(node: AstNode): node is TSBooleanKeyword { return node instanceof TSBooleanKeyword diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts b/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts index 6f30db46332a84ab9f538700fbdece85d4d197db..3aa020694c73b04b3d0b6b415492ba016c08bd8e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Expression } from "./Expression" import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" export class TSClassImplements extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 138) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 138) + super(pointer) console.warn("Warning: stub node TSClassImplements") } + createTSClassImplements(expression: Expression, typeParameters: TSTypeParameterInstantiation): TSClassImplements { + return new TSClassImplements(global.generatedEs2panda._CreateTSClassImplements(global.context, passNode(expression), passNode(typeParameters))) + } get expr(): Expression { return unpackNonNullableNode(global.generatedEs2panda._TSClassImplementsExpr(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts index 680d13adde0e21708d51a5578d9afd0889d05a21..1485e80085db725d4cc862455707572665f3c6cf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { TypeNode } from "./TypeNode" import { Expression } from "./Expression" export class TSConditionalType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 110) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 110) + super(pointer) console.warn("Warning: stub node TSConditionalType") } + 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))) + } get checkTypeConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._TSConditionalTypeCheckTypeConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts index c54d3812ca280b709fa51ce1a47a05b66b2a1689..82d27b378ab281840be2ffc42e01e0b2f8225927 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,9 +29,9 @@ import { TypeNode } from "./TypeNode" import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" import { Expression } from "./Expression" export class TSConstructorType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 125) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 125) + super(pointer) console.warn("Warning: stub node TSConstructorType") } get typeParamsConst(): TSTypeParameterDeclaration { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts index 66dfd97cc553f93d8c19210d228f599650c33248..9efaff62308d762be2e0079031118fec48e5dd4e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -29,11 +30,14 @@ import { Identifier } from "./Identifier" import { ClassDefinition } from "./ClassDefinition" import { Decorator } from "./Decorator" export class TSEnumDeclaration extends TypedStatement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 86) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 86) + super(pointer) console.warn("Warning: stub node TSEnumDeclaration") } + createTSEnumDeclaration(key: Identifier, 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)) + } get keyConst(): Identifier { return unpackNonNullableNode(global.generatedEs2panda._TSEnumDeclarationKeyConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts b/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts index 82a4e3ae101f3ae8e788f17419aeba265dc2c28a..d0cd13ab517cae890739e1f575da710e0f89b50a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Expression } from "./Expression" export class TSEnumMember extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 87) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 87) + super(pointer) console.warn("Warning: stub node TSEnumMember") } + createTSEnumMember(key: Expression, init: Expression): TSEnumMember { + return new TSEnumMember(global.generatedEs2panda._CreateTSEnumMember(global.context, passNode(key), passNode(init))) + } get keyConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._TSEnumMemberKeyConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts b/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts index f85009f7eeed8bfa39d1766fdceb907909ce8e21..fb2f9566dd45e8925a97e322f95080feca3d7b2f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class TSExternalModuleReference extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 88) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 88) + super(pointer) console.warn("Warning: stub node TSExternalModuleReference") } + createTSExternalModuleReference(expr: Expression): TSExternalModuleReference { + return new TSExternalModuleReference(global.generatedEs2panda._CreateTSExternalModuleReference(global.context, passNode(expr))) + } get exprConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._TSExternalModuleReferenceExprConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts index 5010103e6053e80ef5f25718c2099545ee3be4a6..786f45c08edeeb405ed50d0dc500bb81d88e8be2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,9 +29,9 @@ import { TypeNode } from "./TypeNode" import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" import { Expression } from "./Expression" export class TSFunctionType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 124) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 124) + super(pointer) console.warn("Warning: stub node TSFunctionType") } get typeParamsConst(): TSTypeParameterDeclaration { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts index 56b7905d3e49cdf73ee82679e44c405d24308e49..9764c42bd7db932fa7f1e55b9bd76571d45e0da1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,11 +29,14 @@ import { Statement } from "./Statement" import { Identifier } from "./Identifier" import { Expression } from "./Expression" export class TSImportEqualsDeclaration extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 123) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 123) + super(pointer) console.warn("Warning: stub node TSImportEqualsDeclaration") } + createTSImportEqualsDeclaration(id: Identifier, moduleReference: Expression, isExport: boolean): TSImportEqualsDeclaration { + return new TSImportEqualsDeclaration(global.generatedEs2panda._CreateTSImportEqualsDeclaration(global.context, passNode(id), passNode(moduleReference), isExport)) + } get idConst(): Identifier { return unpackNonNullableNode(global.generatedEs2panda._TSImportEqualsDeclarationIdConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts index 0c772bebdb3d10fa01a6b19d0f703b0bece1db56..1b3357a6f04e157654c6c270902ca8776cc344d0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,11 +29,14 @@ import { TypeNode } from "./TypeNode" import { Expression } from "./Expression" import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" export class TSImportType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 111) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 111) + super(pointer) console.warn("Warning: stub node TSImportType") } + createTSImportType(param: Expression, typeParams: TSTypeParameterInstantiation, qualifier: Expression, isTypeof: boolean): TSImportType { + return new TSImportType(global.generatedEs2panda._CreateTSImportType(global.context, passNode(param), passNode(typeParams), passNode(qualifier), isTypeof)) + } get paramConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._TSImportTypeParamConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts index a9f75f97aed6b3a15641d93fb05a69b8abc1e451..912bf24e4f716092cd7cfd6ba38e2bea38cdab1c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,9 +29,9 @@ import { TypedAstNode } from "./TypedAstNode" import { Expression } from "./Expression" import { TypeNode } from "./TypeNode" export class TSIndexSignature extends TypedAstNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 135) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 135) + super(pointer) console.warn("Warning: stub node TSIndexSignature") } get paramConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts index 917a622c444ba99c96971a4ea952d0eef46ceb1b..125888f8dbfeaff7c68865063b59bb380278522f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,9 +27,9 @@ import { import { TypeNode } from "./TypeNode" export class TSIndexedAccessType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 129) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 129) + super(pointer) console.warn("Warning: stub node TSIndexedAccessType") } get objectTypeConst(): TypeNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts index 43d19b2f86650c5ab6db5cc451609ec193fd3a37..8927d601e3f63e1f2ee71e1009cc2dfd7f777964 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { TypeNode } from "./TypeNode" import { TSTypeParameter } from "./TSTypeParameter" export class TSInferType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 109) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 109) + super(pointer) console.warn("Warning: stub node TSInferType") } + createTSInferType(typeParam: TSTypeParameter): TSInferType { + return new TSInferType(global.generatedEs2panda._CreateTSInferType(global.context, passNode(typeParam))) + } get typeParamConst(): TSTypeParameter { return unpackNonNullableNode(global.generatedEs2panda._TSInferTypeTypeParamConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts index c8949565da34ddb2621972dedf28dd55465db87b..cff3cc78021c2a9cb25e3c575b173ecfee610665 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class TSInterfaceBody extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 131) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 131) + super(pointer) console.warn("Warning: stub node TSInterfaceBody") } + createTSInterfaceBody(body: readonly AstNode[], bodyLen: number): TSInterfaceBody { + return new TSInterfaceBody(global.generatedEs2panda._CreateTSInterfaceBody(global.context, passNodeArray(body), bodyLen)) + } get bodyPtr(): readonly AstNode[] { return unpackNodeArray(global.generatedEs2panda._TSInterfaceBodyBodyPtr(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts index 09c683a9f567bad261d8bcc2fbaef7c70956f4b3..3b24730ac36a1601a691c41f47594f731474e5b1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,18 +26,21 @@ import { } from "../../reexport-for-generated" import { TypedStatement } from "./TypedStatement" +import { TSInterfaceHeritage } from "./TSInterfaceHeritage" import { TSInterfaceBody } from "./TSInterfaceBody" import { Identifier } from "./Identifier" import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" -import { TSInterfaceHeritage } from "./TSInterfaceHeritage" import { Decorator } from "./Decorator" import { ClassDeclaration } from "./ClassDeclaration" export class TSInterfaceDeclaration extends TypedStatement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 130) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 130) + super(pointer) console.warn("Warning: stub node TSInterfaceDeclaration") } + createTSInterfaceDeclaration(_extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode, typeParams: AstNode, body: AstNode, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration { + return new TSInterfaceDeclaration(global.generatedEs2panda._CreateTSInterfaceDeclaration(global.context, passNodeArray(_extends), extendsLen, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal)) + } get body(): TSInterfaceBody { return unpackNonNullableNode(global.generatedEs2panda._TSInterfaceDeclarationBody(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts index 840f55b339b178af8f159db75517428fbd63396c..9035c38d78731d88257df897b568144c0a26cd4d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { Expression } from "./Expression" import { TypeNode } from "./TypeNode" export class TSInterfaceHeritage extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 132) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 132) + super(pointer) console.warn("Warning: stub node TSInterfaceHeritage") } get expr(): TypeNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts index 7aaad2d6b675629ce8a782fbf322161fb5d7c82d..75f2b5f6be5a2be2ff373a466c1d6f71182d9a30 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { TypeNode } from "./TypeNode" import { Expression } from "./Expression" export class TSIntersectionType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 112) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 112) + super(pointer) console.warn("Warning: stub node TSIntersectionType") } + createTSIntersectionType(types: readonly Expression[], typesLen: number): TSIntersectionType { + return new TSIntersectionType(global.generatedEs2panda._CreateTSIntersectionType(global.context, passNodeArray(types), typesLen)) + } get typesConst(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._TSIntersectionTypeTypesConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts index b59282ade24521675df2a16a215d7e2cdc3782ea..9b6ada3ee3b453ddbf2480090f5deccb1110886c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { TypeNode } from "./TypeNode" import { Expression } from "./Expression" export class TSLiteralType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 108) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 108) + super(pointer) console.warn("Warning: stub node TSLiteralType") } + createTSLiteralType(literal: Expression): TSLiteralType { + return new TSLiteralType(global.generatedEs2panda._CreateTSLiteralType(global.context, passNode(literal))) + } get literalConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._TSLiteralTypeLiteralConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts index 0b3b84b415c1987172e6bf18659f6ea1b594e6eb..1a03c22e020be8a055e9bc3ecfea3f9077f4fd6e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,11 @@ import { import { TypeNode } from "./TypeNode" import { TSTypeParameter } from "./TSTypeParameter" -import { Es2pandaMappedOption } from "../Es2pandaEnums" +import { Es2pandaMappedOption } from "./../Es2pandaEnums" export class TSMappedType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 113) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 113) + super(pointer) console.warn("Warning: stub node TSMappedType") } get typeParameter(): TSTypeParameter { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts index da161a47529c1bd3a697b9ad676c2a86a4d971e6..15470f9b57b5ce2161ba87ccd0a569031feb2f42 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,9 +29,9 @@ import { Expression } from "./Expression" import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" import { TypeNode } from "./TypeNode" export class TSMethodSignature extends AstNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 105) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 105) + super(pointer) console.warn("Warning: stub node TSMethodSignature") } get keyConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts b/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts index 309247011acadda70493b82a1ec488aac141e03b..5039de67188d5f87ef3e4249bd0ae444cdbf4069 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,9 +27,9 @@ import { import { Statement } from "./Statement" export class TSModuleBlock extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 114) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 114) + super(pointer) console.warn("Warning: stub node TSModuleBlock") } get statementsConst(): readonly Statement[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts index dd2e26c069c2a2273008b03e96f3876b6e4473d0..0e1de1933c2e741b825087e1dce5364d3292090c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { Statement } from "./Statement" import { Expression } from "./Expression" export class TSModuleDeclaration extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 122) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 122) + super(pointer) console.warn("Warning: stub node TSModuleDeclaration") } get nameConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts index 3c49c7687073b34916816099292b575a8d3b5b5f..fbde47caed5b9581086a1fc8024e426a21bf6c96 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { TypeNode } from "./TypeNode" import { Expression } from "./Expression" export class TSNamedTupleMember extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 134) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 134) + super(pointer) console.warn("Warning: stub node TSNamedTupleMember") } get labelConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts index 8137f5b8b545ab16a4740c83238bc41cbe39cd66..8b2ba92b2c2bd0cb71c79db672b2f52eb966bb81 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSNeverKeyword extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 98) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 98) + super(pointer) console.warn("Warning: stub node TSNeverKeyword") } + createTSNeverKeyword(): TSNeverKeyword { + return new TSNeverKeyword(global.generatedEs2panda._CreateTSNeverKeyword(global.context)) + } } export function isTSNeverKeyword(node: AstNode): node is TSNeverKeyword { return node instanceof TSNeverKeyword diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts index 106c4d03d9675f63d538d9c93e12f99cdd9fe27c..38b9b76f2472130a6b8a03c6bc766a1fbeb9adfe 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class TSNonNullExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 99) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 99) + super(pointer) console.warn("Warning: stub node TSNonNullExpression") } + createTSNonNullExpression(expr: Expression): TSNonNullExpression { + return new TSNonNullExpression(global.generatedEs2panda._CreateTSNonNullExpression(global.context, passNode(expr))) + } get exprConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._TSNonNullExpressionExprConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts index 81eeed0f2bc9366ac652692b73f775e5792c671b..9a433b19859dd235c0786a7b4ee3d4a45af132bd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSNullKeyword extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 100) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 100) + super(pointer) console.warn("Warning: stub node TSNullKeyword") } + createTSNullKeyword(): TSNullKeyword { + return new TSNullKeyword(global.generatedEs2panda._CreateTSNullKeyword(global.context)) + } } export function isTSNullKeyword(node: AstNode): node is TSNullKeyword { return node instanceof TSNullKeyword diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts index 7f2b430fb0754dec15756746ea065ff964e27be9..9e2bd39924f09e26cdff39c4728eedc63e99ba30 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSNumberKeyword extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 89) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 89) + super(pointer) console.warn("Warning: stub node TSNumberKeyword") } + createTSNumberKeyword(): TSNumberKeyword { + return new TSNumberKeyword(global.generatedEs2panda._CreateTSNumberKeyword(global.context)) + } } export function isTSNumberKeyword(node: AstNode): node is TSNumberKeyword { return node instanceof TSNumberKeyword diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts index f8b78ece16ecbda1ebd0a69ea3c5556cdc5246f9..aa088ba6fb08807d8dc5035265c368b149a67837 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSObjectKeyword extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 96) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 96) + super(pointer) console.warn("Warning: stub node TSObjectKeyword") } + createTSObjectKeyword(): TSObjectKeyword { + return new TSObjectKeyword(global.generatedEs2panda._CreateTSObjectKeyword(global.context)) + } } export function isTSObjectKeyword(node: AstNode): node is TSObjectKeyword { return node instanceof TSObjectKeyword diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts index ad9cc4930d2b2de529ed9b032589784f205a22c7..e3c78ee5cb8234d005acec2d98246e5339ccfcef 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,13 +26,16 @@ import { } from "../../reexport-for-generated" import { Expression } from "./Expression" -import { Es2pandaAccessibilityOption } from "../Es2pandaEnums" +import { Es2pandaAccessibilityOption } from "./../Es2pandaEnums" export class TSParameterProperty extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 121) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 121) + super(pointer) console.warn("Warning: stub node TSParameterProperty") } + createTSParameterProperty(accessibility: Es2pandaAccessibilityOption, parameter: Expression, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty { + return new TSParameterProperty(global.generatedEs2panda._CreateTSParameterProperty(global.context, accessibility, passNode(parameter), readonly_arg, isStatic, isExport)) + } get accessibilityConst(): Es2pandaAccessibilityOption { return global.generatedEs2panda._TSParameterPropertyAccessibilityConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts index da3abfc2eb407471ee42f862994917b2d8e5fdb9..630a0f34892f2286831eb96a1e4cf6a6b9bd43c5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { TypeNode } from "./TypeNode" import { Expression } from "./Expression" export class TSParenthesizedType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 107) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 107) + super(pointer) console.warn("Warning: stub node TSParenthesizedType") } get typeConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts index 617a8e834814c512600dc93ea3a29281a472c3ab..53971e57b432b8db91879725c347e541a71e5e11 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { AnnotatedAstNode } from "./AnnotatedAstNode" import { Expression } from "./Expression" export class TSPropertySignature extends AnnotatedAstNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 104) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 104) + super(pointer) console.warn("Warning: stub node TSPropertySignature") } get keyConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts b/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts index 807afca923da2123dbfcf7512be7aa591d0c0922..754a8f5f81e5d00b31f0b07ae5fa3f5210622972 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Expression } from "./Expression" import { Identifier } from "./Identifier" export class TSQualifiedName extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 128) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 128) + super(pointer) console.warn("Warning: stub node TSQualifiedName") } + createTSQualifiedName(left: Expression, right: Identifier): TSQualifiedName { + return new TSQualifiedName(global.generatedEs2panda._CreateTSQualifiedName(global.context, passNode(left), passNode(right))) + } get leftConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._TSQualifiedNameLeftConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts index 2b783ebd442497e3dfdac89cbf3820ec4998a1ea..7ae561905b2c1432a3ef65ebca7b7739a7e926bf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,11 +29,11 @@ import { TypedAstNode } from "./TypedAstNode" import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" import { Expression } from "./Expression" import { TypeNode } from "./TypeNode" -import { Es2pandaTSSignatureDeclarationKind } from "../Es2pandaEnums" +import { Es2pandaTSSignatureDeclarationKind } from "./../Es2pandaEnums" export class TSSignatureDeclaration extends TypedAstNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 106) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 106) + super(pointer) console.warn("Warning: stub node TSSignatureDeclaration") } get typeParamsConst(): TSTypeParameterDeclaration { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts index c7b5b560640346167859c343b8f8937e905c8a72..155d03c9aefaba10fb5b402bfdbde66d8d96eadd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSStringKeyword extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 91) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 91) + super(pointer) console.warn("Warning: stub node TSStringKeyword") } + createTSStringKeyword(): TSStringKeyword { + return new TSStringKeyword(global.generatedEs2panda._CreateTSStringKeyword(global.context)) + } } export function isTSStringKeyword(node: AstNode): node is TSStringKeyword { return node instanceof TSStringKeyword diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts index 5da8b8fb64c833636527513dd84b555c18b1f331..6ef443d5dcc30d223a46396d4a55c5fb2d1ed35f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSThisType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 115) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 115) + super(pointer) console.warn("Warning: stub node TSThisType") } + createTSThisType(): TSThisType { + return new TSThisType(global.generatedEs2panda._CreateTSThisType(global.context)) + } } export function isTSThisType(node: AstNode): node is TSThisType { return node instanceof TSThisType diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts index ba8463d7b07455de856f4b72ca9d6304d0b2a029..750e7684f561bd97797febac515114259c9e127c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,9 +27,9 @@ import { import { TypeNode } from "./TypeNode" export class TSTupleType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 133) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 133) + super(pointer) console.warn("Warning: stub node TSTupleType") } get elementTypeConst(): readonly TypeNode[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts index 4979409fffaa79b1122c33ff8fa6a001c99a6798..620cadd48dc3998e5076a153a7d0d9922525309b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -30,9 +31,9 @@ import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" import { Decorator } from "./Decorator" import { AnnotationUsage } from "./AnnotationUsage" export class TSTypeAliasDeclaration extends AnnotatedStatement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 126) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 126) + super(pointer) console.warn("Warning: stub node TSTypeAliasDeclaration") } get id(): Identifier { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts index c271159d629b1091dd1c6f8656fe51b86d9efa60..35116196b929358b779233c4377fd82bd1804445 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { AnnotatedExpression } from "./AnnotatedExpression" import { Expression } from "./Expression" export class TSTypeAssertion extends AnnotatedExpression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 139) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 139) + super(pointer) console.warn("Warning: stub node TSTypeAssertion") } get getExpressionConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts index fe25e06cc32d5932bdfe82091ef5a61e70f2b8fb..ae2465a627d3e5c835ce1f44dc1bb543613712cd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSTypeLiteral extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 103) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 103) + super(pointer) console.warn("Warning: stub node TSTypeLiteral") } + createTSTypeLiteral(members: readonly AstNode[], membersLen: number): TSTypeLiteral { + return new TSTypeLiteral(global.generatedEs2panda._CreateTSTypeLiteral(global.context, passNodeArray(members), membersLen)) + } get membersConst(): readonly AstNode[] { return unpackNodeArray(global.generatedEs2panda._TSTypeLiteralMembersConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts index b0097fe321cb290f037b31f5f2eeb4915643a5b9..9544941782a21eb2c3e25ed58d86748317a8bf48 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,9 +27,9 @@ import { import { TypeNode } from "./TypeNode" export class TSTypeOperator extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 116) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 116) + super(pointer) console.warn("Warning: stub node TSTypeOperator") } get typeConst(): TypeNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts index 88500798d2683af30d2b0729be159348d9096041..134adbcd2226d829853e211ebd01784d6d259f3f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,9 +29,9 @@ import { Expression } from "./Expression" import { Identifier } from "./Identifier" import { TypeNode } from "./TypeNode" export class TSTypeParameter extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 117) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 117) + super(pointer) console.warn("Warning: stub node TSTypeParameter") } get nameConst(): Identifier { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts index 38e91a413596708acce5507f673924c2e93b5f64..2d5122c6ccef5085f9d755d9c4007287928b37a5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Expression } from "./Expression" import { TSTypeParameter } from "./TSTypeParameter" export class TSTypeParameterDeclaration extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 118) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 118) + super(pointer) console.warn("Warning: stub node TSTypeParameterDeclaration") } + createTSTypeParameterDeclaration(params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration { + return new TSTypeParameterDeclaration(global.generatedEs2panda._CreateTSTypeParameterDeclaration(global.context, passNodeArray(params), paramsLen, requiredParams)) + } get paramsConst(): readonly TSTypeParameter[] { return unpackNodeArray(global.generatedEs2panda._TSTypeParameterDeclarationParamsConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts index cc4165a7265c9f8e0944cfaa651ec22afab7eedc..e05cbb8256268e2adef95af6afa11ba5467e099b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { Expression } from "./Expression" import { TypeNode } from "./TypeNode" export class TSTypeParameterInstantiation extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 119) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 119) + super(pointer) console.warn("Warning: stub node TSTypeParameterInstantiation") } get paramsConst(): readonly TypeNode[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts index 57b1e62d4199ad77406b874bd4b384eb0ceb6dc0..7a5e25ad9ce4eae00911b6deae0d9154f2ea9096 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,9 +28,9 @@ import { import { TypeNode } from "./TypeNode" import { Expression } from "./Expression" export class TSTypePredicate extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 120) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 120) + super(pointer) console.warn("Warning: stub node TSTypePredicate") } get parameterNameConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts index fcc741841131dadc30e065c1741c62856d2957a3..dcfd22545f3faaf08a15f4f6da4a0b3d7700baf7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { TypeNode } from "./TypeNode" import { Expression } from "./Expression" export class TSTypeQuery extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 136) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 136) + super(pointer) console.warn("Warning: stub node TSTypeQuery") } + createTSTypeQuery(exprName: Expression): TSTypeQuery { + return new TSTypeQuery(global.generatedEs2panda._CreateTSTypeQuery(global.context, passNode(exprName))) + } get exprNameConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._TSTypeQueryExprNameConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts index 174c128ca4246ac8b1ef277b0284b65e71b3c6d2..f238c4433a497071abbbaf85524c62296296e554 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,14 +26,17 @@ import { } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" -import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" import { Expression } from "./Expression" +import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" export class TSTypeReference extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 127) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 127) + super(pointer) console.warn("Warning: stub node TSTypeReference") } + createTSTypeReference(typeName: Expression, typeParams: TSTypeParameterInstantiation): TSTypeReference { + return new TSTypeReference(global.generatedEs2panda._CreateTSTypeReference(global.context, passNode(typeName), passNode(typeParams))) + } get typeParamsConst(): TSTypeParameterInstantiation { return unpackNonNullableNode(global.generatedEs2panda._TSTypeReferenceTypeParamsConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts index 10ecd6177ee6588286dbf3aac6c7dfde3a3fc26f..21436bd73e63c6bdab93a2ff901edaa5efde354f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSUndefinedKeyword extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 94) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 94) + super(pointer) console.warn("Warning: stub node TSUndefinedKeyword") } + createTSUndefinedKeyword(): TSUndefinedKeyword { + return new TSUndefinedKeyword(global.generatedEs2panda._CreateTSUndefinedKeyword(global.context)) + } } export function isTSUndefinedKeyword(node: AstNode): node is TSUndefinedKeyword { return node instanceof TSUndefinedKeyword diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts index 6063abe68e96532a9128c84ad59014ea38f0bab5..e10a50361aadd462731d61290bba4303e18e2793 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,9 +27,9 @@ import { import { TypeNode } from "./TypeNode" export class TSUnionType extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 102) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 102) + super(pointer) console.warn("Warning: stub node TSUnionType") } get typesConst(): readonly TypeNode[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts index a61391862b4f926b257e06cc4bf24073558f42f0..613e0c4f9dbc68e29d54da642b35630bb65f5718 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSUnknownKeyword extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 95) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 95) + super(pointer) console.warn("Warning: stub node TSUnknownKeyword") } + createTSUnknownKeyword(): TSUnknownKeyword { + return new TSUnknownKeyword(global.generatedEs2panda._CreateTSUnknownKeyword(global.context)) + } } export function isTSUnknownKeyword(node: AstNode): node is TSUnknownKeyword { return node instanceof TSUnknownKeyword diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts index 33ab79df5facd3113cfd512eb9a75128ed117412..63d16ac0454caea7b805f8adb8492fdec0402d19 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { TypeNode } from "./TypeNode" export class TSVoidKeyword extends TypeNode { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 93) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 93) + super(pointer) console.warn("Warning: stub node TSVoidKeyword") } + createTSVoidKeyword(): TSVoidKeyword { + return new TSVoidKeyword(global.generatedEs2panda._CreateTSVoidKeyword(global.context)) + } } export function isTSVoidKeyword(node: AstNode): node is TSVoidKeyword { return node instanceof TSVoidKeyword diff --git a/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts index 1e4f4487032897894f8568c84392c2eae5c3c52d..f80a1bbb4257006a660be69459f1abb358a3cfa2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,11 +29,14 @@ import { Expression } from "./Expression" import { TemplateLiteral } from "./TemplateLiteral" import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" export class TaggedTemplateExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 140) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 140) + super(pointer) console.warn("Warning: stub node TaggedTemplateExpression") } + createTaggedTemplateExpression(tag: Expression, quasi: TemplateLiteral, typeParams: TSTypeParameterInstantiation): TaggedTemplateExpression { + return new TaggedTemplateExpression(global.generatedEs2panda._CreateTaggedTemplateExpression(global.context, passNode(tag), passNode(quasi), passNode(typeParams))) + } get tagConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._TaggedTemplateExpressionTagConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts b/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts index d16fa61efa30181524ee007ada12a6491a8b89f4..ac043b066583267de8f511ebc6322da2389a2019 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class TemplateElement extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 141) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 141) + super(pointer) console.warn("Warning: stub node TemplateElement") } + createTemplateElement(): TemplateElement { + return new TemplateElement(global.generatedEs2panda._CreateTemplateElement(global.context)) + } get rawConst(): string { return global.generatedEs2panda._TemplateElementRawConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts index cdb9c9b4d484f9aea5b8f2de356bac381cd79db2..8fb612e9d91e5ef7a1e74170744537c065d0be40 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Expression } from "./Expression" import { TemplateElement } from "./TemplateElement" export class TemplateLiteral extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 142) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 142) + super(pointer) console.warn("Warning: stub node TemplateLiteral") } + 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)) + } get quasisConst(): readonly TemplateElement[] { return unpackNodeArray(global.generatedEs2panda._TemplateLiteralQuasisConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts index 67e7e081410eb5f8e97c5d2ed50bd747bf15ab45..32a46cc29073052e65d826a32975c1ab1859cc66 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class ThisExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 143) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 143) + super(pointer) console.warn("Warning: stub node ThisExpression") } + createThisExpression(): ThisExpression { + return new ThisExpression(global.generatedEs2panda._CreateThisExpression(global.context)) + } } export function isThisExpression(node: AstNode): node is ThisExpression { return node instanceof ThisExpression diff --git a/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts index 5ba4424fd4ee73d384fe6d7a7ddc9fc44438e33f..5fbccef94ccb2f2f0d68e7442ae7e8ec5ad83784 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -27,11 +28,14 @@ import { import { Statement } from "./Statement" import { Expression } from "./Expression" export class ThrowStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 145) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 145) + super(pointer) console.warn("Warning: stub node ThrowStatement") } + createThrowStatement(argument: Expression): ThrowStatement { + return new ThrowStatement(global.generatedEs2panda._CreateThrowStatement(global.context, passNode(argument))) + } get argumentConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._ThrowStatementArgumentConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts index 65704e8895332088d42ceba46b48e5e386f4488d..3115086be9b15db4e64c31e8b144509681db63a6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,9 +29,9 @@ import { Statement } from "./Statement" import { BlockStatement } from "./BlockStatement" import { CatchClause } from "./CatchClause" export class TryStatement extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 146) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 146) + super(pointer) console.warn("Warning: stub node TryStatement") } get finallyBlockConst(): BlockStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts b/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts index 736dd98d484b0fd65b1001951a2884132427410e..62b0197909ef6b5d0ea83a4a42f2bd74d87c04fb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,8 +27,8 @@ import { import { Expression } from "./Expression" export abstract class TypeNode extends Expression { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node TypeNode") } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts b/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts index 863222e67d7f4c5fb7e45e01bfb90e3d25c87216..09a07affcf8c6fa04a42a8f3d0deb81cb1297e49 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,8 +26,8 @@ import { } from "../../reexport-for-generated" export abstract class TypedAstNode extends AstNode { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node TypedAstNode") } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts index 5c39cd2349b5905807527e0048b18804dd1d649e..ae56ef7494891fa3485bbf920e57a5c66d0079ac 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,8 +27,8 @@ import { import { Statement } from "./Statement" export abstract class TypedStatement extends Statement { - constructor(peer: KNativePointer) { - super(peer) + constructor(pointer: KNativePointer) { + super(pointer) console.warn("Warning: stub node TypedStatement") } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts index 20713dea29f433af8f9f3d6fef8214daadb1e519..de4136c3f6bece56faf64a1aa418d3b1cc392ce0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class TypeofExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 144) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 144) + super(pointer) console.warn("Warning: stub node TypeofExpression") } + createTypeofExpression(argument: Expression): TypeofExpression { + return new TypeofExpression(global.generatedEs2panda._CreateTypeofExpression(global.context, passNode(argument))) + } get argumentConst(): Expression { return unpackNonNullableNode(global.generatedEs2panda._TypeofExpressionArgumentConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts index 914942aeb94e03f1b2562de7bb6e8ae69986f9f9..5276f30348e3c1aae2092da57f31de6e0696a4c2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,13 +26,16 @@ import { } from "../../reexport-for-generated" import { Expression } from "./Expression" -import { Es2pandaTokenType } from "../Es2pandaEnums" +import { Es2pandaTokenType } from "./../Es2pandaEnums" export class UnaryExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 147) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 147) + super(pointer) console.warn("Warning: stub node UnaryExpression") } + createUnaryExpression(argument: Expression, unaryOperator: Es2pandaTokenType): UnaryExpression { + return new UnaryExpression(global.generatedEs2panda._CreateUnaryExpression(global.context, passNode(argument), unaryOperator)) + } get operatorTypeConst(): Es2pandaTokenType { return global.generatedEs2panda._UnaryExpressionOperatorTypeConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts index d2c0ec2dd128caec25a2a6570596164b742bc67e..cd187d5d83008442600922b8d309d95c05463e28 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Literal } from "./Literal" export class UndefinedLiteral extends Literal { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 51) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 51) + super(pointer) console.warn("Warning: stub node UndefinedLiteral") } + createUndefinedLiteral(): UndefinedLiteral { + return new UndefinedLiteral(global.generatedEs2panda._CreateUndefinedLiteral(global.context)) + } } export function isUndefinedLiteral(node: AstNode): node is UndefinedLiteral { return node instanceof UndefinedLiteral diff --git a/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts index 48279e1b5a1a4a2af24fedc4c7bf07c01340ede8..2cba43e09c63044a7d83dc560c1f76d2db4e38ac 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,13 +26,16 @@ import { } from "../../reexport-for-generated" import { Expression } from "./Expression" -import { Es2pandaTokenType } from "../Es2pandaEnums" +import { Es2pandaTokenType } from "./../Es2pandaEnums" export class UpdateExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 148) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 148) + super(pointer) console.warn("Warning: stub node UpdateExpression") } + createUpdateExpression(argument: Expression, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression { + return new UpdateExpression(global.generatedEs2panda._CreateUpdateExpression(global.context, passNode(argument), updateOperator, isPrefix)) + } get operatorTypeConst(): Es2pandaTokenType { return global.generatedEs2panda._UpdateExpressionOperatorTypeConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts index 118bd911016d7ae4b3697a80e6e77ef18821d9e3..87cf0212d465242f00dca82b2aacd488b042ff07 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,15 +26,18 @@ import { } from "../../reexport-for-generated" import { Statement } from "./Statement" +import { Es2pandaVariableDeclarationKind } from "./../Es2pandaEnums" import { VariableDeclarator } from "./VariableDeclarator" -import { Es2pandaVariableDeclarationKind } from "../Es2pandaEnums" import { Decorator } from "./Decorator" export class VariableDeclaration extends Statement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 149) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 149) + super(pointer) console.warn("Warning: stub node VariableDeclaration") } + createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration { + return new VariableDeclaration(global.generatedEs2panda._CreateVariableDeclaration(global.context, kind, passNodeArray(declarators), declaratorsLen)) + } get declaratorsConst(): readonly VariableDeclarator[] { return unpackNodeArray(global.generatedEs2panda._VariableDeclarationDeclaratorsConst(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts index e216e4faf3b6608ab9adc643972e097af46b9186..241c0f9a3489e38530afafe9bb829500f3d818cf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -25,14 +26,17 @@ import { } from "../../reexport-for-generated" import { TypedStatement } from "./TypedStatement" +import { Es2pandaVariableDeclaratorFlag } from "./../Es2pandaEnums" import { Expression } from "./Expression" -import { Es2pandaVariableDeclaratorFlag } from "../Es2pandaEnums" export class VariableDeclarator extends TypedStatement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 150) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 150) + super(pointer) console.warn("Warning: stub node VariableDeclarator") } + createVariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident: Expression): VariableDeclarator { + return new VariableDeclarator(global.generatedEs2panda._CreateVariableDeclarator(global.context, flag, passNode(ident))) + } get init(): Expression { return unpackNonNullableNode(global.generatedEs2panda._VariableDeclaratorInit(global.context, this.peer)) } diff --git a/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts index 930b1669ead405000ff60b6395f54487749d7fe4..119c184f71a3e4a60792575d57555b4a048b08a2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -28,9 +29,9 @@ import { LoopStatement } from "./LoopStatement" import { Expression } from "./Expression" import { Statement } from "./Statement" export class WhileStatement extends LoopStatement { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 151) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 151) + super(pointer) console.warn("Warning: stub node WhileStatement") } get testConst(): Expression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts index 252abfc161d303a43f1c74ed40d1172958d1ed68..7180446b7ea9dab6252b99a5319f7a05cb196093 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts @@ -16,6 +16,7 @@ import { global, passNode, + passNodeArray, unpackNonNullableNode, unpackNodeArray, assertValidPeer, @@ -26,11 +27,14 @@ import { import { Expression } from "./Expression" export class YieldExpression extends Expression { - constructor(peer: KNativePointer) { - assertValidPeer(peer, 152) - super(peer) + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, 152) + super(pointer) console.warn("Warning: stub node YieldExpression") } + createYieldExpression(argument: Expression, isDelegate: boolean): YieldExpression { + return new YieldExpression(global.generatedEs2panda._CreateYieldExpression(global.context, passNode(argument), isDelegate)) + } get hasDelegateConst(): boolean { return global.generatedEs2panda._YieldExpressionHasDelegateConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/reexport-for-generated.ts b/arkoala-arkts/libarkts/src/reexport-for-generated.ts index fa96736a133f0ed0d89e9351abdcc32e2d2e6019..274fa339132543a6bcacac9b03e0197fd86dfb22 100644 --- a/arkoala-arkts/libarkts/src/reexport-for-generated.ts +++ b/arkoala-arkts/libarkts/src/reexport-for-generated.ts @@ -16,7 +16,7 @@ export { KNativePointer } from "@koalaui/interop" export { Es2pandaAstNodeType } from "./Es2pandaEnums" export { assertValidPeer } from "./arkts-api//types" -export { passNode, unpackNonNullableNode, unpackNodeArray } from "./arkts-api/utilities/private" +export { passNode, unpackNonNullableNode, unpackNodeArray, passNodeArray } from "./arkts-api/utilities/private" export { global } from "./arkts-api/static/global" export { Es2pandaMemberExpressionKind } from "./generated/Es2pandaEnums" export { AstNode } from "./arkts-api/peers/AstNode"