@idlizer/arktscgen 2.1.10-arktscgen-2 → 2.1.10-arktscgen-3

package/build/libarkts-copy/native/src/memoryTracker.cc

@@ -0,0 +1,178 @@
+/**
+ * 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.
+ */
+
+#include "memoryTracker.h"
+
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <system_error>
+#include <vector>
+#include <regex>
+
+#ifdef _WIN32
+    #include <windows.h>
+    #include <psapi.h>
+#elif defined(__APPLE__)
+    #include <mach/mach.h>
+    #include <sys/resource.h>
+#elif defined(__linux__)
+    #include <sys/resource.h>
+    #include <unistd.h>
+#endif
+
+constexpr const char* UNIT_K = "kB";
+constexpr size_t BYTES_PER_KB = 1024;
+constexpr const char* MEMORY_STATUS_FILE = "/proc/self/status";
+const std::regex VM_RSS_REGEX(R"#(VmRSS:\s*(\d+)\s*([kKmMgG]?B))#",
+    std::regex_constants::ECMAScript | std::regex_constants::icase);
+const std::regex VM_SIZE_REGEX(R"#(VmSize:\s*(\d+)\s*([kKmMgG]?B))#",
+    std::regex_constants::ECMAScript | std::regex_constants::icase);
+
+constexpr int MATCH_GROUP_VALUE = 1;
+constexpr int MATCH_GROUP_UNIT = 2;
+constexpr int MATCH_GROUP_SIZE = 3;
+
+#if defined(_WIN32)
+MemoryStats GetMemoryStats()
+{
+    MemoryStats stats = {0, 0, 0, 0, 0};
+    PROCESS_MEMORY_COUNTERS_EX pmc;
+    if (GetProcessMemoryInfo(GetCurrentProcess(),
+        reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&pmc), sizeof(pmc))) {
+        stats.currentRss = pmc.WorkingSetSize;
+        stats.peakRss = pmc.PeakWorkingSetSize;
+        stats.currentVss = pmc.PrivateUsage; // 私有内存使用量
+        stats.pageFaultsMinor = pmc.PageFaultCount;
+        // Windows API不直接提供主缺页错误计数
+        stats.pageFaultsMajor = 0;
+    }
+    return stats;
+}
+
+#elif defined(__APPLE__)
+MemoryStats GetMemoryStats()
+{
+    MemoryStats stats = {0, 0, 0, 0, 0};
+    struct rusage ru;
+    if (getrusage(RUSAGE_SELF, &ru) == 0) {
+        stats.currentRss = 0; // macOS需要专用API获取当前内存
+        stats.peakRss = ru.ru_maxrss; // macOS返回字节
+        stats.pageFaultsMinor = ru.ru_minflt;
+        stats.pageFaultsMajor = ru.ru_majflt;
+        
+        // 获取当前内存使用 (macOS专用API)
+        task_basic_info info;
+        mach_msg_type_number_t count = TASK_BASIC_INFO_64_COUNT;
+        if (task_info(mach_task_self(), TASK_BASIC_INFO_64,
+            (task_info_t)&info, &count) == KERN_SUCCESS) {
+            stats.currentRss = info.resident_size; // 物理内存使用量
+            stats.currentVss = info.virtual_size;  // 虚拟内存总量
+        }
+    }
+    return stats;
+}
+
+#elif defined(__linux__)
+MemoryStats GetMemoryStats()
+{
+    MemoryStats stats = {0, 0, 0, 0, 0};
+    struct rusage ru;
+    if (getrusage(RUSAGE_SELF, &ru) == 0) {
+        stats.peakRss = static_cast<size_t>(ru.ru_maxrss) * BYTES_PER_KB; // KB -> 字节
+        stats.pageFaultsMinor = ru.ru_minflt;
+        stats.pageFaultsMajor = ru.ru_majflt;
+    }
+    std::ifstream statusFile(MEMORY_STATUS_FILE);
+    if (!statusFile) {
+        return stats;
+    }
+    std::string line;
+    std::smatch matches;
+    while (std::getline(statusFile, line)) {
+        if (std::regex_match(line, matches, VM_RSS_REGEX) && matches.size() >= MATCH_GROUP_SIZE) {
+            stats.currentRss = std::stoull(matches[MATCH_GROUP_VALUE].str());
+            std::string unit = matches[MATCH_GROUP_UNIT].str();
+            if (unit == UNIT_K) {
+                stats.currentRss *= BYTES_PER_KB;
+            }
+        } else if (std::regex_match(line, matches, VM_SIZE_REGEX) && matches.size() >= MATCH_GROUP_SIZE) {
+            stats.currentVss = std::stoull(matches[MATCH_GROUP_VALUE].str());
+            std::string unit = matches[MATCH_GROUP_UNIT].str();
+            if (unit == UNIT_K) {
+                stats.currentVss *= BYTES_PER_KB;
+            }
+        }
+    }
+    return stats;
+}
+#endif
+
+void MemoryTracker::Reset()
+{
+    baseline = GetMemoryStats();
+}
+
+MemoryStats MemoryTracker::GetDelta()
+{
+    MemoryStats current = GetMemoryStats();
+    MemoryStats delta = {
+        current.currentRss - baseline.currentRss,
+        current.peakRss - baseline.peakRss,
+        current.currentVss - baseline.currentVss,
+        current.pageFaultsMinor - baseline.pageFaultsMinor,
+        current.pageFaultsMajor - baseline.pageFaultsMajor
+    };
+    return delta;
+}
+
+template<typename Func>
+MemoryStats MemoryTracker::MeasureMemory(Func&& func)
+{
+    Reset();
+    auto preStats = GetMemoryStats();
+    func();
+    auto postStats = GetMemoryStats();
+
+    return {
+        postStats.currentRss - preStats.currentRss,
+        postStats.peakRss - preStats.peakRss,
+        postStats.currentVss - preStats.currentVss,
+        postStats.pageFaultsMinor - preStats.pageFaultsMinor,
+        postStats.pageFaultsMajor - preStats.pageFaultsMajor
+    };
+}
+
+void MemoryTracker::Report(MemoryStats stats)
+{
+    auto formatBytes = [](size_t bytes) -> std::string {
+        const double kb = BYTES_PER_KB;
+        const double mb = kb * BYTES_PER_KB;
+        const double gb = mb * BYTES_PER_KB;
+
+        if (bytes > gb) return std::to_string(bytes / gb) + " GB";
+        if (bytes > mb) return std::to_string(bytes / mb) + " MB";
+        if (bytes > kb) return std::to_string(bytes / kb) + " KB";
+        return std::to_string(bytes) + " B";
+    };
+
+    std::cout << "Current RSS: " << formatBytes(stats.currentRss) << "\n";
+    std::cout << "Peak RSS   : " << formatBytes(stats.peakRss) << "\n";
+    std::cout << "VSS        : " << formatBytes(stats.currentVss) << "\n";
+    std::cout << "FaultsMinor: " << stats.pageFaultsMinor << "\n";
+    std::cout << "FaultsMajor: " << stats.pageFaultsMajor << "\n";
+    return;
+}

package/build/libarkts-copy/native/src/memoryTracker.h

@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+
+#ifndef KOALA_MEMORY_TRACKER
+#define KOALA_MEMORY_TRACKER
+
+#include <cstddef>
+#include <string>
+
+// 内存统计结构体
+struct MemoryStats {
+    size_t currentRss = 0;    // 当前驻留集大小 (字节)
+    size_t peakRss = 0;       // 峰值驻留集大小 (字节)
+    size_t currentVss = 0;    // 当前虚拟内存大小 (字节)
+    size_t pageFaultsMinor = 0;  // 小页错误次数
+    size_t pageFaultsMajor = 0;  // 大页错误次数
+};
+
+class MemoryTracker {
+public:
+    MemoryTracker()
+    {
+        Reset();
+    }
+
+    void Reset();
+    MemoryStats GetDelta();
+
+    template<typename Func>
+    MemoryStats MeasureMemory(Func&& func);
+
+    void Report(MemoryStats stats);
+
+private:
+    MemoryStats baseline;
+};
+
+MemoryStats GetMemoryStats();
+
+#endif

package/build/libarkts-copy/package.json

@@ -34,7 +34,7 @@
         "@koalaui/harness": "1.7.9+devel",
         "@koalaui/interop": "1.7.9+devel",
         "@koalaui/fast-arktsc": "1.7.9+devel",
-        "@idlizer/arktscgen": "2.1.10-arktscgen-1",
+        "@idlizer/arktscgen": "2.1.10-arktscgen-2",
         "@types/mocha": "^9.1.0",
         "mocha": "^9.2.2",
         "node-addon-api": "8.0.0",

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

@@ -129,7 +129,7 @@ export class Es2pandaNativeModule {
     _ETSParserGetImportPathManager(context: KNativePointer): KPtr {
         throw new Error("Not implemented");
     }
-    _SourcePositionCol(context: KNativePointer, instance: KNativePointer): KInt {
+    _SourcePositionCol(context: KNativePointer, instance: KNativePointer): KUInt {
         throw new Error("Not implemented");
     }
     _ConfigGetOptions(config: KNativePointer): KNativePointer {
@@ -192,7 +192,7 @@ export class Es2pandaNativeModule {
         throw new Error("Not implemented")
     }
     _CreateSuggestionInfo(context: KNativePointer, kind: KNativePointer, args: string[],
-        argc: number, substitutionCode: string, range: KNativePointer): KNativePointer {
+        argc: number, substitutionCode: string, title: string, range: KNativePointer): KNativePointer {
         throw new Error("Not implemented")
     }
     _LogDiagnostic(context: KNativePointer, kind: KNativePointer, argv: string[], argc: number, pos: KNativePointer): void {
@@ -227,6 +227,18 @@ export class Es2pandaNativeModule {
     _CreateTypeNodeFromTsType(context: KNativePointer, classInstance: KNativePointer): KNativePointer {
         throw new Error('Not implemented');
     }
+
+    _MemoryTrackerReset(context: KNativePointer): void {
+        throw new Error('Not implemented');
+    }
+
+    _MemoryTrackerGetDelta(context: KNativePointer): void {
+        throw new Error('Not implemented');
+    }
+
+    _MemoryTrackerPrintCurrent(context: KNativePointer): void {
+        throw new Error('Not implemented');
+    }
 }
 
 export function findNativeModule(): string {

package/build/libarkts-copy/src/arkts-api/class-by-peer.ts

@@ -22,12 +22,12 @@ import { NodeCache } from "./node-cache"
 
 export const nodeByType = new Map<Es2pandaAstNodeType, (peer: KNativePointer) => AstNode>([])
 
-export function nodeFrom<T extends AstNode>(peer: KNativePointer): T {
+export function nodeFrom<T extends AstNode>(peer: KNativePointer, typeHint?: Es2pandaAstNodeType): T {
     const fromCache = NodeCache.get<T>(peer)
     if (fromCache) {
         return fromCache
     }
-    const type = global.generatedEs2panda._AstNodeTypeConst(global.context, peer)
+    const type = typeHint ?? global.generatedEs2panda._AstNodeTypeConst(global.context, peer)
     const create = nodeByType.get(type) ?? throwError(`unknown node type: ${type}`)
     return create(peer) as T
 }

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

@@ -16,12 +16,12 @@
 export * from "../generated/Es2pandaEnums"
 export * from "../generated"
 
+export * from "./utilities/performance"
 export * from "./utilities/private"
 export * from "./utilities/public"
 export * from "./factory/nodeFactory"
 export * from "./visitor"
 export * from "./AbstractVisitor"
-export * from "./ChainExpressionFilter"
 export * from "./plugins"
 export * from "./ImportStorage"
 export * from "./ProgramProvider"
@@ -32,6 +32,7 @@ export * from "./peers/Context"
 export { GlobalContext } from "./peers/Context"
 export * from "./peers/ExternalSource"
 export * from "./peers/Options"
+export * from "./peers/DiagnosticKind"
 export * from "./node-utilities/ArkTsConfig"
 export * from "./node-utilities/Program"
 export * from "./peers/ImportPathManager"

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

@@ -15,29 +15,25 @@
 
 import { KNativePointer } from "@koalaui/interop"
 import { AstNode } from "./peers/AstNode"
+import { Es2pandaAstNodeType } from "src/generated/Es2pandaEnums"
 
 export class NodeCache {
     private static cache = new Map<KNativePointer, AstNode>()
 
-    static cached<T extends AstNode>(pointer: KNativePointer, factory: (pointer: KNativePointer) => AstNode): T {
-        const cached = NodeCache.cache.get(pointer)
-        if (cached !== undefined) {
-            return cached as T
-        }
-        const node = factory(pointer)
-        NodeCache.addToCache(pointer, node)
-        return node as T
-    }
-
     static get<T extends AstNode>(pointer: KNativePointer): T | undefined {
         return NodeCache.cache.get(pointer) as T | undefined
     }
 
     public static addToCache(pointer: KNativePointer, node: AstNode) {
-        NodeCache.cache.set(pointer, node)
+        if (node.astNodeType == Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION
+            || node.astNodeType == Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE
+            || node.astNodeType == Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION) {
+            NodeCache.cache.set(pointer, node)
+        }
     }
 
     public static clear(): void {
+        console.log("SIZE WAS", NodeCache.cache.size, "ON CLEAR")
         NodeCache.cache.clear()
     }
 }

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

@@ -32,7 +32,6 @@ export abstract class AstNode extends ArktsObject {
         }
         super(peer)
         this.astNodeType = astNodeType
-        this.setChildrenParentPtr()
         NodeCache.addToCache(peer, this)
     }
 
@@ -49,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))
     }

package/{templates/node-map.ts → build/libarkts-copy/src/arkts-api/peers/DiagnosticKind.ts}

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * 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
@@ -13,23 +13,12 @@
  * limitations under the License.
  */
 
-/*
- * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY!
- */
-
-import {
-    global,
-    passNode,
-    unpackNonNullableNode,
-    Es2pandaMemberExpressionKind,
-    assertValidPeer,
-    AstNode,
-    Es2pandaAstNodeType,
-    KNativePointer
-} from "../reexport-for-generated"
+import { KNativePointer } from "@koalaui/interop";
+import { ArktsObject } from "./ArktsObject"
 
-import * as peers from "./index"
 
-export const nodes = new Map<Es2pandaAstNodeType, { new(peer: KNativePointer): AstNode }>([
-%GENERATED_PART%
-])
+export class DiagnosticKind extends ArktsObject {
+  constructor(peer: KNativePointer) {
+    super(peer);
+  }
+}

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

@@ -13,10 +13,12 @@
  * limitations under the License.
  */
 
-import { KInt, KNativePointer } from "@koalaui/interop"
+import { KInt, KNativePointer, KUInt } from "@koalaui/interop"
 import type {
     ClassDefinition,
+    ETSFunctionType,
     ETSModule,
+    ETSParameterExpression,
     Expression,
     MethodDefinition,
     NumberLiteral,
@@ -25,9 +27,9 @@ import type {
     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, passNodeArray } from "./private"
+import { acceptNativeObjectArrayResult, passNodeArray, unpackNodeArray, unpackNonNullableNode } from "./private"
 import type { AstNode } from "../peers/AstNode"
 
 export function extension_ETSModuleGetNamespaceFlag(this: ETSModule): Es2pandaModuleFlag {
@@ -64,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)
@@ -82,6 +89,11 @@ export function extension_ExpressionSetPreferredTypePointer(this: Expression, ty
     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>(
@@ -91,15 +103,20 @@ export function extension_ProgramGetExternalSources(this: Program): ExternalSour
 }
 
 // Improve: SourcePositionLine is global in idl
-export function extension_SourcePositionGetLine(this: SourcePosition): KInt {
+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): KInt {
+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()}`
 }
@@ -110,11 +127,11 @@ export function extension_NumberLiteralValue(this: NumberLiteral): number {
 }
 
 // Improve: weird API
-export function extension_ScriptFunctionSetParams(this: ScriptFunction, params: readonly Expression[]): void {
-    global.es2panda._ScriptFunctionSetParams(global.context, this.peer, passNodeArray(params), params.length)
+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_ClassDefinitionSetBody(this: ClassDefinition, body: readonly AstNode[]): void {
-    global.es2panda._ClassDefinitionSetBody(global.context, this.peer, passNodeArray(body), body.length)
+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)
 }