npm - @idlizer/arktscgen - Versions diffs - 2.1.9-arktscgen-9 → 2.1.10-arktscgen-3 - Mend

@idlizer/arktscgen 2.1.9-arktscgen-9 → 2.1.10-arktscgen-3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (296) hide show

package/build/libarkts-copy/src/generated/peers/DirectEvalExpression.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,17 +37,16 @@ import { Expression } from "./Expression"
 import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 export class DirectEvalExpression extends CallExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 23)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createDirectEvalExpression(callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression {
-        const result: DirectEvalExpression = new DirectEvalExpression(global.generatedEs2panda._CreateDirectEvalExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, parserStatus))
+        const result: DirectEvalExpression = new DirectEvalExpression(global.generatedEs2panda._CreateDirectEvalExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, parserStatus), Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateDirectEvalExpression(original: DirectEvalExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression {
-        const result: DirectEvalExpression = new DirectEvalExpression(global.generatedEs2panda._UpdateDirectEvalExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, parserStatus))
+        const result: DirectEvalExpression = new DirectEvalExpression(global.generatedEs2panda._UpdateDirectEvalExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, parserStatus), Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -58,5 +56,5 @@ export function isDirectEvalExpression(node: object | undefined): node is Direct
     return node instanceof DirectEvalExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL, (peer: KNativePointer) => new DirectEvalExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL, (peer: KNativePointer) => new DirectEvalExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL))
 }

package/build/libarkts-copy/src/generated/peers/DoWhileStatement.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,17 +37,16 @@ import { LoopStatement } from "./LoopStatement"
 import { Statement } from "./Statement"
 export class DoWhileStatement extends LoopStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 24)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createDoWhileStatement(body?: Statement, test?: Expression): DoWhileStatement {
-        const result: DoWhileStatement = new DoWhileStatement(global.generatedEs2panda._CreateDoWhileStatement(global.context, passNode(body), passNode(test)))
+        const result: DoWhileStatement = new DoWhileStatement(global.generatedEs2panda._CreateDoWhileStatement(global.context, passNode(body), passNode(test)), Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateDoWhileStatement(original?: DoWhileStatement, body?: Statement, test?: Expression): DoWhileStatement {
-        const result: DoWhileStatement = new DoWhileStatement(global.generatedEs2panda._UpdateDoWhileStatement(global.context, passNode(original), passNode(body), passNode(test)))
+        const result: DoWhileStatement = new DoWhileStatement(global.generatedEs2panda._UpdateDoWhileStatement(global.context, passNode(original), passNode(body), passNode(test)), Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -64,5 +62,5 @@ export function isDoWhileStatement(node: object | undefined): node is DoWhileSta
     return node instanceof DoWhileStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT, (peer: KNativePointer) => new DoWhileStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT, (peer: KNativePointer) => new DoWhileStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT))
 }

package/build/libarkts-copy/src/generated/peers/DynamicImportData.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,

package/build/libarkts-copy/src/generated/peers/ETSClassLiteral.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 export class ETSClassLiteral extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 73)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSClassLiteral(expr?: TypeNode): ETSClassLiteral {
-        const result: ETSClassLiteral = new ETSClassLiteral(global.generatedEs2panda._CreateETSClassLiteral(global.context, passNode(expr)))
+        const result: ETSClassLiteral = new ETSClassLiteral(global.generatedEs2panda._CreateETSClassLiteral(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSClassLiteral(original?: ETSClassLiteral, expr?: TypeNode): ETSClassLiteral {
-        const result: ETSClassLiteral = new ETSClassLiteral(global.generatedEs2panda._UpdateETSClassLiteral(global.context, passNode(original), passNode(expr)))
+        const result: ETSClassLiteral = new ETSClassLiteral(global.generatedEs2panda._UpdateETSClassLiteral(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +58,5 @@ export function isETSClassLiteral(node: object | undefined): node is ETSClassLit
     return node instanceof ETSClassLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL, (peer: KNativePointer) => new ETSClassLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL, (peer: KNativePointer) => new ETSClassLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL))
 }

package/build/libarkts-copy/src/generated/peers/ETSFunctionType.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -40,14 +39,14 @@ import { FunctionSignature } from "./FunctionSignature"
 import { TSInterfaceDeclaration } from "./TSInterfaceDeclaration"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
+import { extension_ETSFunctionTypeGetParamsCasted } from "./../../reexport-for-generated"
 export class ETSFunctionType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 69)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSFunctionType(signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags, annotations?: readonly AnnotationUsage[]): ETSFunctionType {
-        const result: ETSFunctionType = new ETSFunctionType(global.generatedEs2panda._CreateETSFunctionType(global.context, passNode(signature), funcFlags))
+        const result: ETSFunctionType = new ETSFunctionType(global.generatedEs2panda._CreateETSFunctionType(global.context, passNode(signature), funcFlags), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -56,7 +55,7 @@ export class ETSFunctionType extends TypeNode {
         return result
     }
     static updateETSFunctionType(original: ETSFunctionType | undefined, signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags, annotations?: readonly AnnotationUsage[]): ETSFunctionType {
-        const result: ETSFunctionType = new ETSFunctionType(global.generatedEs2panda._UpdateETSFunctionType(global.context, passNode(original), passNode(signature), funcFlags))
+        const result: ETSFunctionType = new ETSFunctionType(global.generatedEs2panda._UpdateETSFunctionType(global.context, passNode(original), passNode(signature), funcFlags), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -65,16 +64,21 @@ export class ETSFunctionType extends TypeNode {
         return result
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._ETSFunctionTypeTypeParams(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSFunctionTypeTypeParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
     }
     get params(): readonly Expression[] {
         return unpackNodeArray(global.generatedEs2panda._ETSFunctionTypeParamsConst(global.context, this.peer))
     }
+    /** @deprecated */
+    setParams(paramsList: readonly Expression[]): this {
+        global.generatedEs2panda._ETSFunctionTypeSetParams(global.context, this.peer, passNodeArray(paramsList), paramsList.length)
+        return this
+    }
     get returnType(): TypeNode | undefined {
         return unpackNode(global.generatedEs2panda._ETSFunctionTypeReturnType(global.context, this.peer))
     }
     get functionalInterface(): TSInterfaceDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._ETSFunctionTypeFunctionalInterface(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSFunctionTypeFunctionalInterface(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION)
     }
     /** @deprecated */
     setFunctionalInterface(functionalInterface?: TSInterfaceDeclaration): this {
@@ -87,11 +91,12 @@ export class ETSFunctionType extends TypeNode {
     get isExtensionFunction(): boolean {
         return global.generatedEs2panda._ETSFunctionTypeIsExtensionFunctionConst(global.context, this.peer)
     }
+    getParamsCasted = extension_ETSFunctionTypeGetParamsCasted
     protected readonly brandETSFunctionType: undefined
 }
 export function isETSFunctionType(node: object | undefined): node is ETSFunctionType {
     return node instanceof ETSFunctionType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, (peer: KNativePointer) => new ETSFunctionType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, (peer: KNativePointer) => new ETSFunctionType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/ETSImportDeclaration.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -40,17 +39,16 @@ import { ImportDeclaration } from "./ImportDeclaration"
 import { StringLiteral } from "./StringLiteral"
 export class ETSImportDeclaration extends ImportDeclaration {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 81)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSImportDeclaration(importPath: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ETSImportDeclaration {
-        const result: ETSImportDeclaration = new ETSImportDeclaration(global.generatedEs2panda._CreateETSImportDeclaration(global.context, passNode(importPath), passNodeArray(specifiers), specifiers.length, importKinds))
+        const result: ETSImportDeclaration = new ETSImportDeclaration(global.generatedEs2panda._CreateETSImportDeclaration(global.context, passNode(importPath), passNodeArray(specifiers), specifiers.length, importKinds), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSImportDeclaration(original: ETSImportDeclaration | undefined, importPath: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ETSImportDeclaration {
-        const result: ETSImportDeclaration = new ETSImportDeclaration(global.generatedEs2panda._UpdateETSImportDeclaration(global.context, passNode(original), passNode(importPath), passNodeArray(specifiers), specifiers.length, importKinds))
+        const result: ETSImportDeclaration = new ETSImportDeclaration(global.generatedEs2panda._UpdateETSImportDeclaration(global.context, passNode(original), passNode(importPath), passNodeArray(specifiers), specifiers.length, importKinds), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -88,5 +86,5 @@ export function isETSImportDeclaration(node: object | undefined): node is ETSImp
     return node instanceof ETSImportDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, (peer: KNativePointer) => new ETSImportDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, (peer: KNativePointer) => new ETSImportDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION))
 }

package/build/libarkts-copy/src/generated/peers/ETSIntrinsicNode.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,27 +36,26 @@ import { Es2pandaIntrinsicNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 export class ETSIntrinsicNode extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 68)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create2ETSIntrinsicNode(type: Es2pandaIntrinsicNodeType, _arguments: readonly Expression[]): ETSIntrinsicNode {
-        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._CreateETSIntrinsicNode2(global.context, type, passNodeArray(_arguments), _arguments.length))
+        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._CreateETSIntrinsicNode2(global.context, type, passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSIntrinsicNode(original?: ETSIntrinsicNode): ETSIntrinsicNode {
-        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode(global.context, passNode(original)))
+        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static update1ETSIntrinsicNode(original?: ETSIntrinsicNode, other?: ETSIntrinsicNode): ETSIntrinsicNode {
-        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode1(global.context, passNode(original), passNode(other)))
+        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static update2ETSIntrinsicNode(original: ETSIntrinsicNode | undefined, type: Es2pandaIntrinsicNodeType, _arguments: readonly Expression[]): ETSIntrinsicNode {
-        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode2(global.context, passNode(original), type, passNodeArray(_arguments), _arguments.length))
+        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode2(global.context, passNode(original), type, passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -73,5 +71,5 @@ export function isETSIntrinsicNode(node: object | undefined): node is ETSIntrins
     return node instanceof ETSIntrinsicNode
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE, (peer: KNativePointer) => new ETSIntrinsicNode(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE, (peer: KNativePointer) => new ETSIntrinsicNode(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/ETSKeyofType.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class ETSKeyofType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 77)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSKeyofType(type?: TypeNode): ETSKeyofType {
-        const result: ETSKeyofType = new ETSKeyofType(global.generatedEs2panda._CreateETSKeyofType(global.context, passNode(type)))
+        const result: ETSKeyofType = new ETSKeyofType(global.generatedEs2panda._CreateETSKeyofType(global.context, passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSKeyofType(original?: ETSKeyofType, type?: TypeNode): ETSKeyofType {
-        const result: ETSKeyofType = new ETSKeyofType(global.generatedEs2panda._UpdateETSKeyofType(global.context, passNode(original), passNode(type)))
+        const result: ETSKeyofType = new ETSKeyofType(global.generatedEs2panda._UpdateETSKeyofType(global.context, passNode(original), passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isETSKeyofType(node: object | undefined): node is ETSKeyofType {
     return node instanceof ETSKeyofType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE, (peer: KNativePointer) => new ETSKeyofType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE, (peer: KNativePointer) => new ETSKeyofType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/ETSModule.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -39,32 +38,32 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaModuleFlag } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
 import { Program } from "./Program"
+import { SrcDumper } from "./SrcDumper"
 import { Statement } from "./Statement"
 import { extension_ETSModuleGetNamespaceFlag } from "./../../reexport-for-generated"
 export class ETSModule extends BlockStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 84)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSModule(statementList: readonly Statement[], ident: Identifier | undefined, flag: Es2pandaModuleFlag, program?: Program): ETSModule {
-        const result: ETSModule = new ETSModule(global.generatedEs2panda._CreateETSModule(global.context, passNodeArray(statementList), statementList.length, passNode(ident), flag, passNode(program)))
+        const result: ETSModule = new ETSModule(global.generatedEs2panda._CreateETSModule(global.context, passNodeArray(statementList), statementList.length, passNode(ident), flag, passNode(program)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSModule(original: ETSModule | undefined, statementList: readonly Statement[], ident: Identifier | undefined, flag: Es2pandaModuleFlag, program?: Program): ETSModule {
-        const result: ETSModule = new ETSModule(global.generatedEs2panda._UpdateETSModule(global.context, passNode(original), passNodeArray(statementList), statementList.length, passNode(ident), flag, passNode(program)))
+        const result: ETSModule = new ETSModule(global.generatedEs2panda._UpdateETSModule(global.context, passNode(original), passNodeArray(statementList), statementList.length, passNode(ident), flag, passNode(program)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)
         result.setChildrenParentPtr()
         return result
     }
     get ident(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ETSModuleIdent(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSModuleIdent(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get program(): Program | undefined {
         return new Program(global.generatedEs2panda._ETSModuleProgram(global.context, this.peer))
     }
     get globalClass(): ClassDefinition | undefined {
-        return unpackNode(global.generatedEs2panda._ETSModuleGlobalClass(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSModuleGlobalClass(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
     }
     /** @deprecated */
     setGlobalClass(globalClass?: ClassDefinition): this {
@@ -85,9 +84,12 @@ export class ETSModule extends BlockStatement {
         global.generatedEs2panda._ETSModuleSetNamespaceChainLastNode(global.context, this.peer)
         return this
     }
+    get hasAnnotations(): boolean {
+        return global.generatedEs2panda._ETSModuleHasAnnotationsConst(global.context, this.peer)
+    }
     /** @deprecated */
-    emplaceAnnotations(source?: AnnotationUsage): this {
-        global.generatedEs2panda._ETSModuleEmplaceAnnotations(global.context, this.peer, passNode(source))
+    emplaceAnnotation(source?: AnnotationUsage): this {
+        global.generatedEs2panda._ETSModuleEmplaceAnnotation(global.context, this.peer, passNode(source))
         return this
     }
     /** @deprecated */
@@ -96,15 +98,15 @@ export class ETSModule extends BlockStatement {
         return this
     }
     /** @deprecated */
-    setValueAnnotations(source: AnnotationUsage | undefined, index: number): this {
-        global.generatedEs2panda._ETSModuleSetValueAnnotations(global.context, this.peer, passNode(source), index)
+    dumpAnnotations(dumper?: SrcDumper): this {
+        global.generatedEs2panda._ETSModuleDumpAnnotationsConst(global.context, this.peer, passNode(dumper))
         return this
     }
     get annotationsForUpdate(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ETSModuleAnnotationsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ETSModuleAnnotationsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ETSModuleAnnotations(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ETSModuleAnnotations(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     /** @deprecated */
     setAnnotations(annotationList: readonly AnnotationUsage[]): this {
@@ -116,11 +118,6 @@ export class ETSModule extends BlockStatement {
         global.generatedEs2panda._ETSModuleSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length)
         return this
     }
-    /** @deprecated */
-    addAnnotations(annotations?: AnnotationUsage): this {
-        global.generatedEs2panda._ETSModuleAddAnnotations(global.context, this.peer, passNode(annotations))
-        return this
-    }
     getNamespaceFlag = extension_ETSModuleGetNamespaceFlag
     protected readonly brandETSModule: undefined
 }
@@ -128,5 +125,5 @@ export function isETSModule(node: object | undefined): node is ETSModule {
     return node instanceof ETSModule
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, (peer: KNativePointer) => new ETSModule(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, (peer: KNativePointer) => new ETSModule(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE))
 }

package/build/libarkts-copy/src/generated/peers/ETSNewArrayInstanceExpression.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 export class ETSNewArrayInstanceExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 78)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSNewArrayInstanceExpression(typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression {
-        const result: ETSNewArrayInstanceExpression = new ETSNewArrayInstanceExpression(global.generatedEs2panda._CreateETSNewArrayInstanceExpression(global.context, passNode(typeReference), passNode(dimension)))
+        const result: ETSNewArrayInstanceExpression = new ETSNewArrayInstanceExpression(global.generatedEs2panda._CreateETSNewArrayInstanceExpression(global.context, passNode(typeReference), passNode(dimension)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSNewArrayInstanceExpression(original?: ETSNewArrayInstanceExpression, typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression {
-        const result: ETSNewArrayInstanceExpression = new ETSNewArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNode(dimension)))
+        const result: ETSNewArrayInstanceExpression = new ETSNewArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNode(dimension)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -73,5 +71,5 @@ export function isETSNewArrayInstanceExpression(node: object | undefined): node
     return node instanceof ETSNewArrayInstanceExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewArrayInstanceExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewArrayInstanceExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/ETSNewClassInstanceExpression.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,22 +35,21 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 export class ETSNewClassInstanceExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 80)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSNewClassInstanceExpression(typeReference: Expression | undefined, _arguments: readonly Expression[]): ETSNewClassInstanceExpression {
-        const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression(global.context, passNode(typeReference), passNodeArray(_arguments), _arguments.length))
+        const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression(global.context, passNode(typeReference), passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSNewClassInstanceExpression(original: ETSNewClassInstanceExpression | undefined, typeReference: Expression | undefined, _arguments: readonly Expression[]): ETSNewClassInstanceExpression {
-        const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(_arguments), _arguments.length))
+        const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static update1ETSNewClassInstanceExpression(original?: ETSNewClassInstanceExpression, other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression {
-        const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression1(global.context, passNode(original), passNode(other)))
+        const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -77,5 +75,5 @@ export function isETSNewClassInstanceExpression(node: object | undefined): node
     return node instanceof ETSNewClassInstanceExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewClassInstanceExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewClassInstanceExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,22 +36,21 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 export class ETSNewMultiDimArrayInstanceExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 79)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSNewMultiDimArrayInstanceExpression(typeReference: TypeNode | undefined, dimensions: readonly Expression[]): ETSNewMultiDimArrayInstanceExpression {
-        const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._CreateETSNewMultiDimArrayInstanceExpression(global.context, passNode(typeReference), passNodeArray(dimensions), dimensions.length))
+        const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._CreateETSNewMultiDimArrayInstanceExpression(global.context, passNode(typeReference), passNodeArray(dimensions), dimensions.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSNewMultiDimArrayInstanceExpression(original: ETSNewMultiDimArrayInstanceExpression | undefined, typeReference: TypeNode | undefined, dimensions: readonly Expression[]): ETSNewMultiDimArrayInstanceExpression {
-        const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(dimensions), dimensions.length))
+        const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(dimensions), dimensions.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static update1ETSNewMultiDimArrayInstanceExpression(original?: ETSNewMultiDimArrayInstanceExpression, other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression {
-        const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(original), passNode(other)))
+        const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -73,5 +71,5 @@ export function isETSNewMultiDimArrayInstanceExpression(node: object | undefined
     return node instanceof ETSNewMultiDimArrayInstanceExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewMultiDimArrayInstanceExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewMultiDimArrayInstanceExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/ETSNullType.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class ETSNullType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 64)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSNullType(): ETSNullType {
-        const result: ETSNullType = new ETSNullType(global.generatedEs2panda._CreateETSNullType(global.context))
+        const result: ETSNullType = new ETSNullType(global.generatedEs2panda._CreateETSNullType(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSNullType(original?: ETSNullType): ETSNullType {
-        const result: ETSNullType = new ETSNullType(global.generatedEs2panda._UpdateETSNullType(global.context, passNode(original)))
+        const result: ETSNullType = new ETSNullType(global.generatedEs2panda._UpdateETSNullType(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isETSNullType(node: object | undefined): node is ETSNullType {
     return node instanceof ETSNullType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE, (peer: KNativePointer) => new ETSNullType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE, (peer: KNativePointer) => new ETSNullType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/ETSPackageDeclaration.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 export class ETSPackageDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 72)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSPackageDeclaration(name?: Expression): ETSPackageDeclaration {
-        const result: ETSPackageDeclaration = new ETSPackageDeclaration(global.generatedEs2panda._CreateETSPackageDeclaration(global.context, passNode(name)))
+        const result: ETSPackageDeclaration = new ETSPackageDeclaration(global.generatedEs2panda._CreateETSPackageDeclaration(global.context, passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSPackageDeclaration(original?: ETSPackageDeclaration, name?: Expression): ETSPackageDeclaration {
-        const result: ETSPackageDeclaration = new ETSPackageDeclaration(global.generatedEs2panda._UpdateETSPackageDeclaration(global.context, passNode(original), passNode(name)))
+        const result: ETSPackageDeclaration = new ETSPackageDeclaration(global.generatedEs2panda._UpdateETSPackageDeclaration(global.context, passNode(original), passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -57,5 +55,5 @@ export function isETSPackageDeclaration(node: object | undefined): node is ETSPa
     return node instanceof ETSPackageDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION, (peer: KNativePointer) => new ETSPackageDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION, (peer: KNativePointer) => new ETSPackageDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION))
 }