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

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
@@ -15,30 +15,32 @@
 
 #include <common.h>
 #include <iterator>
-#include <regex.h>
+#include <regex>
 #include <sstream>
 #include <utility>
 #include <vector>
+#include <bitset>
 
 #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);
@@ -56,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;
 }
 
@@ -136,14 +138,14 @@ void impl_SetUpSoPath(KStringPtr& soPath)
 }
 KOALA_INTEROP_V1(SetUpSoPath, KStringPtr);
 
-void* TryLibrary(const char* name) 
+void* TryLibrary(const char* name)
 {
     void* res = nullptr;
     std::vector<std::string> pathArray;
 
     // find by SetUpSoPath
     if (!ES2PANDA_LIB_PATH.empty()) {
-        pathArray = {ES2PANDA_LIB_PATH, LIB_DIR, name};
+        pathArray = { ES2PANDA_LIB_PATH, LIB_DIR, name };
         res = loadLibrary(joinPath(pathArray));
         if (res) {
             return res;
@@ -153,7 +155,7 @@ void* TryLibrary(const char* name)
     // find by set PANDA_SDK_PATH
     char* envValue = getenv("PANDA_SDK_PATH");
     if (envValue) {
-        pathArray = {envValue, PLUGIN_DIR, LIB_DIR, name};
+        pathArray = { envValue, PLUGIN_DIR, LIB_DIR, name };
         res = loadLibrary(joinPath(pathArray));
         if (res) {
             return res;
@@ -161,14 +163,14 @@ void* TryLibrary(const char* name)
     }
 
     // find by set LD_LIBRARY_PATH
-    pathArray = {name};
+    pathArray = { name };
     res = loadLibrary(joinPath(pathArray));
     if (res) {
         return res;
     }
 
     // find by DEFAULT_SDK_PATH
-    pathArray = {DEFAULT_SDK_PATH, PLUGIN_DIR, LIB_DIR, name};
+    pathArray = { DEFAULT_SDK_PATH, PLUGIN_DIR, LIB_DIR, name };
     res = loadLibrary(joinPath(pathArray));
     if (res) {
         return res;
@@ -177,9 +179,9 @@ void* TryLibrary(const char* name)
     return nullptr;
 }
 
-// TODO: @panda/sdk will be changed to match ohos-sdk
-void* FindLibrary() {
-    void *res = nullptr;
+void* FindLibrary()
+{
+    void* res = nullptr;
 
     res = TryLibrary(LIB_ES2PANDA_PUBLIC);
     if (res) {
@@ -225,47 +227,60 @@ 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() : "");
 }
 
-KNativePointer impl_CreateConfig(KInt argc, KStringArray& argvPtr)
+void impl_DestroyConfig(KNativePointer config)
 {
-    return GetImpl()->CreateConfig(argc, getStringArray(argvPtr));
+    const auto _config = reinterpret_cast<es2panda_Config*>(config);
+    // panda prints diagnostics here and do not clone our strings
+    // so keep arena alive until this moment.
+    GetImpl()->DestroyConfig(_config);
+    StageArena::Instance()->Cleanup();
+    printf("[libarkts native] Arena cleaned up!\n");
 }
-KOALA_INTEROP_2(CreateConfig, KNativePointer, KInt, KStringArray)
+KOALA_INTEROP_V1(DestroyConfig, KNativePointer)
 
-KNativePointer impl_DestroyConfig(KNativePointer configPtr)
-{
-    auto config = reinterpret_cast<es2panda_Config*>(configPtr);
-    GetImpl()->DestroyConfig(config);
-    return nullptr;
-}
-KOALA_INTEROP_1(DestroyConfig, KNativePointer, KNativePointer)
+// ─── Helpers to lower function size/complexity ────────────────────────────────
+namespace {
+template <class T, class U>
+inline T As(U v) { return reinterpret_cast<T>(v); }
 
-void impl_DestroyContext(KNativePointer contextPtr)
+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 context = reinterpret_cast<es2panda_Context*>(contextPtr);
-    GetImpl()->DestroyContext(context);
-    StageArena::instance()->cleanup();
+    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;
 }
-KOALA_INTEROP_V1(DestroyContext, KNativePointer)
+} // 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)
@@ -376,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);
 
@@ -385,72 +400,137 @@ struct Pattern {
     std::string key;
     std::string value;
     es2panda_Impl* impl;
+    bool isWildcard = false;
+    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& 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())
     {
         std::istringstream stream(part);
         std::getline(stream, key, '=');
         std::getline(stream, value, '=');
+        isWildcard = value.find('*') != std::string::npos;
+        if (isWildcard) {
+            this->regex = std::regex(value);
+        }
     }
-    bool match(es2panda_AstNode* node)
+
+    ~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:
-                case Es2pandaAstNodeType::AST_NODE_TYPE_SCRIPT_FUNCTION:
-
-                    return value == "method";
-                case Es2pandaAstNodeType::AST_NODE_TYPE_STRUCT_DECLARATION:
-                    return value == "struct";
-                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_METHOD_DEFINITION: {
-                    auto function = impl->MethodDefinitionFunction(context, node);
-                    result = impl->FunctionDeclarationAnnotations(context, function, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_FUNCTION_DECLARATION:
-                    result = impl->FunctionDeclarationAnnotations(context, node, &length);
-                    break;
-                case AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION: {
-                    auto function = impl->ArrowFunctionExpressionFunction(context, node);
-                    result = impl->FunctionDeclarationAnnotations(context, function, &length);
-                    break;
-                }
-                case Es2pandaAstNodeType::AST_NODE_TYPE_CLASS_PROPERTY:
-                    result = impl->ClassPropertyAnnotations(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)
+    bool MatchWildcard(const std::string& pattern, const char* foundValue) const
     {
-        if (pattern.find('*') == std::string::npos) {
-            return pattern == value;
+        if (!isWildcard) {
+            return pattern == foundValue;
         }
-        regex_t regex;
-        regmatch_t match[1];
-        regcomp(&regex, pattern.c_str(), REG_NEWLINE);
-        return regexec(&regex, value, 1, match, 0) != REG_NOMATCH;
+
+        return std::regex_search(foundValue, this->regex);
     }
 };
 
@@ -464,24 +544,24 @@ struct Matcher {
         std::istringstream stream(query);
         std::string item;
         while (std::getline(stream, item, ';')) {
-            patterns.emplace_back(Pattern(context, item));
+            patterns.emplace_back(std::forward<Pattern>(Pattern(context, item)));
         }
     }
     bool match(es2panda_AstNode* node)
     {
         bool result = true;
-        for (auto pattern : patterns) {
+        for (const auto& pattern : patterns) {
             result &= pattern.match(node);
         }
         return result;
     }
 };
 
-KNativePointer impl_FilterNodes(KNativePointer context, KNativePointer node, const KStringPtr& filters)
+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);
@@ -490,20 +570,73 @@ KNativePointer impl_FilterNodes(KNativePointer context, KNativePointer node, con
     while (queue.size() > 0) {
         auto* current = queue.back();
         queue.pop_back();
-        if (matcher.match(current)) {
+        bool isMatch = matcher.match(current);
+        if (isMatch) {
             result.push_back(current);
-        } else {
+        }
+        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());
+}
+
+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;
+    es2panda_Context *context;
+    std::bitset<AST_NODE_TYPE_LIMIT> *typesMask;
+    std::vector<es2panda_AstNode *> *result;
+};
+
+void filterByType(es2panda_AstNode *node, void *argsPointer)
+{
+    FilterArgs *args = reinterpret_cast<FilterArgs *>(argsPointer);
+    auto type = args->impl->AstNodeTypeConst(args->context, node);
+    if ((*args->typesMask)[type]) {
+        args->result->push_back(node);
+    }
+}
+
+KNativePointer impl_FilterNodes2(KNativePointer context, KNativePointer node, KInt type)
+{
+    auto _node = reinterpret_cast<es2panda_AstNode*>(node);
+    auto _context = reinterpret_cast<es2panda_Context*>(context);
+    std::bitset<AST_NODE_TYPE_LIMIT> typesMask;
+    typesMask.set(type);
+    std::vector<es2panda_AstNode *> result;
+    FilterArgs args = { GetImpl(), _context, &typesMask, &result };
+    GetImpl()->AstNodeForEach(_node, filterByType, &args);
+    return StageArena::CloneVector(result.data(), result.size());
+}
+KOALA_INTEROP_3(FilterNodes2, KNativePointer, KNativePointer, KNativePointer, KInt)
+
+KNativePointer impl_FilterNodes3(KNativePointer context, KNativePointer node, KInt* types, KInt typesSize)
+{
+    auto _node = reinterpret_cast<es2panda_AstNode*>(node);
+    auto _context = reinterpret_cast<es2panda_Context*>(context);
+    std::bitset<AST_NODE_TYPE_LIMIT> typesMask;
+    for (int i = 0; i < typesSize; i++) {
+        typesMask.set(types[i]);
+    }
+    std::vector<es2panda_AstNode *> result;
+    FilterArgs args = { GetImpl(), _context, &typesMask, &result };
+    GetImpl()->AstNodeForEach(_node, filterByType, &args);
+    return StageArena::CloneVector(result.data(), result.size());
 }
-KOALA_INTEROP_3(FilterNodes, KNativePointer, KNativePointer, KNativePointer, KStringPtr)
+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