@idlizer/arktscgen 2.1.9-arktscgen-9 → 2.1.10-arktscgen-3

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

@@ -13,22 +13,41 @@
  * limitations under the License.
  */
 
+import { KNativePointer } from "@koalaui/interop"
 import { ObjectExpression, Expression } from "../../generated"
 import { isSameNativeObject } from "../peers/ArktsObject"
-import { nodeType, updateNodeByNode } from "../utilities/private"
+import { updateNodeByNode } from "../utilities/private"
+import { Es2pandaAstNodeType } from "../../generated/Es2pandaEnums"
+
+export function createObjectExpression(
+    properties: readonly Expression[],
+    preferredReturnType?: KNativePointer,
+): ObjectExpression {
+    const result = ObjectExpression.createObjectExpression(
+        Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION,
+        properties,
+        false, // Improve: provide trailingComma value from native module through ObjectExpression?
+    )
+    if (preferredReturnType) {
+        result.setPreferredTypePointer(preferredReturnType)
+    }
+    return result
+}
 
 export function updateObjectExpression(
     original: ObjectExpression,
-    properties: readonly Expression[]
+    properties: readonly Expression[],
+    preferredReturnType?: KNativePointer,
 ): ObjectExpression {
-    if (isSameNativeObject(properties, original.properties)){
+    if (isSameNativeObject(properties, original.properties)
+        && preferredReturnType == original.getPreferredTypePointer()) {
         return original
     }
     return updateNodeByNode(
-        ObjectExpression.createObjectExpression(
-            nodeType(original),
+        createObjectExpression(
             properties,
-            false), // Improve: provide trailingComma value from native module through ObjectExpression?
+            preferredReturnType
+        ),
         original
     )
 }

package/build/libarkts-copy/src/{wrapper-compat/arkts-api/peers/ImportPathManager.ts → arkts-api/node-utilities/OpaqueTypeNode.ts}

@@ -13,22 +13,13 @@
  * limitations under the License.
  */
 
-import { ArktsObject } from "../../../arkts-api/peers/ArktsObject"
-import { global } from "../static/global"
 import { KNativePointer } from "@koalaui/interop"
+import { global } from "../static/global"
+import { OpaqueTypeNode } from "../../generated"
+import { Es2pandaAstNodeType } from "../../generated/Es2pandaEnums"
 
-export class ImportPathManager extends ArktsObject {
-    constructor(peer: KNativePointer) {
-        super(peer)
-    }
-
-    static create(): ImportPathManager {
-        return new ImportPathManager(
-            global.es2panda._ETSParserGetImportPathManager(global.context)
-        );
-    }
-
-    resolvePath(currentModulePath: string, importPath: string): string {
-        return ''; // Improve: no longer support this.
-    }
-}
+export function createOpaqueTypeNode(
+    typePointer: KNativePointer
+): OpaqueTypeNode {
+    return new OpaqueTypeNode(global.es2panda._Checker_CreateOpaqueTypeNode(global.context, typePointer), Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE)
+}

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

@@ -14,18 +14,19 @@
  */
 
 import { Program } from "../../generated"
+import { traceGlobal } from "../../tracer"
 
 export function dumpProgramInfo(program: Program) {
-    console.log(`Program info:`)
-    console.log(`\tAbsoluteName:          ${program.absoluteName}`)
-    console.log(`\tFileName:              ${program.fileName}`)
-    console.log(`\tFileNameWithExtension: ${program.fileNameWithExtension}`)
-    console.log(`\tModuleName:            ${program.moduleName}`)
-    console.log(`\tModulePrefix:          ${program.modulePrefix}`)
-    console.log(`\tRelativeFilePath:      ${program.relativeFilePath}`)
-    console.log(`\tResolvedFilePath:      ${program.resolvedFilePath}`)
-    console.log(`\tSourceFileFolder:      ${program.sourceFileFolder}`)
-    console.log(`\tSourceFilePath:        ${program.sourceFilePath}`)
+    traceGlobal(() => `Program info:`)
+    traceGlobal(() => `\tAbsoluteName:          ${program.absoluteName}`)
+    traceGlobal(() => `\tFileName:              ${program.fileName}`)
+    traceGlobal(() => `\tFileNameWithExtension: ${program.fileNameWithExtension}`)
+    traceGlobal(() => `\tModuleName:            ${program.moduleName}`)
+    traceGlobal(() => `\tModulePrefix:          ${program.modulePrefix}`)
+    traceGlobal(() => `\tRelativeFilePath:      ${program.relativeFilePath}`)
+    traceGlobal(() => `\tResolvedFilePath:      ${program.resolvedFilePath}`)
+    traceGlobal(() => `\tSourceFileFolder:      ${program.sourceFileFolder}`)
+    traceGlobal(() => `\tSourceFilePath:        ${program.sourceFilePath}`)
 }
 
 export function dumpProgramSrcFormatted(program: Program, recursive: boolean, withLines: boolean = true) {

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

@@ -107,4 +107,4 @@ export function updateScriptFunction(
         ),
         original
     )
-}
+}

package/build/libarkts-copy/src/arkts-api/peers/AstNode.ts

@@ -17,19 +17,21 @@ import { isNullPtr, KInt, KNativePointer, nullptr } from "@koalaui/interop"
 import { global } from "../static/global"
 import { allFlags, unpackNode, unpackNodeArray, unpackNonNullableNode, unpackString } from "../utilities/private"
 import { throwError } from "../../utils"
-import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
+import { Es2pandaAstNodeType, Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
 import { ArktsObject } from "./ArktsObject"
-import { SourcePosition } from "./SourcePosition"
+import { SourcePosition } from "../../generated/peers/SourcePosition"
 import { NodeCache } from "../node-cache"
 
 export abstract class AstNode extends ArktsObject {
-    protected constructor(peer: KNativePointer) {
+    public readonly astNodeType: Es2pandaAstNodeType
+
+    protected constructor(peer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
         global.profiler.nodeCreated()
         if (isNullPtr(peer)) {
             throwError(`attempted to create AstNode from nullptr`)
         }
         super(peer)
-        this.setChildrenParentPtr()
+        this.astNodeType = astNodeType
         NodeCache.addToCache(peer, this)
     }
 
@@ -46,6 +48,10 @@ export abstract class AstNode extends ArktsObject {
         global.generatedEs2panda._AstNodeSetOriginalNode(global.context, this.peer, peer)
     }
 
+    public get original(): this {
+        return unpackNonNullableNode(this.originalPeer)
+    }
+
     public getChildren(): readonly AstNode[] {
         return unpackNodeArray(global.es2panda._AstNodeChildren(global.context, this.peer))
     }
@@ -153,9 +159,8 @@ export abstract class AstNode extends ArktsObject {
     public override onUpdate(original: AstNode): void {
         // Improve: Update modifiers only for specific AST nodes in the generated factory code
         this.modifierFlags = original.modifierFlags
-        global.generatedEs2panda._AstNodeSetOriginalNode(global.context, this.peer, original.originalPeer)
-        global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, global.generatedEs2panda._AstNodeParent(global.context, original.peer))
-        this.setChildrenParentPtr()
+
+        global.es2panda._AstNodeOnUpdate(global.context, this.peer, original.peer)
     }
 
     public get isExport(): boolean {

package/build/libarkts-copy/src/arkts-api/peers/Config.ts

@@ -17,6 +17,7 @@ import { ArktsObject } from "./ArktsObject"
 import { global } from "../static/global"
 import { passStringArray } from "../utilities/private"
 import { KNativePointer, nullptr } from "@koalaui/interop"
+import { Es2pandaCompilationMode } from "../../generated/Es2pandaEnums"
 
 export class Config extends ArktsObject {
     constructor(peer: KNativePointer) {
@@ -55,5 +56,10 @@ export class Config extends ArktsObject {
         }
     }
 
+    get compilationMode(): Es2pandaCompilationMode {
+        return global.es2panda._GetCompilationMode(this.peer);
+    }
+
+
     readonly path: string
 }

package/build/libarkts-copy/src/arkts-api/peers/Context.ts

@@ -52,22 +52,10 @@ export class Context extends ArktsObject {
         );
     }
 
-    static createFromFile(filePath: string, configPath: string, stdlibPath: string, outputPath: string): Context | undefined {
-        const config = Config.create([
-            "",
-            "--arktsconfig",
-            configPath,
-            '--extension',
-            'ets',
-            '--stdlib',
-            stdlibPath,
-            filePath,
-            '--output',
-            outputPath,
-        ])
+    static createFromFile(filePath: string): Context {
         return new Context(
             global.es2panda._CreateContextFromFile(
-                config.peer,
+                global.config,
                 passString(filePath)
             )
         )
@@ -112,7 +100,7 @@ export class Context extends ArktsObject {
     }
 
     get program(): Program {
-        return new Program(global.es2panda._ContextProgram(this.peer));
+        return new Program(global.generatedEs2panda._ContextProgram(this.peer));
     }
 }
 

package/build/libarkts-copy/src/{wrapper-compat/arkts-api/peers/AstNode.ts → arkts-api/peers/DiagnosticKind.ts}

@@ -13,14 +13,12 @@
  * limitations under the License.
  */
 
-import { KNativePointer as KPtr } from '@koalaui/interop';
+import { KNativePointer } from "@koalaui/interop";
+import { ArktsObject } from "./ArktsObject"
 
-import { AstNode } from "../../../arkts-api/peers/AstNode"
 
-export { AstNode }
-
-export class UnsupportedNode extends AstNode {
-    constructor(peer: KPtr) {
-        super(peer);
-    }
+export class DiagnosticKind extends ArktsObject {
+  constructor(peer: KNativePointer) {
+    super(peer);
+  }
 }

package/build/libarkts-copy/src/arkts-api/static/global.ts

@@ -21,15 +21,34 @@ import { initInterop, InteropNativeModule } from "../../InteropNativeModule"
 import { Context } from "../peers/Context"
 import { Profiler } from "./profiler"
 import { ArkTsConfig } from "../../generated"
+import { Config } from '../peers/Config';
+
+export class UpdateTracker {
+    stack: boolean[] = []
+
+    push() {
+        this.stack.push(false)
+    }
+
+    update() {
+        this.stack[this.stack.length - 1] = true
+    }
+
+    check() {
+        return this.stack.pop()
+    }
+}
 
 export class global {
     public static filePath: string = "./plugins/input/main.ets"
 
     public static arktsconfig?: ArkTsConfig
+    public static configObj?: Config;
 
     private static _config?: KNativePointer
     public static set config(config: KNativePointer) {
         global._config = config
+        global.configObj = new Config(global._config);
     }
     public static get config(): KNativePointer {
         return global._config ?? throwError('Global.config not initialized')
@@ -39,6 +58,7 @@ export class global {
     }
     public static resetConfig(): void {
         global._config = undefined
+        global.configObj = undefined;
     }
 
     // Improve: rename to contextPeer
@@ -47,7 +67,7 @@ export class global {
     }
 
     // Improve: rename to context when the pointer valued one is eliminated
-    public static compilerContext: Context
+    public static compilerContext: Context | undefined
     public static isContextGenerateAbcForExternalSourceFiles: boolean = false
 
     private static _es2panda: Es2pandaNativeModule | undefined = undefined
@@ -77,4 +97,11 @@ export class global {
 
     // Check node type values during node creation
     public static validatePeerTypes = false
+
+    public static clearContext(): void {
+        global.compilerContext = undefined
+    }
+
+    // Keep track of update info to optimize performance
+    public static updateTracker: UpdateTracker = new UpdateTracker()
 }

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

@@ -13,17 +13,24 @@
  * limitations under the License.
  */
 
-import { KNativePointer } from "@koalaui/interop"
+import { KInt, KNativePointer, KUInt } from "@koalaui/interop"
 import type {
+    ClassDefinition,
+    ETSFunctionType,
     ETSModule,
+    ETSParameterExpression,
+    Expression,
     MethodDefinition,
+    NumberLiteral,
     Program,
     ScriptFunction,
+    SourcePosition,
 } from "../../generated"
 import { ExternalSource } from "../peers/ExternalSource"
-import { Es2pandaModuleFlag } from "../../generated/Es2pandaEnums"
+import { Es2pandaAstNodeType, Es2pandaModuleFlag } from "../../generated/Es2pandaEnums"
 import { global } from "../static/global"
-import { acceptNativeObjectArrayResult } from "./private"
+import { acceptNativeObjectArrayResult, passNodeArray, unpackNodeArray, unpackNonNullableNode } from "./private"
+import type { AstNode } from "../peers/AstNode"
 
 export function extension_ETSModuleGetNamespaceFlag(this: ETSModule): Es2pandaModuleFlag {
     return (this.isETSScript ? Es2pandaModuleFlag.MODULE_FLAG_ETSSCRIPT : 0)
@@ -43,10 +50,7 @@ export function extension_MethodDefinitionSetChildrenParentPtr(this: MethodDefin
 
 export function extension_MethodDefinitionOnUpdate(this: MethodDefinition, original: MethodDefinition): void {
     this.setChildrenParentPtr()
-    // Improve: Update modifiers only for specific AST nodes in the generated factory code
-    this.modifierFlags = original.modifierFlags
-    global.generatedEs2panda._AstNodeSetOriginalNode(global.context, this.peer, original.originalPeer)
-    global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, global.generatedEs2panda._AstNodeParent(global.context, original.peer))
+    global.es2panda._AstNodeOnUpdate(global.context, this.peer, original.peer)
     const originalBase = original.baseOverloadMethod
     if (originalBase) {
         this.setBaseOverloadMethod(originalBase)
@@ -62,6 +66,11 @@ export function extension_ScriptFunctionSetSignaturePointer(this: ScriptFunction
     global.es2panda._Checker_ScriptFunctionSetSignature(global.context, this.peer, signaturePointer)
 }
 
+// Improve: weird API
+export function extension_ScriptFunctionGetParamsCasted(this: ScriptFunction): readonly ETSParameterExpression[] {
+    return unpackNodeArray<ETSParameterExpression>(global.generatedEs2panda._ScriptFunctionParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)
+}
+
 // Improve: perhaps "preferredReturnType" stuff can be removed later if "signature" is always enough
 export function extension_ScriptFunctionGetPreferredReturnTypePointer(this: ScriptFunction): KNativePointer {
     return global.es2panda._Checker_ScriptFunctionGetPreferredReturnType(global.context, this.peer)
@@ -71,6 +80,20 @@ export function extension_ScriptFunctionSetPreferredReturnTypePointer(this: Scri
     global.es2panda._Checker_ScriptFunctionSetPreferredReturnType(global.context, this.peer, typePointer)
 }
 
+// Improve: generate checker related stuff
+export function extension_ExpressionGetPreferredTypePointer(this: Expression): KNativePointer {
+    return global.es2panda._Checker_ExpressionGetPreferredType(global.context, this.peer)
+}
+
+export function extension_ExpressionSetPreferredTypePointer(this: Expression, typePointer: KNativePointer): void {
+    global.es2panda._Checker_ExpressionSetPreferredType(global.context, this.peer, typePointer)
+}
+
+// Improve: weird API
+export function extension_ProgramGetAstCasted(this: Program): ETSModule {
+    return unpackNonNullableNode<ETSModule>(global.generatedEs2panda._ProgramAst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)
+}
+
 // Improve: generate methods with string[] args or return type
 export function extension_ProgramGetExternalSources(this: Program): ExternalSource[] {
     return acceptNativeObjectArrayResult<ExternalSource>(
@@ -78,3 +101,37 @@ export function extension_ProgramGetExternalSources(this: Program): ExternalSour
         ExternalSource.instantiate,
     )
 }
+
+// Improve: SourcePositionLine is global in idl
+export function extension_SourcePositionGetLine(this: SourcePosition): KUInt {
+    return global.generatedEs2panda._SourcePositionLine(global.context, this.peer)
+}
+
+// Improve: SourcePositionCol is not described in idl
+export function extension_SourcePositionGetCol(this: SourcePosition): KUInt {
+    return global.es2panda._SourcePositionCol(global.context, this.peer)
+}
+
+// Improve: SourcePositionIndex is global in idl
+export function extension_SourcePositionGetIndex(this: SourcePosition): KUInt {
+    return global.generatedEs2panda._SourcePositionIndex(global.context, this.peer)
+}
+
+export function extension_SourcePositionToString(this: SourcePosition): string {
+    return `:${this.getLine() + 1}:${this.getCol()}`
+}
+
+// Improve: weird API
+export function extension_NumberLiteralValue(this: NumberLiteral): number {
+    return +this.dumpSrc()
+}
+
+// Improve: weird API
+export function extension_ClassDefinitionSetBody(this: ClassDefinition, body: readonly AstNode[]): void {
+    global.es2panda._ClassDefinitionSetBody(global.context, this.peer, passNodeArray(body), body.length)
+}
+
+// Improve: weird API
+export function extension_ETSFunctionTypeGetParamsCasted(this: ETSFunctionType): readonly ETSParameterExpression[] {
+    return unpackNodeArray<ETSParameterExpression>(global.generatedEs2panda._ETSFunctionTypeParamsConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)
+}

package/build/libarkts-copy/src/{wrapper-compat/arkts-api → arkts-api}/utilities/performance.ts

@@ -13,6 +13,22 @@
  * limitations under the License.
  */
 
+import * as process from 'process';
+import { global as localGlobal} from '../static/global';
+
+const BYTES_PER_KIBIBYTE = 1024;
+
+interface MemoryContext {
+    startTime: number;
+    startMemory: {
+        rss: number;
+        heapTotal: number;
+        heapUsed: number;
+        external: number;
+        arrayBuffers: number;
+    };
+}
+
 interface Event {
     name: string,
     startTime: number,
@@ -46,12 +62,14 @@ export class Performance {
     private scopes: string[];
     private shouldSkip: boolean;
     private totalDuration: number;
-
+    private memoryContexts = new Map<string, MemoryContext>();
+    private memoryTrackerEnable: boolean;
     private constructor() {
         this.events = new Map();
         this.historyEvents = new Map();
         this.scopes = [];
         this.shouldSkip = true;
+        this.memoryTrackerEnable = false;
         this.totalDuration = 0;
     }
 
@@ -66,6 +84,10 @@ export class Performance {
         this.shouldSkip = shouldSkip;
     }
 
+    enableMemoryTracker(enableMemoryTracker: boolean = false): void {
+        this.memoryTrackerEnable = enableMemoryTracker;
+    }
+
     createEvent(name: string): Event {
         if (this.shouldSkip) {
             return { name: '', startTime: 0 };
@@ -175,7 +197,7 @@ export class Performance {
                 result += `${indent}- ${child.name}: ${formatTime(duration)}(${round(duration)}), ${count}\n`;
                 result += _result;
             });
-    
+
             return [result, children.length];
         }
 
@@ -187,4 +209,101 @@ export class Performance {
           console.log(`[PERFORMANCE] ===== FINAL RESULT ====`);
         }
     }
-}
+
+    startMemRecord(label: string = `measurement-${Date.now()}`): void {
+        // 强制进行垃圾回收（需要 Node.js 启动时添加 --expose-gc 参数）
+        if (!this.memoryTrackerEnable) {
+            return;
+        }
+        if (global.gc) {
+            (global as any).gc();
+        }
+        const startMemory = process.memoryUsage();
+        this.memoryContexts.set(label, {
+            startTime: Date.now(),
+            startMemory: {
+                rss: startMemory.rss / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE),
+                heapTotal: startMemory.heapTotal / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE),
+                heapUsed: startMemory.heapUsed / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE),
+                external: startMemory.external / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE),
+                arrayBuffers: (startMemory.arrayBuffers || 0) / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)
+            }
+        });
+
+        return;
+    }
+
+    stopMemRecord(label: string = `measurement-${Date.now()}`, runGc: boolean = false): void {
+        if (!this.memoryTrackerEnable) {
+            return;
+        }
+        const context = this.memoryContexts.get(label);
+
+        if (!context) {
+            console.error(`未找到标签为 "${label}" 的内存测量上下文`);
+            return;
+        }
+
+        // 可选：在测量结束前执行垃圾回收
+        if (runGc && global.gc) {
+            (global as any).gc();
+        }
+
+        // 记录结束时的内存使用情况
+        const endTime = Date.now();
+        const endMemory = process.memoryUsage();
+
+        // 计算内存使用增量
+        const memoryDiff = {
+            rss: endMemory.rss / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE) - context.startMemory.rss,
+            heapTotal: endMemory.heapTotal / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE) - context.startMemory.heapTotal,
+            heapUsed: endMemory.heapUsed / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE) - context.startMemory.heapUsed,
+            external: endMemory.external / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE) - context.startMemory.external,
+            arrayBuffers: ((endMemory.arrayBuffers || 0) / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)) - context.startMemory.arrayBuffers
+        };
+        const duration = endTime - context.startTime;
+
+        console.log('[PERFORMANCE]', `内存测量结果 [标签: ${label}]`);
+        console.log('[PERFORMANCE]', `执行时间: ${duration}ms`);
+        console.log('---------------------------------------------------------------');
+        console.log('[PERFORMANCE]', `内存类型       | 开始值(MB) | 结束值(MB) | 增量(MB)`);
+        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)}`);
+        console.log('[PERFORMANCE]', `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)}`);
+        console.log('[PERFORMANCE]', `External       | ${context.startMemory.external.toFixed(2)}    | ${(endMemory.external / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.external.toFixed(2)}`);
+        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)}`);
+        }
+        console.log('---------------------------------------------------------------');
+        this.memoryContexts.delete(label);
+        return;
+    }
+
+    memoryTrackerReset(): void {
+        if (!this.memoryTrackerEnable) {
+            return;
+        }
+        localGlobal.es2panda._MemoryTrackerReset(localGlobal.context);
+    }
+
+    memoryTrackerGetDelta(tag: string): void {
+        if (!this.memoryTrackerEnable) {
+            return;
+        }
+        console.log('---------------------------------------------------------------');
+        console.log('[PERFORMANCE] Increamental memory:', tag);
+        localGlobal.es2panda._MemoryTrackerGetDelta(localGlobal.context);
+        console.log('---------------------------------------------------------------');
+    }
+
+    memoryTrackerPrintCurrent(tag: string): void {
+        if (!this.memoryTrackerEnable) {
+            return;
+        }
+        console.log('---------------------------------------------------------------');
+        console.log('[PERFORMANCE] Current total memory:', tag);
+        localGlobal.es2panda._MemoryTrackerPrintCurrent(localGlobal.context);
+        console.log('---------------------------------------------------------------');
+    }
+}

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

@@ -25,7 +25,7 @@ import {
 } from "@koalaui/interop"
 import { NativePtrDecoder } from "./nativePtrDecoder"
 import { Es2pandaAstNodeType, Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums"
-import { classByPeer } from "../class-by-peer"
+import { nodeFrom } from "../class-by-peer"
 import { AstNode } from "../peers/AstNode"
 import { ArktsObject } from "../peers/ArktsObject"
 
@@ -68,31 +68,31 @@ export function acceptNativeObjectArrayResult<T extends ArktsObject>(arrayObject
     return new NativePtrDecoder().decode(arrayObject).map(factory);
 }
 
-export function unpackNonNullableNode<T extends AstNode>(peer: KNativePointer): T {
+export function unpackNonNullableNode<T extends AstNode>(peer: KNativePointer, typeHint?: Es2pandaAstNodeType): T {
     if (peer === nullptr) {
         throwError('peer is NULLPTR (maybe you should use unpackNode)')
     }
-    return classByPeer(peer)
+    return nodeFrom(peer, typeHint)
 }
 
-export function unpackNode<T extends AstNode>(peer: KNativePointer): T | undefined {
+export function unpackNode<T extends AstNode>(peer: KNativePointer, typeHint?: Es2pandaAstNodeType): T | undefined {
     if (peer === nullptr) {
         return undefined
     }
-    return classByPeer<T>(peer)
+    return nodeFrom<T>(peer, typeHint)
 }
 
 export function passNode(node: ArktsObject | undefined): KNativePointer {
     return node?.peer ?? nullptr
 }
 
-export function unpackNodeArray<T extends AstNode>(nodesPtr: KNativePointer): T[] {
+export function unpackNodeArray<T extends AstNode>(nodesPtr: KNativePointer, typeHint?: Es2pandaAstNodeType): T[] {
     if (nodesPtr === nullptr) {
-        throwError('nodesPtr is NULLPTR (maybe you should use unpackNodeArray)')
+        return []
     }
     return new NativePtrDecoder()
         .decode(nodesPtr)
-        .map((peer: KNativePointer) => unpackNonNullableNode(peer))
+        .map((peer: KNativePointer) => unpackNonNullableNode(peer, typeHint))
 }
 
 export function passNodeArray(nodes: readonly ArktsObject[] | undefined): BigUint64Array {
@@ -104,20 +104,6 @@ export function passNodeArray(nodes: readonly ArktsObject[] | undefined): BigUin
     )
 }
 
-export function unpackNonNullableObject<T extends ArktsObject>(type: { new (peer: KNativePointer): T }, peer: KNativePointer): T {
-    if (peer === nullptr) {
-        throwError('peer is NULLPTR (maybe you should use unpackObject)')
-    }
-    return new type(peer)
-}
-
-export function unpackObject<T extends ArktsObject>(type: { new (peer: KNativePointer): T }, peer: KNativePointer): T | undefined {
-    if (peer === nullptr) {
-        return undefined
-    }
-    return new type(peer)
-}
-
 export function unpackString(peer: KNativePointer): string {
     return global.interop._RawUtf8ToString(peer)
 }