From 89c16a164da287a1f8012445b6c4fa77e4876c7b Mon Sep 17 00:00:00 2001
From: luobohua <bohualiu@huawei.com>
Date: Fri, 15 Aug 2025 12:04:00 +0800
Subject: [PATCH] ArenaVector optimization v1.0: simple opt

Issue: https://gitee.com/openharmony/arkcompiler_ets_frontend/issues/ICQ7OP
Change-Id: I03e495c4592d36be3ae951c222faba02f9295a15
Signed-off-by: luobohua <bohualiu@huawei.com>
---
 ets2panda/checker/ETSAnalyzer.cpp             | 10 ++--
 ets2panda/checker/TSchecker.h                 | 10 ++--
 ets2panda/checker/ets/function.cpp            |  4 +-
 ets2panda/checker/ets/typeCheckingHelpers.cpp |  2 +-
 ets2panda/checker/ts/function.cpp             |  4 +-
 ets2panda/checker/ts/object.cpp               | 16 +++---
 ets2panda/compiler/core/ETSCompiler.cpp       |  2 +-
 ets2panda/compiler/core/ETSGen.h              |  1 -
 ets2panda/compiler/core/ETSemitter.cpp        |  2 +-
 .../lowering/ets/exportAnonymousConst.cpp     |  2 +-
 .../compiler/lowering/ets/lambdaLowering.cpp  | 10 ++--
 .../compiler/lowering/ets/opAssignment.cpp    | 12 ++---
 .../lowering/ets/stringComparison.cpp         |  3 +-
 .../debugInfoDeserializer.h                   |  2 +-
 .../inheritanceResolution.cpp                 |  4 +-
 ets2panda/lsp/include/get_adjusted_location.h | 22 ++++-----
 ets2panda/lsp/include/internal_api.h          |  2 +-
 ets2panda/lsp/src/get_adjusted_location.cpp   | 49 ++++++++++---------
 ets2panda/lsp/src/internal_api.cpp            | 12 ++---
 ets2panda/lsp/src/services/services.cpp       |  2 +-
 ets2panda/parser/ETSFormattedParser.cpp       | 12 +++++
 ets2panda/parser/ETSparser.cpp                |  8 +--
 ets2panda/parser/ETSparser.h                  |  8 +--
 ets2panda/parser/ETSparserAnnotations.cpp     |  2 +-
 24 files changed, 106 insertions(+), 95 deletions(-)

diff --git a/ets2panda/checker/ETSAnalyzer.cpp b/ets2panda/checker/ETSAnalyzer.cpp
index 4498536bb1..4a7cb30c38 100644
--- a/ets2panda/checker/ETSAnalyzer.cpp
+++ b/ets2panda/checker/ETSAnalyzer.cpp
@@ -766,7 +766,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);
 
@@ -800,9 +800,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;
@@ -844,7 +844,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];
 
@@ -931,7 +931,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 77756cb489..e608533439 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 2643ee7f1b..c3c3ba8d45 100644
--- a/ets2panda/checker/ets/function.cpp
+++ b/ets2panda/checker/ets/function.cpp
@@ -160,7 +160,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()) {
@@ -1554,7 +1554,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 a2894f93e9..d32423db48 100644
--- a/ets2panda/checker/ets/typeCheckingHelpers.cpp
+++ b/ets2panda/checker/ets/typeCheckingHelpers.cpp
@@ -1532,7 +1532,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 7b0634260a..967bdaf008 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 0c9e3c25c3..e8c7bc1db6 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 7f7059aeca..d9d465912d 100644
--- a/ets2panda/compiler/core/ETSCompiler.cpp
+++ b/ets2panda/compiler/core/ETSCompiler.cpp
@@ -194,7 +194,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 79bc976050..04477f7551 100644
--- a/ets2panda/compiler/core/ETSGen.h
+++ b/ets2panda/compiler/core/ETSGen.h
@@ -303,7 +303,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 ce5ba4ffed..59eff40fbd 100644
--- a/ets2panda/compiler/core/ETSemitter.cpp
+++ b/ets2panda/compiler/core/ETSemitter.cpp
@@ -864,7 +864,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 5677874aea..cd71e8dfb8 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 100d4e5cfa..0e44b0488e 100644
--- a/ets2panda/compiler/lowering/ets/lambdaLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/lambdaLowering.cpp
@@ -133,7 +133,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)
@@ -161,7 +161,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)
@@ -199,7 +199,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);
@@ -223,7 +223,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 {};
 
@@ -1093,7 +1093,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 44b66ee3d2..1f6fb02dc8 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 68d18c745e..17b137db27 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/evaluate/debugInfoDeserialization/debugInfoDeserializer.h b/ets2panda/evaluate/debugInfoDeserialization/debugInfoDeserializer.h
index d2035a6d6d..42ff7b834b 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 586bbb08f0..725ceffe7d 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 7cc88c9f43..6ef20e5087 100644
--- a/ets2panda/lsp/include/get_adjusted_location.h
+++ b/ets2panda/lsp/include/get_adjusted_location.h
@@ -31,24 +31,24 @@ std::optional<ir::AstNode *> GetAdjustedLocation(ir::AstNode *node, ArenaAllocat
 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,
-                                                               const ArenaVector<ir::AstNode *> &children,
+                                                               const std::vector<ir::AstNode *> &children,
                                                                ArenaAllocator *allocator);
 std::optional<ir::AstNode *> GetAdjustedLocationForImportDeclaration(ir::AstNode *node,
-                                                                     const ArenaVector<ir::AstNode *> &children);
+                                                                     const std::vector<ir::AstNode *> &children);
 std::optional<ir::AstNode *> GetAdjustedLocationForExportDeclaration(ir::AstNode *node,
-                                                                     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);
 
 // 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);
@@ -60,7 +60,7 @@ bool IsDeclarationOrModifier(ir::AstNode *node, ir::AstNode *parent);
 ir::AstNode *SkipOuterExpressions(ir::AstNode *node);
 
 // Children collection
-ArenaVector<ir::AstNode *> GetChildren(ir::AstNode *node, ArenaAllocator *allocator);
+std::vector<ir::AstNode *> GetChildren(ir::AstNode *node, ArenaAllocator *allocator);
 
 }  // namespace ark::es2panda::lsp
 #endif  // ES2PANDA_LSP_GET_ADJUSTED_LOCATION_H
diff --git a/ets2panda/lsp/include/internal_api.h b/ets2panda/lsp/include/internal_api.h
index 6777e3729e..66463db1ef 100644
--- a/ets2panda/lsp/include/internal_api.h
+++ b/ets2panda/lsp/include/internal_api.h
@@ -135,7 +135,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 6884083073..0c13668059 100644
--- a/ets2panda/lsp/src/get_adjusted_location.cpp
+++ b/ets2panda/lsp/src/get_adjusted_location.cpp
@@ -46,9 +46,10 @@ static inline bool IsMirroredSimpleKind(AstNodeType t)
     }
 }
 
-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;
     }
@@ -124,7 +125,7 @@ AstNode *SkipOuterExpressions(AstNode *node)
     return node;
 }
 
-AstNode *FindFirstIdentifier(AstNode *node, bool skipModifiers, const ArenaVector<AstNode *> & /*children*/)
+AstNode *FindFirstIdentifier(AstNode *node, bool skipModifiers, const std::vector<AstNode *> & /*children*/)
 {
     if (node == nullptr) {
         return nullptr;
@@ -135,7 +136,7 @@ AstNode *FindFirstIdentifier(AstNode *node, bool skipModifiers, const ArenaVecto
     return node->FindChild([&](AstNode *n) { return n->IsIdentifier() && (!skipModifiers || !IsModifier(n)); });
 }
 
-AstNode *FindFirstExpression(AstNode *node, const ArenaVector<AstNode *> & /*children*/)
+AstNode *FindFirstExpression(AstNode *node, const std::vector<AstNode *> & /*children*/)
 {
     if (node == nullptr) {
         return nullptr;
@@ -146,7 +147,7 @@ AstNode *FindFirstExpression(AstNode *node, const ArenaVector<AstNode *> & /*chi
     return node->FindChild([](AstNode *n) { return n->IsExpression(); });
 }
 
-AstNode *FindFirstExpressionAfter(AstNode *node, AstNode *after, const ArenaVector<AstNode *> & /*children*/)
+AstNode *FindFirstExpressionAfter(AstNode *node, AstNode *after, const std::vector<AstNode *> & /*children*/)
 {
     if (node == nullptr) {
         return nullptr;
@@ -170,7 +171,7 @@ AstNode *FindFirstExpressionAfter(AstNode *node, AstNode *after, const ArenaVect
     return found;
 }
 
-AstNode *FindNodeOfType(AstNode *node, AstNodeType type, const ArenaVector<AstNode *> & /*children*/)
+AstNode *FindNodeOfType(AstNode *node, AstNodeType type, const std::vector<AstNode *> & /*children*/)
 {
     if (node == nullptr) {
         return nullptr;
@@ -181,7 +182,7 @@ AstNode *FindNodeOfType(AstNode *node, AstNodeType type, const ArenaVector<AstNo
     return node->FindChild([&](AstNode *n) { return n->Type() == type; });
 }
 
-AstNode *FindTypeReference(AstNode *node, const ArenaVector<AstNode *> & /*children*/)
+AstNode *FindTypeReference(AstNode *node, const std::vector<AstNode *> & /*children*/)
 {
     if (node == nullptr) {
         return nullptr;
@@ -192,7 +193,7 @@ AstNode *FindTypeReference(AstNode *node, const ArenaVector<AstNode *> & /*child
     return node->FindChild([](AstNode *n) { return n->IsTSTypeReference(); });
 }
 
-AstNode *FindTypeParameter(AstNode *node, const ArenaVector<AstNode *> & /*children*/)
+AstNode *FindTypeParameter(AstNode *node, const std::vector<AstNode *> & /*children*/)
 {
     if (node == nullptr) {
         return nullptr;
@@ -203,7 +204,7 @@ AstNode *FindTypeParameter(AstNode *node, const ArenaVector<AstNode *> & /*child
     return node->FindChild([](AstNode *n) { return n->IsTSTypeParameterDeclaration(); });
 }
 
-AstNode *FindArrayType(AstNode *node, const ArenaVector<AstNode *> & /*children*/)
+AstNode *FindArrayType(AstNode *node, const std::vector<AstNode *> & /*children*/)
 {
     if (node == nullptr) {
         return nullptr;
@@ -238,7 +239,7 @@ std::optional<AstNode *> GetAdjustedLocationForClass(AstNode *node, ArenaAllocat
     if (!node->IsClassDeclaration() && !node->IsClassExpression()) {
         return std::nullopt;
     }
-    ArenaVector<AstNode *> dummy(allocator->Adapter());
+    std::vector<AstNode *> dummy {};
     AstNode *id = FindFirstIdentifier(node, false, dummy);
     if (id != nullptr) {
         return id;
@@ -277,12 +278,12 @@ std::optional<AstNode *> GetAdjustedLocationForFunction(AstNode *node, ArenaAllo
     }
     // CC-OFFNXT(G.NAM.03-CPP) project code style
     constexpr bool K_SKIP_MODIFIERS = false;
-    ArenaVector<AstNode *> dummy(allocator->Adapter());
+    std::vector<AstNode *> dummy {};
     AstNode *id = FindFirstIdentifier(fn, K_SKIP_MODIFIERS, dummy);
     return (id != nullptr) ? std::optional<AstNode *> {id} : std::nullopt;
 }
 
-std::optional<AstNode *> GetAdjustedLocationForDeclaration(AstNode *node, const ArenaVector<AstNode *> &children,
+std::optional<AstNode *> GetAdjustedLocationForDeclaration(AstNode *node, const std::vector<AstNode *> &children,
                                                            ArenaAllocator *allocator)
 {
     switch (node->Type()) {
@@ -307,7 +308,7 @@ std::optional<AstNode *> GetAdjustedLocationForDeclaration(AstNode *node, const
     return std::nullopt;
 }
 
-std::optional<AstNode *> GetAdjustedLocationForImportDeclaration(AstNode *node, const ArenaVector<AstNode *> &children)
+std::optional<AstNode *> GetAdjustedLocationForImportDeclaration(AstNode *node, const std::vector<AstNode *> &children)
 {
     if (!node->IsImportDeclaration()) {
         return std::nullopt;
@@ -324,7 +325,7 @@ std::optional<AstNode *> GetAdjustedLocationForImportDeclaration(AstNode *node,
     return std::make_optional(spec);
 }
 
-std::optional<AstNode *> GetAdjustedLocationForExportDeclaration(AstNode *node, const ArenaVector<AstNode *> &children)
+std::optional<AstNode *> GetAdjustedLocationForExportDeclaration(AstNode *node, const std::vector<AstNode *> &children)
 {
     if (!node->IsExportAllDeclaration()) {
         return std::nullopt;
@@ -354,7 +355,7 @@ std::optional<AstNode *> GetAdjustedLocationForHeritageClause(AstNode *node)
 }
 
 static std::optional<AstNode *> TryTSAsExpression(AstNode *node, AstNode *parent,
-                                                  const ArenaVector<AstNode *> &parentChildren)
+                                                  const std::vector<AstNode *> &parentChildren)
 {
     if (node == nullptr || parent == nullptr) {
         return std::nullopt;
@@ -379,7 +380,7 @@ static std::optional<AstNode *> TryTSAsExpression(AstNode *node, AstNode *parent
 }
 
 static std::optional<AstNode *> TryTSImportType(AstNode *node, AstNode *parent,
-                                                const ArenaVector<AstNode *> &parentChildren, ArenaAllocator *allocator)
+                                                const std::vector<AstNode *> &parentChildren, ArenaAllocator *allocator)
 {
     if (node == nullptr || parent == nullptr) {
         return std::nullopt;
@@ -401,7 +402,7 @@ static std::optional<AstNode *> TryTSImportType(AstNode *node, AstNode *parent,
 }
 
 static std::optional<AstNode *> TryTSHeritageAndInfer(AstNode *node, AstNode *parent,
-                                                      const ArenaVector<AstNode *> &parentChildren)
+                                                      const std::vector<AstNode *> &parentChildren)
 {
     if (node == nullptr || parent == nullptr) {
         return std::nullopt;
@@ -426,7 +427,7 @@ static std::optional<AstNode *> TryTSHeritageAndInfer(AstNode *node, AstNode *pa
     return std::nullopt;
 }
 
-static std::optional<AstNode *> TryTypeOperatorFamily(AstNode *parent, const ArenaVector<AstNode *> &parentChildren)
+static std::optional<AstNode *> TryTypeOperatorFamily(AstNode *parent, const std::vector<AstNode *> &parentChildren)
 {
     if (parent == nullptr) {
         return std::nullopt;
@@ -450,7 +451,7 @@ static std::optional<AstNode *> TryTypeOperatorFamily(AstNode *parent, const Are
 }
 
 static std::optional<AstNode *> TryDeclaration(AstNode *node, AstNode *parent,
-                                               const ArenaVector<AstNode *> &parentChildren, ArenaAllocator *allocator)
+                                               const std::vector<AstNode *> &parentChildren, ArenaAllocator *allocator)
 {
     if (!IsDeclarationOrModifier(node, parent)) {
         return std::nullopt;
@@ -459,7 +460,7 @@ static std::optional<AstNode *> TryDeclaration(AstNode *node, AstNode *parent,
 }
 
 static std::optional<AstNode *> TryExpressions(AstNode *node, AstNode *parent,
-                                               const ArenaVector<AstNode *> &parentChildren, ArenaAllocator *allocator)
+                                               const std::vector<AstNode *> &parentChildren, ArenaAllocator *allocator)
 {
     if (auto asExpr = TryTSAsExpression(node, parent, parentChildren)) {
         return asExpr;
@@ -476,7 +477,7 @@ static std::optional<AstNode *> TryExpressions(AstNode *node, AstNode *parent,
     return std::nullopt;
 }
 
-static std::optional<AstNode *> TryImportsAndExports(AstNode *parent, const ArenaVector<AstNode *> &parentChildren)
+static std::optional<AstNode *> TryImportsAndExports(AstNode *parent, const std::vector<AstNode *> &parentChildren)
 {
     if (auto importDecl = GetAdjustedLocationForImportDeclaration(parent, parentChildren)) {
         return importDecl;
@@ -489,7 +490,7 @@ static std::optional<AstNode *> TryImportsAndExports(AstNode *parent, const Aren
     return std::nullopt;
 }
 
-static std::optional<AstNode *> TryModuleOrVariable(AstNode *parent, const ArenaVector<AstNode *> &parentChildren)
+static std::optional<AstNode *> TryModuleOrVariable(AstNode *parent, const std::vector<AstNode *> &parentChildren)
 {
     if (parent->IsTSExternalModuleReference()) {
         if (AstNode *expr = FindFirstExpression(parent, parentChildren)) {
@@ -510,7 +511,7 @@ static std::optional<AstNode *> TryModuleOrVariable(AstNode *parent, const Arena
 }
 
 static std::optional<AstNode *> TryConvenienceExpressions(AstNode *node, AstNode *parent,
-                                                          const ArenaVector<AstNode *> &parentChildren)
+                                                          const std::vector<AstNode *> &parentChildren)
 {
     if (node == nullptr || parent == nullptr) {
         return std::nullopt;
@@ -562,7 +563,7 @@ std::optional<AstNode *> GetAdjustedLocation(AstNode *node, ArenaAllocator *allo
         return node;
     }
 
-    ArenaVector<AstNode *> parentChildren = GetChildren(parent, allocator);
+    std::vector<AstNode *> parentChildren = GetChildren(parent, allocator);
     if (auto r = TryDeclaration(node, parent, parentChildren, allocator)) {
         return r;
     }
diff --git a/ets2panda/lsp/src/internal_api.cpp b/ets2panda/lsp/src/internal_api.cpp
index 3162e66432..7b71c3a5ce 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 0180adfcbd..af9be9a916 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 6fb21ed010..dfc4fd0705 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 3899a45c50..3d91086727 100644
--- a/ets2panda/parser/ETSparser.cpp
+++ b/ets2panda/parser/ETSparser.cpp
@@ -286,7 +286,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(); }) ==
@@ -309,7 +309,7 @@ void ETSParser::AddDirectImportsToDirectExternalSources(
 
 void ETSParser::ParseParseListElement(const util::ImportPathManager::ParseInfo &parseListElem,
                                       std::string_view const extSrc,
-                                      const ArenaVector<util::StringView> &directImportsFromMainSource,
+                                      const std::vector<util::StringView> &directImportsFromMainSource,
                                       std::vector<Program *> *programs)
 {
     const auto &importData = parseListElem.importData;
@@ -420,7 +420,7 @@ std::optional<std::string_view> ETSParser::GetDeclarationSource(std::string &&fi
 }
 
 std::vector<Program *> ETSParser::SearchForNotParsed(ArenaVector<util::ImportPathManager::ParseInfo> &parseList,
-                                                     ArenaVector<util::StringView> &directImportsFromMainSource)
+                                                     std::vector<util::StringView> &directImportsFromMainSource)
 {
     std::vector<Program *> programs {};
 
@@ -473,7 +473,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 4e78635efd..501e2e7176 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,
@@ -195,7 +195,7 @@ private:
     void ParseUserSources(std::vector<std::string> userParths);
     ArenaVector<ir::Statement *> ParseTopLevelDeclaration();
     void ParseParseListElement(const util::ImportPathManager::ParseInfo &parseListElem, std::string_view extSrc,
-                               const ArenaVector<util::StringView> &directImportsFromMainSource,
+                               const std::vector<util::StringView> &directImportsFromMainSource,
                                std::vector<Program *> *programs);
     bool IsDefaultImport();
     void ParseNamedSpecifiesDefaultImport(ArenaVector<ir::ImportDefaultSpecifier *> *resultDefault,
@@ -214,7 +214,7 @@ private:
 
     std::optional<std::string_view> GetDeclarationSource(std::string &&fileToParse) const;
     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 e294a8573b..6bbd8f5b47 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();
-- 
Gitee