From 912dfeefb760bbfeedb018ef56923437b5269721 Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Tue, 18 Feb 2025 10:40:55 +0300 Subject: [PATCH 1/3] reexport Signed-off-by: naumovdmitrii --- arkoala-arkts/libarkts/src/reexport-for-generated.ts | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/arkoala-arkts/libarkts/src/reexport-for-generated.ts b/arkoala-arkts/libarkts/src/reexport-for-generated.ts index 274fa3391..4fc36e327 100644 --- a/arkoala-arkts/libarkts/src/reexport-for-generated.ts +++ b/arkoala-arkts/libarkts/src/reexport-for-generated.ts @@ -16,8 +16,16 @@ export { KNativePointer } from "@koalaui/interop" export { Es2pandaAstNodeType } from "./Es2pandaEnums" export { assertValidPeer } from "./arkts-api//types" -export { passNode, unpackNonNullableNode, unpackNodeArray, passNodeArray } from "./arkts-api/utilities/private" +export { + passNode, + unpackNonNullableNode, + unpackNodeArray, + passNodeArray, + unpackNode, + unpackNonNullableObject, + unpackString, + unpackObject +} from "./arkts-api/utilities/private" export { global } from "./arkts-api/static/global" export { Es2pandaMemberExpressionKind } from "./generated/Es2pandaEnums" export { AstNode } from "./arkts-api/peers/AstNode" -export { MemberExpression } from "./arkts-api/to-be-generated/MemberExpression" \ No newline at end of file -- Gitee From 9a8ee46958aada2cee3c4ca70c3b058ebca9f0fe Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Tue, 18 Feb 2025 10:42:01 +0300 Subject: [PATCH 2/3] fix import Signed-off-by: naumovdmitrii --- arkoala-arkts/libarkts/src/arkts-api/visitor.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arkoala-arkts/libarkts/src/arkts-api/visitor.ts b/arkoala-arkts/libarkts/src/arkts-api/visitor.ts index 0e0121e9e..f114ccef7 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/visitor.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/visitor.ts @@ -34,7 +34,7 @@ import { } from "../generated/Es2pandaEnums" import { nullptr } from "@koalaui/interop" import { AstNode } from "./peers/AstNode" -import { MemberExpression } from "../reexport-for-generated" +import { MemberExpression } from "./to-be-generated/MemberExpression" type Visitor = (node: AstNode) => AstNode -- Gitee From 9e0a372a84abb030dfab905852ad1171c036920f Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Tue, 18 Feb 2025 10:43:10 +0300 Subject: [PATCH 3/3] nullable Signed-off-by: naumovdmitrii --- .../src/generated/peers/AnnotatedAstNode.ts | 1 + .../generated/peers/AnnotatedExpression.ts | 5 +- .../src/generated/peers/AnnotatedStatement.ts | 1 + .../generated/peers/AnnotationDeclaration.ts | 17 +++--- .../src/generated/peers/AnnotationUsage.ts | 13 +++-- .../src/generated/peers/ArrayExpression.ts | 5 +- .../peers/ArrowFunctionExpression.ts | 17 +++--- .../src/generated/peers/AssertStatement.ts | 17 +++--- .../generated/peers/AssignmentExpression.ts | 25 ++++---- .../src/generated/peers/AwaitExpression.ts | 9 +-- .../src/generated/peers/BigIntLiteral.ts | 5 +- .../src/generated/peers/BinaryExpression.ts | 29 +++++----- .../src/generated/peers/BlockExpression.ts | 1 + .../src/generated/peers/BlockStatement.ts | 1 + .../src/generated/peers/BooleanLiteral.ts | 5 +- .../src/generated/peers/BreakStatement.ts | 21 +++---- .../src/generated/peers/CallExpression.ts | 27 ++++----- .../src/generated/peers/CatchClause.ts | 21 +++---- .../src/generated/peers/ChainExpression.ts | 13 +++-- .../src/generated/peers/CharLiteral.ts | 5 +- .../src/generated/peers/ClassDeclaration.ts | 13 +++-- .../src/generated/peers/ClassDefinition.ts | 57 ++++++++++--------- .../src/generated/peers/ClassElement.ts | 17 +++--- .../src/generated/peers/ClassExpression.ts | 9 +-- .../src/generated/peers/ClassProperty.ts | 9 +-- .../src/generated/peers/ClassStaticBlock.ts | 5 +- .../generated/peers/ConditionalExpression.ts | 29 +++++----- .../src/generated/peers/ContinueStatement.ts | 21 +++---- .../src/generated/peers/DebuggerStatement.ts | 5 +- .../libarkts/src/generated/peers/Decorator.ts | 9 +-- .../generated/peers/DirectEvalExpression.ts | 5 +- .../src/generated/peers/DoWhileStatement.ts | 17 +++--- .../src/generated/peers/ETSClassLiteral.ts | 9 +-- .../generated/peers/ETSDynamicFunctionType.ts | 1 + .../src/generated/peers/ETSFunctionType.ts | 25 ++++---- .../generated/peers/ETSImportDeclaration.ts | 13 +++-- .../generated/peers/ETSLaunchExpression.ts | 9 +-- .../libarkts/src/generated/peers/ETSModule.ts | 9 +-- .../peers/ETSNewArrayInstanceExpression.ts | 21 +++---- .../peers/ETSNewClassInstanceExpression.ts | 13 +++-- .../ETSNewMultiDimArrayInstanceExpression.ts | 17 +++--- .../src/generated/peers/ETSNullType.ts | 5 +- .../generated/peers/ETSPackageDeclaration.ts | 5 +- .../generated/peers/ETSParameterExpression.ts | 5 +- .../src/generated/peers/ETSPrimitiveType.ts | 5 +- .../generated/peers/ETSReExportDeclaration.ts | 9 +-- .../generated/peers/ETSStructDeclaration.ts | 5 +- .../libarkts/src/generated/peers/ETSTuple.ts | 13 +++-- .../src/generated/peers/ETSTypeReference.ts | 13 +++-- .../generated/peers/ETSTypeReferencePart.ts | 29 +++++----- .../src/generated/peers/ETSUndefinedType.ts | 5 +- .../src/generated/peers/ETSUnionType.ts | 5 +- .../src/generated/peers/ETSWildcardType.ts | 13 +++-- .../src/generated/peers/EmptyStatement.ts | 5 +- .../generated/peers/ExportAllDeclaration.ts | 13 +++-- .../peers/ExportDefaultDeclaration.ts | 13 +++-- .../generated/peers/ExportNamedDeclaration.ts | 21 +++---- .../src/generated/peers/ExportSpecifier.ts | 13 +++-- .../src/generated/peers/Expression.ts | 1 + .../generated/peers/ExpressionStatement.ts | 13 +++-- .../src/generated/peers/ForInStatement.ts | 25 ++++---- .../src/generated/peers/ForOfStatement.ts | 25 ++++---- .../src/generated/peers/ForUpdateStatement.ts | 29 +++++----- .../src/generated/peers/FunctionDecl.ts | 1 + .../generated/peers/FunctionDeclaration.ts | 17 +++--- .../src/generated/peers/FunctionExpression.ts | 21 +++---- .../src/generated/peers/Identifier.ts | 17 +++--- .../src/generated/peers/IfStatement.ts | 25 ++++---- .../src/generated/peers/ImportDeclaration.ts | 13 +++-- .../generated/peers/ImportDefaultSpecifier.ts | 13 +++-- .../src/generated/peers/ImportExpression.ts | 13 +++-- .../peers/ImportNamespaceSpecifier.ts | 13 +++-- .../src/generated/peers/ImportSpecifier.ts | 21 +++---- .../src/generated/peers/InterfaceDecl.ts | 1 + .../src/generated/peers/LabelledStatement.ts | 13 +++-- .../libarkts/src/generated/peers/Literal.ts | 1 + .../src/generated/peers/LoopStatement.ts | 1 + .../peers/MaybeOptionalExpression.ts | 1 + .../src/generated/peers/MemberExpression.ts | 21 +++---- .../src/generated/peers/MetaProperty.ts | 5 +- .../src/generated/peers/MethodDefinition.ts | 21 +++---- .../libarkts/src/generated/peers/NamedType.ts | 13 +++-- .../src/generated/peers/NewExpression.ts | 9 +-- .../src/generated/peers/NullLiteral.ts | 5 +- .../src/generated/peers/NumberLiteral.ts | 1 + .../src/generated/peers/ObjectExpression.ts | 5 +- .../src/generated/peers/OmittedExpression.ts | 5 +- .../src/generated/peers/OpaqueTypeNode.ts | 5 +- .../peers/PrefixAssertionExpression.ts | 13 +++-- .../libarkts/src/generated/peers/Property.ts | 25 ++++---- .../src/generated/peers/RegExpLiteral.ts | 5 +- .../src/generated/peers/ReturnStatement.ts | 17 +++--- .../src/generated/peers/ScriptFunction.ts | 33 +++++------ .../src/generated/peers/SequenceExpression.ts | 5 +- .../src/generated/peers/SpreadElement.ts | 13 +++-- .../libarkts/src/generated/peers/Statement.ts | 1 + .../src/generated/peers/StringLiteral.ts | 7 ++- .../src/generated/peers/SuperExpression.ts | 5 +- .../generated/peers/SwitchCaseStatement.ts | 9 +-- .../src/generated/peers/SwitchStatement.ts | 13 +++-- .../src/generated/peers/TSAnyKeyword.ts | 5 +- .../src/generated/peers/TSArrayType.ts | 9 +-- .../src/generated/peers/TSAsExpression.ts | 13 +++-- .../src/generated/peers/TSBigintKeyword.ts | 5 +- .../src/generated/peers/TSBooleanKeyword.ts | 5 +- .../src/generated/peers/TSClassImplements.ts | 21 +++---- .../src/generated/peers/TSConditionalType.ts | 21 +++---- .../src/generated/peers/TSConstructorType.ts | 17 +++--- .../src/generated/peers/TSEnumDeclaration.ts | 17 +++--- .../src/generated/peers/TSEnumMember.ts | 25 ++++---- .../peers/TSExternalModuleReference.ts | 9 +-- .../src/generated/peers/TSFunctionType.ts | 17 +++--- .../peers/TSImportEqualsDeclaration.ts | 13 +++-- .../src/generated/peers/TSImportType.ts | 17 +++--- .../src/generated/peers/TSIndexSignature.ts | 13 +++-- .../generated/peers/TSIndexedAccessType.ts | 13 +++-- .../src/generated/peers/TSInferType.ts | 9 +-- .../src/generated/peers/TSInterfaceBody.ts | 5 +- .../generated/peers/TSInterfaceDeclaration.ts | 37 ++++++------ .../generated/peers/TSInterfaceHeritage.ts | 13 +++-- .../src/generated/peers/TSIntersectionType.ts | 5 +- .../src/generated/peers/TSLiteralType.ts | 9 +-- .../src/generated/peers/TSMappedType.ts | 13 +++-- .../src/generated/peers/TSMethodSignature.ts | 25 ++++---- .../src/generated/peers/TSModuleBlock.ts | 1 + .../generated/peers/TSModuleDeclaration.ts | 9 +-- .../src/generated/peers/TSNamedTupleMember.ts | 17 +++--- .../src/generated/peers/TSNeverKeyword.ts | 5 +- .../generated/peers/TSNonNullExpression.ts | 13 +++-- .../src/generated/peers/TSNullKeyword.ts | 5 +- .../src/generated/peers/TSNumberKeyword.ts | 5 +- .../src/generated/peers/TSObjectKeyword.ts | 5 +- .../generated/peers/TSParameterProperty.ts | 9 +-- .../generated/peers/TSParenthesizedType.ts | 9 +-- .../generated/peers/TSPropertySignature.ts | 17 +++--- .../src/generated/peers/TSQualifiedName.ts | 21 +++---- .../generated/peers/TSSignatureDeclaration.ts | 17 +++--- .../src/generated/peers/TSStringKeyword.ts | 5 +- .../src/generated/peers/TSThisType.ts | 5 +- .../src/generated/peers/TSTupleType.ts | 5 +- .../generated/peers/TSTypeAliasDeclaration.ts | 25 ++++---- .../src/generated/peers/TSTypeAssertion.ts | 13 +++-- .../src/generated/peers/TSTypeLiteral.ts | 5 +- .../src/generated/peers/TSTypeOperator.ts | 9 +-- .../src/generated/peers/TSTypeParameter.ts | 29 +++++----- .../peers/TSTypeParameterDeclaration.ts | 5 +- .../peers/TSTypeParameterInstantiation.ts | 5 +- .../src/generated/peers/TSTypePredicate.ts | 13 +++-- .../src/generated/peers/TSTypeQuery.ts | 9 +-- .../src/generated/peers/TSTypeReference.ts | 13 +++-- .../src/generated/peers/TSUndefinedKeyword.ts | 5 +- .../src/generated/peers/TSUnionType.ts | 5 +- .../src/generated/peers/TSUnknownKeyword.ts | 5 +- .../src/generated/peers/TSVoidKeyword.ts | 5 +- .../peers/TaggedTemplateExpression.ts | 17 +++--- .../src/generated/peers/TemplateElement.ts | 9 +-- .../src/generated/peers/TemplateLiteral.ts | 5 +- .../src/generated/peers/ThisExpression.ts | 5 +- .../src/generated/peers/ThrowStatement.ts | 9 +-- .../src/generated/peers/TryStatement.ts | 9 +-- .../libarkts/src/generated/peers/TypeNode.ts | 1 + .../src/generated/peers/TypedAstNode.ts | 1 + .../src/generated/peers/TypedStatement.ts | 1 + .../src/generated/peers/TypeofExpression.ts | 9 +-- .../src/generated/peers/UnaryExpression.ts | 13 +++-- .../src/generated/peers/UndefinedLiteral.ts | 5 +- .../src/generated/peers/UpdateExpression.ts | 13 +++-- .../generated/peers/VariableDeclaration.ts | 5 +- .../src/generated/peers/VariableDeclarator.ts | 25 ++++---- .../src/generated/peers/WhileStatement.ts | 17 +++--- .../src/generated/peers/YieldExpression.ts | 9 +-- 171 files changed, 1091 insertions(+), 920 deletions(-) diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts index 70875a74e..07b9fbc43 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts index 10fc1fc5f..e6bdfee72 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,8 +33,8 @@ export abstract class AnnotatedExpression extends Expression { super(pointer) console.warn("Warning: stub node AnnotatedExpression") } - get typeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._AnnotatedExpressionTypeAnnotationConst(global.context, this.peer)) + get typeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._AnnotatedExpressionTypeAnnotationConst(global.context, this.peer)) } } export function isAnnotatedExpression(node: AstNode): node is AnnotatedExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts index 387cd8557..171ecd625 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts index a5cf8ce4a..aad6adc04 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,26 +34,26 @@ export class AnnotationDeclaration extends Statement { super(pointer) console.warn("Warning: stub node AnnotationDeclaration") } - static createAnnotationDeclaration(expr: Expression): AnnotationDeclaration { + static createAnnotationDeclaration(expr?: Expression): AnnotationDeclaration | undefined { return new AnnotationDeclaration(global.generatedEs2panda._CreateAnnotationDeclaration(global.context, passNode(expr))) } - static updateAnnotationDeclaration(original: AnnotationDeclaration, expr: Expression): AnnotationDeclaration { + static updateAnnotationDeclaration(original?: AnnotationDeclaration, expr?: Expression): AnnotationDeclaration | undefined { return new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration(global.context, passNode(original), passNode(expr))) } - static create1AnnotationDeclaration(expr: Expression, properties: readonly AstNode[], propertiesLen: number): AnnotationDeclaration { + static create1AnnotationDeclaration(expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationDeclaration | undefined { return new AnnotationDeclaration(global.generatedEs2panda._CreateAnnotationDeclaration1(global.context, passNode(expr), passNodeArray(properties), propertiesLen)) } - static update1AnnotationDeclaration(original: AnnotationDeclaration, expr: Expression, properties: readonly AstNode[], propertiesLen: number): AnnotationDeclaration { + static update1AnnotationDeclaration(original: AnnotationDeclaration | undefined, expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationDeclaration | undefined { return new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration1(global.context, passNode(original), passNode(expr), passNodeArray(properties), propertiesLen)) } get internalNameConst(): string { return global.generatedEs2panda._AnnotationDeclarationInternalNameConst(global.context, this.peer) } - get exprConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AnnotationDeclarationExprConst(global.context, this.peer)) + get exprConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AnnotationDeclarationExprConst(global.context, this.peer)) } - get expr(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AnnotationDeclarationExpr(global.context, this.peer)) + get expr(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AnnotationDeclarationExpr(global.context, this.peer)) } get properties(): readonly AstNode[] { return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationProperties(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 9540b3743..326159dd1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,20 +34,20 @@ export class AnnotationUsage extends Statement { super(pointer) console.warn("Warning: stub node AnnotationUsage") } - static createAnnotationUsage(expr: Expression): AnnotationUsage { + static createAnnotationUsage(expr?: Expression): AnnotationUsage | undefined { return new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsageIr(global.context, passNode(expr))) } - static updateAnnotationUsage(original: AnnotationUsage, expr: Expression): AnnotationUsage { + static updateAnnotationUsage(original?: AnnotationUsage, expr?: Expression): AnnotationUsage | undefined { return new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsageIr(global.context, passNode(original), passNode(expr))) } - static create1AnnotationUsage(expr: Expression, properties: readonly AstNode[], propertiesLen: number): AnnotationUsage { + static create1AnnotationUsage(expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationUsage | undefined { return new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsageIr1(global.context, passNode(expr), passNodeArray(properties), propertiesLen)) } - static update1AnnotationUsage(original: AnnotationUsage, expr: Expression, properties: readonly AstNode[], propertiesLen: number): AnnotationUsage { + static update1AnnotationUsage(original: AnnotationUsage | undefined, expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationUsage | undefined { return new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsageIr1(global.context, passNode(original), passNode(expr), passNodeArray(properties), propertiesLen)) } - get expr(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AnnotationUsageIrExpr(global.context, this.peer)) + get expr(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AnnotationUsageIrExpr(global.context, this.peer)) } get properties(): readonly AstNode[] { return unpackNodeArray(global.generatedEs2panda._AnnotationUsageIrProperties(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 c796cec81..56113fd26 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -49,8 +50,8 @@ export abstract class ArrayExpression extends AnnotatedExpression { get decoratorsConst(): readonly Decorator[] { return unpackNodeArray(global.generatedEs2panda._ArrayExpressionDecoratorsConst(global.context, this.peer)) } - get typeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._ArrayExpressionTypeAnnotationConst(global.context, this.peer)) + get typeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ArrayExpressionTypeAnnotationConst(global.context, this.peer)) } } export function isArrayExpression(node: AstNode): node is ArrayExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts index 07063bafb..2e6d050e7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,23 +35,23 @@ export class ArrowFunctionExpression extends Expression { super(pointer) console.warn("Warning: stub node ArrowFunctionExpression") } - static createArrowFunctionExpression(func: ScriptFunction): ArrowFunctionExpression { + static createArrowFunctionExpression(func?: ScriptFunction): ArrowFunctionExpression | undefined { return new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression(global.context, passNode(func))) } - static updateArrowFunctionExpression(original: ArrowFunctionExpression, func: ScriptFunction): ArrowFunctionExpression { + static updateArrowFunctionExpression(original?: ArrowFunctionExpression, func?: ScriptFunction): ArrowFunctionExpression | undefined { return new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression(global.context, passNode(original), passNode(func))) } - static create1ArrowFunctionExpression(other: ArrowFunctionExpression): ArrowFunctionExpression { + static create1ArrowFunctionExpression(other?: ArrowFunctionExpression): ArrowFunctionExpression | undefined { return new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression1(global.context, passNode(other))) } - static update1ArrowFunctionExpression(original: ArrowFunctionExpression, other: ArrowFunctionExpression): ArrowFunctionExpression { + static update1ArrowFunctionExpression(original?: ArrowFunctionExpression, other?: ArrowFunctionExpression): ArrowFunctionExpression | undefined { return new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression1(global.context, passNode(original), passNode(other))) } - get functionConst(): ScriptFunction { - return unpackNonNullableNode(global.generatedEs2panda._ArrowFunctionExpressionFunctionConst(global.context, this.peer)) + get functionConst(): ScriptFunction | undefined { + return unpackNode(global.generatedEs2panda._ArrowFunctionExpressionFunctionConst(global.context, this.peer)) } - get function(): ScriptFunction { - return unpackNonNullableNode(global.generatedEs2panda._ArrowFunctionExpressionFunction(global.context, this.peer)) + get function(): ScriptFunction | undefined { + return unpackNode(global.generatedEs2panda._ArrowFunctionExpressionFunction(global.context, this.peer)) } get annotations(): readonly AnnotationUsage[] { return unpackNodeArray(global.generatedEs2panda._ArrowFunctionExpressionAnnotations(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 84532cce6..b21e36baf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,20 +34,20 @@ export class AssertStatement extends Statement { super(pointer) console.warn("Warning: stub node AssertStatement") } - static createAssertStatement(test: Expression, second: Expression): AssertStatement { + static createAssertStatement(test?: Expression, second?: Expression): AssertStatement | undefined { return new AssertStatement(global.generatedEs2panda._CreateAssertStatement(global.context, passNode(test), passNode(second))) } - static updateAssertStatement(original: AssertStatement, test: Expression, second: Expression): AssertStatement { + static updateAssertStatement(original?: AssertStatement, test?: Expression, second?: Expression): AssertStatement | undefined { return new AssertStatement(global.generatedEs2panda._UpdateAssertStatement(global.context, passNode(original), passNode(test), passNode(second))) } - get testConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AssertStatementTestConst(global.context, this.peer)) + get testConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssertStatementTestConst(global.context, this.peer)) } - get test(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AssertStatementTest(global.context, this.peer)) + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssertStatementTest(global.context, this.peer)) } - get secondConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AssertStatementSecondConst(global.context, this.peer)) + get secondConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssertStatementSecondConst(global.context, this.peer)) } } export function isAssertStatement(node: AstNode): node is AssertStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts index 6e5c88e09..84f10656d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,23 +33,23 @@ export abstract class AssignmentExpression extends Expression { super(pointer) console.warn("Warning: stub node AssignmentExpression") } - get leftConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AssignmentExpressionLeftConst(global.context, this.peer)) + get leftConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssignmentExpressionLeftConst(global.context, this.peer)) } - get left(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AssignmentExpressionLeft(global.context, this.peer)) + get left(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssignmentExpressionLeft(global.context, this.peer)) } - get right(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AssignmentExpressionRight(global.context, this.peer)) + get right(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssignmentExpressionRight(global.context, this.peer)) } - get rightConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AssignmentExpressionRightConst(global.context, this.peer)) + get rightConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssignmentExpressionRightConst(global.context, this.peer)) } - get resultConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AssignmentExpressionResultConst(global.context, this.peer)) + get resultConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssignmentExpressionResultConst(global.context, this.peer)) } - get result(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AssignmentExpressionResult(global.context, this.peer)) + get result(): Expression | undefined { + return unpackNode(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 b386dd389..e1981e7dc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,14 +33,14 @@ export class AwaitExpression extends Expression { super(pointer) console.warn("Warning: stub node AwaitExpression") } - static createAwaitExpression(argument: Expression): AwaitExpression { + static createAwaitExpression(argument?: Expression): AwaitExpression | undefined { return new AwaitExpression(global.generatedEs2panda._CreateAwaitExpression(global.context, passNode(argument))) } - static updateAwaitExpression(original: AwaitExpression, argument: Expression): AwaitExpression { + static updateAwaitExpression(original?: AwaitExpression, argument?: Expression): AwaitExpression | undefined { return new AwaitExpression(global.generatedEs2panda._UpdateAwaitExpression(global.context, passNode(original), passNode(argument))) } - get argumentConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._AwaitExpressionArgumentConst(global.context, this.peer)) + get argumentConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AwaitExpressionArgumentConst(global.context, this.peer)) } } export function isAwaitExpression(node: AstNode): node is AwaitExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts index 33e3ad477..1d6b844be 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class BigIntLiteral extends Literal { super(pointer) console.warn("Warning: stub node BigIntLiteral") } - static createBigIntLiteral(src: string): BigIntLiteral { + static createBigIntLiteral(src: string): BigIntLiteral | undefined { return new BigIntLiteral(global.generatedEs2panda._CreateBigIntLiteral(global.context, src)) } - static updateBigIntLiteral(original: BigIntLiteral, src: string): BigIntLiteral { + static updateBigIntLiteral(original: BigIntLiteral | undefined, src: string): BigIntLiteral | undefined { return new BigIntLiteral(global.generatedEs2panda._UpdateBigIntLiteral(global.context, passNode(original), src)) } get strConst(): string { diff --git a/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts index e5dd878a8..9a7460643 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,29 +34,29 @@ export class BinaryExpression extends Expression { super(pointer) console.warn("Warning: stub node BinaryExpression") } - static createBinaryExpression(left: Expression, right: Expression, operatorType: Es2pandaTokenType): BinaryExpression { + static createBinaryExpression(left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression | undefined { return new BinaryExpression(global.generatedEs2panda._CreateBinaryExpression(global.context, passNode(left), passNode(right), operatorType)) } - static updateBinaryExpression(original: BinaryExpression, left: Expression, right: Expression, operatorType: Es2pandaTokenType): BinaryExpression { + static updateBinaryExpression(original: BinaryExpression | undefined, left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression | undefined { return new BinaryExpression(global.generatedEs2panda._UpdateBinaryExpression(global.context, passNode(original), passNode(left), passNode(right), operatorType)) } - get leftConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._BinaryExpressionLeftConst(global.context, this.peer)) + get leftConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._BinaryExpressionLeftConst(global.context, this.peer)) } - get left(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._BinaryExpressionLeft(global.context, this.peer)) + get left(): Expression | undefined { + return unpackNode(global.generatedEs2panda._BinaryExpressionLeft(global.context, this.peer)) } - get rightConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._BinaryExpressionRightConst(global.context, this.peer)) + get rightConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._BinaryExpressionRightConst(global.context, this.peer)) } - get right(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._BinaryExpressionRight(global.context, this.peer)) + get right(): Expression | undefined { + return unpackNode(global.generatedEs2panda._BinaryExpressionRight(global.context, this.peer)) } - get resultConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._BinaryExpressionResultConst(global.context, this.peer)) + get resultConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._BinaryExpressionResultConst(global.context, this.peer)) } - get result(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._BinaryExpressionResult(global.context, this.peer)) + get result(): Expression | undefined { + return unpackNode(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 011893654..39d766831 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts index f1ed56f23..d6711fb04 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts index a84c6031e..9390b9ae6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class BooleanLiteral extends Literal { super(pointer) console.warn("Warning: stub node BooleanLiteral") } - static createBooleanLiteral(value: boolean): BooleanLiteral { + static createBooleanLiteral(value: boolean): BooleanLiteral | undefined { return new BooleanLiteral(global.generatedEs2panda._CreateBooleanLiteral(global.context, value)) } - static updateBooleanLiteral(original: BooleanLiteral, value: boolean): BooleanLiteral { + static updateBooleanLiteral(original: BooleanLiteral | undefined, value: boolean): BooleanLiteral | undefined { return new BooleanLiteral(global.generatedEs2panda._UpdateBooleanLiteral(global.context, passNode(original), value)) } get valueConst(): boolean { diff --git a/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts index f70e63cef..8fb8051b5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,26 +34,26 @@ export class BreakStatement extends Statement { super(pointer) console.warn("Warning: stub node BreakStatement") } - static createBreakStatement(): BreakStatement { + static createBreakStatement(): BreakStatement | undefined { return new BreakStatement(global.generatedEs2panda._CreateBreakStatement(global.context)) } - static updateBreakStatement(original: BreakStatement): BreakStatement { + static updateBreakStatement(original?: BreakStatement): BreakStatement | undefined { return new BreakStatement(global.generatedEs2panda._UpdateBreakStatement(global.context, passNode(original))) } - static create1BreakStatement(ident: Identifier): BreakStatement { + static create1BreakStatement(ident?: Identifier): BreakStatement | undefined { return new BreakStatement(global.generatedEs2panda._CreateBreakStatement1(global.context, passNode(ident))) } - static update1BreakStatement(original: BreakStatement, ident: Identifier): BreakStatement { + static update1BreakStatement(original?: BreakStatement, ident?: Identifier): BreakStatement | undefined { return new BreakStatement(global.generatedEs2panda._UpdateBreakStatement1(global.context, passNode(original), passNode(ident))) } - get identConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._BreakStatementIdentConst(global.context, this.peer)) + get identConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._BreakStatementIdentConst(global.context, this.peer)) } - get ident(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._BreakStatementIdent(global.context, this.peer)) + get ident(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._BreakStatementIdent(global.context, this.peer)) } - get targetConst(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._BreakStatementTargetConst(global.context, this.peer)) + get targetConst(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._BreakStatementTargetConst(global.context, this.peer)) } } export function isBreakStatement(node: AstNode): node is BreakStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts index aa64c4645..495b700fc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -35,26 +36,26 @@ export class CallExpression extends MaybeOptionalExpression { super(pointer) console.warn("Warning: stub node CallExpression") } - static createCallExpression(callee: Expression, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation, optional_arg: boolean, trailingComma: boolean): CallExpression { + static createCallExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, trailingComma: boolean): CallExpression | undefined { return new CallExpression(global.generatedEs2panda._CreateCallExpression(global.context, passNode(callee), passNodeArray(_arguments), argumentsLen, passNode(typeParams), optional_arg, trailingComma)) } - static create1CallExpression(other: CallExpression): CallExpression { + static create1CallExpression(other?: CallExpression): CallExpression | undefined { return new CallExpression(global.generatedEs2panda._CreateCallExpression1(global.context, passNode(other))) } - static update1CallExpression(original: CallExpression, other: CallExpression): CallExpression { + static update1CallExpression(original?: CallExpression, other?: CallExpression): CallExpression | undefined { return new CallExpression(global.generatedEs2panda._UpdateCallExpression1(global.context, passNode(original), passNode(other))) } - get calleeConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._CallExpressionCalleeConst(global.context, this.peer)) + get calleeConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._CallExpressionCalleeConst(global.context, this.peer)) } - get callee(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._CallExpressionCallee(global.context, this.peer)) + get callee(): Expression | undefined { + return unpackNode(global.generatedEs2panda._CallExpressionCallee(global.context, this.peer)) } - get typeParamsConst(): TSTypeParameterInstantiation { - return unpackNonNullableNode(global.generatedEs2panda._CallExpressionTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._CallExpressionTypeParamsConst(global.context, this.peer)) } - get typeParams(): TSTypeParameterInstantiation { - return unpackNonNullableNode(global.generatedEs2panda._CallExpressionTypeParams(global.context, this.peer)) + get typeParams(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._CallExpressionTypeParams(global.context, this.peer)) } get argumentsConst(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._CallExpressionArgumentsConst(global.context, this.peer)) @@ -65,8 +66,8 @@ export class CallExpression extends MaybeOptionalExpression { get hasTrailingCommaConst(): boolean { return global.generatedEs2panda._CallExpressionHasTrailingCommaConst(global.context, this.peer) } - get trailingBlockConst(): BlockStatement { - return unpackNonNullableNode(global.generatedEs2panda._CallExpressionTrailingBlockConst(global.context, this.peer)) + get trailingBlockConst(): BlockStatement | undefined { + return unpackNode(global.generatedEs2panda._CallExpressionTrailingBlockConst(global.context, this.peer)) } get isTrailingBlockInNewLineConst(): boolean { return global.generatedEs2panda._CallExpressionIsTrailingBlockInNewLineConst(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 57e462e5d..c22e26d92 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,23 +35,23 @@ export class CatchClause extends TypedStatement { super(pointer) console.warn("Warning: stub node CatchClause") } - static createCatchClause(param: Expression, body: BlockStatement): CatchClause { + static createCatchClause(param?: Expression, body?: BlockStatement): CatchClause | undefined { return new CatchClause(global.generatedEs2panda._CreateCatchClause(global.context, passNode(param), passNode(body))) } - static updateCatchClause(original: CatchClause, param: Expression, body: BlockStatement): CatchClause { + static updateCatchClause(original?: CatchClause, param?: Expression, body?: BlockStatement): CatchClause | undefined { return new CatchClause(global.generatedEs2panda._UpdateCatchClause(global.context, passNode(original), passNode(param), passNode(body))) } - get param(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._CatchClauseParam(global.context, this.peer)) + get param(): Expression | undefined { + return unpackNode(global.generatedEs2panda._CatchClauseParam(global.context, this.peer)) } - get paramConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._CatchClauseParamConst(global.context, this.peer)) + get paramConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._CatchClauseParamConst(global.context, this.peer)) } - get body(): BlockStatement { - return unpackNonNullableNode(global.generatedEs2panda._CatchClauseBody(global.context, this.peer)) + get body(): BlockStatement | undefined { + return unpackNode(global.generatedEs2panda._CatchClauseBody(global.context, this.peer)) } - get bodyConst(): BlockStatement { - return unpackNonNullableNode(global.generatedEs2panda._CatchClauseBodyConst(global.context, this.peer)) + get bodyConst(): BlockStatement | undefined { + return unpackNode(global.generatedEs2panda._CatchClauseBodyConst(global.context, this.peer)) } } export function isCatchClause(node: AstNode): node is CatchClause { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts index 24d7422ca..da0e9826c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,17 +33,17 @@ export class ChainExpression extends Expression { super(pointer) console.warn("Warning: stub node ChainExpression") } - static createChainExpression(expression: Expression): ChainExpression { + static createChainExpression(expression?: Expression): ChainExpression | undefined { return new ChainExpression(global.generatedEs2panda._CreateChainExpression(global.context, passNode(expression))) } - static updateChainExpression(original: ChainExpression, expression: Expression): ChainExpression { + static updateChainExpression(original?: ChainExpression, expression?: Expression): ChainExpression | undefined { return new ChainExpression(global.generatedEs2panda._UpdateChainExpression(global.context, passNode(original), passNode(expression))) } - get getExpressionConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ChainExpressionGetExpressionConst(global.context, this.peer)) + get getExpressionConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ChainExpressionGetExpressionConst(global.context, this.peer)) } - get getExpression(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ChainExpressionGetExpression(global.context, this.peer)) + get getExpression(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ChainExpressionGetExpression(global.context, this.peer)) } } export function isChainExpression(node: AstNode): node is ChainExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts index 11781c75e..73108082d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class CharLiteral extends Literal { super(pointer) console.warn("Warning: stub node CharLiteral") } - static createCharLiteral(): CharLiteral { + static createCharLiteral(): CharLiteral | undefined { return new CharLiteral(global.generatedEs2panda._CreateCharLiteral(global.context)) } - static updateCharLiteral(original: CharLiteral): CharLiteral { + static updateCharLiteral(original?: CharLiteral): CharLiteral | undefined { return new CharLiteral(global.generatedEs2panda._UpdateCharLiteral(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts index d9e679bc7..7a126b6cd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class ClassDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ClassDeclaration") } - static createClassDeclaration(def: ClassDefinition): ClassDeclaration { + static createClassDeclaration(def?: ClassDefinition): ClassDeclaration | undefined { return new ClassDeclaration(global.generatedEs2panda._CreateClassDeclaration(global.context, passNode(def))) } - static updateClassDeclaration(original: ClassDeclaration, def: ClassDefinition): ClassDeclaration { + static updateClassDeclaration(original?: ClassDeclaration, def?: ClassDefinition): ClassDeclaration | undefined { return new ClassDeclaration(global.generatedEs2panda._UpdateClassDeclaration(global.context, passNode(original), passNode(def))) } - get definition(): ClassDefinition { - return unpackNonNullableNode(global.generatedEs2panda._ClassDeclarationDefinition(global.context, this.peer)) + get definition(): ClassDefinition | undefined { + return unpackNode(global.generatedEs2panda._ClassDeclarationDefinition(global.context, this.peer)) } - get definitionConst(): ClassDefinition { - return unpackNonNullableNode(global.generatedEs2panda._ClassDeclarationDefinitionConst(global.context, this.peer)) + get definitionConst(): ClassDefinition | undefined { + return unpackNode(global.generatedEs2panda._ClassDeclarationDefinitionConst(global.context, this.peer)) } get decoratorsConst(): readonly Decorator[] { return unpackNodeArray(global.generatedEs2panda._ClassDeclarationDecoratorsConst(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 c14ce11f6..e46a32592 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -43,38 +44,38 @@ export class ClassDefinition extends TypedAstNode { super(pointer) console.warn("Warning: stub node ClassDefinition") } - static 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 { + static createClassDefinition(ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], implementsLen: number, ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { return new ClassDefinition(global.generatedEs2panda._CreateClassDefinition(global.context, passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), implementsLen, passNode(ctor), passNode(superClass), passNodeArray(body), bodyLen, modifiers, flags)) } - static updateClassDefinition(original: ClassDefinition, 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 { + static updateClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], implementsLen: number, ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { return new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition(global.context, passNode(original), passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), implementsLen, passNode(ctor), passNode(superClass), passNodeArray(body), bodyLen, modifiers, flags)) } - static create1ClassDefinition(ident: Identifier, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { + static create1ClassDefinition(ident: Identifier | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { return new ClassDefinition(global.generatedEs2panda._CreateClassDefinition1(global.context, passNode(ident), passNodeArray(body), bodyLen, modifiers, flags)) } - static update1ClassDefinition(original: ClassDefinition, ident: Identifier, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { + static update1ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { return new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition1(global.context, passNode(original), passNode(ident), passNodeArray(body), bodyLen, modifiers, flags)) } - static create2ClassDefinition(ident: Identifier, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { + static create2ClassDefinition(ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { return new ClassDefinition(global.generatedEs2panda._CreateClassDefinition2(global.context, passNode(ident), modifiers, flags)) } - static update2ClassDefinition(original: ClassDefinition, ident: Identifier, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { + static update2ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { return new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition2(global.context, passNode(original), passNode(ident), modifiers, flags)) } - get identConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ClassDefinitionIdentConst(global.context, this.peer)) + get identConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionIdentConst(global.context, this.peer)) } - get ident(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ClassDefinitionIdent(global.context, this.peer)) + get ident(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionIdent(global.context, this.peer)) } get internalNameConst(): string { return global.generatedEs2panda._ClassDefinitionInternalNameConst(global.context, this.peer) } - get super(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ClassDefinitionSuper(global.context, this.peer)) + get super(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionSuper(global.context, this.peer)) } - get superConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ClassDefinitionSuperConst(global.context, this.peer)) + get superConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionSuperConst(global.context, this.peer)) } get isGlobalConst(): boolean { return global.generatedEs2panda._ClassDefinitionIsGlobalConst(global.context, this.peer) @@ -115,8 +116,8 @@ export class ClassDefinition extends TypedAstNode { get bodyConst(): readonly AstNode[] { return unpackNodeArray(global.generatedEs2panda._ClassDefinitionBodyConst(global.context, this.peer)) } - get ctor(): MethodDefinition { - return unpackNonNullableNode(global.generatedEs2panda._ClassDefinitionCtor(global.context, this.peer)) + get ctor(): MethodDefinition | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionCtor(global.context, this.peer)) } get implements(): readonly TSClassImplements[] { return unpackNodeArray(global.generatedEs2panda._ClassDefinitionImplements(global.context, this.peer)) @@ -124,17 +125,17 @@ export class ClassDefinition extends TypedAstNode { get implementsConst(): readonly TSClassImplements[] { return unpackNodeArray(global.generatedEs2panda._ClassDefinitionImplementsConst(global.context, this.peer)) } - get typeParamsConst(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._ClassDefinitionTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionTypeParamsConst(global.context, this.peer)) } - get typeParams(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._ClassDefinitionTypeParams(global.context, this.peer)) + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionTypeParams(global.context, this.peer)) } - get superTypeParamsConst(): TSTypeParameterInstantiation { - return unpackNonNullableNode(global.generatedEs2panda._ClassDefinitionSuperTypeParamsConst(global.context, this.peer)) + get superTypeParamsConst(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionSuperTypeParamsConst(global.context, this.peer)) } - get superTypeParams(): TSTypeParameterInstantiation { - return unpackNonNullableNode(global.generatedEs2panda._ClassDefinitionSuperTypeParams(global.context, this.peer)) + get superTypeParams(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionSuperTypeParams(global.context, this.peer)) } get localTypeCounter(): number { return global.generatedEs2panda._ClassDefinitionLocalTypeCounter(global.context, this.peer) @@ -145,11 +146,11 @@ export class ClassDefinition extends TypedAstNode { get localPrefixConst(): string { return global.generatedEs2panda._ClassDefinitionLocalPrefixConst(global.context, this.peer) } - get origEnumDeclConst(): TSEnumDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._ClassDefinitionOrigEnumDeclConst(global.context, this.peer)) + get origEnumDeclConst(): TSEnumDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionOrigEnumDeclConst(global.context, this.peer)) } - get getAnonClass(): ClassDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._ClassDefinitionGetAnonClass(global.context, this.peer)) + get getAnonClass(): ClassDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionGetAnonClass(global.context, this.peer)) } get annotations(): readonly AnnotationUsage[] { return unpackNodeArray(global.generatedEs2panda._ClassDefinitionAnnotations(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 4dc4a2d54..f61e0aad0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,17 +34,17 @@ export abstract class ClassElement extends TypedStatement { super(pointer) console.warn("Warning: stub node ClassElement") } - get key(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ClassElementKey(global.context, this.peer)) + get key(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ClassElementKey(global.context, this.peer)) } - get keyConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ClassElementKeyConst(global.context, this.peer)) + get keyConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ClassElementKeyConst(global.context, this.peer)) } - get value(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ClassElementValue(global.context, this.peer)) + get value(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ClassElementValue(global.context, this.peer)) } - get valueConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ClassElementValueConst(global.context, this.peer)) + get valueConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ClassElementValueConst(global.context, this.peer)) } get decoratorsConst(): readonly Decorator[] { return unpackNodeArray(global.generatedEs2panda._ClassElementDecoratorsConst(global.context, this.peer)) diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts index 7981edc66..888be069f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,14 +34,14 @@ export class ClassExpression extends Expression { super(pointer) console.warn("Warning: stub node ClassExpression") } - static createClassExpression(def: ClassDefinition): ClassExpression { + static createClassExpression(def?: ClassDefinition): ClassExpression | undefined { return new ClassExpression(global.generatedEs2panda._CreateClassExpression(global.context, passNode(def))) } - static updateClassExpression(original: ClassExpression, def: ClassDefinition): ClassExpression { + static updateClassExpression(original?: ClassExpression, def?: ClassDefinition): ClassExpression | undefined { return new ClassExpression(global.generatedEs2panda._UpdateClassExpression(global.context, passNode(original), passNode(def))) } - get definitionConst(): ClassDefinition { - return unpackNonNullableNode(global.generatedEs2panda._ClassExpressionDefinitionConst(global.context, this.peer)) + get definitionConst(): ClassDefinition | undefined { + return unpackNode(global.generatedEs2panda._ClassExpressionDefinitionConst(global.context, this.peer)) } } export function isClassExpression(node: AstNode): node is ClassExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts index 52943eab0..65083a584 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -36,14 +37,14 @@ export class ClassProperty extends ClassElement { super(pointer) console.warn("Warning: stub node ClassProperty") } - static createClassProperty(key: Expression, value: Expression, typeAnnotation: TypeNode, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty { + static createClassProperty(key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty | undefined { return new ClassProperty(global.generatedEs2panda._CreateClassProperty(global.context, passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed)) } - static updateClassProperty(original: ClassProperty, key: Expression, value: Expression, typeAnnotation: TypeNode, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty { + static updateClassProperty(original: ClassProperty | undefined, key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty | undefined { return new ClassProperty(global.generatedEs2panda._UpdateClassProperty(global.context, passNode(original), passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed)) } - get typeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._ClassPropertyTypeAnnotationConst(global.context, this.peer)) + get typeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ClassPropertyTypeAnnotationConst(global.context, this.peer)) } get annotations(): readonly AnnotationUsage[] { return unpackNodeArray(global.generatedEs2panda._ClassPropertyAnnotations(global.context, this.peer)) diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts index cd45ddedb..880888735 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,10 +34,10 @@ export class ClassStaticBlock extends ClassElement { super(pointer) console.warn("Warning: stub node ClassStaticBlock") } - static createClassStaticBlock(value: Expression): ClassStaticBlock { + static createClassStaticBlock(value?: Expression): ClassStaticBlock | undefined { return new ClassStaticBlock(global.generatedEs2panda._CreateClassStaticBlock(global.context, passNode(value))) } - static updateClassStaticBlock(original: ClassStaticBlock, value: Expression): ClassStaticBlock { + static updateClassStaticBlock(original?: ClassStaticBlock, value?: Expression): ClassStaticBlock | undefined { return new ClassStaticBlock(global.generatedEs2panda._UpdateClassStaticBlock(global.context, passNode(original), passNode(value))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts index 09f94a47a..d92ad39b5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,29 +33,29 @@ export class ConditionalExpression extends Expression { super(pointer) console.warn("Warning: stub node ConditionalExpression") } - static createConditionalExpression(test: Expression, consequent: Expression, alternate: Expression): ConditionalExpression { + static createConditionalExpression(test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression | undefined { return new ConditionalExpression(global.generatedEs2panda._CreateConditionalExpression(global.context, passNode(test), passNode(consequent), passNode(alternate))) } - static updateConditionalExpression(original: ConditionalExpression, test: Expression, consequent: Expression, alternate: Expression): ConditionalExpression { + static updateConditionalExpression(original?: ConditionalExpression, test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression | undefined { return new ConditionalExpression(global.generatedEs2panda._UpdateConditionalExpression(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate))) } - get testConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ConditionalExpressionTestConst(global.context, this.peer)) + get testConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ConditionalExpressionTestConst(global.context, this.peer)) } - get test(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ConditionalExpressionTest(global.context, this.peer)) + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ConditionalExpressionTest(global.context, this.peer)) } - get consequentConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ConditionalExpressionConsequentConst(global.context, this.peer)) + get consequentConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ConditionalExpressionConsequentConst(global.context, this.peer)) } - get consequent(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ConditionalExpressionConsequent(global.context, this.peer)) + get consequent(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ConditionalExpressionConsequent(global.context, this.peer)) } - get alternateConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ConditionalExpressionAlternateConst(global.context, this.peer)) + get alternateConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ConditionalExpressionAlternateConst(global.context, this.peer)) } - get alternate(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ConditionalExpressionAlternate(global.context, this.peer)) + get alternate(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ConditionalExpressionAlternate(global.context, this.peer)) } } export function isConditionalExpression(node: AstNode): node is ConditionalExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts index ed8568f1b..51ad34eb0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,26 +34,26 @@ export class ContinueStatement extends Statement { super(pointer) console.warn("Warning: stub node ContinueStatement") } - static createContinueStatement(): ContinueStatement { + static createContinueStatement(): ContinueStatement | undefined { return new ContinueStatement(global.generatedEs2panda._CreateContinueStatement(global.context)) } - static updateContinueStatement(original: ContinueStatement): ContinueStatement { + static updateContinueStatement(original?: ContinueStatement): ContinueStatement | undefined { return new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement(global.context, passNode(original))) } - static create1ContinueStatement(ident: Identifier): ContinueStatement { + static create1ContinueStatement(ident?: Identifier): ContinueStatement | undefined { return new ContinueStatement(global.generatedEs2panda._CreateContinueStatement1(global.context, passNode(ident))) } - static update1ContinueStatement(original: ContinueStatement, ident: Identifier): ContinueStatement { + static update1ContinueStatement(original?: ContinueStatement, ident?: Identifier): ContinueStatement | undefined { return new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement1(global.context, passNode(original), passNode(ident))) } - get identConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ContinueStatementIdentConst(global.context, this.peer)) + get identConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ContinueStatementIdentConst(global.context, this.peer)) } - get ident(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ContinueStatementIdent(global.context, this.peer)) + get ident(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ContinueStatementIdent(global.context, this.peer)) } - get targetConst(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._ContinueStatementTargetConst(global.context, this.peer)) + get targetConst(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ContinueStatementTargetConst(global.context, this.peer)) } } export function isContinueStatement(node: AstNode): node is ContinueStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts index 5a914834f..b4f3c236a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class DebuggerStatement extends Statement { super(pointer) console.warn("Warning: stub node DebuggerStatement") } - static createDebuggerStatement(): DebuggerStatement { + static createDebuggerStatement(): DebuggerStatement | undefined { return new DebuggerStatement(global.generatedEs2panda._CreateDebuggerStatement(global.context)) } - static updateDebuggerStatement(original: DebuggerStatement): DebuggerStatement { + static updateDebuggerStatement(original?: DebuggerStatement): DebuggerStatement | undefined { return new DebuggerStatement(global.generatedEs2panda._UpdateDebuggerStatement(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts b/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts index 65d6c7f2a..87db27b5d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,14 +34,14 @@ export class Decorator extends Statement { super(pointer) console.warn("Warning: stub node Decorator") } - static createDecorator(expr: Expression): Decorator { + static createDecorator(expr?: Expression): Decorator | undefined { return new Decorator(global.generatedEs2panda._CreateDecorator(global.context, passNode(expr))) } - static updateDecorator(original: Decorator, expr: Expression): Decorator { + static updateDecorator(original?: Decorator, expr?: Expression): Decorator | undefined { return new Decorator(global.generatedEs2panda._UpdateDecorator(global.context, passNode(original), passNode(expr))) } - get exprConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._DecoratorExprConst(global.context, this.peer)) + get exprConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._DecoratorExprConst(global.context, this.peer)) } } export function isDecorator(node: AstNode): node is Decorator { diff --git a/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts index c97c96040..314fc2522 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,10 +35,10 @@ export class DirectEvalExpression extends CallExpression { super(pointer) console.warn("Warning: stub node DirectEvalExpression") } - static createDirectEvalExpression(callee: Expression, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation, optional_arg: boolean, parserStatus: number): DirectEvalExpression { + static createDirectEvalExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression | undefined { return new DirectEvalExpression(global.generatedEs2panda._CreateDirectEvalExpression(global.context, passNode(callee), passNodeArray(_arguments), argumentsLen, passNode(typeParams), optional_arg, parserStatus)) } - static updateDirectEvalExpression(original: DirectEvalExpression, callee: Expression, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation, optional_arg: boolean, parserStatus: number): DirectEvalExpression { + static updateDirectEvalExpression(original: DirectEvalExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression | undefined { return new DirectEvalExpression(global.generatedEs2panda._UpdateDirectEvalExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), argumentsLen, passNode(typeParams), optional_arg, parserStatus)) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts index 1b6225555..f69393d17 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class DoWhileStatement extends LoopStatement { super(pointer) console.warn("Warning: stub node DoWhileStatement") } - get bodyConst(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._DoWhileStatementBodyConst(global.context, this.peer)) + get bodyConst(): Statement | undefined { + return unpackNode(global.generatedEs2panda._DoWhileStatementBodyConst(global.context, this.peer)) } - get body(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._DoWhileStatementBody(global.context, this.peer)) + get body(): Statement | undefined { + return unpackNode(global.generatedEs2panda._DoWhileStatementBody(global.context, this.peer)) } - get testConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._DoWhileStatementTestConst(global.context, this.peer)) + get testConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._DoWhileStatementTestConst(global.context, this.peer)) } - get test(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._DoWhileStatementTest(global.context, this.peer)) + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._DoWhileStatementTest(global.context, this.peer)) } } export function isDoWhileStatement(node: AstNode): node is DoWhileStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts index 9c382a683..30f74e4f5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,14 +34,14 @@ export class ETSClassLiteral extends Expression { super(pointer) console.warn("Warning: stub node ETSClassLiteral") } - static createETSClassLiteral(expr: TypeNode): ETSClassLiteral { + static createETSClassLiteral(expr?: TypeNode): ETSClassLiteral | undefined { return new ETSClassLiteral(global.generatedEs2panda._CreateETSClassLiteral(global.context, passNode(expr))) } - static updateETSClassLiteral(original: ETSClassLiteral, expr: TypeNode): ETSClassLiteral { + static updateETSClassLiteral(original?: ETSClassLiteral, expr?: TypeNode): ETSClassLiteral | undefined { return new ETSClassLiteral(global.generatedEs2panda._UpdateETSClassLiteral(global.context, passNode(original), passNode(expr))) } - get exprConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._ETSClassLiteralExprConst(global.context, this.peer)) + get exprConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSClassLiteralExprConst(global.context, this.peer)) } } export function isETSClassLiteral(node: AstNode): node is ETSClassLiteral { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts index 56fe11d77..4a24d4bfa 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts index d8fe47ad8..3456e57b9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -36,26 +37,26 @@ export class ETSFunctionType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSFunctionType") } - get typeParamsConst(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._ETSFunctionTypeIrTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ETSFunctionTypeIrTypeParamsConst(global.context, this.peer)) } - get typeParams(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._ETSFunctionTypeIrTypeParams(global.context, this.peer)) + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ETSFunctionTypeIrTypeParams(global.context, this.peer)) } get paramsConst(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._ETSFunctionTypeIrParamsConst(global.context, this.peer)) } - get returnTypeConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._ETSFunctionTypeIrReturnTypeConst(global.context, this.peer)) + get returnTypeConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSFunctionTypeIrReturnTypeConst(global.context, this.peer)) } - get returnType(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._ETSFunctionTypeIrReturnType(global.context, this.peer)) + get returnType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSFunctionTypeIrReturnType(global.context, this.peer)) } - get functionalInterface(): TSInterfaceDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._ETSFunctionTypeIrFunctionalInterface(global.context, this.peer)) + get functionalInterface(): TSInterfaceDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ETSFunctionTypeIrFunctionalInterface(global.context, this.peer)) } - get functionalInterfaceConst(): TSInterfaceDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._ETSFunctionTypeIrFunctionalInterfaceConst(global.context, this.peer)) + get functionalInterfaceConst(): TSInterfaceDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ETSFunctionTypeIrFunctionalInterfaceConst(global.context, this.peer)) } get flags(): Es2pandaScriptFunctionFlags { return global.generatedEs2panda._ETSFunctionTypeIrFlags(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 d6c2bea5a..7143ac0b8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -45,14 +46,14 @@ export class ETSImportDeclaration extends ImportDeclaration { get assemblerNameConst(): string { return global.generatedEs2panda._ETSImportDeclarationAssemblerNameConst(global.context, this.peer) } - get sourceConst(): StringLiteral { - return unpackNonNullableNode(global.generatedEs2panda._ETSImportDeclarationSourceConst(global.context, this.peer)) + get sourceConst(): StringLiteral | undefined { + return unpackNode(global.generatedEs2panda._ETSImportDeclarationSourceConst(global.context, this.peer)) } - get resolvedSource(): StringLiteral { - return unpackNonNullableNode(global.generatedEs2panda._ETSImportDeclarationResolvedSource(global.context, this.peer)) + get resolvedSource(): StringLiteral | undefined { + return unpackNode(global.generatedEs2panda._ETSImportDeclarationResolvedSource(global.context, this.peer)) } - get resolvedSourceConst(): StringLiteral { - return unpackNonNullableNode(global.generatedEs2panda._ETSImportDeclarationResolvedSourceConst(global.context, this.peer)) + get resolvedSourceConst(): StringLiteral | undefined { + return unpackNode(global.generatedEs2panda._ETSImportDeclarationResolvedSourceConst(global.context, this.peer)) } } export function isETSImportDeclaration(node: AstNode): node is ETSImportDeclaration { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts index fcde2a20d..af9f15d70 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,14 +34,14 @@ export class ETSLaunchExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSLaunchExpression") } - static createETSLaunchExpression(expr: CallExpression): ETSLaunchExpression { + static createETSLaunchExpression(expr?: CallExpression): ETSLaunchExpression | undefined { return new ETSLaunchExpression(global.generatedEs2panda._CreateETSLaunchExpression(global.context, passNode(expr))) } - static updateETSLaunchExpression(original: ETSLaunchExpression, expr: CallExpression): ETSLaunchExpression { + static updateETSLaunchExpression(original?: ETSLaunchExpression, expr?: CallExpression): ETSLaunchExpression | undefined { return new ETSLaunchExpression(global.generatedEs2panda._UpdateETSLaunchExpression(global.context, passNode(original), passNode(expr))) } - get callConst(): CallExpression { - return unpackNonNullableNode(global.generatedEs2panda._ETSLaunchExpressionCallConst(global.context, this.peer)) + get callConst(): CallExpression | undefined { + return unpackNode(global.generatedEs2panda._ETSLaunchExpressionCallConst(global.context, this.peer)) } } export function isETSLaunchExpression(node: AstNode): node is ETSLaunchExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts index 0dc848a73..f7fc73b62 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,11 +35,11 @@ export class ETSModule extends BlockStatement { super(pointer) console.warn("Warning: stub node ETSModule") } - get ident(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ETSModuleIdent(global.context, this.peer)) + get ident(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ETSModuleIdent(global.context, this.peer)) } - get identConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ETSModuleIdentConst(global.context, this.peer)) + get identConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ETSModuleIdentConst(global.context, this.peer)) } get isETSScriptConst(): boolean { return global.generatedEs2panda._ETSModuleIsETSScriptConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts index eb413a1e0..5d2dfca72 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,23 +34,23 @@ export class ETSNewArrayInstanceExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSNewArrayInstanceExpression") } - static createETSNewArrayInstanceExpression(typeReference: TypeNode, dimension: Expression): ETSNewArrayInstanceExpression { + static createETSNewArrayInstanceExpression(typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression | undefined { return new ETSNewArrayInstanceExpression(global.generatedEs2panda._CreateETSNewArrayInstanceExpression(global.context, passNode(typeReference), passNode(dimension))) } - static updateETSNewArrayInstanceExpression(original: ETSNewArrayInstanceExpression, typeReference: TypeNode, dimension: Expression): ETSNewArrayInstanceExpression { + static updateETSNewArrayInstanceExpression(original?: ETSNewArrayInstanceExpression, typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression | undefined { return new ETSNewArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNode(dimension))) } - get typeReference(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionTypeReference(global.context, this.peer)) + get typeReference(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionTypeReference(global.context, this.peer)) } - get typeReferenceConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionTypeReferenceConst(global.context, this.peer)) + get typeReferenceConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionTypeReferenceConst(global.context, this.peer)) } - get dimension(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionDimension(global.context, this.peer)) + get dimension(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionDimension(global.context, this.peer)) } - get dimensionConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionDimensionConst(global.context, this.peer)) + get dimensionConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionDimensionConst(global.context, this.peer)) } } export function isETSNewArrayInstanceExpression(node: AstNode): node is ETSNewArrayInstanceExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts index 15651fb0b..b75bab626 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,20 +33,20 @@ export class ETSNewClassInstanceExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSNewClassInstanceExpression") } - static createETSNewClassInstanceExpression(typeReference: Expression, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression { + static createETSNewClassInstanceExpression(typeReference: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression | undefined { return new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression(global.context, passNode(typeReference), passNodeArray(_arguments), argumentsLen)) } - static updateETSNewClassInstanceExpression(original: ETSNewClassInstanceExpression, typeReference: Expression, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression { + static updateETSNewClassInstanceExpression(original: ETSNewClassInstanceExpression | undefined, typeReference: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression | undefined { return new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(_arguments), argumentsLen)) } - static create1ETSNewClassInstanceExpression(other: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression { + static create1ETSNewClassInstanceExpression(other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression | undefined { return new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression1(global.context, passNode(other))) } - static update1ETSNewClassInstanceExpression(original: ETSNewClassInstanceExpression, other: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression { + static update1ETSNewClassInstanceExpression(original?: ETSNewClassInstanceExpression, other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression | undefined { return new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression1(global.context, passNode(original), passNode(other))) } - get getTypeRefConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ETSNewClassInstanceExpressionGetTypeRefConst(global.context, this.peer)) + get getTypeRefConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ETSNewClassInstanceExpressionGetTypeRefConst(global.context, this.peer)) } get getArgumentsConst(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._ETSNewClassInstanceExpressionGetArgumentsConst(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 7ff65b3b2..88a7b6be6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,23 +34,23 @@ export class ETSNewMultiDimArrayInstanceExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSNewMultiDimArrayInstanceExpression") } - static createETSNewMultiDimArrayInstanceExpression(typeReference: TypeNode, dimensions: readonly Expression[], dimensionsLen: number): ETSNewMultiDimArrayInstanceExpression { + static createETSNewMultiDimArrayInstanceExpression(typeReference: TypeNode | undefined, dimensions: readonly Expression[], dimensionsLen: number): ETSNewMultiDimArrayInstanceExpression | undefined { return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._CreateETSNewMultiDimArrayInstanceExpression(global.context, passNode(typeReference), passNodeArray(dimensions), dimensionsLen)) } - static updateETSNewMultiDimArrayInstanceExpression(original: ETSNewMultiDimArrayInstanceExpression, typeReference: TypeNode, dimensions: readonly Expression[], dimensionsLen: number): ETSNewMultiDimArrayInstanceExpression { + static updateETSNewMultiDimArrayInstanceExpression(original: ETSNewMultiDimArrayInstanceExpression | undefined, typeReference: TypeNode | undefined, dimensions: readonly Expression[], dimensionsLen: number): ETSNewMultiDimArrayInstanceExpression | undefined { return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(dimensions), dimensionsLen)) } - static create1ETSNewMultiDimArrayInstanceExpression(other: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression { + static create1ETSNewMultiDimArrayInstanceExpression(other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression | undefined { return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._CreateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(other))) } - static update1ETSNewMultiDimArrayInstanceExpression(original: ETSNewMultiDimArrayInstanceExpression, other: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression { + static update1ETSNewMultiDimArrayInstanceExpression(original?: ETSNewMultiDimArrayInstanceExpression, other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression | undefined { return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(original), passNode(other))) } - get typeReference(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionTypeReference(global.context, this.peer)) + get typeReference(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionTypeReference(global.context, this.peer)) } - get typeReferenceConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionTypeReferenceConst(global.context, this.peer)) + get typeReferenceConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionTypeReferenceConst(global.context, this.peer)) } get dimensions(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionDimensions(global.context, this.peer)) diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts index 74fbe7279..279fc8472 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class ETSNullType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSNullType") } - static createETSNullType(): ETSNullType { + static createETSNullType(): ETSNullType | undefined { return new ETSNullType(global.generatedEs2panda._CreateETSNullTypeIr(global.context)) } - static updateETSNullType(original: ETSNullType): ETSNullType { + static updateETSNullType(original?: ETSNullType): ETSNullType | undefined { return new ETSNullType(global.generatedEs2panda._UpdateETSNullTypeIr(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts index b0738dcad..f784110d9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,10 +34,10 @@ export class ETSPackageDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ETSPackageDeclaration") } - static createETSPackageDeclaration(name: Expression): ETSPackageDeclaration { + static createETSPackageDeclaration(name?: Expression): ETSPackageDeclaration | undefined { return new ETSPackageDeclaration(global.generatedEs2panda._CreateETSPackageDeclaration(global.context, passNode(name))) } - static updateETSPackageDeclaration(original: ETSPackageDeclaration, name: Expression): ETSPackageDeclaration { + static updateETSPackageDeclaration(original?: ETSPackageDeclaration, name?: Expression): ETSPackageDeclaration | undefined { return new ETSPackageDeclaration(global.generatedEs2panda._UpdateETSPackageDeclaration(global.context, passNode(original), passNode(name))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts index 89b4294e3..44a6f7f48 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,10 +35,10 @@ export class ETSParameterExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSParameterExpression") } - static createETSParameterExpression(identOrSpread: AnnotatedExpression, initializer: Expression): ETSParameterExpression { + static createETSParameterExpression(identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression | undefined { return new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression(global.context, passNode(identOrSpread), passNode(initializer))) } - static updateETSParameterExpression(original: ETSParameterExpression, identOrSpread: AnnotatedExpression, initializer: Expression): ETSParameterExpression { + static updateETSParameterExpression(original?: ETSParameterExpression, identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression | undefined { return new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression(global.context, passNode(original), passNode(identOrSpread), passNode(initializer))) } get isDefaultConst(): boolean { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts index 0e59f8a52..761c6f1b9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,10 +34,10 @@ export class ETSPrimitiveType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSPrimitiveType") } - static createETSPrimitiveType(type: Es2pandaPrimitiveType): ETSPrimitiveType { + static createETSPrimitiveType(type: Es2pandaPrimitiveType): ETSPrimitiveType | undefined { return new ETSPrimitiveType(global.generatedEs2panda._CreateETSPrimitiveType(global.context, type)) } - static updateETSPrimitiveType(original: ETSPrimitiveType, type: Es2pandaPrimitiveType): ETSPrimitiveType { + static updateETSPrimitiveType(original: ETSPrimitiveType | undefined, type: Es2pandaPrimitiveType): ETSPrimitiveType | undefined { return new ETSPrimitiveType(global.generatedEs2panda._UpdateETSPrimitiveType(global.context, passNode(original), type)) } get getPrimitiveTypeConst(): Es2pandaPrimitiveType { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts index 178ba7df0..f9df26fee 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,11 +34,11 @@ export class ETSReExportDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ETSReExportDeclaration") } - get getETSImportDeclarationsConst(): ETSImportDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._ETSReExportDeclarationGetETSImportDeclarationsConst(global.context, this.peer)) + get getETSImportDeclarationsConst(): ETSImportDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ETSReExportDeclarationGetETSImportDeclarationsConst(global.context, this.peer)) } - get getETSImportDeclarations(): ETSImportDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._ETSReExportDeclarationGetETSImportDeclarations(global.context, this.peer)) + get getETSImportDeclarations(): ETSImportDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ETSReExportDeclarationGetETSImportDeclarations(global.context, this.peer)) } get getProgramPathConst(): string { return global.generatedEs2panda._ETSReExportDeclarationGetProgramPathConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts index a4a0e8283..b341a7ed3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,10 +34,10 @@ export class ETSStructDeclaration extends ClassDeclaration { super(pointer) console.warn("Warning: stub node ETSStructDeclaration") } - static createETSStructDeclaration(def: ClassDefinition): ETSStructDeclaration { + static createETSStructDeclaration(def?: ClassDefinition): ETSStructDeclaration | undefined { return new ETSStructDeclaration(global.generatedEs2panda._CreateETSStructDeclaration(global.context, passNode(def))) } - static updateETSStructDeclaration(original: ETSStructDeclaration, def: ClassDefinition): ETSStructDeclaration { + static updateETSStructDeclaration(original?: ETSStructDeclaration, def?: ClassDefinition): ETSStructDeclaration | undefined { return new ETSStructDeclaration(global.generatedEs2panda._UpdateETSStructDeclaration(global.context, passNode(original), passNode(def))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts index 86ef2bba4..fbcee5019 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,22 +33,22 @@ export class ETSTuple extends TypeNode { super(pointer) console.warn("Warning: stub node ETSTuple") } - static createETSTuple(): ETSTuple { + static createETSTuple(): ETSTuple | undefined { return new ETSTuple(global.generatedEs2panda._CreateETSTuple(global.context)) } - static updateETSTuple(original: ETSTuple): ETSTuple { + static updateETSTuple(original?: ETSTuple): ETSTuple | undefined { return new ETSTuple(global.generatedEs2panda._UpdateETSTuple(global.context, passNode(original))) } - static create1ETSTuple(size: number): ETSTuple { + static create1ETSTuple(size: number): ETSTuple | undefined { return new ETSTuple(global.generatedEs2panda._CreateETSTuple1(global.context, size)) } - static update1ETSTuple(original: ETSTuple, size: number): ETSTuple { + static update1ETSTuple(original: ETSTuple | undefined, size: number): ETSTuple | undefined { return new ETSTuple(global.generatedEs2panda._UpdateETSTuple1(global.context, passNode(original), size)) } - static create2ETSTuple(typeList: readonly TypeNode[], typeListLen: number): ETSTuple { + static create2ETSTuple(typeList: readonly TypeNode[], typeListLen: number): ETSTuple | undefined { return new ETSTuple(global.generatedEs2panda._CreateETSTuple2(global.context, passNodeArray(typeList), typeListLen)) } - static update2ETSTuple(original: ETSTuple, typeList: readonly TypeNode[], typeListLen: number): ETSTuple { + static update2ETSTuple(original: ETSTuple | undefined, typeList: readonly TypeNode[], typeListLen: number): ETSTuple | undefined { return new ETSTuple(global.generatedEs2panda._UpdateETSTuple2(global.context, passNode(original), passNodeArray(typeList), typeListLen)) } get getTupleSizeConst(): number { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts index 8db1c8496..eb65893c4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,17 +34,17 @@ export class ETSTypeReference extends TypeNode { super(pointer) console.warn("Warning: stub node ETSTypeReference") } - static createETSTypeReference(part: ETSTypeReferencePart): ETSTypeReference { + static createETSTypeReference(part?: ETSTypeReferencePart): ETSTypeReference | undefined { return new ETSTypeReference(global.generatedEs2panda._CreateETSTypeReference(global.context, passNode(part))) } - static updateETSTypeReference(original: ETSTypeReference, part: ETSTypeReferencePart): ETSTypeReference { + static updateETSTypeReference(original?: ETSTypeReference, part?: ETSTypeReferencePart): ETSTypeReference | undefined { return new ETSTypeReference(global.generatedEs2panda._UpdateETSTypeReference(global.context, passNode(original), passNode(part))) } - get part(): ETSTypeReferencePart { - return unpackNonNullableNode(global.generatedEs2panda._ETSTypeReferencePart(global.context, this.peer)) + get part(): ETSTypeReferencePart | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferencePart(global.context, this.peer)) } - get partConst(): ETSTypeReferencePart { - return unpackNonNullableNode(global.generatedEs2panda._ETSTypeReferencePartConst(global.context, this.peer)) + get partConst(): ETSTypeReferencePart | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferencePartConst(global.context, this.peer)) } } export function isETSTypeReference(node: AstNode): node is ETSTypeReference { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts index d48f5c434..9d33ec09b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,32 +35,32 @@ export class ETSTypeReferencePart extends TypeNode { super(pointer) console.warn("Warning: stub node ETSTypeReferencePart") } - static createETSTypeReferencePart(name: Expression, typeParams: TSTypeParameterInstantiation, prev: ETSTypeReferencePart): ETSTypeReferencePart { + static createETSTypeReferencePart(name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart | undefined { return new ETSTypeReferencePart(global.generatedEs2panda._CreateETSTypeReferencePart(global.context, passNode(name), passNode(typeParams), passNode(prev))) } - static updateETSTypeReferencePart(original: ETSTypeReferencePart, name: Expression, typeParams: TSTypeParameterInstantiation, prev: ETSTypeReferencePart): ETSTypeReferencePart { + static updateETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart | undefined { return new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart(global.context, passNode(original), passNode(name), passNode(typeParams), passNode(prev))) } - static create1ETSTypeReferencePart(name: Expression): ETSTypeReferencePart { + static create1ETSTypeReferencePart(name?: Expression): ETSTypeReferencePart | undefined { return new ETSTypeReferencePart(global.generatedEs2panda._CreateETSTypeReferencePart1(global.context, passNode(name))) } - static update1ETSTypeReferencePart(original: ETSTypeReferencePart, name: Expression): ETSTypeReferencePart { + static update1ETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression): ETSTypeReferencePart | undefined { return new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart1(global.context, passNode(original), passNode(name))) } - get previous(): ETSTypeReferencePart { - return unpackNonNullableNode(global.generatedEs2panda._ETSTypeReferencePartPrevious(global.context, this.peer)) + get previous(): ETSTypeReferencePart | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferencePartPrevious(global.context, this.peer)) } - get previousConst(): ETSTypeReferencePart { - return unpackNonNullableNode(global.generatedEs2panda._ETSTypeReferencePartPreviousConst(global.context, this.peer)) + get previousConst(): ETSTypeReferencePart | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferencePartPreviousConst(global.context, this.peer)) } - get name(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ETSTypeReferencePartName(global.context, this.peer)) + get name(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferencePartName(global.context, this.peer)) } - get typeParams(): TSTypeParameterInstantiation { - return unpackNonNullableNode(global.generatedEs2panda._ETSTypeReferencePartTypeParams(global.context, this.peer)) + get typeParams(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferencePartTypeParams(global.context, this.peer)) } - get nameConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ETSTypeReferencePartNameConst(global.context, this.peer)) + get nameConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferencePartNameConst(global.context, this.peer)) } } export function isETSTypeReferencePart(node: AstNode): node is ETSTypeReferencePart { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts index 4bf7416aa..ac8aa77c6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class ETSUndefinedType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSUndefinedType") } - static createETSUndefinedType(): ETSUndefinedType { + static createETSUndefinedType(): ETSUndefinedType | undefined { return new ETSUndefinedType(global.generatedEs2panda._CreateETSUndefinedTypeIr(global.context)) } - static updateETSUndefinedType(original: ETSUndefinedType): ETSUndefinedType { + static updateETSUndefinedType(original?: ETSUndefinedType): ETSUndefinedType | undefined { return new ETSUndefinedType(global.generatedEs2panda._UpdateETSUndefinedTypeIr(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts index 8a76d684f..ab58232f1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class ETSUnionType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSUnionType") } - static createETSUnionType(types: readonly TypeNode[], typesLen: number): ETSUnionType { + static createETSUnionType(types: readonly TypeNode[], typesLen: number): ETSUnionType | undefined { return new ETSUnionType(global.generatedEs2panda._CreateETSUnionTypeIr(global.context, passNodeArray(types), typesLen)) } - static updateETSUnionType(original: ETSUnionType, types: readonly TypeNode[], typesLen: number): ETSUnionType { + static updateETSUnionType(original: ETSUnionType | undefined, types: readonly TypeNode[], typesLen: number): ETSUnionType | undefined { return new ETSUnionType(global.generatedEs2panda._UpdateETSUnionTypeIr(global.context, passNode(original), passNodeArray(types), typesLen)) } get typesConst(): readonly TypeNode[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts index ef9df2213..ae5dbb3b4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class ETSWildcardType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSWildcardType") } - static createETSWildcardType(typeReference: ETSTypeReference, flags: Es2pandaModifierFlags): ETSWildcardType { + static createETSWildcardType(typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType | undefined { return new ETSWildcardType(global.generatedEs2panda._CreateETSWildcardType(global.context, passNode(typeReference), flags)) } - static updateETSWildcardType(original: ETSWildcardType, typeReference: ETSTypeReference, flags: Es2pandaModifierFlags): ETSWildcardType { + static updateETSWildcardType(original: ETSWildcardType | undefined, typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType | undefined { return new ETSWildcardType(global.generatedEs2panda._UpdateETSWildcardType(global.context, passNode(original), passNode(typeReference), flags)) } - get typeReference(): ETSTypeReference { - return unpackNonNullableNode(global.generatedEs2panda._ETSWildcardTypeTypeReference(global.context, this.peer)) + get typeReference(): ETSTypeReference | undefined { + return unpackNode(global.generatedEs2panda._ETSWildcardTypeTypeReference(global.context, this.peer)) } - get typeReferenceConst(): ETSTypeReference { - return unpackNonNullableNode(global.generatedEs2panda._ETSWildcardTypeTypeReferenceConst(global.context, this.peer)) + get typeReferenceConst(): ETSTypeReference | undefined { + return unpackNode(global.generatedEs2panda._ETSWildcardTypeTypeReferenceConst(global.context, this.peer)) } } export function isETSWildcardType(node: AstNode): node is ETSWildcardType { diff --git a/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts index 9a4b3e0d6..a74af4e3a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class EmptyStatement extends Statement { super(pointer) console.warn("Warning: stub node EmptyStatement") } - static createEmptyStatement(): EmptyStatement { + static createEmptyStatement(): EmptyStatement | undefined { return new EmptyStatement(global.generatedEs2panda._CreateEmptyStatement(global.context)) } - static updateEmptyStatement(original: EmptyStatement): EmptyStatement { + static updateEmptyStatement(original?: EmptyStatement): EmptyStatement | undefined { return new EmptyStatement(global.generatedEs2panda._UpdateEmptyStatement(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts index b6622ec55..d827b1a94 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class ExportAllDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ExportAllDeclaration") } - static createExportAllDeclaration(source: StringLiteral, exported: Identifier): ExportAllDeclaration { + static createExportAllDeclaration(source?: StringLiteral, exported?: Identifier): ExportAllDeclaration | undefined { return new ExportAllDeclaration(global.generatedEs2panda._CreateExportAllDeclaration(global.context, passNode(source), passNode(exported))) } - static updateExportAllDeclaration(original: ExportAllDeclaration, source: StringLiteral, exported: Identifier): ExportAllDeclaration { + static updateExportAllDeclaration(original?: ExportAllDeclaration, source?: StringLiteral, exported?: Identifier): ExportAllDeclaration | undefined { return new ExportAllDeclaration(global.generatedEs2panda._UpdateExportAllDeclaration(global.context, passNode(original), passNode(source), passNode(exported))) } - get sourceConst(): StringLiteral { - return unpackNonNullableNode(global.generatedEs2panda._ExportAllDeclarationSourceConst(global.context, this.peer)) + get sourceConst(): StringLiteral | undefined { + return unpackNode(global.generatedEs2panda._ExportAllDeclarationSourceConst(global.context, this.peer)) } - get exportedConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ExportAllDeclarationExportedConst(global.context, this.peer)) + get exportedConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ExportAllDeclarationExportedConst(global.context, this.peer)) } } export function isExportAllDeclaration(node: AstNode): node is ExportAllDeclaration { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts index 8ac9146ba..4da8c11d4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,17 +33,17 @@ export class ExportDefaultDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ExportDefaultDeclaration") } - static createExportDefaultDeclaration(decl: AstNode, exportEquals: boolean): ExportDefaultDeclaration { + static createExportDefaultDeclaration(decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration | undefined { return new ExportDefaultDeclaration(global.generatedEs2panda._CreateExportDefaultDeclaration(global.context, passNode(decl), exportEquals)) } - static updateExportDefaultDeclaration(original: ExportDefaultDeclaration, decl: AstNode, exportEquals: boolean): ExportDefaultDeclaration { + static updateExportDefaultDeclaration(original: ExportDefaultDeclaration | undefined, decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration | undefined { return new ExportDefaultDeclaration(global.generatedEs2panda._UpdateExportDefaultDeclaration(global.context, passNode(original), passNode(decl), exportEquals)) } - get decl(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._ExportDefaultDeclarationDecl(global.context, this.peer)) + get decl(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ExportDefaultDeclarationDecl(global.context, this.peer)) } - get declConst(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._ExportDefaultDeclarationDeclConst(global.context, this.peer)) + get declConst(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ExportDefaultDeclarationDeclConst(global.context, this.peer)) } get isExportEqualsConst(): boolean { return global.generatedEs2panda._ExportDefaultDeclarationIsExportEqualsConst(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 1642077d0..a90bb6bbd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,29 +35,29 @@ export class ExportNamedDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ExportNamedDeclaration") } - static createExportNamedDeclaration(source: StringLiteral, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { + static createExportNamedDeclaration(source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration | undefined { return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiersLen)) } - static updateExportNamedDeclaration(original: ExportNamedDeclaration, source: StringLiteral, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { + static updateExportNamedDeclaration(original: ExportNamedDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration | undefined { return new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiersLen)) } - static create1ExportNamedDeclaration(decl: AstNode, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { + static create1ExportNamedDeclaration(decl: AstNode | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration | undefined { return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration1(global.context, passNode(decl), passNodeArray(specifiers), specifiersLen)) } - static update1ExportNamedDeclaration(original: ExportNamedDeclaration, decl: AstNode, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { + static update1ExportNamedDeclaration(original: ExportNamedDeclaration | undefined, decl: AstNode | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration | undefined { return new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration1(global.context, passNode(original), passNode(decl), passNodeArray(specifiers), specifiersLen)) } - static create2ExportNamedDeclaration(decl: AstNode): ExportNamedDeclaration { + static create2ExportNamedDeclaration(decl?: AstNode): ExportNamedDeclaration | undefined { return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration2(global.context, passNode(decl))) } - static update2ExportNamedDeclaration(original: ExportNamedDeclaration, decl: AstNode): ExportNamedDeclaration { + static update2ExportNamedDeclaration(original?: ExportNamedDeclaration, decl?: AstNode): ExportNamedDeclaration | undefined { return new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration2(global.context, passNode(original), passNode(decl))) } - get declConst(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._ExportNamedDeclarationDeclConst(global.context, this.peer)) + get declConst(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ExportNamedDeclarationDeclConst(global.context, this.peer)) } - get sourceConst(): StringLiteral { - return unpackNonNullableNode(global.generatedEs2panda._ExportNamedDeclarationSourceConst(global.context, this.peer)) + get sourceConst(): StringLiteral | undefined { + return unpackNode(global.generatedEs2panda._ExportNamedDeclarationSourceConst(global.context, this.peer)) } get specifiersConst(): readonly ExportSpecifier[] { return unpackNodeArray(global.generatedEs2panda._ExportNamedDeclarationSpecifiersConst(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 b2b3efefd..382c89054 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,17 +34,17 @@ export class ExportSpecifier extends Statement { super(pointer) console.warn("Warning: stub node ExportSpecifier") } - static createExportSpecifier(local: Identifier, exported: Identifier): ExportSpecifier { + static createExportSpecifier(local?: Identifier, exported?: Identifier): ExportSpecifier | undefined { return new ExportSpecifier(global.generatedEs2panda._CreateExportSpecifier(global.context, passNode(local), passNode(exported))) } - static updateExportSpecifier(original: ExportSpecifier, local: Identifier, exported: Identifier): ExportSpecifier { + static updateExportSpecifier(original?: ExportSpecifier, local?: Identifier, exported?: Identifier): ExportSpecifier | undefined { return new ExportSpecifier(global.generatedEs2panda._UpdateExportSpecifier(global.context, passNode(original), passNode(local), passNode(exported))) } - get localConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ExportSpecifierLocalConst(global.context, this.peer)) + get localConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ExportSpecifierLocalConst(global.context, this.peer)) } - get exportedConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ExportSpecifierExportedConst(global.context, this.peer)) + get exportedConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ExportSpecifierExportedConst(global.context, this.peer)) } } export function isExportSpecifier(node: AstNode): node is ExportSpecifier { diff --git a/arkoala-arkts/libarkts/src/generated/peers/Expression.ts b/arkoala-arkts/libarkts/src/generated/peers/Expression.ts index 3da37221a..29c10a05b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Expression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Expression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts index 2500f2361..bbc0cfb2e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,17 +34,17 @@ export class ExpressionStatement extends Statement { super(pointer) console.warn("Warning: stub node ExpressionStatement") } - static createExpressionStatement(expr: Expression): ExpressionStatement { + static createExpressionStatement(expr?: Expression): ExpressionStatement | undefined { return new ExpressionStatement(global.generatedEs2panda._CreateExpressionStatement(global.context, passNode(expr))) } - static updateExpressionStatement(original: ExpressionStatement, expr: Expression): ExpressionStatement { + static updateExpressionStatement(original?: ExpressionStatement, expr?: Expression): ExpressionStatement | undefined { return new ExpressionStatement(global.generatedEs2panda._UpdateExpressionStatement(global.context, passNode(original), passNode(expr))) } - get getExpressionConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ExpressionStatementGetExpressionConst(global.context, this.peer)) + get getExpressionConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ExpressionStatementGetExpressionConst(global.context, this.peer)) } - get getExpression(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ExpressionStatementGetExpression(global.context, this.peer)) + get getExpression(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ExpressionStatementGetExpression(global.context, this.peer)) } } export function isExpressionStatement(node: AstNode): node is ExpressionStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts index dbd948c7e..832fed72c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,23 +35,23 @@ export class ForInStatement extends LoopStatement { super(pointer) console.warn("Warning: stub node ForInStatement") } - get left(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._ForInStatementLeft(global.context, this.peer)) + get left(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ForInStatementLeft(global.context, this.peer)) } - get leftConst(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._ForInStatementLeftConst(global.context, this.peer)) + get leftConst(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ForInStatementLeftConst(global.context, this.peer)) } - get right(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ForInStatementRight(global.context, this.peer)) + get right(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ForInStatementRight(global.context, this.peer)) } - get rightConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ForInStatementRightConst(global.context, this.peer)) + get rightConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ForInStatementRightConst(global.context, this.peer)) } - get body(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._ForInStatementBody(global.context, this.peer)) + get body(): Statement | undefined { + return unpackNode(global.generatedEs2panda._ForInStatementBody(global.context, this.peer)) } - get bodyConst(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._ForInStatementBodyConst(global.context, this.peer)) + get bodyConst(): Statement | undefined { + return unpackNode(global.generatedEs2panda._ForInStatementBodyConst(global.context, this.peer)) } } export function isForInStatement(node: AstNode): node is ForInStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts index ab86b5e6a..affdb4ed3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,23 +35,23 @@ export class ForOfStatement extends LoopStatement { super(pointer) console.warn("Warning: stub node ForOfStatement") } - get left(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._ForOfStatementLeft(global.context, this.peer)) + get left(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ForOfStatementLeft(global.context, this.peer)) } - get leftConst(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._ForOfStatementLeftConst(global.context, this.peer)) + get leftConst(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ForOfStatementLeftConst(global.context, this.peer)) } - get right(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ForOfStatementRight(global.context, this.peer)) + get right(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ForOfStatementRight(global.context, this.peer)) } - get rightConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ForOfStatementRightConst(global.context, this.peer)) + get rightConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ForOfStatementRightConst(global.context, this.peer)) } - get body(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._ForOfStatementBody(global.context, this.peer)) + get body(): Statement | undefined { + return unpackNode(global.generatedEs2panda._ForOfStatementBody(global.context, this.peer)) } - get bodyConst(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._ForOfStatementBodyConst(global.context, this.peer)) + get bodyConst(): Statement | undefined { + return unpackNode(global.generatedEs2panda._ForOfStatementBodyConst(global.context, this.peer)) } get isAwaitConst(): boolean { return global.generatedEs2panda._ForOfStatementIsAwaitConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts index 0380c73ef..509fe7646 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,26 +35,26 @@ export class ForUpdateStatement extends LoopStatement { super(pointer) console.warn("Warning: stub node ForUpdateStatement") } - get init(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._ForUpdateStatementInit(global.context, this.peer)) + get init(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ForUpdateStatementInit(global.context, this.peer)) } - get initConst(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._ForUpdateStatementInitConst(global.context, this.peer)) + get initConst(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ForUpdateStatementInitConst(global.context, this.peer)) } - get test(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ForUpdateStatementTest(global.context, this.peer)) + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ForUpdateStatementTest(global.context, this.peer)) } - get testConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ForUpdateStatementTestConst(global.context, this.peer)) + get testConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ForUpdateStatementTestConst(global.context, this.peer)) } - get updateConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ForUpdateStatementUpdateConst(global.context, this.peer)) + get updateConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ForUpdateStatementUpdateConst(global.context, this.peer)) } - get body(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._ForUpdateStatementBody(global.context, this.peer)) + get body(): Statement | undefined { + return unpackNode(global.generatedEs2panda._ForUpdateStatementBody(global.context, this.peer)) } - get bodyConst(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._ForUpdateStatementBodyConst(global.context, this.peer)) + get bodyConst(): Statement | undefined { + return unpackNode(global.generatedEs2panda._ForUpdateStatementBodyConst(global.context, this.peer)) } } export function isForUpdateStatement(node: AstNode): node is ForUpdateStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts index ca69f5c8f..e11cd95f9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts index 26c3d1c7e..2a71f9ee2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,26 +35,26 @@ export class FunctionDeclaration extends Statement { super(pointer) console.warn("Warning: stub node FunctionDeclaration") } - static createFunctionDeclaration(func: ScriptFunction, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration { + static createFunctionDeclaration(func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration | undefined { return new FunctionDeclaration(global.generatedEs2panda._CreateFunctionDeclaration(global.context, passNode(func), passNodeArray(annotations), annotationsLen, isAnonymous)) } - static updateFunctionDeclaration(original: FunctionDeclaration, func: ScriptFunction, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration { + static updateFunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration | undefined { return new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration(global.context, passNode(original), passNode(func), passNodeArray(annotations), annotationsLen, isAnonymous)) } - static create1FunctionDeclaration(func: ScriptFunction, isAnonymous: boolean): FunctionDeclaration { + static create1FunctionDeclaration(func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration | undefined { return new FunctionDeclaration(global.generatedEs2panda._CreateFunctionDeclaration1(global.context, passNode(func), isAnonymous)) } - static update1FunctionDeclaration(original: FunctionDeclaration, func: ScriptFunction, isAnonymous: boolean): FunctionDeclaration { + static update1FunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration | undefined { return new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration1(global.context, passNode(original), passNode(func), isAnonymous)) } - get function(): ScriptFunction { - return unpackNonNullableNode(global.generatedEs2panda._FunctionDeclarationFunction(global.context, this.peer)) + get function(): ScriptFunction | undefined { + return unpackNode(global.generatedEs2panda._FunctionDeclarationFunction(global.context, this.peer)) } get isAnonymousConst(): boolean { return global.generatedEs2panda._FunctionDeclarationIsAnonymousConst(global.context, this.peer) } - get functionConst(): ScriptFunction { - return unpackNonNullableNode(global.generatedEs2panda._FunctionDeclarationFunctionConst(global.context, this.peer)) + get functionConst(): ScriptFunction | undefined { + return unpackNode(global.generatedEs2panda._FunctionDeclarationFunctionConst(global.context, this.peer)) } get annotations(): readonly AnnotationUsage[] { return unpackNodeArray(global.generatedEs2panda._FunctionDeclarationAnnotations(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 4d90b1061..549488ee3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,29 +35,29 @@ export class FunctionExpression extends Expression { super(pointer) console.warn("Warning: stub node FunctionExpression") } - static createFunctionExpression(func: ScriptFunction): FunctionExpression { + static createFunctionExpression(func?: ScriptFunction): FunctionExpression | undefined { return new FunctionExpression(global.generatedEs2panda._CreateFunctionExpression(global.context, passNode(func))) } - static updateFunctionExpression(original: FunctionExpression, func: ScriptFunction): FunctionExpression { + static updateFunctionExpression(original?: FunctionExpression, func?: ScriptFunction): FunctionExpression | undefined { return new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression(global.context, passNode(original), passNode(func))) } - static create1FunctionExpression(namedExpr: Identifier, func: ScriptFunction): FunctionExpression { + static create1FunctionExpression(namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression | undefined { return new FunctionExpression(global.generatedEs2panda._CreateFunctionExpression1(global.context, passNode(namedExpr), passNode(func))) } - static update1FunctionExpression(original: FunctionExpression, namedExpr: Identifier, func: ScriptFunction): FunctionExpression { + static update1FunctionExpression(original?: FunctionExpression, namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression | undefined { return new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression1(global.context, passNode(original), passNode(namedExpr), passNode(func))) } - get functionConst(): ScriptFunction { - return unpackNonNullableNode(global.generatedEs2panda._FunctionExpressionFunctionConst(global.context, this.peer)) + get functionConst(): ScriptFunction | undefined { + return unpackNode(global.generatedEs2panda._FunctionExpressionFunctionConst(global.context, this.peer)) } - get function(): ScriptFunction { - return unpackNonNullableNode(global.generatedEs2panda._FunctionExpressionFunction(global.context, this.peer)) + get function(): ScriptFunction | undefined { + return unpackNode(global.generatedEs2panda._FunctionExpressionFunction(global.context, this.peer)) } get isAnonymousConst(): boolean { return global.generatedEs2panda._FunctionExpressionIsAnonymousConst(global.context, this.peer) } - get id(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._FunctionExpressionId(global.context, this.peer)) + get id(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._FunctionExpressionId(global.context, this.peer)) } } export function isFunctionExpression(node: AstNode): node is FunctionExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts b/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts index f6272201a..04b8cb47f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,22 +35,22 @@ export class Identifier extends AnnotatedExpression { super(pointer) console.warn("Warning: stub node Identifier") } - static createIdentifier(): Identifier { + static createIdentifier(): Identifier | undefined { return new Identifier(global.generatedEs2panda._CreateIdentifier(global.context)) } - static updateIdentifier(original: Identifier): Identifier { + static updateIdentifier(original?: Identifier): Identifier | undefined { return new Identifier(global.generatedEs2panda._UpdateIdentifier(global.context, passNode(original))) } - static create1Identifier(name: string): Identifier { + static create1Identifier(name: string): Identifier | undefined { return new Identifier(global.generatedEs2panda._CreateIdentifier1(global.context, name)) } - static update1Identifier(original: Identifier, name: string): Identifier { + static update1Identifier(original: Identifier | undefined, name: string): Identifier | undefined { return new Identifier(global.generatedEs2panda._UpdateIdentifier1(global.context, passNode(original), name)) } - static create2Identifier(name: string, typeAnnotation: TypeNode): Identifier { + static create2Identifier(name: string, typeAnnotation?: TypeNode): Identifier | undefined { return new Identifier(global.generatedEs2panda._CreateIdentifier2(global.context, name, passNode(typeAnnotation))) } - static update2Identifier(original: Identifier, name: string, typeAnnotation: TypeNode): Identifier { + static update2Identifier(original: Identifier | undefined, name: string, typeAnnotation?: TypeNode): Identifier | undefined { return new Identifier(global.generatedEs2panda._UpdateIdentifier2(global.context, passNode(original), name, passNode(typeAnnotation))) } get nameConst(): string { @@ -94,8 +95,8 @@ export class Identifier extends AnnotatedExpression { get isAnnotationUsageConst(): boolean { return global.generatedEs2panda._IdentifierIsAnnotationUsageConst(global.context, this.peer) } - get typeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._IdentifierTypeAnnotationConst(global.context, this.peer)) + get typeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._IdentifierTypeAnnotationConst(global.context, this.peer)) } } export function isIdentifier(node: AstNode): node is Identifier { diff --git a/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts index fb22ed9b0..688ea8080 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,23 +34,23 @@ export class IfStatement extends Statement { super(pointer) console.warn("Warning: stub node IfStatement") } - get testConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._IfStatementTestConst(global.context, this.peer)) + get testConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._IfStatementTestConst(global.context, this.peer)) } - get test(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._IfStatementTest(global.context, this.peer)) + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._IfStatementTest(global.context, this.peer)) } - get consequentConst(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._IfStatementConsequentConst(global.context, this.peer)) + get consequentConst(): Statement | undefined { + return unpackNode(global.generatedEs2panda._IfStatementConsequentConst(global.context, this.peer)) } - get consequent(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._IfStatementConsequent(global.context, this.peer)) + get consequent(): Statement | undefined { + return unpackNode(global.generatedEs2panda._IfStatementConsequent(global.context, this.peer)) } - get alternate(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._IfStatementAlternate(global.context, this.peer)) + get alternate(): Statement | undefined { + return unpackNode(global.generatedEs2panda._IfStatementAlternate(global.context, this.peer)) } - get alternateConst(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._IfStatementAlternateConst(global.context, this.peer)) + get alternateConst(): Statement | undefined { + return unpackNode(global.generatedEs2panda._IfStatementAlternateConst(global.context, this.peer)) } } export function isIfStatement(node: AstNode): node is IfStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts index c1dc57159..38a6ff2af 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class ImportDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ImportDeclaration") } - static createImportDeclaration(source: StringLiteral, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration { + static createImportDeclaration(source: StringLiteral | undefined, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration | undefined { return new ImportDeclaration(global.generatedEs2panda._CreateImportDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiersLen, importKind)) } - static updateImportDeclaration(original: ImportDeclaration, source: StringLiteral, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration { + static updateImportDeclaration(original: ImportDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration | undefined { return new ImportDeclaration(global.generatedEs2panda._UpdateImportDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiersLen, importKind)) } - get sourceConst(): StringLiteral { - return unpackNonNullableNode(global.generatedEs2panda._ImportDeclarationSourceConst(global.context, this.peer)) + get sourceConst(): StringLiteral | undefined { + return unpackNode(global.generatedEs2panda._ImportDeclarationSourceConst(global.context, this.peer)) } - get source(): StringLiteral { - return unpackNonNullableNode(global.generatedEs2panda._ImportDeclarationSource(global.context, this.peer)) + get source(): StringLiteral | undefined { + return unpackNode(global.generatedEs2panda._ImportDeclarationSource(global.context, this.peer)) } get specifiersConst(): readonly AstNode[] { return unpackNodeArray(global.generatedEs2panda._ImportDeclarationSpecifiersConst(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 5042153ba..28d39da39 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,17 +34,17 @@ export class ImportDefaultSpecifier extends Statement { super(pointer) console.warn("Warning: stub node ImportDefaultSpecifier") } - static createImportDefaultSpecifier(local: Identifier): ImportDefaultSpecifier { + static createImportDefaultSpecifier(local?: Identifier): ImportDefaultSpecifier | undefined { return new ImportDefaultSpecifier(global.generatedEs2panda._CreateImportDefaultSpecifier(global.context, passNode(local))) } - static updateImportDefaultSpecifier(original: ImportDefaultSpecifier, local: Identifier): ImportDefaultSpecifier { + static updateImportDefaultSpecifier(original?: ImportDefaultSpecifier, local?: Identifier): ImportDefaultSpecifier | undefined { return new ImportDefaultSpecifier(global.generatedEs2panda._UpdateImportDefaultSpecifier(global.context, passNode(original), passNode(local))) } - get localConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ImportDefaultSpecifierLocalConst(global.context, this.peer)) + get localConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ImportDefaultSpecifierLocalConst(global.context, this.peer)) } - get local(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ImportDefaultSpecifierLocal(global.context, this.peer)) + get local(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ImportDefaultSpecifierLocal(global.context, this.peer)) } } export function isImportDefaultSpecifier(node: AstNode): node is ImportDefaultSpecifier { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts index 540ffdae0..489f8b840 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,17 +33,17 @@ export class ImportExpression extends Expression { super(pointer) console.warn("Warning: stub node ImportExpression") } - static createImportExpression(source: Expression): ImportExpression { + static createImportExpression(source?: Expression): ImportExpression | undefined { return new ImportExpression(global.generatedEs2panda._CreateImportExpression(global.context, passNode(source))) } - static updateImportExpression(original: ImportExpression, source: Expression): ImportExpression { + static updateImportExpression(original?: ImportExpression, source?: Expression): ImportExpression | undefined { return new ImportExpression(global.generatedEs2panda._UpdateImportExpression(global.context, passNode(original), passNode(source))) } - get source(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ImportExpressionSource(global.context, this.peer)) + get source(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ImportExpressionSource(global.context, this.peer)) } - get sourceConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ImportExpressionSourceConst(global.context, this.peer)) + get sourceConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ImportExpressionSourceConst(global.context, this.peer)) } } export function isImportExpression(node: AstNode): node is ImportExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts index dfac39402..b50dd642c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,17 +34,17 @@ export class ImportNamespaceSpecifier extends Statement { super(pointer) console.warn("Warning: stub node ImportNamespaceSpecifier") } - static createImportNamespaceSpecifier(local: Identifier): ImportNamespaceSpecifier { + static createImportNamespaceSpecifier(local?: Identifier): ImportNamespaceSpecifier | undefined { return new ImportNamespaceSpecifier(global.generatedEs2panda._CreateImportNamespaceSpecifier(global.context, passNode(local))) } - static updateImportNamespaceSpecifier(original: ImportNamespaceSpecifier, local: Identifier): ImportNamespaceSpecifier { + static updateImportNamespaceSpecifier(original?: ImportNamespaceSpecifier, local?: Identifier): ImportNamespaceSpecifier | undefined { return new ImportNamespaceSpecifier(global.generatedEs2panda._UpdateImportNamespaceSpecifier(global.context, passNode(original), passNode(local))) } - get local(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ImportNamespaceSpecifierLocal(global.context, this.peer)) + get local(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ImportNamespaceSpecifierLocal(global.context, this.peer)) } - get localConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ImportNamespaceSpecifierLocalConst(global.context, this.peer)) + get localConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ImportNamespaceSpecifierLocalConst(global.context, this.peer)) } } export function isImportNamespaceSpecifier(node: AstNode): node is ImportNamespaceSpecifier { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts index b1886782c..54ea216c9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,23 +34,23 @@ export class ImportSpecifier extends Statement { super(pointer) console.warn("Warning: stub node ImportSpecifier") } - static createImportSpecifier(imported: Identifier, local: Identifier): ImportSpecifier { + static createImportSpecifier(imported?: Identifier, local?: Identifier): ImportSpecifier | undefined { return new ImportSpecifier(global.generatedEs2panda._CreateImportSpecifier(global.context, passNode(imported), passNode(local))) } - static updateImportSpecifier(original: ImportSpecifier, imported: Identifier, local: Identifier): ImportSpecifier { + static updateImportSpecifier(original?: ImportSpecifier, imported?: Identifier, local?: Identifier): ImportSpecifier | undefined { return new ImportSpecifier(global.generatedEs2panda._UpdateImportSpecifier(global.context, passNode(original), passNode(imported), passNode(local))) } - get imported(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ImportSpecifierImported(global.context, this.peer)) + get imported(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ImportSpecifierImported(global.context, this.peer)) } - get importedConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ImportSpecifierImportedConst(global.context, this.peer)) + get importedConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ImportSpecifierImportedConst(global.context, this.peer)) } - get local(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ImportSpecifierLocal(global.context, this.peer)) + get local(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ImportSpecifierLocal(global.context, this.peer)) } - get localConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ImportSpecifierLocalConst(global.context, this.peer)) + get localConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ImportSpecifierLocalConst(global.context, this.peer)) } } export function isImportSpecifier(node: AstNode): node is ImportSpecifier { diff --git a/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts b/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts index 6de644923..4bfb4ab11 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts index a5e4043c2..255075d6e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,14 +34,14 @@ export class LabelledStatement extends Statement { super(pointer) console.warn("Warning: stub node LabelledStatement") } - get bodyConst(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._LabelledStatementBodyConst(global.context, this.peer)) + get bodyConst(): Statement | undefined { + return unpackNode(global.generatedEs2panda._LabelledStatementBodyConst(global.context, this.peer)) } - get identConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._LabelledStatementIdentConst(global.context, this.peer)) + get identConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._LabelledStatementIdentConst(global.context, this.peer)) } - get ident(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._LabelledStatementIdent(global.context, this.peer)) + get ident(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._LabelledStatementIdent(global.context, this.peer)) } } export function isLabelledStatement(node: AstNode): node is LabelledStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/Literal.ts b/arkoala-arkts/libarkts/src/generated/peers/Literal.ts index b1a3ed8b7..8b2a04106 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Literal.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Literal.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts index ece9429a3..73b0ba804 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts index 765543372..175973148 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts index 97db9b369..fc70b945f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,23 +35,23 @@ export class MemberExpression extends MaybeOptionalExpression { super(pointer) console.warn("Warning: stub node MemberExpression") } - static createMemberExpression(object_arg: Expression, property: Expression, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression { + static createMemberExpression(object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression | undefined { return new MemberExpression(global.generatedEs2panda._CreateMemberExpression(global.context, passNode(object_arg), passNode(property), kind, computed, optional_arg)) } - static updateMemberExpression(original: MemberExpression, object_arg: Expression, property: Expression, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression { + static updateMemberExpression(original: MemberExpression | undefined, object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression | undefined { return new MemberExpression(global.generatedEs2panda._UpdateMemberExpression(global.context, passNode(original), passNode(object_arg), passNode(property), kind, computed, optional_arg)) } - get object(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._MemberExpressionObject(global.context, this.peer)) + get object(): Expression | undefined { + return unpackNode(global.generatedEs2panda._MemberExpressionObject(global.context, this.peer)) } - get objectConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._MemberExpressionObjectConst(global.context, this.peer)) + get objectConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._MemberExpressionObjectConst(global.context, this.peer)) } - get property(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._MemberExpressionProperty(global.context, this.peer)) + get property(): Expression | undefined { + return unpackNode(global.generatedEs2panda._MemberExpressionProperty(global.context, this.peer)) } - get propertyConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._MemberExpressionPropertyConst(global.context, this.peer)) + get propertyConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._MemberExpressionPropertyConst(global.context, this.peer)) } get isComputedConst(): boolean { return global.generatedEs2panda._MemberExpressionIsComputedConst(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 e5635c47c..6d02a0c56 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,10 +34,10 @@ export class MetaProperty extends Expression { super(pointer) console.warn("Warning: stub node MetaProperty") } - static createMetaProperty(kind: Es2pandaMetaPropertyKind): MetaProperty { + static createMetaProperty(kind: Es2pandaMetaPropertyKind): MetaProperty | undefined { return new MetaProperty(global.generatedEs2panda._CreateMetaProperty(global.context, kind)) } - static updateMetaProperty(original: MetaProperty, kind: Es2pandaMetaPropertyKind): MetaProperty { + static updateMetaProperty(original: MetaProperty | undefined, kind: Es2pandaMetaPropertyKind): MetaProperty | undefined { return new MetaProperty(global.generatedEs2panda._UpdateMetaProperty(global.context, passNode(original), kind)) } get kindConst(): Es2pandaMetaPropertyKind { diff --git a/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts b/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts index 2b30d77ac..502e8f193 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -35,10 +36,10 @@ export class MethodDefinition extends ClassElement { super(pointer) console.warn("Warning: stub node MethodDefinition") } - static createMethodDefinition(kind: Es2pandaMethodDefinitionKind, key: Expression, value: Expression, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition { + static createMethodDefinition(kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition | undefined { return new MethodDefinition(global.generatedEs2panda._CreateMethodDefinition(global.context, kind, passNode(key), passNode(value), modifiers, isComputed)) } - static updateMethodDefinition(original: MethodDefinition, kind: Es2pandaMethodDefinitionKind, key: Expression, value: Expression, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition { + static updateMethodDefinition(original: MethodDefinition | undefined, kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition | undefined { return new MethodDefinition(global.generatedEs2panda._UpdateMethodDefinition(global.context, passNode(original), kind, passNode(key), passNode(value), modifiers, isComputed)) } get kindConst(): Es2pandaMethodDefinitionKind { @@ -53,17 +54,17 @@ export class MethodDefinition extends ClassElement { get overloadsConst(): readonly MethodDefinition[] { return unpackNodeArray(global.generatedEs2panda._MethodDefinitionOverloadsConst(global.context, this.peer)) } - get baseOverloadMethodConst(): MethodDefinition { - return unpackNonNullableNode(global.generatedEs2panda._MethodDefinitionBaseOverloadMethodConst(global.context, this.peer)) + get baseOverloadMethodConst(): MethodDefinition | undefined { + return unpackNode(global.generatedEs2panda._MethodDefinitionBaseOverloadMethodConst(global.context, this.peer)) } - get baseOverloadMethod(): MethodDefinition { - return unpackNonNullableNode(global.generatedEs2panda._MethodDefinitionBaseOverloadMethod(global.context, this.peer)) + get baseOverloadMethod(): MethodDefinition | undefined { + return unpackNode(global.generatedEs2panda._MethodDefinitionBaseOverloadMethod(global.context, this.peer)) } - get asyncPairMethodConst(): MethodDefinition { - return unpackNonNullableNode(global.generatedEs2panda._MethodDefinitionAsyncPairMethodConst(global.context, this.peer)) + get asyncPairMethodConst(): MethodDefinition | undefined { + return unpackNode(global.generatedEs2panda._MethodDefinitionAsyncPairMethodConst(global.context, this.peer)) } - get asyncPairMethod(): MethodDefinition { - return unpackNonNullableNode(global.generatedEs2panda._MethodDefinitionAsyncPairMethod(global.context, this.peer)) + get asyncPairMethod(): MethodDefinition | undefined { + return unpackNode(global.generatedEs2panda._MethodDefinitionAsyncPairMethod(global.context, this.peer)) } } export function isMethodDefinition(node: AstNode): node is MethodDefinition { diff --git a/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts b/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts index b1470f1dc..a8060bb1b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class NamedType extends TypeNode { super(pointer) console.warn("Warning: stub node NamedType") } - static createNamedType(name: Identifier): NamedType { + static createNamedType(name?: Identifier): NamedType | undefined { return new NamedType(global.generatedEs2panda._CreateNamedType(global.context, passNode(name))) } - static updateNamedType(original: NamedType, name: Identifier): NamedType { + static updateNamedType(original?: NamedType, name?: Identifier): NamedType | undefined { return new NamedType(global.generatedEs2panda._UpdateNamedType(global.context, passNode(original), passNode(name))) } - get nameConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._NamedTypeNameConst(global.context, this.peer)) + get nameConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._NamedTypeNameConst(global.context, this.peer)) } - get typeParamsConst(): TSTypeParameterInstantiation { - return unpackNonNullableNode(global.generatedEs2panda._NamedTypeTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._NamedTypeTypeParamsConst(global.context, this.peer)) } get isNullableConst(): boolean { return global.generatedEs2panda._NamedTypeIsNullableConst(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 95a6ba74c..1c43309d0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,14 +33,14 @@ export class NewExpression extends Expression { super(pointer) console.warn("Warning: stub node NewExpression") } - static createNewExpression(callee: Expression, _arguments: readonly Expression[], argumentsLen: number): NewExpression { + static createNewExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): NewExpression | undefined { return new NewExpression(global.generatedEs2panda._CreateNewExpression(global.context, passNode(callee), passNodeArray(_arguments), argumentsLen)) } - static updateNewExpression(original: NewExpression, callee: Expression, _arguments: readonly Expression[], argumentsLen: number): NewExpression { + static updateNewExpression(original: NewExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): NewExpression | undefined { return new NewExpression(global.generatedEs2panda._UpdateNewExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), argumentsLen)) } - get calleeConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._NewExpressionCalleeConst(global.context, this.peer)) + get calleeConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._NewExpressionCalleeConst(global.context, this.peer)) } get argumentsConst(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._NewExpressionArgumentsConst(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 4ade1d445..b61e7aa8c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class NullLiteral extends Literal { super(pointer) console.warn("Warning: stub node NullLiteral") } - static createNullLiteral(): NullLiteral { + static createNullLiteral(): NullLiteral | undefined { return new NullLiteral(global.generatedEs2panda._CreateNullLiteral(global.context)) } - static updateNullLiteral(original: NullLiteral): NullLiteral { + static updateNullLiteral(original?: NullLiteral): NullLiteral | undefined { return new NullLiteral(global.generatedEs2panda._UpdateNullLiteral(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts index ec7bbd5cc..0677d42de 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts index ebc151cfd..1c8e9eea7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -46,8 +47,8 @@ export abstract class ObjectExpression extends AnnotatedExpression { get decoratorsConst(): readonly Decorator[] { return unpackNodeArray(global.generatedEs2panda._ObjectExpressionDecoratorsConst(global.context, this.peer)) } - get typeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._ObjectExpressionTypeAnnotationConst(global.context, this.peer)) + get typeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ObjectExpressionTypeAnnotationConst(global.context, this.peer)) } } export function isObjectExpression(node: AstNode): node is ObjectExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts index c13fe2372..ec426f5fc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class OmittedExpression extends Expression { super(pointer) console.warn("Warning: stub node OmittedExpression") } - static createOmittedExpression(): OmittedExpression { + static createOmittedExpression(): OmittedExpression | undefined { return new OmittedExpression(global.generatedEs2panda._CreateOmittedExpression(global.context)) } - static updateOmittedExpression(original: OmittedExpression): OmittedExpression { + static updateOmittedExpression(original?: OmittedExpression): OmittedExpression | undefined { return new OmittedExpression(global.generatedEs2panda._UpdateOmittedExpression(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts b/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts index 95f2eabb3..2dde8584e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class OpaqueTypeNode extends TypeNode { super(pointer) console.warn("Warning: stub node OpaqueTypeNode") } - static create1OpaqueTypeNode(): OpaqueTypeNode { + static create1OpaqueTypeNode(): OpaqueTypeNode | undefined { return new OpaqueTypeNode(global.generatedEs2panda._CreateOpaqueTypeNode1(global.context)) } - static update1OpaqueTypeNode(original: OpaqueTypeNode): OpaqueTypeNode { + static update1OpaqueTypeNode(original?: OpaqueTypeNode): OpaqueTypeNode | undefined { return new OpaqueTypeNode(global.generatedEs2panda._UpdateOpaqueTypeNode1(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts index eba245d66..115f28cb4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,17 +34,17 @@ export class PrefixAssertionExpression extends Expression { super(pointer) console.warn("Warning: stub node PrefixAssertionExpression") } - static createPrefixAssertionExpression(expr: Expression, type: TypeNode): PrefixAssertionExpression { + static createPrefixAssertionExpression(expr?: Expression, type?: TypeNode): PrefixAssertionExpression | undefined { return new PrefixAssertionExpression(global.generatedEs2panda._CreatePrefixAssertionExpression(global.context, passNode(expr), passNode(type))) } - static updatePrefixAssertionExpression(original: PrefixAssertionExpression, expr: Expression, type: TypeNode): PrefixAssertionExpression { + static updatePrefixAssertionExpression(original?: PrefixAssertionExpression, expr?: Expression, type?: TypeNode): PrefixAssertionExpression | undefined { return new PrefixAssertionExpression(global.generatedEs2panda._UpdatePrefixAssertionExpression(global.context, passNode(original), passNode(expr), passNode(type))) } - get exprConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._PrefixAssertionExpressionExprConst(global.context, this.peer)) + get exprConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._PrefixAssertionExpressionExprConst(global.context, this.peer)) } - get typeConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._PrefixAssertionExpressionTypeConst(global.context, this.peer)) + get typeConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._PrefixAssertionExpressionTypeConst(global.context, this.peer)) } } export function isPrefixAssertionExpression(node: AstNode): node is PrefixAssertionExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/Property.ts b/arkoala-arkts/libarkts/src/generated/peers/Property.ts index c02700a1e..67f37e128 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Property.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Property.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,29 +34,29 @@ export class Property extends Expression { super(pointer) console.warn("Warning: stub node Property") } - static createProperty(key: Expression, value: Expression): Property { + static createProperty(key?: Expression, value?: Expression): Property | undefined { return new Property(global.generatedEs2panda._CreateProperty(global.context, passNode(key), passNode(value))) } - static updateProperty(original: Property, key: Expression, value: Expression): Property { + static updateProperty(original?: Property, key?: Expression, value?: Expression): Property | undefined { return new Property(global.generatedEs2panda._UpdateProperty(global.context, passNode(original), passNode(key), passNode(value))) } - static create1Property(kind: Es2pandaPropertyKind, key: Expression, value: Expression, isMethod: boolean, isComputed: boolean): Property { + static create1Property(kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property | undefined { return new Property(global.generatedEs2panda._CreateProperty1(global.context, kind, passNode(key), passNode(value), isMethod, isComputed)) } - static update1Property(original: Property, kind: Es2pandaPropertyKind, key: Expression, value: Expression, isMethod: boolean, isComputed: boolean): Property { + static update1Property(original: Property | undefined, kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property | undefined { return new Property(global.generatedEs2panda._UpdateProperty1(global.context, passNode(original), kind, passNode(key), passNode(value), isMethod, isComputed)) } - get key(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._PropertyKey(global.context, this.peer)) + get key(): Expression | undefined { + return unpackNode(global.generatedEs2panda._PropertyKey(global.context, this.peer)) } - get keyConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._PropertyKeyConst(global.context, this.peer)) + get keyConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._PropertyKeyConst(global.context, this.peer)) } - get valueConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._PropertyValueConst(global.context, this.peer)) + get valueConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._PropertyValueConst(global.context, this.peer)) } - get value(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._PropertyValue(global.context, this.peer)) + get value(): Expression | undefined { + return unpackNode(global.generatedEs2panda._PropertyValue(global.context, this.peer)) } get kindConst(): Es2pandaPropertyKind { return global.generatedEs2panda._PropertyKindConst(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 c5f387649..002fab298 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,10 +34,10 @@ export class RegExpLiteral extends Literal { super(pointer) console.warn("Warning: stub node RegExpLiteral") } - static createRegExpLiteral(pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral { + static createRegExpLiteral(pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral | undefined { return new RegExpLiteral(global.generatedEs2panda._CreateRegExpLiteral(global.context, pattern, flags, flagsStr)) } - static updateRegExpLiteral(original: RegExpLiteral, pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral { + static updateRegExpLiteral(original: RegExpLiteral | undefined, pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral | undefined { return new RegExpLiteral(global.generatedEs2panda._UpdateRegExpLiteral(global.context, passNode(original), pattern, flags, flagsStr)) } get patternConst(): string { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts index fbc12dc45..6d416cdbe 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,23 +34,23 @@ export class ReturnStatement extends Statement { super(pointer) console.warn("Warning: stub node ReturnStatement") } - static createReturnStatement(): ReturnStatement { + static createReturnStatement(): ReturnStatement | undefined { return new ReturnStatement(global.generatedEs2panda._CreateReturnStatement(global.context)) } - static updateReturnStatement(original: ReturnStatement): ReturnStatement { + static updateReturnStatement(original?: ReturnStatement): ReturnStatement | undefined { return new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement(global.context, passNode(original))) } - static create1ReturnStatement(argument: Expression): ReturnStatement { + static create1ReturnStatement(argument?: Expression): ReturnStatement | undefined { return new ReturnStatement(global.generatedEs2panda._CreateReturnStatement1(global.context, passNode(argument))) } - static update1ReturnStatement(original: ReturnStatement, argument: Expression): ReturnStatement { + static update1ReturnStatement(original?: ReturnStatement, argument?: Expression): ReturnStatement | undefined { return new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement1(global.context, passNode(original), passNode(argument))) } - get argument(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ReturnStatementArgument(global.context, this.peer)) + get argument(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ReturnStatementArgument(global.context, this.peer)) } - get argumentConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ReturnStatementArgumentConst(global.context, this.peer)) + get argumentConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ReturnStatementArgumentConst(global.context, this.peer)) } } export function isReturnStatement(node: AstNode): node is ReturnStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts b/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts index 3b6acfd82..062ae458e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -38,11 +39,11 @@ export class ScriptFunction extends AstNode { super(pointer) console.warn("Warning: stub node ScriptFunction") } - get idConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ScriptFunctionIdConst(global.context, this.peer)) + get idConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionIdConst(global.context, this.peer)) } - get id(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._ScriptFunctionId(global.context, this.peer)) + get id(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionId(global.context, this.peer)) } get paramsConst(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._ScriptFunctionParamsConst(global.context, this.peer)) @@ -56,23 +57,23 @@ export class ScriptFunction extends AstNode { get returnStatements(): readonly ReturnStatement[] { return unpackNodeArray(global.generatedEs2panda._ScriptFunctionReturnStatements(global.context, this.peer)) } - get typeParamsConst(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._ScriptFunctionTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionTypeParamsConst(global.context, this.peer)) } - get typeParams(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._ScriptFunctionTypeParams(global.context, this.peer)) + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionTypeParams(global.context, this.peer)) } - get bodyConst(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._ScriptFunctionBodyConst(global.context, this.peer)) + get bodyConst(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionBodyConst(global.context, this.peer)) } - get body(): AstNode { - return unpackNonNullableNode(global.generatedEs2panda._ScriptFunctionBody(global.context, this.peer)) + get body(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionBody(global.context, this.peer)) } - get returnTypeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._ScriptFunctionReturnTypeAnnotationConst(global.context, this.peer)) + get returnTypeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionReturnTypeAnnotationConst(global.context, this.peer)) } - get returnTypeAnnotation(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._ScriptFunctionReturnTypeAnnotation(global.context, this.peer)) + get returnTypeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionReturnTypeAnnotation(global.context, this.peer)) } get isEntryPointConst(): boolean { return global.generatedEs2panda._ScriptFunctionIsEntryPointConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts index a5d027b91..df3665420 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class SequenceExpression extends Expression { super(pointer) console.warn("Warning: stub node SequenceExpression") } - static createSequenceExpression(sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression { + static createSequenceExpression(sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression | undefined { return new SequenceExpression(global.generatedEs2panda._CreateSequenceExpression(global.context, passNodeArray(sequence_arg), sequenceLen)) } - static updateSequenceExpression(original: SequenceExpression, sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression { + static updateSequenceExpression(original: SequenceExpression | undefined, sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression | undefined { return new SequenceExpression(global.generatedEs2panda._UpdateSequenceExpression(global.context, passNode(original), passNodeArray(sequence_arg), sequenceLen)) } get sequenceConst(): readonly Expression[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts b/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts index 97c264b9e..85b1a750c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,11 +35,11 @@ export abstract class SpreadElement extends AnnotatedExpression { super(pointer) console.warn("Warning: stub node SpreadElement") } - get argumentConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._SpreadElementArgumentConst(global.context, this.peer)) + get argumentConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._SpreadElementArgumentConst(global.context, this.peer)) } - get argument(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._SpreadElementArgument(global.context, this.peer)) + get argument(): Expression | undefined { + return unpackNode(global.generatedEs2panda._SpreadElementArgument(global.context, this.peer)) } get isOptionalConst(): boolean { return global.generatedEs2panda._SpreadElementIsOptionalConst(global.context, this.peer) @@ -46,8 +47,8 @@ export abstract class SpreadElement extends AnnotatedExpression { get decoratorsConst(): readonly Decorator[] { return unpackNodeArray(global.generatedEs2panda._SpreadElementDecoratorsConst(global.context, this.peer)) } - get typeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._SpreadElementTypeAnnotationConst(global.context, this.peer)) + get typeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._SpreadElementTypeAnnotationConst(global.context, this.peer)) } } export function isSpreadElement(node: AstNode): node is SpreadElement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/Statement.ts b/arkoala-arkts/libarkts/src/generated/peers/Statement.ts index b8d2f6045..b3c39e95d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Statement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Statement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts index 2ac4f4551..cec3d65cd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,13 +33,13 @@ export class StringLiteral extends Literal { super(pointer) console.warn("Warning: stub node StringLiteral") } - static updateStringLiteral(original: StringLiteral): StringLiteral { + static updateStringLiteral(original?: StringLiteral): StringLiteral | undefined { return new StringLiteral(global.generatedEs2panda._UpdateStringLiteral(global.context, passNode(original))) } - static create1StringLiteral(str: string): StringLiteral { + static create1StringLiteral(str: string): StringLiteral | undefined { return new StringLiteral(global.generatedEs2panda._CreateStringLiteral1(global.context, str)) } - static update1StringLiteral(original: StringLiteral, str: string): StringLiteral { + static update1StringLiteral(original: StringLiteral | undefined, str: string): StringLiteral | undefined { return new StringLiteral(global.generatedEs2panda._UpdateStringLiteral1(global.context, passNode(original), str)) } get strConst(): string { diff --git a/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts index f6e53b920..cfd0c78ca 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class SuperExpression extends Expression { super(pointer) console.warn("Warning: stub node SuperExpression") } - static createSuperExpression(): SuperExpression { + static createSuperExpression(): SuperExpression | undefined { return new SuperExpression(global.generatedEs2panda._CreateSuperExpression(global.context)) } - static updateSuperExpression(original: SuperExpression): SuperExpression { + static updateSuperExpression(original?: SuperExpression): SuperExpression | undefined { return new SuperExpression(global.generatedEs2panda._UpdateSuperExpression(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts index 2b45262e6..64bcdb304 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,11 +34,11 @@ export class SwitchCaseStatement extends Statement { super(pointer) console.warn("Warning: stub node SwitchCaseStatement") } - get test(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._SwitchCaseStatementTest(global.context, this.peer)) + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._SwitchCaseStatementTest(global.context, this.peer)) } - get testConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._SwitchCaseStatementTestConst(global.context, this.peer)) + get testConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._SwitchCaseStatementTestConst(global.context, this.peer)) } get consequentConst(): readonly Statement[] { return unpackNodeArray(global.generatedEs2panda._SwitchCaseStatementConsequentConst(global.context, this.peer)) diff --git a/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts index 6517d7d09..824fc4be8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class SwitchStatement extends Statement { super(pointer) console.warn("Warning: stub node SwitchStatement") } - static createSwitchStatement(discriminant: Expression, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement { + static createSwitchStatement(discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement | undefined { return new SwitchStatement(global.generatedEs2panda._CreateSwitchStatement(global.context, passNode(discriminant), passNodeArray(cases), casesLen)) } - static updateSwitchStatement(original: SwitchStatement, discriminant: Expression, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement { + static updateSwitchStatement(original: SwitchStatement | undefined, discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement | undefined { return new SwitchStatement(global.generatedEs2panda._UpdateSwitchStatement(global.context, passNode(original), passNode(discriminant), passNodeArray(cases), casesLen)) } - get discriminantConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._SwitchStatementDiscriminantConst(global.context, this.peer)) + get discriminantConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._SwitchStatementDiscriminantConst(global.context, this.peer)) } - get discriminant(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._SwitchStatementDiscriminant(global.context, this.peer)) + get discriminant(): Expression | undefined { + return unpackNode(global.generatedEs2panda._SwitchStatementDiscriminant(global.context, this.peer)) } get casesConst(): readonly SwitchCaseStatement[] { return unpackNodeArray(global.generatedEs2panda._SwitchStatementCasesConst(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 db404e74e..a9e9bc5c4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSAnyKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSAnyKeyword") } - static createTSAnyKeyword(): TSAnyKeyword { + static createTSAnyKeyword(): TSAnyKeyword | undefined { return new TSAnyKeyword(global.generatedEs2panda._CreateTSAnyKeyword(global.context)) } - static updateTSAnyKeyword(original: TSAnyKeyword): TSAnyKeyword { + static updateTSAnyKeyword(original?: TSAnyKeyword): TSAnyKeyword | undefined { return new TSAnyKeyword(global.generatedEs2panda._UpdateTSAnyKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts index a2b52117b..7c08bd7bc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,14 +33,14 @@ export class TSArrayType extends TypeNode { super(pointer) console.warn("Warning: stub node TSArrayType") } - static createTSArrayType(elementType: TypeNode): TSArrayType { + static createTSArrayType(elementType?: TypeNode): TSArrayType | undefined { return new TSArrayType(global.generatedEs2panda._CreateTSArrayType(global.context, passNode(elementType))) } - static updateTSArrayType(original: TSArrayType, elementType: TypeNode): TSArrayType { + static updateTSArrayType(original?: TSArrayType, elementType?: TypeNode): TSArrayType | undefined { return new TSArrayType(global.generatedEs2panda._UpdateTSArrayType(global.context, passNode(original), passNode(elementType))) } - get elementTypeConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSArrayTypeElementTypeConst(global.context, this.peer)) + get elementTypeConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSArrayTypeElementTypeConst(global.context, this.peer)) } } export function isTSArrayType(node: AstNode): node is TSArrayType { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts index 82d8837b0..6d892689c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,20 +35,20 @@ export class TSAsExpression extends AnnotatedExpression { super(pointer) console.warn("Warning: stub node TSAsExpression") } - static createTSAsExpression(expression: Expression, typeAnnotation: TypeNode, isConst: boolean): TSAsExpression { + static createTSAsExpression(expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression | undefined { return new TSAsExpression(global.generatedEs2panda._CreateTSAsExpression(global.context, passNode(expression), passNode(typeAnnotation), isConst)) } - static updateTSAsExpression(original: TSAsExpression, expression: Expression, typeAnnotation: TypeNode, isConst: boolean): TSAsExpression { + static updateTSAsExpression(original: TSAsExpression | undefined, expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression | undefined { return new TSAsExpression(global.generatedEs2panda._UpdateTSAsExpression(global.context, passNode(original), passNode(expression), passNode(typeAnnotation), isConst)) } - get exprConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSAsExpressionExprConst(global.context, this.peer)) + get exprConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSAsExpressionExprConst(global.context, this.peer)) } get isConstConst(): boolean { return global.generatedEs2panda._TSAsExpressionIsConstConst(global.context, this.peer) } - get typeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSAsExpressionTypeAnnotationConst(global.context, this.peer)) + get typeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSAsExpressionTypeAnnotationConst(global.context, this.peer)) } } export function isTSAsExpression(node: AstNode): node is TSAsExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts index 74a560b10..5c5e0204e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSBigintKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSBigintKeyword") } - static createTSBigintKeyword(): TSBigintKeyword { + static createTSBigintKeyword(): TSBigintKeyword | undefined { return new TSBigintKeyword(global.generatedEs2panda._CreateTSBigintKeyword(global.context)) } - static updateTSBigintKeyword(original: TSBigintKeyword): TSBigintKeyword { + static updateTSBigintKeyword(original?: TSBigintKeyword): TSBigintKeyword | undefined { return new TSBigintKeyword(global.generatedEs2panda._UpdateTSBigintKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts index 95635c0c9..25fd5d2b4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSBooleanKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSBooleanKeyword") } - static createTSBooleanKeyword(): TSBooleanKeyword { + static createTSBooleanKeyword(): TSBooleanKeyword | undefined { return new TSBooleanKeyword(global.generatedEs2panda._CreateTSBooleanKeyword(global.context)) } - static updateTSBooleanKeyword(original: TSBooleanKeyword): TSBooleanKeyword { + static updateTSBooleanKeyword(original?: TSBooleanKeyword): TSBooleanKeyword | undefined { return new TSBooleanKeyword(global.generatedEs2panda._UpdateTSBooleanKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts b/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts index ec9e99903..a5e43b62a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,26 +34,26 @@ export class TSClassImplements extends Expression { super(pointer) console.warn("Warning: stub node TSClassImplements") } - static createTSClassImplements(expression: Expression, typeParameters: TSTypeParameterInstantiation): TSClassImplements { + static createTSClassImplements(expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements | undefined { return new TSClassImplements(global.generatedEs2panda._CreateTSClassImplements(global.context, passNode(expression), passNode(typeParameters))) } - static updateTSClassImplements(original: TSClassImplements, expression: Expression, typeParameters: TSTypeParameterInstantiation): TSClassImplements { + static updateTSClassImplements(original?: TSClassImplements, expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements | undefined { return new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements(global.context, passNode(original), passNode(expression), passNode(typeParameters))) } - static create1TSClassImplements(expression: Expression): TSClassImplements { + static create1TSClassImplements(expression?: Expression): TSClassImplements | undefined { return new TSClassImplements(global.generatedEs2panda._CreateTSClassImplements1(global.context, passNode(expression))) } - static update1TSClassImplements(original: TSClassImplements, expression: Expression): TSClassImplements { + static update1TSClassImplements(original?: TSClassImplements, expression?: Expression): TSClassImplements | undefined { return new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements1(global.context, passNode(original), passNode(expression))) } - get expr(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSClassImplementsExpr(global.context, this.peer)) + get expr(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSClassImplementsExpr(global.context, this.peer)) } - get exprConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSClassImplementsExprConst(global.context, this.peer)) + get exprConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSClassImplementsExprConst(global.context, this.peer)) } - get typeParametersConst(): TSTypeParameterInstantiation { - return unpackNonNullableNode(global.generatedEs2panda._TSClassImplementsTypeParametersConst(global.context, this.peer)) + get typeParametersConst(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._TSClassImplementsTypeParametersConst(global.context, this.peer)) } } export function isTSClassImplements(node: AstNode): node is TSClassImplements { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts index 28ef5228e..21f9982bd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,23 +34,23 @@ export class TSConditionalType extends TypeNode { super(pointer) console.warn("Warning: stub node TSConditionalType") } - static createTSConditionalType(checkType: Expression, extendsType: Expression, trueType: Expression, falseType: Expression): TSConditionalType { + static createTSConditionalType(checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType | undefined { return new TSConditionalType(global.generatedEs2panda._CreateTSConditionalType(global.context, passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType))) } - static updateTSConditionalType(original: TSConditionalType, checkType: Expression, extendsType: Expression, trueType: Expression, falseType: Expression): TSConditionalType { + static updateTSConditionalType(original?: TSConditionalType, checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType | undefined { return new TSConditionalType(global.generatedEs2panda._UpdateTSConditionalType(global.context, passNode(original), passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType))) } - get checkTypeConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSConditionalTypeCheckTypeConst(global.context, this.peer)) + get checkTypeConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSConditionalTypeCheckTypeConst(global.context, this.peer)) } - get extendsTypeConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSConditionalTypeExtendsTypeConst(global.context, this.peer)) + get extendsTypeConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSConditionalTypeExtendsTypeConst(global.context, this.peer)) } - get trueTypeConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSConditionalTypeTrueTypeConst(global.context, this.peer)) + get trueTypeConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSConditionalTypeTrueTypeConst(global.context, this.peer)) } - get falseTypeConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSConditionalTypeFalseTypeConst(global.context, this.peer)) + get falseTypeConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSConditionalTypeFalseTypeConst(global.context, this.peer)) } } export function isTSConditionalType(node: AstNode): node is TSConditionalType { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts index 82d27b378..eeb36fa8a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,20 +35,20 @@ export class TSConstructorType extends TypeNode { super(pointer) console.warn("Warning: stub node TSConstructorType") } - get typeParamsConst(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSConstructorTypeTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSConstructorTypeTypeParamsConst(global.context, this.peer)) } - get typeParams(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSConstructorTypeTypeParams(global.context, this.peer)) + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSConstructorTypeTypeParams(global.context, this.peer)) } get paramsConst(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._TSConstructorTypeParamsConst(global.context, this.peer)) } - get returnTypeConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSConstructorTypeReturnTypeConst(global.context, this.peer)) + get returnTypeConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSConstructorTypeReturnTypeConst(global.context, this.peer)) } - get returnType(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSConstructorTypeReturnType(global.context, this.peer)) + get returnType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSConstructorTypeReturnType(global.context, this.peer)) } get abstractConst(): boolean { return global.generatedEs2panda._TSConstructorTypeAbstractConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts index 31b9b3acf..d02c58204 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -35,17 +36,17 @@ export class TSEnumDeclaration extends TypedStatement { super(pointer) console.warn("Warning: stub node TSEnumDeclaration") } - static createTSEnumDeclaration(key: Identifier, members: readonly AstNode[], membersLen: number, isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration { + static createTSEnumDeclaration(key: Identifier | undefined, members: readonly AstNode[], membersLen: number, isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration | undefined { return new TSEnumDeclaration(global.generatedEs2panda._CreateTSEnumDeclaration(global.context, passNode(key), passNodeArray(members), membersLen, isConst, isStatic, isDeclare)) } - static updateTSEnumDeclaration(original: TSEnumDeclaration, key: Identifier, members: readonly AstNode[], membersLen: number, isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration { + static updateTSEnumDeclaration(original: TSEnumDeclaration | undefined, key: Identifier | undefined, members: readonly AstNode[], membersLen: number, isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration | undefined { return new TSEnumDeclaration(global.generatedEs2panda._UpdateTSEnumDeclaration(global.context, passNode(original), passNode(key), passNodeArray(members), membersLen, isConst, isStatic, isDeclare)) } - get keyConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._TSEnumDeclarationKeyConst(global.context, this.peer)) + get keyConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSEnumDeclarationKeyConst(global.context, this.peer)) } - get key(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._TSEnumDeclarationKey(global.context, this.peer)) + get key(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSEnumDeclarationKey(global.context, this.peer)) } get membersConst(): readonly AstNode[] { return unpackNodeArray(global.generatedEs2panda._TSEnumDeclarationMembersConst(global.context, this.peer)) @@ -53,8 +54,8 @@ export class TSEnumDeclaration extends TypedStatement { get internalNameConst(): string { return global.generatedEs2panda._TSEnumDeclarationInternalNameConst(global.context, this.peer) } - get boxedClassConst(): ClassDefinition { - return unpackNonNullableNode(global.generatedEs2panda._TSEnumDeclarationBoxedClassConst(global.context, this.peer)) + get boxedClassConst(): ClassDefinition | undefined { + return unpackNode(global.generatedEs2panda._TSEnumDeclarationBoxedClassConst(global.context, this.peer)) } get isConstConst(): boolean { return global.generatedEs2panda._TSEnumDeclarationIsConstConst(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 a183c20cf..30fd92c70 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,29 +34,29 @@ export class TSEnumMember extends Statement { super(pointer) console.warn("Warning: stub node TSEnumMember") } - static createTSEnumMember(key: Expression, init: Expression): TSEnumMember { + static createTSEnumMember(key?: Expression, init?: Expression): TSEnumMember | undefined { return new TSEnumMember(global.generatedEs2panda._CreateTSEnumMember(global.context, passNode(key), passNode(init))) } - static updateTSEnumMember(original: TSEnumMember, key: Expression, init: Expression): TSEnumMember { + static updateTSEnumMember(original?: TSEnumMember, key?: Expression, init?: Expression): TSEnumMember | undefined { return new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember(global.context, passNode(original), passNode(key), passNode(init))) } - static create1TSEnumMember(key: Expression, init: Expression, isGenerated: boolean): TSEnumMember { + static create1TSEnumMember(key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember | undefined { return new TSEnumMember(global.generatedEs2panda._CreateTSEnumMember1(global.context, passNode(key), passNode(init), isGenerated)) } - static update1TSEnumMember(original: TSEnumMember, key: Expression, init: Expression, isGenerated: boolean): TSEnumMember { + static update1TSEnumMember(original: TSEnumMember | undefined, key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember | undefined { return new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember1(global.context, passNode(original), passNode(key), passNode(init), isGenerated)) } - get keyConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSEnumMemberKeyConst(global.context, this.peer)) + get keyConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSEnumMemberKeyConst(global.context, this.peer)) } - get key(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSEnumMemberKey(global.context, this.peer)) + get key(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSEnumMemberKey(global.context, this.peer)) } - get initConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSEnumMemberInitConst(global.context, this.peer)) + get initConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSEnumMemberInitConst(global.context, this.peer)) } - get init(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSEnumMemberInit(global.context, this.peer)) + get init(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSEnumMemberInit(global.context, this.peer)) } get isGeneratedConst(): boolean { return global.generatedEs2panda._TSEnumMemberIsGeneratedConst(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 ccc18bad6..68f06199e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,14 +33,14 @@ export class TSExternalModuleReference extends Expression { super(pointer) console.warn("Warning: stub node TSExternalModuleReference") } - static createTSExternalModuleReference(expr: Expression): TSExternalModuleReference { + static createTSExternalModuleReference(expr?: Expression): TSExternalModuleReference | undefined { return new TSExternalModuleReference(global.generatedEs2panda._CreateTSExternalModuleReference(global.context, passNode(expr))) } - static updateTSExternalModuleReference(original: TSExternalModuleReference, expr: Expression): TSExternalModuleReference { + static updateTSExternalModuleReference(original?: TSExternalModuleReference, expr?: Expression): TSExternalModuleReference | undefined { return new TSExternalModuleReference(global.generatedEs2panda._UpdateTSExternalModuleReference(global.context, passNode(original), passNode(expr))) } - get exprConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSExternalModuleReferenceExprConst(global.context, this.peer)) + get exprConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSExternalModuleReferenceExprConst(global.context, this.peer)) } } export function isTSExternalModuleReference(node: AstNode): node is TSExternalModuleReference { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts index 786f45c08..a69de43ee 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,20 +35,20 @@ export class TSFunctionType extends TypeNode { super(pointer) console.warn("Warning: stub node TSFunctionType") } - get typeParamsConst(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSFunctionTypeTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSFunctionTypeTypeParamsConst(global.context, this.peer)) } - get typeParams(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSFunctionTypeTypeParams(global.context, this.peer)) + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSFunctionTypeTypeParams(global.context, this.peer)) } get paramsConst(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._TSFunctionTypeParamsConst(global.context, this.peer)) } - get returnTypeConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSFunctionTypeReturnTypeConst(global.context, this.peer)) + get returnTypeConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSFunctionTypeReturnTypeConst(global.context, this.peer)) } - get returnType(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSFunctionTypeReturnType(global.context, this.peer)) + get returnType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSFunctionTypeReturnType(global.context, this.peer)) } } export function isTSFunctionType(node: AstNode): node is TSFunctionType { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts index 489137825..15d089924 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class TSImportEqualsDeclaration extends Statement { super(pointer) console.warn("Warning: stub node TSImportEqualsDeclaration") } - static createTSImportEqualsDeclaration(id: Identifier, moduleReference: Expression, isExport: boolean): TSImportEqualsDeclaration { + static createTSImportEqualsDeclaration(id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration | undefined { return new TSImportEqualsDeclaration(global.generatedEs2panda._CreateTSImportEqualsDeclaration(global.context, passNode(id), passNode(moduleReference), isExport)) } - static updateTSImportEqualsDeclaration(original: TSImportEqualsDeclaration, id: Identifier, moduleReference: Expression, isExport: boolean): TSImportEqualsDeclaration { + static updateTSImportEqualsDeclaration(original: TSImportEqualsDeclaration | undefined, id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration | undefined { return new TSImportEqualsDeclaration(global.generatedEs2panda._UpdateTSImportEqualsDeclaration(global.context, passNode(original), passNode(id), passNode(moduleReference), isExport)) } - get idConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._TSImportEqualsDeclarationIdConst(global.context, this.peer)) + get idConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSImportEqualsDeclarationIdConst(global.context, this.peer)) } - get moduleReferenceConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSImportEqualsDeclarationModuleReferenceConst(global.context, this.peer)) + get moduleReferenceConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSImportEqualsDeclarationModuleReferenceConst(global.context, this.peer)) } get isExportConst(): boolean { return global.generatedEs2panda._TSImportEqualsDeclarationIsExportConst(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 8ec5fb598..d3baf27b2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,20 +35,20 @@ export class TSImportType extends TypeNode { super(pointer) console.warn("Warning: stub node TSImportType") } - static createTSImportType(param: Expression, typeParams: TSTypeParameterInstantiation, qualifier: Expression, isTypeof: boolean): TSImportType { + static createTSImportType(param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType | undefined { return new TSImportType(global.generatedEs2panda._CreateTSImportType(global.context, passNode(param), passNode(typeParams), passNode(qualifier), isTypeof)) } - static updateTSImportType(original: TSImportType, param: Expression, typeParams: TSTypeParameterInstantiation, qualifier: Expression, isTypeof: boolean): TSImportType { + static updateTSImportType(original: TSImportType | undefined, param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType | undefined { return new TSImportType(global.generatedEs2panda._UpdateTSImportType(global.context, passNode(original), passNode(param), passNode(typeParams), passNode(qualifier), isTypeof)) } - get paramConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSImportTypeParamConst(global.context, this.peer)) + get paramConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSImportTypeParamConst(global.context, this.peer)) } - get typeParamsConst(): TSTypeParameterInstantiation { - return unpackNonNullableNode(global.generatedEs2panda._TSImportTypeTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._TSImportTypeTypeParamsConst(global.context, this.peer)) } - get qualifierConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSImportTypeQualifierConst(global.context, this.peer)) + get qualifierConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSImportTypeQualifierConst(global.context, this.peer)) } get isTypeofConst(): boolean { return global.generatedEs2panda._TSImportTypeIsTypeofConst(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 8e0db344f..929d213b3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class TSIndexSignature extends TypedAstNode { super(pointer) console.warn("Warning: stub node TSIndexSignature") } - static createTSIndexSignature(param: Expression, typeAnnotation: TypeNode, readonly_arg: boolean): TSIndexSignature { + static createTSIndexSignature(param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature | undefined { return new TSIndexSignature(global.generatedEs2panda._CreateTSIndexSignature(global.context, passNode(param), passNode(typeAnnotation), readonly_arg)) } - static updateTSIndexSignature(original: TSIndexSignature, param: Expression, typeAnnotation: TypeNode, readonly_arg: boolean): TSIndexSignature { + static updateTSIndexSignature(original: TSIndexSignature | undefined, param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature | undefined { return new TSIndexSignature(global.generatedEs2panda._UpdateTSIndexSignature(global.context, passNode(original), passNode(param), passNode(typeAnnotation), readonly_arg)) } - get paramConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSIndexSignatureParamConst(global.context, this.peer)) + get paramConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSIndexSignatureParamConst(global.context, this.peer)) } - get typeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSIndexSignatureTypeAnnotationConst(global.context, this.peer)) + get typeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSIndexSignatureTypeAnnotationConst(global.context, this.peer)) } get readonlyConst(): boolean { return global.generatedEs2panda._TSIndexSignatureReadonlyConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts index 2290f4c9e..f1792697d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,17 +33,17 @@ export class TSIndexedAccessType extends TypeNode { super(pointer) console.warn("Warning: stub node TSIndexedAccessType") } - static createTSIndexedAccessType(objectType: TypeNode, indexType: TypeNode): TSIndexedAccessType { + static createTSIndexedAccessType(objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType | undefined { return new TSIndexedAccessType(global.generatedEs2panda._CreateTSIndexedAccessType(global.context, passNode(objectType), passNode(indexType))) } - static updateTSIndexedAccessType(original: TSIndexedAccessType, objectType: TypeNode, indexType: TypeNode): TSIndexedAccessType { + static updateTSIndexedAccessType(original?: TSIndexedAccessType, objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType | undefined { return new TSIndexedAccessType(global.generatedEs2panda._UpdateTSIndexedAccessType(global.context, passNode(original), passNode(objectType), passNode(indexType))) } - get objectTypeConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSIndexedAccessTypeObjectTypeConst(global.context, this.peer)) + get objectTypeConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSIndexedAccessTypeObjectTypeConst(global.context, this.peer)) } - get indexTypeConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSIndexedAccessTypeIndexTypeConst(global.context, this.peer)) + get indexTypeConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSIndexedAccessTypeIndexTypeConst(global.context, this.peer)) } } export function isTSIndexedAccessType(node: AstNode): node is TSIndexedAccessType { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts index c31fe75f1..f0b45fdbf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,14 +34,14 @@ export class TSInferType extends TypeNode { super(pointer) console.warn("Warning: stub node TSInferType") } - static createTSInferType(typeParam: TSTypeParameter): TSInferType { + static createTSInferType(typeParam?: TSTypeParameter): TSInferType | undefined { return new TSInferType(global.generatedEs2panda._CreateTSInferType(global.context, passNode(typeParam))) } - static updateTSInferType(original: TSInferType, typeParam: TSTypeParameter): TSInferType { + static updateTSInferType(original?: TSInferType, typeParam?: TSTypeParameter): TSInferType | undefined { return new TSInferType(global.generatedEs2panda._UpdateTSInferType(global.context, passNode(original), passNode(typeParam))) } - get typeParamConst(): TSTypeParameter { - return unpackNonNullableNode(global.generatedEs2panda._TSInferTypeTypeParamConst(global.context, this.peer)) + get typeParamConst(): TSTypeParameter | undefined { + return unpackNode(global.generatedEs2panda._TSInferTypeTypeParamConst(global.context, this.peer)) } } export function isTSInferType(node: AstNode): node is TSInferType { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts index 8b53601ed..284f28809 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSInterfaceBody extends Expression { super(pointer) console.warn("Warning: stub node TSInterfaceBody") } - static createTSInterfaceBody(body: readonly AstNode[], bodyLen: number): TSInterfaceBody { + static createTSInterfaceBody(body: readonly AstNode[], bodyLen: number): TSInterfaceBody | undefined { return new TSInterfaceBody(global.generatedEs2panda._CreateTSInterfaceBody(global.context, passNodeArray(body), bodyLen)) } - static updateTSInterfaceBody(original: TSInterfaceBody, body: readonly AstNode[], bodyLen: number): TSInterfaceBody { + static updateTSInterfaceBody(original: TSInterfaceBody | undefined, body: readonly AstNode[], bodyLen: number): TSInterfaceBody | undefined { return new TSInterfaceBody(global.generatedEs2panda._UpdateTSInterfaceBody(global.context, passNode(original), passNodeArray(body), bodyLen)) } get bodyPtr(): readonly AstNode[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts index a0c422920..f9bea7253 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -39,23 +40,23 @@ export class TSInterfaceDeclaration extends TypedStatement { super(pointer) console.warn("Warning: stub node TSInterfaceDeclaration") } - static createTSInterfaceDeclaration(_extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode, typeParams: AstNode, body: AstNode, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration { + static createTSInterfaceDeclaration(_extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration | undefined { return new TSInterfaceDeclaration(global.generatedEs2panda._CreateTSInterfaceDeclaration(global.context, passNodeArray(_extends), extendsLen, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal)) } - static updateTSInterfaceDeclaration(original: TSInterfaceDeclaration, _extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode, typeParams: AstNode, body: AstNode, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration { + static updateTSInterfaceDeclaration(original: TSInterfaceDeclaration | undefined, _extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration | undefined { return new TSInterfaceDeclaration(global.generatedEs2panda._UpdateTSInterfaceDeclaration(global.context, passNode(original), passNodeArray(_extends), extendsLen, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal)) } - get body(): TSInterfaceBody { - return unpackNonNullableNode(global.generatedEs2panda._TSInterfaceDeclarationBody(global.context, this.peer)) + get body(): TSInterfaceBody | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationBody(global.context, this.peer)) } - get bodyConst(): TSInterfaceBody { - return unpackNonNullableNode(global.generatedEs2panda._TSInterfaceDeclarationBodyConst(global.context, this.peer)) + get bodyConst(): TSInterfaceBody | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationBodyConst(global.context, this.peer)) } - get id(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._TSInterfaceDeclarationId(global.context, this.peer)) + get id(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationId(global.context, this.peer)) } - get idConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._TSInterfaceDeclarationIdConst(global.context, this.peer)) + get idConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationIdConst(global.context, this.peer)) } get internalNameConst(): string { return global.generatedEs2panda._TSInterfaceDeclarationInternalNameConst(global.context, this.peer) @@ -66,11 +67,11 @@ export class TSInterfaceDeclaration extends TypedStatement { get isFromExternalConst(): boolean { return global.generatedEs2panda._TSInterfaceDeclarationIsFromExternalConst(global.context, this.peer) } - get typeParamsConst(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSInterfaceDeclarationTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationTypeParamsConst(global.context, this.peer)) } - get typeParams(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSInterfaceDeclarationTypeParams(global.context, this.peer)) + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationTypeParams(global.context, this.peer)) } get extends(): readonly TSInterfaceHeritage[] { return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationExtends(global.context, this.peer)) @@ -81,11 +82,11 @@ export class TSInterfaceDeclaration extends TypedStatement { get decoratorsConst(): readonly Decorator[] { return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationDecoratorsConst(global.context, this.peer)) } - get getAnonClass(): ClassDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSInterfaceDeclarationGetAnonClass(global.context, this.peer)) + get getAnonClass(): ClassDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationGetAnonClass(global.context, this.peer)) } - get getAnonClassConst(): ClassDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSInterfaceDeclarationGetAnonClassConst(global.context, this.peer)) + get getAnonClassConst(): ClassDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationGetAnonClassConst(global.context, this.peer)) } get annotations(): readonly AnnotationUsage[] { return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationAnnotations(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 64f92f191..d7b633693 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,17 +34,17 @@ export class TSInterfaceHeritage extends Expression { super(pointer) console.warn("Warning: stub node TSInterfaceHeritage") } - static createTSInterfaceHeritage(expr: TypeNode): TSInterfaceHeritage { + static createTSInterfaceHeritage(expr?: TypeNode): TSInterfaceHeritage | undefined { return new TSInterfaceHeritage(global.generatedEs2panda._CreateTSInterfaceHeritage(global.context, passNode(expr))) } - static updateTSInterfaceHeritage(original: TSInterfaceHeritage, expr: TypeNode): TSInterfaceHeritage { + static updateTSInterfaceHeritage(original?: TSInterfaceHeritage, expr?: TypeNode): TSInterfaceHeritage | undefined { return new TSInterfaceHeritage(global.generatedEs2panda._UpdateTSInterfaceHeritage(global.context, passNode(original), passNode(expr))) } - get expr(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSInterfaceHeritageExpr(global.context, this.peer)) + get expr(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceHeritageExpr(global.context, this.peer)) } - get exprConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSInterfaceHeritageExprConst(global.context, this.peer)) + get exprConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceHeritageExprConst(global.context, this.peer)) } } export function isTSInterfaceHeritage(node: AstNode): node is TSInterfaceHeritage { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts index 8f17c2e20..e3cc6b959 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,10 +34,10 @@ export class TSIntersectionType extends TypeNode { super(pointer) console.warn("Warning: stub node TSIntersectionType") } - static createTSIntersectionType(types: readonly Expression[], typesLen: number): TSIntersectionType { + static createTSIntersectionType(types: readonly Expression[], typesLen: number): TSIntersectionType | undefined { return new TSIntersectionType(global.generatedEs2panda._CreateTSIntersectionType(global.context, passNodeArray(types), typesLen)) } - static updateTSIntersectionType(original: TSIntersectionType, types: readonly Expression[], typesLen: number): TSIntersectionType { + static updateTSIntersectionType(original: TSIntersectionType | undefined, types: readonly Expression[], typesLen: number): TSIntersectionType | undefined { return new TSIntersectionType(global.generatedEs2panda._UpdateTSIntersectionType(global.context, passNode(original), passNodeArray(types), typesLen)) } get typesConst(): readonly Expression[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts index eed5e6bb2..558cbcc67 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,14 +34,14 @@ export class TSLiteralType extends TypeNode { super(pointer) console.warn("Warning: stub node TSLiteralType") } - static createTSLiteralType(literal: Expression): TSLiteralType { + static createTSLiteralType(literal?: Expression): TSLiteralType | undefined { return new TSLiteralType(global.generatedEs2panda._CreateTSLiteralType(global.context, passNode(literal))) } - static updateTSLiteralType(original: TSLiteralType, literal: Expression): TSLiteralType { + static updateTSLiteralType(original?: TSLiteralType, literal?: Expression): TSLiteralType | undefined { return new TSLiteralType(global.generatedEs2panda._UpdateTSLiteralType(global.context, passNode(original), passNode(literal))) } - get literalConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSLiteralTypeLiteralConst(global.context, this.peer)) + get literalConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSLiteralTypeLiteralConst(global.context, this.peer)) } } export function isTSLiteralType(node: AstNode): node is TSLiteralType { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts index f3cfa7e7e..4bec564d2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class TSMappedType extends TypeNode { super(pointer) console.warn("Warning: stub node TSMappedType") } - static createTSMappedType(typeParameter: TSTypeParameter, typeAnnotation: TypeNode, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType { + static createTSMappedType(typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType | undefined { return new TSMappedType(global.generatedEs2panda._CreateTSMappedType(global.context, passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg)) } - static updateTSMappedType(original: TSMappedType, typeParameter: TSTypeParameter, typeAnnotation: TypeNode, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType { + static updateTSMappedType(original: TSMappedType | undefined, typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType | undefined { return new TSMappedType(global.generatedEs2panda._UpdateTSMappedType(global.context, passNode(original), passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg)) } - get typeParameter(): TSTypeParameter { - return unpackNonNullableNode(global.generatedEs2panda._TSMappedTypeTypeParameter(global.context, this.peer)) + get typeParameter(): TSTypeParameter | undefined { + return unpackNode(global.generatedEs2panda._TSMappedTypeTypeParameter(global.context, this.peer)) } - get typeAnnotation(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSMappedTypeTypeAnnotation(global.context, this.peer)) + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSMappedTypeTypeAnnotation(global.context, this.peer)) } get readonly(): Es2pandaMappedOption { return global.generatedEs2panda._TSMappedTypeReadonly(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts index 15470f9b5..96072c65e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,26 +35,26 @@ export class TSMethodSignature extends AstNode { super(pointer) console.warn("Warning: stub node TSMethodSignature") } - get keyConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSMethodSignatureKeyConst(global.context, this.peer)) + get keyConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSMethodSignatureKeyConst(global.context, this.peer)) } - get key(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSMethodSignatureKey(global.context, this.peer)) + get key(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSMethodSignatureKey(global.context, this.peer)) } - get typeParamsConst(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSMethodSignatureTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSMethodSignatureTypeParamsConst(global.context, this.peer)) } - get typeParams(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSMethodSignatureTypeParams(global.context, this.peer)) + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSMethodSignatureTypeParams(global.context, this.peer)) } get paramsConst(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._TSMethodSignatureParamsConst(global.context, this.peer)) } - get returnTypeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSMethodSignatureReturnTypeAnnotationConst(global.context, this.peer)) + get returnTypeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSMethodSignatureReturnTypeAnnotationConst(global.context, this.peer)) } - get returnTypeAnnotation(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSMethodSignatureReturnTypeAnnotation(global.context, this.peer)) + get returnTypeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSMethodSignatureReturnTypeAnnotation(global.context, this.peer)) } get computedConst(): boolean { return global.generatedEs2panda._TSMethodSignatureComputedConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts b/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts index 5039de671..dd276c788 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts index 0e1de1933..98adfc7cc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,11 +34,11 @@ export class TSModuleDeclaration extends Statement { super(pointer) console.warn("Warning: stub node TSModuleDeclaration") } - get nameConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSModuleDeclarationNameConst(global.context, this.peer)) + get nameConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSModuleDeclarationNameConst(global.context, this.peer)) } - get bodyConst(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._TSModuleDeclarationBodyConst(global.context, this.peer)) + get bodyConst(): Statement | undefined { + return unpackNode(global.generatedEs2panda._TSModuleDeclarationBodyConst(global.context, this.peer)) } get globalConst(): boolean { return global.generatedEs2panda._TSModuleDeclarationGlobalConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts index e3b7b441b..b7d1d4663 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,20 +34,20 @@ export class TSNamedTupleMember extends TypeNode { super(pointer) console.warn("Warning: stub node TSNamedTupleMember") } - static createTSNamedTupleMember(label: Expression, elementType: TypeNode, optional_arg: boolean): TSNamedTupleMember { + static createTSNamedTupleMember(label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember | undefined { return new TSNamedTupleMember(global.generatedEs2panda._CreateTSNamedTupleMember(global.context, passNode(label), passNode(elementType), optional_arg)) } - static updateTSNamedTupleMember(original: TSNamedTupleMember, label: Expression, elementType: TypeNode, optional_arg: boolean): TSNamedTupleMember { + static updateTSNamedTupleMember(original: TSNamedTupleMember | undefined, label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember | undefined { return new TSNamedTupleMember(global.generatedEs2panda._UpdateTSNamedTupleMember(global.context, passNode(original), passNode(label), passNode(elementType), optional_arg)) } - get labelConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSNamedTupleMemberLabelConst(global.context, this.peer)) + get labelConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSNamedTupleMemberLabelConst(global.context, this.peer)) } - get elementType(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSNamedTupleMemberElementType(global.context, this.peer)) + get elementType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSNamedTupleMemberElementType(global.context, this.peer)) } - get elementTypeConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSNamedTupleMemberElementTypeConst(global.context, this.peer)) + get elementTypeConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSNamedTupleMemberElementTypeConst(global.context, this.peer)) } get isOptionalConst(): boolean { return global.generatedEs2panda._TSNamedTupleMemberIsOptionalConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts index 44bfec9a8..f5dff1d60 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSNeverKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSNeverKeyword") } - static createTSNeverKeyword(): TSNeverKeyword { + static createTSNeverKeyword(): TSNeverKeyword | undefined { return new TSNeverKeyword(global.generatedEs2panda._CreateTSNeverKeyword(global.context)) } - static updateTSNeverKeyword(original: TSNeverKeyword): TSNeverKeyword { + static updateTSNeverKeyword(original?: TSNeverKeyword): TSNeverKeyword | undefined { return new TSNeverKeyword(global.generatedEs2panda._UpdateTSNeverKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts index 19c2f3aa8..c349ead31 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,17 +33,17 @@ export class TSNonNullExpression extends Expression { super(pointer) console.warn("Warning: stub node TSNonNullExpression") } - static createTSNonNullExpression(expr: Expression): TSNonNullExpression { + static createTSNonNullExpression(expr?: Expression): TSNonNullExpression | undefined { return new TSNonNullExpression(global.generatedEs2panda._CreateTSNonNullExpression(global.context, passNode(expr))) } - static updateTSNonNullExpression(original: TSNonNullExpression, expr: Expression): TSNonNullExpression { + static updateTSNonNullExpression(original?: TSNonNullExpression, expr?: Expression): TSNonNullExpression | undefined { return new TSNonNullExpression(global.generatedEs2panda._UpdateTSNonNullExpression(global.context, passNode(original), passNode(expr))) } - get exprConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSNonNullExpressionExprConst(global.context, this.peer)) + get exprConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSNonNullExpressionExprConst(global.context, this.peer)) } - get expr(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSNonNullExpressionExpr(global.context, this.peer)) + get expr(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSNonNullExpressionExpr(global.context, this.peer)) } } export function isTSNonNullExpression(node: AstNode): node is TSNonNullExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts index fc4018ec6..fdb0363c9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSNullKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSNullKeyword") } - static createTSNullKeyword(): TSNullKeyword { + static createTSNullKeyword(): TSNullKeyword | undefined { return new TSNullKeyword(global.generatedEs2panda._CreateTSNullKeyword(global.context)) } - static updateTSNullKeyword(original: TSNullKeyword): TSNullKeyword { + static updateTSNullKeyword(original?: TSNullKeyword): TSNullKeyword | undefined { return new TSNullKeyword(global.generatedEs2panda._UpdateTSNullKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts index 328750b7f..14c7a45c0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSNumberKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSNumberKeyword") } - static createTSNumberKeyword(): TSNumberKeyword { + static createTSNumberKeyword(): TSNumberKeyword | undefined { return new TSNumberKeyword(global.generatedEs2panda._CreateTSNumberKeyword(global.context)) } - static updateTSNumberKeyword(original: TSNumberKeyword): TSNumberKeyword { + static updateTSNumberKeyword(original?: TSNumberKeyword): TSNumberKeyword | undefined { return new TSNumberKeyword(global.generatedEs2panda._UpdateTSNumberKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts index ad0715082..ee05fa504 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSObjectKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSObjectKeyword") } - static createTSObjectKeyword(): TSObjectKeyword { + static createTSObjectKeyword(): TSObjectKeyword | undefined { return new TSObjectKeyword(global.generatedEs2panda._CreateTSObjectKeyword(global.context)) } - static updateTSObjectKeyword(original: TSObjectKeyword): TSObjectKeyword { + static updateTSObjectKeyword(original?: TSObjectKeyword): TSObjectKeyword | undefined { return new TSObjectKeyword(global.generatedEs2panda._UpdateTSObjectKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts index bed1a4c3e..4206b7b5c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,10 +34,10 @@ export class TSParameterProperty extends Expression { super(pointer) console.warn("Warning: stub node TSParameterProperty") } - static createTSParameterProperty(accessibility: Es2pandaAccessibilityOption, parameter: Expression, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty { + static createTSParameterProperty(accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty | undefined { return new TSParameterProperty(global.generatedEs2panda._CreateTSParameterProperty(global.context, accessibility, passNode(parameter), readonly_arg, isStatic, isExport)) } - static updateTSParameterProperty(original: TSParameterProperty, accessibility: Es2pandaAccessibilityOption, parameter: Expression, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty { + static updateTSParameterProperty(original: TSParameterProperty | undefined, accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty | undefined { return new TSParameterProperty(global.generatedEs2panda._UpdateTSParameterProperty(global.context, passNode(original), accessibility, passNode(parameter), readonly_arg, isStatic, isExport)) } get accessibilityConst(): Es2pandaAccessibilityOption { @@ -51,8 +52,8 @@ export class TSParameterProperty extends Expression { get isExportConst(): boolean { return global.generatedEs2panda._TSParameterPropertyIsExportConst(global.context, this.peer) } - get parameterConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSParameterPropertyParameterConst(global.context, this.peer)) + get parameterConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSParameterPropertyParameterConst(global.context, this.peer)) } } export function isTSParameterProperty(node: AstNode): node is TSParameterProperty { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts index 2a5d2b5b1..1e091bef9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,14 +34,14 @@ export class TSParenthesizedType extends TypeNode { super(pointer) console.warn("Warning: stub node TSParenthesizedType") } - static createTSParenthesizedType(type: TypeNode): TSParenthesizedType { + static createTSParenthesizedType(type?: TypeNode): TSParenthesizedType | undefined { return new TSParenthesizedType(global.generatedEs2panda._CreateTSParenthesizedType(global.context, passNode(type))) } - static updateTSParenthesizedType(original: TSParenthesizedType, type: TypeNode): TSParenthesizedType { + static updateTSParenthesizedType(original?: TSParenthesizedType, type?: TypeNode): TSParenthesizedType | undefined { return new TSParenthesizedType(global.generatedEs2panda._UpdateTSParenthesizedType(global.context, passNode(original), passNode(type))) } - get typeConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSParenthesizedTypeTypeConst(global.context, this.peer)) + get typeConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSParenthesizedTypeTypeConst(global.context, this.peer)) } } export function isTSParenthesizedType(node: AstNode): node is TSParenthesizedType { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts index 6ee049994..d14000f2a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class TSPropertySignature extends AnnotatedAstNode { super(pointer) console.warn("Warning: stub node TSPropertySignature") } - static createTSPropertySignature(key: Expression, typeAnnotation: TypeNode, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature { + static createTSPropertySignature(key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature | undefined { return new TSPropertySignature(global.generatedEs2panda._CreateTSPropertySignature(global.context, passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg)) } - static updateTSPropertySignature(original: TSPropertySignature, key: Expression, typeAnnotation: TypeNode, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature { + static updateTSPropertySignature(original: TSPropertySignature | undefined, key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature | undefined { return new TSPropertySignature(global.generatedEs2panda._UpdateTSPropertySignature(global.context, passNode(original), passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg)) } - get keyConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSPropertySignatureKeyConst(global.context, this.peer)) + get keyConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSPropertySignatureKeyConst(global.context, this.peer)) } - get key(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSPropertySignatureKey(global.context, this.peer)) + get key(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSPropertySignatureKey(global.context, this.peer)) } get computedConst(): boolean { return global.generatedEs2panda._TSPropertySignatureComputedConst(global.context, this.peer) @@ -55,8 +56,8 @@ export class TSPropertySignature extends AnnotatedAstNode { get readonlyConst(): boolean { return global.generatedEs2panda._TSPropertySignatureReadonlyConst(global.context, this.peer) } - get typeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSPropertySignatureTypeAnnotationConst(global.context, this.peer)) + get typeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSPropertySignatureTypeAnnotationConst(global.context, this.peer)) } } export function isTSPropertySignature(node: AstNode): node is TSPropertySignature { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts b/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts index 0286bc223..d7c41cff3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,23 +34,23 @@ export class TSQualifiedName extends Expression { super(pointer) console.warn("Warning: stub node TSQualifiedName") } - static createTSQualifiedName(left: Expression, right: Identifier): TSQualifiedName { + static createTSQualifiedName(left?: Expression, right?: Identifier): TSQualifiedName | undefined { return new TSQualifiedName(global.generatedEs2panda._CreateTSQualifiedName(global.context, passNode(left), passNode(right))) } - static updateTSQualifiedName(original: TSQualifiedName, left: Expression, right: Identifier): TSQualifiedName { + static updateTSQualifiedName(original?: TSQualifiedName, left?: Expression, right?: Identifier): TSQualifiedName | undefined { return new TSQualifiedName(global.generatedEs2panda._UpdateTSQualifiedName(global.context, passNode(original), passNode(left), passNode(right))) } - get leftConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSQualifiedNameLeftConst(global.context, this.peer)) + get leftConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSQualifiedNameLeftConst(global.context, this.peer)) } - get left(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSQualifiedNameLeft(global.context, this.peer)) + get left(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSQualifiedNameLeft(global.context, this.peer)) } - get rightConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._TSQualifiedNameRightConst(global.context, this.peer)) + get rightConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSQualifiedNameRightConst(global.context, this.peer)) } - get right(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._TSQualifiedNameRight(global.context, this.peer)) + get right(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSQualifiedNameRight(global.context, this.peer)) } } export function isTSQualifiedName(node: AstNode): node is TSQualifiedName { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts index 7ae561905..4fc3e85cb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -36,20 +37,20 @@ export class TSSignatureDeclaration extends TypedAstNode { super(pointer) console.warn("Warning: stub node TSSignatureDeclaration") } - get typeParamsConst(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSSignatureDeclarationTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSSignatureDeclarationTypeParamsConst(global.context, this.peer)) } - get typeParams(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSSignatureDeclarationTypeParams(global.context, this.peer)) + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSSignatureDeclarationTypeParams(global.context, this.peer)) } get paramsConst(): readonly Expression[] { return unpackNodeArray(global.generatedEs2panda._TSSignatureDeclarationParamsConst(global.context, this.peer)) } - get returnTypeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSSignatureDeclarationReturnTypeAnnotationConst(global.context, this.peer)) + get returnTypeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSSignatureDeclarationReturnTypeAnnotationConst(global.context, this.peer)) } - get returnTypeAnnotation(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSSignatureDeclarationReturnTypeAnnotation(global.context, this.peer)) + get returnTypeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSSignatureDeclarationReturnTypeAnnotation(global.context, this.peer)) } get kindConst(): Es2pandaTSSignatureDeclarationKind { return global.generatedEs2panda._TSSignatureDeclarationKindConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts index a59e8ef5f..6638b1b3e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSStringKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSStringKeyword") } - static createTSStringKeyword(): TSStringKeyword { + static createTSStringKeyword(): TSStringKeyword | undefined { return new TSStringKeyword(global.generatedEs2panda._CreateTSStringKeyword(global.context)) } - static updateTSStringKeyword(original: TSStringKeyword): TSStringKeyword { + static updateTSStringKeyword(original?: TSStringKeyword): TSStringKeyword | undefined { return new TSStringKeyword(global.generatedEs2panda._UpdateTSStringKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts index dc3d3fa0e..c5a813ea9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSThisType extends TypeNode { super(pointer) console.warn("Warning: stub node TSThisType") } - static createTSThisType(): TSThisType { + static createTSThisType(): TSThisType | undefined { return new TSThisType(global.generatedEs2panda._CreateTSThisType(global.context)) } - static updateTSThisType(original: TSThisType): TSThisType { + static updateTSThisType(original?: TSThisType): TSThisType | undefined { return new TSThisType(global.generatedEs2panda._UpdateTSThisType(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts index 6dc2af8cf..f780da746 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSTupleType extends TypeNode { super(pointer) console.warn("Warning: stub node TSTupleType") } - static createTSTupleType(elementTypes: readonly TypeNode[], elementTypesLen: number): TSTupleType { + static createTSTupleType(elementTypes: readonly TypeNode[], elementTypesLen: number): TSTupleType | undefined { return new TSTupleType(global.generatedEs2panda._CreateTSTupleType(global.context, passNodeArray(elementTypes), elementTypesLen)) } - static updateTSTupleType(original: TSTupleType, elementTypes: readonly TypeNode[], elementTypesLen: number): TSTupleType { + static updateTSTupleType(original: TSTupleType | undefined, elementTypes: readonly TypeNode[], elementTypesLen: number): TSTupleType | undefined { return new TSTupleType(global.generatedEs2panda._UpdateTSTupleType(global.context, passNode(original), passNodeArray(elementTypes), elementTypesLen)) } 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 c5f26a92c..cc5654dfb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -37,26 +38,26 @@ export class TSTypeAliasDeclaration extends AnnotatedStatement { super(pointer) console.warn("Warning: stub node TSTypeAliasDeclaration") } - static createTSTypeAliasDeclaration(id: Identifier, typeParams: TSTypeParameterDeclaration, typeAnnotation: TypeNode): TSTypeAliasDeclaration { + static createTSTypeAliasDeclaration(id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration | undefined { return new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration(global.context, passNode(id), passNode(typeParams), passNode(typeAnnotation))) } - static updateTSTypeAliasDeclaration(original: TSTypeAliasDeclaration, id: Identifier, typeParams: TSTypeParameterDeclaration, typeAnnotation: TypeNode): TSTypeAliasDeclaration { + static updateTSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration | undefined { return new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration(global.context, passNode(original), passNode(id), passNode(typeParams), passNode(typeAnnotation))) } - static create1TSTypeAliasDeclaration(id: Identifier): TSTypeAliasDeclaration { + static create1TSTypeAliasDeclaration(id?: Identifier): TSTypeAliasDeclaration | undefined { return new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration1(global.context, passNode(id))) } - static update1TSTypeAliasDeclaration(original: TSTypeAliasDeclaration, id: Identifier): TSTypeAliasDeclaration { + static update1TSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier): TSTypeAliasDeclaration | undefined { return new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration1(global.context, passNode(original), passNode(id))) } - get id(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeAliasDeclarationId(global.context, this.peer)) + get id(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationId(global.context, this.peer)) } - get idConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeAliasDeclarationIdConst(global.context, this.peer)) + get idConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationIdConst(global.context, this.peer)) } - get typeParamsConst(): TSTypeParameterDeclaration { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeAliasDeclarationTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationTypeParamsConst(global.context, this.peer)) } get decoratorsConst(): readonly Decorator[] { return unpackNodeArray(global.generatedEs2panda._TSTypeAliasDeclarationDecoratorsConst(global.context, this.peer)) @@ -67,8 +68,8 @@ export class TSTypeAliasDeclaration extends AnnotatedStatement { get annotationsConst(): readonly AnnotationUsage[] { return unpackNodeArray(global.generatedEs2panda._TSTypeAliasDeclarationAnnotationsConst(global.context, this.peer)) } - get typeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeAliasDeclarationTypeAnnotationConst(global.context, this.peer)) + get typeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationTypeAnnotationConst(global.context, this.peer)) } } export function isTSTypeAliasDeclaration(node: AstNode): node is TSTypeAliasDeclaration { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts index 749439f96..8d1915b7d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class TSTypeAssertion extends AnnotatedExpression { super(pointer) console.warn("Warning: stub node TSTypeAssertion") } - static createTSTypeAssertion(typeAnnotation: TypeNode, expression: Expression): TSTypeAssertion { + static createTSTypeAssertion(typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion | undefined { return new TSTypeAssertion(global.generatedEs2panda._CreateTSTypeAssertion(global.context, passNode(typeAnnotation), passNode(expression))) } - static updateTSTypeAssertion(original: TSTypeAssertion, typeAnnotation: TypeNode, expression: Expression): TSTypeAssertion { + static updateTSTypeAssertion(original?: TSTypeAssertion, typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion | undefined { return new TSTypeAssertion(global.generatedEs2panda._UpdateTSTypeAssertion(global.context, passNode(original), passNode(typeAnnotation), passNode(expression))) } - get getExpressionConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeAssertionGetExpressionConst(global.context, this.peer)) + get getExpressionConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSTypeAssertionGetExpressionConst(global.context, this.peer)) } - get typeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeAssertionTypeAnnotationConst(global.context, this.peer)) + get typeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSTypeAssertionTypeAnnotationConst(global.context, this.peer)) } } export function isTSTypeAssertion(node: AstNode): node is TSTypeAssertion { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts index 8b0b7aa55..db04fb73b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSTypeLiteral extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypeLiteral") } - static createTSTypeLiteral(members: readonly AstNode[], membersLen: number): TSTypeLiteral { + static createTSTypeLiteral(members: readonly AstNode[], membersLen: number): TSTypeLiteral | undefined { return new TSTypeLiteral(global.generatedEs2panda._CreateTSTypeLiteral(global.context, passNodeArray(members), membersLen)) } - static updateTSTypeLiteral(original: TSTypeLiteral, members: readonly AstNode[], membersLen: number): TSTypeLiteral { + static updateTSTypeLiteral(original: TSTypeLiteral | undefined, members: readonly AstNode[], membersLen: number): TSTypeLiteral | undefined { return new TSTypeLiteral(global.generatedEs2panda._UpdateTSTypeLiteral(global.context, passNode(original), passNodeArray(members), membersLen)) } get membersConst(): readonly AstNode[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts index 28373b965..0245e44c4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,14 +34,14 @@ export class TSTypeOperator extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypeOperator") } - static createTSTypeOperator(type: TypeNode, operatorType: Es2pandaTSOperatorType): TSTypeOperator { + static createTSTypeOperator(type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator | undefined { return new TSTypeOperator(global.generatedEs2panda._CreateTSTypeOperator(global.context, passNode(type), operatorType)) } - static updateTSTypeOperator(original: TSTypeOperator, type: TypeNode, operatorType: Es2pandaTSOperatorType): TSTypeOperator { + static updateTSTypeOperator(original: TSTypeOperator | undefined, type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator | undefined { return new TSTypeOperator(global.generatedEs2panda._UpdateTSTypeOperator(global.context, passNode(original), passNode(type), operatorType)) } - get typeConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeOperatorTypeConst(global.context, this.peer)) + get typeConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSTypeOperatorTypeConst(global.context, this.peer)) } get isReadonlyConst(): boolean { return global.generatedEs2panda._TSTypeOperatorIsReadonlyConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts index a31d6167e..df61b3d5e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -36,32 +37,32 @@ export class TSTypeParameter extends Expression { super(pointer) console.warn("Warning: stub node TSTypeParameter") } - static createTSTypeParameter(name: Identifier, constraint: TypeNode, defaultType: TypeNode): TSTypeParameter { + static createTSTypeParameter(name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter | undefined { return new TSTypeParameter(global.generatedEs2panda._CreateTSTypeParameter(global.context, passNode(name), passNode(constraint), passNode(defaultType))) } - static updateTSTypeParameter(original: TSTypeParameter, name: Identifier, constraint: TypeNode, defaultType: TypeNode): TSTypeParameter { + static updateTSTypeParameter(original?: TSTypeParameter, name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter | undefined { return new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType))) } - static create1TSTypeParameter(name: Identifier, constraint: TypeNode, defaultType: TypeNode, flags: Es2pandaModifierFlags): TSTypeParameter { + static create1TSTypeParameter(name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter | undefined { return new TSTypeParameter(global.generatedEs2panda._CreateTSTypeParameter1(global.context, passNode(name), passNode(constraint), passNode(defaultType), flags)) } - static update1TSTypeParameter(original: TSTypeParameter, name: Identifier, constraint: TypeNode, defaultType: TypeNode, flags: Es2pandaModifierFlags): TSTypeParameter { + static update1TSTypeParameter(original: TSTypeParameter | undefined, name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter | undefined { return new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter1(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType), flags)) } - get nameConst(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeParameterNameConst(global.context, this.peer)) + get nameConst(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSTypeParameterNameConst(global.context, this.peer)) } - get name(): Identifier { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeParameterName(global.context, this.peer)) + get name(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSTypeParameterName(global.context, this.peer)) } - get constraint(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeParameterConstraint(global.context, this.peer)) + get constraint(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSTypeParameterConstraint(global.context, this.peer)) } - get constraintConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeParameterConstraintConst(global.context, this.peer)) + get constraintConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSTypeParameterConstraintConst(global.context, this.peer)) } - get defaultTypeConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeParameterDefaultTypeConst(global.context, this.peer)) + get defaultTypeConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSTypeParameterDefaultTypeConst(global.context, this.peer)) } get annotations(): readonly AnnotationUsage[] { return unpackNodeArray(global.generatedEs2panda._TSTypeParameterAnnotations(global.context, this.peer)) diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts index ab91da693..649b62924 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,10 +34,10 @@ export class TSTypeParameterDeclaration extends Expression { super(pointer) console.warn("Warning: stub node TSTypeParameterDeclaration") } - static createTSTypeParameterDeclaration(params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration { + static createTSTypeParameterDeclaration(params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration | undefined { return new TSTypeParameterDeclaration(global.generatedEs2panda._CreateTSTypeParameterDeclaration(global.context, passNodeArray(params), paramsLen, requiredParams)) } - static updateTSTypeParameterDeclaration(original: TSTypeParameterDeclaration, params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration { + static updateTSTypeParameterDeclaration(original: TSTypeParameterDeclaration | undefined, params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration | undefined { return new TSTypeParameterDeclaration(global.generatedEs2panda._UpdateTSTypeParameterDeclaration(global.context, passNode(original), passNodeArray(params), paramsLen, requiredParams)) } get paramsConst(): readonly TSTypeParameter[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts index c233f22b1..bb571ed29 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,10 +34,10 @@ export class TSTypeParameterInstantiation extends Expression { super(pointer) console.warn("Warning: stub node TSTypeParameterInstantiation") } - static createTSTypeParameterInstantiation(params: readonly TypeNode[], paramsLen: number): TSTypeParameterInstantiation { + static createTSTypeParameterInstantiation(params: readonly TypeNode[], paramsLen: number): TSTypeParameterInstantiation | undefined { return new TSTypeParameterInstantiation(global.generatedEs2panda._CreateTSTypeParameterInstantiation(global.context, passNodeArray(params), paramsLen)) } - static updateTSTypeParameterInstantiation(original: TSTypeParameterInstantiation, params: readonly TypeNode[], paramsLen: number): TSTypeParameterInstantiation { + static updateTSTypeParameterInstantiation(original: TSTypeParameterInstantiation | undefined, params: readonly TypeNode[], paramsLen: number): TSTypeParameterInstantiation | undefined { return new TSTypeParameterInstantiation(global.generatedEs2panda._UpdateTSTypeParameterInstantiation(global.context, passNode(original), passNodeArray(params), paramsLen)) } 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 68f29257d..0af99af29 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,17 +34,17 @@ export class TSTypePredicate extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypePredicate") } - static createTSTypePredicate(parameterName: Expression, typeAnnotation: TypeNode, asserts: boolean): TSTypePredicate { + static createTSTypePredicate(parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate | undefined { return new TSTypePredicate(global.generatedEs2panda._CreateTSTypePredicate(global.context, passNode(parameterName), passNode(typeAnnotation), asserts)) } - static updateTSTypePredicate(original: TSTypePredicate, parameterName: Expression, typeAnnotation: TypeNode, asserts: boolean): TSTypePredicate { + static updateTSTypePredicate(original: TSTypePredicate | undefined, parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate | undefined { return new TSTypePredicate(global.generatedEs2panda._UpdateTSTypePredicate(global.context, passNode(original), passNode(parameterName), passNode(typeAnnotation), asserts)) } - get parameterNameConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSTypePredicateParameterNameConst(global.context, this.peer)) + get parameterNameConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSTypePredicateParameterNameConst(global.context, this.peer)) } - get typeAnnotationConst(): TypeNode { - return unpackNonNullableNode(global.generatedEs2panda._TSTypePredicateTypeAnnotationConst(global.context, this.peer)) + get typeAnnotationConst(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSTypePredicateTypeAnnotationConst(global.context, this.peer)) } get assertsConst(): boolean { return global.generatedEs2panda._TSTypePredicateAssertsConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts index e5c121c92..e4be5cc26 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,14 +34,14 @@ export class TSTypeQuery extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypeQuery") } - static createTSTypeQuery(exprName: Expression): TSTypeQuery { + static createTSTypeQuery(exprName?: Expression): TSTypeQuery | undefined { return new TSTypeQuery(global.generatedEs2panda._CreateTSTypeQuery(global.context, passNode(exprName))) } - static updateTSTypeQuery(original: TSTypeQuery, exprName: Expression): TSTypeQuery { + static updateTSTypeQuery(original?: TSTypeQuery, exprName?: Expression): TSTypeQuery | undefined { return new TSTypeQuery(global.generatedEs2panda._UpdateTSTypeQuery(global.context, passNode(original), passNode(exprName))) } - get exprNameConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeQueryExprNameConst(global.context, this.peer)) + get exprNameConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSTypeQueryExprNameConst(global.context, this.peer)) } } export function isTSTypeQuery(node: AstNode): node is TSTypeQuery { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts index f1efece70..286229070 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class TSTypeReference extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypeReference") } - static createTSTypeReference(typeName: Expression, typeParams: TSTypeParameterInstantiation): TSTypeReference { + static createTSTypeReference(typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference | undefined { return new TSTypeReference(global.generatedEs2panda._CreateTSTypeReference(global.context, passNode(typeName), passNode(typeParams))) } - static updateTSTypeReference(original: TSTypeReference, typeName: Expression, typeParams: TSTypeParameterInstantiation): TSTypeReference { + static updateTSTypeReference(original?: TSTypeReference, typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference | undefined { return new TSTypeReference(global.generatedEs2panda._UpdateTSTypeReference(global.context, passNode(original), passNode(typeName), passNode(typeParams))) } - get typeParamsConst(): TSTypeParameterInstantiation { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeReferenceTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._TSTypeReferenceTypeParamsConst(global.context, this.peer)) } - get typeNameConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TSTypeReferenceTypeNameConst(global.context, this.peer)) + get typeNameConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSTypeReferenceTypeNameConst(global.context, this.peer)) } } export function isTSTypeReference(node: AstNode): node is TSTypeReference { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts index 8acaa8e7d..617f53697 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSUndefinedKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSUndefinedKeyword") } - static createTSUndefinedKeyword(): TSUndefinedKeyword { + static createTSUndefinedKeyword(): TSUndefinedKeyword | undefined { return new TSUndefinedKeyword(global.generatedEs2panda._CreateTSUndefinedKeyword(global.context)) } - static updateTSUndefinedKeyword(original: TSUndefinedKeyword): TSUndefinedKeyword { + static updateTSUndefinedKeyword(original?: TSUndefinedKeyword): TSUndefinedKeyword | undefined { return new TSUndefinedKeyword(global.generatedEs2panda._UpdateTSUndefinedKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts index 24da482e1..7602a8fbe 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSUnionType extends TypeNode { super(pointer) console.warn("Warning: stub node TSUnionType") } - static createTSUnionType(types: readonly TypeNode[], typesLen: number): TSUnionType { + static createTSUnionType(types: readonly TypeNode[], typesLen: number): TSUnionType | undefined { return new TSUnionType(global.generatedEs2panda._CreateTSUnionType(global.context, passNodeArray(types), typesLen)) } - static updateTSUnionType(original: TSUnionType, types: readonly TypeNode[], typesLen: number): TSUnionType { + static updateTSUnionType(original: TSUnionType | undefined, types: readonly TypeNode[], typesLen: number): TSUnionType | undefined { return new TSUnionType(global.generatedEs2panda._UpdateTSUnionType(global.context, passNode(original), passNodeArray(types), typesLen)) } 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 44050a537..0b4030231 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSUnknownKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSUnknownKeyword") } - static createTSUnknownKeyword(): TSUnknownKeyword { + static createTSUnknownKeyword(): TSUnknownKeyword | undefined { return new TSUnknownKeyword(global.generatedEs2panda._CreateTSUnknownKeyword(global.context)) } - static updateTSUnknownKeyword(original: TSUnknownKeyword): TSUnknownKeyword { + static updateTSUnknownKeyword(original?: TSUnknownKeyword): TSUnknownKeyword | undefined { return new TSUnknownKeyword(global.generatedEs2panda._UpdateTSUnknownKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts index 6b6228c23..392412c70 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class TSVoidKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSVoidKeyword") } - static createTSVoidKeyword(): TSVoidKeyword { + static createTSVoidKeyword(): TSVoidKeyword | undefined { return new TSVoidKeyword(global.generatedEs2panda._CreateTSVoidKeyword(global.context)) } - static updateTSVoidKeyword(original: TSVoidKeyword): TSVoidKeyword { + static updateTSVoidKeyword(original?: TSVoidKeyword): TSVoidKeyword | undefined { return new TSVoidKeyword(global.generatedEs2panda._UpdateTSVoidKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts index 5487ae10c..991244956 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,20 +35,20 @@ export class TaggedTemplateExpression extends Expression { super(pointer) console.warn("Warning: stub node TaggedTemplateExpression") } - static createTaggedTemplateExpression(tag: Expression, quasi: TemplateLiteral, typeParams: TSTypeParameterInstantiation): TaggedTemplateExpression { + static createTaggedTemplateExpression(tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression | undefined { return new TaggedTemplateExpression(global.generatedEs2panda._CreateTaggedTemplateExpression(global.context, passNode(tag), passNode(quasi), passNode(typeParams))) } - static updateTaggedTemplateExpression(original: TaggedTemplateExpression, tag: Expression, quasi: TemplateLiteral, typeParams: TSTypeParameterInstantiation): TaggedTemplateExpression { + static updateTaggedTemplateExpression(original?: TaggedTemplateExpression, tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression | undefined { return new TaggedTemplateExpression(global.generatedEs2panda._UpdateTaggedTemplateExpression(global.context, passNode(original), passNode(tag), passNode(quasi), passNode(typeParams))) } - get tagConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TaggedTemplateExpressionTagConst(global.context, this.peer)) + get tagConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionTagConst(global.context, this.peer)) } - get quasiConst(): TemplateLiteral { - return unpackNonNullableNode(global.generatedEs2panda._TaggedTemplateExpressionQuasiConst(global.context, this.peer)) + get quasiConst(): TemplateLiteral | undefined { + return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionQuasiConst(global.context, this.peer)) } - get typeParamsConst(): TSTypeParameterInstantiation { - return unpackNonNullableNode(global.generatedEs2panda._TaggedTemplateExpressionTypeParamsConst(global.context, this.peer)) + get typeParamsConst(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionTypeParamsConst(global.context, this.peer)) } } export function isTaggedTemplateExpression(node: AstNode): node is TaggedTemplateExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts b/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts index 773450a4a..0d505f70f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,16 +33,16 @@ export class TemplateElement extends Expression { super(pointer) console.warn("Warning: stub node TemplateElement") } - static createTemplateElement(): TemplateElement { + static createTemplateElement(): TemplateElement | undefined { return new TemplateElement(global.generatedEs2panda._CreateTemplateElement(global.context)) } - static updateTemplateElement(original: TemplateElement): TemplateElement { + static updateTemplateElement(original?: TemplateElement): TemplateElement | undefined { return new TemplateElement(global.generatedEs2panda._UpdateTemplateElement(global.context, passNode(original))) } - static create1TemplateElement(raw: string, cooked: string): TemplateElement { + static create1TemplateElement(raw: string, cooked: string): TemplateElement | undefined { return new TemplateElement(global.generatedEs2panda._CreateTemplateElement1(global.context, raw, cooked)) } - static update1TemplateElement(original: TemplateElement, raw: string, cooked: string): TemplateElement { + static update1TemplateElement(original: TemplateElement | undefined, raw: string, cooked: string): TemplateElement | undefined { return new TemplateElement(global.generatedEs2panda._UpdateTemplateElement1(global.context, passNode(original), raw, cooked)) } get rawConst(): string { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts index 6ad850b68..952583ba0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,10 +34,10 @@ export class TemplateLiteral extends Expression { super(pointer) console.warn("Warning: stub node TemplateLiteral") } - static createTemplateLiteral(quasis: readonly TemplateElement[], quasisLen: number, expressions: readonly Expression[], expressionsLen: number, multilineString: string): TemplateLiteral { + static createTemplateLiteral(quasis: readonly TemplateElement[], quasisLen: number, expressions: readonly Expression[], expressionsLen: number, multilineString: string): TemplateLiteral | undefined { return new TemplateLiteral(global.generatedEs2panda._CreateTemplateLiteral(global.context, passNodeArray(quasis), quasisLen, passNodeArray(expressions), expressionsLen, multilineString)) } - static updateTemplateLiteral(original: TemplateLiteral, quasis: readonly TemplateElement[], quasisLen: number, expressions: readonly Expression[], expressionsLen: number, multilineString: string): TemplateLiteral { + static updateTemplateLiteral(original: TemplateLiteral | undefined, quasis: readonly TemplateElement[], quasisLen: number, expressions: readonly Expression[], expressionsLen: number, multilineString: string): TemplateLiteral | undefined { return new TemplateLiteral(global.generatedEs2panda._UpdateTemplateLiteral(global.context, passNode(original), passNodeArray(quasis), quasisLen, passNodeArray(expressions), expressionsLen, multilineString)) } get quasisConst(): readonly TemplateElement[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts index 383fb1d9c..28563e464 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class ThisExpression extends Expression { super(pointer) console.warn("Warning: stub node ThisExpression") } - static createThisExpression(): ThisExpression { + static createThisExpression(): ThisExpression | undefined { return new ThisExpression(global.generatedEs2panda._CreateThisExpression(global.context)) } - static updateThisExpression(original: ThisExpression): ThisExpression { + static updateThisExpression(original?: ThisExpression): ThisExpression | undefined { return new ThisExpression(global.generatedEs2panda._UpdateThisExpression(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts index 1e28b83fd..c2468f34c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,14 +34,14 @@ export class ThrowStatement extends Statement { super(pointer) console.warn("Warning: stub node ThrowStatement") } - static createThrowStatement(argument: Expression): ThrowStatement { + static createThrowStatement(argument?: Expression): ThrowStatement | undefined { return new ThrowStatement(global.generatedEs2panda._CreateThrowStatement(global.context, passNode(argument))) } - static updateThrowStatement(original: ThrowStatement, argument: Expression): ThrowStatement { + static updateThrowStatement(original?: ThrowStatement, argument?: Expression): ThrowStatement | undefined { return new ThrowStatement(global.generatedEs2panda._UpdateThrowStatement(global.context, passNode(original), passNode(argument))) } - get argumentConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._ThrowStatementArgumentConst(global.context, this.peer)) + get argumentConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ThrowStatementArgumentConst(global.context, this.peer)) } } export function isThrowStatement(node: AstNode): node is ThrowStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts index 3115086be..cbf22f6dc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,11 +35,11 @@ export class TryStatement extends Statement { super(pointer) console.warn("Warning: stub node TryStatement") } - get finallyBlockConst(): BlockStatement { - return unpackNonNullableNode(global.generatedEs2panda._TryStatementFinallyBlockConst(global.context, this.peer)) + get finallyBlockConst(): BlockStatement | undefined { + return unpackNode(global.generatedEs2panda._TryStatementFinallyBlockConst(global.context, this.peer)) } - get blockConst(): BlockStatement { - return unpackNonNullableNode(global.generatedEs2panda._TryStatementBlockConst(global.context, this.peer)) + get blockConst(): BlockStatement | undefined { + return unpackNode(global.generatedEs2panda._TryStatementBlockConst(global.context, this.peer)) } get hasFinalizerConst(): boolean { return global.generatedEs2panda._TryStatementHasFinalizerConst(global.context, this.peer) diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts b/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts index 8232dc0fc..bd893051b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts b/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts index 09a07affc..a93cec213 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts index ae56ef749..f277f2845 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts index 1d8a81eba..e12144926 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,14 +33,14 @@ export class TypeofExpression extends Expression { super(pointer) console.warn("Warning: stub node TypeofExpression") } - static createTypeofExpression(argument: Expression): TypeofExpression { + static createTypeofExpression(argument?: Expression): TypeofExpression | undefined { return new TypeofExpression(global.generatedEs2panda._CreateTypeofExpression(global.context, passNode(argument))) } - static updateTypeofExpression(original: TypeofExpression, argument: Expression): TypeofExpression { + static updateTypeofExpression(original?: TypeofExpression, argument?: Expression): TypeofExpression | undefined { return new TypeofExpression(global.generatedEs2panda._UpdateTypeofExpression(global.context, passNode(original), passNode(argument))) } - get argumentConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._TypeofExpressionArgumentConst(global.context, this.peer)) + get argumentConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TypeofExpressionArgumentConst(global.context, this.peer)) } } export function isTypeofExpression(node: AstNode): node is TypeofExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts index 9ecfaa432..3664948fc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,20 +34,20 @@ export class UnaryExpression extends Expression { super(pointer) console.warn("Warning: stub node UnaryExpression") } - static createUnaryExpression(argument: Expression, unaryOperator: Es2pandaTokenType): UnaryExpression { + static createUnaryExpression(argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression | undefined { return new UnaryExpression(global.generatedEs2panda._CreateUnaryExpression(global.context, passNode(argument), unaryOperator)) } - static updateUnaryExpression(original: UnaryExpression, argument: Expression, unaryOperator: Es2pandaTokenType): UnaryExpression { + static updateUnaryExpression(original: UnaryExpression | undefined, argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression | undefined { return new UnaryExpression(global.generatedEs2panda._UpdateUnaryExpression(global.context, passNode(original), passNode(argument), unaryOperator)) } get operatorTypeConst(): Es2pandaTokenType { return global.generatedEs2panda._UnaryExpressionOperatorTypeConst(global.context, this.peer) } - get argument(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._UnaryExpressionArgument(global.context, this.peer)) + get argument(): Expression | undefined { + return unpackNode(global.generatedEs2panda._UnaryExpressionArgument(global.context, this.peer)) } - get argumentConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._UnaryExpressionArgumentConst(global.context, this.peer)) + get argumentConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._UnaryExpressionArgumentConst(global.context, this.peer)) } } export function isUnaryExpression(node: AstNode): node is UnaryExpression { diff --git a/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts index 53d3e38bf..ff60f1550 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,10 +33,10 @@ export class UndefinedLiteral extends Literal { super(pointer) console.warn("Warning: stub node UndefinedLiteral") } - static createUndefinedLiteral(): UndefinedLiteral { + static createUndefinedLiteral(): UndefinedLiteral | undefined { return new UndefinedLiteral(global.generatedEs2panda._CreateUndefinedLiteral(global.context)) } - static updateUndefinedLiteral(original: UndefinedLiteral): UndefinedLiteral { + static updateUndefinedLiteral(original?: UndefinedLiteral): UndefinedLiteral | undefined { return new UndefinedLiteral(global.generatedEs2panda._UpdateUndefinedLiteral(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts index 1bb4c09ca..e0f3f1374 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -33,20 +34,20 @@ export class UpdateExpression extends Expression { super(pointer) console.warn("Warning: stub node UpdateExpression") } - static createUpdateExpression(argument: Expression, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression { + static createUpdateExpression(argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression | undefined { return new UpdateExpression(global.generatedEs2panda._CreateUpdateExpression(global.context, passNode(argument), updateOperator, isPrefix)) } - static updateUpdateExpression(original: UpdateExpression, argument: Expression, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression { + static updateUpdateExpression(original: UpdateExpression | undefined, argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression | undefined { return new UpdateExpression(global.generatedEs2panda._UpdateUpdateExpression(global.context, passNode(original), passNode(argument), updateOperator, isPrefix)) } get operatorTypeConst(): Es2pandaTokenType { return global.generatedEs2panda._UpdateExpressionOperatorTypeConst(global.context, this.peer) } - get argument(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._UpdateExpressionArgument(global.context, this.peer)) + get argument(): Expression | undefined { + return unpackNode(global.generatedEs2panda._UpdateExpressionArgument(global.context, this.peer)) } - get argumentConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._UpdateExpressionArgumentConst(global.context, this.peer)) + get argumentConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._UpdateExpressionArgumentConst(global.context, this.peer)) } get isPrefixConst(): boolean { return global.generatedEs2panda._UpdateExpressionIsPrefixConst(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 a8e744cbe..b145115d8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -36,10 +37,10 @@ export class VariableDeclaration extends Statement { super(pointer) console.warn("Warning: stub node VariableDeclaration") } - static createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration { + static createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration | undefined { return new VariableDeclaration(global.generatedEs2panda._CreateVariableDeclaration(global.context, kind, passNodeArray(declarators), declaratorsLen)) } - static updateVariableDeclaration(original: VariableDeclaration, kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration { + static updateVariableDeclaration(original: VariableDeclaration | undefined, kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration | undefined { return new VariableDeclaration(global.generatedEs2panda._UpdateVariableDeclaration(global.context, passNode(original), kind, passNodeArray(declarators), declaratorsLen)) } get declaratorsConst(): readonly VariableDeclarator[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts index 3f25900f0..9d46bd035 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,29 +35,29 @@ export class VariableDeclarator extends TypedStatement { super(pointer) console.warn("Warning: stub node VariableDeclarator") } - static createVariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident: Expression): VariableDeclarator { + static createVariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator | undefined { return new VariableDeclarator(global.generatedEs2panda._CreateVariableDeclarator(global.context, flag, passNode(ident))) } - static updateVariableDeclarator(original: VariableDeclarator, flag: Es2pandaVariableDeclaratorFlag, ident: Expression): VariableDeclarator { + static updateVariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator | undefined { return new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator(global.context, passNode(original), flag, passNode(ident))) } - static create1VariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident: Expression, init: Expression): VariableDeclarator { + static create1VariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator | undefined { return new VariableDeclarator(global.generatedEs2panda._CreateVariableDeclarator1(global.context, flag, passNode(ident), passNode(init))) } - static update1VariableDeclarator(original: VariableDeclarator, flag: Es2pandaVariableDeclaratorFlag, ident: Expression, init: Expression): VariableDeclarator { + static update1VariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator | undefined { return new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator1(global.context, passNode(original), flag, passNode(ident), passNode(init))) } - get init(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._VariableDeclaratorInit(global.context, this.peer)) + get init(): Expression | undefined { + return unpackNode(global.generatedEs2panda._VariableDeclaratorInit(global.context, this.peer)) } - get initConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._VariableDeclaratorInitConst(global.context, this.peer)) + get initConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._VariableDeclaratorInitConst(global.context, this.peer)) } - get id(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._VariableDeclaratorId(global.context, this.peer)) + get id(): Expression | undefined { + return unpackNode(global.generatedEs2panda._VariableDeclaratorId(global.context, this.peer)) } - get idConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._VariableDeclaratorIdConst(global.context, this.peer)) + get idConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._VariableDeclaratorIdConst(global.context, this.peer)) } get flag(): Es2pandaVariableDeclaratorFlag { return global.generatedEs2panda._VariableDeclaratorFlag(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 119c184f7..b5ca5e0be 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -34,17 +35,17 @@ export class WhileStatement extends LoopStatement { super(pointer) console.warn("Warning: stub node WhileStatement") } - get testConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._WhileStatementTestConst(global.context, this.peer)) + get testConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._WhileStatementTestConst(global.context, this.peer)) } - get test(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._WhileStatementTest(global.context, this.peer)) + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._WhileStatementTest(global.context, this.peer)) } - get bodyConst(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._WhileStatementBodyConst(global.context, this.peer)) + get bodyConst(): Statement | undefined { + return unpackNode(global.generatedEs2panda._WhileStatementBodyConst(global.context, this.peer)) } - get body(): Statement { - return unpackNonNullableNode(global.generatedEs2panda._WhileStatementBody(global.context, this.peer)) + get body(): Statement | undefined { + return unpackNode(global.generatedEs2panda._WhileStatementBody(global.context, this.peer)) } } export function isWhileStatement(node: AstNode): node is WhileStatement { diff --git a/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts index 62f6bd9f3..6a1279f7b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts @@ -18,6 +18,7 @@ import { passNode, passNodeArray, unpackNonNullableNode, + unpackNode, unpackNodeArray, assertValidPeer, AstNode, @@ -32,17 +33,17 @@ export class YieldExpression extends Expression { super(pointer) console.warn("Warning: stub node YieldExpression") } - static createYieldExpression(argument: Expression, isDelegate: boolean): YieldExpression { + static createYieldExpression(argument: Expression | undefined, isDelegate: boolean): YieldExpression | undefined { return new YieldExpression(global.generatedEs2panda._CreateYieldExpression(global.context, passNode(argument), isDelegate)) } - static updateYieldExpression(original: YieldExpression, argument: Expression, isDelegate: boolean): YieldExpression { + static updateYieldExpression(original: YieldExpression | undefined, argument: Expression | undefined, isDelegate: boolean): YieldExpression | undefined { return new YieldExpression(global.generatedEs2panda._UpdateYieldExpression(global.context, passNode(original), passNode(argument), isDelegate)) } get hasDelegateConst(): boolean { return global.generatedEs2panda._YieldExpressionHasDelegateConst(global.context, this.peer) } - get argumentConst(): Expression { - return unpackNonNullableNode(global.generatedEs2panda._YieldExpressionArgumentConst(global.context, this.peer)) + get argumentConst(): Expression | undefined { + return unpackNode(global.generatedEs2panda._YieldExpressionArgumentConst(global.context, this.peer)) } } export function isYieldExpression(node: AstNode): node is YieldExpression { -- Gitee