From 324341332239d8535631cb270082ec984e3bd7fd Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Fri, 27 Jun 2025 16:36:45 +0300 Subject: [PATCH 01/20] Prototype --- .../libarkts/src/arkts-api/CachingPlugins.ts | 474 ++++++++++++++++++ ui2abc/libarkts/src/plugin-utils.ts | 8 + 2 files changed, 482 insertions(+) create mode 100644 ui2abc/libarkts/src/arkts-api/CachingPlugins.ts diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts new file mode 100644 index 000000000..6d4de8a2c --- /dev/null +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -0,0 +1,474 @@ +/* + * Copyright (c) 2025 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 { AstNode } from './peers/AstNode' +import { global } from './static/global' +import { Es2pandaAstNodeType } from '../generated/Es2pandaEnums' +import { factory } from './factory/nodeFactory' +import { + BlockStatement, + ClassDeclaration, + ClassDefinition, + ClassStaticBlock, + ETSPrimitiveType, + ETSTypeReference, + ETSTypeReferencePart, + FunctionDeclaration, + FunctionExpression, + Identifier, + isBlockStatement, + isClassDeclaration, + isClassDefinition, + isClassStaticBlock, + isETSPrimitiveType, + isETSTypeReference, + isETSTypeReferencePart, + isFunctionDeclaration, + isFunctionExpression, + isIdentifier, + isMethodDefinition, + isReturnStatement, + isScriptFunction, + isStringLiteral, + MethodDefinition, + ReturnStatement, + ScriptFunction, + StringLiteral +} from '../generated' + +interface AstNodeData { + type: Es2pandaAstNodeType, + stringData?: Record + booleanData?: Record + numericData?: Record + nodeData?: Record + nodeArrayData?: Record +} + +export type MaybeAstNodeData = AstNodeData | undefined +export type MaybeAstNode = AstNode | undefined + +function extractBlockStatement(extractor: ExtractingVisitor, node: BlockStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, + nodeArrayData: { + statements: extractor.arrayVisitor(node.statements), + }, + } +} + +function buildBlockStatement(builder: BuildingVisitor, node: AstNodeData): BlockStatement { + return factory.createBlockStatement( + builder.arrayVisitor(node.nodeArrayData!.statements) + ) +} + +function extractFunctionDeclaration(extractor: ExtractingVisitor, node: FunctionDeclaration): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, + nodeData: { + function: extractor.visitor(node.function), + }, + nodeArrayData: { + annotations: extractor.arrayVisitor(node.annotations), + }, + booleanData: { + isAnonymous: node.isAnonymous, + }, + } +} + +function buildFunctionDeclaration(builder: BuildingVisitor, node: AstNodeData): FunctionDeclaration { + return factory.createFunctionDeclaration( + builder.visitor(node.nodeData!.function), + builder.arrayVisitor(node.nodeArrayData!.annotations), + node.booleanData!.isAnonymous, + ) +} + +function extractScriptFunction(extractor: ExtractingVisitor, node: ScriptFunction): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, + nodeData: { + body: extractor.visitor(node.body), + typeParams: extractor.visitor(node.typeParams), + returnTypeAnnotation: extractor.visitor(node.returnTypeAnnotation), + id: extractor.visitor(node.id), + }, + nodeArrayData: { + params: extractor.arrayVisitor(node.params), + annotations: extractor.arrayVisitor(node.annotations), + }, + booleanData: { + hasReceiver: node.hasReceiver, + }, + numericData: { + flags: node.flags, + modifierFlags: node.modifierFlags, + }, + } +} + +function buildScriptFunction(builder: BuildingVisitor, node: AstNodeData): ScriptFunction { + return factory.createScriptFunction( + builder.visitor(node.nodeData!.body), + builder.visitor(node.nodeData!.typeParams), + builder.arrayVisitor(node.nodeArrayData!.params), + builder.visitor(node.nodeData!.returnTypeAnnotation), + node.booleanData!.hasReceiver, + node.numericData!.flags, + node.numericData!.modifierFlags, + builder.visitor(node.nodeData!.id), + builder.arrayVisitor(node.nodeArrayData!.annotations), + ) +} + +function extractIdentifier(extractor: ExtractingVisitor, node: Identifier): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, + stringData: { + name: node.name, + }, + nodeData: { + typeAnnotation: extractor.visitor(node.typeAnnotation), + }, + } +} + +function buildIdentifier(builder: BuildingVisitor, node: AstNodeData): Identifier { + return factory.createIdentifier( + node.stringData!.name, + builder.visitor(node.nodeData!.typeAnnotation), + ) +} + +function extractClassDeclaration(extractor: ExtractingVisitor, node: ClassDeclaration): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, + nodeData: { + definition: extractor.visitor(node.definition), + }, + numericData: { + modifierFlags: node.modifierFlags, + }, + } +} + +function buildClassDeclaration(builder: BuildingVisitor, node: AstNodeData): ClassDeclaration { + return factory.createClassDeclaration( + builder.visitor(node.nodeData!.definition), + node.numericData!.modifierFlags, + ) +} + +function extractClassDefinition(extractor: ExtractingVisitor, node: ClassDefinition): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, + nodeData: { + ident: extractor.visitor(node.ident), + typeParams: extractor.visitor(node.typeParams), + superTypeParams: extractor.visitor(node.superTypeParams), + super: extractor.visitor(node.super), + ctor: undefined, + }, + nodeArrayData: { + implements: extractor.arrayVisitor(node.implements), + body: extractor.arrayVisitor(node.body), + }, + numericData: { + modifiers: node.modifiers, + modifierFlags: node.modifierFlags, + }, + } +} + +function buildClassDefinition(builder: BuildingVisitor, node: AstNodeData): ClassDefinition { + return factory.createClassDefinition( + builder.visitor(node.nodeData!.ident), + builder.visitor(node.nodeData!.typeParams), + builder.visitor(node.nodeData!.superTypeParams), + builder.arrayVisitor(node.nodeArrayData!.implements), + undefined, + builder.visitor(node.nodeData!.super), + builder.arrayVisitor(node.nodeArrayData!.body), + node.numericData!.modifiers, + node.numericData!.modifierFlags, + ) +} + +function extractMethodDefinition(extractor: ExtractingVisitor, node: MethodDefinition): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, + nodeData: { + id: extractor.visitor(node.id), + value: extractor.visitor(node.value), + }, + nodeArrayData: { + overloads: extractor.arrayVisitor(node.overloads), + }, + numericData: { + kind: node.kind, + modifierFlags: node.modifierFlags, + }, + booleanData: { + isComputed: node.isComputed, + }, + } +} + +function buildMethodDefinition(builder: BuildingVisitor, node: AstNodeData): MethodDefinition { + return factory.createMethodDefinition( + node.numericData!.kind, + builder.visitor(node.nodeData!.id), + builder.visitor(node.nodeData!.value), + node.numericData!.modifierFlags, + node.booleanData!.isComputed, + builder.arrayVisitor(node.nodeArrayData!.overloads), + ) +} + +function extractFunctionExpression(extractor: ExtractingVisitor, node: FunctionExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION, + nodeData: { + id: extractor.visitor(node.id), + function: extractor.visitor(node.function), + }, + } +} + +function buildFunctionExpression(builder: BuildingVisitor, node: AstNodeData): FunctionExpression { + return factory.createFunctionExpression( + builder.visitor(node.nodeData!.id), + builder.visitor(node.nodeData!.function), + ) +} + +function extractETSPrimitiveType(extractor: ExtractingVisitor, node: ETSPrimitiveType): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, + numericData: { + primitiveType: node.primitiveType, + }, + } +} + +function buildETSPrimitiveType(builder: BuildingVisitor, node: AstNodeData): ETSPrimitiveType { + return factory.createETSPrimitiveType( + node.numericData!.primitiveType, + ) +} + +function extractReturnStatement(extractor: ExtractingVisitor, node: ReturnStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, + nodeData: { + argument: extractor.visitor(node.argument), + }, + } +} + +function buildReturnStatement(builder: BuildingVisitor, node: AstNodeData): ReturnStatement { + return factory.createReturnStatement( + builder.visitor(node.nodeData!.argument), + ) +} + +function extractStringLiteral(extractor: ExtractingVisitor, node: StringLiteral): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, + stringData: { + str: node.str, + }, + } +} + +function buildStringLiteral(builder: BuildingVisitor, node: AstNodeData): StringLiteral { + return factory.createStringLiteral( + node.stringData!.str, + ) +} + +function extractETSTypeReference(extractor: ExtractingVisitor, node: ETSTypeReference): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, + nodeData: { + part: extractor.visitor(node.part), + }, + } +} + +function buildETSTypeReference(builder: BuildingVisitor, node: AstNodeData): ETSTypeReference { + return factory.createETSTypeReference( + builder.visitor(node.nodeData!.part), + ) +} + +function extractETSTypeReferencePart(extractor: ExtractingVisitor, node: ETSTypeReferencePart): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART, + nodeData: { + name: extractor.visitor(node.name), + typeParams: extractor.visitor(node.typeParams), + previous: extractor.visitor(node.previous), + }, + } +} + +function buildETSTypeReferencePart(builder: BuildingVisitor, node: AstNodeData): ETSTypeReferencePart { + return factory.createETSTypeReferencePart( + builder.visitor(node.nodeData!.name), + builder.visitor(node.nodeData!.typeParams), + builder.visitor(node.nodeData!.previous), + ) +} + +function extractClassStaticBlock(extractor: ExtractingVisitor, node: ClassStaticBlock): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, + nodeData: { + function: extractor.visitor(node.function), + }, + stringData: { + name: node.name, + }, + } +} + +function buildClassStaticBlock(builder: BuildingVisitor, node: AstNodeData): ClassStaticBlock { + return ClassStaticBlock.createClassStaticBlock( + factory.createFunctionExpression( + factory.createIdentifier(node.stringData!.name), + builder.visitor(node.nodeData!.function), + ), + ) +} + +export class ExtractingVisitor { + arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { + return nodes.map(node => this.visitor(node)) + } + + visitor(node: MaybeAstNode): MaybeAstNodeData { + if (!node) { + return undefined + } + if (isBlockStatement(node)) { + return extractBlockStatement(this, node) + } + if (isFunctionDeclaration(node)) { + return extractFunctionDeclaration(this, node) + } + if (isScriptFunction(node)) { + return extractScriptFunction(this, node) + } + if (isIdentifier(node)) { + return extractIdentifier(this, node) + } + if (isClassDeclaration(node)) { + return extractClassDeclaration(this, node) + } + if (isClassDefinition(node)) { + return extractClassDefinition(this, node) + } + if (isMethodDefinition(node)) { + return extractMethodDefinition(this, node) + } + if (isFunctionExpression(node)) { + return extractFunctionExpression(this, node) + } + if (isETSPrimitiveType(node)) { + return extractETSPrimitiveType(this, node) + } + if (isReturnStatement(node)) { + return extractReturnStatement(this, node) + } + if (isStringLiteral(node)) { + return extractStringLiteral(this, node) + } + if (isETSTypeReference(node)) { + return extractETSTypeReference(this, node) + } + if (isETSTypeReferencePart(node)) { + return extractETSTypeReferencePart(this, node) + } + if (isClassStaticBlock(node)) { + return extractClassStaticBlock(this, node) + } + const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) + throw new Error( + `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` + ) + } +} + +export class BuildingVisitor { + arrayVisitor(nodes: MaybeAstNodeData[]): T[] + arrayVisitor(nodes: MaybeAstNodeData[]): MaybeAstNode[] { + return nodes.map(node => this.visitor(node)) + } + + visitor(node: MaybeAstNodeData): T + visitor(node: MaybeAstNodeData): MaybeAstNode { + if (!node) { + return undefined + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT) { + return buildBlockStatement(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION) { + return buildFunctionDeclaration(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION) { + return buildScriptFunction(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER) { + return buildIdentifier(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION) { + return buildClassDeclaration(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION) { + return buildClassDefinition(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION) { + return buildMethodDefinition(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION) { + return buildFunctionExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE) { + return buildETSPrimitiveType(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT) { + return buildReturnStatement(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL) { + return buildStringLiteral(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE) { + return buildETSTypeReference(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART) { + return buildETSTypeReferencePart(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK) { + return buildClassStaticBlock(this, node) + } + throw new Error( + `Cannot build node for ${Es2pandaAstNodeType[node.type]}` + ) + } +} diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index 8ac746a40..638d45adf 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -78,6 +78,14 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp // Run some common plugins that should be run after plugin usage and depends on the current state stateSpecificPostFilters(program, options.state) + // For oveloads, set additional pointer to base overload to fix AST + setBaseOverloads(ast) + + //console.log(ast.dumpJson()) + const astData = new ExtractingVisitor().visitor(ast) + const builtAst = new BuildingVisitor().visitor(astData) as ETSModule + updateETSModuleByStatements(ast as ETSModule, builtAst.statements) + // Update internal import information based on import modification by plugin importStorage.update() -- Gitee From 5903ac7a7215380133f7ed0f487011cc326e11da Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Tue, 24 Jun 2025 14:29:42 +0300 Subject: [PATCH 02/20] more --- .../libarkts/src/arkts-api/CachingPlugins.ts | 328 +++++++++++++++++- 1 file changed, 326 insertions(+), 2 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 6d4de8a2c..81b33a15d 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -15,37 +15,59 @@ import { AstNode } from './peers/AstNode' import { global } from './static/global' -import { Es2pandaAstNodeType } from '../generated/Es2pandaEnums' +import { Es2pandaAstNodeType, Es2pandaModifierFlags } from '../generated/Es2pandaEnums' import { factory } from './factory/nodeFactory' import { + AssignmentExpression, BlockStatement, + CallExpression, ClassDeclaration, ClassDefinition, + ClassProperty, ClassStaticBlock, + ETSParameterExpression, ETSPrimitiveType, ETSTypeReference, ETSTypeReferencePart, + ExpressionStatement, FunctionDeclaration, FunctionExpression, Identifier, + isAssignmentExpression, isBlockStatement, + isCallExpression, isClassDeclaration, isClassDefinition, + isClassProperty, isClassStaticBlock, + isETSParameterExpression, isETSPrimitiveType, isETSTypeReference, isETSTypeReferencePart, + isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isIdentifier, + isMemberExpression, isMethodDefinition, + isNumberLiteral, isReturnStatement, isScriptFunction, isStringLiteral, + isSuperExpression, + isTSEnumDeclaration, + isTSEnumMember, + isTSTypeParameterInstantiation, + MemberExpression, MethodDefinition, + NumberLiteral, ReturnStatement, ScriptFunction, - StringLiteral + StringLiteral, + SuperExpression, + TSEnumDeclaration, + TSEnumMember, + TSTypeParameterInstantiation } from '../generated' interface AstNodeData { @@ -356,6 +378,242 @@ function buildClassStaticBlock(builder: BuildingVisitor, node: AstNodeData): Cla ) } +function extractTSEnumDeclaration(extractor: ExtractingVisitor, node: TSEnumDeclaration): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION, + nodeData: { + key: extractor.visitor(node.key), + }, + nodeArrayData: { + members: extractor.arrayVisitor(node.members), + }, + booleanData: { + isConst: node.isConst, + isStatic: node.isStatic, + isDeclare: !!(node.modifierFlags & Es2pandaModifierFlags.MODIFIER_FLAGS_DECLARE), + }, + } +} + +function buildTSEnumDeclaration(builder: BuildingVisitor, node: AstNodeData): TSEnumDeclaration { + return TSEnumDeclaration.createTSEnumDeclaration( + builder.visitor(node.nodeData!.key), + builder.arrayVisitor(node.nodeArrayData!.members), + node.booleanData!.isConst, + node.booleanData!.isStatic, + node.booleanData!.isDeclare, + ) +} + +function extractTSEnumMember(extractor: ExtractingVisitor, node: TSEnumMember): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER, + nodeData: { + key: extractor.visitor(node.key), + init: extractor.visitor(node.init), + }, + booleanData: { + isGenerated: node.isGenerated, + }, + } +} + +function buildTSEnumMember(builder: BuildingVisitor, node: AstNodeData): TSEnumMember { + return factory.createTSEnumMember( + builder.visitor(node.nodeData!.key), + builder.visitor(node.nodeData!.init), + node.booleanData!.isGenerated, + ) +} + +function extractNumberLiteral(extractor: ExtractingVisitor, node: NumberLiteral): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, + stringData: { + str: node.str, + }, + } +} + +function buildNumberLiteral(builder: BuildingVisitor, node: AstNodeData): NumberLiteral { + return factory.createNumberLiteral( + Number(node.stringData!.str), + ) +} + +function extractTSTypeParameterInstantiation(extractor: ExtractingVisitor, node: TSTypeParameterInstantiation): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION, + nodeArrayData: { + params: extractor.arrayVisitor(node.params), + }, + } +} + +function buildTSTypeParameterInstantiation(builder: BuildingVisitor, node: AstNodeData): TSTypeParameterInstantiation { + return factory.createTSTypeParameterInstantiation( + builder.arrayVisitor(node.nodeArrayData!.params), + ) +} + +function extractClassProperty(extractor: ExtractingVisitor, node: ClassProperty): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, + nodeData: { + key: extractor.visitor(node.key), + value: extractor.visitor(node.value), + typeAnnotation: extractor.visitor(node.typeAnnotation), + }, + nodeArrayData: { + annotations: extractor.arrayVisitor(node.annotations), + }, + numericData: { + modifierFlags: node.modifierFlags, + }, + booleanData: { + isComputed: node.isComputed, + }, + } +} + +function buildClassProperty(builder: BuildingVisitor, node: AstNodeData): ClassProperty { + return factory.createClassProperty( + builder.visitor(node.nodeData!.key), + builder.visitor(node.nodeData!.value), + builder.visitor(node.nodeData!.typeAnnotation), + node.numericData!.modifierFlags, + node.booleanData!.isComputed, + builder.visitor(node.nodeData!.annotations), + ) +} + +function extractExpressionStatement(extractor: ExtractingVisitor, node: ExpressionStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, + nodeData: { + expression: extractor.visitor(node.expression), + }, + } +} + +function buildExpressionStatement(builder: BuildingVisitor, node: AstNodeData): ExpressionStatement { + return factory.createExpressionStatement( + builder.visitor(node.nodeData!.expression), + ) +} + +function extractCallExpression(extractor: ExtractingVisitor, node: CallExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, + nodeData: { + callee: extractor.visitor(node.callee), + typeParams: extractor.visitor(node.typeParams), + trailingBlock: extractor.visitor(node.trailingBlock), + }, + nodeArrayData: { + arguments: extractor.arrayVisitor(node.arguments), + }, + booleanData: { + isOptional: node.isOptional, + hasTrailingComma: node.hasTrailingComma, + }, + } +} + +function buildCallExpression(builder: BuildingVisitor, node: AstNodeData): CallExpression { + return factory.createCallExpression( + builder.visitor(node.nodeData!.callee), + builder.arrayVisitor(node.nodeArrayData!.arguments), + builder.visitor(node.nodeData!.typeParams), + node.booleanData!.isOptional, + node.booleanData!.hasTrailingComma, + builder.visitor(node.nodeData!.trailingBlock), + ) +} + +function extractETSParameterExpression(extractor: ExtractingVisitor, node: ETSParameterExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, + nodeData: { + ident: extractor.visitor(node.ident), + initializer: extractor.visitor(node.initializer), + }, + nodeArrayData: { + annotations: extractor.arrayVisitor(node.annotations), + }, + booleanData: { + isOptional: node.isOptional, + }, + } +} + +function buildETSParameterExpression(builder: BuildingVisitor, node: AstNodeData): ETSParameterExpression { + return factory.createETSParameterExpression( + builder.visitor(node.nodeData!.ident), + node.booleanData!.isOptional, + builder.visitor(node.nodeData!.initializer), + builder.arrayVisitor(node.nodeArrayData!.annotations), + ) +} + +function extractSuperExpression(extractor: ExtractingVisitor, node: SuperExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, + } +} + +function buildSuperExpression(builder: BuildingVisitor, node: AstNodeData): SuperExpression { + return factory.createSuperExpression() +} + +function extractAssignmentExpression(extractor: ExtractingVisitor, node: AssignmentExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, + nodeData: { + left: extractor.visitor(node.left), + right: extractor.visitor(node.right), + }, + numericData: { + assignmentOperator: node.operatorType, + }, + } +} + +function buildAssignmentExpression(builder: BuildingVisitor, node: AstNodeData): AssignmentExpression { + return factory.createAssignmentExpression( + builder.visitor(node.nodeData!.left), + builder.visitor(node.nodeData!.right), + node.numericData!.assignmentOperator, + ) +} + +function extractMemberExpression(extractor: ExtractingVisitor, node: MemberExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, + nodeData: { + object: extractor.visitor(node.object), + property: extractor.visitor(node.property), + }, + numericData: { + kind: node.kind, + }, + booleanData: { + isComputed: node.isComputed, + isOptional: node.isOptional, + }, + } +} + +function buildMemberExpression(builder: BuildingVisitor, node: AstNodeData): MemberExpression { + return factory.createMemberExpression( + builder.visitor(node.nodeData!.object), + builder.visitor(node.nodeData!.property), + node.numericData!.kind, + node.booleanData!.isComputed, + node.booleanData!.isOptional, + ) +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -407,6 +665,39 @@ export class ExtractingVisitor { if (isClassStaticBlock(node)) { return extractClassStaticBlock(this, node) } + if (isTSEnumDeclaration(node)) { + return extractTSEnumDeclaration(this, node) + } + if (isTSEnumMember(node)) { + return extractTSEnumMember(this, node) + } + if (isNumberLiteral(node)) { + return extractNumberLiteral(this, node) + } + if (isTSTypeParameterInstantiation(node)) { + return extractTSTypeParameterInstantiation(this, node) + } + if (isClassProperty(node)) { + return extractClassProperty(this, node) + } + if (isExpressionStatement(node)) { + return extractExpressionStatement(this, node) + } + if (isCallExpression(node)) { + return extractCallExpression(this, node) + } + if (isETSParameterExpression(node)) { + return extractETSParameterExpression(this, node) + } + if (isSuperExpression(node)) { + return extractSuperExpression(this, node) + } + if (isAssignmentExpression(node)) { + return extractAssignmentExpression(this, node) + } + if (isMemberExpression(node)) { + return extractMemberExpression(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -467,6 +758,39 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK) { return buildClassStaticBlock(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION) { + return buildTSEnumDeclaration(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER) { + return buildTSEnumMember(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL) { + return buildNumberLiteral(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION) { + return buildTSTypeParameterInstantiation(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY) { + return buildClassProperty(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT) { + return buildExpressionStatement(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION) { + return buildCallExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION) { + return buildETSParameterExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION) { + return buildSuperExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION) { + return buildAssignmentExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION) { + return buildMemberExpression(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) -- Gitee From 724276bc06bcdb2c4047e7aa49149a01c2fb74a4 Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Tue, 24 Jun 2025 15:20:08 +0300 Subject: [PATCH 03/20] to enum --- .../libarkts/src/arkts-api/CachingPlugins.ts | 290 +++++++++++++++++- 1 file changed, 289 insertions(+), 1 deletion(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 81b33a15d..aeedeeb68 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -18,36 +18,46 @@ import { global } from './static/global' import { Es2pandaAstNodeType, Es2pandaModifierFlags } from '../generated/Es2pandaEnums' import { factory } from './factory/nodeFactory' import { + ArrayExpression, AssignmentExpression, + BinaryExpression, BlockStatement, CallExpression, ClassDeclaration, ClassDefinition, ClassProperty, ClassStaticBlock, + ETSNewClassInstanceExpression, ETSParameterExpression, ETSPrimitiveType, ETSTypeReference, ETSTypeReferencePart, ExpressionStatement, + ForUpdateStatement, FunctionDeclaration, FunctionExpression, Identifier, + IfStatement, + isArrayExpression, isAssignmentExpression, + isBinaryExpression, isBlockStatement, isCallExpression, isClassDeclaration, isClassDefinition, isClassProperty, isClassStaticBlock, + isETSNewClassInstanceExpression, isETSParameterExpression, isETSPrimitiveType, isETSTypeReference, isETSTypeReferencePart, isExpressionStatement, + isForUpdateStatement, isFunctionDeclaration, isFunctionExpression, isIdentifier, + isIfStatement, isMemberExpression, isMethodDefinition, isNumberLiteral, @@ -55,9 +65,15 @@ import { isScriptFunction, isStringLiteral, isSuperExpression, + isThisExpression, + isThrowStatement, + isTSArrayType, isTSEnumDeclaration, isTSEnumMember, isTSTypeParameterInstantiation, + isUpdateExpression, + isVariableDeclaration, + isVariableDeclarator, MemberExpression, MethodDefinition, NumberLiteral, @@ -65,9 +81,15 @@ import { ScriptFunction, StringLiteral, SuperExpression, + ThisExpression, + ThrowStatement, + TSArrayType, TSEnumDeclaration, TSEnumMember, - TSTypeParameterInstantiation + TSTypeParameterInstantiation, + UpdateExpression, + VariableDeclaration, + VariableDeclarator } from '../generated' interface AstNodeData { @@ -614,6 +636,206 @@ function buildMemberExpression(builder: BuildingVisitor, node: AstNodeData): Mem ) } +function extractThisExpression(extractor: ExtractingVisitor, node: ThisExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE, + } +} + +function buildThisExpression(builder: BuildingVisitor, node: AstNodeData): ThisExpression { + return factory.createThisExpression() +} + +function extractETSNewClassInstanceExpression(extractor: ExtractingVisitor, node: ETSNewClassInstanceExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION, + nodeData: { + typeRef: extractor.visitor(node.typeRef), + }, + nodeArrayData: { + arguments: extractor.arrayVisitor(node.arguments), + }, + } +} + +function buildETSNewClassInstanceExpression(builder: BuildingVisitor, node: AstNodeData): ETSNewClassInstanceExpression { + return factory.createETSNewClassInstanceExpression( + builder.visitor(node.nodeData!.typeRef), + builder.arrayVisitor(node.nodeArrayData!.arguments), + ) +} + +function extractArrayExpression(extractor: ExtractingVisitor, node: ArrayExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION, + nodeArrayData: { + elements: extractor.arrayVisitor(node.elements), + }, + } +} + +function buildArrayExpression(builder: BuildingVisitor, node: AstNodeData): ArrayExpression { + return factory.createArrayExpression( + builder.arrayVisitor(node.nodeArrayData!.elements), + ) +} + +function extractTSArrayType(extractor: ExtractingVisitor, node: TSArrayType): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE, + nodeData: { + elementType: extractor.visitor(node.elementType), + }, + } +} + +function buildTSArrayType(builder: BuildingVisitor, node: AstNodeData): TSArrayType { + return factory.createTSArrayType( + builder.visitor(node.nodeData!.elementType), + ) +} + +function extractForUpdateStatement(extractor: ExtractingVisitor, node: ForUpdateStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT, + nodeData: { + init: extractor.visitor(node.init), + test: extractor.visitor(node.test), + update: extractor.visitor(node.update), + body: extractor.visitor(node.body), + }, + } +} + +function buildForUpdateStatement(builder: BuildingVisitor, node: AstNodeData): ForUpdateStatement { + return factory.createForUpdateStatement( + builder.visitor(node.nodeData!.init), + builder.visitor(node.nodeData!.test), + builder.visitor(node.nodeData!.update), + builder.visitor(node.nodeData!.body), + ) +} + +function extractVariableDeclaration(extractor: ExtractingVisitor, node: VariableDeclaration): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, + nodeArrayData: { + declarators: extractor.arrayVisitor(node.declarators), + annotations: extractor.arrayVisitor(node.annotations), + }, + numericData: { + kind: node.kind, + }, + } +} + +function buildVariableDeclaration(builder: BuildingVisitor, node: AstNodeData): VariableDeclaration { + return factory.createVariableDeclaration( + node.numericData!.kind, + builder.arrayVisitor(node.nodeArrayData!.declarators), + builder.arrayVisitor(node.nodeArrayData!.annotations), + ) +} + +function extractVariableDeclarator(extractor: ExtractingVisitor, node: VariableDeclarator): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, + nodeData: { + ident: extractor.visitor(node.id), + init: extractor.visitor(node.init), + }, + numericData: { + flag: node.flag, + }, + } +} + +function buildVariableDeclarator(builder: BuildingVisitor, node: AstNodeData): VariableDeclarator { + return factory.createVariableDeclarator( + node.numericData!.flag, + builder.visitor(node.nodeData!.ident), + builder.visitor(node.nodeData!.init), + ) +} + +function extractBinaryExpression(extractor: ExtractingVisitor, node: BinaryExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, + nodeData: { + left: extractor.visitor(node.left), + right: extractor.visitor(node.right), + }, + numericData: { + operatorType: node.operatorType, + }, + } +} + +function buildBinaryExpression(builder: BuildingVisitor, node: AstNodeData): BinaryExpression { + return factory.createBinaryExpression( + builder.visitor(node.nodeData!.left), + builder.visitor(node.nodeData!.right), + node.numericData!.operatorType, + ) +} + +function extractUpdateExpression(extractor: ExtractingVisitor, node: UpdateExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION, + nodeData: { + argument: extractor.visitor(node.argument), + }, + numericData: { + operatorType: node.operatorType, + }, + booleanData: { + isPrefix: node.isPrefix, + }, + } +} + +function buildUpdateExpression(builder: BuildingVisitor, node: AstNodeData): UpdateExpression { + return factory.createUpdateExpression( + builder.visitor(node.nodeData!.argument), + node.numericData!.operatorType, + node.booleanData!.isPrefix, + ) +} + +function extractIfStatment(extractor: ExtractingVisitor, node: IfStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, + nodeData: { + test: extractor.visitor(node.test), + consequent: extractor.visitor(node.consequent), + alternate: extractor.visitor(node.alternate), + }, + } +} + +function buildIfStatement(builder: BuildingVisitor, node: AstNodeData): IfStatement { + return factory.createIfStatement( + builder.visitor(node.nodeData!.test), + builder.visitor(node.nodeData!.consequent), + builder.visitor(node.nodeData!.alternate), + ) +} + +function extractThrowStatement(extractor: ExtractingVisitor, node: ThrowStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT, + nodeData: { + argument: extractor.visitor(node.argument), + }, + } +} + +function buildThrowStatement(builder: BuildingVisitor, node: AstNodeData): ThrowStatement { + return factory.createThrowStatement( + builder.visitor(node.nodeData!.argument), + ) +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -698,6 +920,39 @@ export class ExtractingVisitor { if (isMemberExpression(node)) { return extractMemberExpression(this, node) } + if (isThisExpression(node)) { + return extractThisExpression(this, node) + } + if (isETSNewClassInstanceExpression(node)) { + return extractETSNewClassInstanceExpression(this, node) + } + if (isArrayExpression(node)) { + return extractArrayExpression(this, node) + } + if (isTSArrayType(node)) { + return extractTSArrayType(this, node) + } + if (isForUpdateStatement(node)) { + return extractForUpdateStatement(this, node) + } + if (isVariableDeclaration(node)) { + return extractVariableDeclaration(this, node) + } + if (isVariableDeclarator(node)) { + return extractVariableDeclarator(this, node) + } + if (isBinaryExpression(node)) { + return extractBinaryExpression(this, node) + } + if (isUpdateExpression(node)) { + return extractUpdateExpression(this, node) + } + if (isIfStatement(node)) { + return extractIfStatment(this, node) + } + if (isThrowStatement(node)) { + return extractThrowStatement(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -791,6 +1046,39 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION) { return buildMemberExpression(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE) { + return buildThisExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION) { + return buildETSNewClassInstanceExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION) { + return buildArrayExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE) { + return buildTSArrayType(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT) { + return buildForUpdateStatement(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION) { + return buildVariableDeclaration(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR) { + return buildVariableDeclarator(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION) { + return buildBinaryExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION) { + return buildUpdateExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT) { + return buildIfStatement(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT) { + return buildThrowStatement(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) -- Gitee From 8e8f4ae5cca4870a2a80bd4b1d22e2751ccfc95e Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Tue, 24 Jun 2025 16:01:26 +0300 Subject: [PATCH 04/20] more --- .../libarkts/src/arkts-api/CachingPlugins.ts | 119 +++++++++++++++++- ui2abc/libarkts/src/plugin-utils.ts | 7 +- 2 files changed, 124 insertions(+), 2 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index aeedeeb68..b10f6bd64 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -15,18 +15,20 @@ import { AstNode } from './peers/AstNode' import { global } from './static/global' -import { Es2pandaAstNodeType, Es2pandaModifierFlags } from '../generated/Es2pandaEnums' +import { Es2pandaAstNodeType, Es2pandaModifierFlags, Es2pandaModuleFlag } from '../generated/Es2pandaEnums' import { factory } from './factory/nodeFactory' import { ArrayExpression, AssignmentExpression, BinaryExpression, BlockStatement, + BreakStatement, CallExpression, ClassDeclaration, ClassDefinition, ClassProperty, ClassStaticBlock, + ETSModule, ETSNewClassInstanceExpression, ETSParameterExpression, ETSPrimitiveType, @@ -42,11 +44,13 @@ import { isAssignmentExpression, isBinaryExpression, isBlockStatement, + isBreakStatement, isCallExpression, isClassDeclaration, isClassDefinition, isClassProperty, isClassStaticBlock, + isETSModule, isETSNewClassInstanceExpression, isETSParameterExpression, isETSPrimitiveType, @@ -65,6 +69,8 @@ import { isScriptFunction, isStringLiteral, isSuperExpression, + isSwitchCaseStatement, + isSwitchStatement, isThisExpression, isThrowStatement, isTSArrayType, @@ -81,6 +87,8 @@ import { ScriptFunction, StringLiteral, SuperExpression, + SwitchCaseStatement, + SwitchStatement, ThisExpression, ThrowStatement, TSArrayType, @@ -104,6 +112,38 @@ interface AstNodeData { export type MaybeAstNodeData = AstNodeData | undefined export type MaybeAstNode = AstNode | undefined +function ETSModuleFlag(node: ETSModule): number { + const res = + (node.isETSScript ? Es2pandaModuleFlag.MODULE_FLAG_ETSSCRIPT : 0) + + (node.isNamespace ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE : 0) + + (node.isNamespaceChainLastNode ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE_CHAIN_LAST_NODE : 0) + return res +} + +function extractETSModule(extractor: ExtractingVisitor, node: ETSModule): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, + nodeArrayData: { + statements: extractor.arrayVisitor(node.statements), + }, + nodeData: { + ident: extractor.visitor(node.ident), + }, + numericData: { + flag: ETSModuleFlag(node), + }, + } +} + +function buildETSModule(builder: BuildingVisitor, node: AstNodeData): ETSModule { + return ETSModule.createETSModule( + builder.arrayVisitor(node.nodeArrayData!.statements), + builder.visitor(node.nodeData!.ident), + node.numericData!.flag, + undefined, + ) +} + function extractBlockStatement(extractor: ExtractingVisitor, node: BlockStatement): AstNodeData { return { type: Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, @@ -836,6 +876,59 @@ function buildThrowStatement(builder: BuildingVisitor, node: AstNodeData): Throw ) } +function extractSwitchStatement(extractor: ExtractingVisitor, node: SwitchStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT, + nodeData: { + discriminant: extractor.visitor(node.discriminant), + }, + nodeArrayData: { + cases: extractor.arrayVisitor(node.cases), + }, + } +} + +function buildSwitchStatement(builder: BuildingVisitor, node: AstNodeData): SwitchStatement { + return factory.createSwitchStatement( + builder.visitor(node.nodeData!.discriminant), + builder.arrayVisitor(node.nodeArrayData!.cases), + ) +} + +function extractSwitchCaseStatement(extractor: ExtractingVisitor, node: SwitchCaseStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT, + nodeData: { + test: extractor.visitor(node.test), + }, + nodeArrayData: { + consequent: extractor.arrayVisitor(node.consequent), + }, + } +} + +function buildSwitchCaseStatement(builder: BuildingVisitor, node: AstNodeData): SwitchCaseStatement { + return factory.createSwitchCaseStatement( + builder.visitor(node.nodeData!.test), + builder.arrayVisitor(node.nodeArrayData!.consequent), + ) +} + +function extractBreakStatement(extractor: ExtractingVisitor, node: BreakStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT, + nodeData: { + ident: extractor.visitor(node.ident), + }, + } +} + +function buildBreakStatement(builder: BuildingVisitor, node: AstNodeData): BreakStatement { + return factory.createBreakStatement( + builder.visitor(node.nodeData!.ident), + ) +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -845,6 +938,9 @@ export class ExtractingVisitor { if (!node) { return undefined } + if (isETSModule(node)) { + return extractETSModule(this, node) + } if (isBlockStatement(node)) { return extractBlockStatement(this, node) } @@ -953,6 +1049,15 @@ export class ExtractingVisitor { if (isThrowStatement(node)) { return extractThrowStatement(this, node) } + if (isSwitchStatement(node)) { + return extractSwitchStatement(this, node) + } + if (isSwitchCaseStatement(node)) { + return extractSwitchCaseStatement(this, node) + } + if (isBreakStatement(node)) { + return extractBreakStatement(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -971,6 +1076,9 @@ export class BuildingVisitor { if (!node) { return undefined } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) { + return buildETSModule(this, node) + } if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT) { return buildBlockStatement(this, node) } @@ -1079,6 +1187,15 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT) { return buildThrowStatement(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT) { + return buildSwitchStatement(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT) { + return buildSwitchCaseStatement(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT) { + return buildBreakStatement(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index 638d45adf..2998412f5 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -81,10 +81,15 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp // For oveloads, set additional pointer to base overload to fix AST setBaseOverloads(ast) - //console.log(ast.dumpJson()) + console.log("BEFORE") + console.log(ast.dumpSrc()) + console.log(ast.dumpJson()) const astData = new ExtractingVisitor().visitor(ast) const builtAst = new BuildingVisitor().visitor(astData) as ETSModule updateETSModuleByStatements(ast as ETSModule, builtAst.statements) + console.log("AFTER") + console.log(ast.dumpSrc()) + console.log(ast.dumpJson()) // Update internal import information based on import modification by plugin importStorage.update() -- Gitee From 06961bdf7873a2c52ebb5840ec9a71ddc17a5937 Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Tue, 24 Jun 2025 17:14:40 +0300 Subject: [PATCH 05/20] more --- .../libarkts/src/arkts-api/CachingPlugins.ts | 138 +++++++++++++++++- ui2abc/libarkts/src/plugin-utils.ts | 18 +-- 2 files changed, 146 insertions(+), 10 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index b10f6bd64..e38086eaa 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -15,7 +15,7 @@ import { AstNode } from './peers/AstNode' import { global } from './static/global' -import { Es2pandaAstNodeType, Es2pandaModifierFlags, Es2pandaModuleFlag } from '../generated/Es2pandaEnums' +import { Es2pandaAstNodeType, Es2pandaImportKinds, Es2pandaModifierFlags, Es2pandaModuleFlag } from '../generated/Es2pandaEnums' import { factory } from './factory/nodeFactory' import { ArrayExpression, @@ -28,6 +28,8 @@ import { ClassDefinition, ClassProperty, ClassStaticBlock, + ConditionalExpression, + ETSImportDeclaration, ETSModule, ETSNewClassInstanceExpression, ETSParameterExpression, @@ -40,6 +42,7 @@ import { FunctionExpression, Identifier, IfStatement, + ImportSpecifier, isArrayExpression, isAssignmentExpression, isBinaryExpression, @@ -50,6 +53,8 @@ import { isClassDefinition, isClassProperty, isClassStaticBlock, + isConditionalExpression, + isETSImportDeclaration, isETSModule, isETSNewClassInstanceExpression, isETSParameterExpression, @@ -62,6 +67,7 @@ import { isFunctionExpression, isIdentifier, isIfStatement, + isImportSpecifier, isMemberExpression, isMethodDefinition, isNumberLiteral, @@ -74,9 +80,11 @@ import { isThisExpression, isThrowStatement, isTSArrayType, + isTSAsExpression, isTSEnumDeclaration, isTSEnumMember, isTSTypeParameterInstantiation, + isUnaryExpression, isUpdateExpression, isVariableDeclaration, isVariableDeclarator, @@ -92,9 +100,11 @@ import { ThisExpression, ThrowStatement, TSArrayType, + TSAsExpression, TSEnumDeclaration, TSEnumMember, TSTypeParameterInstantiation, + UnaryExpression, UpdateExpression, VariableDeclaration, VariableDeclarator @@ -929,6 +939,102 @@ function buildBreakStatement(builder: BuildingVisitor, node: AstNodeData): Break ) } +function extractETSImportDeclaration(extractor: ExtractingVisitor, node: ETSImportDeclaration): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, + nodeData: { + importPath: extractor.visitor(node.source), + }, + nodeArrayData: { + specifiers: extractor.arrayVisitor(node.specifiers), + }, + } +} + +function buildETSImportDeclaration(builder: BuildingVisitor, node: AstNodeData): ETSImportDeclaration { + return factory.createETSImportDeclaration( + builder.visitor(node.nodeData!.importPath), + builder.arrayVisitor(node.nodeArrayData!.specifiers), + Es2pandaImportKinds.IMPORT_KINDS_ALL, + ) +} + +function extractImportSpecifier(extractor: ExtractingVisitor, node: ImportSpecifier): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, + nodeData: { + imported: extractor.visitor(node.imported), + local: extractor.visitor(node.local), + }, + } +} + +function buildImportSpecifier(builder: BuildingVisitor, node: AstNodeData): ImportSpecifier { + return factory.createImportSpecifier( + builder.visitor(node.nodeData!.imported), + builder.visitor(node.nodeData!.local), + ) +} + +function extractConditionalExpression(extractor: ExtractingVisitor, node: ConditionalExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION, + nodeData: { + test: extractor.visitor(node.test), + consequent: extractor.visitor(node.consequent), + alternate: extractor.visitor(node.alternate), + }, + } +} + +function buildConditionalExpression(builder: BuildingVisitor, node: AstNodeData): ConditionalExpression { + return factory.createConditionalExpression( + builder.visitor(node.nodeData!.test), + builder.visitor(node.nodeData!.consequent), + builder.visitor(node.nodeData!.alternate), + ) +} + +function extractUnaryExpression(extractor: ExtractingVisitor, node: UnaryExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION, + nodeData: { + argument: extractor.visitor(node.argument), + }, + numericData: { + unaryOperator: node.operatorType, + }, + } +} + +function buildUnaryExpression(builder: BuildingVisitor, node: AstNodeData): UnaryExpression { + return factory.createUnaryExpression( + builder.visitor(node.nodeData!.argument), + node.numericData!.unaryOperator, + ) +} + +function extractTSAsExpression(extractor: ExtractingVisitor, node: TSAsExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION, + nodeData: { + expr: extractor.visitor(node.expr), + typeAnnotation: extractor.visitor(node.typeAnnotation), + }, + booleanData: { + isConst: node.isConst, + }, + } +} + +function buildTSAsExpression(builder: BuildingVisitor, node: AstNodeData): TSAsExpression { + return factory.createTSAsExpression( + builder.visitor(node.nodeData!.expr), + builder.visitor(node.nodeData!.typeAnnotation), + node.booleanData!.isConst, + ) +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -1058,6 +1164,21 @@ export class ExtractingVisitor { if (isBreakStatement(node)) { return extractBreakStatement(this, node) } + if (isETSImportDeclaration(node)) { + return extractETSImportDeclaration(this, node) + } + if (isImportSpecifier(node)) { + return extractImportSpecifier(this, node) + } + if (isConditionalExpression(node)) { + return extractConditionalExpression(this, node) + } + if (isUnaryExpression(node)) { + return extractUnaryExpression(this, node) + } + if (isTSAsExpression(node)) { + return extractTSAsExpression(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -1196,6 +1317,21 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT) { return buildBreakStatement(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION) { + return buildETSImportDeclaration(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER) { + return buildImportSpecifier(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION) { + return buildConditionalExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION) { + return buildUnaryExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION) { + return buildTSAsExpression(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index 2998412f5..503e78f93 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -81,15 +81,15 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp // For oveloads, set additional pointer to base overload to fix AST setBaseOverloads(ast) - console.log("BEFORE") - console.log(ast.dumpSrc()) - console.log(ast.dumpJson()) - const astData = new ExtractingVisitor().visitor(ast) - const builtAst = new BuildingVisitor().visitor(astData) as ETSModule - updateETSModuleByStatements(ast as ETSModule, builtAst.statements) - console.log("AFTER") - console.log(ast.dumpSrc()) - console.log(ast.dumpJson()) + try { + console.log("BEFORE") + const astData = new ExtractingVisitor().visitor(ast) + const builtAst = new BuildingVisitor().visitor(astData) as ETSModule + // updateETSModuleByStatements(ast as ETSModule, builtAst.statements) + console.log("AFTER") + } catch (e) { + console.log("ERROR", e) + } // Update internal import information based on import modification by plugin importStorage.update() -- Gitee From 3de7335995d1965b22837971504f8de5f343ba96 Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Tue, 24 Jun 2025 17:47:59 +0300 Subject: [PATCH 06/20] more --- .../libarkts/src/arkts-api/CachingPlugins.ts | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index e38086eaa..8a17bb191 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -18,6 +18,7 @@ import { global } from './static/global' import { Es2pandaAstNodeType, Es2pandaImportKinds, Es2pandaModifierFlags, Es2pandaModuleFlag } from '../generated/Es2pandaEnums' import { factory } from './factory/nodeFactory' import { + AnnotationUsage, ArrayExpression, AssignmentExpression, BinaryExpression, @@ -43,6 +44,7 @@ import { Identifier, IfStatement, ImportSpecifier, + isAnnotationUsage, isArrayExpression, isAssignmentExpression, isBinaryExpression, @@ -70,6 +72,7 @@ import { isImportSpecifier, isMemberExpression, isMethodDefinition, + isNullLiteral, isNumberLiteral, isReturnStatement, isScriptFunction, @@ -85,11 +88,13 @@ import { isTSEnumMember, isTSTypeParameterInstantiation, isUnaryExpression, + isUndefinedLiteral, isUpdateExpression, isVariableDeclaration, isVariableDeclarator, MemberExpression, MethodDefinition, + NullLiteral, NumberLiteral, ReturnStatement, ScriptFunction, @@ -105,6 +110,7 @@ import { TSEnumMember, TSTypeParameterInstantiation, UnaryExpression, + UndefinedLiteral, UpdateExpression, VariableDeclaration, VariableDeclarator @@ -1035,6 +1041,45 @@ function buildTSAsExpression(builder: BuildingVisitor, node: AstNodeData): TSAsE ) } +function extractUndefinedLiteral(extractor: ExtractingVisitor, node: UndefinedLiteral): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL, + } +} + +function buildUndefinedLiteral(builder: BuildingVisitor, node: AstNodeData): UndefinedLiteral { + return factory.createUndefinedLiteral() +} + +function extractNullLiteral(extractor: ExtractingVisitor, node: NullLiteral): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL, + } +} + +function buildNullLiteral(builder: BuildingVisitor, node: AstNodeData): NullLiteral { + return factory.createNullLiteral() +} + +function extractAnnotationUsage(extractor: ExtractingVisitor, node: AnnotationUsage): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, + nodeData: { + expr: extractor.visitor(node.expr), + }, + nodeArrayData: { + properties: extractor.arrayVisitor(node.properties), + }, + } +} + +function buildAnnotationUsage(builder: BuildingVisitor, node: AstNodeData): AnnotationUsage { + return factory.createAnnotationUsage( + builder.visitor(node.nodeData!.expr), + builder.arrayVisitor(node.nodeArrayData!.properties), + ) +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -1179,6 +1224,15 @@ export class ExtractingVisitor { if (isTSAsExpression(node)) { return extractTSAsExpression(this, node) } + if (isUndefinedLiteral(node)) { + return extractUndefinedLiteral(this, node) + } + if (isNullLiteral(node)) { + return extractNullLiteral(this, node) + } + if (isAnnotationUsage(node)) { + return extractAnnotationUsage(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -1332,6 +1386,15 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION) { return buildTSAsExpression(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL) { + return buildUndefinedLiteral(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL) { + return buildNullLiteral(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE) { + return buildAnnotationUsage(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) -- Gitee From f25c390be8d091a3afd4817162d888ac6120dfcc Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Wed, 25 Jun 2025 09:11:11 +0300 Subject: [PATCH 07/20] more --- .../libarkts/src/arkts-api/CachingPlugins.ts | 76 ++++++++++++++----- .../libarkts/src/arkts-api/ImportStorage.ts | 2 +- ui2abc/libarkts/src/plugin-utils.ts | 13 +++- 3 files changed, 69 insertions(+), 22 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 8a17bb191..4d9351b1d 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -86,6 +86,7 @@ import { isTSAsExpression, isTSEnumDeclaration, isTSEnumMember, + isTSTypeAliasDeclaration, isTSTypeParameterInstantiation, isUnaryExpression, isUndefinedLiteral, @@ -108,6 +109,7 @@ import { TSAsExpression, TSEnumDeclaration, TSEnumMember, + TSTypeAliasDeclaration, TSTypeParameterInstantiation, UnaryExpression, UndefinedLiteral, @@ -146,6 +148,7 @@ function extractETSModule(extractor: ExtractingVisitor, node: ETSModule): AstNod ident: extractor.visitor(node.ident), }, numericData: { + // TODO: inconsistency flag: ETSModuleFlag(node), }, } @@ -448,6 +451,7 @@ function extractClassStaticBlock(extractor: ExtractingVisitor, node: ClassStatic } function buildClassStaticBlock(builder: BuildingVisitor, node: AstNodeData): ClassStaticBlock { + // TODO: inconsistency return ClassStaticBlock.createClassStaticBlock( factory.createFunctionExpression( factory.createIdentifier(node.stringData!.name), @@ -468,6 +472,7 @@ function extractTSEnumDeclaration(extractor: ExtractingVisitor, node: TSEnumDecl booleanData: { isConst: node.isConst, isStatic: node.isStatic, + // TODO: inconsistency isDeclare: !!(node.modifierFlags & Es2pandaModifierFlags.MODIFIER_FLAGS_DECLARE), }, } @@ -515,6 +520,7 @@ function extractNumberLiteral(extractor: ExtractingVisitor, node: NumberLiteral) function buildNumberLiteral(builder: BuildingVisitor, node: AstNodeData): NumberLiteral { return factory.createNumberLiteral( + // TODO: inconsistency Number(node.stringData!.str), ) } @@ -1080,6 +1086,33 @@ function buildAnnotationUsage(builder: BuildingVisitor, node: AstNodeData): Anno ) } +function extractTSTypeAliasDeclaration(extractor: ExtractingVisitor, node: TSTypeAliasDeclaration): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION, + nodeData: { + id: extractor.visitor(node.id), + typeParams: extractor.visitor(node.typeParams), + typeAnnotation: extractor.visitor(node.typeAnnotation), + }, + nodeArrayData: { + annotations: extractor.arrayVisitor(node.annotations), + }, + numericData: { + modifierFlags: node.modifierFlags, + }, + } +} + +function buildTSTypeAliasDeclaration(builder: BuildingVisitor, node: AstNodeData): TSTypeAliasDeclaration { + return factory.createTSTypeAliasDeclaration( + builder.visitor(node.nodeData!.id), + builder.visitor(node.nodeData!.typeParams), + builder.visitor(node.nodeData!.typeAnnotation), + builder.arrayVisitor(node.nodeArrayData!.annotations), + node.numericData!.modifierFlags, + ) +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -1209,30 +1242,34 @@ export class ExtractingVisitor { if (isBreakStatement(node)) { return extractBreakStatement(this, node) } + // TODO: it seems that extracting imports doesn't work yet if (isETSImportDeclaration(node)) { return extractETSImportDeclaration(this, node) } if (isImportSpecifier(node)) { return extractImportSpecifier(this, node) } - if (isConditionalExpression(node)) { - return extractConditionalExpression(this, node) - } - if (isUnaryExpression(node)) { - return extractUnaryExpression(this, node) - } - if (isTSAsExpression(node)) { - return extractTSAsExpression(this, node) - } - if (isUndefinedLiteral(node)) { - return extractUndefinedLiteral(this, node) - } - if (isNullLiteral(node)) { - return extractNullLiteral(this, node) - } - if (isAnnotationUsage(node)) { - return extractAnnotationUsage(this, node) - } + // if (isConditionalExpression(node)) { + // return extractConditionalExpression(this, node) + // } + // if (isUnaryExpression(node)) { + // return extractUnaryExpression(this, node) + // } + // if (isTSAsExpression(node)) { + // return extractTSAsExpression(this, node) + // } + // if (isUndefinedLiteral(node)) { + // return extractUndefinedLiteral(this, node) + // } + // if (isNullLiteral(node)) { + // return extractNullLiteral(this, node) + // } + // if (isAnnotationUsage(node)) { + // return extractAnnotationUsage(this, node) + // } + // if (isTSTypeAliasDeclaration(node)) { + // return extractTSTypeAliasDeclaration(this, node) + // } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -1395,6 +1432,9 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE) { return buildAnnotationUsage(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION) { + return buildTSTypeAliasDeclaration(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) diff --git a/ui2abc/libarkts/src/arkts-api/ImportStorage.ts b/ui2abc/libarkts/src/arkts-api/ImportStorage.ts index a08ad3955..03b649de5 100644 --- a/ui2abc/libarkts/src/arkts-api/ImportStorage.ts +++ b/ui2abc/libarkts/src/arkts-api/ImportStorage.ts @@ -37,7 +37,7 @@ export class ImportStorage { } } - update() { + update(all: boolean) { // Save current statements const statements = this.program.ast.statements diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index 503e78f93..0bfe0ef09 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -81,18 +81,25 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp // For oveloads, set additional pointer to base overload to fix AST setBaseOverloads(ast) + let extracted = true + let builtAst: ETSModule | undefined try { console.log("BEFORE") const astData = new ExtractingVisitor().visitor(ast) - const builtAst = new BuildingVisitor().visitor(astData) as ETSModule - // updateETSModuleByStatements(ast as ETSModule, builtAst.statements) + builtAst = new BuildingVisitor().visitor(astData) as ETSModule console.log("AFTER") } catch (e) { + extracted = false console.log("ERROR", e) } + if (extracted) { + updateETSModuleByStatements(ast as ETSModule, builtAst!.statements) + } + + setBaseOverloads(ast) // Update internal import information based on import modification by plugin - importStorage.update() + importStorage.update(true) // Perform some additional actions after the transformation end hooks.onProgramTransformEnd?.(options, program) -- Gitee From f67943832296ac6f04fcaff5d452b44a15d03e0f Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Wed, 25 Jun 2025 10:19:05 +0300 Subject: [PATCH 08/20] more --- .../libarkts/src/arkts-api/CachingPlugins.ts | 88 ++++++++++++++----- .../libarkts/src/arkts-api/ImportStorage.ts | 2 +- ui2abc/libarkts/src/plugin-utils.ts | 10 ++- 3 files changed, 73 insertions(+), 27 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 4d9351b1d..4eb0d3154 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -30,6 +30,7 @@ import { ClassProperty, ClassStaticBlock, ConditionalExpression, + ETSFunctionType, ETSImportDeclaration, ETSModule, ETSNewClassInstanceExpression, @@ -56,6 +57,7 @@ import { isClassProperty, isClassStaticBlock, isConditionalExpression, + isETSFunctionType, isETSImportDeclaration, isETSModule, isETSNewClassInstanceExpression, @@ -787,16 +789,20 @@ function extractVariableDeclaration(extractor: ExtractingVisitor, node: Variable }, numericData: { kind: node.kind, + modifierFlags: node.modifierFlags, }, } } function buildVariableDeclaration(builder: BuildingVisitor, node: AstNodeData): VariableDeclaration { - return factory.createVariableDeclaration( + const rv = factory.createVariableDeclaration( node.numericData!.kind, builder.arrayVisitor(node.nodeArrayData!.declarators), builder.arrayVisitor(node.nodeArrayData!.annotations), ) + // TODO: inconsistency + rv.modifierFlags = node.numericData!.modifierFlags + return rv } function extractVariableDeclarator(extractor: ExtractingVisitor, node: VariableDeclarator): AstNodeData { @@ -1113,6 +1119,37 @@ function buildTSTypeAliasDeclaration(builder: BuildingVisitor, node: AstNodeData ) } +function extractETSFunctionType(extractor: ExtractingVisitor, node: ETSFunctionType): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, + nodeData: { + typeParams: extractor.visitor(node.typeParams), + returnType: extractor.visitor(node.returnType), + }, + nodeArrayData: { + params: extractor.arrayVisitor(node.params), + annotations: extractor.arrayVisitor(node.annotations), + }, + booleanData: { + hasReceiver: node.isExtensionFunction, + }, + numericData: { + flags: node.flags, + }, + } +} + +function buildETSFunctionType(builder: BuildingVisitor, node: AstNodeData): ETSFunctionType { + return factory.createETSFunctionType( + builder.visitor(node.nodeData!.typeParams), + builder.arrayVisitor(node.nodeArrayData!.params), + builder.visitor(node.nodeData!.returnType), + node.booleanData!.hasReceiver, + node.numericData!.flags, + builder.arrayVisitor(node.nodeArrayData!.annotations), + ) +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -1242,34 +1279,36 @@ export class ExtractingVisitor { if (isBreakStatement(node)) { return extractBreakStatement(this, node) } - // TODO: it seems that extracting imports doesn't work yet if (isETSImportDeclaration(node)) { return extractETSImportDeclaration(this, node) } if (isImportSpecifier(node)) { return extractImportSpecifier(this, node) } - // if (isConditionalExpression(node)) { - // return extractConditionalExpression(this, node) - // } - // if (isUnaryExpression(node)) { - // return extractUnaryExpression(this, node) - // } - // if (isTSAsExpression(node)) { - // return extractTSAsExpression(this, node) - // } - // if (isUndefinedLiteral(node)) { - // return extractUndefinedLiteral(this, node) - // } - // if (isNullLiteral(node)) { - // return extractNullLiteral(this, node) - // } - // if (isAnnotationUsage(node)) { - // return extractAnnotationUsage(this, node) - // } - // if (isTSTypeAliasDeclaration(node)) { - // return extractTSTypeAliasDeclaration(this, node) - // } + if (isConditionalExpression(node)) { + return extractConditionalExpression(this, node) + } + if (isUnaryExpression(node)) { + return extractUnaryExpression(this, node) + } + if (isTSAsExpression(node)) { + return extractTSAsExpression(this, node) + } + if (isUndefinedLiteral(node)) { + return extractUndefinedLiteral(this, node) + } + if (isNullLiteral(node)) { + return extractNullLiteral(this, node) + } + if (isAnnotationUsage(node)) { + return extractAnnotationUsage(this, node) + } + if (isTSTypeAliasDeclaration(node)) { + return extractTSTypeAliasDeclaration(this, node) + } + if (isETSFunctionType(node)) { + return extractETSFunctionType(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -1435,6 +1474,9 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION) { return buildTSTypeAliasDeclaration(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE) { + return buildETSFunctionType(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) diff --git a/ui2abc/libarkts/src/arkts-api/ImportStorage.ts b/ui2abc/libarkts/src/arkts-api/ImportStorage.ts index 03b649de5..a08ad3955 100644 --- a/ui2abc/libarkts/src/arkts-api/ImportStorage.ts +++ b/ui2abc/libarkts/src/arkts-api/ImportStorage.ts @@ -37,7 +37,7 @@ export class ImportStorage { } } - update(all: boolean) { + update() { // Save current statements const statements = this.program.ast.statements diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index 0bfe0ef09..2ed22a054 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -93,13 +93,17 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp console.log("ERROR", e) } if (extracted) { + console.log("UPDATE FOR", program.absoluteName) + // console.log(ast.dumpSrc()) updateETSModuleByStatements(ast as ETSModule, builtAst!.statements) + + // Fix ast in some places! + setBaseOverloads(ast) + setAllParents(ast) } - setBaseOverloads(ast) - // Update internal import information based on import modification by plugin - importStorage.update(true) + importStorage.update() // Perform some additional actions after the transformation end hooks.onProgramTransformEnd?.(options, program) -- Gitee From c66077762aa26113196c15326edadc8e01c76b74 Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Fri, 27 Jun 2025 16:45:58 +0300 Subject: [PATCH 09/20] rebase, more --- .../libarkts/src/arkts-api/CachingPlugins.ts | 89 +++++++++++++++++++ ui2abc/libarkts/src/plugin-utils.ts | 1 - 2 files changed, 89 insertions(+), 1 deletion(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 4eb0d3154..ffaf851da 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -86,8 +86,11 @@ import { isThrowStatement, isTSArrayType, isTSAsExpression, + isTSClassImplements, isTSEnumDeclaration, isTSEnumMember, + isTSInterfaceBody, + isTSInterfaceDeclaration, isTSTypeAliasDeclaration, isTSTypeParameterInstantiation, isUnaryExpression, @@ -109,8 +112,11 @@ import { ThrowStatement, TSArrayType, TSAsExpression, + TSClassImplements, TSEnumDeclaration, TSEnumMember, + TSInterfaceBody, + TSInterfaceDeclaration, TSTypeAliasDeclaration, TSTypeParameterInstantiation, UnaryExpression, @@ -1150,6 +1156,71 @@ function buildETSFunctionType(builder: BuildingVisitor, node: AstNodeData): ETSF ) } +function extractTSInterfaceDeclaration(extractor: ExtractingVisitor, node: TSInterfaceDeclaration): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION, + nodeData: { + id: extractor.visitor(node.id), + typeParams: extractor.visitor(node.typeParams), + body: extractor.visitor(node.body), + }, + nodeArrayData: { + extends: extractor.arrayVisitor(node.extends), + }, + booleanData: { + isStatic: node.isStatic, + isFromExternal: node.isFromExternal, + }, + numericData: { + modifierFlags: node.modifierFlags, + }, + } +} + +function buildTSInterfaceDeclaration(builder: BuildingVisitor, node: AstNodeData): TSInterfaceDeclaration { + return factory.createInterfaceDeclaration( + builder.arrayVisitor(node.nodeArrayData!.extends), + builder.visitor(node.nodeData!.id), + builder.visitor(node.nodeData!.typeParams), + builder.visitor(node.nodeData!.body), + node.booleanData!.isStatic, + node.booleanData!.isFromExternal, + node.numericData!.modifierFlags, + ) +} + +function extractTSInterfaceBody(extractor: ExtractingVisitor, node: TSInterfaceBody): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY, + nodeArrayData: { + body: extractor.arrayVisitor(node.body), + }, + } +} + +function buildTSInterfaceBody(builder: BuildingVisitor, node: AstNodeData): TSInterfaceBody { + return factory.createTSInterfaceBody( + builder.arrayVisitor(node.nodeArrayData!.body), + ) +} + +function extractTSClassImplements(extractor: ExtractingVisitor, node: TSClassImplements): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS, + nodeData: { + expr: extractor.visitor(node.expr), + typeParameters: extractor.visitor(node.typeParameters), + }, + } +} + +function buildTSClassImplements(builder: BuildingVisitor, node: AstNodeData): TSClassImplements { + return factory.createTSClassImplements( + builder.visitor(node.nodeData!.expr), + builder.visitor(node.nodeData!.typeParameters), + ) +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -1309,6 +1380,15 @@ export class ExtractingVisitor { if (isETSFunctionType(node)) { return extractETSFunctionType(this, node) } + if (isTSInterfaceDeclaration(node)) { + return extractTSInterfaceDeclaration(this, node) + } + if (isTSInterfaceBody(node)) { + return extractTSInterfaceBody(this, node) + } + if (isTSClassImplements(node)) { + return extractTSClassImplements(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -1477,6 +1557,15 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE) { return buildETSFunctionType(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION) { + return buildTSInterfaceDeclaration(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY) { + return buildTSInterfaceBody(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS) { + return buildTSClassImplements(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index 2ed22a054..893382234 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -94,7 +94,6 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp } if (extracted) { console.log("UPDATE FOR", program.absoluteName) - // console.log(ast.dumpSrc()) updateETSModuleByStatements(ast as ETSModule, builtAst!.statements) // Fix ast in some places! -- Gitee From fe3543420b03b3981ec222609df7ec208b616de8 Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Fri, 4 Jul 2025 16:01:05 +0300 Subject: [PATCH 10/20] more --- .../libarkts/src/arkts-api/CachingPlugins.ts | 85 +++++++++++++++++-- .../libarkts/src/arkts-api/class-by-peer.ts | 12 ++- ui2abc/libarkts/src/plugin-utils.ts | 19 +++-- 3 files changed, 98 insertions(+), 18 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index ffaf851da..0c3924c0a 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -15,11 +15,12 @@ import { AstNode } from './peers/AstNode' import { global } from './static/global' -import { Es2pandaAstNodeType, Es2pandaImportKinds, Es2pandaModifierFlags, Es2pandaModuleFlag } from '../generated/Es2pandaEnums' +import { Es2pandaAstNodeType, Es2pandaImportKinds, Es2pandaModifierFlags, Es2pandaModuleFlag, Es2pandaTokenType } from '../generated/Es2pandaEnums' import { factory } from './factory/nodeFactory' import { AnnotationUsage, ArrayExpression, + ArrowFunctionExpression, AssignmentExpression, BinaryExpression, BlockStatement, @@ -47,6 +48,7 @@ import { ImportSpecifier, isAnnotationUsage, isArrayExpression, + isArrowFunctionExpression, isAssignmentExpression, isBinaryExpression, isBlockStatement, @@ -78,6 +80,7 @@ import { isNumberLiteral, isReturnStatement, isScriptFunction, + isSpreadElement, isStringLiteral, isSuperExpression, isSwitchCaseStatement, @@ -104,6 +107,7 @@ import { NumberLiteral, ReturnStatement, ScriptFunction, + SpreadElement, StringLiteral, SuperExpression, SwitchCaseStatement, @@ -521,16 +525,25 @@ function extractNumberLiteral(extractor: ExtractingVisitor, node: NumberLiteral) return { type: Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, stringData: { - str: node.str, + str: node.dumpSrc(), // TODO: es2panda bug 27250 }, } } -function buildNumberLiteral(builder: BuildingVisitor, node: AstNodeData): NumberLiteral { - return factory.createNumberLiteral( - // TODO: inconsistency - Number(node.stringData!.str), - ) +function buildNumberLiteral(builder: BuildingVisitor, node: AstNodeData): NumberLiteral | BinaryExpression { + // TODO: inconsistency, reported as es2panda bug 27252 + const str = node.stringData!.str + if (str.match(/$[0-9]+^/)) { + return new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral(global.context, parseInt(str))) + } else { + // TODO: workaround for es2panda bug 27251 + const eps = 0.0001 + return factory.createBinaryExpression( + new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, parseFloat(str) + eps)), + new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, eps)), + Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_MINUS, + ) + } } function extractTSTypeParameterInstantiation(extractor: ExtractingVisitor, node: TSTypeParameterInstantiation): AstNodeData { @@ -627,7 +640,8 @@ function extractETSParameterExpression(extractor: ExtractingVisitor, node: ETSPa return { type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, nodeData: { - ident: extractor.visitor(node.ident), + // TODO: inconsistency + identOrSpread: node.isRestParameter ? extractor.visitor(node.restParameter) : extractor.visitor(node.ident), initializer: extractor.visitor(node.initializer), }, nodeArrayData: { @@ -641,7 +655,7 @@ function extractETSParameterExpression(extractor: ExtractingVisitor, node: ETSPa function buildETSParameterExpression(builder: BuildingVisitor, node: AstNodeData): ETSParameterExpression { return factory.createETSParameterExpression( - builder.visitor(node.nodeData!.ident), + builder.visitor(node.nodeData!.identOrSpread), node.booleanData!.isOptional, builder.visitor(node.nodeData!.initializer), builder.arrayVisitor(node.nodeArrayData!.annotations), @@ -1221,6 +1235,47 @@ function buildTSClassImplements(builder: BuildingVisitor, node: AstNodeData): TS ) } +function extractArrowFunctionExpression(extractor: ExtractingVisitor, node: ArrowFunctionExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, + nodeData: { + func: extractor.visitor(node.function), + }, + nodeArrayData: { + annotations: extractor.arrayVisitor(node.annotations), + }, + } +} + +function buildArrowFunctionExpression(builder: BuildingVisitor, node: AstNodeData): ArrowFunctionExpression { + return factory.createArrowFunctionExpression( + builder.visitor(node.nodeData!.func), + builder.arrayVisitor(node.nodeArrayData!.annotations), + ) +} + +function extractSpreadElement(extractor: ExtractingVisitor, node: SpreadElement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT, + nodeData: { + argument: extractor.visitor(node.argument), + typeAnnotation: extractor.visitor(node.typeAnnotation), + }, + } +} + +function buildSpreadElement(builder: BuildingVisitor, node: AstNodeData): SpreadElement { + // TODO: inconsistency + const result = SpreadElement.createSpreadElement( + Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT, // TODO: how to decide node type here? (it could be rest element as well) + builder.visitor(node.nodeData!.argument), + ) + if (node.nodeData!.typeAnnotation) { + result.setTsTypeAnnotation(builder.visitor(node.nodeData!.typeAnnotation)) + } + return result +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -1389,6 +1444,12 @@ export class ExtractingVisitor { if (isTSClassImplements(node)) { return extractTSClassImplements(this, node) } + if (isArrowFunctionExpression(node)) { + return extractArrowFunctionExpression(this, node) + } + if (isSpreadElement(node)) { + return extractSpreadElement(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -1566,6 +1627,12 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS) { return buildTSClassImplements(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION) { + return buildArrowFunctionExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT) { + return buildSpreadElement(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) diff --git a/ui2abc/libarkts/src/arkts-api/class-by-peer.ts b/ui2abc/libarkts/src/arkts-api/class-by-peer.ts index bc87d3967..41ee83d4c 100644 --- a/ui2abc/libarkts/src/arkts-api/class-by-peer.ts +++ b/ui2abc/libarkts/src/arkts-api/class-by-peer.ts @@ -22,11 +22,21 @@ import { NodeCache } from "./node-cache" export const nodeByType = new Map AstNode>([]) +/** + * Some nodes are stored in native as nodes of the other class, so use cast here + */ +function nodeReinterpret(type: number) { + if (type == Es2pandaAstNodeType.AST_NODE_TYPE_REST_ELEMENT) { + return Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT + } + return type +} + export function classByPeer(peer: KNativePointer): T { if (peer === nullptr) { throwError('classByPeer: peer is NULLPTR') } const type = global.generatedEs2panda._AstNodeTypeConst(global.context, peer) - const create = nodeByType.get(type) ?? throwError(`unknown node type: ${type}`) + const create = nodeByType.get(nodeReinterpret(type)) ?? throwError(`unknown node type: ${type}`) return NodeCache.cached(peer, create) } diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index 893382234..53d99a4df 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -78,14 +78,11 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp // Run some common plugins that should be run after plugin usage and depends on the current state stateSpecificPostFilters(program, options.state) - // For oveloads, set additional pointer to base overload to fix AST - setBaseOverloads(ast) - let extracted = true let builtAst: ETSModule | undefined try { console.log("BEFORE") - const astData = new ExtractingVisitor().visitor(ast) + const astData = new ExtractingVisitor().visitor(program.ast) builtAst = new BuildingVisitor().visitor(astData) as ETSModule console.log("AFTER") } catch (e) { @@ -94,11 +91,17 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp } if (extracted) { console.log("UPDATE FOR", program.absoluteName) - updateETSModuleByStatements(ast as ETSModule, builtAst!.statements) - + const oldSource = program.ast.dumpSrc() + // updateETSModuleByStatements(program.ast as ETSModule, builtAst!.statements) + const newSource = program.ast.dumpSrc() + if (oldSource != newSource) { + console.log("DIFF =====================") + console.log(oldSource) + console.log("DIFF =====================") + console.log(newSource) + } // Fix ast in some places! - setBaseOverloads(ast) - setAllParents(ast) + setAllParents(program.ast) } // Update internal import information based on import modification by plugin -- Gitee From 07b6f8d681cc5d20094703d3ee23bd06246811b5 Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Fri, 4 Jul 2025 16:07:02 +0300 Subject: [PATCH 11/20] more --- ui2abc/libarkts/src/plugin-utils.ts | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index 53d99a4df..9ba252114 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -91,7 +91,17 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp } if (extracted) { console.log("UPDATE FOR", program.absoluteName) + const module = program.ast as ETSModule const oldSource = program.ast.dumpSrc() + program.setAst( + factory.updateETSModule( + module, + builtAst!.statements, + module.ident, + module.getNamespaceFlag(), + module.program, + ) + ) // updateETSModuleByStatements(program.ast as ETSModule, builtAst!.statements) const newSource = program.ast.dumpSrc() if (oldSource != newSource) { -- Gitee From 736bba9936a367ccd6cf026f5af2fa2de4cef6a1 Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Fri, 4 Jul 2025 11:40:46 +0300 Subject: [PATCH 12/20] more --- ui2abc/libarkts/src/arkts-api/CachingPlugins.ts | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 0c3924c0a..02a4a1685 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -533,14 +533,14 @@ function extractNumberLiteral(extractor: ExtractingVisitor, node: NumberLiteral) function buildNumberLiteral(builder: BuildingVisitor, node: AstNodeData): NumberLiteral | BinaryExpression { // TODO: inconsistency, reported as es2panda bug 27252 const str = node.stringData!.str - if (str.match(/$[0-9]+^/)) { + if (str.match(/^[0-9]+$/)) { return new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral(global.context, parseInt(str))) } else { - // TODO: workaround for es2panda bug 27251 + // TODO: bad workaround for es2panda bug 27251 const eps = 0.0001 return factory.createBinaryExpression( - new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, parseFloat(str) + eps)), - new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, eps)), + new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, parseFloat(str) * (1 + eps))), + new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, parseFloat(str) * eps)), Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_MINUS, ) } -- Gitee From cf95c4e192fe771bf7973fd9cb091e27b760da0a Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Fri, 4 Jul 2025 16:45:52 +0300 Subject: [PATCH 13/20] more --- .../libarkts/src/arkts-api/CachingPlugins.ts | 118 ++++++++++++++++-- ui2abc/libarkts/src/plugin-utils.ts | 3 +- 2 files changed, 109 insertions(+), 12 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 02a4a1685..615372af3 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -24,6 +24,7 @@ import { AssignmentExpression, BinaryExpression, BlockStatement, + BooleanLiteral, BreakStatement, CallExpression, ClassDeclaration, @@ -52,6 +53,7 @@ import { isAssignmentExpression, isBinaryExpression, isBlockStatement, + isBooleanLiteral, isBreakStatement, isCallExpression, isClassDeclaration, @@ -94,7 +96,10 @@ import { isTSEnumMember, isTSInterfaceBody, isTSInterfaceDeclaration, + isTSQualifiedName, isTSTypeAliasDeclaration, + isTSTypeParameter, + isTSTypeParameterDeclaration, isTSTypeParameterInstantiation, isUnaryExpression, isUndefinedLiteral, @@ -121,7 +126,10 @@ import { TSEnumMember, TSInterfaceBody, TSInterfaceDeclaration, + TSQualifiedName, TSTypeAliasDeclaration, + TSTypeParameter, + TSTypeParameterDeclaration, TSTypeParameterInstantiation, UnaryExpression, UndefinedLiteral, @@ -142,14 +150,6 @@ interface AstNodeData { export type MaybeAstNodeData = AstNodeData | undefined export type MaybeAstNode = AstNode | undefined -function ETSModuleFlag(node: ETSModule): number { - const res = - (node.isETSScript ? Es2pandaModuleFlag.MODULE_FLAG_ETSSCRIPT : 0) - + (node.isNamespace ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE : 0) - + (node.isNamespaceChainLastNode ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE_CHAIN_LAST_NODE : 0) - return res -} - function extractETSModule(extractor: ExtractingVisitor, node: ETSModule): AstNodeData { return { type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, @@ -160,8 +160,7 @@ function extractETSModule(extractor: ExtractingVisitor, node: ETSModule): AstNod ident: extractor.visitor(node.ident), }, numericData: { - // TODO: inconsistency - flag: ETSModuleFlag(node), + flag: node.getNamespaceFlag(), }, } } @@ -1276,6 +1275,81 @@ function buildSpreadElement(builder: BuildingVisitor, node: AstNodeData): Spread return result } +function extractTSTypeParameterDeclaration(extractor: ExtractingVisitor, node: TSTypeParameterDeclaration): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, + nodeArrayData: { + params: extractor.arrayVisitor(node.params), + }, + numericData: { + requiredParams: node.requiredParams, + }, + } +} + +function buildTSTypeParameterDeclaration(builder: BuildingVisitor, node: AstNodeData): TSTypeParameterDeclaration { + return factory.createTSTypeParameterDeclaration( + builder.arrayVisitor(node.nodeArrayData!.params), + node.numericData!.requiredParams, + ) +} + +function extractTSQualifiedName(extractor: ExtractingVisitor, node: TSQualifiedName): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME, + nodeData: { + left: extractor.visitor(node.left), + right: extractor.visitor(node.right), + } + } +} + +function buildTSQualifiedName(builder: BuildingVisitor, node: AstNodeData): TSQualifiedName { + return factory.createTSQualifiedName( + builder.visitor(node.nodeData!.left), + builder.visitor(node.nodeData!.right), + ) +} + +function extractBooleanLiteral(extractor: ExtractingVisitor, node: BooleanLiteral): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL, + booleanData: { + value: node.value, + }, + } +} + +function buildBooleanLiteral(builder: BuildingVisitor, node: AstNodeData): BooleanLiteral { + return factory.createBooleanLiteral( + node.booleanData!.value, + ) +} + +function extractTSTypeParameter(extractor: ExtractingVisitor, node: TSTypeParameter): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, + nodeData: { + name: extractor.visitor(node.name), + constraint: extractor.visitor(node.constraint), + defaultType: extractor.visitor(node.defaultType), + }, + numericData: { + modifierFlags: node.modifierFlags, + }, + } +} + +function buildTSTypeParameter(builder: BuildingVisitor, node: AstNodeData): TSTypeParameter { + // TODO: inconsistency + return TSTypeParameter.create1TSTypeParameter( + builder.visitor(node.nodeData!.name), + builder.visitor(node.nodeData!.constraint), + builder.visitor(node.nodeData!.defaultType), + node.numericData!.modifierFlags, + ) +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -1450,6 +1524,18 @@ export class ExtractingVisitor { if (isSpreadElement(node)) { return extractSpreadElement(this, node) } + if (isTSTypeParameterDeclaration(node)) { + return extractTSTypeParameterDeclaration(this, node) + } + if (isTSQualifiedName(node)) { + return extractTSQualifiedName(this, node) + } + if (isBooleanLiteral(node)) { + return extractBooleanLiteral(this, node) + } + if (isTSTypeParameter(node)) { + return extractTSTypeParameter(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -1633,6 +1719,18 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT) { return buildSpreadElement(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION) { + return buildTSTypeParameterDeclaration(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME) { + return buildTSQualifiedName(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL) { + return buildBooleanLiteral(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER) { + return buildTSTypeParameter(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index 9ba252114..12d904153 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -102,9 +102,8 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp module.program, ) ) - // updateETSModuleByStatements(program.ast as ETSModule, builtAst!.statements) const newSource = program.ast.dumpSrc() - if (oldSource != newSource) { + if (oldSource.split('\n').length != newSource.split('\n').length) { console.log("DIFF =====================") console.log(oldSource) console.log("DIFF =====================") -- Gitee From 89018e3b96509a35fdc5ecf80861e0e17c01170f Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Fri, 4 Jul 2025 19:31:10 +0300 Subject: [PATCH 14/20] WIP --- .../libarkts/src/arkts-api/CachingPlugins.ts | 130 ++++++++++++++++++ ui2abc/libarkts/src/plugin-utils.ts | 37 +++-- 2 files changed, 155 insertions(+), 12 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 615372af3..4bd5099b9 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -23,10 +23,12 @@ import { ArrowFunctionExpression, AssignmentExpression, BinaryExpression, + BlockExpression, BlockStatement, BooleanLiteral, BreakStatement, CallExpression, + ChainExpression, ClassDeclaration, ClassDefinition, ClassProperty, @@ -36,10 +38,13 @@ import { ETSImportDeclaration, ETSModule, ETSNewClassInstanceExpression, + ETSNullType, ETSParameterExpression, ETSPrimitiveType, ETSTypeReference, ETSTypeReferencePart, + ETSUndefinedType, + ETSUnionType, ExpressionStatement, ForUpdateStatement, FunctionDeclaration, @@ -52,10 +57,12 @@ import { isArrowFunctionExpression, isAssignmentExpression, isBinaryExpression, + isBlockExpression, isBlockStatement, isBooleanLiteral, isBreakStatement, isCallExpression, + isChainExpression, isClassDeclaration, isClassDefinition, isClassProperty, @@ -65,10 +72,13 @@ import { isETSImportDeclaration, isETSModule, isETSNewClassInstanceExpression, + isETSNullType, isETSParameterExpression, isETSPrimitiveType, isETSTypeReference, isETSTypeReferencePart, + isETSUndefinedType, + isETSUnionType, isExpressionStatement, isForUpdateStatement, isFunctionDeclaration, @@ -96,6 +106,7 @@ import { isTSEnumMember, isTSInterfaceBody, isTSInterfaceDeclaration, + isTSNonNullExpression, isTSQualifiedName, isTSTypeAliasDeclaration, isTSTypeParameter, @@ -126,6 +137,7 @@ import { TSEnumMember, TSInterfaceBody, TSInterfaceDeclaration, + TSNonNullExpression, TSQualifiedName, TSTypeAliasDeclaration, TSTypeParameter, @@ -150,6 +162,8 @@ interface AstNodeData { export type MaybeAstNodeData = AstNodeData | undefined export type MaybeAstNode = AstNode | undefined +const GENSYM_PREFIX = "gensym%%_" + function extractETSModule(extractor: ExtractingVisitor, node: ETSModule): AstNodeData { return { type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, @@ -1350,6 +1364,86 @@ function buildTSTypeParameter(builder: BuildingVisitor, node: AstNodeData): TSTy ) } +function extractETSUnionType(extractor: ExtractingVisitor, node: ETSUnionType): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, + nodeArrayData: { + types: extractor.arrayVisitor(node.types), + }, + } +} + +function buildETSUnionType(builder: BuildingVisitor, node: AstNodeData): ETSUnionType { + return factory.createETSUnionType( + builder.arrayVisitor(node.nodeArrayData!.types), + ) +} + +function extractETSUndefinedType(extractor: ExtractingVisitor, node: ETSUndefinedType): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, + } +} + +function buildETSUndefinedType(builder: BuildingVisitor, node: AstNodeData): ETSUndefinedType { + return factory.createETSUndefinedType() +} + +function extractETSNullType(extractor: ExtractingVisitor, node: ETSNullType): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE, + } +} + +function buildETSNullType(builder: BuildingVisitor, node: AstNodeData): ETSNullType { + return factory.createETSNullType() +} + +function extractBlockExpression(extractor: ExtractingVisitor, node: BlockExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION, + nodeArrayData: { + statements: extractor.arrayVisitor(node.statements), + }, + } +} + +function buildBlockExpression(builder: BuildingVisitor, node: AstNodeData): BlockExpression { + return factory.createBlockExpression( + builder.arrayVisitor(node.nodeArrayData!.statements), + ) +} + +function extractTSNonNullExpression(extractor: ExtractingVisitor, node: TSNonNullExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION, + nodeData: { + expression: extractor.visitor(node.expr), + }, + } +} + +function buildTSNonNullExpression(builder: BuildingVisitor, node: AstNodeData): TSNonNullExpression { + return factory.createTSNonNullExpression( + builder.visitor(node.nodeData!.expression), + ) +} + +function extractChainExpression(extractor: ExtractingVisitor, node: ChainExpression): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION, + nodeData: { + expression: extractor.visitor(node.expression), + }, + } +} + +function buildChainExpression(builder: BuildingVisitor, node: AstNodeData): ChainExpression { + return factory.createChainExpression( + builder.visitor(node.nodeData!.expression), + ) +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -1536,6 +1630,24 @@ export class ExtractingVisitor { if (isTSTypeParameter(node)) { return extractTSTypeParameter(this, node) } + if (isETSUnionType(node)) { + return extractETSUnionType(this, node) + } + if (isETSUndefinedType(node)) { + return extractETSUndefinedType(this, node) + } + if (isETSNullType(node)) { + return extractETSNullType(this, node) + } + if (isBlockExpression(node)) { + return extractBlockExpression(this, node) + } + if (isTSNonNullExpression(node)) { + return extractTSNonNullExpression(this, node) + } + if (isChainExpression(node)) { + return extractChainExpression(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -1731,6 +1843,24 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER) { return buildTSTypeParameter(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE) { + return buildETSUnionType(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE) { + return buildETSUndefinedType(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE) { + return buildETSNullType(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION) { + return buildBlockExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION) { + return buildTSNonNullExpression(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION) { + return buildChainExpression(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index 12d904153..392c0b47c 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -87,27 +87,40 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp console.log("AFTER") } catch (e) { extracted = false + console.log("ERROR FOR", program.absoluteName) console.log("ERROR", e) } if (extracted) { console.log("UPDATE FOR", program.absoluteName) const module = program.ast as ETSModule - const oldSource = program.ast.dumpSrc() - program.setAst( - factory.updateETSModule( - module, - builtAst!.statements, - module.ident, - module.getNamespaceFlag(), - module.program, + const oldSource = program.ast.dumpJson() + if (program.absoluteName.endsWith("TimeAnimation.ts") || program.absoluteName.endsWith("main.ets")) { + program.setAst( + factory.updateETSModule( + module, + builtAst!.statements, + module.ident, + module.getNamespaceFlag(), + module.program, + ) ) - ) - const newSource = program.ast.dumpSrc() + } + const newSource = program.ast.dumpJson() if (oldSource.split('\n').length != newSource.split('\n').length) { - console.log("DIFF =====================") + console.log("DIFF (LINES) =====================") console.log(oldSource) - console.log("DIFF =====================") + console.log("DIFF (LINES) =====================") console.log(newSource) + } else if (oldSource != newSource) { + const oldSourceLines = oldSource.split('\n') + const newSourceLines = newSource.split('\n') + for (let i = 0; i < oldSourceLines.length; i++) { + if (oldSourceLines[i] != newSourceLines[i]) { + console.log("DIFF LINE", i) + console.log(oldSourceLines[i]) + console.log(newSourceLines[i]) + } + } } // Fix ast in some places! setAllParents(program.ast) -- Gitee From 5e21789b0bf73597d32745a4ae5a914375b2112f Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Fri, 4 Jul 2025 20:44:25 +0300 Subject: [PATCH 15/20] more --- .../libarkts/src/arkts-api/CachingPlugins.ts | 61 ++++++++++++++++++- ui2abc/libarkts/src/plugin-utils.ts | 22 +++---- 2 files changed, 68 insertions(+), 15 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 4bd5099b9..10237cd28 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -99,6 +99,7 @@ import { isSwitchStatement, isThisExpression, isThrowStatement, + isTryStatement, isTSArrayType, isTSAsExpression, isTSClassImplements, @@ -106,6 +107,7 @@ import { isTSEnumMember, isTSInterfaceBody, isTSInterfaceDeclaration, + isTSInterfaceHeritage, isTSNonNullExpression, isTSQualifiedName, isTSTypeAliasDeclaration, @@ -130,6 +132,7 @@ import { SwitchStatement, ThisExpression, ThrowStatement, + TryStatement, TSArrayType, TSAsExpression, TSClassImplements, @@ -137,6 +140,7 @@ import { TSEnumMember, TSInterfaceBody, TSInterfaceDeclaration, + TSInterfaceHeritage, TSNonNullExpression, TSQualifiedName, TSTypeAliasDeclaration, @@ -1444,6 +1448,44 @@ function buildChainExpression(builder: BuildingVisitor, node: AstNodeData): Chai ) } +function extractTSInterfaceHeritage(extractor: ExtractingVisitor, node: TSInterfaceHeritage): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE, + nodeData: { + expression: extractor.visitor(node.expr), + }, + } +} + +function buildTSInterfaceHeritage(builder: BuildingVisitor, node: AstNodeData): TSInterfaceHeritage { + return factory.createTSInterfaceHeritage( + builder.visitor(node.nodeData!.expression), + ) +} + +function extractTryStatement(extractor: ExtractingVisitor, node: TryStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT, + nodeData: { + block: extractor.visitor(node.block), + finalizer: extractor.visitor(node.finallyBlock), + }, + nodeArrayData: { + catchClauses: extractor.arrayVisitor(node.catchClauses), + }, + } +} + +function buildTryStatement(builder: BuildingVisitor, node: AstNodeData): TryStatement { + return factory.createTryStatement( + builder.visitor(node.nodeData!.block), + builder.arrayVisitor(node.nodeArrayData!.catchClauses), + builder.visitor(node.nodeData!.finalizer), + [], + [], + ) +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -1648,6 +1690,12 @@ export class ExtractingVisitor { if (isChainExpression(node)) { return extractChainExpression(this, node) } + if (isTSInterfaceHeritage(node)) { + return extractTSInterfaceHeritage(this, node) + } + if (isTryStatement(node)) { + return extractTryStatement(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -1723,9 +1771,10 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION) { return buildTSTypeParameterInstantiation(this, node) } - if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY) { - return buildClassProperty(this, node) - } + // TODO: what is wrong with class property implementing interface property? + // if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY) { + // return buildClassProperty(this, node) + // } if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT) { return buildExpressionStatement(this, node) } @@ -1861,6 +1910,12 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION) { return buildChainExpression(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE) { + return buildTSInterfaceHeritage(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT) { + return buildTryStatement(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index 392c0b47c..fc6317a0c 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -93,19 +93,17 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp if (extracted) { console.log("UPDATE FOR", program.absoluteName) const module = program.ast as ETSModule - const oldSource = program.ast.dumpJson() - if (program.absoluteName.endsWith("TimeAnimation.ts") || program.absoluteName.endsWith("main.ets")) { - program.setAst( - factory.updateETSModule( - module, - builtAst!.statements, - module.ident, - module.getNamespaceFlag(), - module.program, - ) + const oldSource = program.ast.dumpSrc() + program.setAst( + factory.updateETSModule( + module, + builtAst!.statements, + module.ident, + module.getNamespaceFlag(), + module.program, ) - } - const newSource = program.ast.dumpJson() + ) + const newSource = program.ast.dumpSrc() if (oldSource.split('\n').length != newSource.split('\n').length) { console.log("DIFF (LINES) =====================") console.log(oldSource) -- Gitee From ea4e677729209893457c6b333c47bed24b83f636 Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Fri, 4 Jul 2025 21:58:59 +0300 Subject: [PATCH 16/20] more --- .../libarkts/src/arkts-api/CachingPlugins.ts | 92 +++++++++++++++++-- ui2abc/libarkts/src/plugin-utils.ts | 19 ++-- 2 files changed, 97 insertions(+), 14 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 10237cd28..91888c4c9 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -34,6 +34,7 @@ import { ClassProperty, ClassStaticBlock, ConditionalExpression, + DoWhileStatement, ETSFunctionType, ETSImportDeclaration, ETSModule, @@ -46,6 +47,7 @@ import { ETSUndefinedType, ETSUnionType, ExpressionStatement, + ForOfStatement, ForUpdateStatement, FunctionDeclaration, FunctionExpression, @@ -68,6 +70,7 @@ import { isClassProperty, isClassStaticBlock, isConditionalExpression, + isDoWhileStatement, isETSFunctionType, isETSImportDeclaration, isETSModule, @@ -80,6 +83,7 @@ import { isETSUndefinedType, isETSUnionType, isExpressionStatement, + isForOfStatement, isForUpdateStatement, isFunctionDeclaration, isFunctionExpression, @@ -119,6 +123,7 @@ import { isUpdateExpression, isVariableDeclaration, isVariableDeclarator, + isWhileStatement, MemberExpression, MethodDefinition, NullLiteral, @@ -151,7 +156,8 @@ import { UndefinedLiteral, UpdateExpression, VariableDeclaration, - VariableDeclarator + VariableDeclarator, + WhileStatement } from '../generated' interface AstNodeData { @@ -550,7 +556,7 @@ function extractNumberLiteral(extractor: ExtractingVisitor, node: NumberLiteral) function buildNumberLiteral(builder: BuildingVisitor, node: AstNodeData): NumberLiteral | BinaryExpression { // TODO: inconsistency, reported as es2panda bug 27252 const str = node.stringData!.str - if (str.match(/^[0-9]+$/)) { + if (str.match(/^(-?)[0-9]+$/)) { return new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral(global.context, parseInt(str))) } else { // TODO: bad workaround for es2panda bug 27251 @@ -1486,6 +1492,63 @@ function buildTryStatement(builder: BuildingVisitor, node: AstNodeData): TryStat ) } +function extractWhileStatement(extractor: ExtractingVisitor, node: WhileStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT, + nodeData: { + test: extractor.visitor(node.test), + body: extractor.visitor(node.body), + }, + } +} + +function buildWhileStatement(builder: BuildingVisitor, node: AstNodeData): WhileStatement { + return factory.createWhileStatement( + builder.visitor(node.nodeData!.test), + builder.visitor(node.nodeData!.body), + ) +} + +function extractDoWhileStatement(extractor: ExtractingVisitor, node: DoWhileStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT, + nodeData: { + test: extractor.visitor(node.test), + body: extractor.visitor(node.body), + }, + } +} + +function buildDoWhileStatement(builder: BuildingVisitor, node: AstNodeData): DoWhileStatement { + return factory.createDoWhileStatement( + builder.visitor(node.nodeData!.test), + builder.visitor(node.nodeData!.body), + ) +} + +function extractForOfStatement(extractor: ExtractingVisitor, node: ForOfStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT, + nodeData: { + left: extractor.visitor(node.left), + right: extractor.visitor(node.right), + body: extractor.visitor(node.body), + }, + booleanData: { + isAsync: node.isAwait, + }, + } +} + +function buildForOfStatement(builder: BuildingVisitor, node: AstNodeData): ForOfStatement { + return factory.createForOfStatement( + builder.visitor(node.nodeData!.left), + builder.visitor(node.nodeData!.right), + builder.visitor(node.nodeData!.body), + node.booleanData!.isAwait, + ) +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -1696,6 +1759,15 @@ export class ExtractingVisitor { if (isTryStatement(node)) { return extractTryStatement(this, node) } + if (isWhileStatement(node)) { + return extractWhileStatement(this, node) + } + if (isDoWhileStatement(node)) { + return extractDoWhileStatement(this, node) + } + if (isForOfStatement(node)) { + return extractForOfStatement(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -1771,10 +1843,9 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION) { return buildTSTypeParameterInstantiation(this, node) } - // TODO: what is wrong with class property implementing interface property? - // if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY) { - // return buildClassProperty(this, node) - // } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY) { + return buildClassProperty(this, node) + } if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT) { return buildExpressionStatement(this, node) } @@ -1916,6 +1987,15 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT) { return buildTryStatement(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT) { + return buildWhileStatement(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT) { + return buildDoWhileStatement(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT) { + return buildForOfStatement(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index fc6317a0c..b549f4ae9 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -94,15 +94,18 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp console.log("UPDATE FOR", program.absoluteName) const module = program.ast as ETSModule const oldSource = program.ast.dumpSrc() - program.setAst( - factory.updateETSModule( - module, - builtAst!.statements, - module.ident, - module.getNamespaceFlag(), - module.program, + // class C implements I { prop: boolean } doesn't work + if (!program.absoluteName.endsWith("TimeAnimation.ts")) { + program.setAst( + factory.updateETSModule( + module, + builtAst!.statements, + module.ident, + module.getNamespaceFlag(), + module.program, + ) ) - ) + } const newSource = program.ast.dumpSrc() if (oldSource.split('\n').length != newSource.split('\n').length) { console.log("DIFF (LINES) =====================") -- Gitee From bc6615a51825fd133b78bfc9f9d05a56d49a33c3 Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Sat, 5 Jul 2025 12:24:59 +0300 Subject: [PATCH 17/20] more --- .../libarkts/src/arkts-api/CachingPlugins.ts | 136 +++++++++++++++++- ui2abc/libarkts/src/plugin-utils.ts | 19 ++- 2 files changed, 138 insertions(+), 17 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 91888c4c9..17ac66064 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -28,12 +28,14 @@ import { BooleanLiteral, BreakStatement, CallExpression, + CatchClause, ChainExpression, ClassDeclaration, ClassDefinition, ClassProperty, ClassStaticBlock, ConditionalExpression, + ContinueStatement, DoWhileStatement, ETSFunctionType, ETSImportDeclaration, @@ -42,6 +44,7 @@ import { ETSNullType, ETSParameterExpression, ETSPrimitiveType, + ETSReExportDeclaration, ETSTypeReference, ETSTypeReferencePart, ETSUndefinedType, @@ -64,12 +67,14 @@ import { isBooleanLiteral, isBreakStatement, isCallExpression, + isCatchClause, isChainExpression, isClassDeclaration, isClassDefinition, isClassProperty, isClassStaticBlock, isConditionalExpression, + isContinueStatement, isDoWhileStatement, isETSFunctionType, isETSImportDeclaration, @@ -101,6 +106,8 @@ import { isSuperExpression, isSwitchCaseStatement, isSwitchStatement, + isTemplateElement, + isTemplateLiteral, isThisExpression, isThrowStatement, isTryStatement, @@ -114,6 +121,7 @@ import { isTSInterfaceHeritage, isTSNonNullExpression, isTSQualifiedName, + isTSThisType, isTSTypeAliasDeclaration, isTSTypeParameter, isTSTypeParameterDeclaration, @@ -135,6 +143,8 @@ import { SuperExpression, SwitchCaseStatement, SwitchStatement, + TemplateElement, + TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, @@ -148,6 +158,7 @@ import { TSInterfaceHeritage, TSNonNullExpression, TSQualifiedName, + TSThisType, TSTypeAliasDeclaration, TSTypeParameter, TSTypeParameterDeclaration, @@ -560,6 +571,13 @@ function buildNumberLiteral(builder: BuildingVisitor, node: AstNodeData): Number return new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral(global.context, parseInt(str))) } else { // TODO: bad workaround for es2panda bug 27251 + if (str == "0.0") { + return factory.createBinaryExpression( + new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, 0.1)), + new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, 0.1)), + Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_MINUS, + ) + } const eps = 0.0001 return factory.createBinaryExpression( new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, parseFloat(str) * (1 + eps))), @@ -745,7 +763,7 @@ function buildMemberExpression(builder: BuildingVisitor, node: AstNodeData): Mem function extractThisExpression(extractor: ExtractingVisitor, node: ThisExpression): AstNodeData { return { - type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE, + type: Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION, } } @@ -1535,7 +1553,7 @@ function extractForOfStatement(extractor: ExtractingVisitor, node: ForOfStatemen body: extractor.visitor(node.body), }, booleanData: { - isAsync: node.isAwait, + isAwait: node.isAwait, }, } } @@ -1549,6 +1567,81 @@ function buildForOfStatement(builder: BuildingVisitor, node: AstNodeData): ForOf ) } +function extractCatchClause(extractor: ExtractingVisitor, node: CatchClause): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE, + nodeData: { + param: extractor.visitor(node.param), + body: extractor.visitor(node.body), + }, + } +} + +function buildCatchClause(builder: BuildingVisitor, node: AstNodeData): CatchClause { + return factory.createCatchClause( + builder.visitor(node.nodeData!.param), + builder.visitor(node.nodeData!.body), + ) +} + +function extractTemplateLiteral(extractor: ExtractingVisitor, node: TemplateLiteral): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL, + nodeArrayData: { + quasis: extractor.arrayVisitor(node.quasis), + expressions: extractor.arrayVisitor(node.expressions), + }, + stringData: { + multilineString: node.multilineString, + }, + } +} + +function buildTemplateLiteral(builder: BuildingVisitor, node: AstNodeData): TemplateLiteral { + return factory.createTemplateLiteral( + builder.arrayVisitor(node.nodeArrayData!.quasis), + builder.arrayVisitor(node.nodeArrayData!.expressions), + node.stringData!.multilineString, + ) +} + +function extractTemplateElement(extractor: ExtractingVisitor, node: TemplateElement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT, + stringData: { + raw: node.raw, + cooked: node.cooked, + }, + } +} + +function buildTemplateElement(builder: BuildingVisitor, node: AstNodeData): TemplateElement { + return factory.createTemplateElement( + node.stringData!.raw, + node.stringData!.cooked, + ) +} + +function extractContinueStatement(extractor: ExtractingVisitor, node: ContinueStatement): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT, + } +} + +function buildContinueStatement(builder: BuildingVisitor, node: AstNodeData): ContinueStatement { + return factory.createContinueStatement() +} + +function extractTSThisType(extractor: ExtractingVisitor, node: TSThisType): AstNodeData { + return { + type: Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE, + } +} + +function buildTSThisType(builder: BuildingVisitor, node: AstNodeData): TSThisType { + return factory.createTSThisType() +} + export class ExtractingVisitor { arrayVisitor(nodes: MaybeAstNode[] | readonly MaybeAstNode[]): MaybeAstNodeData[] { return nodes.map(node => this.visitor(node)) @@ -1714,9 +1807,10 @@ export class ExtractingVisitor { if (isTSInterfaceBody(node)) { return extractTSInterfaceBody(this, node) } - if (isTSClassImplements(node)) { - return extractTSClassImplements(this, node) - } + // implemented properties cannot be processed in simultaneous mode + // if (isTSClassImplements(node)) { + // return extractTSClassImplements(this, node) + // } if (isArrowFunctionExpression(node)) { return extractArrowFunctionExpression(this, node) } @@ -1768,6 +1862,21 @@ export class ExtractingVisitor { if (isForOfStatement(node)) { return extractForOfStatement(this, node) } + if (isCatchClause(node)) { + return extractCatchClause(this, node) + } + if (isTemplateLiteral(node)) { + return extractTemplateLiteral(this, node) + } + if (isTemplateElement(node)) { + return extractTemplateElement(this, node) + } + if (isContinueStatement(node)) { + return extractContinueStatement(this, node) + } + if (isTSThisType(node)) { + return extractTSThisType(this, node) + } const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer) throw new Error( `Cannot extract node data for ${Es2pandaAstNodeType[nodeType]}` @@ -1864,7 +1973,7 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION) { return buildMemberExpression(this, node) } - if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE) { + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION) { return buildThisExpression(this, node) } if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION) { @@ -1996,6 +2105,21 @@ export class BuildingVisitor { if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT) { return buildForOfStatement(this, node) } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE) { + return buildCatchClause(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL) { + return buildTemplateLiteral(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT) { + return buildTemplateElement(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT) { + return buildContinueStatement(this, node) + } + if (node.type == Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE) { + return buildTSThisType(this, node) + } throw new Error( `Cannot build node for ${Es2pandaAstNodeType[node.type]}` ) diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index b549f4ae9..fc6317a0c 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -94,18 +94,15 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp console.log("UPDATE FOR", program.absoluteName) const module = program.ast as ETSModule const oldSource = program.ast.dumpSrc() - // class C implements I { prop: boolean } doesn't work - if (!program.absoluteName.endsWith("TimeAnimation.ts")) { - program.setAst( - factory.updateETSModule( - module, - builtAst!.statements, - module.ident, - module.getNamespaceFlag(), - module.program, - ) + program.setAst( + factory.updateETSModule( + module, + builtAst!.statements, + module.ident, + module.getNamespaceFlag(), + module.program, ) - } + ) const newSource = program.ast.dumpSrc() if (oldSource.split('\n').length != newSource.split('\n').length) { console.log("DIFF (LINES) =====================") -- Gitee From 8ce85013a4f6261bc4435ed26cb5822a5e625b76 Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Sat, 5 Jul 2025 22:33:22 +0300 Subject: [PATCH 18/20] more --- ui2abc/libarkts/src/arkts-api/CachingPlugins.ts | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 17ac66064..3740afd98 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -567,21 +567,21 @@ function extractNumberLiteral(extractor: ExtractingVisitor, node: NumberLiteral) function buildNumberLiteral(builder: BuildingVisitor, node: AstNodeData): NumberLiteral | BinaryExpression { // TODO: inconsistency, reported as es2panda bug 27252 const str = node.stringData!.str - if (str.match(/^(-?)[0-9]+$/)) { - return new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral(global.context, parseInt(str))) + if (str.match(/^(-?)((0x)?)[0-9|a-f|A-F]+$/)) { + return new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral1(global.context, parseInt(str))) } else { // TODO: bad workaround for es2panda bug 27251 if (str == "0.0") { return factory.createBinaryExpression( - new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, 0.1)), - new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, 0.1)), + new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral2(global.context, 0.1)), + new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral2(global.context, 0.1)), Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_MINUS, ) } const eps = 0.0001 return factory.createBinaryExpression( - new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, parseFloat(str) * (1 + eps))), - new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral3(global.context, parseFloat(str) * eps)), + new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral2(global.context, parseFloat(str) * (1 + eps))), + new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral2(global.context, parseFloat(str) * eps)), Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_MINUS, ) } -- Gitee From 49c1ce6f89812e13677b89fb5c0b0c315cf6da3c Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Thu, 10 Jul 2025 16:50:30 +0300 Subject: [PATCH 19/20] more --- ui2abc/libarkts/src/arkts-api/CachingPlugins.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts index 3740afd98..a7af7671a 100644 --- a/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts +++ b/ui2abc/libarkts/src/arkts-api/CachingPlugins.ts @@ -525,7 +525,7 @@ function extractTSEnumDeclaration(extractor: ExtractingVisitor, node: TSEnumDecl } function buildTSEnumDeclaration(builder: BuildingVisitor, node: AstNodeData): TSEnumDeclaration { - return TSEnumDeclaration.createTSEnumDeclaration( + return TSEnumDeclaration.create1TSEnumDeclaration( builder.visitor(node.nodeData!.key), builder.arrayVisitor(node.nodeArrayData!.members), node.booleanData!.isConst, @@ -568,7 +568,7 @@ function buildNumberLiteral(builder: BuildingVisitor, node: AstNodeData): Number // TODO: inconsistency, reported as es2panda bug 27252 const str = node.stringData!.str if (str.match(/^(-?)((0x)?)[0-9|a-f|A-F]+$/)) { - return new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral1(global.context, parseInt(str))) + return new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral(global.context, parseInt(str))) } else { // TODO: bad workaround for es2panda bug 27251 if (str == "0.0") { -- Gitee From bea02cf2df8ab217136e49d5f466fcaf2c5ab14f Mon Sep 17 00:00:00 2001 From: Igor Loginov Date: Fri, 1 Aug 2025 23:08:07 +0300 Subject: [PATCH 20/20] fix imports --- ui2abc/libarkts/src/plugin-utils.ts | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/ui2abc/libarkts/src/plugin-utils.ts b/ui2abc/libarkts/src/plugin-utils.ts index fc6317a0c..3c7faff2f 100644 --- a/ui2abc/libarkts/src/plugin-utils.ts +++ b/ui2abc/libarkts/src/plugin-utils.ts @@ -23,8 +23,12 @@ import { Program, ProgramProvider, CompilationOptions, - dumpProgramSrcFormatted + dumpProgramSrcFormatted, + ETSModule, + factory, + setAllParents } from "./arkts-api" +import { BuildingVisitor, ExtractingVisitor } from "./arkts-api/CachingPlugins" export interface RunTransformerHooks { onProgramTransformStart?(options: CompilationOptions, program: Program): void -- Gitee