diff --git a/arkoala-arkts/libarkts/plugins/src/AbstractVisitor.ts b/arkoala-arkts/libarkts/plugins/src/AbstractVisitor.ts index 567edda0599e86def23cd4a731deb62cf245a693..09aa4a141abef770792e428f079f8a201f50cbc5 100644 --- a/arkoala-arkts/libarkts/plugins/src/AbstractVisitor.ts +++ b/arkoala-arkts/libarkts/plugins/src/AbstractVisitor.ts @@ -28,9 +28,9 @@ export abstract class AbstractVisitor { return result } - abstract visitor(node: ts.Node): ts.Node + abstract visitor(node: ts.AstNode): ts.AstNode - visitEachChild(node: ts.Node): ts.Node { + visitEachChild(node: ts.AstNode): ts.AstNode { return this.withIndentation(() => ts.visitEachChild( node, diff --git a/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts b/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts index f4e8143ddac3c324775fa9d4303691e6a8d65874..c2cc52f6bb7502153db9100370863ba69eb9c361 100644 --- a/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts +++ b/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts @@ -18,7 +18,7 @@ import { AbstractVisitor } from "./AbstractVisitor"; const builderLambdaInstanceName = "instance" -function getLambdaArg(lambdaBody: arkts.Node): arkts.ArrowFunctionExpression { +function getLambdaArg(lambdaBody: arkts.AstNode): arkts.ArrowFunctionExpression { const body = arkts.factory.createBlock( [ arkts.factory.createReturnStatement( @@ -62,7 +62,7 @@ function getLambdaArg(lambdaBody: arkts.Node): arkts.ArrowFunctionExpression { } function builderLambdaFunctionName(node: arkts.CallExpression): undefined | string { - let decl: arkts.Node|undefined = undefined + let decl: arkts.AstNode|undefined = undefined if (arkts.isIdentifier(node.expression)) { decl = arkts.getDecl(node.expression) } else if (arkts.isMemberExpression(node.expression)) { @@ -134,7 +134,7 @@ function builderLambdaReplace(leaf: arkts.CallExpression): arkts.Identifier|arkt export class BuilderLambdaTransformer extends AbstractVisitor { - visitor(beforeChildren: arkts.Node): arkts.Node { + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { const node = this.visitEachChild(beforeChildren) if (!arkts.isCallExpression(node)) { diff --git a/arkoala-arkts/libarkts/plugins/src/component-transformer.ts b/arkoala-arkts/libarkts/plugins/src/component-transformer.ts index c79727e2fabc3f213f2defe63bd239d4187b70b9..099f0590d5a10c3f7d8c66424e14551b64ff2016 100644 --- a/arkoala-arkts/libarkts/plugins/src/component-transformer.ts +++ b/arkoala-arkts/libarkts/plugins/src/component-transformer.ts @@ -13,6 +13,7 @@ * limitations under the License. */ +import { nullptr } from "@koalaui/interop"; import * as arkts from "@koalaui/libarkts" import { AbstractVisitor } from "./AbstractVisitor"; @@ -31,7 +32,7 @@ export class ComponentTransformer extends AbstractVisitor { [ arkts.factory.createImportSpecifier( arkts.factory.createIdentifier('StructBase'), - arkts.nullptr + nullptr // TODO: wtf ) ], arkts.Es2pandaImportKinds.IMPORT_KINDS_TYPE, @@ -44,7 +45,7 @@ export class ComponentTransformer extends AbstractVisitor { name => arkts.factory.createInterfaceDeclaration( [], arkts.factory.createIdentifier(`__Options_${name}`), - arkts.nullptr, + nullptr, // TODO: wtf arkts.factory.createBlock([]), false, false @@ -101,7 +102,7 @@ export class ComponentTransformer extends AbstractVisitor { ) } - visitor(node: arkts.Node): arkts.Node { + visitor(node: arkts.AstNode): arkts.AstNode { const newNode = this.visitEachChild(node) if (arkts.isEtsScript(newNode)) { return this.processEtsScript(newNode) diff --git a/arkoala-arkts/libarkts/plugins/src/print-visitor.ts b/arkoala-arkts/libarkts/plugins/src/print-visitor.ts index 9f9baf9d7195ca0880997f6767fa0b19971b9018..50be42fc2f9894ca188389e1bf9f0dd436c1cb15 100644 --- a/arkoala-arkts/libarkts/plugins/src/print-visitor.ts +++ b/arkoala-arkts/libarkts/plugins/src/print-visitor.ts @@ -8,13 +8,13 @@ export class PrintVisitor extends AbstractVisitor { this.result += " ".repeat(4 * this.indentation) + s + '\n' } - visitor(node: ts.Node): ts.Node { + visitor(node: ts.AstNode): ts.AstNode { console.log(`${" ".repeat(4 * this.indentation) + node.constructor.name}`) this.print(`${node.constructor.name}`) return this.visitEachChild(node) } - astToString(node: ts.Node): string { + astToString(node: ts.AstNode): string { this.result = "" this.visitor(node) return this.result.trim() diff --git a/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts b/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts new file mode 100644 index 0000000000000000000000000000000000000000..859c4d57a9d3f2b75481ef31c1037cc2827c04d7 --- /dev/null +++ b/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts @@ -0,0 +1,113 @@ +/* + * 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 { + AnnotationUsageIr, + ArrowFunctionExpression, + AssignmentExpression, + BinaryExpression, + BlockStatement, + CallExpression, + ClassDeclaration, + ClassDefinition, + ClassProperty, + ClassStaticBlock, + ETSFunctionType, + EtsImportDeclaration, + ETSParameterExpression, + ETSPrimitiveType, + EtsScript, + ETSTypeReference, + ETSTypeReferencePart, + ETSUndefinedType, + ETSUnionType, + ExpressionStatement, + FunctionDeclaration, + FunctionExpression, + Identifier, + IfStatement, + ImportSpecifier, + MethodDefinition, + NumberLiteral, + ReturnStatement, + ScriptFunction, + StringLiteral, + StructDeclaration, + SuperExpression, + TSTypeParameter, + TSTypeParameterDeclaration, + UndefinedLiteral, + UnsupportedNode, + VariableDeclaration, + VariableDeclarator +} from "./types" +import { Es2pandaAstNodeType } from "../Es2pandaEnums" +import { MemberExpression } from "./to-be-generated/MemberExpression" +import { throwError } from "../utils" +import { global } from "./static/global" +import { KNativePointer, nullptr } from "@koalaui/interop" +import { AstNode } from "./peers/AstNode" + +export function classByPeer(peer: KNativePointer): AstNode { + const constructors = new Map([ + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, EtsScript], + [Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, Identifier], + [Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, StringLiteral], + [Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, NumberLiteral], + [Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, ExpressionStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, FunctionDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, ScriptFunction], + [Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, BlockStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, ReturnStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, ETSParameterExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, ETSTypeReference], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART, ETSTypeReferencePart], + [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, TSTypeParameterDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, ETSPrimitiveType], + [Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, CallExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, MemberExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, TSTypeParameter], + [Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, IfStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, BinaryExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, ETSUnionType], + [Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, ArrowFunctionExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION, StructDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, ClassDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, ClassDefinition], + [Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, MethodDefinition], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, ClassProperty], + [Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, AssignmentExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, VariableDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, VariableDeclarator], + [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION, FunctionExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, ETSFunctionType], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, ClassStaticBlock], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, ETSUndefinedType], + [Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL, UndefinedLiteral], + [Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, SuperExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, EtsImportDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, ImportSpecifier], + [Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, AnnotationUsageIr], + ]) + + if (peer === nullptr) { + throwError('classByPeer: peer is NULLPTR') + } + const type = global.generatedEs2panda._AstNodeTypeConst(global.context, peer) + const constructor = constructors.get(type) + return constructor !== undefined + ? new constructor(peer) + : new UnsupportedNode(peer) +} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts index 37ac26e13f7acf4ed290bed6ab26c77874d73644..ff36ada6fe71586ed48aadfffa6919ab11c5a85b 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts @@ -13,11 +13,46 @@ * limitations under the License. */ -import * as arkts from "../types" import { updateNodeByNode } from "../utilities/private" +import { + ArrowFunctionExpression, + BinaryExpression, + BlockStatement, + CallExpression, + ClassDeclaration, + ClassDefinition, + ETSFunctionType, + EtsImportDeclaration, + ETSParameterExpression, + ETSPrimitiveType, + EtsScript, + ETSTypeReference, + ETSTypeReferencePart, + ETSUnionType, + ExpressionStatement, + FunctionDeclaration, + FunctionExpression, + Identifier, + IfStatement, + ImportSpecifier, + MethodDefinition, + NumberLiteral, + ReturnStatement, + ScriptFunction, + StringLiteral, + StructDeclaration, + SuperExpression, + TSInterfaceDeclaration, + TSTypeParameter, + TSTypeParameterDeclaration, + TSTypeParameterInstantiation, + VariableDeclaration, + VariableDeclarator +} from "../types" import { MemberExpression } from "../to-be-generated/MemberExpression" +import { AstNode } from "../peers/AstNode" -function compose( +function compose( create: (...args: ARGS) => T, update: (node: T, original: T) => T = updateNodeByNode ): (node: T, ...args: ARGS) => T { @@ -25,121 +60,218 @@ function compose( } export const factory = { - /** - * @see TS_INTERFACE - * @arg text: string - */ - createIdentifier: arkts.Identifier.create, - updateIdentifier: compose(arkts.Identifier.create), - - /** - * @see TS_INTERFACE - * @arg expression: Expression, - * @arg typeArguments: readonly TypeNode[] | undefined, - * @arg argumentsArray: readonly Expression[] | undefined, - */ - createCallExpression: arkts.CallExpression.create, - updateCallExpression: compose(arkts.CallExpression.create), - - createExpressionStatement: arkts.ExpressionStatement.create, - updateExpressionStatement: compose(arkts.ExpressionStatement.create), - - createMemberExpression: MemberExpression.create, - updateMemberExpression: compose(MemberExpression.create), - - createEtsScript: arkts.EtsScript.createFromSource, - updateEtsScript: arkts.EtsScript.updateByStatements, - - createFunctionDeclaration: arkts.FunctionDeclaration.create, - updateFunctionDeclaration: compose(arkts.FunctionDeclaration.create), - - createBlock: arkts.BlockStatement.create, - updateBlock: compose(arkts.BlockStatement.create), - - createArrowFunction: arkts.ArrowFunctionExpression.create, - updateArrowFunction: compose(arkts.ArrowFunctionExpression.create), - - createScriptFunction: arkts.ScriptFunction.create, - updateScriptFunction: compose(arkts.ScriptFunction.create), - - createStringLiteral: arkts.StringLiteral.create, - updateStringLiteral: compose(arkts.StringLiteral.create), - - createNumericLiteral: arkts.NumberLiteral.create, - updateNumericLiteral: compose(arkts.NumberLiteral.create), - - createParameterDeclaration: arkts.ETSParameterExpression.create, - updateParameterDeclaration: compose(arkts.ETSParameterExpression.create), - - createTypeParameter: arkts.TSTypeParameter.create, - updateTypeParameter: compose(arkts.TSTypeParameter.create), - - createTypeParameterDeclaration: arkts.TSTypeParameterDeclaration.create, - updateTypeParameterDeclaration: compose(arkts.TSTypeParameterDeclaration.create), - - createPrimitiveType: arkts.ETSPrimitiveType.create, - updatePrimitiveType: compose(arkts.ETSPrimitiveType.create), - - createTypeReference: arkts.ETSTypeReference.create, - updateTypeReference: compose(arkts.ETSTypeReference.create), - - createTypeReferenceFromId: arkts.ETSTypeReference.createFromId, - updateTypeReferenceFromId: compose(arkts.ETSTypeReference.createFromId), - - createTypeReferencePart: arkts.ETSTypeReferencePart.create, - updateTypeReferencePart: compose(arkts.ETSTypeReferencePart.create), - - createImportDeclaration: arkts.EtsImportDeclaration.create, - updateImportDeclaration: compose(arkts.EtsImportDeclaration.create), - - createImportSpecifier: arkts.ImportSpecifier.create, - updateImportSpecifier: compose(arkts.ImportSpecifier.create), - - // createImportSource: arkts.ImportSource.create, - // updateImportSource: compose(arkts.ImportSource.create), - - createVariableDeclaration: arkts.VariableDeclaration.create, - updateVariableDeclaration: compose(arkts.VariableDeclaration.create), - - createVariableDeclarator: arkts.VariableDeclarator.create, - updateVariableDeclarator: compose(arkts.VariableDeclarator.create), - - createUnionType: arkts.ETSUnionType.create, - updateUnionType: compose(arkts.ETSUnionType.create), - - createReturnStatement: arkts.ReturnStatement.create, - updateReturnStatement: compose(arkts.ReturnStatement.create), - - createIfStatement: arkts.IfStatement.create, - updateIfStatement: compose(arkts.IfStatement.create), - - createBinaryExpression: arkts.BinaryExpression.create, - updateBinaryExpression: compose(arkts.BinaryExpression.create), - - createClassDeclaration: arkts.ClassDeclaration.create, - updateClassDeclaration: compose(arkts.ClassDeclaration.create), - - createStructDeclaration: arkts.StructDeclaration.create, - updateStructDeclaration: compose(arkts.StructDeclaration.create), - - createClassDefinition: arkts.ClassDefinition.create, - updateClassDefinition: compose(arkts.ClassDefinition.create), - - createFunctionType: arkts.ETSFunctionType.create, - updateFunctionType: compose(arkts.ETSFunctionType.create), - - createFunctionExpression: arkts.FunctionExpression.create, - updateFunctionExpression: compose(arkts.FunctionExpression.create), - - createMethodDefinition: arkts.MethodDefinition.create, - updateMethodDefinition: compose(arkts.MethodDefinition.create), - - createSuperExpression: arkts.SuperExpression.create, - updateSuperExpression: compose(arkts.SuperExpression.create), - - createTSTypeParameterInstantiation: arkts.TSTypeParameterInstantiation.create, - updateTSTypeParameterInstantiation: compose(arkts.TSTypeParameterInstantiation.create), - - createInterfaceDeclaration: arkts.TSInterfaceDeclaration.create, - updateInterfaceDeclaration: compose(arkts.TSInterfaceDeclaration.create), + get createIdentifier() { + return Identifier.create + }, + get updateIdentifier() { + return compose(Identifier.create) + }, + get createCallExpression() { + return CallExpression.create + }, + get updateCallExpression() { + return compose(CallExpression.create) + }, + get createExpressionStatement() { + return ExpressionStatement.create + }, + get updateExpressionStatement() { + return compose(ExpressionStatement.create) + }, + get createMemberExpression() { + return MemberExpression.create + }, + get updateMemberExpression() { + return compose(MemberExpression.create) + }, + get createEtsScript() { + return EtsScript.createFromSource + }, + get updateEtsScript() { + return EtsScript.updateByStatements + }, + get createFunctionDeclaration() { + return FunctionDeclaration.create + }, + get updateFunctionDeclaration() { + return compose(FunctionDeclaration.create) + }, + get createBlock() { + return BlockStatement.create + }, + get updateBlock() { + return compose(BlockStatement.create) + }, + get createArrowFunction() { + return ArrowFunctionExpression.create + }, + get updateArrowFunction() { + return compose(ArrowFunctionExpression.create) + }, + get createScriptFunction() { + return ScriptFunction.create + }, + get updateScriptFunction() { + return compose(ScriptFunction.create) + }, + get createStringLiteral() { + return StringLiteral.create + }, + get updateStringLiteral() { + return compose(StringLiteral.create) + }, + get createNumericLiteral() { + return NumberLiteral.create + }, + get updateNumericLiteral() { + return compose(NumberLiteral.create) + }, + get createParameterDeclaration() { + return ETSParameterExpression.create + }, + get updateParameterDeclaration() { + return compose(ETSParameterExpression.create) + }, + get createTypeParameter() { + return TSTypeParameter.create + }, + get updateTypeParameter() { + return compose(TSTypeParameter.create) + }, + get createTypeParameterDeclaration() { + return TSTypeParameterDeclaration.create + }, + get updateTypeParameterDeclaration() { + return compose(TSTypeParameterDeclaration.create) + }, + get createPrimitiveType() { + return ETSPrimitiveType.create + }, + get updatePrimitiveType() { + return compose(ETSPrimitiveType.create) + }, + get createTypeReference() { + return ETSTypeReference.create + }, + get updateTypeReference() { + return compose(ETSTypeReference.create) + }, + get createTypeReferenceFromId() { + return ETSTypeReference.createFromId + }, + get updateTypeReferenceFromId() { + return compose(ETSTypeReference.createFromId) + }, + get createTypeReferencePart() { + return ETSTypeReferencePart.create + }, + get updateTypeReferencePart() { + return compose(ETSTypeReferencePart.create) + }, + get createImportDeclaration() { + return EtsImportDeclaration.create + }, + get updateImportDeclaration() { + return compose(EtsImportDeclaration.create) + }, + get createImportSpecifier() { + return ImportSpecifier.create + }, + get updateImportSpecifier() { + return compose(ImportSpecifier.create) + }, + +// create ImportSource: ImportSource.create, +// update ImportSource: compose(ImportSource.create), + + get createVariableDeclaration() { + return VariableDeclaration.create + }, + get updateVariableDeclaration() { + return compose(VariableDeclaration.create) + }, + get createVariableDeclarator() { + return VariableDeclarator.create + }, + get updateVariableDeclarator() { + return compose(VariableDeclarator.create) + }, + get createUnionType() { + return ETSUnionType.create + }, + get updateUnionType() { + return compose(ETSUnionType.create) + }, + get createReturnStatement() { + return ReturnStatement.create + }, + get updateReturnStatement() { + return compose(ReturnStatement.create) + }, + get createIfStatement() { + return IfStatement.create + }, + get updateIfStatement() { + return compose(IfStatement.create) + }, + get createBinaryExpression() { + return BinaryExpression.create + }, + get updateBinaryExpression() { + return compose(BinaryExpression.create) + }, + get createClassDeclaration() { + return ClassDeclaration.create + }, + get updateClassDeclaration() { + return compose(ClassDeclaration.create) + }, + get createStructDeclaration() { + return StructDeclaration.create + }, + get updateStructDeclaration() { + return compose(StructDeclaration.create) + }, + get createClassDefinition() { + return ClassDefinition.create + }, + get updateClassDefinition() { + return compose(ClassDefinition.create) + }, + get createFunctionType() { + return ETSFunctionType.create + }, + get updateFunctionType() { + return compose(ETSFunctionType.create) + }, + get createFunctionExpression() { + return FunctionExpression.create + }, + get updateFunctionExpression() { + return compose(FunctionExpression.create) + }, + get createMethodDefinition() { + return MethodDefinition.create + }, + get updateMethodDefinition() { + return compose(MethodDefinition.create) + }, + get createSuperExpression() { + return SuperExpression.create + }, + get updateSuperExpression() { + return compose(SuperExpression.create) + }, + get createTSTypeParameterInstantiation() { + return TSTypeParameterInstantiation.create + }, + get updateTSTypeParameterInstantiation() { + return compose(TSTypeParameterInstantiation.create) + }, + get createInterfaceDeclaration() { + return TSInterfaceDeclaration.create + }, + get updateInterfaceDeclaration() { + return compose(TSInterfaceDeclaration.create) + }, } diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts index 658cac2866febadf3c8f5eadd57efe2af7eb7d4f..07750fe2ffb1e9e3c7d35614b9f4485866415eaf 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts @@ -1,87 +1,88 @@ -import { MemberExpression } from "../to-be-generated/MemberExpression" import { - Node, - Identifier, + ArrowFunctionExpression, + BlockStatement, CallExpression, - FunctionDeclaration, - MethodDefinition, + ClassDeclaration, + ClassDefinition, + ETSParameterExpression, EtsScript, ExpressionStatement, - ArrowFunctionExpression, - ClassDeclaration, BlockStatement, + FunctionDeclaration, FunctionExpression, - ETSParameterExpression, - VariableDeclaration, + Identifier, + MethodDefinition, ScriptFunction, StringLiteral, - ClassDefinition, StructDeclaration, + VariableDeclaration, } from "../types" +import { MemberExpression } from "../to-be-generated/MemberExpression" +import { AstNode } from "../peers/AstNode" -export function isIdentifier(node: Node): node is Identifier { +export function isIdentifier(node: AstNode): node is Identifier { return node instanceof Identifier } -export function isCallExpression(node: Node): node is CallExpression { +export function isCallExpression(node: AstNode): node is CallExpression { return node instanceof CallExpression } -export function isMemberExpression(node: Node): node is MemberExpression { +export function isMemberExpression(node: AstNode): node is MemberExpression { return node instanceof MemberExpression } -export function isFunctionDeclaration(node: Node): node is FunctionDeclaration { +export function isFunctionDeclaration(node: AstNode): node is FunctionDeclaration { return node instanceof FunctionDeclaration } -export function isMethodDefinition(node: Node): node is MethodDefinition { +export function isMethodDefinition(node: AstNode): node is MethodDefinition { return node instanceof MethodDefinition } -export function isEtsScript(node: Node): node is EtsScript { +export function isEtsScript(node: AstNode): node is EtsScript { return node instanceof EtsScript } -export function isExpressionStatement(node: Node): node is ExpressionStatement { +export function isExpressionStatement(node: AstNode): node is ExpressionStatement { return node instanceof ExpressionStatement } -export function isArrowFunctionExpression(node: Node): node is ArrowFunctionExpression { +export function isArrowFunctionExpression(node: AstNode): node is ArrowFunctionExpression { return node instanceof ArrowFunctionExpression } -export function isClassDeclaration(node: Node): node is ClassDeclaration { +export function isClassDeclaration(node: AstNode): node is ClassDeclaration { return node instanceof ClassDeclaration } -export function isStructDeclaration(node: Node): node is StructDeclaration { +export function isStructDeclaration(node: AstNode): node is StructDeclaration { return node instanceof StructDeclaration } -export function isBlockStatement(node: Node): node is BlockStatement { +export function isBlockStatement(node: AstNode): node is BlockStatement { return node instanceof BlockStatement } -export function isFunctionExpression(node: Node): node is FunctionExpression { +export function isFunctionExpression(node: AstNode): node is FunctionExpression { return node instanceof FunctionExpression } -export function isEtsParameterExpression(node: Node): node is ETSParameterExpression { +export function isEtsParameterExpression(node: AstNode): node is ETSParameterExpression { return node instanceof ETSParameterExpression } -export function isVariableDeclaration(node: Node): node is VariableDeclaration { +export function isVariableDeclaration(node: AstNode): node is VariableDeclaration { return node instanceof VariableDeclaration } -export function isScriptFunction(node: Node): node is ScriptFunction { +export function isScriptFunction(node: AstNode): node is ScriptFunction { return node instanceof ScriptFunction } -export function isStringLiteral(node: Node): node is StringLiteral { +export function isStringLiteral(node: AstNode): node is StringLiteral { return node instanceof StringLiteral } -export function isClassDefinition(node: Node): node is ClassDefinition { +export function isClassDefinition(node: AstNode): node is ClassDefinition { return node instanceof ClassDefinition } diff --git a/arkoala-arkts/libarkts/src/arkts-api/index.ts b/arkoala-arkts/libarkts/src/arkts-api/index.ts index d6fa621d0d2aba361d4f4f7637ba21b8edb5f8ee..8e444fc04a7647378c791a084ade7cc4ec62d1b7 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/index.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/index.ts @@ -22,4 +22,7 @@ export * from "./utilities/public" export * from "./factory/nodeFactory" export * from "./factory/nodeTests" export * from "./visitor" +export * from "./peers/AstNode" +export * from "./peers/Config" +export * from "./peers/Context" export * from "./to-be-generated/MemberExpression" diff --git a/arkoala-arkts/libarkts/src/arkts-api/peers/ArktsObject.ts b/arkoala-arkts/libarkts/src/arkts-api/peers/ArktsObject.ts new file mode 100644 index 0000000000000000000000000000000000000000..b748966d955510db09cf26556b2d215b3201bcfe --- /dev/null +++ b/arkoala-arkts/libarkts/src/arkts-api/peers/ArktsObject.ts @@ -0,0 +1,24 @@ +/* + * 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 { KNativePointer } from "@koalaui/interop" + +export abstract class ArktsObject { + protected constructor(peer: KNativePointer) { + this.peer = peer + } + + readonly peer: KNativePointer +} diff --git a/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts b/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts new file mode 100644 index 0000000000000000000000000000000000000000..99ff70be6d70553c000a7513dcd44c680ecd5a7b --- /dev/null +++ b/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts @@ -0,0 +1,120 @@ +/* + * 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 { KNativePointer } from "@idlizer/arkgen/tests/mini_skoala/build/utils" +import { global } from "../static/global" +import { Es2pandaAstNodeType } from "../../Es2pandaEnums" +import { unpackNodeArray, unpackNonNullableNode, unpackString } from "../utilities/private" +import { throwError } from "../../utils" +import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums" +import { allFlags } from "../types" +import { KInt } from "@koalaui/interop" +import { isNullPtr, nullptr } from "@koalaui/interop" +import { ArktsObject } from "./ArktsObject" + +export abstract class AstNode extends ArktsObject { + protected constructor(peer: KNativePointer) { + if (isNullPtr(peer)) { + throw new Error('trying to create new Node on NULLPTR') + } + super(peer) + this.type = global.generatedEs2panda._AstNodeTypeConst(global.context, this.peer) + this.updateChildren() + } + + readonly type: Es2pandaAstNodeType + + public get originalPeer(): KNativePointer { + return global.generatedEs2panda._AstNodeOriginalNodeConst(global.context, this.peer) + } + + public set originalPeer(peer: KNativePointer) { + global.generatedEs2panda._AstNodeSetOriginalNode(global.context, this.peer, peer) + } + + public getChildren(): readonly AstNode[] { + return unpackNodeArray(global.es2panda._AstNodeChildren(global.context, this.peer)) + } + + public getSubtree(): readonly AstNode[] { + return this.getChildren().reduce( + (prev: readonly AstNode[], curr: AstNode): readonly AstNode[] => { + return prev.concat(curr.getSubtree()) + }, + [this] + ) + } + + public updateChildren(): void { + if (this.peer === nullptr) { + throwError('updateChildren called on NULLPTR') + } + global.es2panda._AstNodeUpdateChildren(global.context, this.peer) + } + + public updateModifiers(modifierFlags: KInt | undefined): this { + global.generatedEs2panda._AstNodeClearModifier(global.context, this.peer, allFlags) + global.generatedEs2panda._AstNodeAddModifier(global.context, this.peer, modifierFlags ?? Es2pandaModifierFlags.MODIFIER_FLAGS_NONE) + return this + } + + public dump(indentation: number = 0): string { + const children = this.getChildren() + .map((it) => it.dump(indentation + 1)) + const msg = + `${indentation}_` + + Es2pandaAstNodeType[this.type] + + ` ` + + this.dumpMessage() + return "> " + " ".repeat(4 * indentation) + msg + "\n" + children.join("") + } + + protected dumpMessage(): string { + return `` + } + + public dumpJson(): string { + return unpackString(global.generatedEs2panda._AstNodeDumpJSONConst(global.context, this.peer)) + } + + public dumpSrc(): string { + return unpackString(global.generatedEs2panda._AstNodeDumpEtsSrcConst(global.context, this.peer)) + } + + public dumpModifiers(): string { + return unpackString(global.es2panda._AstNodeDumpModifiers(global.context, this.peer)) + } + + public get parent(): AstNode { + const _parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer) + if (_parent === nullptr) { + throwError('BAD ACCESS: PARENT IS NULLPTR') + } + return unpackNonNullableNode(_parent) + } + + public set parent(node: AstNode) { + global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node.peer) + } + + public get modifiers(): KInt { + return global.generatedEs2panda._AstNodeModifiers(global.context, this.peer) + } + + public set modifiers(flags: KInt | undefined) { + global.generatedEs2panda._AstNodeClearModifier(global.context, this.peer, allFlags) + global.generatedEs2panda._AstNodeAddModifier(global.context, this.peer, flags ?? Es2pandaModifierFlags.MODIFIER_FLAGS_NONE) + } +} diff --git a/arkoala-arkts/libarkts/src/arkts-api/peers/Config.ts b/arkoala-arkts/libarkts/src/arkts-api/peers/Config.ts new file mode 100644 index 0000000000000000000000000000000000000000..ca7984740d88ddc1fbf29dc412c51b59db758852 --- /dev/null +++ b/arkoala-arkts/libarkts/src/arkts-api/peers/Config.ts @@ -0,0 +1,52 @@ +/* + * 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 { ArktsObject } from "./ArktsObject" +import { global } from "../static/global" +import { passStringArray } from "../utilities/private" +import { KNativePointer } from "@koalaui/interop" + +export class Config extends ArktsObject { + constructor(peer: KNativePointer) { + super(peer) + // TODO: wait for getter from api + this.path = `` + } + + static create( + input: readonly string[] + ): Config { + return new Config( + global.es2panda._CreateConfig(input.length, passStringArray(input)) + ) + } + + static createDefault(): Config { + if (global.configIsInitialized()) { + console.warn(`Config already initialized`) + return new Config( + global.config + ) + } + return new Config( + global.es2panda._CreateConfig( + 4, + passStringArray(["", "--arktsconfig", "./arktsconfig.json", global.filePath]) + ) + ) + } + + readonly path: string +} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts b/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts new file mode 100644 index 0000000000000000000000000000000000000000..07fede2a8f024ee5ecad4c826e688476c4dc2ba2 --- /dev/null +++ b/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts @@ -0,0 +1,44 @@ +/* + * 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 { ArktsObject } from "./ArktsObject" +import { global } from "../static/global" +import { throwError } from "../../utils" +import { passString } from "../utilities/private" +import { KNativePointer } from "@koalaui/interop" + +export class Context extends ArktsObject { + constructor(peer: KNativePointer) { + super(peer) + } + + // TODO: + // static create + + static createFromString( + source: string + ): Context { + if (!global.configIsInitialized()) { + throwError(`Config not initialized`) + } + return new Context( + global.es2panda._CreateContextFromString( + global.config, + passString(source), + passString(global.filePath) + ) + ) + } +} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/static/global.ts b/arkoala-arkts/libarkts/src/arkts-api/static/global.ts index 963bde426f2c8ca468698ca46471bc95f309a825..97d82523d6fe7a32dc6944f6e953452eedfd803f 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/static/global.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/static/global.ts @@ -19,7 +19,7 @@ import { initEs2panda, Es2pandaNativeModule, initGeneratedEs2panda } from "../.. import { Es2pandaNativeModule as GeneratedEs2pandaNativeModule } from "../../generated/Es2pandaNativeModule" import { initInterop, InteropNativeModule } from "../../InteropNativeModule" -export default class global { +export class global { public static filePath: string = "./plugins/input/main.sts" private static _config?: KNativePointer diff --git a/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts b/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts index a264572bbaba594e81eca256d7892a869c410a7a..790405568ed25d9f921e999fb9b5d3100a96e783 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts @@ -1,19 +1,35 @@ -import { KNativePointer as KPtr } from "@koalaui/interop" -import { Es2pandaAstNodeType } from "../../Es2pandaEnums" -import { assertValidPeer, Node } from "../types" -import { passNode, unpackNonNullableNode } from "../utilities/private" -import global from "../static/global" +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { global } from "../static/global" +import { assertValidPeer } from "../types" import { Es2pandaMemberExpressionKind } from "../../generated/Es2pandaEnums" +import { passNode, unpackNonNullableNode } from "../utilities/private" +import { KNativePointer } from "@koalaui/interop" +import { Es2pandaAstNodeType } from "../../Es2pandaEnums" +import { AstNode } from "../peers/AstNode" -export class MemberExpression extends Node { - constructor(peer: KPtr) { +export class MemberExpression extends AstNode { + constructor(peer: KNativePointer) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION) super(peer) } static create( - object: Node, - property: Node, + object: AstNode, + property: AstNode, kind: Es2pandaMemberExpressionKind, computed: boolean, optional: boolean @@ -34,12 +50,14 @@ export class MemberExpression extends Node { return ` ` } - get object(): Node { + get object(): AstNode { return unpackNonNullableNode(global.generatedEs2panda._MemberExpressionObject(global.context, this.peer)) } - get property(): Node { + + get property(): AstNode { return unpackNonNullableNode(global.generatedEs2panda._MemberExpressionProperty(global.context, this.peer)) } + get kind(): Es2pandaMemberExpressionKind { return global.generatedEs2panda._MemberExpressionKindConst(global.context, this.peer) } diff --git a/arkoala-arkts/libarkts/src/arkts-api/types.ts b/arkoala-arkts/libarkts/src/arkts-api/types.ts index 1af2373d750553f245e4284dc986e33bf33698f3..a9bf80f46e63fa2f2755bc2a57f484af28ed97c7 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/types.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/types.ts @@ -13,41 +13,39 @@ * limitations under the License. */ -import global from "./static/global" +import { global } from "./static/global" import { throwError } from "../utils" - -import { KBoolean, KInt, KNativePointer as KPtr, isNullPtr, nullptr } from "@koalaui/interop" +import { KBoolean, KInt, KNativePointer as KPtr, nullptr } from "@koalaui/interop" import { - Es2pandaPrimitiveType, + Es2pandaContextState, + Es2pandaIdentifierFlags, + Es2pandaImportKinds, + Es2pandaMethodDefinitionKind, Es2pandaModifierFlags, + Es2pandaPrimitiveType, Es2pandaScriptFunctionFlags, - Es2pandaAstNodeType, - Es2pandaContextState, Es2pandaTokenType, - Es2pandaMethodDefinitionKind, Es2pandaVariableDeclarationKind, Es2pandaVariableDeclaratorFlag, - Es2pandaImportKinds, - Es2pandaMemberExpressionKind, - Es2pandaIdentifierFlags, -} from "." +} from "../generated/Es2pandaEnums" import { - unpackNonNullableNode, - unpackNode, passNode, - unpackNodeArray, passNodeArray, passString, + resolveSource, + unpackNode, + unpackNodeArray, + unpackNonNullableNode, unpackString, - passStringArray, updatePeerByNode, - resolveSource, } from "./utilities/private" -import { - proceedToState, -} from "./utilities/public" +import { proceedToState } from "./utilities/public" +import { Es2pandaAstNodeType } from "../Es2pandaEnums" +import { AstNode } from "./peers/AstNode" +import { ArktsObject } from "./peers/ArktsObject" +import { Config } from "./peers/Config" +import { Context } from "./peers/Context" -export { nullptr } export const arrayOfNullptr = new BigUint64Array([nullptr]) export const allFlags: KInt = @@ -68,174 +66,14 @@ export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): } } -export abstract class ArktsObject { - protected constructor(peer: KPtr) { - this.peer = peer - } - - readonly peer: KPtr -} - -export abstract class Node extends ArktsObject { - protected constructor(peer: KPtr) { - if (isNullPtr(peer)) { - throw new Error('trying to create new Node on NULLPTR') - } - super(peer) - this.type = global.generatedEs2panda._AstNodeTypeConst(global.context, this.peer) - this.updateChildren() - } - - readonly type: Es2pandaAstNodeType - - public get originalPeer(): KPtr { - return global.generatedEs2panda._AstNodeOriginalNodeConst(global.context, this.peer) - } - - public set originalPeer(peer: KPtr) { - global.generatedEs2panda._AstNodeSetOriginalNode(global.context, this.peer, peer) - } - - public getChildren(): readonly Node[] { - return unpackNodeArray(global.es2panda._AstNodeChildren(global.context, this.peer)) - } - - public getSubtree(): readonly Node[] { - return this.getChildren().reduce( - (prev: readonly Node[], curr: Node): readonly Node[] => { - return prev.concat(curr.getSubtree()) - }, - [this] - ) - } - - public updateChildren(): void { - if (this.peer === nullptr) { - throwError('updateChildren called on NULLPTR') - } - global.es2panda._AstNodeUpdateChildren(global.context, this.peer) - } - - public updateModifiers(modifierFlags: KInt | undefined): this { - global.generatedEs2panda._AstNodeClearModifier(global.context, this.peer, allFlags) - global.generatedEs2panda._AstNodeAddModifier(global.context, this.peer, modifierFlags ?? Es2pandaModifierFlags.MODIFIER_FLAGS_NONE) - return this - } - - public dump(indentation: number = 0): string { - const children = this.getChildren() - .map((it) => it.dump(indentation + 1)) - const msg = - `${indentation}_` - + Es2pandaAstNodeType[this.type] - + ` ` - + this.dumpMessage() - return "> " + " ".repeat(4 * indentation) + msg + "\n" + children.join("") - } - - protected dumpMessage(): string { - return `` - } - - public dumpJson(): string { - return unpackString(global.generatedEs2panda._AstNodeDumpJSONConst(global.context, this.peer)) - } - - public dumpSrc(): string { - return unpackString(global.generatedEs2panda._AstNodeDumpEtsSrcConst(global.context, this.peer)) - } - - public dumpModifiers(): string { - return unpackString(global.es2panda._AstNodeDumpModifiers(global.context, this.peer)) - } - - public get parent(): Node { - const _parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer) - if (_parent === nullptr) { - throwError('BAD ACCESS: PARENT IS NULLPTR') - } - return unpackNonNullableNode(_parent) - } - - public set parent(node: Node) { - global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node.peer) - } - - public get modifiers(): KInt { - return global.generatedEs2panda._AstNodeModifiers(global.context, this.peer) - } - - public set modifiers(flags: KInt | undefined) { - global.generatedEs2panda._AstNodeClearModifier(global.context, this.peer, allFlags) - global.generatedEs2panda._AstNodeAddModifier(global.context, this.peer, flags ?? Es2pandaModifierFlags.MODIFIER_FLAGS_NONE) - } -} - -export class UnsupportedNode extends Node { +export class UnsupportedNode extends AstNode { constructor(peer: KPtr) { super(peer) console.log(`WARNING: UNSUPPORTED NODE (arkts): ${Es2pandaAstNodeType[this.type]}`) } } -export class Config extends ArktsObject { - constructor(peer: KPtr) { - super(peer) - // TODO: wait for getter from api - this.path = `` - } - - static create( - input: readonly string[] - ): Config { - return new Config( - global.es2panda._CreateConfig(input.length, passStringArray(input)) - ) - } - - static createDefault(): Config { - if (global.configIsInitialized()) { - console.warn(`Config already initialized`) - return new Config( - global.config - ) - } - return new Config( - global.es2panda._CreateConfig( - 4, - passStringArray(["", "--arktsconfig", "./arktsconfig.json", global.filePath]) - ) - ) - } - - readonly path: string -} - -export class Context extends ArktsObject { - constructor(peer: KPtr) { - super(peer) - } - - // TODO: - // static create - - static createFromString( - source: string - ): Context { - if (!global.configIsInitialized()) { - throwError(`Config not initialized`) - } - return new Context( - global.es2panda._CreateContextFromString( - global.config, - passString(source), - passString(global.filePath) - ) - ) - } -} - -export class EtsScript extends Node { +export class EtsScript extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) super(peer) @@ -271,22 +109,22 @@ export class EtsScript extends Node { */ static updateByStatements( node: EtsScript, - statements: readonly Node[], + statements: readonly AstNode[], ): EtsScript { global.generatedEs2panda._BlockStatementSetStatements(global.context, node.peer, passNodeArray(statements), statements.length) return node } - get statements(): readonly Node[] { + get statements(): readonly AstNode[] { return unpackNodeArray(global.generatedEs2panda._BlockStatementStatements(global.context, this.peer)) } - set statements(nodes: readonly Node[]) { + set statements(nodes: readonly AstNode[]) { global.generatedEs2panda._BlockStatementSetStatements(global.context, this.peer, passNodeArray(nodes), nodes.length) } } -export class ExpressionStatement extends Node { +export class ExpressionStatement extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT) super(peer) @@ -294,7 +132,7 @@ export class ExpressionStatement extends Node { } static create( - expression: Node, + expression: AstNode, ): ExpressionStatement { return new ExpressionStatement( global.generatedEs2panda._CreateExpressionStatement( @@ -304,10 +142,10 @@ export class ExpressionStatement extends Node { ) } - readonly expression: Node + readonly expression: AstNode } -export class CallExpression extends Node { +export class CallExpression extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION) super(peer) @@ -316,9 +154,9 @@ export class CallExpression extends Node { } static create( - expression: Node, + expression: AstNode, typeParamsDecl: TSTypeParameterDeclaration | undefined, - args: readonly Node[] | undefined + args: readonly AstNode[] | undefined ): CallExpression { return new CallExpression( global.generatedEs2panda._CreateCallExpression( @@ -333,20 +171,20 @@ export class CallExpression extends Node { ) } - readonly expression: Node // Expression - readonly arguments: readonly Node[] + readonly expression: AstNode // Expression + readonly arguments: readonly AstNode[] } -export class AssignmentExpression extends Node { +export class AssignmentExpression extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION) super(peer) } static create( - left: Node, + left: AstNode, assignmentOperator: Es2pandaTokenType, - right: Node + right: AstNode ): AssignmentExpression { return new AssignmentExpression( global.generatedEs2panda._CreateAssignmentExpression( @@ -359,16 +197,16 @@ export class AssignmentExpression extends Node { } } -export class BinaryExpression extends Node { +export class BinaryExpression extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION) super(peer) } static create( - left: Node, + left: AstNode, operatorType: Es2pandaTokenType, - right: Node + right: AstNode ): BinaryExpression { return new BinaryExpression( global.generatedEs2panda._CreateBinaryExpression( @@ -381,7 +219,7 @@ export class BinaryExpression extends Node { } } -export class ETSPrimitiveType extends Node { +export class ETSPrimitiveType extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE) super(peer) @@ -406,7 +244,7 @@ export class ETSPrimitiveType extends Node { readonly primitiveType: Es2pandaPrimitiveType } -export class ETSTypeReference extends Node { +export class ETSTypeReference extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE) super(peer) @@ -439,7 +277,7 @@ export class ETSTypeReference extends Node { // readonly typeRefPart: TypeReferencePart } -export class ETSTypeReferencePart extends Node { +export class ETSTypeReferencePart extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART) super(peer) @@ -448,7 +286,7 @@ export class ETSTypeReferencePart extends Node { // TODO: support type params and prev static create( typeName: Identifier, - typeParamsDecl?: Node, + typeParamsDecl?: AstNode, ) { // typeName.setReference(true) // TODO: support type params and prev @@ -465,7 +303,7 @@ export class ETSTypeReferencePart extends Node { // readonly typeName: Identifier } -export class TSUnionType extends Node { +export class TSUnionType extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE) super(peer) @@ -474,7 +312,7 @@ export class TSUnionType extends Node { static create( node: undefined | TSUnionType, - types: Node[], + types: AstNode[], ): TSUnionType { return new TSUnionType( updatePeerByNode( @@ -488,10 +326,10 @@ export class TSUnionType extends Node { ) } - readonly types: readonly Node[] + readonly types: readonly AstNode[] } -export class ETSUnionType extends Node { +export class ETSUnionType extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE) super(peer) @@ -499,7 +337,7 @@ export class ETSUnionType extends Node { } static create( - types: Node[], + types: AstNode[], ): ETSUnionType { return new ETSUnionType( global.es2panda._CreateETSUnionTypeIr( @@ -510,10 +348,10 @@ export class ETSUnionType extends Node { ) } - readonly types: readonly Node[] + readonly types: readonly AstNode[] } -export class ETSFunctionType extends Node { +export class ETSFunctionType extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE) super(peer) @@ -533,7 +371,7 @@ export class ETSFunctionType extends Node { } } -export class Identifier extends Node { +export class Identifier extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER) super(peer) @@ -541,7 +379,7 @@ export class Identifier extends Node { static create( name: string, - typeAnnotation?: Node + typeAnnotation?: AstNode ): Identifier { if (typeAnnotation === undefined) { return new Identifier( @@ -575,7 +413,7 @@ export class Identifier extends Node { } } -export class StringLiteral extends Node { +export class StringLiteral extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL) super(peer) @@ -600,7 +438,7 @@ export class StringLiteral extends Node { readonly str: string } -export class NumberLiteral extends Node { +export class NumberLiteral extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL) super(peer) @@ -639,8 +477,8 @@ export class FunctionSignature extends ArktsObject { static create( typeParamsDecl: TSTypeParameterDeclaration | undefined, - params: readonly Node[], - returnTypeAnnotation: Node | undefined, + params: readonly AstNode[], + returnTypeAnnotation: AstNode | undefined, ): FunctionSignature { return new FunctionSignature( global.es2panda._CreateFunctionSignature( @@ -655,11 +493,11 @@ export class FunctionSignature extends ArktsObject { } // readonly typeParamsDecl?: TSTypeParameterDeclaration - // readonly parameters: readonly Node[] - // readonly returnTypeAnnotation?: Node + // readonly parameters: readonly AstNode[] + // readonly returnTypeAnnotation?: AstNode } -export class ScriptFunction extends Node { +export class ScriptFunction extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION) super(peer) @@ -674,7 +512,7 @@ export class ScriptFunction extends Node { } static create( - body: Node | undefined, + body: AstNode | undefined, signature: FunctionSignature, functionFlags: Es2pandaScriptFunctionFlags, modifierFlags: Es2pandaModifierFlags, @@ -719,7 +557,7 @@ export class ScriptFunction extends Node { let hasReturn: boolean = false // TODO: goes through whole subtree, optimizable (unnecessary now) this.body.getSubtree().forEach( - (node: Node) => { + (node: AstNode) => { hasReturn = hasReturn || (node.type === Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT) } ) @@ -738,7 +576,7 @@ export class ScriptFunction extends Node { readonly ident?: Identifier } -export class ArrowFunctionExpression extends Node { +export class ArrowFunctionExpression extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION) super(peer) @@ -759,7 +597,7 @@ export class ArrowFunctionExpression extends Node { readonly scriptFunction: ScriptFunction } -export class FunctionDeclaration extends Node { +export class FunctionDeclaration extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION) super(peer) @@ -792,15 +630,15 @@ export class FunctionDeclaration extends Node { } readonly scriptFunction: ScriptFunction - readonly parameters: readonly Node[] + readonly parameters: readonly AstNode[] readonly name?: Identifier readonly body?: BlockStatement readonly typeParamsDecl?: TSTypeParameterDeclaration - readonly returnType?: Node + readonly returnType?: AstNode readonly isAnon: boolean } -export class FunctionExpression extends Node { +export class FunctionExpression extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION) super(peer) @@ -821,7 +659,7 @@ export class FunctionExpression extends Node { readonly scriptFunction: ScriptFunction } -export class BlockStatement extends Node { +export class BlockStatement extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT) super(peer) @@ -829,7 +667,7 @@ export class BlockStatement extends Node { } static create( - statements: readonly Node[], + statements: readonly AstNode[], ): BlockStatement { return new BlockStatement( global.generatedEs2panda._CreateBlockStatement( @@ -840,10 +678,10 @@ export class BlockStatement extends Node { ) } - readonly statements: readonly Node[] + readonly statements: readonly AstNode[] } -export class ETSParameterExpression extends Node { +export class ETSParameterExpression extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION) super(peer) @@ -851,7 +689,7 @@ export class ETSParameterExpression extends Node { static create( identifier: Identifier, - initializer: Node | undefined + initializer: AstNode | undefined ): ETSParameterExpression { return new ETSParameterExpression( global.generatedEs2panda._CreateETSParameterExpression( @@ -863,7 +701,7 @@ export class ETSParameterExpression extends Node { } } -export class TSTypeParameterDeclaration extends Node { +export class TSTypeParameterDeclaration extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION) super(peer) @@ -872,7 +710,7 @@ export class TSTypeParameterDeclaration extends Node { // TODO: think about valid type of parameters static create( - parameters: Node[], + parameters: AstNode[], ): TSTypeParameterDeclaration { return new TSTypeParameterDeclaration( global.generatedEs2panda._CreateTSTypeParameterDeclaration( @@ -888,7 +726,7 @@ export class TSTypeParameterDeclaration extends Node { readonly parameters: readonly TSTypeParameter[] } -export class TSTypeParameter extends Node { +export class TSTypeParameter extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER) super(peer) @@ -897,8 +735,8 @@ export class TSTypeParameter extends Node { static create( name: Identifier, - constraint: Node | undefined, - defaultType: Node | undefined, + constraint: AstNode | undefined, + defaultType: AstNode | undefined, modifierFlags: KInt, ): TSTypeParameter { const peer = global.generatedEs2panda._CreateTSTypeParameter( @@ -917,7 +755,7 @@ export class TSTypeParameter extends Node { readonly name: Identifier } -export class ReturnStatement extends Node { +export class ReturnStatement extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT) super(peer) @@ -927,7 +765,7 @@ export class ReturnStatement extends Node { } static create( - argument: Node, + argument: AstNode, ): ReturnStatement { return new ReturnStatement( global.es2panda._CreateReturnStatement1( @@ -937,19 +775,19 @@ export class ReturnStatement extends Node { ) } - readonly argument: Node | undefined + readonly argument: AstNode | undefined } -export class IfStatement extends Node { +export class IfStatement extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT) super(peer) } static create( - test: Node, - consequent: Node, - alternate?: Node + test: AstNode, + consequent: AstNode, + alternate?: AstNode ): IfStatement { return new IfStatement( global.generatedEs2panda._CreateIfStatement( @@ -962,7 +800,7 @@ export class IfStatement extends Node { } } -export class StructDeclaration extends Node { +export class StructDeclaration extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION) super(peer) @@ -985,7 +823,7 @@ export class StructDeclaration extends Node { } -export class ClassDeclaration extends Node { +export class ClassDeclaration extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION) super(peer) @@ -1006,7 +844,7 @@ export class ClassDeclaration extends Node { readonly definition: ClassDefinition } -export class ClassDefinition extends Node { +export class ClassDefinition extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION) super(peer) @@ -1018,11 +856,11 @@ export class ClassDefinition extends Node { static create( name: Identifier | undefined, - members: readonly Node[], + members: readonly AstNode[], modifiers: KInt, classFlags: KInt, typeParamsDecl: TSTypeParameterDeclaration | undefined, - superClass?: Node, + superClass?: AstNode, ): ClassDefinition { const peer = global.es2panda._CreateClassDefinition1( global.context, @@ -1040,12 +878,12 @@ export class ClassDefinition extends Node { } readonly name: Identifier - readonly members: readonly Node[] + readonly members: readonly AstNode[] readonly typeParamsDecl?: TSTypeParameterDeclaration - readonly superClass?: Node + readonly superClass?: AstNode } -export class ClassStaticBlock extends Node { +export class ClassStaticBlock extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK) super(peer) @@ -1053,7 +891,7 @@ export class ClassStaticBlock extends Node { // TODO: // static create( - // value: Node + // value: AstNode // ): ClassStaticBlock { // return new ClassStaticBlock( // nativeModule._CreateClassStaticBlock( @@ -1064,7 +902,7 @@ export class ClassStaticBlock extends Node { // } } -export class MethodDefinition extends Node { +export class MethodDefinition extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION) super(peer) @@ -1074,8 +912,8 @@ export class MethodDefinition extends Node { static create( kind: Es2pandaMethodDefinitionKind, - key: Node, - value: Node, + key: AstNode, + value: AstNode, modifiers: KInt, isComputed: boolean ): MethodDefinition { @@ -1095,15 +933,15 @@ export class MethodDefinition extends Node { readonly name: Identifier } -export class ClassElement extends Node { +export class ClassElement extends AstNode { constructor(peer: KPtr) { super(peer) this.key = unpackNonNullableNode(global.generatedEs2panda._ClassElementKey(global.context, this.peer)) this.value = unpackNode(global.generatedEs2panda._ClassElementValue(global.context, this.peer)) } - readonly key: Node - readonly value?: Node + readonly key: AstNode + readonly value?: AstNode } export class ClassProperty extends ClassElement { @@ -1113,9 +951,9 @@ export class ClassProperty extends ClassElement { } static create( - key: Node, - value: Node, - typeAnnotation: Node, + key: AstNode, + value: AstNode, + typeAnnotation: AstNode, modifiers: KInt, isComputed: boolean ): ClassProperty { @@ -1132,7 +970,7 @@ export class ClassProperty extends ClassElement { } } -export class VariableDeclaration extends Node { +export class VariableDeclaration extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION) super(peer) @@ -1160,7 +998,7 @@ export class VariableDeclaration extends Node { readonly declarators: readonly VariableDeclarator[] } -export class VariableDeclarator extends Node { +export class VariableDeclarator extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR) super(peer) @@ -1170,7 +1008,7 @@ export class VariableDeclarator extends Node { static create( flag: Es2pandaVariableDeclaratorFlag, name: Identifier, - initializer: Node | undefined + initializer: AstNode | undefined ): VariableDeclarator { const peer = global.generatedEs2panda._CreateVariableDeclarator( global.context, @@ -1186,14 +1024,14 @@ export class VariableDeclarator extends Node { readonly name: Identifier } -export class ETSUndefinedType extends Node { +export class ETSUndefinedType extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE) super(peer) } } -export class SuperExpression extends Node { +export class SuperExpression extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION) super(peer) @@ -1229,7 +1067,7 @@ export class ImportSource extends ArktsObject { } } -export class EtsImportDeclaration extends Node { +export class EtsImportDeclaration extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION) super(peer) @@ -1263,7 +1101,7 @@ export class EtsImportDeclaration extends Node { readonly hasDecl: boolean } -export class ImportSpecifier extends Node { +export class ImportSpecifier extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER) super(peer) @@ -1283,7 +1121,7 @@ export class ImportSpecifier extends Node { } } -export class AnnotationUsageIr extends Node { +export class AnnotationUsageIr extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE) super(peer) @@ -1294,18 +1132,18 @@ export class AnnotationUsageIr extends Node { // TODO: // static create - readonly expr: Node + readonly expr: AstNode readonly properties: readonly ClassProperty[] } -export class TSTypeParameterInstantiation extends Node { +export class TSTypeParameterInstantiation extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION) super(peer) } static create( - parameters: readonly Node[], + parameters: readonly AstNode[], ): TSTypeParameterInstantiation { return new TSTypeParameterInstantiation( global.generatedEs2panda._CreateTSTypeParameterInstantiation( @@ -1317,17 +1155,17 @@ export class TSTypeParameterInstantiation extends Node { } } -export class TSInterfaceDeclaration extends Node { +export class TSInterfaceDeclaration extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION) super(peer) } static create( - extendsParams: readonly Node[], - id: Node, - typeParams: Node, - body: Node, + extendsParams: readonly AstNode[], + id: AstNode, + typeParams: AstNode, + body: AstNode, isStatic: KBoolean, isExternal: KBoolean, ): TSInterfaceDeclaration { @@ -1346,7 +1184,7 @@ export class TSInterfaceDeclaration extends Node { } } -export class UndefinedLiteral extends Node { +export class UndefinedLiteral extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL) super(peer) diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/nativePtrDecoder.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/nativePtrDecoder.ts index ee70e57c5efb8e3ac56593224e2e2e139eb38d89..1bb8900b4061655b8f07498018bc631468f80296 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/nativePtrDecoder.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/nativePtrDecoder.ts @@ -24,7 +24,7 @@ import { providePlatformDefinedData, withByteArray } from "@koalaui/interop" -import global from "../static/global" +import { global } from "../static/global" class NativeString extends NativeStringBase { constructor(ptr: pointer) { diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts index aec2954fa9f68f8cecc0cba7ed66d0c4ff34225d..ea90f728200cf6841f6ac1144e7adc6c80614663 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts @@ -13,90 +13,39 @@ * limitations under the License. */ -import * as arkts from ".." -import global from "../static/global" +import { global } from "../static/global" import { throwError } from "../../utils" -import { KNativePointer, withString, withStringResult, withStringArray, KInt } from "@koalaui/interop" +import { KInt, KNativePointer, nullptr, withString, withStringArray, withStringResult } from "@koalaui/interop" import { NativePtrDecoder } from "./nativePtrDecoder" -import { - Es2pandaAstNodeType, - Es2pandaScriptFunctionFlags, -} from ".." import * as path from "node:path" - -export function classByPeer(peer: KNativePointer): arkts.Node { - const constructors = new Map([ - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, arkts.EtsScript], - [Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, arkts.Identifier], - [Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, arkts.StringLiteral], - [Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, arkts.NumberLiteral], - [Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, arkts.ExpressionStatement], - [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, arkts.FunctionDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, arkts.ScriptFunction], - [Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, arkts.BlockStatement], - [Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, arkts.ReturnStatement], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, arkts.ETSParameterExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, arkts.ETSTypeReference], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART, arkts.ETSTypeReferencePart], - [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, arkts.TSTypeParameterDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, arkts.ETSPrimitiveType], - [Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, arkts.CallExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, arkts.MemberExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, arkts.TSTypeParameter], - [Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, arkts.IfStatement], - [Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, arkts.BinaryExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, arkts.ETSUnionType], - [Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, arkts.ArrowFunctionExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION, arkts.StructDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, arkts.ClassDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, arkts.ClassDefinition], - [Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, arkts.MethodDefinition], - [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, arkts.ClassProperty], - [Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, arkts.AssignmentExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, arkts.VariableDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, arkts.VariableDeclarator], - [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION, arkts.FunctionExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, arkts.ETSFunctionType], - [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, arkts.ClassStaticBlock], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, arkts.ETSUndefinedType], - [Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL, arkts.UndefinedLiteral], - [Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, arkts.SuperExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, arkts.EtsImportDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, arkts.ImportSpecifier], - [Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, arkts.AnnotationUsageIr], - ]) - - if (peer === arkts.nullptr) { - throwError('classByPeer: peer is NULLPTR') - } - const type = global.generatedEs2panda._AstNodeTypeConst(global.context, peer) - const constructor = constructors.get(type) - return constructor !== undefined - ? new constructor(peer) - : new arkts.UnsupportedNode(peer) -} - -export function unpackNonNullableNode(peer: KNativePointer): T { - if (peer === arkts.nullptr) { +import { allFlags, StringLiteral } from "../types" +import { Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums" +import { factory } from "../factory/nodeFactory" +import { classByPeer } from "../class-by-peer" +import { AstNode } from "../peers/AstNode" +import { ArktsObject } from "../peers/ArktsObject" + +export function unpackNonNullableNode(peer: KNativePointer): T { + if (peer === nullptr) { throwError('peer is NULLPTR (maybe you should use unpackNode)') } return classByPeer(peer) as T } -export function unpackNode(peer: KNativePointer): T | undefined { - if (peer === arkts.nullptr) { +export function unpackNode(peer: KNativePointer): T | undefined { + if (peer === nullptr) { return undefined } return classByPeer(peer) as T } -export function passNode(node: arkts.Node | undefined): KNativePointer { - return node?.peer ?? arkts.nullptr +export function passNode(node: AstNode | undefined): KNativePointer { + return node?.peer ?? nullptr } // meaning unpackNonNullableNodeArray -export function unpackNodeArray(nodesPtr: KNativePointer): readonly T[] { - if (nodesPtr === arkts.nullptr) { +export function unpackNodeArray(nodesPtr: KNativePointer): readonly T[] { + if (nodesPtr === nullptr) { throwError('nodesPtr is NULLPTR (maybe you should use unpackNodeArray)') } return (new NativePtrDecoder()) @@ -104,21 +53,21 @@ export function unpackNodeArray(nodesPtr: KNativePointer): .map((peer: KNativePointer) => unpackNonNullableNode(peer)) } -export function passNodeArray(nodes: readonly arkts.Node[] | undefined): BigUint64Array { +export function passNodeArray(nodes: readonly AstNode[] | undefined): BigUint64Array { return new BigUint64Array( nodes?.map(node => BigInt(node.peer)) ?? [] ) } -export function unpackNonNullableObject(type: { new (peer: KNativePointer): T }, peer: KNativePointer): T { - if (peer === arkts.nullptr) { +export function unpackNonNullableObject(type: { new (peer: KNativePointer): T }, peer: KNativePointer): T { + if (peer === nullptr) { throwError('peer is NULLPTR (maybe you should use unpackObject)') } return new type(peer) } -export function unpackObject(type: { new (peer: KNativePointer): T }, peer: KNativePointer): T | undefined { - if (peer === arkts.nullptr) { +export function unpackObject(type: { new (peer: KNativePointer): T }, peer: KNativePointer): T | undefined { + if (peer === nullptr) { return undefined } return new type(peer) @@ -139,7 +88,7 @@ export function passStringArray(strings: readonly string[]): string[] { return withStringArray(strings, (it: string[]) => it) } -export function passNodeWithNewModifiers(node: T, modifiers: KInt): T { +export function passNodeWithNewModifiers(node: T, modifiers: KInt): T { return (unpackNonNullableNode(node.peer) as T).updateModifiers(modifiers) } @@ -151,8 +100,8 @@ export function scriptFunctionHasBody(peer: KNativePointer): boolean { // TODO: remove this // TODO: update scopes and other data -export function updatePeerByNode(peer: KNativePointer, original: T | undefined): KNativePointer { - if (peer === arkts.nullptr) { +export function updatePeerByNode(peer: KNativePointer, original: T | undefined): KNativePointer { + if (peer === nullptr) { throwError('updatePeerByNode called on NULLPTR') } if (original === undefined) { @@ -161,28 +110,28 @@ export function updatePeerByNode(peer: KNativePointer, ori global.generatedEs2panda._AstNodeSetOriginalNode(global.context, peer, original.peer) global.generatedEs2panda._AstNodeSetParent(global.context, peer, global.generatedEs2panda._AstNodeParent(global.context, original.peer)) global.es2panda._AstNodeUpdateChildren(global.context, peer) - global.generatedEs2panda._AstNodeClearModifier(global.context, peer, arkts.allFlags) + global.generatedEs2panda._AstNodeClearModifier(global.context, peer, allFlags) global.generatedEs2panda._AstNodeAddModifier(global.context, peer, original.modifiers) global.es2panda._AstNodeUpdateChildren(global.context, peer) return peer } // TODO: update scopes and other data -export function updateNodeByNode(node: T, original: arkts.Node): T { - if (original.peer === arkts.nullptr) { +export function updateNodeByNode(node: T, original: AstNode): T { + if (original.peer === nullptr) { throwError('update called on NULLPTR') } global.generatedEs2panda._AstNodeSetOriginalNode(global.context, node.peer, original.peer) global.generatedEs2panda._AstNodeSetParent(global.context, node.peer, global.generatedEs2panda._AstNodeParent(global.context, original.peer)) global.es2panda._AstNodeUpdateChildren(global.context, node.peer) - global.generatedEs2panda._AstNodeClearModifier(global.context, node.peer, arkts.allFlags) + global.generatedEs2panda._AstNodeClearModifier(global.context, node.peer, allFlags) global.generatedEs2panda._AstNodeAddModifier(global.context, node.peer, original.modifiers) global.es2panda._AstNodeUpdateChildren(global.context, node.peer) return node } -export function resolveSource(source: arkts.StringLiteral): arkts.StringLiteral { - return arkts.factory.createStringLiteral( +export function resolveSource(source: StringLiteral): StringLiteral { + return factory.createStringLiteral( path.resolve(source.str).toString() ) } diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts index d784151da89d89e611e1b74c0bb07efecf00c2b2..2d8ba52e993cc3827d29fcbbc5f3425b793e5e02 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts @@ -13,13 +13,14 @@ * limitations under the License. */ -import global from "../static/global" +import { global } from "../static/global" import { throwError } from "../../utils" -import * as arkts from "../../arkts-api" -import { KNativePointer, withString, withStringArray, withStringResult } from "@koalaui/interop" -import { - Es2pandaContextState, -} from ".." +import { KNativePointer, nullptr, withStringResult } from "@koalaui/interop" +import { AnnotationUsageIr } from "../types" +import { unpackNodeArray, unpackNonNullableNode } from "./private" +import { isClassDefinition, isFunctionDeclaration, isScriptFunction } from "../factory/nodeTests" +import { Es2pandaContextState } from "../../generated/Es2pandaEnums" +import { AstNode } from "../peers/AstNode" export function proceedToState(state: Es2pandaContextState): void { if (state <= global.es2panda._ContextState(global.context)) { @@ -44,46 +45,46 @@ export function startChecker(): boolean { return global.es2panda._CheckerStartChecker(global.context) } -export function recheckSubtree(node: arkts.Node): void { +export function recheckSubtree(node: AstNode): void { global.es2panda._AstNodeRecheck(global.context, node.peer) } -export function rebindSubtree(node: arkts.Node): void { +export function rebindSubtree(node: AstNode): void { global.es2panda._AstNodeRebind(global.context, node.peer) } -export function getDecl(node: arkts.Node): arkts.Node | undefined { +export function getDecl(node: AstNode): AstNode | undefined { let decl: KNativePointer = node.peer decl = global.es2panda._AstNodeVariableConst(global.context, decl) - if (decl === arkts.nullptr) { + if (decl === nullptr) { return undefined } decl = global.es2panda._VariableDeclaration(global.context, decl) - if (decl === arkts.nullptr) { + if (decl === nullptr) { return undefined } decl = global.es2panda._DeclNode(global.context, decl) - if (decl === arkts.nullptr) { + if (decl === nullptr) { return undefined } - return arkts.unpackNonNullableNode(decl) + return unpackNonNullableNode(decl) } -export function getAnnotations(node: arkts.Node): readonly arkts.AnnotationUsageIr[] { - if (!arkts.isFunctionDeclaration(node) && !arkts.isScriptFunction(node) && !arkts.isClassDefinition(node)) { +export function getAnnotations(node: AstNode): readonly AnnotationUsageIr[] { + if (!isFunctionDeclaration(node) && !isScriptFunction(node) && !isClassDefinition(node)) { throwError('for now annotations allowed only for: functionDeclaration, scriptFunction, classDefinition') } - return arkts.unpackNodeArray(global.es2panda._AnnotationAllowedAnnotations(global.context, node.peer, arkts.nullptr)) + return unpackNodeArray(global.es2panda._AnnotationAllowedAnnotations(global.context, node.peer, nullptr)) } -export function getOriginalNode(node: arkts.Node): arkts.Node { +export function getOriginalNode(node: AstNode): AstNode { if (node === undefined) { // TODO: fix this throwError('there is no arkts pair of ts node (unable to getOriginalNode)') } - if (node.originalPeer === arkts.nullptr) { + if (node.originalPeer === nullptr) { return node } - return arkts.unpackNonNullableNode(node.originalPeer) + return unpackNonNullableNode(node.originalPeer) } diff --git a/arkoala-arkts/libarkts/src/arkts-api/visitor.ts b/arkoala-arkts/libarkts/src/arkts-api/visitor.ts index 5d584cdfb5723cd8fd13b2f7609c5e9373c6fa51..7838dd0ddc3f8ce046f94449f00cd1bcf4987d1a 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/visitor.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/visitor.ts @@ -1,15 +1,43 @@ -import * as arkts from "./types" +/* + * Copyright (c) 2022-2023 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 { factory } from "./factory/nodeFactory" import { - Es2pandaMethodDefinitionKind, - Es2pandaModifierFlags, + BlockStatement, + CallExpression, + ClassDeclaration, + ClassDefinition, + EtsScript, + ExpressionStatement, + FunctionDeclaration, + FunctionSignature, + MethodDefinition, + StructDeclaration +} from "./types" +import { Es2pandaClassDefinitionModifiers, -} from "." + Es2pandaMethodDefinitionKind, + Es2pandaModifierFlags +} from "../generated/Es2pandaEnums" +import { nullptr } from "@koalaui/interop" +import { AstNode } from "./peers/AstNode" -type Visitor = (node: arkts.Node) => arkts.Node +type Visitor = (node: AstNode) => AstNode // TODO: rethink (remove as) -function nodeVisitor(node: T, visitor: Visitor): T { +function nodeVisitor(node: T, visitor: Visitor): T { if (node === undefined) { return node } @@ -17,7 +45,7 @@ function nodeVisitor(node: T, visitor: Visitor } // TODO: rethink (remove as) -function nodesVisitor(nodes: TIn, visitor: Visitor): T[] | TIn { +function nodesVisitor(nodes: TIn, visitor: Visitor): T[] | TIn { if (nodes === undefined) { return nodes } @@ -25,16 +53,16 @@ function nodesVisitor void>, state: arkts.Es2pandaContextState, dumpAst: boolean): arkts.Node { - arkts.proceedToState(state) - const script = arkts.EtsScript.fromContext() +function insertPlugin(pluginsByState: Map void>, state: Es2pandaContextState, dumpAst: boolean): AstNode { + proceedToState(state) + const script = EtsScript.fromContext() if (script === undefined) { throwError(`Failed to receive ast from es2panda`) } @@ -55,15 +71,15 @@ function insertPlugin(pluginsByState: Map void>, dumpAst: boolean ): void { +function invokeWithPlugins(configPath: string, filePath: string, outputPath: string, pluginsByState: Map void>, dumpAst: boolean ): void { const source = fs.readFileSync(filePath).toString() const sdk = process.env.PANDA_SDK_PATH ?? withWarning( defaultPandaSdk, @@ -72,12 +88,11 @@ function invokeWithPlugins(configPath: string, filePath: string, outputPath: str const stdlib = `${sdk}/ets/stdlib` global.filePath = filePath - global.config = arkts.Config.create([ + global.config = Config.create([ '_', '--arktsconfig', configPath, filePath, - // Always assume this option unconditionally '--extension', 'sts', '--stdlib', @@ -85,64 +100,60 @@ function invokeWithPlugins(configPath: string, filePath: string, outputPath: str '--output', outputPath ]).peer - global.context = arkts.Context.createFromString(source).peer + global.context = Context.createFromString(source).peer console.log("PLUGINS: ", pluginsByState.size, pluginsByState) if (pluginsByState.size == 0 ) { - arkts.proceedToState(arkts.Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) + proceedToState(Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) return } // ComponentTransformer - const parsedTransform = insertPlugin(pluginsByState, arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED, dumpAst) - // TODO: Normally we need just to proceede to a given state, - // but the compiler crashes now, so we restart - restartCompilerUptoState(parsedTransform, arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED) + const parsedTransform = insertPlugin(pluginsByState, Es2pandaContextState.ES2PANDA_STATE_PARSED, dumpAst) + // TODO: Normally we need just to proceed to a given state, + // but the compiler crashes now, so we restart + restartCompilerUptoState(parsedTransform, Es2pandaContextState.ES2PANDA_STATE_CHECKED) // BuilderLambdaTransformer - const checkedTransform = insertPlugin(pluginsByState, arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED, dumpAst) - restartCompilerUptoState(checkedTransform, arkts.Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) + const checkedTransform = insertPlugin(pluginsByState, Es2pandaContextState.ES2PANDA_STATE_CHECKED, dumpAst) + restartCompilerUptoState(checkedTransform, Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) } function loadPlugin(configDir: string, jsonPlugin: any) { const pluginPath = jsonPlugin.transform ?? throwError(`arktsconfig plugins objects should specify transform`) /** TODO: read and pass plugin options */ const options = jsonPlugin.options ?? {} - const plugin = (pluginPath.startsWith(".") || pluginPath.startsWith("/")) ? - path.resolve(configDir, pluginPath) : pluginPath + const plugin = (pluginPath.startsWith(".") || pluginPath.startsWith("/")) + ? path.resolve(configDir, pluginPath) + : pluginPath return require(plugin).default() } -function selectPlugins(configDir: string, plugins: any[], stage: string): ((arg: arkts.Node) => arkts.Node)|undefined { +function selectPlugins(configDir: string, plugins: any[], stage: string): ((arg: AstNode) => AstNode) { const selected = plugins .filter(it => (it.stage == stage)) .map(it => loadPlugin(configDir, it)) - if (selected.length == 0) { - return undefined - } else { - return (ast: arkts.Node) => selected.reduce( - (it, transform) => transform(it), - ast - ) - } + return (ast: AstNode) => selected.reduce( + (it, transform) => transform(it), + ast + ) } -function stateName(value: arkts.Es2pandaContextState): string { - return arkts.Es2pandaContextState[value].substring("ES2PANDA_STATE_".length) +function stateName(value: Es2pandaContextState): string { + return Es2pandaContextState[value].substring("ES2PANDA_STATE_".length) } function readAndSortPlugins(configDir: string, plugins: any[]) { - const pluginsByState = new Map void>() + const pluginsByState = new Map void>() - Object.values(arkts.Es2pandaContextState) - .filter(it => typeof it == "number") // enum values are numbers and strings together + Object.values(Es2pandaContextState) + .filter(isNumber) .forEach(it => { - const selected = selectPlugins(configDir, plugins, stateName(it as number).toLowerCase()) - if (selected) pluginsByState.set( - it as number, - selected + pluginsByState.set( + it, + selectPlugins(configDir, plugins, stateName(it).toLowerCase()) ) }) diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts index c93541481df0b3f2b5a516d05a306d7b046ef27c..e9ad73edca3b606aa830030db95fdff9ea98053f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class AnnotatedAstNode extends Node { +export class AnnotatedAstNode extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts index a4ef2be0a426d448892642a20465a79f368616ca..da6f803221a658af070b46aaa656581affb9565d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class AnnotatedExpression extends Node { +export class AnnotatedExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts index b4f40014cdfe316c6f515637ab1f3c7dc211a12f..1990319f946704f32d53e416d454b0b2a50bd44e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class AnnotatedStatement extends Node { +export class AnnotatedStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts index ec853f5a28f451317b38fd4487844ac443388540..cc03397cf0f39f165590e4472ef3b6a4403a6550 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class AnnotationDeclaration extends Node { +export class AnnotationDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts index f9721fbf6b9b53f908cbd1c4ac886ec02388559b..7a621f6f71db98f67ded8a582fd29841f681ea79 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class AnnotationUsage extends Node { +export class AnnotationUsage extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts index 95f33b97bf428b6f63c58e1a3f44c1c7a4cd7a88..70ffeff70f6485c5eca205b8f30755ba638b96b0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ArrayExpression extends Node { +export class ArrayExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts index 43f756284f1f10f19b5f0804087b0188b2b90374..e5373a0c039dfedf7bb6e257bf33567baa119dd9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ArrowFunctionExpression extends Node { +export class ArrowFunctionExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts index c725a9f4ae90b65981ce775ff4bdf2969f6ecfb3..9174be879b86d3b6c97f542cf143078d11ebb46c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class AssertStatement extends Node { +export class AssertStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts index b4faff3e3c3bf7f4a4db6829ac6013c681f40cf6..751a2411d58dd2bd500ba9666a1271579dffa6ae 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class AssignmentExpression extends Node { +export class AssignmentExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AstNode.ts b/arkoala-arkts/libarkts/src/generated/peers/AstNode.ts index a97c034d800987fcbc77bb361a380f3347fd2309..25a24324c7e2f72226f451388e96e3df47bb986f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AstNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AstNode.ts @@ -19,10 +19,8 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class AstNode extends Node { -} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts index c0d2227a53e28f603a20e5a632ae31063fc9537b..ce4ba5fc4055338182d4c5a984a5bf71db7a9413 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class AwaitExpression extends Node { +export class AwaitExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts index 6d84178846eb77b0870c8d79b11856b859ed1055..640adaea900fcd58d78da47de21d4431bba72fb1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class BigIntLiteral extends Node { +export class BigIntLiteral extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts index 3cf1245b3edf6a82f78214b99021f55bde77fc44..146aea6308a15ca27d7bc2bafd981b20a39f8b75 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class BinaryExpression extends Node { +export class BinaryExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts index 636af2fa1a4023fdbd9caec3669d93ec3e45be76..ff62ee51e4945e070318c97428851b050257ef98 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class BlockExpression extends Node { +export class BlockExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts index 43ee41c9b2247890f162fe31e45ffefac6c72a90..138ed00b92d573b50840ee084994fc7b851db5e0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class BlockStatement extends Node { +export class BlockStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts index eab8961dd874ad0237b75a4ba34c1996308aab1e..bc7df11a36fcbf92af2f52f296bf088d938849cf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class BooleanLiteral extends Node { +export class BooleanLiteral extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts index 4ce8afede4e4844e32d51854c14a9190dd017b7a..001439e734da58b9e64d75ed24130d79d0f4ee84 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class BreakStatement extends Node { +export class BreakStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts index fb40fc1c32c8ce155dce63c79d3c10438c01fcd1..d1765c0e2794120ad0f22ca3937bda75bde46d81 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class CallExpression extends Node { +export class CallExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts b/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts index c3c7cdd77332e1ff3ef1f29d8140197f0e4609d4..f448fb63763b9431eee1408d3052ec4634c59034 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class CatchClause extends Node { +export class CatchClause extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts index a4519f2b3ccc64dd5bf561a1795082346b0a64f7..099a8fccbaafb6331d0d43cd77d456366f5960f9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ChainExpression extends Node { +export class ChainExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts index 0526e403c96dd422112dedf33e04466c5d5d70eb..8d8462b88c0a0fb8d1a60d1777fba02da329d118 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class CharLiteral extends Node { +export class CharLiteral extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts index 474eec36c4163505e269d785b1c033c820e0df0b..75dfb532f593e4af363f3b65f96f1ffdf5856bef 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ClassDeclaration extends Node { +export class ClassDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts index 53f03904227c54f9006e3595ecd1416f955c22a7..acbafd3c4df137432c520682eb37c485d12726e8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ClassDefinition extends Node { +export class ClassDefinition extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts index 1162e5c03363976d3d261ce9bcea3d45f3cb962e..daca5b44826f9be219ecece2d50fae560d056120 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ClassElement extends Node { +export class ClassElement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts index cc9ebf3eab42ded0f4075ed7b123fbfa703883c2..f6203358d8d36b9b20c3ce6e8077f159e1d88374 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ClassExpression extends Node { +export class ClassExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts index c8ff6501091f74042a774676ff5fafc56195a23f..049c3c908254b3208a506b467f125ecadc2d2be8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ClassProperty extends Node { +export class ClassProperty extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts index d911d563c8822f4c368bc15e7fcd192475df7f66..251f2931e7abb7f56a25fce1a4bef7745fbe4ad7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ClassStaticBlock extends Node { +export class ClassStaticBlock extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts index 5d0b0f03604cd505cf896ea529940219ca4ac043..95c762154c937a731f1190350a4fdd9db15ca29a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ConditionalExpression extends Node { +export class ConditionalExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts index ea608c7db6cab9f3234bed3d3e5d180f52566599..0fe3287b916caa161601e339ee13be471b60ab5d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ContinueStatement extends Node { +export class ContinueStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts index 5684cf79ca49b5e797ae214be5ff421d1b31ec55..c4fdb067d70fc51d927c0e2e8585e1815eae571f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class DebuggerStatement extends Node { +export class DebuggerStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts b/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts index 5591a7c9f2ae724677c9f0463fad748bf28ed946..cad7f83e9dd239e0cdc8a0252108e8f4b198693c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class Decorator extends Node { +export class Decorator extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts index 2ffd483ac620f1931a89cff9a8511c5f32a74e98..b1c87f1006995b6a9b3f3d25c3c00b2456ef4863 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class DirectEvalExpression extends Node { +export class DirectEvalExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts index 64097c561f4dfb88132624fbac696068ada62bcb..b25177488eb58ef50733053c01b3c5e089373161 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class DoWhileStatement extends Node { +export class DoWhileStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts index 7f1bfb2c7cacc89b6d37f9429ef322ce321bb459..33487f928c92740c4e644736f057b0378e05d4ba 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSClassLiteral extends Node { +export class ETSClassLiteral extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts index c1ffb306dbbaf8879c84442ef8f1e7816723982f..047bada0e2def6250b5e68caa9accc850cec8147 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSFunctionType extends Node { +export class ETSFunctionType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts index 81fc1b2813395994e8ea9201bef8edfa91c115bd..38bcc0eceda75d2e0a4a5eb4c0318c71b53ccba6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSImportDeclaration extends Node { +export class ETSImportDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts index 9323046279fb0041edc1139b52ecbe50ef35c822..5a0ce6280cb0def157a4eecb8c9a55e507fcc865 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSLaunchExpression extends Node { +export class ETSLaunchExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts index ca63d66c5bf22796add21776517ebcb5609c83e0..2842a9a80bb2f0626635f15323f0b6b27b67b770 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSModule extends Node { +export class ETSModule extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts index 6c157cd1bbeba2e878308fc03b5e83bc2c9fc72e..12b0e5017efc83ecb812c39c85e9986e6a46c57e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSNewArrayInstanceExpression extends Node { +export class ETSNewArrayInstanceExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts index 9dadcd4f82ecbd5678301b2a1c7d6158e14785a3..bb0452a04363f2868e9a79b1c6297364c738c6a6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSNewClassInstanceExpression extends Node { +export class ETSNewClassInstanceExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts index ae3d0b32e5eb52637835c7f886d119f9755dca17..23233fc80b84362911c2fffdb40d6686b5a3a5ea 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSNewMultiDimArrayInstanceExpression extends Node { +export class ETSNewMultiDimArrayInstanceExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts index b5730c9e447054d08cf89b8c514d1f5eb58bd337..918f435aa068fabcd9e6523b3f3c33650076485d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSNullType extends Node { +export class ETSNullType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts index e45a0c7ffb61592cc0b98ef8d459535e0331a6f6..c918c9b1dd9eb3a87ece0a5cfd28940b12c21e52 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSPackageDeclaration extends Node { +export class ETSPackageDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts index bc6dc84d74282753a02f74cb65378b53c9b7a7c2..b2910fbb2c1d4a0dee229236bfe44be97c1ada4f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSParameterExpression extends Node { +export class ETSParameterExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts index c637f1d162f411b8632f43e13a7e417205dc6b00..7f8403d25799b538e1fd9df538a917bbb927f612 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSPrimitiveType extends Node { +export class ETSPrimitiveType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts index 105c62ac76b2932f86ae2bb31d4f541fe6b7520a..8783356a4c377f33d7c051cf00734f198ad8aa5b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSReExportDeclaration extends Node { +export class ETSReExportDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts index 1754892e30d1d7b6daee7cc6173ffe65b5c97e34..907a3ad5e81d6b59994eb77c71d13ebdbae8cbc3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSStructDeclaration extends Node { +export class ETSStructDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts index a8208a28b252683227127d96dd35ddb6e4fe1122..90605b1d2d10f1e3c5e754b419ab7824f621d9a4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSTuple extends Node { +export class ETSTuple extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts index 49749e7dd37de1a47265fe5d61fcabcbbba6a008..41121ca81b9460e97e4a51ea098779335ad9496f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSTypeReference extends Node { +export class ETSTypeReference extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts index b4f074a2b0031c582b6919a5b75e85604a8090dd..2ec89f0211f70ef9824920ec224d4c382db59878 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSTypeReferencePart extends Node { +export class ETSTypeReferencePart extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts index a6c121b8f9fc8513e61797c2f3299640e58844bb..d4cc3db1f4aa32bbd416b3a2b497b7f955fc1b26 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSUndefinedType extends Node { +export class ETSUndefinedType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts index cc9147190c12a1926640cc3c85603fb766f21453..87deca03ede73e2f8a894a8bceb518b52dad0dfb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSUnionType extends Node { +export class ETSUnionType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts index 5077d3a740dc75e6853cff98586897527bd9d4dc..d427ccd790a241969b738484f6d34c1d56f1f64c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ETSWildcardType extends Node { +export class ETSWildcardType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts index 34d74c714a835af97769e739fe414832dd71a463..21d441a53bc2e2ae77b5b4472006b8aa8edce3a5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class EmptyStatement extends Node { +export class EmptyStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts index 526829873cfbeb6bded6233308b2ac7203170463..b3603633a3da32a1ba4c0d598f475a41863e34aa 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ExportAllDeclaration extends Node { +export class ExportAllDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts index a945039169f34ca40ec741def5a464e2f396a44e..2e0cf44575434aff25b6d41245c4299cf09b437b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ExportDefaultDeclaration extends Node { +export class ExportDefaultDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts index ef49bc1c49597050f9972390af309ecad6974bb8..27cdb7b7bc9cc38495b513ecfbf157a6a272ddc2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ExportNamedDeclaration extends Node { +export class ExportNamedDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts index 1ef1f21fbfa8dd075f32c8bf097404ee5e10833e..614a859fde2c98ef1f0784bc79e4294c53f2d6ee 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ExportSpecifier extends Node { +export class ExportSpecifier extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Expression.ts b/arkoala-arkts/libarkts/src/generated/peers/Expression.ts index e0c2d235a000cfed5b18447f725732b3b48b5b54..8e1f479ce1f593575692b0fe8b1e3e4d2bea8bd8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Expression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Expression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class Expression extends Node { +export class Expression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts index e343966674aeb9de74fc975208ab189eab314ba3..c48137e458f5e2a9632d33b75213bb2b0fae9297 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ExpressionStatement extends Node { +export class ExpressionStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts index 11cfefc891e649cc93aa2bdbcbd7c63ba1c45e66..5eaa68a03b93b6e43475a97dbf32bf6a0dc80137 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ForInStatement extends Node { +export class ForInStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts index 408b87f796d0705763fd6d2148b63b2827dc90d3..63bf7fd475b3baebb1ff2c4f846f1618310bd739 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ForOfStatement extends Node { +export class ForOfStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts index 48a94c122ed903045825db581b7953925f759cec..914da6ffd58cf9706141048bebd39ef6aca077e7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ForUpdateStatement extends Node { +export class ForUpdateStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts index 3430b82f33b0b12207eabac1a6c837231ca551af..36a43287369e9b16a50e506925b62237c63789c3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class FunctionDeclaration extends Node { +export class FunctionDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts index 3fc5685e27b7898961f867d8c8ae5b9206877790..3c6ddf3a25eb34c8047ab1411688603a37ce4269 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class FunctionExpression extends Node { +export class FunctionExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts b/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts index 5ad4d3c47408e1ed4c652848b404a2197fbd8137..f21d42510fd351b4d85daa3018bf4ffd07389202 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class Identifier extends Node { +export class Identifier extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts index 8bd0e33e3e8568f433048df0379e37f552772b9d..b27ddefad2de5f389864200128a73926e513f211 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class IfStatement extends Node { +export class IfStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts index 93918bd86e363d51bc1c8d255ebdf75b676ace6c..bd15deb13fe6e38e6bb2b80c3defafd62f7703cb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ImportDeclaration extends Node { +export class ImportDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts index 7a70b644b22d2bd13bb982e0ec1974baef834510..bb0e364a12633a0d95f649841bd596c34165bad0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ImportDefaultSpecifier extends Node { +export class ImportDefaultSpecifier extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts index b055ed3db2417773399bc4be1993831a1d86558c..a837d33854da7df0abcf83cd5e7163c0f7211d51 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ImportExpression extends Node { +export class ImportExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts index f51d33a4b312aa74d557b0b70f2cf8b1a96e298c..ba16feb35b2536870c1a24a97ff247513dd71c3f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ImportNamespaceSpecifier extends Node { +export class ImportNamespaceSpecifier extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts index bda9839267d6c9d0ad291e757b0137d0aa8ce46a..611a6b1d8e43b504b350c3df9dfa7c1409f19b04 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ImportSpecifier extends Node { +export class ImportSpecifier extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts index f2d535de8356db8242aeeac9aa27cb369ec04e07..d54feff7bac8ddeecbb39080ce5faa5b4ecc980b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class LabelledStatement extends Node { +export class LabelledStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Literal.ts b/arkoala-arkts/libarkts/src/generated/peers/Literal.ts index 6dee82956ad4778779b0dd544b37db96f5c5c866..dedaf507bf3d7a5c1c29f22f43970e7580d26abb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Literal.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Literal.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class Literal extends Node { +export class Literal extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts index 490a587a8e724cac8bcc20332bea6d3f28f419fd..4dcdc0718cdeb2536f079e41f7d020952d17e146 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class LoopStatement extends Node { +export class LoopStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts index b6ace4c470471684a3f3bd2c7db260e0f6874c24..368d349d1fc78faad318c13e485d42f9eefbff73 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class MaybeOptionalExpression extends Node { +export class MaybeOptionalExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts index f6921bf583264bdba75b6696964531b7775806cc..d16611eab4ab2ae95d6d350de2b43fd02e9cb928 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class MemberExpression extends Node { +export class MemberExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts index f3f57c0ee8c45028d1e7387929b4e3cebfc8d53e..2be94ca466a631f03d48055dba7b311d5a7dbf43 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class MetaProperty extends Node { +export class MetaProperty extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts b/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts index 8e7e6fe888f3cc92f0e0154d0ca8d0600d1c7e60..2918a41444c5c88099481ec15bcbc22299213ac5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class MethodDefinition extends Node { +export class MethodDefinition extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts b/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts index 6c86cf8bbb13abbc6df51a644e5699b9e007de8c..6ff015e309242b85da3e6d38fa2faa95fa8a8875 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class NamedType extends Node { +export class NamedType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts index 67fffa65a01883d8bf9e61a6bfcdfc07318794d3..424203244086061692bf84e6d8a3a001a3743413 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class NewExpression extends Node { +export class NewExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts index c71efedf7c53434235cb93d01f7b989abfb8b176..37e51ed231c86b42e1d96681fab194f7313f7cc1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class NullLiteral extends Node { +export class NullLiteral extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts index 8f040b578dfc080f9dfb48f498d867f43f0519a7..8f8f507f5bddf401ca59f1e828069e9237f016ae 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class NumberLiteral extends Node { +export class NumberLiteral extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts index c15280859134caf239e69da2d8c7b03f733375a7..a5d822e1257b978929fac9faf82c7e68e3c4bf0f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ObjectExpression extends Node { +export class ObjectExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts index 460e2203d16ea6eef2f3d56b25550cde80fb17ed..4b08487b4254912515f58522158e71b373ed86fd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class OmittedExpression extends Node { +export class OmittedExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts b/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts index e4e5a769bd94ea6ec6ec421c1f41a1815e083ade..e21fac8230d0f76a977c151b4a56ea8775c4046b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class OpaqueTypeNode extends Node { +export class OpaqueTypeNode extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts index e9ad0e15c2ae259942639458fdb4a43fbd2941e2..9f62e4ff8f3641978e6c8e7927e9b1b2aefc73e7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class PrefixAssertionExpression extends Node { +export class PrefixAssertionExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Property.ts b/arkoala-arkts/libarkts/src/generated/peers/Property.ts index 07050946f4d10a6e2565946a3ba83f17e6e64472..90320bbc00b33ef832b93a91d59ac0529fe5888d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Property.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Property.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class Property extends Node { +export class Property extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts index 664eb585265735f494354b672e9c35c088f513c3..422fe0b52a54b241b7ecbefe1119d65948fc4f45 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class RegExpLiteral extends Node { +export class RegExpLiteral extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts index 0ac98e3891c299242ab6c545061eff45320494f9..f9d90e7edc9df9dbfba7a915f4626ef0f71c4a6f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ReturnStatement extends Node { +export class ReturnStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts b/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts index 9be650d0114f1e7d752a694a7ee1e1f4b5bed94c..8d49e05c64688830003843bdf3238cdb39ade7bc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ScriptFunction extends Node { +export class ScriptFunction extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts index 658a713715a6507fabecbce52ee54167bc634503..ec6fb06f94732bc406a7ece54afa91ac7d3b8b5d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class SequenceExpression extends Node { +export class SequenceExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts b/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts index 1f1658e4adc240ea32e69f8849d3d2b2fe1d339a..a82389f3fff3cc188b48813281800f01d7534550 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class SpreadElement extends Node { +export class SpreadElement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Statement.ts b/arkoala-arkts/libarkts/src/generated/peers/Statement.ts index 638090d72861a9d83a2d67da90f94f1edc37656f..09cafa323b691271bfe0a0409201b2c791a459c7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Statement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Statement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class Statement extends Node { +export class Statement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts index 520013971a5ec814f91e821917c4cc3cf101b88b..c999fa7d0eb79b8e9510f1c76dae84a24d3cb01b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class StringLiteral extends Node { +export class StringLiteral extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts index 9784764f566a2ab61d8c7086afd02045f10b121e..9b59d33434d97f69438ba4371b73e62b194e1493 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class SuperExpression extends Node { +export class SuperExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts index 761b4484d29b3dece3b990cf011be44ac47186f1..1ea6bc23fb74320ccdd27971115e3440f1598e26 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class SwitchCaseStatement extends Node { +export class SwitchCaseStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts index 2501607b82ade085e75296cba94c6f05d55f9101..d9cc846795d4fe2a7703900ccc1fac2cb4c77f9b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class SwitchStatement extends Node { +export class SwitchStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts index a74eceb80144cdc48b77912d4ba4b47f87138fe3..64e79c7cb89f4b85940de903cdae9094ff086a59 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSAnyKeyword extends Node { +export class TSAnyKeyword extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts index b8998d97dad6d382e921f62b5e70e5940058b0e2..92a074c8dd82ef76aba248fe661349be3a749e75 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSArrayType extends Node { +export class TSArrayType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts index 29da2397509336cd2dcdde0d0ae6dbcaf24dcd09..7086aa1fa215a4bb55fee86d15daa6747c10701f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSAsExpression extends Node { +export class TSAsExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts index cfa0851ff371949c0d327504d8608a518a3bd2e5..e17e6776e94d4b23b7fb8f3a6ebf0a6a04b5cde8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSBigintKeyword extends Node { +export class TSBigintKeyword extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts index 5061ce255e63bcc4ef8ae32b000119ad95270f5f..79131e97305f4ddf15bc39b2eaec883e4b59f746 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSBooleanKeyword extends Node { +export class TSBooleanKeyword extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts b/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts index 150b14818e16f6855322a9acfdfb24130f4bdb51..2c5337e7cc290817082d26d01681d14425f7fe23 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSClassImplements extends Node { +export class TSClassImplements extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts index 91dfcc4dcb4be41bc8431c27974c2941046c2b09..af84e887c98b5a3c766a52fef5be1756446cc80e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSConditionalType extends Node { +export class TSConditionalType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts index 4ea16a7b6741afd8f108ceed8f8483d3bd052cf2..695defc74953cd050c233491841902c6e4030bf8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSConstructorType extends Node { +export class TSConstructorType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts index 590647ce3c28a0b8763fd8f2115ac742a9b3aab1..afe5edc92b41862e9ca04037cbf417a2d850ce8b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSEnumDeclaration extends Node { +export class TSEnumDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts b/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts index a4456b8b097ea7d1a575313499f038ea13cf7a30..e4ce7d0c1e4648499b0d08dad32cf2085485057f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSEnumMember extends Node { +export class TSEnumMember extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts b/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts index b79040a862ee4bfa877fe64763d9f98d27a123d0..e6a0c3ae1dba181e8ddc388f2dfe95580454934d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSExternalModuleReference extends Node { +export class TSExternalModuleReference extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts index 9c9597fc852f6c1ff541e08d0ff784274b71b64e..5941d1e72c374952eceb0e69dc38b237dfc35039 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSFunctionType extends Node { +export class TSFunctionType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts index 339cf8b7d5be0d3af30d6629a82f0a6bc669b4d3..0dc8b32c38962fdb8fc6d93b825454cb019f9a6f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSImportEqualsDeclaration extends Node { +export class TSImportEqualsDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts index fb8ec8468e2583a0bef2f907596d0bde8fd153f3..26a3e3adc03ef07d4d83e6b2feccf536f321e307 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSImportType extends Node { +export class TSImportType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts index 1565462ef044db433d4331d8c42f97c523b3db86..f2c518e311492d4d71ee7cf3e82a8a775ded6607 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSIndexSignature extends Node { +export class TSIndexSignature extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts index 948746c0b868da7423b01d5210d02790fb7a959a..97e91bd655c9bb39dd68eed9d067a609b134721c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSIndexedAccessType extends Node { +export class TSIndexedAccessType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts index 7b5990c7d22a6ec5c84a4a6cd992774dc9a18643..8a4485df1255f03ffab207b3c864c92c7b49106d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSInferType extends Node { +export class TSInferType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts index 8f4816c58622105b810d9099ef5bad063e36453b..bf0ecf83c6e1ea26d685f719ffc1c22fae63f8e3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSInterfaceBody extends Node { +export class TSInterfaceBody extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts index cf885b2cd7b1686556bae9302e5ba2d3d1127de9..59fb42730221a098fd8b5ad2e7617203d53b0fb8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSInterfaceDeclaration extends Node { +export class TSInterfaceDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts index 79c5e5aa4d340d4f1380ae80fd5af8704c9a01b3..3f887eed5cbc09279831fb6ed1332a3fac65fa30 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSInterfaceHeritage extends Node { +export class TSInterfaceHeritage extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts index 2612650a53b0cfb7989cdf3ef5368728bdb9db52..9cfd644ce752011ebb49655bfd17f06b03b6e004 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSIntersectionType extends Node { +export class TSIntersectionType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts index be794facf75db6c60effe92ec62fbeb9c1f83522..660721a0909f1f338d9f628adfb50a19ad8ef37a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSLiteralType extends Node { +export class TSLiteralType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts index 3b2156b91b218d14b3f0505eb57b87841d76ccc0..26d43d12da37fc14c2c0c8cd9c7e1e71a1b803e6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSMappedType extends Node { +export class TSMappedType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts index 3493aa2ce44c85d1dcb5b46de25fa3f957301340..4fbce646fa4fd3f5c8137c916d6313f4a456ebcd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSMethodSignature extends Node { +export class TSMethodSignature extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts b/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts index 8a278e3a2a7d738d847fec410225c28e8111f95e..8fb7774999e5f9619ca4f566a506102bb878a863 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSModuleBlock extends Node { +export class TSModuleBlock extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts index 38cf33c75fca7f9351e89dccda39ea5abb1e22de..eb5c2b6ddd16c907111fab902e4e55810e5a5752 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSModuleDeclaration extends Node { +export class TSModuleDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts index a1ecba8322065c2f661e905face59dfa0dd25de8..0f9e8290da3fcc8a4cc05acd4f945ac7dff21a42 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSNamedTupleMember extends Node { +export class TSNamedTupleMember extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts index 55550999b5583d05c7e762dfb8319d4edf26fa2d..4ee2c0bc30c67dd7bd8d03f4797d551477378d39 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSNeverKeyword extends Node { +export class TSNeverKeyword extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts index 260d1b43c71e8b94c3840e0971245726bb6e3237..2baabd617261715b13ac95d6e7c69d527ea7f2a0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSNonNullExpression extends Node { +export class TSNonNullExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts index 2d7b08d55fa3d318a4cd8e33e867905437c81626..9f53801515b8d417d7af10a1011fbfebc1e8c9dd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSNullKeyword extends Node { +export class TSNullKeyword extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts index 1ff7f14e1ad9dd53c94f22728596d1ac55f3a49e..3b217200e9df285e983fd683c07afd434057aef2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSNumberKeyword extends Node { +export class TSNumberKeyword extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts index eb1546746ad4b07439c1918f1fe0ede14771f3e1..cfa373de2ecdb06ac1498af6fce66991933513a1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSObjectKeyword extends Node { +export class TSObjectKeyword extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts index e0243020eee81a3a08c87a02f40298a21009b530..cacc62e0b75d5934570fb1514c6e6e1400803c3b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSParameterProperty extends Node { +export class TSParameterProperty extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts index 69dae9eb5304ee00b43e1aa49fa195ff6b151b0f..c4844a58be0f5d276d8f831c707272e5ee547f7a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSParenthesizedType extends Node { +export class TSParenthesizedType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts index 2fc25cd0bc56aae8471a858637d1e0427f35bb51..6a39f235a0d063d4bba0afaef9785e31b0a4b9a1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSPropertySignature extends Node { +export class TSPropertySignature extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts b/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts index 00eca1c67b9b14a1636e04c5275274bcd2b72c63..3175f1f9f44d98edb1547a02b7ff1016c6e54b93 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSQualifiedName extends Node { +export class TSQualifiedName extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts index bd5c23a6335614d6272a1bdd855e4da1a9cd01f9..d6f0f152e4ee4a25da9f27424ef09c31e589be11 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSSignatureDeclaration extends Node { +export class TSSignatureDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts index f96ab200bd63070da7195cd63049da52aab89782..9fdaa842a0d32eb2bf8e9f182faf319adbe8fbd6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSStringKeyword extends Node { +export class TSStringKeyword extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts index 145af4da1b78561857d7fdde4e0ce16707fbf4c4..98b32e00bdec84c8af0b1cf23f025255f3c88f13 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSThisType extends Node { +export class TSThisType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts index 7ebd2d950a32084ca02a30698efa2b5d4ddd602d..de97511667933729dceb26bf90d2d174cfe73131 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSTupleType extends Node { +export class TSTupleType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts index 6cbbd1ae54fe06c13eceb25d5ffcf458fe6aad67..81c16119a11ae72e02d8765d76fbe8e34082575a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSTypeAliasDeclaration extends Node { +export class TSTypeAliasDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts index 3100c48c7c6fc90fc7737ff447562adea7eb1f3a..a4ca07ceb0242b37c1b72b6413f5514cbc660387 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSTypeAssertion extends Node { +export class TSTypeAssertion extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts index 4d5bb62b2c71b9a3971848710541e9116ffae3cb..dc7cdd1f8a40597f61e0d1c9ffd091bc84aa6929 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSTypeLiteral extends Node { +export class TSTypeLiteral extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts index b8af0d59e731c165ece808e5cace99127bccfc21..80ee0f825905d3c17020e161e3c272758c717fad 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSTypeOperator extends Node { +export class TSTypeOperator extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts index e67de36bca942d01e59bb9a09a3b3455a79a78fa..6118baa7ed3fb2c57aa21c49e5feefa1309ac4d6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSTypeParameter extends Node { +export class TSTypeParameter extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts index c1620b9239275ceb376497ce4b05717da4549520..09661ce9ae927579029ed66f79afbd8b1303dcad 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSTypeParameterDeclaration extends Node { +export class TSTypeParameterDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts index 27ecc8ffd7913beb7a3bf69a68dddca840993335..1ddd27bef0648cd544abeb2924ab0eb8fda24b2d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSTypeParameterInstantiation extends Node { +export class TSTypeParameterInstantiation extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts index 5e7935e9bbe94ea9c4b9dca0261b49e08de44701..b5fcc03b64f1af3f312d3d95eaafd56746c19651 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSTypePredicate extends Node { +export class TSTypePredicate extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts index 1a6855faa4ba45232d7b97d1e9c59cf058421ba6..3497c85be9ee05c0e2d2393ca9b148336647c84a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSTypeQuery extends Node { +export class TSTypeQuery extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts index 30ae5d6ea34274e8ab4afb4c9971e3c75adb9721..3a82700cdaad89b720d08af02d2dc552e781031e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSTypeReference extends Node { +export class TSTypeReference extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts index afe66a6dbc9638efe16a98ef76c1735e49c0f665..b1a7c2ce0fe7996021ebc74681d20cadaeb5c59f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSUndefinedKeyword extends Node { +export class TSUndefinedKeyword extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts index f977ecb5290097dc24f6b0b86ca8160d932a87c5..bd7eca681ffed0023e965445c32b74cc984b58b0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSUnionType extends Node { +export class TSUnionType extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts index ce59aa35eb61b929fe8c751c5f9e53f479d8b3b0..77080315b4636c94eda83024b6b437c904e3d4bf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSUnknownKeyword extends Node { +export class TSUnknownKeyword extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts index cd848829525ea801c749e6bd6f6d57cac174baae..9f74d5bd72af3ddfd2beac8cb0067e3edc77e796 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TSVoidKeyword extends Node { +export class TSVoidKeyword extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts index ea08698b51e7383975859550f5e9f1e9f3e847a7..12694a960c2f28150a301d11d2f81a9dfbeae555 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TaggedTemplateExpression extends Node { +export class TaggedTemplateExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts b/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts index c1d2fa021ff38d147be6a2447f8241323838870e..70ccee8a998f0ec2530875627f392c267e9757b9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TemplateElement extends Node { +export class TemplateElement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts index bbcd449926b0fe7db8b658199e8e408e26cd3c34..d83888b76b3ca97a03176eb8fca00baae80b5053 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TemplateLiteral extends Node { +export class TemplateLiteral extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts index caec4d27eec06736ab6de48b00894f547ef39dc9..7d1f0629e1a44e524b8bd7f28d33982dc644b690 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ThisExpression extends Node { +export class ThisExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts index c796d2a64a964f2530be69dc4dddfc38cd33d05f..7e1cd64ede587db91dbc944ac4a11fe0a0893288 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class ThrowStatement extends Node { +export class ThrowStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts index e564d83569c6d37fc2d551959d86760df4278118..86060a39636a983c1f797f774c7e37b4d501d8db 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TryStatement extends Node { +export class TryStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts b/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts index 31294e1f236501a30128935eede98aa4466ba881..99670655badcfee722634f34140c40e9da278a9e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TypeNode extends Node { +export class TypeNode extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts b/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts index 6bb9cd0603b32651b7c34eff8e5da976b96747aa..284ee488208184320f3a858a7b8006bd76fdb847 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TypedAstNode extends Node { +export class TypedAstNode extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts index f1668eee3cd4ff86b565b455098afb957e5d75fb..b2800a3f704fd4795eec8efb02278cb9fb088f61 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TypedStatement extends Node { +export class TypedStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts index 38b12352a85fe35395ca4df51a453d096ae9b59a..a694b2b028a15b7189280625abcc2e6bdc689f7c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class TypeofExpression extends Node { +export class TypeofExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts index 48ee2ce2ded893c6e90444782a2d992fbc89254a..6f651eb850188244b4ea765472c19ab756f102f3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class UnaryExpression extends Node { +export class UnaryExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts index abec619cdef06877ec05f40a7480bbddb75c8296..7d07c339e417e14790d0259ef23a50726b669368 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class UndefinedLiteral extends Node { +export class UndefinedLiteral extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts index 67daf1a2767ac43fc3e28f8af99334eee25c7bd4..c1ef6622f72b1c8ef6ff3092bf1bf7edb3c191f2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class UpdateExpression extends Node { +export class UpdateExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts index 57823d11ada11a219d735727d825148318005162..2be92a7611777c15870f1c14980aeb1858026493 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class VariableDeclaration extends Node { +export class VariableDeclaration extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts index 349ea041d66291f25c9f1f2b68a54db5a8055aa2..41a192fd91c5576421764ebdc429e98e75b9d35d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class VariableDeclarator extends Node { +export class VariableDeclarator extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts index caa647efb146b366d5095a141da28ed58aad6cff..ca65798bdf5c8b16fccdd911a53cdaa00d3534e9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class WhileStatement extends Node { +export class WhileStatement extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts index 4627861f49088c9119ba53da2f6ef83b2583483e..fa850dffc6dbf86aa9c868d0650ce31a22ff9b68 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts @@ -19,10 +19,10 @@ import { unpackNonNullableNode, Es2pandaMemberExpressionKind, assertValidPeer, - Node, + AstNode, Es2pandaAstNodeType, KNativePointer } from "../../reexport-for-generated" -export class YieldExpression extends Node { +export class YieldExpression extends AstNode { } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/reexport-for-generated.ts b/arkoala-arkts/libarkts/src/reexport-for-generated.ts index 680410e83538fdd6aa17b5a7b3e6804e423ffb78..781be826eb64e77ad3f3448c43220d015cd7a61f 100644 --- a/arkoala-arkts/libarkts/src/reexport-for-generated.ts +++ b/arkoala-arkts/libarkts/src/reexport-for-generated.ts @@ -15,8 +15,9 @@ export { KNativePointer } from "@koalaui/interop" export { Es2pandaAstNodeType } from "./Es2pandaEnums" -export { assertValidPeer, Node } from "./arkts-api//types" +export { assertValidPeer } from "./arkts-api//types" export { passNode, unpackNonNullableNode } from "./arkts-api/utilities/private" -import global from "./arkts-api/static/global" -export { global } +export { global } from "./arkts-api/static/global" export { Es2pandaMemberExpressionKind } from "./generated/Es2pandaEnums" +export { AstNode } from "./arkts-api/peers/AstNode" +export { MemberExpression } from "./arkts-api/to-be-generated/MemberExpression" diff --git a/arkoala-arkts/libarkts/src/ts-api/factory/nodeTests.ts b/arkoala-arkts/libarkts/src/ts-api/factory/nodeTests.ts index eed8a6703e379023733e244fb8d6a55b743b3ba9..94820ba97846dd7ec888a14e7a0e356d20d21176 100644 --- a/arkoala-arkts/libarkts/src/ts-api/factory/nodeTests.ts +++ b/arkoala-arkts/libarkts/src/ts-api/factory/nodeTests.ts @@ -1,40 +1,27 @@ -import { - SyntaxKind, -} from "@koalaui/ets-tsc" +import { SyntaxKind, } from "@koalaui/ets-tsc" import { - Node, - Identifier, - StringLiteral, - FunctionDeclaration, + ArrowFunction, Block, - KeywordTypeNode, - PropertyAccessExpression, - ParameterDeclaration, - ReturnStatement, - IfStatement, - ExpressionStatement, CallExpression, - ArrowFunction, - TypeReferenceNode, - BinaryExpression, - BinaryOperatorToken, ClassDeclaration, + ExpressionStatement, + FunctionDeclaration, + FunctionExpression, FunctionTypeNode, - TypeNode, - Expression, - Statement, - SourceFile, - ClassElement, + GetAccessorDeclaration, + Identifier, MethodDeclaration, - FunctionExpression, - VariableDeclaration, - VariableDeclarationList, + MethodSignature, + Node, + ParameterDeclaration, + PropertyAccessExpression, PropertyDeclaration, PropertySignature, - MethodSignature, - GetAccessorDeclaration, SetAccessorDeclaration, + SourceFile, + VariableDeclaration, + VariableDeclarationList, VariableStatement, } from "../types" diff --git a/arkoala-arkts/libarkts/src/ts-api/types.ts b/arkoala-arkts/libarkts/src/ts-api/types.ts index 88774f765202775e8d0cc121bac853af88425ba9..13a3fb64c79e7e074273800d2cf3ed60a014f3e4 100644 --- a/arkoala-arkts/libarkts/src/ts-api/types.ts +++ b/arkoala-arkts/libarkts/src/ts-api/types.ts @@ -19,9 +19,9 @@ export interface TransformationContext {} export interface Program {} // TODO: remove U type param -export type NodeArray, U extends arkts.Node | undefined = arkts.Node | undefined> = ts.NodeArray +export type NodeArray, U extends arkts.AstNode | undefined = arkts.AstNode | undefined> = ts.NodeArray -export abstract class Node implements ts.Node { +export abstract class Node implements ts.Node { constructor(node: T) { this.node = node } @@ -133,7 +133,7 @@ export class Modifier extends Node { kind: ModifierSyntaxKind } -export abstract class Expression extends Node implements ts.Expression { +export abstract class Expression extends Node implements ts.Expression { // TODO: support minimal interface _expressionBrand: any } @@ -235,7 +235,7 @@ export class PrivateIdentifier extends Node implements ts.Priv _declarationBrand: any } -export abstract class Statement extends Node implements ts.Statement { +export abstract class Statement extends Node implements ts.Statement { // brands _statementBrand: any } @@ -285,7 +285,7 @@ export class SourceFile extends Node implements ts.SourceFile { _declarationBrand: any } -export abstract class LeftHandSideExpression extends Node implements ts.LeftHandSideExpression, Expression { +export abstract class LeftHandSideExpression extends Node implements ts.LeftHandSideExpression, Expression { // brands _leftHandSideExpressionBrand: any _updateExpressionBrand: any @@ -384,7 +384,7 @@ export class ClassDeclaration extends Node implements ts _statementBrand: any } -export abstract class ClassElement extends Node implements ts.ClassElement { +export abstract class ClassElement extends Node implements ts.ClassElement { // brands _declarationBrand: any _classElementBrand: any @@ -405,9 +405,9 @@ export type DeclarationName = // | BindingPattern // | EntityNameExpression; -export interface Declaration extends Node {} +export interface Declaration extends Node {} -export abstract class NamedDeclaration extends Node implements ts.NamedDeclaration, Declaration { +export abstract class NamedDeclaration extends Node implements ts.NamedDeclaration, Declaration { readonly name?: DeclarationName; // brands @@ -429,8 +429,8 @@ export interface FunctionLikeDeclarationBase extends SignatureDeclarationBase { // export type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction; export type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction; -export class MethodSignature extends Node implements ts.MethodSignature, SignatureDeclarationBase { - constructor(node: arkts.Node) { +export class MethodSignature extends Node implements ts.MethodSignature, SignatureDeclarationBase { + constructor(node: arkts.AstNode) { super(node) } @@ -493,9 +493,9 @@ export class ConstructorDeclaration extends Node impleme _declarationBrand: any } -// TODO: specify arkts.Node type -export class PropertySignature extends Node implements ts.TypeElement { - constructor(node: arkts.Node) { +// TODO: specify arkts.AstNode type +export class PropertySignature extends Node implements ts.TypeElement { + constructor(node: arkts.AstNode) { super(node) } @@ -507,9 +507,9 @@ export class PropertySignature extends Node implements ts.TypeElemen _declarationBrand: any } -// TODO: specify arkts.Node type -export class PropertyDeclaration extends Node implements ts.PropertyDeclaration, ClassElement { - constructor(node: arkts.Node) { +// TODO: specify arkts.AstNode type +export class PropertyDeclaration extends Node implements ts.PropertyDeclaration, ClassElement { + constructor(node: arkts.AstNode) { super(node) } @@ -523,9 +523,9 @@ export class PropertyDeclaration extends Node implements ts.Property _declarationBrand: any } -// TODO: specify arkts.Node type -export class GetAccessorDeclaration extends Node implements ts.GetAccessorDeclaration, FunctionLikeDeclarationBase, ClassElement { - constructor(node: arkts.Node) { +// TODO: specify arkts.AstNode type +export class GetAccessorDeclaration extends Node implements ts.GetAccessorDeclaration, FunctionLikeDeclarationBase, ClassElement { + constructor(node: arkts.AstNode) { super(node) } @@ -545,9 +545,9 @@ export class GetAccessorDeclaration extends Node implements ts.GetAc _objectLiteralBrand: any } -// TODO: specify arkts.Node type -export class SetAccessorDeclaration extends Node implements ts.SetAccessorDeclaration, FunctionLikeDeclarationBase, ClassElement { - constructor(node: arkts.Node) { +// TODO: specify arkts.AstNode type +export class SetAccessorDeclaration extends Node implements ts.SetAccessorDeclaration, FunctionLikeDeclarationBase, ClassElement { + constructor(node: arkts.AstNode) { super(node) } @@ -633,7 +633,7 @@ export class TypeParameterDeclaration extends Node implem _declarationBrand: any } -export abstract class TypeNode extends Node implements ts.TypeNode { +export abstract class TypeNode extends Node implements ts.TypeNode { // brands _typeNodeBrand: any } @@ -649,8 +649,8 @@ export class KeywordTypeNode extends Node implements ts.TypeReferenceNode, TypeNode { - constructor(node: arkts.Node) { +export class TypeReferenceNode extends Node implements ts.TypeReferenceNode, TypeNode { + constructor(node: arkts.AstNode) { super(node) } @@ -663,8 +663,8 @@ export class TypeReferenceNode extends Node implements ts.TypeRefere _typeNodeBrand: any } -export class FunctionTypeNode extends Node implements ts.FunctionTypeNode, TypeNode, SignatureDeclarationBase { - constructor(node: arkts.Node) { +export class FunctionTypeNode extends Node implements ts.FunctionTypeNode, TypeNode, SignatureDeclarationBase { + constructor(node: arkts.AstNode) { super(node) } @@ -911,8 +911,8 @@ export class ImportSpecifier extends Node implements ts.Import _declarationBrand: any } -export class UnsupportedNode extends Node implements ts.Node { - constructor(node: arkts.Node) { +export class UnsupportedNode extends Node implements ts.Node { + constructor(node: arkts.AstNode) { super(node) } diff --git a/arkoala-arkts/libarkts/src/ts-api/utilities/private.ts b/arkoala-arkts/libarkts/src/ts-api/utilities/private.ts index d3720c5850fde7378e5ee9f2cdfc325f1dd41ca6..718fd97680ae404646185a3954afc8f606cbaf7e 100644 --- a/arkoala-arkts/libarkts/src/ts-api/utilities/private.ts +++ b/arkoala-arkts/libarkts/src/ts-api/utilities/private.ts @@ -37,7 +37,7 @@ export function todo(): any { } type kindTypes = - | { new (node: arkts.Node): ts.Node } + | { new (node: arkts.AstNode): ts.Node } | { new (node: arkts.Identifier): ts.Identifier } | { new (node: arkts.EtsScript): ts.SourceFile } | { new (node: arkts.StringLiteral): ts.StringLiteral } @@ -61,7 +61,7 @@ type kindTypes = | { new (node: arkts.VariableDeclarator): ts.VariableDeclaration } | { new (node: arkts.VariableDeclaration): ts.VariableStatement } -export function classByEtsNode(node: arkts.Node) { +export function classByEtsNode(node: arkts.AstNode) { const types = new Map([ [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, ts.SourceFile], @@ -98,33 +98,33 @@ export function classByEtsNode(node: arkts.Node) { // TODO: add checks for casts in functions below -export function unpackNode >(node: U): T -export function unpackNode >(node: U): T | undefined -export function unpackNode >(node: U): T | undefined { +export function unpackNode >(node: U): T +export function unpackNode >(node: U): T | undefined +export function unpackNode >(node: U): T | undefined { if (node === undefined) { return undefined } return (new (classByEtsNode(node))(node as any)) as T } -export function passNode(node: ts.Node): T -export function passNode(node: ts.Node | undefined): T | undefined -export function passNode(node: ts.Node | undefined): T | undefined { +export function passNode(node: ts.Node): T +export function passNode(node: ts.Node | undefined): T | undefined +export function passNode(node: ts.Node | undefined): T | undefined { if (node === undefined) { return undefined } return (node.node as T) ?? throwError('trying to pass non-compatible node') } -export function unpackNodeArray >(nodes: readonly U[]): ts.NodeArray -export function unpackNodeArray >(nodes: readonly U[] | undefined): ts.NodeArray | undefined -export function unpackNodeArray >(nodes: readonly U[] | undefined): ts.NodeArray | undefined { - return nodes?.map((node: U) => unpackNode(node)) as ReadonlyArray > as ts.NodeArray +export function unpackNodeArray >(nodes: readonly U[]): ts.NodeArray +export function unpackNodeArray >(nodes: readonly U[] | undefined): ts.NodeArray | undefined +export function unpackNodeArray >(nodes: readonly U[] | undefined): ts.NodeArray | undefined { + return nodes?.map((node: U) => unpackNode(node)) as ReadonlyArray > as ts.NodeArray } -export function passNodeArray(nodes: readonly ts.Node[]): T[] -export function passNodeArray(nodes: readonly ts.Node[] | undefined): T[] | undefined -export function passNodeArray(nodes: readonly ts.Node[] | undefined): T[] | undefined { +export function passNodeArray(nodes: readonly ts.Node[]): T[] +export function passNodeArray(nodes: readonly ts.Node[] | undefined): T[] | undefined +export function passNodeArray(nodes: readonly ts.Node[] | undefined): T[] | undefined { return nodes?.map((node: ts.Node) => passNode(node)) } diff --git a/arkoala-arkts/libarkts/src/ts-api/utilities/public.ts b/arkoala-arkts/libarkts/src/ts-api/utilities/public.ts index ffc2a6f475e5aec33c1465b097a82b467719baab..85d666f55fd8bb293c1d92f5385681b06ba95a69 100644 --- a/arkoala-arkts/libarkts/src/ts-api/utilities/public.ts +++ b/arkoala-arkts/libarkts/src/ts-api/utilities/public.ts @@ -13,17 +13,13 @@ * limitations under the License. */ -import global from "../../arkts-api/static/global" +import { global } from "../../arkts-api/static/global" import { throwError } from "../../utils" import * as ts from "../." -import * as arkts from "../../arkts-api" -import { KNativePointer, withString, withStringArray, withStringResult } from "@koalaui/interop" +import { KNativePointer, nullptr } from "@koalaui/interop" +import { unpackNonNullableNode } from "../../arkts-api" -import { proceedToState } from "../../arkts-api/utilities/public" -export { proceedToState } - -import { startChecker } from "../../arkts-api/utilities/public" -export { startChecker } +export { proceedToState, startChecker } from "../../arkts-api" // TODO: like in arkts utils export function getDecl(node: ts.Node): ts.Node | undefined { @@ -32,18 +28,18 @@ export function getDecl(node: ts.Node): ts.Node | undefined { } let decl: KNativePointer = node.node.peer decl = global.es2panda._AstNodeVariableConst(global.context, decl) - if (decl === arkts.nullptr) { + if (decl === nullptr) { return undefined } decl = global.es2panda._VariableDeclaration(global.context, decl) - if (decl === arkts.nullptr) { + if (decl === nullptr) { return undefined } decl = global.es2panda._DeclNode(global.context, decl) - if (decl === arkts.nullptr) { + if (decl === nullptr) { return undefined } - return ts.unpackNode(arkts.unpackNonNullableNode(decl)) + return ts.unpackNode(unpackNonNullableNode(decl)) } // TODO: like in arkts utils @@ -52,8 +48,8 @@ export function getOriginalNode(node: ts.Node): ts.Node { // TODO: fix this throwError('there is no arkts pair of ts node (unable to getOriginalNode)') } - if (node.node.originalPeer === arkts.nullptr) { + if (node.node.originalPeer === nullptr) { return node } - return ts.unpackNode(arkts.unpackNonNullableNode(node.node.originalPeer)) + return ts.unpackNode(unpackNonNullableNode(node.node.originalPeer)) } diff --git a/arkoala-arkts/libarkts/src/ts-api/visitor/visitor.ts b/arkoala-arkts/libarkts/src/ts-api/visitor/visitor.ts index 7790966af7a410f8c22d8e2e03c8c1f975133c8d..76c81da9b11bec5e594dda2e2a4fc076caa7758e 100644 --- a/arkoala-arkts/libarkts/src/ts-api/visitor/visitor.ts +++ b/arkoala-arkts/libarkts/src/ts-api/visitor/visitor.ts @@ -1,4 +1,18 @@ -import global from "../../arkts-api/static/global" +/* + * Copyright (c) 2022-2023 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 { throwError } from "../../utils" import * as ts from "../." diff --git a/arkoala-arkts/libarkts/src/utils.ts b/arkoala-arkts/libarkts/src/utils.ts index eef3d501f5327118d7c2702312de2db84b28e59d..20dc342e51b19b53c6f01577fd839c34342cb171 100644 --- a/arkoala-arkts/libarkts/src/utils.ts +++ b/arkoala-arkts/libarkts/src/utils.ts @@ -20,4 +20,8 @@ export function throwError(error: string): never { export function withWarning(value: T, message: string): T { console.warn(message) return value -} \ No newline at end of file +} + +export function isNumber(value: any): value is number { + return typeof value === `number` +} diff --git a/arkoala-arkts/libarkts/test/test-util.ts b/arkoala-arkts/libarkts/test/test-util.ts index 0898cad4b64466f21628904712067830b897fb88..3d85b1ea1faf5f8514ef64a04c61778fa15c053a 100644 --- a/arkoala-arkts/libarkts/test/test-util.ts +++ b/arkoala-arkts/libarkts/test/test-util.ts @@ -13,7 +13,7 @@ * limitations under the License. */ -import global from "../src/arkts-api/static/global" +import { global } from "../src/arkts-api/static/global" import * as ts from "../src/ts-api" import * as arkts from "../src/arkts-api"