@idlizer/arktscgen 2.1.10-arktscgen-6 → 2.1.10-arktscgen-7

package/build/libarkts-copy/native/meson.build

@@ -23,10 +23,10 @@ project(
 is_cross = get_option('cross_compile')
 
 sources = [
-    './src/common.cc',
-    './src/memoryTracker.cc',
-    './src/bridges.cc',
-    '../generated/native/bridges.cc',
+    './src/common.cpp',
+    './src/memoryTracker.cpp',
+    './src/bridges.cpp',
+    '../generated/native/bridges.cpp',
     get_option('interop_src_dir') / 'common-interop.cpp',
     get_option('interop_src_dir') / 'callback-resource.cpp',
     get_option('interop_src_dir') / 'interop-logging.cpp',

package/build/libarkts-copy/native/src/{bridges.cc → bridges.cpp}

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-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
@@ -40,7 +40,7 @@ KNativePointer impl_AnnotationAllowedAnnotations(
     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
     std::size_t params_len = 0;
     auto annotations = GetImpl()->AnnotationAllowedAnnotations(context, node, &params_len);
-    return StageArena::cloneVector(annotations, params_len);
+    return StageArena::CloneVector(annotations, params_len);
 }
 KOALA_INTEROP_3(AnnotationAllowedAnnotations, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
 
@@ -51,7 +51,7 @@ KNativePointer impl_AnnotationAllowedAnnotationsConst(
     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
     std::size_t params_len = 0;
     auto annotations = GetImpl()->AnnotationAllowedAnnotationsConst(context, node, &params_len);
-    return StageArena::cloneVector(annotations, params_len);
+    return StageArena::CloneVector(annotations, params_len);
 }
 KOALA_INTEROP_3(AnnotationAllowedAnnotationsConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
 
@@ -107,7 +107,7 @@ static KNativePointer impl_ProgramExternalSources(KNativePointer contextPtr, KNa
     auto&& instance = reinterpret_cast<es2panda_Program*>(instancePtr);
     std::size_t source_len = 0;
     auto external_sources = GetImpl()->ProgramExternalSources(context, instance, &source_len);
-    return StageArena::cloneVector(external_sources, source_len);
+    return StageArena::CloneVector(external_sources, source_len);
 }
 KOALA_INTEROP_2(ProgramExternalSources, KNativePointer, KNativePointer, KNativePointer);
 
@@ -126,7 +126,7 @@ static KNativePointer impl_ProgramSourceFilePath(KNativePointer contextPtr, KNat
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
     auto&& instance = reinterpret_cast<es2panda_Program*>(instancePtr);
     auto&& result = GetImpl()->ProgramSourceFilePathConst(context, instance);
-    return StageArena::strdup(result);
+    return StageArena::Strdup(result);
 }
 KOALA_INTEROP_2(ProgramSourceFilePath, KNativePointer, KNativePointer, KNativePointer);
 
@@ -134,7 +134,7 @@ static KNativePointer impl_ExternalSourceName(KNativePointer instance)
 {
     auto&& _instance_ = reinterpret_cast<es2panda_ExternalSource*>(instance);
     auto&& result = GetImpl()->ExternalSourceName(_instance_);
-    return StageArena::strdup(result);
+    return StageArena::Strdup(result);
 }
 KOALA_INTEROP_1(ExternalSourceName, KNativePointer, KNativePointer);
 
@@ -143,7 +143,7 @@ static KNativePointer impl_ExternalSourcePrograms(KNativePointer instance)
     auto&& _instance_ = reinterpret_cast<es2panda_ExternalSource*>(instance);
     std::size_t program_len = 0;
     auto programs = GetImpl()->ExternalSourcePrograms(_instance_, &program_len);
-    return StageArena::cloneVector(programs, program_len);
+    return StageArena::CloneVector(programs, program_len);
 }
 KOALA_INTEROP_1(ExternalSourcePrograms, KNativePointer, KNativePointer);
 
@@ -275,7 +275,7 @@ KNativePointer impl_Checker_TypeToString(KNativePointer context, KNativePointer
     auto _context = reinterpret_cast<es2panda_Context*>(context);
     auto _type = reinterpret_cast<es2panda_Type*>(type);
     auto result = GetImpl()->TypeToStringConst(_context, _type);
-    return StageArena::strdup(result);
+    return StageArena::Strdup(result);
 }
 KOALA_INTEROP_2(Checker_TypeToString, KNativePointer, KNativePointer, KNativePointer)
 
@@ -347,7 +347,7 @@ KNativePointer impl_TSInterfaceBodyBodyPtr(KNativePointer context, KNativePointe
     const auto _receiver = reinterpret_cast<es2panda_AstNode*>(receiver);
     std::size_t length;
     auto result = GetImpl()->TSInterfaceBodyBodyPtr(_context, _receiver, &length);
-    return StageArena::cloneVector(result, length);
+    return StageArena::CloneVector(result, length);
 }
 KOALA_INTEROP_2(TSInterfaceBodyBodyPtr, KNativePointer, KNativePointer, KNativePointer);
 
@@ -357,7 +357,7 @@ KNativePointer impl_AnnotationDeclarationPropertiesPtrConst(KNativePointer conte
     const auto _receiver = reinterpret_cast<es2panda_AstNode*>(receiver);
     std::size_t length;
     auto result = GetImpl()->AnnotationDeclarationPropertiesPtrConst(_context, _receiver, &length);
-    return StageArena::cloneVector(result, length);
+    return StageArena::CloneVector(result, length);
 }
 KOALA_INTEROP_2(AnnotationDeclarationPropertiesPtrConst, KNativePointer, KNativePointer, KNativePointer);
 
@@ -394,7 +394,7 @@ KNativePointer impl_AnnotationUsageIrPropertiesPtrConst(KNativePointer context,
     const auto _receiver = reinterpret_cast<es2panda_AstNode*>(receiver);
     std::size_t length;
     auto result = GetImpl()->AnnotationUsageIrPropertiesPtrConst(_context, _receiver, &length);
-    return StageArena::cloneVector(result, length);
+    return StageArena::CloneVector(result, length);
 }
 KOALA_INTEROP_2(AnnotationUsageIrPropertiesPtrConst, KNativePointer, KNativePointer, KNativePointer);
 

package/build/libarkts-copy/native/src/{common.cc → common.cpp}

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-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
@@ -24,22 +24,23 @@
 #include "interop-types.h"
 
 using std::string, std::cout, std::endl, std::vector;
+constexpr int AST_NODE_TYPE_LIMIT = 256;
 
 es2panda_Impl* es2pandaImplementation = nullptr;
 static thread_local StageArena currentArena;
 
-StageArena* StageArena::instance()
+StageArena* StageArena::Instance()
 {
     return &currentArena;
 }
 
-void StageArena::add(void* pointer)
+void StageArena::Add(void* pointer)
 {
     if (pointer)
         allocated.push_back(pointer);
 }
 
-void StageArena::cleanup()
+void StageArena::Cleanup()
 {
     if (totalSize > 0 && false)
         printf("cleanup %d objects %d bytes\n", (int)allocated.size(), (int)totalSize);
@@ -57,26 +58,26 @@ StageArena::StageArena()
 
 StageArena::~StageArena()
 {
-    cleanup();
+    Cleanup();
 }
 
-char* StageArena::strdup(const char* string)
+char* StageArena::Strdup(const char* string)
 {
-    auto* arena = StageArena::instance();
+    auto* arena = StageArena::Instance();
     auto size = strlen(string) + 1;
-    char* memory = (char*)arena->alloc(size);
+    char* memory = (char*)arena->Alloc(size);
     interop_memcpy(memory, size, string, size);
     return memory;
 }
 
-void* StageArena::alloc(size_t size)
+void* StageArena::Alloc(size_t size)
 {
     void* result = malloc(size);
     if (!result) {
         INTEROP_FATAL("Cannot allocate memory");
     }
     totalSize += size;
-    add(result);
+    Add(result);
     return result;
 }
 
@@ -178,7 +179,6 @@ void* TryLibrary(const char* name)
     return nullptr;
 }
 
-// TODO: @panda/sdk will be changed to match ohos-sdk
 void* FindLibrary()
 {
     void* res = nullptr;
@@ -227,7 +227,7 @@ const char** getStringArray(KStringArray& ptr)
 
 char* getStringCopy(KStringPtr& ptr)
 {
-    return StageArena::strdup(ptr.c_str() ? ptr.c_str() : "");
+    return StageArena::Strdup(ptr.c_str() ? ptr.c_str() : "");
 }
 
 void impl_DestroyConfig(KNativePointer config)
@@ -236,27 +236,51 @@ void impl_DestroyConfig(KNativePointer config)
     // panda prints diagnostics here and do not clone our strings
     // so keep arena alive until this moment.
     GetImpl()->DestroyConfig(_config);
-    StageArena::instance()->cleanup();
+    StageArena::Instance()->Cleanup();
     printf("[libarkts native] Arena cleaned up!\n");
 }
-KOALA_INTEROP_V1(DestroyConfig, KNativePointer);
+KOALA_INTEROP_V1(DestroyConfig, KNativePointer)
+
+// ─── Helpers to lower function size/complexity ────────────────────────────────
+namespace {
+template <class T, class U>
+inline T As(U v) { return reinterpret_cast<T>(v); }
+
+struct CallExprArgs {
+    es2panda_Context*  context;
+    es2panda_AstNode*  node;
+    es2panda_AstNode*  callee;
+    es2panda_AstNode** arguments;
+    KInt               argumentsLen;
+    es2panda_AstNode*  typeParams;
+    bool               optional;
+    bool               trailingComma;
+};
+
+inline KNativePointer DoUpdateCallExpression(const CallExprArgs& a)
+{
+    auto nn = GetImpl()->CreateCallExpression(
+        a.context, a.callee, a.arguments, a.argumentsLen, a.typeParams, a.optional, a.trailingComma);
+    GetImpl()->AstNodeSetOriginalNode(a.context, nn, a.node);
+    return nn;
+}
+} // namespace
 
 KNativePointer impl_UpdateCallExpression(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer calleePtr,
     KNativePointerArray argumentsPtr, KInt argumentsLen, KNativePointer typeParamsPtr, KBoolean optionalT,
     KBoolean trailingCommaT)
 {
-    auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
-    auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
-    auto callee = reinterpret_cast<es2panda_AstNode*>(calleePtr);
-    auto arguments = reinterpret_cast<es2panda_AstNode**>(argumentsPtr);
-    auto typeParams = reinterpret_cast<es2panda_AstNode*>(typeParamsPtr);
-    auto optional = static_cast<bool>(optionalT);
-    auto trailingComma = static_cast<bool>(trailingCommaT);
-
-    auto nn =
-        GetImpl()->CreateCallExpression(context, callee, arguments, argumentsLen, typeParams, optional, trailingComma);
-    GetImpl()->AstNodeSetOriginalNode(context, nn, node);
-    return nn;
+    const CallExprArgs a{
+        As<es2panda_Context*>(contextPtr),
+        As<es2panda_AstNode*>(nodePtr),
+        As<es2panda_AstNode*>(calleePtr),
+        As<es2panda_AstNode**>(argumentsPtr),
+        argumentsLen,
+        As<es2panda_AstNode*>(typeParamsPtr),
+        static_cast<bool>(optionalT),
+        static_cast<bool>(trailingCommaT),
+    };
+    return DoUpdateCallExpression(a);
 }
 KOALA_INTEROP_8(UpdateCallExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer,
     KNativePointerArray, KInt, KNativePointer, KBoolean, KBoolean)
@@ -367,7 +391,7 @@ KNativePointer impl_AstNodeChildren(KNativePointer contextPtr, KNativePointer no
     cachedChildren.clear();
 
     GetImpl()->AstNodeIterateConst(context, node, visitChild);
-    return StageArena::clone(cachedChildren);
+    return StageArena::Clone(cachedChildren);
 }
 KOALA_INTEROP_2(AstNodeChildren, KNativePointer, KNativePointer, KNativePointer);
 
@@ -380,10 +404,29 @@ struct Pattern {
     std::regex regex;
 
     Pattern(const Pattern&) = delete;
+    Pattern& operator=(const Pattern&) = default;
+
+    Pattern(Pattern&& other) noexcept
+        : context(other.context),
+        key(std::move(other.key)),
+        value(std::move(other.value)),
+        impl(other.impl),
+        isWildcard(other.isWildcard),
+        regex(other.regex)
+        {
+            other.isWildcard = false;
+        }
 
-    Pattern(Pattern&& other) noexcept :
-        context(other.context), key(std::move(other.key)), value(std::move(other.value)), impl(other.impl), isWildcard(other.isWildcard), regex(other.regex) {
+    Pattern& operator=(Pattern&& other) noexcept
+    {
+        context = other.context;
+        key = std::move(other.key);
+        value = std::move(other.value);
+        impl = other.impl;
+        isWildcard = other.isWildcard;
+        regex = other.regex;
         other.isWildcard = false;
+        return *this;
     }
 
     Pattern(es2panda_Context* context, const std::string& part) : context(context), impl(GetImpl())
@@ -392,95 +435,102 @@ struct Pattern {
         std::getline(stream, key, '=');
         std::getline(stream, value, '=');
         isWildcard = value.find('*') != std::string::npos;
-
         if (isWildcard) {
             this->regex = std::regex(value);
         }
     }
-    
+
     ~Pattern() = default;
 
     bool match(es2panda_AstNode* node) const
     {
         if (key == "type") {
-            auto type = impl->AstNodeTypeConst(context, node);
-            switch (type) {
-                case Es2pandaAstNodeType::AST_NODE_TYPE_METHOD_DEFINITION:
-                    return value == "method";
-                case Es2pandaAstNodeType::AST_NODE_TYPE_SCRIPT_FUNCTION:
-                    return value == "function";
-                case Es2pandaAstNodeType::AST_NODE_TYPE_STRUCT_DECLARATION:
-                    return value == "struct";
-                case Es2pandaAstNodeType::AST_NODE_TYPE_CALL_EXPRESSION:
-                    return value == "call";
-                case Es2pandaAstNodeType::AST_NODE_TYPE_ASSIGNMENT_EXPRESSION:
-                    return value == "assignment";
-                default:
-                    return false;
-            }
+            return matchByType(node, impl->AstNodeTypeConst(context, node));
         }
         if (key == "annotation") {
-            std::size_t length = 0;
-            Es2pandaAstNodeType type = impl->AstNodeTypeConst(context, node);
-            es2panda_AstNode** result = nullptr;
-            switch (type) {
-                case Es2pandaAstNodeType::AST_NODE_TYPE_SCRIPT_FUNCTION: {
-                    result = impl->ScriptFunctionAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_FUNCTION_DECLARATION: {
-                    result = impl->FunctionDeclarationAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION: {
-                    result = impl->ArrowFunctionExpressionAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_FUNCTION_TYPE: {
-                    result = impl->TypeNodeAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION: {
-                    result = impl->TSTypeAliasDeclarationAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_VARIABLE_DECLARATION: {
-                    result = impl->VariableDeclarationAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_UNION_TYPE: {
-                    result = impl->TypeNodeAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_CLASS_PROPERTY: {
-                    result = impl->ClassPropertyAnnotations(context, node, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION: {
-                    result = impl->ETSParameterExpressionAnnotations(context, node, &length);
-                    break;
-                }
-                default:
-                    return false;
+            return matchByAnnotation(node, impl->AstNodeTypeConst(context, node));
+        }
+        return false;
+    }
+
+    bool matchByType(es2panda_AstNode* node, Es2pandaAstNodeType type) const
+    {
+        switch (type) {
+            case Es2pandaAstNodeType::AST_NODE_TYPE_METHOD_DEFINITION:
+                return value == "method";
+            case Es2pandaAstNodeType::AST_NODE_TYPE_SCRIPT_FUNCTION:
+                return value == "function";
+            case Es2pandaAstNodeType::AST_NODE_TYPE_STRUCT_DECLARATION:
+                return value == "struct";
+            case Es2pandaAstNodeType::AST_NODE_TYPE_CALL_EXPRESSION:
+                return value == "call";
+            case Es2pandaAstNodeType::AST_NODE_TYPE_ASSIGNMENT_EXPRESSION:
+                return value == "assignment";
+            default:
+                return false;
+        }
+    }
+
+    bool matchByAnnotation(es2panda_AstNode* node, Es2pandaAstNodeType type) const
+    {
+        std::size_t length = 0;
+        es2panda_AstNode** result = nullptr;
+        switch (type) {
+            case Es2pandaAstNodeType::AST_NODE_TYPE_SCRIPT_FUNCTION: {
+                result = impl->ScriptFunctionAnnotations(context, node, &length);
+                break;
+            }
+            case Es2pandaAstNodeType::AST_NODE_TYPE_FUNCTION_DECLARATION: {
+                result = impl->FunctionDeclarationAnnotations(context, node, &length);
+                break;
+            }
+            case Es2pandaAstNodeType::AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION: {
+                result = impl->ArrowFunctionExpressionAnnotations(context, node, &length);
+                break;
+            }
+            case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_FUNCTION_TYPE: {
+                result = impl->TypeNodeAnnotations(context, node, &length);
+                break;
             }
-            bool found = false;
-            for (std::size_t i = 0; i < length && result; i++) {
-                es2panda_AstNode* ident = impl->AnnotationUsageIrGetBaseNameConst(context, result[i]);
-                const char* name = impl->IdentifierNameConst(context, ident);
-                found |= matchWildcard(value, name);
+            case Es2pandaAstNodeType::AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION: {
+                result = impl->TSTypeAliasDeclarationAnnotations(context, node, &length);
+                break;
             }
-            return found;
+            case Es2pandaAstNodeType::AST_NODE_TYPE_VARIABLE_DECLARATION: {
+                result = impl->VariableDeclarationAnnotations(context, node, &length);
+                break;
+            }
+            case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_UNION_TYPE: {
+                result = impl->TypeNodeAnnotations(context, node, &length);
+                break;
+            }
+            case Es2pandaAstNodeType::AST_NODE_TYPE_CLASS_PROPERTY: {
+                result = impl->ClassPropertyAnnotations(context, node, &length);
+                break;
+            }
+            case Es2pandaAstNodeType::AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION: {
+                result = impl->ETSParameterExpressionAnnotations(context, node, &length);
+                break;
+            }
+            default:
+                return false;
         }
-        return false;
+
+        bool found = false;
+        for (std::size_t i = 0; i < length && result; i++) {
+            es2panda_AstNode* ident = impl->AnnotationUsageIrGetBaseNameConst(context, result[i]);
+            found |= MatchWildcard(value, impl->IdentifierNameConst(context, ident));
+        }
+        return found;
     }
 
-    bool matchWildcard(const std::string& pattern, const char* value) const
+    bool MatchWildcard(const std::string& pattern, const char* foundValue) const
     {
         if (!isWildcard) {
-            return pattern == value;
+            return pattern == foundValue;
         }
 
-        return std::regex_search(value, this->regex);
+        return std::regex_search(foundValue, this->regex);
     }
 };
 
@@ -507,11 +557,11 @@ struct Matcher {
     }
 };
 
-KNativePointer impl_FilterNodes(KNativePointer context, KNativePointer node, const KStringPtr& filters, KBoolean deeperAfterMatch)
+static KNativePointer DoFilterNodes(es2panda_Context* _context,
+                                    es2panda_AstNode* _node,
+                                    const char* _filters,
+                                    bool deeperAfterMatch)
 {
-    auto _node = reinterpret_cast<es2panda_AstNode*>(node);
-    auto _context = reinterpret_cast<es2panda_Context*>(context);
-    const char* _filters = filters.c_str();
     std::vector<es2panda_AstNode*> result;
     es2panda_Impl* impl = GetImpl();
     Matcher matcher(_context, _filters);
@@ -526,18 +576,23 @@ KNativePointer impl_FilterNodes(KNativePointer context, KNativePointer node, con
         }
         if (!isMatch || deeperAfterMatch) {
             impl->AstNodeIterateConst(_context, current, visitChild);
-            // We want to retain match order, so add children in reverse order.
             for (auto it = cachedChildren.rbegin(); it != cachedChildren.rend(); ++it) {
                 queue.push_back(*it);
             }
             cachedChildren.clear();
         }
     }
-    return StageArena::cloneVector(result.data(), result.size());
+    return StageArena::CloneVector(result.data(), result.size());
 }
-KOALA_INTEROP_4(FilterNodes, KNativePointer, KNativePointer, KNativePointer, KStringPtr, KBoolean)
 
-constexpr int AST_NODE_TYPE_LIMIT = 256;
+KNativePointer impl_FilterNodes(
+    KNativePointer context, KNativePointer node, const KStringPtr& filters, KBoolean deeperAfterMatch)
+{
+    auto* _node = reinterpret_cast<es2panda_AstNode*>(node);
+    auto* _context = reinterpret_cast<es2panda_Context*>(context);
+    return DoFilterNodes(_context, _node, filters.c_str(), static_cast<bool>(deeperAfterMatch));
+}
+KOALA_INTEROP_4(FilterNodes, KNativePointer, KNativePointer, KNativePointer, KStringPtr, KBoolean)
 
 struct FilterArgs {
     es2panda_Impl *impl;
@@ -564,7 +619,7 @@ KNativePointer impl_FilterNodes2(KNativePointer context, KNativePointer node, KI
     std::vector<es2panda_AstNode *> result;
     FilterArgs args = { GetImpl(), _context, &typesMask, &result };
     GetImpl()->AstNodeForEach(_node, filterByType, &args);
-    return StageArena::cloneVector(result.data(), result.size());
+    return StageArena::CloneVector(result.data(), result.size());
 }
 KOALA_INTEROP_3(FilterNodes2, KNativePointer, KNativePointer, KNativePointer, KInt)
 
@@ -579,7 +634,7 @@ KNativePointer impl_FilterNodes3(KNativePointer context, KNativePointer node, KI
     std::vector<es2panda_AstNode *> result;
     FilterArgs args = { GetImpl(), _context, &typesMask, &result };
     GetImpl()->AstNodeForEach(_node, filterByType, &args);
-    return StageArena::cloneVector(result.data(), result.size());
+    return StageArena::CloneVector(result.data(), result.size());
 }
 KOALA_INTEROP_4(FilterNodes3, KNativePointer, KNativePointer, KNativePointer, KInt*, KInt)
 

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

@@ -82,52 +82,52 @@ class StageArena {
 public:
     StageArena();
     ~StageArena();
-    static StageArena* instance();
+    static StageArena* Instance();
     template<typename T>
-    static T* alloc()
+    static T* Alloc()
     {
-        auto* arena = StageArena::instance();
-        void* memory = arena->alloc(sizeof(T));
+        auto* arena = StageArena::Instance();
+        void* memory = arena->Alloc(sizeof(T));
         return new (memory) T();
     }
     template<class T, class T1>
-    static T* alloc(T1 arg1)
+    static T* Alloc(T1 arg1)
     {
-        auto* arena = StageArena::instance();
-        void* memory = arena->alloc(sizeof(T));
+        auto* arena = StageArena::Instance();
+        void* memory = arena->Alloc(sizeof(T));
         return new (memory) T(std::forward(arg1));
     }
     template<class T, class T1, class T2>
-    static T* alloc(T1 arg1, T2 arg2)
+    static T* Alloc(T1 arg1, T2 arg2)
     {
-        auto* arena = StageArena::instance();
-        void* memory = arena->alloc(sizeof(T));
+        auto* arena = StageArena::Instance();
+        void* memory = arena->Alloc(sizeof(T));
         return new (memory) T(arg1, arg2);
     }
     template<typename T>
-    static T* allocArray(size_t count)
+    static T* AllocArray(size_t count)
     {
-        auto* arena = StageArena::instance();
+        auto* arena = StageArena::Instance();
         // align?
-        void* memory = arena->alloc(sizeof(T) * count);
+        void* memory = arena->Alloc(sizeof(T) * count);
         return new (memory) T();
     }
     template<class T>
-    static T* clone(const T& arg)
+    static T* Clone(const T& arg)
     {
-        auto* arena = StageArena::instance();
-        void* memory = arena->alloc(sizeof(T));
+        auto* arena = StageArena::Instance();
+        void* memory = arena->Alloc(sizeof(T));
         return new (memory) T(arg);
     }
     template<class T>
-    static std::vector<const void*>* cloneVector(const T* arg, size_t count)
+    static std::vector<const void*>* CloneVector(const T* arg, size_t count)
     {
-        return alloc<std::vector<const void*>, const T*, const T*>(arg, arg + count);
+        return Alloc<std::vector<const void*>, const T*, const T*>(arg, arg + count);
     }
-    void* alloc(size_t size);
-    static char* strdup(const char* original);
-    void add(void* pointer);
-    void cleanup();
+    void* Alloc(size_t size);
+    static char* Strdup(const char* original);
+    void Add(void* pointer);
+    void Cleanup();
 };
 
 #endif // COMMON_H

package/build/libarkts-copy/native/src/{memoryTracker.cc → memoryTracker.cpp}

@@ -163,9 +163,15 @@ void MemoryTracker::Report(MemoryStats stats)
         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";
+        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";
     };
 

package/build/libarkts-copy/package.json

@@ -42,7 +42,7 @@
         "tsconfig-paths": "^4.2.0",
         "rimraf": "^6.0.1",
         "@koalaui/fast-arktsc": "1.7.10+devel",
-        "@idlizer/arktscgen": "2.1.10-arktscgen-5",
+        "@idlizer/arktscgen": "2.1.10-arktscgen-6",
         "mocha": "^9.2.2",
         "@koalaui/harness": "1.7.10+devel",
         "@koalaui/ets-tsc": "4.9.5-r6",
@@ -63,7 +63,7 @@
         "compile": "npm run regenerate && npm run compile:native && npm run compile:js",
         "compile:current": "npm run regenerate:current && npm run compile:native && npm run compile:js",
         "compile:release": "npm run regenerate && npm run crosscompile:native && npm run compile:js",
-        "compile:js": "rm -rf lib/ && rollup -c rollup.lib.mjs && rollup -c rollup.es2panda.mjs",
+        "compile:js": "rm -rf lib/ && rollup -c rollup.libarkts.mjs && rollup -c rollup.es2panda.mjs",
         "compile:plugins": "rollup -c ./rollup.printer-plugin.mjs",
         "direct": "fast-arktsc --config arktsconfig.json --compiler ../incremental/tools/panda/arkts/ui2abc --link-name ./build/abc/main.abc && ninja -f build/abc/build.ninja",
         "simultaneous": "mkdir -p build/abc && bash ../incremental/tools/panda/arkts/ui2abc --simultaneous --arktsconfig arktsconfig.json --output ./build/abc/main.abc:./build/abc/library.abc plugins/input/main.ets:plugins/input/library.ets",