diff --git a/koala-wrapper/native/src/generated/bridges.cc b/koala-wrapper/native/src/generated/bridges.cc index d89b383f9462046f70aebb5ed3cebe73e231b121..73a311a4ad69033499c0903612a317e66fda7a97 100644 --- a/koala-wrapper/native/src/generated/bridges.cc +++ b/koala-wrapper/native/src/generated/bridges.cc @@ -11282,6 +11282,19 @@ KNativePointer impl_CreateForUpdateStatement(KNativePointer context, KNativePoin } KOALA_INTEROP_5(CreateForUpdateStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); +KNativePointer impl_UpdateForUpdateStatement(KNativePointer context, KNativePointer original, KNativePointer init, KNativePointer test, KNativePointer update, KNativePointer body) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _init = reinterpret_cast(init); + const auto _test = reinterpret_cast(test); + const auto _update = reinterpret_cast(update); + const auto _body = reinterpret_cast(body); + auto result = GetImpl()->UpdateForUpdateStatement(_context, _original, _init, _test, _update, _body); + return result; +} +KOALA_INTEROP_6(UpdateForUpdateStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + KNativePointer impl_ForUpdateStatementInit(KNativePointer context, KNativePointer receiver) { const auto _context = reinterpret_cast(context); diff --git a/koala-wrapper/src/arkts-api/factory/nodeFactory.ts b/koala-wrapper/src/arkts-api/factory/nodeFactory.ts index f9ad2411845d976924a1b0ccd47a7d8968e1dbe4..c780fdbf9e9b760ce14b9536ad5b386725d3772d 100644 --- a/koala-wrapper/src/arkts-api/factory/nodeFactory.ts +++ b/koala-wrapper/src/arkts-api/factory/nodeFactory.ts @@ -78,6 +78,9 @@ import { AnnotationDeclaration, TryStatement, TSClassImplements, + ForUpdateStatement, + ForInStatement, + ForOfStatement, } from '../../generated'; import { Es2pandaModifierFlags } from '../../generated/Es2pandaEnums'; import { classPropertySetOptional, hasModifierFlag } from '../utilities/public'; @@ -136,6 +139,9 @@ import { updateArrayExpression } from '../node-utilities/ArrayExpression'; import { updateAnnotationDeclaration } from '../node-utilities/AnnotationDeclaration'; import { updateTryStatement } from '../node-utilities/TryStatement'; import { updateTSClassImplements } from '../node-utilities/TSClassImplements'; +import { updateForUpdateStatement } from '../node-utilities/ForUpdateStatement'; +import { updateForInStatement } from '../node-utilities/ForInStatement'; +import { updateForOfStatement } from '../node-utilities/ForOfStatement'; export const factory = { get createIdentifier(): (...args: Parameters) => Identifier { @@ -567,12 +573,34 @@ export const factory = { get updateTryStatement(): (...args: Parameters) => TryStatement { return updateTryStatement; }, - get createTSClassImplements(): (...args: Parameters) => TSClassImplements { + get createTSClassImplements(): ( + ...args: Parameters + ) => TSClassImplements { return TSClassImplements.createTSClassImplements; }, get UpdateTSClassImplements(): (...args: Parameters) => TSClassImplements { return updateTSClassImplements; }, + get createForUpdateStatement(): ( + ...args: Parameters + ) => ForUpdateStatement { + return ForUpdateStatement.createForUpdateStatement; + }, + get updateForUpdateStatement(): (...args: Parameters) => ForUpdateStatement { + return updateForUpdateStatement; + }, + get createForInStatement(): (...args: Parameters) => ForInStatement { + return ForInStatement.createForInStatement; + }, + get updateForInStatement(): (...args: Parameters) => ForInStatement { + return updateForInStatement; + }, + get createForOfStatement(): (...args: Parameters) => ForOfStatement { + return ForOfStatement.createForOfStatement; + }, + get updateForOfStatement(): (...args: Parameters) => ForOfStatement { + return updateForOfStatement; + }, /** @deprecated */ createTypeParameter1_(name: Identifier, constraint?: TypeNode, defaultType?: TypeNode) { return TSTypeParameter.createTSTypeParameter(Identifier.create1Identifier(name.name), constraint, defaultType); diff --git a/koala-wrapper/src/arkts-api/node-utilities/ForInStatement.ts b/koala-wrapper/src/arkts-api/node-utilities/ForInStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..5e35ce0f00b2325313fc74da8f961a98c5a6bd3b --- /dev/null +++ b/koala-wrapper/src/arkts-api/node-utilities/ForInStatement.ts @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { ForInStatement, Statement, Expression } from '../../generated'; +import { isSameNativeObject } from '../peers/ArktsObject'; +import { AstNode } from '../peers/AstNode'; +import { attachModifiers, updateThenAttach } from '../utilities/private'; + +export function updateForInStatement( + original: ForInStatement, + left?: AstNode, + right?: Expression, + body?: Statement +): ForInStatement { + if ( + isSameNativeObject(left, original.left) && + isSameNativeObject(right, original.right) && + isSameNativeObject(body, original.body) + ) { + return original; + } + + const updateNode = updateThenAttach(ForInStatement.updateForInStatement, attachModifiers); + return updateNode(original, left, right, body); +} diff --git a/koala-wrapper/src/arkts-api/node-utilities/ForOfStatement.ts b/koala-wrapper/src/arkts-api/node-utilities/ForOfStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..be4911dac2de2681d94177cca740611d51d7b9fe --- /dev/null +++ b/koala-wrapper/src/arkts-api/node-utilities/ForOfStatement.ts @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { ForOfStatement, Statement, Expression } from '../../generated'; +import { isSameNativeObject } from '../peers/ArktsObject'; +import { AstNode } from '../peers/AstNode'; +import { attachModifiers, updateThenAttach } from '../utilities/private'; + +export function updateForOfStatement( + original: ForOfStatement, + left: AstNode | undefined, + right: Expression | undefined, + body: Statement | undefined, + isAwait: boolean +): ForOfStatement { + if ( + isSameNativeObject(left, original.left) && + isSameNativeObject(right, original.right) && + isSameNativeObject(body, original.body) + ) { + return original; + } + + const updateNode = updateThenAttach(ForOfStatement.updateForOfStatement, attachModifiers); + return updateNode(original, left, right, body, isAwait); +} diff --git a/koala-wrapper/src/arkts-api/node-utilities/ForUpdateStatement.ts b/koala-wrapper/src/arkts-api/node-utilities/ForUpdateStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..a2085b159e59f7eb1a2ec2fbdfa6a1f05a2d3a39 --- /dev/null +++ b/koala-wrapper/src/arkts-api/node-utilities/ForUpdateStatement.ts @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { ForUpdateStatement, Statement, Expression } from '../../generated'; +import { isSameNativeObject } from '../peers/ArktsObject'; +import { AstNode } from '../peers/AstNode'; +import { attachModifiers, updateThenAttach } from '../utilities/private'; + +export function updateForUpdateStatement( + original: ForUpdateStatement, + init?: AstNode, + test?: Expression, + update?: Expression, + body?: Statement +): ForUpdateStatement { + if ( + isSameNativeObject(init, original.init) && + isSameNativeObject(test, original.test) && + isSameNativeObject(update, original.update) && + isSameNativeObject(body, original.body) + ) { + return original; + } + + const updateNode = updateThenAttach(ForUpdateStatement.updateForUpdateStatement, attachModifiers); + return updateNode(original, init, test, update, body); +} diff --git a/koala-wrapper/src/arkts-api/visitor.ts b/koala-wrapper/src/arkts-api/visitor.ts index b2bca233671de1e6348a744fa6ff0085cdb79b99..e0218c32c82015e1545403faab5b41f5d881dd98 100644 --- a/koala-wrapper/src/arkts-api/visitor.ts +++ b/koala-wrapper/src/arkts-api/visitor.ts @@ -48,6 +48,9 @@ import { isArrayExpression, isTryStatement, isBinaryExpression, + isForInStatement, + isForUpdateStatement, + isForOfStatement, } from '../generated'; import { isEtsScript, @@ -98,6 +101,7 @@ export function visitEachChild(node: AstNode, visitor: Visitor): AstNode { script = visitDefinition(script, visitor); script = visitDefinitionBody(script, visitor); script = visitStatement(script, visitor); + script = visitForLoopStatement(script, visitor); script = visitOuterExpression(script, visitor); script = visitInnerExpression(script, visitor); script = visitTrivialExpression(script, visitor); @@ -150,10 +154,7 @@ function visitOuterExpression(node: AstNode, visitor: Visitor): AstNode { } if (isArrayExpression(node)) { updated = true; - return factory.updateArrayExpression( - node, - nodesVisitor(node.elements, visitor) - ); + return factory.updateArrayExpression(node, nodesVisitor(node.elements, visitor)); } return node; } @@ -358,6 +359,42 @@ function visitStatement(node: AstNode, visitor: Visitor): AstNode { return node; } +function visitForLoopStatement(node: AstNode, visitor: Visitor): AstNode { + if (updated) { + return node; + } + if (isForUpdateStatement(node)) { + updated = true; + return factory.updateForUpdateStatement( + node, + nodeVisitor(node.init, visitor), + nodeVisitor(node.test, visitor), + nodeVisitor(node.update, visitor), + nodeVisitor(node.body, visitor) + ); + } + if (isForInStatement(node)) { + updated = true; + return factory.updateForInStatement( + node, + nodeVisitor(node.left, visitor), + nodeVisitor(node.right, visitor), + nodeVisitor(node.body, visitor) + ); + } + if (isForOfStatement(node)) { + updated = true; + return factory.updateForOfStatement( + node, + nodeVisitor(node.left, visitor), + nodeVisitor(node.right, visitor), + nodeVisitor(node.body, visitor), + node.isAwait + ); + } + return node; +} + function visitETSModule(node: AstNode, visitor: Visitor): AstNode { if (updated) { return node; diff --git a/koala-wrapper/src/generated/Es2pandaNativeModule.ts b/koala-wrapper/src/generated/Es2pandaNativeModule.ts index 7dcfda5a9e6fd221976438214656a28cdb7b1448..ef089731b19427e8bd01e8367ce692f5fda6ad31 100644 --- a/koala-wrapper/src/generated/Es2pandaNativeModule.ts +++ b/koala-wrapper/src/generated/Es2pandaNativeModule.ts @@ -3562,6 +3562,16 @@ export class Es2pandaNativeModule { _CreateForUpdateStatement(context: KNativePointer, init: KNativePointer, test: KNativePointer, update: KNativePointer, body: KNativePointer): KNativePointer { throw new Error("'CreateForUpdateStatement was not overloaded by native module initialization") } + _UpdateForUpdateStatement( + context: KNativePointer, + original: KNativePointer, + init: KNativePointer, + test: KNativePointer, + update: KNativePointer, + body: KNativePointer + ): KNativePointer { + throw new Error("'CreateForUpdateStatement was not overloaded by native module initialization"); + } _ForUpdateStatementInit(context: KNativePointer, receiver: KNativePointer): KNativePointer { throw new Error("'ForUpdateStatementInit was not overloaded by native module initialization") } diff --git a/koala-wrapper/src/generated/peers/ForInStatement.ts b/koala-wrapper/src/generated/peers/ForInStatement.ts index adb587a5e0ffbef7e9acff669298e42af3aab1d7..52d828bc18144096e4a20c57bfce70a5a8f991e8 100644 --- a/koala-wrapper/src/generated/peers/ForInStatement.ts +++ b/koala-wrapper/src/generated/peers/ForInStatement.ts @@ -16,47 +16,62 @@ import { global, passNode, - passNodeArray, - unpackNonNullableNode, unpackNode, - unpackNodeArray, assertValidPeer, AstNode, Es2pandaAstNodeType, KNativePointer, nodeByType, - ArktsObject, - unpackString -} from "../../reexport-for-generated" +} from '../../reexport-for-generated'; -import { LoopStatement } from "./LoopStatement" -import { Expression } from "./Expression" -import { Statement } from "./Statement" +import { LoopStatement } from './LoopStatement'; +import { Expression } from './Expression'; +import { Statement } from './Statement'; export class ForInStatement extends LoopStatement { - constructor(pointer: KNativePointer) { - assertValidPeer(pointer, Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT) - super(pointer) - + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT); + super(pointer); } static createForInStatement(left?: AstNode, right?: Expression, body?: Statement): ForInStatement { - return new ForInStatement(global.generatedEs2panda._CreateForInStatement(global.context, passNode(left), passNode(right), passNode(body))) + return new ForInStatement( + global.generatedEs2panda._CreateForInStatement( + global.context, + passNode(left), + passNode(right), + passNode(body) + ) + ); } - static updateForInStatement(original?: ForInStatement, left?: AstNode, right?: Expression, body?: Statement): ForInStatement { - return new ForInStatement(global.generatedEs2panda._UpdateForInStatement(global.context, passNode(original), passNode(left), passNode(right), passNode(body))) + static updateForInStatement( + original?: ForInStatement, + left?: AstNode, + right?: Expression, + body?: Statement + ): ForInStatement { + return new ForInStatement( + global.generatedEs2panda._UpdateForInStatement( + global.context, + passNode(original), + passNode(left), + passNode(right), + passNode(body) + ) + ); } get left(): AstNode | undefined { - return unpackNode(global.generatedEs2panda._ForInStatementLeftConst(global.context, this.peer)) + return unpackNode(global.generatedEs2panda._ForInStatementLeft(global.context, this.peer)); } get right(): Expression | undefined { - return unpackNode(global.generatedEs2panda._ForInStatementRightConst(global.context, this.peer)) + return unpackNode(global.generatedEs2panda._ForInStatementRight(global.context, this.peer)); } get body(): Statement | undefined { - return unpackNode(global.generatedEs2panda._ForInStatementBodyConst(global.context, this.peer)) + return unpackNode(global.generatedEs2panda._ForInStatementBody(global.context, this.peer)); } + protected readonly brandForInStatement: undefined; } -export function isForInStatement(node: AstNode): node is ForInStatement { - return node instanceof ForInStatement +export function isForInStatement(node: object | undefined): node is ForInStatement { + return node instanceof ForInStatement; } if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT)) { - nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT, ForInStatement) + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT, ForInStatement); } diff --git a/koala-wrapper/src/generated/peers/ForOfStatement.ts b/koala-wrapper/src/generated/peers/ForOfStatement.ts index d958eb5a2dd27cab794199d6ef4402fdc69313f9..4ff443a2668991dd4a1ca0e18f7c36da8b4afc43 100644 --- a/koala-wrapper/src/generated/peers/ForOfStatement.ts +++ b/koala-wrapper/src/generated/peers/ForOfStatement.ts @@ -16,50 +16,73 @@ import { global, passNode, - passNodeArray, - unpackNonNullableNode, unpackNode, - unpackNodeArray, assertValidPeer, AstNode, Es2pandaAstNodeType, KNativePointer, nodeByType, - ArktsObject, - unpackString -} from "../../reexport-for-generated" +} from '../../reexport-for-generated'; -import { LoopStatement } from "./LoopStatement" -import { Expression } from "./Expression" -import { Statement } from "./Statement" +import { LoopStatement } from './LoopStatement'; +import { Expression } from './Expression'; +import { Statement } from './Statement'; export class ForOfStatement extends LoopStatement { - constructor(pointer: KNativePointer) { - assertValidPeer(pointer, Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT) - super(pointer) - + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT); + super(pointer); } - static createForOfStatement(left: AstNode | undefined, right: Expression | undefined, body: Statement | undefined, isAwait: boolean): ForOfStatement { - return new ForOfStatement(global.generatedEs2panda._CreateForOfStatement(global.context, passNode(left), passNode(right), passNode(body), isAwait)) + static createForOfStatement( + left: AstNode | undefined, + right: Expression | undefined, + body: Statement | undefined, + isAwait: boolean + ): ForOfStatement { + return new ForOfStatement( + global.generatedEs2panda._CreateForOfStatement( + global.context, + passNode(left), + passNode(right), + passNode(body), + isAwait + ) + ); } - static updateForOfStatement(original: ForOfStatement | undefined, left: AstNode | undefined, right: Expression | undefined, body: Statement | undefined, isAwait: boolean): ForOfStatement { - return new ForOfStatement(global.generatedEs2panda._UpdateForOfStatement(global.context, passNode(original), passNode(left), passNode(right), passNode(body), isAwait)) + static updateForOfStatement( + original: ForOfStatement | undefined, + left: AstNode | undefined, + right: Expression | undefined, + body: Statement | undefined, + isAwait: boolean + ): ForOfStatement { + return new ForOfStatement( + global.generatedEs2panda._UpdateForOfStatement( + global.context, + passNode(original), + passNode(left), + passNode(right), + passNode(body), + isAwait + ) + ); } get left(): AstNode | undefined { - return unpackNode(global.generatedEs2panda._ForOfStatementLeftConst(global.context, this.peer)) + return unpackNode(global.generatedEs2panda._ForOfStatementLeft(global.context, this.peer)); } get right(): Expression | undefined { - return unpackNode(global.generatedEs2panda._ForOfStatementRightConst(global.context, this.peer)) + return unpackNode(global.generatedEs2panda._ForOfStatementRight(global.context, this.peer)); } get body(): Statement | undefined { - return unpackNode(global.generatedEs2panda._ForOfStatementBodyConst(global.context, this.peer)) + return unpackNode(global.generatedEs2panda._ForOfStatementBody(global.context, this.peer)); } get isAwait(): boolean { - return global.generatedEs2panda._ForOfStatementIsAwaitConst(global.context, this.peer) + return global.generatedEs2panda._ForOfStatementIsAwaitConst(global.context, this.peer); } + protected readonly brandForOfStatement: undefined; } -export function isForOfStatement(node: AstNode): node is ForOfStatement { - return node instanceof ForOfStatement +export function isForOfStatement(node: object | undefined): node is ForOfStatement { + return node instanceof ForOfStatement; } if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT)) { - nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT, ForOfStatement) + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT, ForOfStatement); } diff --git a/koala-wrapper/src/generated/peers/ForUpdateStatement.ts b/koala-wrapper/src/generated/peers/ForUpdateStatement.ts index cb7985248cb7769cf657b85d0b5cc2bbdb201619..0594d8771cdefcfe5fb4e0d93e9cad1fce397805 100644 --- a/koala-wrapper/src/generated/peers/ForUpdateStatement.ts +++ b/koala-wrapper/src/generated/peers/ForUpdateStatement.ts @@ -1,5 +1,5 @@ /* - * Copyright (c) 2025 Huawei Device Co., Ltd. + * Copyright (c) 2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -16,47 +16,77 @@ import { global, passNode, - passNodeArray, - unpackNonNullableNode, unpackNode, - unpackNodeArray, assertValidPeer, AstNode, - Es2pandaAstNodeType, KNativePointer, nodeByType, - ArktsObject, - unpackString -} from "../../reexport-for-generated" + Es2pandaAstNodeType, +} from '../../reexport-for-generated'; +import { Expression } from './Expression'; +import { LoopStatement } from './LoopStatement'; +import { Statement } from './Statement'; -import { LoopStatement } from "./LoopStatement" -import { Expression } from "./Expression" -import { Statement } from "./Statement" export class ForUpdateStatement extends LoopStatement { - constructor(pointer: KNativePointer) { - assertValidPeer(pointer, Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT) - super(pointer) - + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT); + super(pointer); } - static createForUpdateStatement(init?: AstNode, test?: Expression, update?: Expression, body?: Statement): ForUpdateStatement { - return new ForUpdateStatement(global.generatedEs2panda._CreateForUpdateStatement(global.context, passNode(init), passNode(test), passNode(update), passNode(body))) + static createForUpdateStatement( + init?: AstNode, + test?: Expression, + update?: Expression, + body?: Statement + ): ForUpdateStatement { + return new ForUpdateStatement( + global.generatedEs2panda._CreateForUpdateStatement( + global.context, + passNode(init), + passNode(test), + passNode(update), + passNode(body) + ) + ); + } + + static updateForUpdateStatement( + original: ForUpdateStatement, + init?: AstNode, + test?: Expression, + update?: Expression, + body?: Statement + ): ForUpdateStatement { + return new ForUpdateStatement( + global.generatedEs2panda._UpdateForUpdateStatement( + global.context, + passNode(original), + passNode(init), + passNode(test), + passNode(update), + passNode(body) + ) + ); } + get init(): AstNode | undefined { - return unpackNode(global.generatedEs2panda._ForUpdateStatementInitConst(global.context, this.peer)) + return unpackNode(global.generatedEs2panda._ForUpdateStatementInit(global.context, this.peer)); } get test(): Expression | undefined { - return unpackNode(global.generatedEs2panda._ForUpdateStatementTestConst(global.context, this.peer)) + return unpackNode(global.generatedEs2panda._ForUpdateStatementTest(global.context, this.peer)); } get update(): Expression | undefined { - return unpackNode(global.generatedEs2panda._ForUpdateStatementUpdateConst(global.context, this.peer)) + return unpackNode(global.generatedEs2panda._ForUpdateStatementUpdateConst(global.context, this.peer)); } get body(): Statement | undefined { - return unpackNode(global.generatedEs2panda._ForUpdateStatementBodyConst(global.context, this.peer)) + return unpackNode(global.generatedEs2panda._ForUpdateStatementBody(global.context, this.peer)); } + protected readonly brandForUpdateStatement: undefined; } -export function isForUpdateStatement(node: AstNode): node is ForUpdateStatement { - return node instanceof ForUpdateStatement + +export function isForUpdateStatement(node: object | undefined): node is ForUpdateStatement { + return node instanceof ForUpdateStatement; } + if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT)) { - nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT, ForUpdateStatement) + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT, ForUpdateStatement); }