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

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

@@ -14,12 +14,17 @@
  */
 
 #include <common.h>
+#include <iterator>
+#include <regex.h>
+#include <sstream>
 #include <utility>
+#include <vector>
+
 #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 +80,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 +109,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 +130,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 +153,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 +161,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 +177,24 @@ 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 +209,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 +218,42 @@ string getString(KStringPtr ptr)
     return ptr.data();
 }
 
+const char** getStringArray(KStringArray& ptr)
+{
+    return const_cast<const char**>(ptr.get()); // release()?
+}
+
 char* getStringCopy(KStringPtr& 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);
+KNativePointer impl_CreateConfig(KInt argc, KStringArray& argvPtr)
+{
+    return GetImpl()->CreateConfig(argc, getStringArray(argvPtr));
 }
 KOALA_INTEROP_2(CreateConfig, KNativePointer, KInt, KStringArray)
 
-KNativePointer impl_DestroyConfig(KNativePointer configPtr) {
+KNativePointer impl_DestroyConfig(KNativePointer configPtr)
+{
     auto config = reinterpret_cast<es2panda_Config*>(configPtr);
     GetImpl()->DestroyConfig(config);
     return nullptr;
 }
 KOALA_INTEROP_1(DestroyConfig, KNativePointer, KNativePointer)
 
-void impl_DestroyContext(KNativePointer contextPtr) {
+void impl_DestroyContext(KNativePointer contextPtr)
+{
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
     GetImpl()->DestroyContext(context);
     StageArena::instance()->cleanup();
 }
 KOALA_INTEROP_V1(DestroyContext, KNativePointer)
 
-KNativePointer impl_UpdateCallExpression(
-    KNativePointer contextPtr,
-    KNativePointer nodePtr,
-    KNativePointer calleePtr,
-    KNativePointerArray argumentsPtr,
-    KInt argumentsLen,
-    KNativePointer typeParamsPtr,
-    KBoolean optionalT,
-    KBoolean trailingCommaT
-) {
+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 +262,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 +300,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 +327,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 +337,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 +361,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 +378,132 @@ 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;
+
+    Pattern(es2panda_Context* context, const std::string& part) : context(context), impl(GetImpl())
+    {
+        std::istringstream stream(part);
+        std::getline(stream, key, '=');
+        std::getline(stream, value, '=');
+    }
+    bool match(es2panda_AstNode* node)
+    {
+        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;
+            }
+        }
+        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;
+            }
+            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)
+    {
+        if (pattern.find('*') == std::string::npos) {
+            return pattern == value;
+        }
+        regex_t regex;
+        regmatch_t match[1];
+        regcomp(&regex, pattern.c_str(), REG_NEWLINE);
+        return regexec(&regex, value, 1, match, 0) != REG_NOMATCH;
+    }
+};
+
+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(Pattern(context, item));
+        }
+    }
+    bool match(es2panda_AstNode* node)
+    {
+        bool result = true;
+        for (auto pattern : patterns) {
+            result &= pattern.match(node);
+        }
+        return result;
+    }
+};
+
+KNativePointer impl_FilterNodes(KNativePointer context, KNativePointer node, const KStringPtr& filters)
+{
+    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();
+        if (matcher.match(current)) {
+            result.push_back(current);
+        } else {
+            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_3(FilterNodes, KNativePointer, KNativePointer, KNativePointer, KStringPtr)
 
 /*
 -----------------------------------------------------------------------------------------------------------------------------
@@ -390,9 +531,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 +546,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);

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

@@ -31,21 +31,23 @@
  * limitations under the License.
  */
 
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "common-interop.h"
 #include "dynamic-loader.h"
 #include "es2panda_lib.h"
-#include "common-interop.h"
-#include "stdexcept"
 #include "interop-utils.h"
-#include <string>
-#include <iostream>
-#include <vector>
+#include "stdexcept"
 
 using std::string, std::cout, std::endl, std::vector;
 
-extern es2panda_Impl *es2pandaImplementation;
+extern es2panda_Impl* es2pandaImplementation;
 
-es2panda_Impl *GetImplSlow();
-inline es2panda_Impl *GetImpl() {
+es2panda_Impl* GetImplSlow();
+inline es2panda_Impl* GetImpl()
+{
     if (es2pandaImplementation) {
         return es2pandaImplementation;
     }
@@ -53,6 +55,7 @@ inline es2panda_Impl *GetImpl() {
 }
 
 string getString(KStringPtr ptr);
+const char** getStringArray(KStringArray& ptr);
 
 char* getStringCopy(KStringPtr& ptr);
 
@@ -66,12 +69,8 @@ inline KUInt unpackUInt(const KByte* bytes)
     const KUInt BYTE_1_SHIFT = 8;
     const KUInt BYTE_2_SHIFT = 16;
     const KUInt BYTE_3_SHIFT = 24;
-    return (
-        bytes[BYTE_0]
-        | (bytes[BYTE_1] << BYTE_1_SHIFT)
-        | (bytes[BYTE_2] << BYTE_2_SHIFT)
-        | (bytes[BYTE_3] << BYTE_3_SHIFT)
-    );
+    return (bytes[BYTE_0] | (bytes[BYTE_1] << BYTE_1_SHIFT) | (bytes[BYTE_2] << BYTE_2_SHIFT) |
+            (bytes[BYTE_3] << BYTE_3_SHIFT));
 }
 
 es2panda_ContextState intToState(KInt state);
@@ -79,32 +78,33 @@ es2panda_ContextState intToState(KInt state);
 class StageArena {
     std::vector<void*> allocated;
     size_t totalSize;
-  public:
+
+public:
     StageArena();
     ~StageArena();
     static StageArena* instance();
-    template <typename T>
+    template<typename T>
     static T* alloc()
     {
         auto* arena = StageArena::instance();
         void* memory = arena->alloc(sizeof(T));
         return new (memory) T();
     }
-    template <class T, class T1>
+    template<class T, class T1>
     static T* alloc(T1 arg1)
     {
         auto* arena = StageArena::instance();
         void* memory = arena->alloc(sizeof(T));
         return new (memory) T(std::forward(arg1));
     }
-    template <class T, class T1, class T2>
+    template<class T, class T1, class T2>
     static T* alloc(T1 arg1, T2 arg2)
     {
         auto* arena = StageArena::instance();
         void* memory = arena->alloc(sizeof(T));
         return new (memory) T(arg1, arg2);
     }
-    template <typename T>
+    template<typename T>
     static T* allocArray(size_t count)
     {
         auto* arena = StageArena::instance();
@@ -112,14 +112,14 @@ class StageArena {
         void* memory = arena->alloc(sizeof(T) * count);
         return new (memory) T();
     }
-    template <class T>
+    template<class T>
     static T* clone(const T& arg)
     {
         auto* arena = StageArena::instance();
         void* memory = arena->alloc(sizeof(T));
         return new (memory) T(arg);
     }
-    template <class T>
+    template<class T>
     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);
@@ -130,4 +130,4 @@ class StageArena {
     void cleanup();
 };
 
-#endif // COMMON_H
+#endif // COMMON_H