diff --git a/ets2panda/checker/ETSAnalyzer.cpp b/ets2panda/checker/ETSAnalyzer.cpp
index a35397d0b8c46ba7ecf41bf291460bc34c09848c..749c7f5cc34d8644705d78f56f8d7364b525ec41 100644
--- a/ets2panda/checker/ETSAnalyzer.cpp
+++ b/ets2panda/checker/ETSAnalyzer.cpp
@@ -769,7 +769,7 @@ checker::Type *ETSAnalyzer::Check(ir::ETSKeyofType *node) const
 // compile methods for EXPRESSIONS in alphabetical order
 
 static void AddSpreadElementTypes(ETSChecker *checker, ir::SpreadElement *const element,
-                                  ArenaVector<std::pair<Type *, ir::Expression *>> &elementTypes)
+                                  std::vector<std::pair<Type *, ir::Expression *>> &elementTypes)
 {
     Type *const spreadType = element->Check(checker);
 
@@ -803,9 +803,9 @@ static bool ValidArrayExprSizeForTupleSize(ETSChecker *checker, Type *possibleTu
                                                  possibleTupleType->AsETSTupleType());
 }
 
-static ArenaVector<std::pair<Type *, ir::Expression *>> GetElementTypes(ETSChecker *checker, ir::ArrayExpression *expr)
+static std::vector<std::pair<Type *, ir::Expression *>> GetElementTypes(ETSChecker *checker, ir::ArrayExpression *expr)
 {
-    ArenaVector<std::pair<Type *, ir::Expression *>> elementTypes(checker->ProgramAllocator()->Adapter());
+    std::vector<std::pair<Type *, ir::Expression *>> elementTypes {};
 
     auto *const exprPreferredType = expr->PreferredType();
     auto *const exprTupleType = exprPreferredType->IsETSTupleType() ? exprPreferredType->AsETSTupleType() : nullptr;
@@ -847,7 +847,7 @@ static Type *GetArrayElementType(ETSChecker *checker, Type *preferredType)
 }
 
 static bool CheckElement(ETSChecker *checker, Type *const preferredType,
-                         ArenaVector<std::pair<Type *, ir::Expression *>> arrayExprElementTypes, std::size_t idx)
+                         std::vector<std::pair<Type *, ir::Expression *>> arrayExprElementTypes, std::size_t idx)
 {
     auto [elementType, currentElement] = arrayExprElementTypes[idx];
 
@@ -934,7 +934,7 @@ static Type *InferPreferredTypeFromElements(ETSChecker *checker, ir::ArrayExpres
 
 static bool CheckArrayExpressionElements(ETSChecker *checker, ir::ArrayExpression *arrayExpr)
 {
-    const ArenaVector<std::pair<Type *, ir::Expression *>> arrayExprElementTypes = GetElementTypes(checker, arrayExpr);
+    const std::vector<std::pair<Type *, ir::Expression *>> arrayExprElementTypes = GetElementTypes(checker, arrayExpr);
 
     bool allElementsAssignable = !std::any_of(arrayExprElementTypes.begin(), arrayExprElementTypes.end(),
                                               [](auto &pair) { return pair.first->IsTypeError(); });
diff --git a/ets2panda/checker/TSchecker.h b/ets2panda/checker/TSchecker.h
index 77756cb4891aa666dcdf36041f559260a12ff917..e60853343903954b757dcadc6db12e069fb2bdd0 100644
--- a/ets2panda/checker/TSchecker.h
+++ b/ets2panda/checker/TSchecker.h
@@ -320,11 +320,11 @@ public:
 
     // Object
     void ResolvePropertiesOfObjectType(ObjectType *type, ir::AstNode *member,
-                                       ArenaVector<ir::TSSignatureDeclaration *> &signatureDeclarations,
-                                       ArenaVector<ir::TSIndexSignature *> &indexDeclarations, bool isInterface);
+                                       std::vector<ir::TSSignatureDeclaration *> &signatureDeclarations,
+                                       std::vector<ir::TSIndexSignature *> &indexDeclarations, bool isInterface);
     void ResolveSignaturesOfObjectType(ObjectType *type,
-                                       ArenaVector<ir::TSSignatureDeclaration *> &signatureDeclarations);
-    void ResolveIndexInfosOfObjectType(ObjectType *type, ArenaVector<ir::TSIndexSignature *> &indexDeclarations);
+                                       std::vector<ir::TSSignatureDeclaration *> &signatureDeclarations);
+    void ResolveIndexInfosOfObjectType(ObjectType *type, std::vector<ir::TSIndexSignature *> &indexDeclarations);
     void ResolveDeclaredMembers(InterfaceType *type);
     bool ValidateInterfaceMemberRedeclaration(ObjectType *type, varbinder::Variable *prop,
                                               const lexer::SourcePosition &locInfo);
@@ -366,7 +366,7 @@ public:
     void CreatePatternParameterName(ir::AstNode *node, std::stringstream &ss);
     void HandlePropertyPatternParameterName(ir::Property *prop, std::stringstream &ss);
     void ThrowReturnTypeCircularityError(ir::ScriptFunction *func);
-    ArgRange GetArgRange(const ArenaVector<Signature *> &signatures, ArenaVector<Signature *> *potentialSignatures,
+    ArgRange GetArgRange(const ArenaVector<Signature *> &signatures, std::vector<Signature *> *potentialSignatures,
                          uint32_t callArgsSize, bool *haveSignatureWithRest);
     bool CallMatchesSignature(const ArenaVector<ir::Expression *> &args, Signature *signature, bool throwError);
     Type *ResolveCallOrNewExpression(const ArenaVector<Signature *> &signatures,
diff --git a/ets2panda/checker/ets/function.cpp b/ets2panda/checker/ets/function.cpp
index f42c123c760130414ae1a5beef82b2a2157f2fe3..4c37a0976a33803e4ee51b814503e0a04e5a0a6f 100644
--- a/ets2panda/checker/ets/function.cpp
+++ b/ets2panda/checker/ets/function.cpp
@@ -166,7 +166,7 @@ bool ETSChecker::EnhanceSubstitutionForUnion(const ArenaVector<Type *> &typePara
     }
     auto *const argUn = argumentType->AsETSUnionType();
 
-    ArenaVector<Type *> paramWlist(ProgramAllocator()->Adapter());
+    std::vector<Type *> paramWlist {};
     ArenaVector<Type *> argWlist(ProgramAllocator()->Adapter());
 
     for (auto *pc : paramUn->ConstituentTypes()) {
@@ -1532,7 +1532,7 @@ void ETSChecker::CheckObjectLiteralArguments(Signature *signature, ArenaVector<i
 static bool CollectOverload(checker::ETSChecker *checker, ir::MethodDefinition *method, ETSFunctionType *funcType)
 {
     ir::OverloadInfo &ldInfo = method->GetOverloadInfoForUpdate();
-    ArenaVector<ETSFunctionType *> overloads(checker->ProgramAllocator()->Adapter());
+    std::vector<ETSFunctionType *> overloads {};
 
     for (ir::MethodDefinition *const currentFunc : method->Overloads()) {
         if (currentFunc->IsDeclare() != ldInfo.isDeclare) {
diff --git a/ets2panda/checker/ets/typeCheckingHelpers.cpp b/ets2panda/checker/ets/typeCheckingHelpers.cpp
index cd193f452313a1b09f34b39efb0a48bab3a12d3e..40475459df75edef9a31b8febc8232bf32546a50 100644
--- a/ets2panda/checker/ets/typeCheckingHelpers.cpp
+++ b/ets2panda/checker/ets/typeCheckingHelpers.cpp
@@ -1533,7 +1533,7 @@ bool ETSChecker::CheckLambdaTypeAnnotation(ir::ETSParameterExpression *param,
 
     // Preserve actual lambda types
     ir::ScriptFunction *const lambda = arrowFuncExpr->Function();
-    ArenaVector<ir::TypeNode *> lambdaParamTypes {ProgramAllocator()->Adapter()};
+    std::vector<ir::TypeNode *> lambdaParamTypes {};
     for (auto *const lambdaParam : lambda->Params()) {
         lambdaParamTypes.emplace_back(lambdaParam->AsETSParameterExpression()->Ident()->TypeAnnotation());
     }
diff --git a/ets2panda/checker/ts/function.cpp b/ets2panda/checker/ts/function.cpp
index 7b0634260ae6807f7d3a0a5ed3871690ee83a8db..967bdaf008739d7ad008055525da02c4eba37cc8 100644
--- a/ets2panda/checker/ts/function.cpp
+++ b/ets2panda/checker/ts/function.cpp
@@ -683,7 +683,7 @@ void TSChecker::CheckAllCodePathsInNonVoidFunctionReturnOrThrow(ir::ScriptFuncti
 }
 
 ArgRange TSChecker::GetArgRange(const ArenaVector<Signature *> &signatures,
-                                ArenaVector<Signature *> *potentialSignatures, uint32_t callArgsSize,
+                                std::vector<Signature *> *potentialSignatures, uint32_t callArgsSize,
                                 bool *haveSignatureWithRest)
 {
     uint32_t minArg = UINT32_MAX;
@@ -752,7 +752,7 @@ Type *TSChecker::ResolveCallOrNewExpression(const ArenaVector<Signature *> &sign
         ThrowTypeError("This expression is not callable.", errPos);
     }
 
-    ArenaVector<checker::Signature *> potentialSignatures(Allocator()->Adapter());
+    std::vector<checker::Signature *> potentialSignatures {};
     bool haveSignatureWithRest = false;
 
     auto argRange = GetArgRange(signatures, &potentialSignatures, arguments.size(), &haveSignatureWithRest);
diff --git a/ets2panda/checker/ts/object.cpp b/ets2panda/checker/ts/object.cpp
index 0c9e3c25c32a4186ee55c6746a6e212a05cedbc7..e8c7bc1db6648c97731c18a00311f4f2ce816f2c 100644
--- a/ets2panda/checker/ts/object.cpp
+++ b/ets2panda/checker/ts/object.cpp
@@ -177,8 +177,8 @@ void TSChecker::ResolveObjectTypeMembers(ObjectType *type)
 
     ES2PANDA_ASSERT(type->Variable() && type->Variable()->Declaration()->Node()->IsTSTypeLiteral());
     auto *typeLiteral = type->Variable()->Declaration()->Node()->AsTSTypeLiteral();
-    ArenaVector<ir::TSSignatureDeclaration *> signatureDeclarations(Allocator()->Adapter());
-    ArenaVector<ir::TSIndexSignature *> indexDeclarations(Allocator()->Adapter());
+    std::vector<ir::TSSignatureDeclaration *> signatureDeclarations {};
+    std::vector<ir::TSIndexSignature *> indexDeclarations {};
 
     for (auto *it : typeLiteral->Members()) {
         ResolvePropertiesOfObjectType(type, it, signatureDeclarations, indexDeclarations, false);
@@ -191,8 +191,8 @@ void TSChecker::ResolveObjectTypeMembers(ObjectType *type)
 }
 
 void TSChecker::ResolvePropertiesOfObjectType(ObjectType *type, ir::AstNode *member,
-                                              ArenaVector<ir::TSSignatureDeclaration *> &signatureDeclarations,
-                                              ArenaVector<ir::TSIndexSignature *> &indexDeclarations, bool isInterface)
+                                              std::vector<ir::TSSignatureDeclaration *> &signatureDeclarations,
+                                              std::vector<ir::TSIndexSignature *> &indexDeclarations, bool isInterface)
 {
     if (member->IsTSPropertySignature()) {
         varbinder::Variable *prop = member->AsTSPropertySignature()->Variable();
@@ -226,7 +226,7 @@ void TSChecker::ResolvePropertiesOfObjectType(ObjectType *type, ir::AstNode *mem
 }
 
 void TSChecker::ResolveSignaturesOfObjectType(ObjectType *type,
-                                              ArenaVector<ir::TSSignatureDeclaration *> &signatureDeclarations)
+                                              std::vector<ir::TSSignatureDeclaration *> &signatureDeclarations)
 {
     for (auto *it : signatureDeclarations) {
         Type *placeholderObj = it->Check(this);
@@ -240,7 +240,7 @@ void TSChecker::ResolveSignaturesOfObjectType(ObjectType *type,
         type->AddConstructSignature(placeholderObj->AsObjectType()->ConstructSignatures()[0]);
     }
 }
-void TSChecker::ResolveIndexInfosOfObjectType(ObjectType *type, ArenaVector<ir::TSIndexSignature *> &indexDeclarations)
+void TSChecker::ResolveIndexInfosOfObjectType(ObjectType *type, std::vector<ir::TSIndexSignature *> &indexDeclarations)
 {
     for (auto *it : indexDeclarations) {
         Type *placeholderObj = it->Check(this);
@@ -512,8 +512,8 @@ void TSChecker::ResolveDeclaredMembers(InterfaceType *type)
     ES2PANDA_ASSERT(type->Variable() && type->Variable()->Declaration()->IsInterfaceDecl());
     varbinder::InterfaceDecl *decl = type->Variable()->Declaration()->AsInterfaceDecl();
 
-    ArenaVector<ir::TSSignatureDeclaration *> signatureDeclarations(Allocator()->Adapter());
-    ArenaVector<ir::TSIndexSignature *> indexDeclarations(Allocator()->Adapter());
+    std::vector<ir::TSSignatureDeclaration *> signatureDeclarations {};
+    std::vector<ir::TSIndexSignature *> indexDeclarations {};
 
     for (const auto *declaration : decl->Decls()) {
         for (auto *member : declaration->Body()->Body()) {
diff --git a/ets2panda/compiler/core/ETSCompiler.cpp b/ets2panda/compiler/core/ETSCompiler.cpp
index fc921010efd67abd01808af32ff58f76ca59f6a1..5330f8b043005ff0f82821a4534f94e00c48cdbe 100644
--- a/ets2panda/compiler/core/ETSCompiler.cpp
+++ b/ets2panda/compiler/core/ETSCompiler.cpp
@@ -193,7 +193,7 @@ static void ConvertRestArguments(checker::ETSChecker *const checker, const ir::E
 static void HandleUnionTypeInForOf(compiler::ETSGen *etsg, checker::Type const *const exprType,
                                    const ir::ForOfStatement *st, VReg objReg, VReg *countReg)
 {
-    ArenaVector<Label *> labels(etsg->Allocator()->Adapter());
+    std::vector<Label *> labels {};
 
     for (auto it : exprType->AsETSUnionType()->ConstituentTypes()) {
         labels.push_back(etsg->AllocLabel());
diff --git a/ets2panda/compiler/core/ETSGen.h b/ets2panda/compiler/core/ETSGen.h
index 72d720e5216e98efc35aa57cdd3f60289616e6b5..24fc4945aa887a03e77909f9c69983a2e2b10131 100644
--- a/ets2panda/compiler/core/ETSGen.h
+++ b/ets2panda/compiler/core/ETSGen.h
@@ -297,7 +297,6 @@ public:
     {
         CallImpl<InitobjShort, Initobj, InitobjRange>(node, signature, arguments);
     }
-
     bool IsDevirtualizedSignature(const checker::Signature *signature)
     {
         ES2PANDA_ASSERT(signature != nullptr && !signature->HasSignatureFlag(checker::SignatureFlags::STATIC));
diff --git a/ets2panda/compiler/core/ETSemitter.cpp b/ets2panda/compiler/core/ETSemitter.cpp
index de105630af76aae36079948cf88f3a910ca8178c..1c7d474a0e1cf70197b91d5a97270a091f08213c 100644
--- a/ets2panda/compiler/core/ETSemitter.cpp
+++ b/ets2panda/compiler/core/ETSemitter.cpp
@@ -783,7 +783,7 @@ void ETSEmitter::ProcessArrayElement(const ir::Expression *elem, std::vector<pan
     }
 }
 
-LiteralArrayVector ETSEmitter::CreateLiteralArray(std::string &baseName, const ir::Expression *array)
+LiteralArrayVector ETSEmitter::CreateLiteralArray(std::string &baseName, [[maybe_unused]] const ir::Expression *array)
 {
     LiteralArrayVector result;
     std::vector<pandasm::LiteralArray::Literal> literals;
diff --git a/ets2panda/compiler/lowering/ets/exportAnonymousConst.cpp b/ets2panda/compiler/lowering/ets/exportAnonymousConst.cpp
index 5677874aeaac2326d5f017e1d7bc8303b75699b7..cd71e8dfb8bb1df3cf85d1219c3bbea1bae2012e 100644
--- a/ets2panda/compiler/lowering/ets/exportAnonymousConst.cpp
+++ b/ets2panda/compiler/lowering/ets/exportAnonymousConst.cpp
@@ -109,7 +109,7 @@ static void HandleExportDefaultInExportNamedDecl(public_lib::Context *const ctx,
     auto *exportNamedDeclaration = (*iterator)->AsExportNamedDeclaration();
     auto oldSpecifiers = exportNamedDeclaration->Specifiers();
     ArenaVector<ir::ExportSpecifier *> newSpecifiers(allocator->Adapter());
-    ArenaVector<ir::ExportNamedDeclaration *> exportDefaulNamedDeclarations(allocator->Adapter());
+    std::vector<ir::ExportNamedDeclaration *> exportDefaulNamedDeclarations {};
 
     for (auto *specifier : oldSpecifiers) {
         if (specifier->IsDefault()) {
diff --git a/ets2panda/compiler/lowering/ets/lambdaLowering.cpp b/ets2panda/compiler/lowering/ets/lambdaLowering.cpp
index 8399b8cc35b8a7f2caedc8146464af932c1cf953..ab85216b3465a4e67b5b1f984102558184907722 100644
--- a/ets2panda/compiler/lowering/ets/lambdaLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/lambdaLowering.cpp
@@ -132,7 +132,7 @@ static void ProcessTypeParameterProperties(checker::ETSTypeParameter *oldTypePar
 // NOTE (smartin): The two methods 'CreateNewTypeParamVectors' and 'SetConstraintTypeAndDefaultTypeForTypeParams'
 // contain very similar logic that can be found in 'CloneTypeParamsForClass'. Merge these later if possible
 static void FillNewTypeParamVectors(ThreadSafeArenaAllocator *allocator,
-                                    ArenaVector<checker::ETSTypeParameter *> &newTypeParams,
+                                    std::vector<checker::ETSTypeParameter *> &newTypeParams,
                                     ArenaVector<ir::TSTypeParameter *> &newTypeParamNodes,
                                     const checker::Signature *const lambdaSig,
                                     checker::Substitution *const substitution)
@@ -160,7 +160,7 @@ static void FillNewTypeParamVectors(ThreadSafeArenaAllocator *allocator,
 }
 
 static void SetConstraintTypeAndDefaultTypeForTypeParams(public_lib::Context *ctx,
-                                                         const ArenaVector<checker::ETSTypeParameter *> &newTypeParams,
+                                                         const std::vector<checker::ETSTypeParameter *> &newTypeParams,
                                                          const ArenaVector<ir::TSTypeParameter *> &newTypeParamNodes,
                                                          const checker::Signature *const lambdaSig,
                                                          const checker::Substitution *const substitution)
@@ -198,7 +198,7 @@ static ir::TSTypeParameterDeclaration *CloneTypeParamsForSignature(public_lib::C
     }
 
     auto *allocator = ctx->allocator;
-    auto newTypeParams = ArenaVector<checker::ETSTypeParameter *>(allocator->Adapter());
+    auto newTypeParams = std::vector<checker::ETSTypeParameter *> {};
     auto newTypeParamNodes = ArenaVector<ir::TSTypeParameter *>(allocator->Adapter());
 
     FillNewTypeParamVectors(allocator, newTypeParams, newTypeParamNodes, lambdaSig, lciInfo->substitution);
@@ -222,7 +222,7 @@ static std::pair<ir::TSTypeParameterDeclaration *, checker::Substitution> CloneT
     auto *allocator = ctx->allocator;
 
     auto *newScope = allocator->New<varbinder::LocalScope>(allocator, enclosingScope);
-    auto newTypeParams = ArenaVector<checker::ETSTypeParameter *>(allocator->Adapter());
+    auto newTypeParams = std::vector<checker::ETSTypeParameter *> {};
     auto newTypeParamNodes = ArenaVector<ir::TSTypeParameter *>(allocator->Adapter());
     auto substitution = checker::Substitution {};
 
@@ -1052,7 +1052,7 @@ static void CorrectTheTrueThisForExtensionLambda(public_lib::Context *ctx, ir::C
 {
     auto *checker = ctx->GetChecker()->AsETSChecker();
     auto *classScope = lambdaClass->Definition()->Scope();
-    ArenaVector<varbinder::Variable *> invokeFuncsOfLambda(ctx->Allocator()->Adapter());
+    std::vector<varbinder::Variable *> invokeFuncsOfLambda {};
     auto invokeName = checker->FunctionalInterfaceInvokeName(arity, hasRestParam);
     invokeFuncsOfLambda.emplace_back(
         classScope->FindLocal(compiler::Signatures::LAMBDA_OBJECT_INVOKE, varbinder::ResolveBindingOptions::METHODS));
diff --git a/ets2panda/compiler/lowering/ets/opAssignment.cpp b/ets2panda/compiler/lowering/ets/opAssignment.cpp
index 44b66ee3d2f22c0e38f59b168e86ef3e95d8f5ad..1f6fb02dc86014413a8c2d8514c4c6b31ce6758f 100644
--- a/ets2panda/compiler/lowering/ets/opAssignment.cpp
+++ b/ets2panda/compiler/lowering/ets/opAssignment.cpp
@@ -129,7 +129,7 @@ static std::string UpdateStatementToAccessPropertyOrElement(const ir::MemberExpr
     return statement;
 }
 
-static std::tuple<std::string, ArenaVector<ir::Expression *>> GenerateNestedMemberAccess(
+static std::tuple<std::string, std::vector<ir::Expression *>> GenerateNestedMemberAccess(
     ir::MemberExpression *expr, ArenaAllocator *const allocator, size_t counter = 1)
 {
     // Generate a formatString and a vector of expressions(same order as the format string)
@@ -138,7 +138,7 @@ static std::tuple<std::string, ArenaVector<ir::Expression *>> GenerateNestedMemb
     // If "[", then after the number there will be a "]".
     // Where N is the number of nested member accesses (N == newAssignmentExpressions.size())
     auto member = expr->Object();
-    ArenaVector<ir::Expression *> newAssignmentExpressions(allocator->Adapter());
+    std::vector<ir::Expression *> newAssignmentExpressions {};
     newAssignmentExpressions.push_back(expr->Property());
 
     while (member->IsMemberExpression()) {
@@ -165,7 +165,7 @@ static std::tuple<std::string, ArenaVector<ir::Expression *>> GenerateNestedMemb
     return {newAssignmentStatements, newAssignmentExpressions};
 }
 
-static std::tuple<std::string, ArenaVector<ir::Expression *>> GenerateStringForAssignment(
+static std::tuple<std::string, std::vector<ir::Expression *>> GenerateStringForAssignment(
     const lexer::TokenType opEqual, ir::MemberExpression *expr, ArenaAllocator *const allocator, size_t counter)
 {
     // Note: Handle "A `opAssign` B" to "A = (A `operation` B) as T"
@@ -181,7 +181,7 @@ static std::tuple<std::string, ArenaVector<ir::Expression *>> GenerateStringForA
     return {retStr, retVec};
 }
 
-static std::string GetCastString(checker::ETSChecker *checker, ir::Expression *expr, ArenaVector<ir::Expression *> &vec)
+static std::string GetCastString(checker::ETSChecker *checker, ir::Expression *expr, std::vector<ir::Expression *> &vec)
 {
     auto type = expr->TsType();
     if (type->IsETSObjectType() && type->AsETSObjectType()->IsBoxedPrimitive()) {
@@ -218,7 +218,7 @@ static ir::Expression *GenerateLoweredResultForLoweredAssignment(const lexer::To
     if (expr->Kind() == ir::MemberExpressionKind::ELEMENT_ACCESS && !expr->Property()->IsLiteral()) {
         // Note: support such a situation could be okay: `a[idx++] += someExpr`.
         // It should be lowered as: `let dummyIdx = (lower result of `idx++`); a[dummyIdx] = a[dummyIdx] + someExpr`;
-        ArenaVector<ir::Expression *> dummyIndexDeclExpression(allocator->Adapter());
+        std::vector<ir::Expression *> dummyIndexDeclExpression {};
         std::string dummyIndexDeclStr = "let @@I1 = @@E2;\n";
         auto dummyIndex = Gensym(allocator);
         dummyIndexDeclExpression.emplace_back(dummyIndex);
@@ -261,7 +261,7 @@ static ir::Expression *ConstructOpAssignmentResult(public_lib::Context *ctx, ir:
     if (left->IsIdentifier()) {
         std::string formatString =
             "@@I1 = (@@I2 " + std::string(lexer::TokenToString(CombinedOpToOp(opEqual))) + " (@@E3))";
-        ArenaVector<ir::Expression *> retVec(allocator->Adapter());
+        std::vector<ir::Expression *> retVec {};
         retVec.push_back(GetClone(allocator, left->AsIdentifier()));
         retVec.push_back(GetClone(allocator, left->AsIdentifier()));
         retVec.push_back(right);
diff --git a/ets2panda/compiler/lowering/ets/stringComparison.cpp b/ets2panda/compiler/lowering/ets/stringComparison.cpp
index 68d18c745e13857b8c481ae05cb54c014c1ffd4d..17b137db2798f512a3360d0eeec9c1e0407dba30 100644
--- a/ets2panda/compiler/lowering/ets/stringComparison.cpp
+++ b/ets2panda/compiler/lowering/ets/stringComparison.cpp
@@ -110,8 +110,7 @@ void StringComparisonLowering::ProcessBinaryExpression(ir::BinaryExpression *exp
 
 bool StringComparisonLowering::PerformForModule(public_lib::Context *ctx, parser::Program *program)
 {
-    checker::ETSChecker *checker = ctx->GetChecker()->AsETSChecker();
-    [[maybe_unused]] ArenaVector<ir::BinaryExpression *> foundNodes(checker->Allocator()->Adapter());
+    [[maybe_unused]] std::vector<ir::BinaryExpression *> foundNodes {};
     // CC-OFFNXT(G.FMT.14-CPP) project code style
     program->Ast()->IterateRecursively([&foundNodes, this](ir::AstNode *ast) -> ir::AstNode * {
         if (IsStringComparison(ast)) {
diff --git a/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.h b/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.h
index 4d785eb815ad18cfe20ad4c148a41226019eb372..2cacf9c98545ee229d1b851d158558326e530312 100644
--- a/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.h
+++ b/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.h
@@ -149,8 +149,7 @@ private:
             exportMap.erase(it);
         }
 
-        ArenaMap<util::StringView, std::pair<util::StringView, ir::AstNode const *>> newMap(
-            program_->Allocator()->Adapter());
+        std::map<util::StringView, std::pair<util::StringView, ir::AstNode const *>> newMap {};
         exportMap.insert({program_->SourceFilePath(), newMap});
     }
 
@@ -162,13 +161,12 @@ private:
         imExDecl_->exportDefaultName_ = exportDefaultNamePrev_;
     }
 
-    ArenaMap<util::StringView, std::pair<util::StringView, ir::AstNode const *>> SaveExportAliasMultimap()
+    std::map<util::StringView, std::pair<util::StringView, ir::AstNode const *>> SaveExportAliasMultimap()
     {
         auto &exportMap = imExDecl_->varbinder_->GetSelectiveExportAliasMultimap();
         const auto found = exportMap.find(program_->SourceFilePath());
         if (found == exportMap.end()) {
-            return ArenaMap<util::StringView, std::pair<util::StringView, ir::AstNode const *>>(
-                program_->Allocator()->Adapter());
+            return std::map<util::StringView, std::pair<util::StringView, ir::AstNode const *>>();
         }
         return found->second;
     }
@@ -180,7 +178,7 @@ private:
     std::map<util::StringView, lexer::SourcePosition> exportNameMapPrev_;
     std::set<util::StringView> exportedTypesPrev_;
     util::StringView exportDefaultNamePrev_;
-    ArenaMap<util::StringView, std::pair<util::StringView, ir::AstNode const *>> exportAliasMultimapPrev_;
+    std::map<util::StringView, std::pair<util::StringView, ir::AstNode const *>> exportAliasMultimapPrev_;
 };
 }  // namespace ark::es2panda::compiler
 
diff --git a/ets2panda/evaluate/debugInfoDeserialization/debugInfoDeserializer.h b/ets2panda/evaluate/debugInfoDeserialization/debugInfoDeserializer.h
index d2035a6d6d79c436158534a2b841586dd77cda8d..42ff7b834b104b1209d193124be5f54b46ca6545 100644
--- a/ets2panda/evaluate/debugInfoDeserialization/debugInfoDeserializer.h
+++ b/ets2panda/evaluate/debugInfoDeserialization/debugInfoDeserializer.h
@@ -83,7 +83,7 @@ private:
      * @returns declaration name of the first already created class in chain,
      * empty string if algorithm has reached BUILTIN_OBJECT.
      */
-    util::StringView CollectChainInfo(ArenaVector<ChainEntryInfo> &chainEntryList, util::StringView abcSuperName,
+    util::StringView CollectChainInfo(std::vector<ChainEntryInfo> &chainEntryList, util::StringView abcSuperName,
                                       FileDebugInfo *debugInfo);
 
     varbinder::Variable *CreateLocalVarDecl(ir::Identifier *ident, RegisterNumber regNumber,
diff --git a/ets2panda/evaluate/debugInfoDeserialization/inheritanceResolution.cpp b/ets2panda/evaluate/debugInfoDeserialization/inheritanceResolution.cpp
index 586bbb08f060fe3cbb19494ece3293966e7163ad..725ceffe7d3ef12672f7c7adb6b40989ab7586b5 100644
--- a/ets2panda/evaluate/debugInfoDeserialization/inheritanceResolution.cpp
+++ b/ets2panda/evaluate/debugInfoDeserialization/inheritanceResolution.cpp
@@ -108,7 +108,7 @@ ir::ETSTypeReference *DebugInfoDeserializer::ResolveInheritanceChainImpl(util::S
     auto *checker = debugInfoPlugin_.GetIrCheckHelper()->GetChecker();
 
     // List starting from the most derived to the base class.
-    ArenaVector<ChainEntryInfo> chainEntryList(checker->Allocator()->Adapter());
+    std::vector<ChainEntryInfo> chainEntryList {};
     auto alreadyCreatedSuperClassName = CollectChainInfo(chainEntryList, abcSuperName, debugInfo);
 
     ir::ETSTypeReference *superClass = nullptr;
@@ -136,7 +136,7 @@ ir::ETSTypeReference *DebugInfoDeserializer::ResolveInheritanceChainImpl(util::S
     return superClass;
 }
 
-util::StringView DebugInfoDeserializer::CollectChainInfo(ArenaVector<ChainEntryInfo> &chainEntryList,
+util::StringView DebugInfoDeserializer::CollectChainInfo(std::vector<ChainEntryInfo> &chainEntryList,
                                                          util::StringView abcSuperName, FileDebugInfo *debugInfo)
 {
     ES2PANDA_ASSERT(debugInfo != nullptr);
diff --git a/ets2panda/lsp/include/get_adjusted_location.h b/ets2panda/lsp/include/get_adjusted_location.h
index 7980e1c9f47a9e5b7290c3bdd77d34e4da60e736..a58a9a36b19de3d84f02f453fea16feb8a8d0f69 100644
--- a/ets2panda/lsp/include/get_adjusted_location.h
+++ b/ets2panda/lsp/include/get_adjusted_location.h
@@ -31,44 +31,44 @@ std::optional<ir::AstNode *> GetAdjustedLocation(ir::AstNode *node, bool forRena
 std::optional<ir::AstNode *> GetAdjustedLocationForClass(ir::AstNode *node, ArenaAllocator *allocator);
 std::optional<ir::AstNode *> GetAdjustedLocationForFunction(ir::AstNode *node, ArenaAllocator *allocator);
 std::optional<ir::AstNode *> GetAdjustedLocationForDeclaration(ir::AstNode *node, bool forRename,
-                                                               const ArenaVector<ir::AstNode *> &children,
+                                                               const std::vector<ir::AstNode *> &children,
                                                                ArenaAllocator *allocator);
 std::optional<ir::AstNode *> GetAdjustedLocationForImportDeclaration(ir::AstNode *node, bool forRename,
-                                                                     const ArenaVector<ir::AstNode *> &children);
+                                                                     const std::vector<ir::AstNode *> &children);
 std::optional<ir::AstNode *> GetAdjustedLocationForExportDeclaration(ir::AstNode *node, bool forRename,
-                                                                     const ArenaVector<ir::AstNode *> &children);
+                                                                     const std::vector<ir::AstNode *> &children);
 std::optional<ir::AstNode *> GetAdjustedLocationForHeritageClause(ir::AstNode *node);
 ir::AstNode *GetTouchingPropertyName(es2panda_Context *context, size_t pos);
 // Expression handlers
 std::optional<ir::AstNode *> HandleBasicExpressions(ir::AstNode *node, ir::AstNode *parent,
-                                                    const ArenaVector<ir::AstNode *> &parentChildren);
+                                                    const std::vector<ir::AstNode *> &parentChildren);
 std::optional<ir::AstNode *> HandleBinaryExpressions(ir::AstNode *node, ir::AstNode *parent,
-                                                     const ArenaVector<ir::AstNode *> &parentChildren);
+                                                     const std::vector<ir::AstNode *> &parentChildren);
 std::optional<ir::AstNode *> HandleForStatements(ir::AstNode *node, ir::AstNode *parent,
-                                                 const ArenaVector<ir::AstNode *> &parentChildren);
+                                                 const std::vector<ir::AstNode *> &parentChildren);
 std::optional<ir::AstNode *> HandleNonRenameExpressions(ir::AstNode *node, ir::AstNode *parent,
-                                                        const ArenaVector<ir::AstNode *> &parentChildren,
+                                                        const std::vector<ir::AstNode *> &parentChildren,
                                                         bool forRename);
 
 // Node type handlers
 inline std::optional<ir::AstNode *> HandleTSAsExpression(ir::AstNode *node, ir::AstNode *parent,
-                                                         const ArenaVector<ir::AstNode *> &parentChildren);
+                                                         const std::vector<ir::AstNode *> &parentChildren);
 inline std::optional<ir::AstNode *> HandleImportDeclaration(ir::AstNode *node, ir::AstNode *parent,
-                                                            const ArenaVector<ir::AstNode *> &parentChildren,
+                                                            const std::vector<ir::AstNode *> &parentChildren,
                                                             bool forRename);
 inline std::optional<ir::AstNode *> HandleTSImportType(ir::AstNode *node, ir::AstNode *parent,
-                                                       const ArenaVector<ir::AstNode *> &parentChildren, bool forRename,
+                                                       const std::vector<ir::AstNode *> &parentChildren, bool forRename,
                                                        ArenaAllocator *allocator);
 
 // Node finding functions
-ir::AstNode *FindFirstIdentifier(ir::AstNode *node, bool skipModifiers, const ArenaVector<ir::AstNode *> &children);
-ir::AstNode *FindFirstExpression(ir::AstNode *node, const ArenaVector<ir::AstNode *> &children);
+ir::AstNode *FindFirstIdentifier(ir::AstNode *node, bool skipModifiers, const std::vector<ir::AstNode *> &children);
+ir::AstNode *FindFirstExpression(ir::AstNode *node, const std::vector<ir::AstNode *> &children);
 ir::AstNode *FindFirstExpressionAfter(ir::AstNode *node, ir::AstNode *after,
-                                      const ArenaVector<ir::AstNode *> &children);
-ir::AstNode *FindNodeOfType(ir::AstNode *node, ir::AstNodeType type, const ArenaVector<ir::AstNode *> &children);
-ir::AstNode *FindTypeReference(ir::AstNode *node, const ArenaVector<ir::AstNode *> &children);
-ir::AstNode *FindTypeParameter(ir::AstNode *node, const ArenaVector<ir::AstNode *> &children);
-ir::AstNode *FindArrayType(ir::AstNode *node, const ArenaVector<ir::AstNode *> &children);
+                                      const std::vector<ir::AstNode *> &children);
+ir::AstNode *FindNodeOfType(ir::AstNode *node, ir::AstNodeType type, const std::vector<ir::AstNode *> &children);
+ir::AstNode *FindTypeReference(ir::AstNode *node, const std::vector<ir::AstNode *> &children);
+ir::AstNode *FindTypeParameter(ir::AstNode *node, const std::vector<ir::AstNode *> &children);
+ir::AstNode *FindArrayType(ir::AstNode *node, const std::vector<ir::AstNode *> &children);
 
 // Node property checkers
 bool IsModifier(const ir::AstNode *node);
@@ -80,7 +80,7 @@ bool IsDeclarationOrModifier(ir::AstNode *node, ir::AstNode *parent, bool forRen
 ir::AstNode *SkipOuterExpressions(ir::AstNode *node);
 
 // Child node functions
-ArenaVector<ir::AstNode *> GetChildren(ir::AstNode *node, ArenaAllocator *allocator);
+std::vector<ir::AstNode *> GetChildren(ir::AstNode *node, ArenaAllocator *allocator);
 
 }  // namespace ark::es2panda::lsp
 
diff --git a/ets2panda/lsp/include/internal_api.h b/ets2panda/lsp/include/internal_api.h
index 84eebcc952f3b6e61317ca5393a11e921d0e2e7c..31d9b78d4246ce55e674c1f6779bbe792607af31 100644
--- a/ets2panda/lsp/include/internal_api.h
+++ b/ets2panda/lsp/include/internal_api.h
@@ -125,7 +125,7 @@ DocumentHighlights GetDocumentHighlightsImpl(es2panda_Context *context, size_t p
 void GetReferenceLocationAtPositionImpl(FileNodeInfo fileNodeInfo, es2panda_Context *referenceFileContext,
                                         ReferenceLocationList *list);
 void RemoveFromFiles(std::vector<std::string> &files, const std::vector<std::string> &autoGenerateFolders);
-ir::AstNode *FindRightToken(const size_t pos, const ArenaVector<ir::AstNode *> &nodes);
+ir::AstNode *FindRightToken(const size_t pos, const std::vector<ir::AstNode *> &nodes);
 std::string GetOwnerId(ir::AstNode *node);
 std::string GetIdentifierName(ir::AstNode *node);
 bool NodeHasTokens(const ir::AstNode *node);
diff --git a/ets2panda/lsp/src/get_adjusted_location.cpp b/ets2panda/lsp/src/get_adjusted_location.cpp
index 4bb625026e40f09073692956c035918f20c3ede2..7b8ca50c30e102436b39b60b7c3007e5c57c21e6 100644
--- a/ets2panda/lsp/src/get_adjusted_location.cpp
+++ b/ets2panda/lsp/src/get_adjusted_location.cpp
@@ -30,9 +30,9 @@ using ark::es2panda::ir::ModifierFlags;
 
 namespace ark::es2panda::lsp {
 
-ArenaVector<AstNode *> GetChildren(AstNode *node, ArenaAllocator *allocator)
+std::vector<AstNode *> GetChildren(AstNode *node, [[maybe_unused]] ArenaAllocator *allocator)
 {
-    ArenaVector<AstNode *> children(allocator->Adapter());
+    std::vector<AstNode *> children {};
 
     if (node == nullptr) {
         return children;
@@ -92,7 +92,7 @@ bool IsDeclarationOrModifier(AstNode *node, AstNode *parent, bool forRename)
 }
 
 std::optional<AstNode *> HandleTSAsExpression(AstNode *node, AstNode *parent,
-                                              const ArenaVector<AstNode *> &parentChildren)
+                                              const std::vector<AstNode *> &parentChildren)
 {
     if (!node->IsTSAsExpression()) {
         return std::nullopt;
@@ -114,7 +114,7 @@ std::optional<AstNode *> HandleTSAsExpression(AstNode *node, AstNode *parent,
 }
 
 std::optional<AstNode *> HandleTSImportType(AstNode *node, AstNode *parent,
-                                            const ArenaVector<AstNode *> &parentChildren, bool forRename,
+                                            const std::vector<AstNode *> &parentChildren, bool forRename,
                                             ArenaAllocator *allocator)
 {
     if (!node->IsTSImportType()) {
@@ -133,7 +133,7 @@ std::optional<AstNode *> HandleTSImportType(AstNode *node, AstNode *parent,
 }
 
 std::optional<AstNode *> HandleImportDeclaration(AstNode *node, AstNode *parent,
-                                                 const ArenaVector<AstNode *> &parentChildren, bool forRename)
+                                                 const std::vector<AstNode *> &parentChildren, bool forRename)
 {
     if (!node->IsImportDeclaration() || !parent->IsImportDeclaration()) {
         return std::nullopt;
@@ -142,7 +142,7 @@ std::optional<AstNode *> HandleImportDeclaration(AstNode *node, AstNode *parent,
 }
 
 inline std::optional<AstNode *> HandleExportAllDeclaration(AstNode *node, AstNode *parent, bool forRename,
-                                                           const ArenaVector<AstNode *> &parentChildren)
+                                                           const std::vector<AstNode *> &parentChildren)
 {
     if (!node->IsExportAllDeclaration() || !parent->IsExportAllDeclaration()) {
         return std::nullopt;
@@ -159,7 +159,7 @@ inline std::optional<AstNode *> HandleTSClassImplements(AstNode *node, AstNode *
 }
 
 inline std::optional<AstNode *> HandleTSInferType(AstNode *node, AstNode *parent,
-                                                  const ArenaVector<AstNode *> &parentChildren)
+                                                  const std::vector<AstNode *> &parentChildren)
 {
     if (!node->IsTSInferType() || !parent->IsTSInferType()) {
         return std::nullopt;
@@ -171,7 +171,7 @@ inline std::optional<AstNode *> HandleTSInferType(AstNode *node, AstNode *parent
 }
 
 inline std::optional<AstNode *> HandleTSTypeParameterDeclaration(AstNode *parent,
-                                                                 const ArenaVector<AstNode *> &parentChildren)
+                                                                 const std::vector<AstNode *> &parentChildren)
 {
     if (!parent->IsTSTypeParameterDeclaration() || !parent->Parent()->IsTSTypeParameterDeclaration()) {
         return std::nullopt;
@@ -179,7 +179,7 @@ inline std::optional<AstNode *> HandleTSTypeParameterDeclaration(AstNode *parent
     return std::make_optional(FindFirstIdentifier(parent, false, parentChildren));
 }
 
-std::optional<AstNode *> HandleTSTypeOperator(AstNode *parent, const ArenaVector<AstNode *> &parentChildren)
+std::optional<AstNode *> HandleTSTypeOperator(AstNode *parent, const std::vector<AstNode *> &parentChildren)
 {
     if (!parent->IsTSTypeOperator()) {
         return std::nullopt;
@@ -196,7 +196,7 @@ std::optional<AstNode *> HandleTSTypeOperator(AstNode *parent, const ArenaVector
 }
 
 std::optional<AstNode *> HandleBasicExpressions(AstNode *node, AstNode *parent,
-                                                const ArenaVector<AstNode *> &parentChildren)
+                                                const std::vector<AstNode *> &parentChildren)
 {
     if ((node->IsNewExpression() && parent->IsNewExpression()) ||
         (node->IsTSVoidKeyword() && parent->IsTSVoidKeyword()) ||
@@ -211,7 +211,7 @@ std::optional<AstNode *> HandleBasicExpressions(AstNode *node, AstNode *parent,
 }
 
 std::optional<AstNode *> HandleBinaryExpressions(AstNode *node, AstNode *parent,
-                                                 const ArenaVector<AstNode *> &parentChildren)
+                                                 const std::vector<AstNode *> &parentChildren)
 {
     if (!parent->IsBinaryExpression()) {
         return std::nullopt;
@@ -227,7 +227,7 @@ std::optional<AstNode *> HandleBinaryExpressions(AstNode *node, AstNode *parent,
 }
 
 std::optional<AstNode *> HandleForStatements(AstNode *node, AstNode *parent,
-                                             const ArenaVector<AstNode *> &parentChildren)
+                                             const std::vector<AstNode *> &parentChildren)
 {
     if ((node->IsForInStatement() && parent->IsForInStatement()) ||
         (node->IsForOfStatement() && parent->IsForOfStatement())) {
@@ -239,7 +239,7 @@ std::optional<AstNode *> HandleForStatements(AstNode *node, AstNode *parent,
 }
 
 std::optional<AstNode *> HandleNonRenameExpressions(AstNode *node, AstNode *parent,
-                                                    const ArenaVector<AstNode *> &parentChildren, bool forRename)
+                                                    const std::vector<AstNode *> &parentChildren, bool forRename)
 {
     if (forRename) {
         return std::nullopt;
@@ -298,7 +298,7 @@ std::optional<AstNode *> HandleDefaultExport(AstNode *node, ArenaAllocator *allo
     return std::nullopt;
 }
 
-inline std::optional<AstNode *> HandleVariableDeclaration(AstNode *parent, const ArenaVector<AstNode *> &parentChildren)
+inline std::optional<AstNode *> HandleVariableDeclaration(AstNode *parent, const std::vector<AstNode *> &parentChildren)
 {
     if (parent->IsVariableDeclaration()) {
         if (auto *identifier = FindFirstIdentifier(parent, false, parentChildren)) {
@@ -309,7 +309,7 @@ inline std::optional<AstNode *> HandleVariableDeclaration(AstNode *parent, const
 }
 
 inline std::optional<AstNode *> HandleExternalModuleReference(AstNode *parent,
-                                                              const ArenaVector<AstNode *> &parentChildren)
+                                                              const std::vector<AstNode *> &parentChildren)
 {
     if (parent->IsTSExternalModuleReference()) {
         if (auto *expr = FindFirstExpression(parent, parentChildren)) {
@@ -319,7 +319,7 @@ inline std::optional<AstNode *> HandleExternalModuleReference(AstNode *parent,
     return std::nullopt;
 }
 
-inline std::optional<AstNode *> HandleModuleSpecifier(AstNode *parent, const ArenaVector<AstNode *> &parentChildren)
+inline std::optional<AstNode *> HandleModuleSpecifier(AstNode *parent, const std::vector<AstNode *> &parentChildren)
 {
     if ((parent->IsImportDeclaration() || parent->IsExportAllDeclaration())) {
         if (auto *moduleSpecifier = FindNodeOfType(parent, AstNodeType::STRING_LITERAL, parentChildren)) {
@@ -330,7 +330,7 @@ inline std::optional<AstNode *> HandleModuleSpecifier(AstNode *parent, const Are
 }
 
 std::optional<AstNode *> HandleExpressionAndTypes(AstNode *node, AstNode *parent,
-                                                  const ArenaVector<AstNode *> &parentChildren, bool forRename,
+                                                  const std::vector<AstNode *> &parentChildren, bool forRename,
                                                   ArenaAllocator *allocator)
 {
     // Expression handlers
@@ -358,7 +358,7 @@ std::optional<AstNode *> HandleExpressionAndTypes(AstNode *node, AstNode *parent
 }
 
 std::optional<AstNode *> HandleModulesAndExports(AstNode *node, AstNode *parent,
-                                                 const ArenaVector<AstNode *> &parentChildren, bool forRename,
+                                                 const std::vector<AstNode *> &parentChildren, bool forRename,
                                                  ArenaAllocator *allocator)
 {
     // Import/Export handlers
@@ -392,7 +392,7 @@ std::optional<AstNode *> GetAdjustedLocation(AstNode *node, bool forRename, Aren
         return std::make_optional(node);
     }
 
-    ArenaVector<AstNode *> parentChildren = GetChildren(parent, allocator);
+    std::vector<AstNode *> parentChildren = GetChildren(parent, allocator);
 
     // Declaration handlers
     if (IsDeclarationOrModifier(node, parent, forRename)) {
@@ -419,7 +419,7 @@ std::optional<AstNode *> GetAdjustedLocation(AstNode *node, bool forRename, Aren
 }
 
 std::optional<AstNode *> GetAdjustedLocationForDeclaration(AstNode *node, bool forRename,
-                                                           const ArenaVector<AstNode *> &children,
+                                                           const std::vector<AstNode *> &children,
                                                            ArenaAllocator *allocator)
 {
     if (!forRename) {
@@ -444,7 +444,7 @@ std::optional<AstNode *> GetAdjustedLocationForDeclaration(AstNode *node, bool f
 }
 
 std::optional<AstNode *> GetAdjustedLocationForImportDeclaration(AstNode *node, bool forRename,
-                                                                 const ArenaVector<AstNode *> &children)
+                                                                 const std::vector<AstNode *> &children)
 {
     if (!node->IsImportDeclaration()) {
         return std::nullopt;
@@ -469,7 +469,7 @@ std::optional<AstNode *> GetAdjustedLocationForImportDeclaration(AstNode *node,
 }
 
 std::optional<AstNode *> GetAdjustedLocationForExportDeclaration(AstNode *node, bool forRename,
-                                                                 const ArenaVector<AstNode *> &children)
+                                                                 const std::vector<AstNode *> &children)
 {
     if (!node->IsExportAllDeclaration()) {
         return std::nullopt;
@@ -625,7 +625,7 @@ bool CanHaveModifiers(const AstNode &node)
     }
 }
 
-AstNode *FindFirstIdentifier(AstNode *node, bool skipModifiers, const ArenaVector<AstNode *> &children)
+AstNode *FindFirstIdentifier(AstNode *node, bool skipModifiers, const std::vector<AstNode *> &children)
 {
     if (node->IsIdentifier() && (!skipModifiers || !IsModifier(node))) {
         return node;
@@ -638,7 +638,7 @@ AstNode *FindFirstIdentifier(AstNode *node, bool skipModifiers, const ArenaVecto
     return nullptr;
 }
 
-AstNode *FindFirstExpression(AstNode *node, const ArenaVector<AstNode *> &children)
+AstNode *FindFirstExpression(AstNode *node, const std::vector<AstNode *> &children)
 {
     if (node->IsExpression()) {
         return node;
@@ -651,7 +651,7 @@ AstNode *FindFirstExpression(AstNode *node, const ArenaVector<AstNode *> &childr
     return nullptr;
 }
 
-AstNode *FindFirstExpressionAfter(AstNode *node, AstNode *after, const ArenaVector<AstNode *> &children)
+AstNode *FindFirstExpressionAfter(AstNode *node, AstNode *after, const std::vector<AstNode *> &children)
 {
     if (node->IsExpression() && node != after) {
         return node;
@@ -669,7 +669,7 @@ AstNode *FindFirstExpressionAfter(AstNode *node, AstNode *after, const ArenaVect
     return nullptr;
 }
 
-AstNode *FindNodeOfType(AstNode *node, AstNodeType type, const ArenaVector<AstNode *> &children)
+AstNode *FindNodeOfType(AstNode *node, AstNodeType type, const std::vector<AstNode *> &children)
 {
     if (node->Type() == type) {
         return node;
@@ -682,7 +682,7 @@ AstNode *FindNodeOfType(AstNode *node, AstNodeType type, const ArenaVector<AstNo
     return nullptr;
 }
 
-AstNode *FindTypeReference(AstNode *node, const ArenaVector<AstNode *> &children)
+AstNode *FindTypeReference(AstNode *node, const std::vector<AstNode *> &children)
 {
     if (node != nullptr && node->IsTSTypeReference()) {
         return node;
@@ -695,7 +695,7 @@ AstNode *FindTypeReference(AstNode *node, const ArenaVector<AstNode *> &children
     return nullptr;
 }
 
-AstNode *FindTypeParameter(AstNode *node, const ArenaVector<AstNode *> &children)
+AstNode *FindTypeParameter(AstNode *node, const std::vector<AstNode *> &children)
 {
     if (node->IsTSTypeParameterDeclaration()) {
         return node;
@@ -713,7 +713,7 @@ AstNode *FindTypeParameter(AstNode *node, const ArenaVector<AstNode *> &children
     return nullptr;
 }
 
-AstNode *FindArrayType(AstNode *node, const ArenaVector<AstNode *> &children)
+AstNode *FindArrayType(AstNode *node, const std::vector<AstNode *> &children)
 {
     if (node->IsTSArrayType()) {
         return node;
diff --git a/ets2panda/lsp/src/internal_api.cpp b/ets2panda/lsp/src/internal_api.cpp
index 3162e6643295cb7fc310239fb1f99547801c46bf..7b71c3a5ce49a8a1cfce72968bd2c563cba4e13c 100644
--- a/ets2panda/lsp/src/internal_api.cpp
+++ b/ets2panda/lsp/src/internal_api.cpp
@@ -211,7 +211,7 @@ bool NodeHasTokens(const ir::AstNode *node)
     return node->Start().index != node->End().index;
 }
 
-ir::AstNode *FindRightmostChildNodeWithTokens(const ArenaVector<ir::AstNode *> &nodes, int exclusiveStartPosition)
+ir::AstNode *FindRightmostChildNodeWithTokens(const std::vector<ir::AstNode *> &nodes, int exclusiveStartPosition)
 {
     for (int i = exclusiveStartPosition - 1; i >= 0; --i) {
         if (NodeHasTokens(nodes[i])) {
@@ -221,9 +221,9 @@ ir::AstNode *FindRightmostChildNodeWithTokens(const ArenaVector<ir::AstNode *> &
     return nullptr;
 }
 
-ArenaVector<ir::AstNode *> GetChildren(const ir::AstNode *node, ArenaAllocator *allocator)
+std::vector<ir::AstNode *> GetChildren(const ir::AstNode *node, [[maybe_unused]] ArenaAllocator *allocator)
 {
-    ArenaVector<ir::AstNode *> children(allocator->Adapter());
+    std::vector<ir::AstNode *> children {};
     if (node->Type() == ir::AstNodeType::ETS_MODULE) {
         // ETS_MODULE is the root node, need to get the definition of global class
         auto globalClass =
@@ -250,7 +250,7 @@ ir::AstNode *FindRightmostToken(const ir::AstNode *node, ArenaAllocator *allocat
     return FindRightmostToken(candidate, allocator);
 }
 
-ir::AstNode *FindNodeBeforePosition(const ArenaVector<ir::AstNode *> &children, size_t pos)
+ir::AstNode *FindNodeBeforePosition(const std::vector<ir::AstNode *> &children, size_t pos)
 {
     if (children.empty()) {
         return nullptr;
@@ -338,7 +338,7 @@ std::string GetCurrentTokenValueImpl(es2panda_Context *context, size_t position)
     return node != nullptr ? ReplaceQuotation(program->SourceCode().Substr(node->Start().index, position)) : "";
 }
 
-ir::AstNode *FindLeftToken(const size_t pos, const ArenaVector<ir::AstNode *> &nodes)
+ir::AstNode *FindLeftToken(const size_t pos, const std::vector<ir::AstNode *> &nodes)
 {
     int left = 0;
     int right = nodes.size() - 1;
@@ -355,7 +355,7 @@ ir::AstNode *FindLeftToken(const size_t pos, const ArenaVector<ir::AstNode *> &n
     return result;
 }
 
-ir::AstNode *FindRightToken(const size_t pos, const ArenaVector<ir::AstNode *> &nodes)
+ir::AstNode *FindRightToken(const size_t pos, const std::vector<ir::AstNode *> &nodes)
 {
     int left = 0;
     int right = nodes.size() - 1;
diff --git a/ets2panda/lsp/src/services/services.cpp b/ets2panda/lsp/src/services/services.cpp
index 0180adfcbde398357fc324d6ec5e95f2ac2fc9d9..af9be9a916c505040b9b1f148e260af61456be15 100644
--- a/ets2panda/lsp/src/services/services.cpp
+++ b/ets2panda/lsp/src/services/services.cpp
@@ -35,7 +35,7 @@ std::vector<Location> GetImplementationLocationAtPosition(es2panda_Context *cont
     // So this section should be updated after the implementation of vector returning
     // function.
 
-    auto implementationList = ArenaVector<ir::AstNode *>(ctx->allocator->Adapter());
+    auto implementationList = std::vector<ir::AstNode *> {};
     auto declInfo = GetDefinitionAtPositionImpl(context, (size_t)position);
     auto implementation = declInfo.first;
     if (implementation != nullptr && IsValidImplementation(implementation)) {
diff --git a/ets2panda/parser/ETSFormattedParser.cpp b/ets2panda/parser/ETSFormattedParser.cpp
index b999b9a7bf24de8f8993f6da689f07514d89d84a..cf918170c30d5cf9e8f1276a5066a60cfe14f2d7 100644
--- a/ets2panda/parser/ETSFormattedParser.cpp
+++ b/ets2panda/parser/ETSFormattedParser.cpp
@@ -323,6 +323,18 @@ ir::Expression *ETSParser::CreateFormattedExpression(std::string_view const sour
     return CreateFormattedExpression(sourceCode, insertingNodes);
 }
 
+ir::Expression *ETSParser::CreateFormattedExpression(std::string_view const sourceCode,
+                                                     std::vector<ir::Expression *> &args)
+{
+    std::vector<ir::AstNode *> insertingNodes {};
+    insertingNodes.reserve(args.size());
+    for (auto it : args) {
+        ProcessFormattedArg(insertingNodes, it);
+    }
+
+    return CreateFormattedExpression(sourceCode, insertingNodes);
+}
+
 ir::Statement *ETSParser::CreateFormattedStatement(std::string_view const sourceCode,
                                                    std::vector<ir::AstNode *> &insertingNodes)
 {
diff --git a/ets2panda/parser/ETSparser.cpp b/ets2panda/parser/ETSparser.cpp
index e4b25915ea843bfd0b9febf3a5945ebebd39ad08..50949550b22063a8d5c3f625499cc5a567134fb3 100644
--- a/ets2panda/parser/ETSparser.cpp
+++ b/ets2panda/parser/ETSparser.cpp
@@ -284,7 +284,7 @@ ArenaVector<ir::ETSImportDeclaration *> ETSParser::ParseDefaultSources(std::stri
 }
 
 void ETSParser::AddDirectImportsToDirectExternalSources(
-    const ArenaVector<util::StringView> &directImportsFromMainSource, parser::Program *const newProg) const
+    const std::vector<util::StringView> &directImportsFromMainSource, parser::Program *const newProg) const
 {
     if (std::find_if(directImportsFromMainSource.begin(), directImportsFromMainSource.end(),
                      [newProg](const util::StringView &sv) { return sv == newProg->AbsoluteName(); }) ==
@@ -306,7 +306,7 @@ void ETSParser::AddDirectImportsToDirectExternalSources(
 }
 
 void ETSParser::ParseParseListElement(const util::ImportPathManager::ParseInfo &parseListElem, util::UString *extSrc,
-                                      const ArenaVector<util::StringView> &directImportsFromMainSource,
+                                      const std::vector<util::StringView> &directImportsFromMainSource,
                                       std::vector<Program *> *programs)
 {
     const auto &importData = parseListElem.importData;
@@ -386,7 +386,7 @@ bool ETSParser::TryMergeFromCache(size_t idx, ArenaVector<util::ImportPathManage
 // the file. But when the same file is also added with an explicit import declaration, then we need to re-parse it,
 // and throw the syntax error.
 std::vector<Program *> ETSParser::SearchForNotParsed(ArenaVector<util::ImportPathManager::ParseInfo> &parseList,
-                                                     ArenaVector<util::StringView> &directImportsFromMainSource)
+                                                     std::vector<util::StringView> &directImportsFromMainSource)
 {
     std::vector<Program *> programs;
     auto notParsedElement =
@@ -447,7 +447,7 @@ std::vector<Program *> ETSParser::SearchForNotParsed(ArenaVector<util::ImportPat
 std::vector<Program *> ETSParser::ParseSources(bool firstSource)
 {
     auto &parseList = importPathManager_->ParseList();
-    ArenaVector<util::StringView> directImportsFromMainSource(Allocator()->Adapter());
+    std::vector<util::StringView> directImportsFromMainSource {};
     if (firstSource) {
         // NOLINTNEXTLINE(modernize-loop-convert)
         for (size_t idx = 0; idx < parseList.size(); idx++) {
diff --git a/ets2panda/parser/ETSparser.h b/ets2panda/parser/ETSparser.h
index 66ddcc044e8e2c478bf790a9923d043e37cef6ec..f1d3327ea3974afecd5906bae666d369230e2008 100644
--- a/ets2panda/parser/ETSparser.h
+++ b/ets2panda/parser/ETSparser.h
@@ -68,8 +68,7 @@ public:
     [[nodiscard]] bool IsETSParser() const noexcept override;
 
     [[nodiscard]] bool IsValidIdentifierName(const lexer::Token &token) const noexcept override;
-
-    void AddDirectImportsToDirectExternalSources(const ArenaVector<util::StringView> &directImportsFromMainSource,
+    void AddDirectImportsToDirectExternalSources(const std::vector<util::StringView> &directImportsFromMainSource,
                                                  parser::Program *newProg) const;
     bool CheckDupAndReplace(Program *&oldProg, Program *newProg) const;
     ArenaVector<ir::ETSImportDeclaration *> ParseDefaultSources(std::string_view srcFile, std::string_view importSrc);
@@ -98,6 +97,7 @@ public:
     ir::Expression *CreateFormattedExpression(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes);
 
     ir::Expression *CreateFormattedExpression(std::string_view const sourceCode, ArenaVector<ir::Expression *> &args);
+    ir::Expression *CreateFormattedExpression(std::string_view const sourceCode, std::vector<ir::Expression *> &args);
     ir::Statement *CreateFormattedStatement(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes);
     ArenaVector<ir::Statement *> CreateStatements(std::string_view sourceCode);
     ArenaVector<ir::Statement *> CreateFormattedStatements(std::string_view sourceCode,
@@ -194,7 +194,7 @@ private:
     void ParseUserSources(std::vector<std::string> userParths);
     ArenaVector<ir::Statement *> ParseTopLevelDeclaration();
     void ParseParseListElement(const util::ImportPathManager::ParseInfo &parseListElem, util::UString *extSrc,
-                               const ArenaVector<util::StringView> &directImportsFromMainSource,
+                               const std::vector<util::StringView> &directImportsFromMainSource,
                                std::vector<Program *> *programs);
     bool IsDefaultImport();
     void ParseNamedSpecifiesDefaultImport(ArenaVector<ir::ImportDefaultSpecifier *> *resultDefault,
@@ -211,7 +211,7 @@ private:
                                                 ir::ImportKinds importKind);
     bool TryMergeFromCache(size_t idx, ArenaVector<util::ImportPathManager::ParseInfo> &parseList);
     std::vector<Program *> SearchForNotParsed(ArenaVector<util::ImportPathManager::ParseInfo> &parseList,
-                                              ArenaVector<util::StringView> &directImportsFromMainSource);
+                                              std::vector<util::StringView> &directImportsFromMainSource);
     parser::Program *ParseSource(const SourceFile &sourceFile);
     ir::ETSModule *ParseETSGlobalScript(lexer::SourcePosition startLoc, ArenaVector<ir::Statement *> &statements);
     void ParseFileHeaderFlag(lexer::SourcePosition startLoc, ArenaVector<ir::Statement *> *statements);
diff --git a/ets2panda/parser/ETSparserAnnotations.cpp b/ets2panda/parser/ETSparserAnnotations.cpp
index e294a8573baf600112275eb0ac90ec63b0e3fa81..6bbd8f5b47fe40f49c230b928f72b316ced87bf0 100644
--- a/ets2panda/parser/ETSparserAnnotations.cpp
+++ b/ets2panda/parser/ETSparserAnnotations.cpp
@@ -438,7 +438,7 @@ ir::AnnotationUsage *ETSParser::ParseAnnotationUsage()
 
 bool ETSParser::TryParseAnnotations()
 {
-    ArenaVector<ir::AnnotationUsage *> annotations(Allocator()->Adapter());
+    std::vector<ir::AnnotationUsage *> annotations {};
 
     while (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_AT) {
         Lexer()->NextToken();
diff --git a/ets2panda/varbinder/ETSBinder.cpp b/ets2panda/varbinder/ETSBinder.cpp
index 29652fc113745c590cac6c57fce26e109b7681c6..1c8e9884ed77dad26ba52926344d75695c43354b 100644
--- a/ets2panda/varbinder/ETSBinder.cpp
+++ b/ets2panda/varbinder/ETSBinder.cpp
@@ -215,7 +215,7 @@ bool ETSBinder::AddSelectiveExportAlias(parser::ETSParser *parser, util::StringV
         return inserted;
     }
 
-    ArenaMap<util::StringView, std::pair<util::StringView, ir::AstNode const *>> map(Allocator()->Adapter());
+    std::map<util::StringView, std::pair<util::StringView, ir::AstNode const *>> map;
     bool insertResult = map.insert({key, std::make_pair(value, decl)}).second;
     selectiveExportAliasMultimap_.insert({path, map});
     return insertResult;
diff --git a/ets2panda/varbinder/ETSBinder.h b/ets2panda/varbinder/ETSBinder.h
index 025f4c30d9c9186f5bf8afde56c5bced090d1890..352a7258f63ab18daea89da61b24fcdf1d395bb4 100644
--- a/ets2panda/varbinder/ETSBinder.h
+++ b/ets2panda/varbinder/ETSBinder.h
@@ -44,8 +44,8 @@ class ETSNewClassInstanceExpression;
 }  // namespace ark::es2panda::ir
 
 namespace ark::es2panda::varbinder {
-using AliasesByExportedNames = ArenaMap<util::StringView, std::pair<util::StringView, ir::AstNode const *>>;
-using ModulesToExportedNamesWithAliases = ArenaMap<util::StringView, AliasesByExportedNames>;
+using AliasesByExportedNames = std::map<util::StringView, std::pair<util::StringView, ir::AstNode const *>>;
+using ModulesToExportedNamesWithAliases = std::map<util::StringView, AliasesByExportedNames>;
 
 struct DynamicImportData {
     const ir::ETSImportDeclaration *import;
@@ -66,7 +66,7 @@ public:
           dynamicImports_(Allocator()->Adapter()),
           reExportImports_(Allocator()->Adapter()),
           reexportedNames_(Allocator()->Adapter()),
-          selectiveExportAliasMultimap_(Allocator()->Adapter())
+          selectiveExportAliasMultimap_()
     {
         InitImplicitThisParam();
     }