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

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

@@ -14,12 +14,18 @@
  */
 
 #include <common.h>
+#include <iterator>
+#include <regex>
+#include <sstream>
 #include <utility>
+#include <vector>
+#include <bitset>
+
 #include "interop-types.h"
 
 using std::string, std::cout, std::endl, std::vector;
 
-es2panda_Impl *es2pandaImplementation = nullptr;
+es2panda_Impl* es2pandaImplementation = nullptr;
 static thread_local StageArena currentArena;
 
 StageArena* StageArena::instance()
@@ -75,28 +81,28 @@ void* StageArena::alloc(size_t size)
 }
 
 #ifdef KOALA_WINDOWS
-    #include <windows.h>
-    #define PLUGIN_DIR "windows_host_tools"
-    #define LIB_PREFIX "lib"
-    #define LIB_SUFFIX ".dll"
+#include <windows.h>
+#define PLUGIN_DIR "windows_host_tools"
+#define LIB_PREFIX "lib"
+#define LIB_SUFFIX ".dll"
 #endif
 
 #if defined(KOALA_LINUX) || defined(KOALA_MACOS)
-    #include <dlfcn.h>
+#include <dlfcn.h>
 
-    #ifdef __x86_64__
-        #define PLUGIN_DIR "linux_host_tools"
-    #else
-        #define PLUGIN_DIR "linux_arm64_host_tools"
-    #endif
+#ifdef __x86_64__
+#define PLUGIN_DIR "linux_host_tools"
+#else
+#define PLUGIN_DIR "linux_arm64_host_tools"
+#endif
 
-    #define LIB_PREFIX "lib"
-    #define LIB_SUFFIX ".so"
+#define LIB_PREFIX "lib"
+#define LIB_SUFFIX ".so"
 #endif
 
-const char* DEFAULT_SDK_PATH = "../../../incremental/tools/panda/node_modules/@panda/sdk" ;
-const char* NAME = LIB_PREFIX "es2panda-public" LIB_SUFFIX;
+const char* DEFAULT_SDK_PATH = "../../../incremental/tools/panda/node_modules/@panda/sdk";
 
+const char* LIB_ES2PANDA_PUBLIC_ALT = LIB_PREFIX "es2panda-public" LIB_SUFFIX;
 const char* LIB_ES2PANDA_PUBLIC = LIB_PREFIX "es2panda_public" LIB_SUFFIX;
 const char* IS_UI_FLAG = "IS_UI_FLAG";
 const char* NOT_UI_FLAG = "NOT_UI_FLAG";
@@ -104,15 +110,15 @@ const string MODULE_SUFFIX = ".d.ets";
 const string ARKUI = "arkui";
 
 #ifdef KOALA_WINDOWS
-    const char *SEPARATOR = "\\";
+const char* SEPARATOR = "\\";
 #else
-    const char *SEPARATOR = "/";
+const char* SEPARATOR = "/";
 #endif
-const char *LIB_DIR = "lib";
+const char* LIB_DIR = "lib";
 
 static std::string ES2PANDA_LIB_PATH = "";
 
-std::string joinPath(vector<string> &paths)
+std::string joinPath(vector<string>& paths)
 {
     std::string res;
     for (std::size_t i = 0; i < paths.size(); ++i) {
@@ -125,20 +131,20 @@ std::string joinPath(vector<string> &paths)
     return res;
 }
 
-void impl_SetUpSoPath(KStringPtr &soPath)
+void impl_SetUpSoPath(KStringPtr& soPath)
 {
     ES2PANDA_LIB_PATH = std::string(soPath.c_str());
 }
 KOALA_INTEROP_V1(SetUpSoPath, KStringPtr);
 
-// Improve: simplify this
-void* FindLibrary() {
-    void *res = nullptr;
+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, LIB_ES2PANDA_PUBLIC};
+        pathArray = { ES2PANDA_LIB_PATH, LIB_DIR, name };
         res = loadLibrary(joinPath(pathArray));
         if (res) {
             return res;
@@ -148,7 +154,7 @@ void* FindLibrary() {
     // 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;
@@ -156,14 +162,14 @@ void* FindLibrary() {
     }
 
     // find by set LD_LIBRARY_PATH
-    pathArray = {LIB_ES2PANDA_PUBLIC};
+    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;
@@ -172,7 +178,25 @@ void* FindLibrary() {
     return nullptr;
 }
 
-es2panda_Impl *GetImplSlow()
+// TODO: @panda/sdk will be changed to match ohos-sdk
+void* FindLibrary()
+{
+    void* res = nullptr;
+
+    res = TryLibrary(LIB_ES2PANDA_PUBLIC);
+    if (res) {
+        return res;
+    }
+
+    res = TryLibrary(LIB_ES2PANDA_PUBLIC_ALT);
+    if (res) {
+        return res;
+    }
+
+    return nullptr;
+}
+
+es2panda_Impl* GetImplSlow()
 {
     if (es2pandaImplementation) {
         return es2pandaImplementation;
@@ -187,7 +211,7 @@ es2panda_Impl *GetImplSlow()
         printf("no entry point");
         abort();
     }
-    es2pandaImplementation = reinterpret_cast<es2panda_Impl *(*)(int)>(symbol)(ES2PANDA_LIB_VERSION);
+    es2pandaImplementation = reinterpret_cast<es2panda_Impl* (*)(int)>(symbol)(ES2PANDA_LIB_VERSION);
     return es2pandaImplementation;
 }
 
@@ -196,51 +220,31 @@ string getString(KStringPtr ptr)
     return ptr.data();
 }
 
-char* getStringCopy(KStringPtr& ptr)
+const char** getStringArray(KStringArray& ptr)
 {
-    return StageArena::strdup(ptr.c_str() ? ptr.c_str() : "");
-}
-
-KNativePointer impl_CreateConfig(KInt argc, KStringArray argvPtr) {
-    const std::size_t headerLen = 4;
-
-    const char** argv = StageArena::allocArray<const char*>(argc);
-    std::size_t position = headerLen;
-    std::size_t strLen;
-    for (std::size_t i = 0; i < static_cast<std::size_t>(argc); ++i) {
-        strLen = unpackUInt(argvPtr + position);
-        position += headerLen;
-        argv[i] = StageArena::strdup(std::string(reinterpret_cast<const char*>(argvPtr + position), strLen).c_str());
-        position += strLen;
-    }
-    return GetImpl()->CreateConfig(argc, argv);
+    return const_cast<const char**>(ptr.get()); // release()?
 }
-KOALA_INTEROP_2(CreateConfig, KNativePointer, KInt, KStringArray)
 
-KNativePointer impl_DestroyConfig(KNativePointer configPtr) {
-    auto config = reinterpret_cast<es2panda_Config*>(configPtr);
-    GetImpl()->DestroyConfig(config);
-    return nullptr;
+char* getStringCopy(KStringPtr& ptr)
+{
+    return StageArena::strdup(ptr.c_str() ? ptr.c_str() : "");
 }
-KOALA_INTEROP_1(DestroyConfig, KNativePointer, KNativePointer)
 
-void impl_DestroyContext(KNativePointer contextPtr) {
-    auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
-    GetImpl()->DestroyContext(context);
+void impl_DestroyConfig(KNativePointer config)
+{
+    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_V1(DestroyContext, KNativePointer)
-
-KNativePointer impl_UpdateCallExpression(
-    KNativePointer contextPtr,
-    KNativePointer nodePtr,
-    KNativePointer calleePtr,
-    KNativePointerArray argumentsPtr,
-    KInt argumentsLen,
-    KNativePointer typeParamsPtr,
-    KBoolean optionalT,
-    KBoolean trailingCommaT
-) {
+KOALA_INTEROP_V1(DestroyConfig, KNativePointer);
+
+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);
@@ -249,26 +253,28 @@ KNativePointer impl_UpdateCallExpression(
     auto optional = static_cast<bool>(optionalT);
     auto trailingComma = static_cast<bool>(trailingCommaT);
 
-    auto nn = GetImpl()->CreateCallExpression(
-        context, callee, arguments, argumentsLen, typeParams, optional, trailingComma
-    );
+    auto nn =
+        GetImpl()->CreateCallExpression(context, callee, arguments, argumentsLen, typeParams, optional, trailingComma);
     GetImpl()->AstNodeSetOriginalNode(context, nn, node);
     return nn;
 }
-KOALA_INTEROP_8(UpdateCallExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KNativePointer, KBoolean, KBoolean)
+KOALA_INTEROP_8(UpdateCallExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer,
+    KNativePointerArray, KInt, KNativePointer, KBoolean, KBoolean)
 
-KInt impl_IdentifierIdentifierFlags(KNativePointer contextPtr, KNativePointer nodePtr) {
+KInt impl_IdentifierIdentifierFlags(KNativePointer contextPtr, KNativePointer nodePtr)
+{
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
 
-    return
-        (GetImpl()->IdentifierIsOptionalConst(context, node) ? (1 << 0) : 0) |
-        (GetImpl()->IdentifierIsReferenceConst(context, node) ? (1 << 1) : 0) |
-        (GetImpl()->IdentifierIsTdzConst(context, node) ? (1 << 2) : 0);
+    return (GetImpl()->IdentifierIsOptionalConst(context, node) ? (1 << 0) : 0) |
+           (GetImpl()->IdentifierIsReferenceConst(context, node) ? (1 << 1) : 0) |
+           (GetImpl()->IdentifierIsTdzConst(context, node) ? (1 << 2) : 0);
 }
 KOALA_INTEROP_2(IdentifierIdentifierFlags, KInt, KNativePointer, KNativePointer)
 
-void impl_ClassDefinitionSetBody(KNativePointer context, KNativePointer receiver, KNativePointerArray body, KUInt bodyLength) {
+void impl_ClassDefinitionSetBody(
+    KNativePointer context, KNativePointer receiver, KNativePointerArray body, KUInt bodyLength)
+{
     const auto _context = reinterpret_cast<es2panda_Context*>(context);
     const auto _receiver = reinterpret_cast<es2panda_AstNode*>(receiver);
     const auto _body = reinterpret_cast<es2panda_AstNode**>(body);
@@ -285,24 +291,25 @@ Improve: NOT FROM API (shouldn't be there)
 -----------------------------------------------------------------------------------------------------------------------------
 */
 
-es2panda_AstNode * cachedParentNode;
-es2panda_Context * cachedContext;
+es2panda_AstNode* cachedParentNode;
+es2panda_Context* cachedContext;
 
-static void changeParent(es2panda_AstNode *child)
+static void changeParent(es2panda_AstNode* child)
 {
     GetImpl()->AstNodeSetParent(cachedContext, child, cachedParentNode);
 }
 
-static void SetRightParent(es2panda_AstNode *node, void *arg)
+static void SetRightParent(es2panda_AstNode* node, void* arg)
 {
-    es2panda_Context *ctx = static_cast<es2panda_Context *>(arg);
+    es2panda_Context* ctx = static_cast<es2panda_Context*>(arg);
     cachedContext = ctx;
     cachedParentNode = node;
 
     GetImpl()->AstNodeIterateConst(ctx, node, changeParent);
 }
 
-KNativePointer impl_AstNodeUpdateAll(KNativePointer contextPtr, KNativePointer programPtr) {
+KNativePointer impl_AstNodeUpdateAll(KNativePointer contextPtr, KNativePointer programPtr)
+{
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
     auto program = reinterpret_cast<es2panda_AstNode*>(programPtr);
 
@@ -311,7 +318,8 @@ KNativePointer impl_AstNodeUpdateAll(KNativePointer contextPtr, KNativePointer p
 }
 KOALA_INTEROP_2(AstNodeUpdateAll, KNativePointer, KNativePointer, KNativePointer)
 
-void impl_AstNodeSetChildrenParentPtr(KNativePointer contextPtr, KNativePointer nodePtr) {
+void impl_AstNodeSetChildrenParentPtr(KNativePointer contextPtr, KNativePointer nodePtr)
+{
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
     cachedParentNode = node;
@@ -320,7 +328,8 @@ void impl_AstNodeSetChildrenParentPtr(KNativePointer contextPtr, KNativePointer
 }
 KOALA_INTEROP_V2(AstNodeSetChildrenParentPtr, KNativePointer, KNativePointer)
 
-void impl_AstNodeOnUpdate(KNativePointer context, KNativePointer newNode, KNativePointer replacedNode) {
+void impl_AstNodeOnUpdate(KNativePointer context, KNativePointer newNode, KNativePointer replacedNode)
+{
     auto _context = reinterpret_cast<es2panda_Context*>(context);
     auto _newNode = reinterpret_cast<es2panda_AstNode*>(newNode);
     auto _replacedNode = reinterpret_cast<es2panda_AstNode*>(replacedNode);
@@ -343,17 +352,15 @@ void impl_AstNodeOnUpdate(KNativePointer context, KNativePointer newNode, KNativ
 }
 KOALA_INTEROP_V3(AstNodeOnUpdate, KNativePointer, KNativePointer, KNativePointer)
 
-std::vector<void*> cachedChildren;
+static thread_local std::vector<es2panda_AstNode*> cachedChildren;
 
-static void visitChild(es2panda_AstNode *node)
+static void visitChild(es2panda_AstNode* node)
 {
     cachedChildren.emplace_back(node);
 }
 
-KNativePointer impl_AstNodeChildren(
-    KNativePointer contextPtr,
-    KNativePointer nodePtr
-) {
+KNativePointer impl_AstNodeChildren(KNativePointer contextPtr, KNativePointer nodePtr)
+{
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
     cachedContext = context;
@@ -362,7 +369,219 @@ KNativePointer impl_AstNodeChildren(
     GetImpl()->AstNodeIterateConst(context, node, visitChild);
     return StageArena::clone(cachedChildren);
 }
-KOALA_INTEROP_2(AstNodeChildren, KNativePointer, KNativePointer, KNativePointer)
+KOALA_INTEROP_2(AstNodeChildren, KNativePointer, KNativePointer, KNativePointer);
+
+struct Pattern {
+    es2panda_Context* context;
+    std::string key;
+    std::string value;
+    es2panda_Impl* impl;
+    bool isWildcard = false;
+    std::regex regex;
+
+    Pattern(const Pattern&) = delete;
+
+    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(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);
+        }
+    }
+    
+    ~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;
+            }
+        }
+        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;
+            }
+            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);
+            }
+            return found;
+        }
+        return false;
+    }
+
+    bool matchWildcard(const std::string& pattern, const char* value) const
+    {
+        if (!isWildcard) {
+            return pattern == value;
+        }
+
+        return std::regex_search(value, this->regex);
+    }
+};
+
+struct Matcher {
+    es2panda_Context* context;
+    const char* query;
+    std::vector<Pattern> patterns;
+    es2panda_Impl* impl;
+    Matcher(es2panda_Context* context, const char* query) : context(context), query(query), impl(GetImpl())
+    {
+        std::istringstream stream(query);
+        std::string item;
+        while (std::getline(stream, item, ';')) {
+            patterns.emplace_back(std::forward<Pattern>(Pattern(context, item)));
+        }
+    }
+    bool match(es2panda_AstNode* node)
+    {
+        bool result = true;
+        for (const auto& pattern : patterns) {
+            result &= pattern.match(node);
+        }
+        return result;
+    }
+};
+
+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);
+    const char* _filters = filters.c_str();
+    std::vector<es2panda_AstNode*> result;
+    es2panda_Impl* impl = GetImpl();
+    Matcher matcher(_context, _filters);
+    std::vector<es2panda_AstNode*> queue;
+    queue.push_back(_node);
+    while (queue.size() > 0) {
+        auto* current = queue.back();
+        queue.pop_back();
+        bool isMatch = matcher.match(current);
+        if (isMatch) {
+            result.push_back(current);
+        }
+        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());
+}
+KOALA_INTEROP_4(FilterNodes, KNativePointer, KNativePointer, KNativePointer, KStringPtr, KBoolean)
+
+constexpr int AST_NODE_TYPE_LIMIT = 256;
+
+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_4(FilterNodes3, KNativePointer, KNativePointer, KNativePointer, KInt*, KInt)
 
 /*
 -----------------------------------------------------------------------------------------------------------------------------
@@ -390,9 +609,9 @@ static bool isUIHeaderFile(es2panda_Context* context, es2panda_Program* program)
     result = GetImpl()->ProgramModuleNameConst(context, program);
     string moduleName(result);
 
-    return fileNameWithExtension.length() >= MODULE_SUFFIX.length()
-        && fileNameWithExtension.substr(fileNameWithExtension.length() - MODULE_SUFFIX.length()) == MODULE_SUFFIX
-        && moduleName.find(ARKUI) != std::string::npos;
+    return fileNameWithExtension.length() >= MODULE_SUFFIX.length() &&
+           fileNameWithExtension.substr(fileNameWithExtension.length() - MODULE_SUFFIX.length()) == MODULE_SUFFIX &&
+           moduleName.find(ARKUI) != std::string::npos;
 }
 
 KBoolean impl_ProgramCanSkipPhases(KNativePointer context, KNativePointer program)
@@ -405,8 +624,8 @@ KBoolean impl_ProgramCanSkipPhases(KNativePointer context, KNativePointer progra
         return false;
     }
     std::size_t sourceLen;
-    const auto externalSources = reinterpret_cast<es2panda_ExternalSource **>
-        (GetImpl()->ProgramExternalSources(_context, _program, &sourceLen));
+    const auto externalSources =
+        reinterpret_cast<es2panda_ExternalSource**>(GetImpl()->ProgramExternalSources(_context, _program, &sourceLen));
     for (std::size_t i = 0; i < sourceLen; ++i) {
         std::size_t programLen;
         auto programs = GetImpl()->ExternalSourcePrograms(externalSources[i], &programLen);