@idlizer/arktscgen 2.1.10-arktscgen-9 → 2.1.10-arktscgen-10

package/build/libarkts-copy/src/arkts-api/plugins.ts

@@ -61,6 +61,7 @@ export interface ProjectConfig {
     frameworkMode?: string;
     isUi2abc?: boolean;
     memoPluginOptions?: Object;
+    uiPluginOptions?: Object;
 }
 
 export interface PluginContextBase {

package/build/libarkts-copy/src/arkts-api/utilities/performance.ts

@@ -56,22 +56,34 @@ function round(value: number, index: number = 2): number {
     return Math.round(value * factor) / factor;
 }
 
+interface DetailedEventInfo {
+    duration: number;
+    count: number;
+}
+
 export class Performance {
     private static instance: Performance;
     private events: Map<string, Event>;
+    private detailedEvents: Map<string, Event>;
     private historyEvents = new Map<string | null, Event[]>();
     private scopes: string[];
     private shouldSkip: boolean;
+    private shouldSkipDetail: boolean;
     private totalDuration: number;
     private memoryContexts = new Map<string, MemoryContext>();
     private memoryTrackerEnable: boolean;
+    private detailedEventInfos: Map<string, DetailedEventInfo>;
+
     private constructor() {
         this.events = new Map();
+        this.detailedEvents = new Map();
         this.historyEvents = new Map();
         this.scopes = [];
         this.shouldSkip = true;
+        this.shouldSkipDetail = true;
         this.memoryTrackerEnable = false;
         this.totalDuration = 0;
+        this.detailedEventInfos = new Map<string, DetailedEventInfo>();
     }
 
     public static getInstance(): Performance {
@@ -81,8 +93,14 @@ export class Performance {
         return this.instance;
     }
 
-    skip(shouldSkip: boolean = true): void {
+    skip(shouldSkip: boolean = true): this {
         this.shouldSkip = shouldSkip;
+        return this;
+    }
+
+    skipDetail(shouldSkipDetail: boolean = true): this {
+        this.shouldSkipDetail = shouldSkipDetail;
+        return this;
     }
 
     enableMemoryTracker(enableMemoryTracker: boolean = false): void {
@@ -100,6 +118,57 @@ export class Performance {
         return newEvent;
     }
 
+    logDetailedEventInfos(shouldLog: boolean = false): void {
+        if (!shouldLog) {
+            return;
+        }
+        const sortedEvents = new Map([...this.detailedEventInfos.entries()].sort((a, b) => a[0].localeCompare(b[0])));
+        for (const [key, value] of sortedEvents) {
+            const dura = formatTime(value.duration);
+            const duraRound = round(value.duration);
+            const perDura = formatTime(value.duration / value.count);
+            const duraPerDura = round(value.duration / value.count);
+            console.log(
+                `[PERFORMANCE] name: ${key}, detailed-total-duration: ${dura}(${duraRound}), total-count: ${value.count}, time-per-conversion: ${perDura}(${duraPerDura})`
+            );
+        }
+    }
+
+    createDetailedEvent(name: string) {
+        if (this.shouldSkipDetail) {
+            return { name: '', startTime: 0 };
+        }
+        const startTime: number = performance.now();
+        const newEvent: Event = { name, startTime };
+        this.detailedEvents.set(name, newEvent);
+    }
+
+    stopDetailedEvent(name: string, shouldLog: boolean = false) {
+        if (this.shouldSkipDetail) {
+            return { name: '', startTime: 0 };
+        }
+        if (!this.detailedEvents.has(name)) {
+            throw new Error(`Event ${name} is not created.`);
+        }
+
+        const event: Event = this.detailedEvents.get(name)!;
+        const endTime: number = performance.now();
+        const duration: number = endTime - event.startTime;
+
+        let totalDetailedDuration = duration;
+        let totalDetailedCount = 1;
+        if (this.detailedEventInfos.has(name)) {
+            const lastInfo = this.detailedEventInfos.get(name)!;
+            totalDetailedDuration += lastInfo.duration;
+            totalDetailedCount += lastInfo.count;
+        }
+
+        this.detailedEventInfos.set(name, {
+            duration: totalDetailedDuration,
+            count: totalDetailedCount,
+        });
+    }
+
     stopEvent(name: string, shouldLog: boolean = false): Event {
         if (this.shouldSkip) {
             return { name: '', startTime: 0 };
@@ -122,7 +191,9 @@ export class Performance {
 
         if (shouldLog) {
             console.log(
-                `[PERFORMANCE] name: ${event.name}, parent: ${parentEvent}, duration: ${formatTime(duration)}(${round(duration)}), total: ${formatTime(this.totalDuration)}(${round(this.totalDuration)})`
+                `[PERFORMANCE] name: ${event.name}, parent: ${parentEvent}, duration: ${formatTime(duration)}(${round(
+                    duration
+                )}), total: ${formatTime(this.totalDuration)}(${round(this.totalDuration)})`
             );
         }
 
@@ -154,7 +225,9 @@ export class Performance {
 
         if (shouldLog) {
             console.log(
-                `[PERFORMANCE] name: ${event.name}, parent: ${parentEvent}, duration: ${formatTime(duration)}(${round(duration)}), total: ${formatTime(this.totalDuration)}(${round(this.totalDuration)})`
+                `[PERFORMANCE] name: ${event.name}, parent: ${parentEvent}, duration: ${formatTime(duration)}(${round(
+                    duration
+                )}), total: ${formatTime(this.totalDuration)}(${round(this.totalDuration)})`
             );
         }
 
@@ -176,6 +249,8 @@ export class Performance {
 
     clearTotalDuration(): void {
         this.totalDuration = 0;
+        this.detailedEventInfos.clear();
+        this.detailedEvents.clear();
     }
 
     clearHistory(): void {
@@ -273,23 +348,38 @@ export class Performance {
         console.log('---------------------------------------------------------------');
         console.log(
             '[PERFORMANCE]',
-            `RSS            | ${context.startMemory.rss.toFixed(2)}    | ${(endMemory.rss / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.rss.toFixed(2)}`
+            `RSS            | ${context.startMemory.rss.toFixed(2)}    | ${(
+                endMemory.rss /
+                (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)
+            ).toFixed(2)}    | ${memoryDiff.rss.toFixed(2)}`
         );
         console.log(
             '[PERFORMANCE]',
-            `Heap Total     | ${context.startMemory.heapTotal.toFixed(2)}    | ${(endMemory.heapTotal / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.heapTotal.toFixed(2)}`
+            `Heap Total     | ${context.startMemory.heapTotal.toFixed(2)}    | ${(
+                endMemory.heapTotal /
+                (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)
+            ).toFixed(2)}    | ${memoryDiff.heapTotal.toFixed(2)}`
         );
         console.log(
             '[PERFORMANCE]',
-            `Heap Used      | ${context.startMemory.heapUsed.toFixed(2)}    | ${(endMemory.heapUsed / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.heapUsed.toFixed(2)}`
+            `Heap Used      | ${context.startMemory.heapUsed.toFixed(2)}    | ${(
+                endMemory.heapUsed /
+                (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)
+            ).toFixed(2)}    | ${memoryDiff.heapUsed.toFixed(2)}`
         );
         console.log(
             '[PERFORMANCE]',
-            `External       | ${context.startMemory.external.toFixed(2)}    | ${(endMemory.external / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.external.toFixed(2)}`
+            `External       | ${context.startMemory.external.toFixed(2)}    | ${(
+                endMemory.external /
+                (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)
+            ).toFixed(2)}    | ${memoryDiff.external.toFixed(2)}`
         );
-        if (!!endMemory.arrayBuffers) {
+        if (endMemory.arrayBuffers !== undefined) {
             console.log(
-                `Array Buffers  | ${context.startMemory.arrayBuffers.toFixed(2)}    | ${((endMemory.arrayBuffers || 0) / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.arrayBuffers.toFixed(2)}`
+                `Array Buffers  | ${context.startMemory.arrayBuffers.toFixed(2)}    | ${(
+                    (endMemory.arrayBuffers || 0) /
+                    (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)
+                ).toFixed(2)}    | ${memoryDiff.arrayBuffers.toFixed(2)}`
             );
         }
         console.log('---------------------------------------------------------------');

package/build/libarkts-copy/src/arkts-api/utilities/public.ts

@@ -20,9 +20,7 @@ import {
     passNode,
     unpackNodeArray,
     unpackNonNullableNode,
-    passString,
     unpackString,
-    passStringArray,
     unpackNode,
 } from './private';
 import {
@@ -30,20 +28,18 @@ import {
     Es2pandaModifierFlags,
     Es2pandaMethodDefinitionKind,
     Es2pandaAstNodeType,
-    Es2pandaPluginDiagnosticType,
 } from '../../../generated/Es2pandaEnums';
 import type { AstNode } from '../peers/AstNode';
 import {
-    DiagnosticInfo,
+    AnnotationAllowed,
     Identifier,
     isConditionalExpression,
     SourcePosition,
-    SourceRange,
-    SuggestionInfo,
     VariableDeclarator,
 } from '../../../generated';
 import {
-    type AnnotationUsage,
+    AnnotationUsage,
+    compiler,
     ClassDefinition,
     ClassProperty,
     ETSModule,
@@ -63,14 +59,12 @@ import {
     MemberExpression,
     isMethodDefinition,
     TypeNode,
-    DiagnosticKind
 } from '../../../generated';
 import { Config } from '../peers/Config';
 import { Context } from '../peers/Context';
 import { NodeCache } from '../node-cache';
 import { factory } from '../factory/nodeFactory';
 import { traceGlobal } from '../../tracer';
-import { compiler } from '../../../generated';
 
 /**
  * Improve: Replace or remove with better naming
@@ -78,15 +72,8 @@ import { compiler } from '../../../generated';
  * @deprecated
  */
 export function createETSModuleFromContext(): ETSModule {
-    let program = global.generatedEs2panda._ContextProgram(global.context);
-    if (program === nullptr || program === null) {
-        throw new Error(`Program is null for context ${global.context.toString(16)}`);
-    }
-    const ast = global.generatedEs2panda._ProgramAst(global.context, program);
-    if (ast === nullptr || ast === null) {
-        throw new Error(`AST is null for program ${program.toString(16)}`);
-    }
-    return new ETSModule(ast, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE);
+    const program = compiler.contextProgram();
+    return program.getAstCasted();
 }
 
 /**
@@ -104,13 +91,8 @@ export function createETSModuleFromSource(
     }
     global.compilerContext = Context.createFromString(source);
     proceedToState(state);
-    let program = global.generatedEs2panda._ContextProgram(global.compilerContext.peer);
-    if (program === nullptr)
-        throw new Error(`Program is null for ${source} 0x${global.compilerContext.peer.toString(16)}`);
-    return new ETSModule(
-        global.generatedEs2panda._ProgramAst(global.context, program),
-        Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE
-    );
+    const program = compiler.contextProgram();
+    return program.getAstCasted();
 }
 
 export function metaDatabase(fileName: string): string {
@@ -118,26 +100,31 @@ export function metaDatabase(fileName: string): string {
     return `${fileName}.meta.json`;
 }
 
-export function checkErrors() {
-    if (global.es2panda._ContextState(global.context) === Es2pandaContextState.ES2PANDA_STATE_ERROR) {
+export function checkErrors(proceedTo?: string) {
+    if (compiler.contextState() === Es2pandaContextState.ES2PANDA_STATE_ERROR) {
         traceGlobal(() => `Terminated due to compilation errors occured`);
-        console.log(unpackString(global.generatedEs2panda._GetAllErrorMessages(global.context)));
-        // global.es2panda._DestroyConfig(global.config)
-        throw new Error(`Compilation error`)
-    }
-}
-
-function format(value: number): string {
-    return `${(value / 1024 / 1024 / 1024).toFixed(4)} GB`
-}
 
-// Improve: move to profiler
-function dumpMemoryProfilerInfo(str: string) {
-    console.log(str, format(process.memoryUsage().rss));
+        const errorMessage = compiler.contextErrorMessage();
+        if (errorMessage === undefined) {
+            throwError(`Could not get ContextErrorMessage`);
+        }
+        const allErrorMessages = compiler.getAllErrorMessages();
+        if (allErrorMessages === undefined) {
+            throwError(`Could not get AllErrorMessages`);
+        }
+        const actionMsg = proceedTo ? " to " + proceedTo : ""
+        throwError([`Failed to proceed${actionMsg}`, errorMessage, allErrorMessages].join(`\n`));
+    }
 }
 
-export function proceedToState(state: Es2pandaContextState): void {
-    if (state <= global.es2panda._ContextState(global.context)) {
+export function proceedToState(state: Es2pandaContextState, _contextPtr?: KNativePointer, ignoreErrors = false): void {
+    if (compiler.contextState() === Es2pandaContextState.ES2PANDA_STATE_ERROR) {
+        NodeCache.clear();
+        if (!ignoreErrors) {
+            checkErrors(Es2pandaContextState[state]);
+        }
+    }
+    if (state <= compiler.contextState()) {
         return;
     }
     NodeCache.clear();
@@ -147,17 +134,16 @@ export function proceedToState(state: Es2pandaContextState): void {
     traceGlobal(() => `Proceeding to state ${Es2pandaContextState[state]}: done`);
     const after = Date.now();
     global.profiler.proceededToState(after - before);
-    if (state == Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) {
-        dumpMemoryProfilerInfo("Memory usage (rss) after proceed to bin:")
+    if (!ignoreErrors) {
+        checkErrors(Es2pandaContextState[state]);
     }
-    checkErrors();
 }
 
 /** @deprecated Use {@link rebindContext} instead */
 export function rebindSubtree(node: AstNode): void {
     NodeCache.clear();
     traceGlobal(() => `Rebind: start`);
-    global.es2panda._AstNodeRebind(global.context, node.peer);
+    compiler.astNodeRebind(node);
     traceGlobal(() => `Rebind: done`);
     checkErrors();
 }
@@ -166,18 +152,14 @@ export function rebindSubtree(node: AstNode): void {
 export function recheckSubtree(node: AstNode): void {
     NodeCache.clear();
     traceGlobal(() => `Recheck: start`);
-    global.generatedEs2panda._AstNodeRecheck(global.context, node.peer);
+    compiler.astNodeRecheck(node);
     traceGlobal(() => `Recheck: done`);
-    checkErrors();
 }
 
 export function rebindContext(context: KNativePointer = global.context): void {
     NodeCache.clear();
     traceGlobal(() => `Rebind: start`);
-    global.es2panda._AstNodeRebind(
-        context,
-        global.generatedEs2panda._ProgramAst(context, global.generatedEs2panda._ContextProgram(context))
-    );
+    compiler.astNodeRebind(compiler.contextProgram().getAstCasted());
     traceGlobal(() => `Rebind: done`);
     checkErrors();
 }
@@ -185,10 +167,7 @@ export function rebindContext(context: KNativePointer = global.context): void {
 export function recheckContext(context: KNativePointer = global.context): void {
     NodeCache.clear();
     traceGlobal(() => `Recheck: start`);
-    global.generatedEs2panda._AstNodeRecheck(
-        context,
-        global.generatedEs2panda._ProgramAst(context, global.generatedEs2panda._ContextProgram(context))
-    );
+    compiler.astNodeRecheck(compiler.contextProgram().getAstCasted());
     traceGlobal(() => `Recheck: done`);
     checkErrors();
 }
@@ -257,10 +236,6 @@ export function getPeerDecl(peer: KNativePointer): AstNode | undefined {
     return unpackNonNullableNode(decl);
 }
 
-export function declarationFromIdentifier(node: Identifier): AstNode | undefined {
-    return unpackNode(global.generatedEs2panda._DeclarationFromIdentifier(global.context, node.peer));
-}
-
 export function resolveGensymVariableDeclaratorForDefaultParam(node: VariableDeclarator): Identifier | undefined {
     const init = node.init;
     if (
@@ -281,6 +256,14 @@ export function resolveGensymVariableDeclaratorForOptionalCall(node: VariableDec
     return undefined;
 }
 
+export function getPeerIdentifierDecl(peer: KNativePointer): AstNode | undefined {
+    const decl = global.generatedEs2panda._DeclarationFromIdentifier(global.context, peer);
+    if (decl === nullptr) {
+        return undefined;
+    }
+    return unpackNonNullableNode(decl);
+}
+
 export function getPeerObjectDecl(peer: KNativePointer): AstNode | undefined {
     const decl = global.es2panda._ClassVariableDeclaration(global.context, peer);
     if (decl === nullptr) {
@@ -289,11 +272,28 @@ export function getPeerObjectDecl(peer: KNativePointer): AstNode | undefined {
     return unpackNonNullableNode(decl);
 }
 
+export function getPeerMemberDecl(peer: KNativePointer): AstNode | undefined {
+    const decl = global.es2panda._DeclarationFromMemberExpression(global.context, peer);
+    if (decl === nullptr) {
+        return undefined;
+    }
+    return unpackNonNullableNode(decl);
+}
+
+export function getPeerPropertyDecl(peer: KNativePointer): AstNode | undefined {
+    const decl = global.es2panda._DeclarationFromProperty(global.context, peer);
+    if (decl === nullptr) {
+        return undefined;
+    }
+    return unpackNonNullableNode(decl);
+}
+
+
 export function getAnnotations(node: AstNode): readonly AnnotationUsage[] {
     if (!isFunctionDeclaration(node) && !isScriptFunction(node) && !isClassDefinition(node)) {
         throwError('for now annotations allowed only for: functionDeclaration, scriptFunction, classDefinition');
     }
-    return unpackNodeArray(global.generatedEs2panda._AnnotationAllowedAnnotations(global.context, node.peer));
+    return new AnnotationAllowed(node.peer).annotations
 }
 
 export function getOriginalNode(node: AstNode): AstNode {
@@ -321,7 +321,7 @@ export function getJsDoc(node: AstNode): string | undefined {
 // Use this function if you need
 // the language level modifiers: public, declare, export, etc.
 export function classDefinitionFlags(node: ClassDefinition): Es2pandaModifierFlags {
-    return global.generatedEs2panda._AstNodeModifiers(global.context, node.peer);
+    return node.modifierFlags
 }
 
 // Improve: ClassProperty's optional flag is set by AstNode's modifiers flags.
@@ -377,25 +377,6 @@ export function findStdlib(): string {
     return `${sdk}/ets/stdlib`;
 }
 
-export function generateTsDeclarationsFromContext(
-    outputDeclEts: string,
-    outputEts: string,
-    exportAll: boolean,
-    isolated: boolean,
-    recordFile: string,
-    genAnnotations: boolean
-): KInt {
-    return global.generatedEs2panda._GenerateTsDeclarationsFromContext(
-        global.context,
-        passString(outputDeclEts),
-        passString(outputEts),
-        exportAll,
-        isolated,
-        recordFile,
-        genAnnotations
-    );
-}
-
 export function setAllParents(ast: AstNode): void {
     global.es2panda._AstNodeUpdateAll(global.context, ast.peer);
 }
@@ -405,7 +386,7 @@ export function getProgramFromAstNode(node: AstNode): Program {
 }
 
 export function importDeclarationInsert(node: ETSImportDeclaration, program: Program): void {
-    global.generatedEs2panda._InsertETSImportDeclarationAndParse(global.context, program.peer, node.peer);
+    compiler.insertETSImportDeclarationAndParse(program, node);
 }
 
 export function signatureReturnType(signature: KNativePointer): KNativePointer {
@@ -438,10 +419,6 @@ export function originalSourcePositionString(node: AstNode | undefined) {
     return `[${program.absoluteName}${sourcePosition.toString()}]`;
 }
 
-export function generateStaticDeclarationsFromContext(outputPath: string): KInt {
-    return global.generatedEs2panda._GenerateStaticDeclarationsFromContext(global.context, passString(outputPath));
-}
-
 export function createTypeNodeFromTsType(node: AstNode): AstNode | undefined {
     const typeAnnotation = global.es2panda._CreateTypeNodeFromTsType(global.context, node.peer);
     if (typeAnnotation === nullptr) {
@@ -450,62 +427,6 @@ export function createTypeNodeFromTsType(node: AstNode): AstNode | undefined {
     return unpackNonNullableNode(typeAnnotation);
 }
 
-export function createSourcePosition(index: KUInt, line: KUInt): SourcePosition {
-    return new SourcePosition(global.generatedEs2panda._CreateSourcePosition(global.context, index, line));
-}
-
-export function createSourceRange(start: SourcePosition, end: SourcePosition): SourceRange {
-    return new SourceRange(global.generatedEs2panda._CreateSourceRange(global.context, start.peer, end.peer));
-}
-
-export function createDiagnosticInfo(
-    kind: DiagnosticKind,
-    position: SourcePosition,
-    ...args: string[]
-): DiagnosticInfo {
-    return new DiagnosticInfo(
-        global.generatedEs2panda._CreateDiagnosticInfo(
-            global.context,
-            kind.peer,
-            passStringArray(args),
-            args.length,
-            position.peer
-        )
-    );
-}
-
-export function createSuggestionInfo(
-    kind: DiagnosticKind,
-    substitutionCode: string,
-    title: string,
-    range: SourceRange,
-    ...args: string[]
-): SuggestionInfo {
-    return new SuggestionInfo(
-        global.generatedEs2panda._CreateSuggestionInfo(
-            global.context,
-            kind.peer,
-            passStringArray(args),
-            args.length,
-            substitutionCode,
-            title,
-            range.peer
-        )
-    );
-}
-
-export function createDiagnosticKind(message: string, type: Es2pandaPluginDiagnosticType): DiagnosticKind {
-    return new DiagnosticKind(global.es2panda._CreateDiagnosticKind(global.context, message, type));
-}
-
-export function logDiagnostic(kind: DiagnosticKind, pos: SourcePosition, ...args: string[]): void {
-    global.es2panda._LogDiagnostic(global.context, kind.peer, passStringArray(args), args.length, pos.peer);
-}
-
-export function logDiagnosticWithSuggestion(diagnosticInfo: DiagnosticInfo, suggestionInfo: SuggestionInfo): void {
-    global.generatedEs2panda._LogDiagnosticWithSuggestion(global.context, diagnosticInfo.peer, suggestionInfo.peer);
-}
-
 export function filterNodes(node: AstNode, filter: string, deeperAfterMatch: boolean): AstNode[] {
     return unpackNodeArray(global.es2panda._FilterNodes(global.context, passNode(node), filter, deeperAfterMatch));
 }
@@ -522,12 +443,8 @@ export function filterNodesByTypes(node: AstNode, types: Es2pandaAstNodeType[]):
     return unpackNodeArray(global.es2panda._FilterNodes3(global.context, passNode(node), typesArray, types.length));
 }
 
-// This functions are used as capitalized in build-system, unlike the others
-// See https://gitcode.com/openharmony/arkcompiler_ets_frontend/issues/8196
-export function MemInitialize() {
-    compiler.memInitialize()
-}
-
-export function MemFinalize() {
-    compiler.memFinalize()
+export function jumpFromETSTypeReferenceToTSTypeAliasDeclarationTypeAnnotation(node: AstNode): AstNode | undefined {
+    return unpackNode(
+        global.es2panda._JumpFromETSTypeReferenceToTSTypeAliasDeclarationTypeAnnotation(global.context, passNode(node))
+    );
 }

package/build/libarkts-copy/src/arkts-api/visitor.ts

@@ -19,6 +19,7 @@ import {
     ArrayExpression,
     ArrowFunctionExpression,
     AssignmentExpression,
+    AwaitExpression,
     BinaryExpression,
     BlockExpression,
     BlockStatement,
@@ -764,6 +765,7 @@ function visitClassProperty(node: ClassProperty, visitor: Visitor): ClassPropert
             result.onUpdate(node);
             return result;
         }
+        node.setKey(newKey);
         node.setValue(newValue);
         node.setTypeAnnotation(newTypeAnnotation);
         node.setAnnotations(newAnnotations);
@@ -773,12 +775,12 @@ function visitClassProperty(node: ClassProperty, visitor: Visitor): ClassPropert
 
 function visitProperty(node: Property, visitor: Visitor): Property {
     global.updateTracker.push();
+    const oldKey = node.key;
     const newKey = nodeVisitor(node.key, visitor);
     const newValue = nodeVisitor(node.value, visitor);
     if (global.updateTracker.check()) {
-        const result = factory.createProperty(node.kind, newKey, newValue, node.isMethod, node.isComputed);
-        result.onUpdate(node);
-        return result;
+        node.setKey(newKey);
+        node.setValue(newValue);
     }
     return node;
 }
@@ -957,6 +959,17 @@ function visitClassStaticBlock(node: ClassStaticBlock, visitor: Visitor): ClassS
     return node;
 }
 
+function visitAwaitExpression(node: AwaitExpression, visitor: Visitor): AwaitExpression {
+    global.updateTracker.push();
+    const newArgument = nodeVisitor(node.argument, visitor);
+    if (global.updateTracker.check()) {
+        const result = factory.createAwaitExpression(newArgument);
+        result.onUpdate(node);
+        return result;
+    }
+    return node;
+}
+
 const visitsTable: (((node: any, visitor: Visitor) => any) | undefined)[] = [];
 
 export function initVisitsTable(): void {
@@ -1017,6 +1030,7 @@ export function initVisitsTable(): void {
     visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION] = visitTSTypeParameterDeclaration;
     visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION] = visitTSTypeParameterInstantiation;
     visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK] = visitClassStaticBlock;
+    visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION] = visitAwaitExpression;
 }
 
 initVisitsTable();

package/build/libarkts-copy/src/utils.ts

@@ -245,3 +245,7 @@ export function filterSource(text: string): string {
     // console.error(dumperUnwrappers.reduceRight((code, f) => f(code), text).split('\n').map((it, index) => `${`${index + 1}`.padStart(4)} |${it}`).join('\n'))
     return dumperUnwrappers.reduceRight((code, f) => f(code), text);
 }
+
+export function getEnumName(enumType: any, value: number): string | undefined {
+    return enumType[value];
+}