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/BigIntLiteral.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 export class BigIntLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 5)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createBigIntLiteral(src: string): BigIntLiteral {
-        const result: BigIntLiteral = new BigIntLiteral(global.generatedEs2panda._CreateBigIntLiteral(global.context, src))
+        const result: BigIntLiteral = new BigIntLiteral(global.generatedEs2panda._CreateBigIntLiteral(global.context, src), Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateBigIntLiteral(original: BigIntLiteral | undefined, src: string): BigIntLiteral {
-        const result: BigIntLiteral = new BigIntLiteral(global.generatedEs2panda._UpdateBigIntLiteral(global.context, passNode(original), src))
+        const result: BigIntLiteral = new BigIntLiteral(global.generatedEs2panda._UpdateBigIntLiteral(global.context, passNode(original), src), Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isBigIntLiteral(node: object | undefined): node is BigIntLiteral
     return node instanceof BigIntLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL, (peer: KNativePointer) => new BigIntLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL, (peer: KNativePointer) => new BigIntLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -39,17 +38,16 @@ import { Expression } from "./Expression"
 import { VReg } from "./VReg"
 export class BinaryExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 6)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createBinaryExpression(left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression {
-        const result: BinaryExpression = new BinaryExpression(global.generatedEs2panda._CreateBinaryExpression(global.context, passNode(left), passNode(right), operatorType))
+        const result: BinaryExpression = new BinaryExpression(global.generatedEs2panda._CreateBinaryExpression(global.context, passNode(left), passNode(right), operatorType), Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateBinaryExpression(original: BinaryExpression | undefined, left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression {
-        const result: BinaryExpression = new BinaryExpression(global.generatedEs2panda._UpdateBinaryExpression(global.context, passNode(original), passNode(left), passNode(right), operatorType))
+        const result: BinaryExpression = new BinaryExpression(global.generatedEs2panda._UpdateBinaryExpression(global.context, passNode(original), passNode(left), passNode(right), operatorType), Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -108,5 +106,5 @@ export function isBinaryExpression(node: object | undefined): node is BinaryExpr
     return node instanceof BinaryExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, (peer: KNativePointer) => new BinaryExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, (peer: KNativePointer) => new BinaryExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION))
 }

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

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

package/build/libarkts-copy/src/generated/peers/BlockExpression.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 BlockExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 157)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createBlockExpression(statements: readonly Statement[]): BlockExpression {
-        const result: BlockExpression = new BlockExpression(global.generatedEs2panda._CreateBlockExpression(global.context, passNodeArray(statements), statements.length))
+        const result: BlockExpression = new BlockExpression(global.generatedEs2panda._CreateBlockExpression(global.context, passNodeArray(statements), statements.length), Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateBlockExpression(original: BlockExpression | undefined, statements: readonly Statement[]): BlockExpression {
-        const result: BlockExpression = new BlockExpression(global.generatedEs2panda._UpdateBlockExpression(global.context, passNode(original), passNodeArray(statements), statements.length))
+        const result: BlockExpression = new BlockExpression(global.generatedEs2panda._UpdateBlockExpression(global.context, passNode(original), passNodeArray(statements), statements.length), Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -70,5 +68,5 @@ export function isBlockExpression(node: object | undefined): node is BlockExpres
     return node instanceof BlockExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION, (peer: KNativePointer) => new BlockExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION, (peer: KNativePointer) => new BlockExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 export class BlockStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 7)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createBlockStatement(statementList: readonly Statement[]): BlockStatement {
-        const result: BlockStatement = new BlockStatement(global.generatedEs2panda._CreateBlockStatement(global.context, passNodeArray(statementList), statementList.length))
+        const result: BlockStatement = new BlockStatement(global.generatedEs2panda._CreateBlockStatement(global.context, passNodeArray(statementList), statementList.length), Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateBlockStatement(original: BlockStatement | undefined, statementList: readonly Statement[]): BlockStatement {
-        const result: BlockStatement = new BlockStatement(global.generatedEs2panda._UpdateBlockStatement(global.context, passNode(original), passNodeArray(statementList), statementList.length))
+        const result: BlockStatement = new BlockStatement(global.generatedEs2panda._UpdateBlockStatement(global.context, passNode(original), passNodeArray(statementList), statementList.length), Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -92,5 +90,5 @@ export function isBlockStatement(node: object | undefined): node is BlockStateme
     return node instanceof BlockStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, (peer: KNativePointer) => new BlockStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, (peer: KNativePointer) => new BlockStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 export class BooleanLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 8)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createBooleanLiteral(value: boolean): BooleanLiteral {
-        const result: BooleanLiteral = new BooleanLiteral(global.generatedEs2panda._CreateBooleanLiteral(global.context, value))
+        const result: BooleanLiteral = new BooleanLiteral(global.generatedEs2panda._CreateBooleanLiteral(global.context, value), Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateBooleanLiteral(original: BooleanLiteral | undefined, value: boolean): BooleanLiteral {
-        const result: BooleanLiteral = new BooleanLiteral(global.generatedEs2panda._UpdateBooleanLiteral(global.context, passNode(original), value))
+        const result: BooleanLiteral = new BooleanLiteral(global.generatedEs2panda._UpdateBooleanLiteral(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isBooleanLiteral(node: object | undefined): node is BooleanLiter
     return node instanceof BooleanLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL, (peer: KNativePointer) => new BooleanLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL, (peer: KNativePointer) => new BooleanLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,27 +36,26 @@ import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 export class BreakStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 9)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1BreakStatement(ident?: Identifier): BreakStatement {
-        const result: BreakStatement = new BreakStatement(global.generatedEs2panda._CreateBreakStatement1(global.context, passNode(ident)))
+        const result: BreakStatement = new BreakStatement(global.generatedEs2panda._CreateBreakStatement1(global.context, passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateBreakStatement(original?: BreakStatement): BreakStatement {
-        const result: BreakStatement = new BreakStatement(global.generatedEs2panda._UpdateBreakStatement(global.context, passNode(original)))
+        const result: BreakStatement = new BreakStatement(global.generatedEs2panda._UpdateBreakStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static update1BreakStatement(original?: BreakStatement, ident?: Identifier): BreakStatement {
-        const result: BreakStatement = new BreakStatement(global.generatedEs2panda._UpdateBreakStatement1(global.context, passNode(original), passNode(ident)))
+        const result: BreakStatement = new BreakStatement(global.generatedEs2panda._UpdateBreakStatement1(global.context, passNode(original), passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     get ident(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._BreakStatementIdent(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._BreakStatementIdent(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get target(): AstNode | undefined {
         return unpackNode(global.generatedEs2panda._BreakStatementTargetConst(global.context, this.peer))
@@ -76,5 +74,5 @@ export function isBreakStatement(node: object | undefined): node is BreakStateme
     return node instanceof BreakStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT, (peer: KNativePointer) => new BreakStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT, (peer: KNativePointer) => new BreakStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -39,12 +38,11 @@ import { MaybeOptionalExpression } from "./MaybeOptionalExpression"
 import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 export class CallExpression extends MaybeOptionalExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 10)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createCallExpression(callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, trailingComma: boolean, trailingBlock?: BlockStatement): CallExpression {
-        const result: CallExpression = new CallExpression(global.generatedEs2panda._CreateCallExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, trailingComma))
+        const result: CallExpression = new CallExpression(global.generatedEs2panda._CreateCallExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION)
         if (trailingBlock)
         {
             result.setTrailingBlock(trailingBlock)
@@ -53,7 +51,7 @@ export class CallExpression extends MaybeOptionalExpression {
         return result
     }
     static update1CallExpression(original?: CallExpression, other?: CallExpression, trailingBlock?: BlockStatement): CallExpression {
-        const result: CallExpression = new CallExpression(global.generatedEs2panda._UpdateCallExpression1(global.context, passNode(original), passNode(other)))
+        const result: CallExpression = new CallExpression(global.generatedEs2panda._UpdateCallExpression1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION)
         if (trailingBlock)
         {
             result.setTrailingBlock(trailingBlock)
@@ -70,11 +68,16 @@ export class CallExpression extends MaybeOptionalExpression {
         return this
     }
     get typeParams(): TSTypeParameterInstantiation | undefined {
-        return unpackNode(global.generatedEs2panda._CallExpressionTypeParams(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._CallExpressionTypeParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)
     }
     get arguments(): readonly Expression[] {
         return unpackNodeArray(global.generatedEs2panda._CallExpressionArguments(global.context, this.peer))
     }
+    /** @deprecated */
+    setArguments(argumentsList: readonly Expression[]): this {
+        global.generatedEs2panda._CallExpressionSetArguments(global.context, this.peer, passNodeArray(argumentsList), argumentsList.length)
+        return this
+    }
     get hasTrailingComma(): boolean {
         return global.generatedEs2panda._CallExpressionHasTrailingCommaConst(global.context, this.peer)
     }
@@ -122,5 +125,5 @@ export function isCallExpression(node: object | undefined): node is CallExpressi
     return node instanceof CallExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, (peer: KNativePointer) => new CallExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, (peer: KNativePointer) => new CallExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,22 +37,21 @@ import { Expression } from "./Expression"
 import { TypedStatement } from "./TypedStatement"
 export class CatchClause extends TypedStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 11)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createCatchClause(param?: Expression, body?: BlockStatement): CatchClause {
-        const result: CatchClause = new CatchClause(global.generatedEs2panda._CreateCatchClause(global.context, passNode(param), passNode(body)))
+        const result: CatchClause = new CatchClause(global.generatedEs2panda._CreateCatchClause(global.context, passNode(param), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE)
         result.setChildrenParentPtr()
         return result
     }
     static updateCatchClause(original?: CatchClause, param?: Expression, body?: BlockStatement): CatchClause {
-        const result: CatchClause = new CatchClause(global.generatedEs2panda._UpdateCatchClause(global.context, passNode(original), passNode(param), passNode(body)))
+        const result: CatchClause = new CatchClause(global.generatedEs2panda._UpdateCatchClause(global.context, passNode(original), passNode(param), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE)
         result.setChildrenParentPtr()
         return result
     }
     static update1CatchClause(original?: CatchClause, other?: CatchClause): CatchClause {
-        const result: CatchClause = new CatchClause(global.generatedEs2panda._UpdateCatchClause1(global.context, passNode(original), passNode(other)))
+        const result: CatchClause = new CatchClause(global.generatedEs2panda._UpdateCatchClause1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE)
         result.setChildrenParentPtr()
         return result
     }
@@ -72,5 +70,5 @@ export function isCatchClause(node: object | undefined): node is CatchClause {
     return node instanceof CatchClause
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE, (peer: KNativePointer) => new CatchClause(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE, (peer: KNativePointer) => new CatchClause(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,17 +37,16 @@ import { Expression } from "./Expression"
 import { VReg } from "./VReg"
 export class ChainExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 12)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createChainExpression(expression?: Expression): ChainExpression {
-        const result: ChainExpression = new ChainExpression(global.generatedEs2panda._CreateChainExpression(global.context, passNode(expression)))
+        const result: ChainExpression = new ChainExpression(global.generatedEs2panda._CreateChainExpression(global.context, passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateChainExpression(original?: ChainExpression, expression?: Expression): ChainExpression {
-        const result: ChainExpression = new ChainExpression(global.generatedEs2panda._UpdateChainExpression(global.context, passNode(original), passNode(expression)))
+        const result: ChainExpression = new ChainExpression(global.generatedEs2panda._UpdateChainExpression(global.context, passNode(original), passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -66,5 +64,5 @@ export function isChainExpression(node: object | undefined): node is ChainExpres
     return node instanceof ChainExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION, (peer: KNativePointer) => new ChainExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION, (peer: KNativePointer) => new ChainExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 export class CharLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 13)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createCharLiteral(): CharLiteral {
-        const result: CharLiteral = new CharLiteral(global.generatedEs2panda._CreateCharLiteral(global.context))
+        const result: CharLiteral = new CharLiteral(global.generatedEs2panda._CreateCharLiteral(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateCharLiteral(original?: CharLiteral): CharLiteral {
-        const result: CharLiteral = new CharLiteral(global.generatedEs2panda._UpdateCharLiteral(global.context, passNode(original)))
+        const result: CharLiteral = new CharLiteral(global.generatedEs2panda._UpdateCharLiteral(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isCharLiteral(node: object | undefined): node is CharLiteral {
     return node instanceof CharLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL, (peer: KNativePointer) => new CharLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL, (peer: KNativePointer) => new CharLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -33,18 +32,16 @@ import {
 } from "../../reexport-for-generated"
 import { ClassDefinition } from "./ClassDefinition"
-import { Decorator } from "./Decorator"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 export class ClassDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 15)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createClassDeclaration(def?: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration {
-        const result: ClassDeclaration = new ClassDeclaration(global.generatedEs2panda._CreateClassDeclaration(global.context, passNode(def)))
+        const result: ClassDeclaration = new ClassDeclaration(global.generatedEs2panda._CreateClassDeclaration(global.context, passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION)
         if (modifierFlags)
         {
             result.modifierFlags = modifierFlags
@@ -53,7 +50,7 @@ export class ClassDeclaration extends Statement {
         return result
     }
     static updateClassDeclaration(original?: ClassDeclaration, def?: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration {
-        const result: ClassDeclaration = new ClassDeclaration(global.generatedEs2panda._UpdateClassDeclaration(global.context, passNode(original), passNode(def)))
+        const result: ClassDeclaration = new ClassDeclaration(global.generatedEs2panda._UpdateClassDeclaration(global.context, passNode(original), passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION)
         if (modifierFlags)
         {
             result.modifierFlags = modifierFlags
@@ -62,28 +59,7 @@ export class ClassDeclaration extends Statement {
         return result
     }
     get definition(): ClassDefinition {
-        return unpackNonNullableNode(global.generatedEs2panda._ClassDeclarationDefinition(global.context, this.peer))
-    }
-    /** @deprecated */
-    emplaceDecorators(decorators?: Decorator): this {
-        global.generatedEs2panda._ClassDeclarationEmplaceDecorators(global.context, this.peer, passNode(decorators))
-        return this
-    }
-    /** @deprecated */
-    clearDecorators(): this {
-        global.generatedEs2panda._ClassDeclarationClearDecorators(global.context, this.peer)
-        return this
-    }
-    /** @deprecated */
-    setValueDecorators(decorators: Decorator | undefined, index: number): this {
-        global.generatedEs2panda._ClassDeclarationSetValueDecorators(global.context, this.peer, passNode(decorators), index)
-        return this
-    }
-    get decorators(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._ClassDeclarationDecorators(global.context, this.peer))
-    }
-    get decoratorsForUpdate(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._ClassDeclarationDecoratorsForUpdate(global.context, this.peer))
+        return unpackNonNullableNode(global.generatedEs2panda._ClassDeclarationDefinition(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
     }
     /** @deprecated */
     setDefinition(def?: ClassDefinition): this {
@@ -96,5 +72,5 @@ export function isClassDeclaration(node: object | undefined): node is ClassDecla
     return node instanceof ClassDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, (peer: KNativePointer) => new ClassDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, (peer: KNativePointer) => new ClassDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION))
 }