From 90f60ddc09ce0cba13b5d602b9604b900b9b1807 Mon Sep 17 00:00:00 2001
From: luobohua <bohualiu@huawei.com>
Date: Thu, 31 Jul 2025 17:40:05 +0800
Subject: [PATCH] ArenaVector optimization v1.0: simple opt

Issue: https://gitee.com/openharmony/arkcompiler_ets_frontend/issues/ICQ7OP
Change-Id: Iaa1d997ad80c8f488ab411d85bf01ac62944ed0b
Signed-off-by: luobohua <bohualiu@huawei.com>
---
 ets2panda/checker/ETSAnalyzer.cpp             |  10 +-
 ets2panda/checker/ETSAnalyzerHelpers.cpp      |   2 +-
 ets2panda/checker/ETSchecker.h                |  17 ++
 ets2panda/checker/TSchecker.h                 |  10 +-
 ets2panda/checker/ets/function.cpp            | 214 +++++++++++++++++-
 ets2panda/checker/ets/typeCheckingHelpers.cpp |   2 +-
 ets2panda/checker/ts/function.cpp             |   4 +-
 ets2panda/checker/ts/object.cpp               |  16 +-
 ets2panda/compiler/core/ETSCompiler.cpp       |   4 +-
 ets2panda/compiler/core/ETSGen.cpp            |   2 +-
 ets2panda/compiler/core/ETSGen.h              |  55 +++++
 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 |  36 +--
 ets2panda/lsp/include/internal_api.h          |   2 +-
 ets2panda/lsp/src/get_adjusted_location.cpp   |  58 ++---
 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 +-
 27 files changed, 402 insertions(+), 109 deletions(-)

diff --git a/ets2panda/checker/ETSAnalyzer.cpp b/ets2panda/checker/ETSAnalyzer.cpp
index 6f1a8fbd83..79759099e4 100644
--- a/ets2panda/checker/ETSAnalyzer.cpp
+++ b/ets2panda/checker/ETSAnalyzer.cpp
@@ -756,7 +756,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);
 
@@ -790,9 +790,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;
@@ -834,7 +834,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];
 
@@ -921,7 +921,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/ETSAnalyzerHelpers.cpp b/ets2panda/checker/ETSAnalyzerHelpers.cpp
index 2075563dcd..b37095a0d1 100644
--- a/ets2panda/checker/ETSAnalyzerHelpers.cpp
+++ b/ets2panda/checker/ETSAnalyzerHelpers.cpp
@@ -403,7 +403,7 @@ checker::Signature *GetMostSpecificSigFromExtensionFuncAndClassMethod(checker::E
     // So we temporarily transfer expr node from `a.foo(...)` to `a.foo(a, ...)`.
     // For allCallSignatures in ClassMethodType, temporarily insert the dummyReceiver into their signatureInfo,
     // otherwise we can't get the most suitable classMethod signature if all the extensionFunction signature mismatched.
-    ArenaVector<Signature *> signatures(checker->ProgramAllocator()->Adapter());
+    std::vector<Signature *> signatures {};
     signatures.insert(signatures.end(), type->ClassMethodType()->CallSignatures().begin(),
                       type->ClassMethodType()->CallSignatures().end());
     signatures.insert(signatures.end(), type->ExtensionMethodType()->CallSignatures().begin(),
diff --git a/ets2panda/checker/ETSchecker.h b/ets2panda/checker/ETSchecker.h
index 9494c61473..5b84b99243 100644
--- a/ets2panda/checker/ETSchecker.h
+++ b/ets2panda/checker/ETSchecker.h
@@ -482,6 +482,8 @@ public:
                                      TypeRelationFlag flags, bool reportError, bool unique);
     void ThrowSignatureMismatch(ArenaVector<Signature *> &signatures, const ArenaVector<ir::Expression *> &arguments,
                                 const lexer::SourcePosition &pos, std::string_view signatureKind);
+    void ThrowSignatureMismatch(std::vector<Signature *> &signatures, const ArenaVector<ir::Expression *> &arguments,
+                                const lexer::SourcePosition &pos, std::string_view signatureKind);
     Signature *FirstMatchSignatures(ir::CallExpression *expr, checker::Type *calleeType);
     Signature *MatchOrderSignatures(ArenaVector<Signature *> &signatures,
                                     const ir::TSTypeParameterInstantiation *typeArguments,
@@ -513,6 +515,11 @@ public:
                                   const ArenaVector<ir::Expression *> &arguments, const lexer::SourcePosition &pos,
                                   std::string_view signatureKind,
                                   TypeRelationFlag resolveFlags = TypeRelationFlag::NONE);
+    Signature *ValidateSignatures(std::vector<Signature *> &signatures,
+                                  const ir::TSTypeParameterInstantiation *typeArguments,
+                                  const ArenaVector<ir::Expression *> &arguments, const lexer::SourcePosition &pos,
+                                  std::string_view signatureKind,
+                                  TypeRelationFlag resolveFlags = TypeRelationFlag::NONE);
     Signature *FindMostSpecificSignature(const ArenaVector<Signature *> &signatures,
                                          const ArenaMultiMap<size_t, Signature *> &bestSignaturesForParameter,
                                          size_t paramCount);
@@ -534,10 +541,16 @@ public:
     Signature *ResolvePotentialTrailingLambdaWithReceiver(ir::CallExpression *callExpr,
                                                           ArenaVector<Signature *> const &signatures,
                                                           ArenaVector<ir::Expression *> &arguments);
+    Signature *ResolvePotentialTrailingLambdaWithReceiver(ir::CallExpression *callExpr,
+                                                          std::vector<Signature *> const &signatures,
+                                                          ArenaVector<ir::Expression *> &arguments);
     Signature *MakeSignatureInvocable(Signature *sig, ir::CallExpression *callExpr);
     Signature *ResolveCallExpressionAndTrailingLambda(ArenaVector<Signature *> &signatures,
                                                       ir::CallExpression *callExpr, const lexer::SourcePosition &pos,
                                                       TypeRelationFlag reportFlag = TypeRelationFlag::NONE);
+    Signature *ResolveCallExpressionAndTrailingLambda(std::vector<Signature *> &signatures,
+                                                      ir::CallExpression *callExpr, const lexer::SourcePosition &pos,
+                                                      TypeRelationFlag reportFlag = TypeRelationFlag::NONE);
     void UpdateDeclarationFromSignature(ir::CallExpression *expr, checker::Signature *signature);
     Signature *ResolveConstructExpression(ETSObjectType *type, const ArenaVector<ir::Expression *> &arguments,
                                           const lexer::SourcePosition &pos);
@@ -1076,6 +1089,10 @@ private:
                                                const ir::TSTypeParameterInstantiation *typeArguments,
                                                const ArenaVector<ir::Expression *> &arguments,
                                                const lexer::SourcePosition &pos, TypeRelationFlag resolveFlags);
+    ArenaVector<Signature *> CollectSignatures(std::vector<Signature *> &signatures,
+                                               const ir::TSTypeParameterInstantiation *typeArguments,
+                                               const ArenaVector<ir::Expression *> &arguments,
+                                               const lexer::SourcePosition &pos, TypeRelationFlag resolveFlags);
     // Trailing lambda
     void MoveTrailingBlockToEnclosingBlockStatement(ir::CallExpression *callExpr);
     ir::ScriptFunction *CreateLambdaFunction(ir::BlockStatement *trailingBlock, Signature *sig);
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 0719ed1705..77312600c8 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()) {
@@ -806,6 +806,67 @@ ArenaVector<Signature *> ETSChecker::CollectSignatures(ArenaVector<Signature *>
     return compatibleSignatures;
 }
 
+// CC-OFFNXT(huge_method) solid logic
+ArenaVector<Signature *> ETSChecker::CollectSignatures(std::vector<Signature *> &signatures,
+                                                       const ir::TSTypeParameterInstantiation *typeArguments,
+                                                       const ArenaVector<ir::Expression *> &arguments,
+                                                       const lexer::SourcePosition &pos, TypeRelationFlag resolveFlags)
+{
+    ArenaVector<Signature *> compatibleSignatures(ProgramAllocator()->Adapter());
+    std::vector<bool> argTypeInferenceRequired = FindTypeInferenceArguments(arguments);
+    Signature *notVisibleSignature = nullptr;
+
+    if (signatures.size() > 1) {
+        resolveFlags |= TypeRelationFlag::OVERLOADING_CONTEXT;
+    }
+
+    auto collectSignatures = [&](TypeRelationFlag relationFlags) {
+        for (auto *sig : signatures) {
+            if (notVisibleSignature != nullptr &&
+                !IsSignatureAccessible(sig, Context().ContainingClass(), Relation())) {
+                continue;
+            }
+            if (sig->HasSignatureFlag(SignatureFlags::BRIDGE)) {
+                // Bridges are never invoked direcly
+                continue;
+            }
+            // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
+            auto *concreteSig = ValidateSignature(std::make_tuple(sig, typeArguments, relationFlags), arguments, pos,
+                                                  argTypeInferenceRequired, signatures.size() == 1);
+            if (concreteSig == nullptr) {
+                continue;
+            }
+            if (notVisibleSignature == nullptr &&
+                !IsSignatureAccessible(sig, Context().ContainingClass(), Relation())) {
+                notVisibleSignature = concreteSig;
+            } else {
+                compatibleSignatures.push_back(concreteSig);
+            }
+        }
+    };
+
+    // If there's only one signature, we don't need special checks for boxing/unboxing/widening.
+    // We are also able to provide more specific error messages.
+    if (signatures.size() == 1) {
+        TypeRelationFlag flags = TypeRelationFlag::WIDENING | resolveFlags;
+        collectSignatures(flags);
+    } else {
+        for (auto flags : GetFlagVariants()) {
+            flags = flags | resolveFlags;
+            collectSignatures(flags);
+            if (!compatibleSignatures.empty()) {
+                break;
+            }
+        }
+    }
+
+    if (compatibleSignatures.empty() && notVisibleSignature != nullptr &&
+        ((resolveFlags & TypeRelationFlag::NO_THROW) == 0)) {
+        LogError(diagnostic::SIG_INVISIBLE, {notVisibleSignature->Function()->Id()->Name(), notVisibleSignature}, pos);
+    }
+    return compatibleSignatures;
+}
+
 static void UpdateArrayArgsAndUnboxingFlags(ETSChecker *checker, Signature *sig,
                                             const ArenaVector<ir::Expression *> &arguments)
 {
@@ -884,6 +945,47 @@ void ETSChecker::ThrowSignatureMismatch(ArenaVector<Signature *> &signatures,
     LogError(diagnostic::NO_MATCHING_SIG_2, {signatureKind}, pos);
 }
 
+void ETSChecker::ThrowSignatureMismatch(std::vector<Signature *> &signatures,
+                                        const ArenaVector<ir::Expression *> &arguments,
+                                        const lexer::SourcePosition &pos, std::string_view signatureKind)
+{
+    if (!arguments.empty() && !signatures.empty()) {
+        std::string msg {};
+        auto someSignature = signatures[0];
+
+        if (someSignature->HasFunction()) {
+            if (someSignature->Function()->IsConstructor()) {
+                msg.append(util::Helpers::GetClassDefiniton(someSignature->Function())->InternalName().Mutf8());
+            } else {
+                msg.append(someSignature->Function()->Id()->Name().Mutf8());
+            }
+        }
+
+        msg += "(";
+
+        for (std::size_t index = 0U; index < arguments.size(); ++index) {
+            auto const &argument = arguments[index];
+            Type const *const argumentType = argument->Check(this);
+            if (!argumentType->IsTypeError()) {
+                msg += argumentType->ToString();
+            } else {
+                //  NOTE (DZ): extra cases for some specific nodes can be added here (as for 'ArrowFunctionExpression')
+                msg += argument->ToString();
+            }
+
+            if (index == arguments.size() - 1U) {
+                msg += ")";
+                LogError(diagnostic::NO_MATCHING_SIG, {signatureKind, msg.c_str()}, pos);
+                return;
+            }
+
+            msg += ", ";
+        }
+    }
+
+    LogError(diagnostic::NO_MATCHING_SIG_2, {signatureKind}, pos);
+}
+
 Signature *ETSChecker::ValidateSignatures(ArenaVector<Signature *> &signatures,
                                           const ir::TSTypeParameterInstantiation *typeArguments,
                                           const ArenaVector<ir::Expression *> &arguments,
@@ -915,6 +1017,37 @@ Signature *ETSChecker::ValidateSignatures(ArenaVector<Signature *> &signatures,
     return nullptr;
 }
 
+Signature *ETSChecker::ValidateSignatures(std::vector<Signature *> &signatures,
+                                          const ir::TSTypeParameterInstantiation *typeArguments,
+                                          const ArenaVector<ir::Expression *> &arguments,
+                                          const lexer::SourcePosition &pos, std::string_view signatureKind,
+                                          TypeRelationFlag resolveFlags)
+{
+    // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
+    auto compatibleSignatures = CollectSignatures(signatures, typeArguments, arguments, pos, resolveFlags);
+    if (!compatibleSignatures.empty()) {
+        // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
+        auto *sig = GetMostSpecificSignature(compatibleSignatures, arguments, pos, resolveFlags);
+        // NOTE (DZ):   skip Promise<T> constructor/then/catch check -
+        //              temporary solution, need to be removed after fixing OHOS code!
+        if (sig == nullptr || !sig->HasFunction() ||
+            !(sig->Function()->IsConstructor() || sig->Function()->Id()->Name().Is("then") ||
+              sig->Function()->Id()->Name().Is("catch")) ||
+            !sig->Owner()->Name().Is("Promise")) {
+            // May need to re-check the arguments now that we know the particular signature to call.
+            ValidateSignature({sig, nullptr, TypeRelationFlag::WIDENING | TypeRelationFlag::NO_SUBSTITUTION_NEEDED},
+                              arguments, pos, FindTypeInferenceArguments(arguments), true);
+        }
+        return sig;
+    }
+
+    if ((resolveFlags & TypeRelationFlag::NO_THROW) == 0) {
+        ThrowSignatureMismatch(signatures, arguments, pos, signatureKind);
+    }
+
+    return nullptr;
+}
+
 Signature *ETSChecker::FindMostSpecificSignature(const ArenaVector<Signature *> &signatures,
                                                  const ArenaMultiMap<size_t, Signature *> &bestSignaturesForParameter,
                                                  size_t paramCount)
@@ -1288,6 +1421,44 @@ Signature *ETSChecker::ResolvePotentialTrailingLambdaWithReceiver(ir::CallExpres
                               TypeRelationFlag::NO_THROW | TypeRelationFlag::NO_CHECK_TRAILING_LAMBDA);
 }
 
+Signature *ETSChecker::ResolvePotentialTrailingLambdaWithReceiver(ir::CallExpression *callExpr,
+                                                                  std::vector<Signature *> const &signatures,
+                                                                  ArenaVector<ir::Expression *> &arguments)
+{
+    auto *trailingLambda = arguments.back()->AsArrowFunctionExpression();
+    std::vector<Signature *> normalSig;
+    std::vector<Signature *> sigContainLambdaWithReceiverAsParam;
+    Signature *signature = nullptr;
+    for (auto sig : signatures) {
+        if (!sig->HasFunction()) {
+            continue;
+        }
+
+        if (!IsLastParameterLambdaWithReceiver(sig)) {
+            normalSig.emplace_back(sig);
+            continue;
+        }
+
+        auto *candidateFunctionType =
+            sig->Function()->Params().back()->AsETSParameterExpression()->TypeAnnotation()->AsETSFunctionType();
+        auto *currentReceiver = candidateFunctionType->Params()[0];
+        trailingLambda->Function()->EmplaceParams(currentReceiver);
+        sigContainLambdaWithReceiverAsParam.emplace_back(sig);
+        // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
+        signature = ValidateSignatures(sigContainLambdaWithReceiverAsParam, callExpr->TypeParams(), arguments,
+                                       callExpr->Start(), "call",
+                                       TypeRelationFlag::NO_THROW | TypeRelationFlag::NO_CHECK_TRAILING_LAMBDA);
+        if (signature != nullptr) {
+            return signature;
+        }
+        sigContainLambdaWithReceiverAsParam.clear();
+        trailingLambda->Function()->ClearParams();
+    }
+    // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
+    return ValidateSignatures(normalSig, callExpr->TypeParams(), arguments, callExpr->Start(), "call",
+                              TypeRelationFlag::NO_THROW | TypeRelationFlag::NO_CHECK_TRAILING_LAMBDA);
+}
+
 void ETSChecker::UpdateDeclarationFromSignature(ir::CallExpression *expr, checker::Signature *signature)
 {
     if (signature == nullptr) {
@@ -1390,6 +1561,45 @@ Signature *ETSChecker::ResolveCallExpressionAndTrailingLambda(ArenaVector<Signat
     return sig;
 }
 
+Signature *ETSChecker::ResolveCallExpressionAndTrailingLambda(std::vector<Signature *> &signatures,
+                                                              ir::CallExpression *callExpr,
+                                                              const lexer::SourcePosition &pos,
+                                                              const TypeRelationFlag reportFlag)
+{
+    if (callExpr->TrailingBlock() == nullptr) {
+        auto sig =
+            // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
+            ValidateSignatures(signatures, callExpr->TypeParams(), callExpr->Arguments(), pos, "call", reportFlag);
+        sig = MakeSignatureInvocable(sig, callExpr);
+        UpdateDeclarationFromSignature(callExpr, sig);
+        return sig;
+    }
+
+    // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
+    auto arguments = ExtendArgumentsWithFakeLamda(callExpr);
+    // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
+    auto sig = ResolvePotentialTrailingLambdaWithReceiver(callExpr, signatures, arguments);
+    if (sig != nullptr) {
+        // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
+        TransformTraillingLambda(callExpr, sig);
+        // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
+        TrailingLambdaTypeInference(sig, callExpr->Arguments());
+        UpdateDeclarationFromSignature(callExpr, sig);
+        callExpr->SetIsTrailingCall(true);
+        return sig;
+    }
+
+    // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
+    sig = ValidateSignatures(signatures, callExpr->TypeParams(), callExpr->Arguments(), pos, "call", reportFlag);
+    sig = MakeSignatureInvocable(sig, callExpr);
+    if (sig != nullptr) {
+        EnsureValidCurlyBrace(callExpr);
+    }
+
+    UpdateDeclarationFromSignature(callExpr, sig);
+    return sig;
+}
+
 Signature *ETSChecker::ResolveConstructExpression(ETSObjectType *type, const ArenaVector<ir::Expression *> &arguments,
                                                   const lexer::SourcePosition &pos)
 {
@@ -1436,7 +1646,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 dd0a84f46e..57c4f370b1 100644
--- a/ets2panda/checker/ets/typeCheckingHelpers.cpp
+++ b/ets2panda/checker/ets/typeCheckingHelpers.cpp
@@ -1531,7 +1531,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 9e26143b69..0e1d60af22 100644
--- a/ets2panda/compiler/core/ETSCompiler.cpp
+++ b/ets2panda/compiler/core/ETSCompiler.cpp
@@ -137,7 +137,7 @@ void ETSCompiler::Compile(const ir::ETSNewArrayInstanceExpression *expr) const
 
         if (expr->Signature() != nullptr) {
             const compiler::TargetTypeContext ttctx2(etsg, elementType);
-            static const ArenaVector<ir::Expression *> ARGUMENTS(GetCodeGen()->Allocator()->Adapter());
+            static const std::vector<ir::Expression *> ARGUMENTS {};
             etsg->InitObject(expr, expr->Signature(), ARGUMENTS);
         } else {
             etsg->LoadAccumulatorPoison(expr, elementType);
@@ -188,7 +188,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.cpp b/ets2panda/compiler/core/ETSGen.cpp
index b1559ad0cc..ec0a5da5ee 100644
--- a/ets2panda/compiler/core/ETSGen.cpp
+++ b/ets2panda/compiler/core/ETSGen.cpp
@@ -551,7 +551,7 @@ const checker::Type *ETSGen::LoadDefaultValue(const ir::AstNode *node, const che
             LoadAccumulatorUndefined(node);
         } else if (type->IsETSObjectType() && type->AsETSObjectType()->IsBoxedPrimitive()) {
             //  Call default constructor for boxed primitive types.
-            static auto const DUMMY_ARGS = ArenaVector<ir::Expression *>(checker->Allocator()->Adapter());
+            static auto const DUMMY_ARGS = std::vector<ir::Expression *> {};
             auto const &signatures = type->AsETSObjectType()->ConstructSignatures();
             auto const it = std::find_if(signatures.cbegin(), signatures.cend(), [](checker::Signature *signature) {
                 return signature->ArgCount() == 0U && !signature->HasRestParameter();
diff --git a/ets2panda/compiler/core/ETSGen.h b/ets2panda/compiler/core/ETSGen.h
index 4b306cccb2..27eecbce59 100644
--- a/ets2panda/compiler/core/ETSGen.h
+++ b/ets2panda/compiler/core/ETSGen.h
@@ -299,6 +299,11 @@ public:
     {
         CallImpl<InitobjShort, Initobj, InitobjRange>(node, signature, arguments);
     }
+    void InitObject(const ir::AstNode *node, checker::Signature const *signature,
+                    const std::vector<ir::Expression *> &arguments)
+    {
+        CallImpl<InitobjShort, Initobj, InitobjRange>(node, signature, arguments);
+    }
 
     bool IsDevirtualizedSignature(const checker::Signature *signature)
     {
@@ -661,6 +666,56 @@ private:
         ES2PANDA_ASSERT(signature != nullptr);
         RegScope rs(this);
 
+        switch (arguments.size()) {
+            case 0U: {
+                Ra().Emit<Short, 0U>(node, signature->InternalName(), dummyReg_, dummyReg_);
+                break;
+            }
+            case 1U: {
+                COMPILE_ARG(0);
+                Ra().Emit<Short, 1U>(node, signature->InternalName(), arg0, dummyReg_);
+                break;
+            }
+            case 2U: {
+                COMPILE_ARG(0);
+                COMPILE_ARG(1);
+                Ra().Emit<Short, 2U>(node, signature->InternalName(), arg0, arg1);
+                break;
+            }
+            case 3U: {
+                COMPILE_ARG(0);
+                COMPILE_ARG(1);
+                COMPILE_ARG(2);
+                Ra().Emit<General, 3U>(node, signature->InternalName(), arg0, arg1, arg2, dummyReg_);
+                break;
+            }
+            case 4U: {
+                COMPILE_ARG(0);
+                COMPILE_ARG(1);
+                COMPILE_ARG(2);
+                COMPILE_ARG(3);
+                Ra().Emit<General, 4U>(node, signature->InternalName(), arg0, arg1, arg2, arg3);
+                break;
+            }
+            default: {
+                VReg argStart = NextReg();
+
+                for (size_t idx = 0; idx < arguments.size(); idx++) {
+                    COMPILE_ARG(idx);
+                }
+
+                Rra().Emit<Range>(node, argStart, arguments.size(), signature->InternalName(), argStart);
+                break;
+            }
+        }
+    }
+    template <typename Short, typename General, typename Range>
+    void CallImpl(const ir::AstNode *node, checker::Signature const *signature,
+                  const std::vector<ir::Expression *> &arguments)
+    {
+        ES2PANDA_ASSERT(signature != nullptr);
+        RegScope rs(this);
+
         switch (arguments.size()) {
             case 0U: {
                 Ra().Emit<Short, 0U>(node, signature->InternalName(), dummyReg_, dummyReg_);
diff --git a/ets2panda/compiler/core/ETSemitter.cpp b/ets2panda/compiler/core/ETSemitter.cpp
index 4da7d669bf..01b2231831 100644
--- a/ets2panda/compiler/core/ETSemitter.cpp
+++ b/ets2panda/compiler/core/ETSemitter.cpp
@@ -774,7 +774,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 26a2f43910..8a77dda09c 100644
--- a/ets2panda/compiler/lowering/ets/exportAnonymousConst.cpp
+++ b/ets2panda/compiler/lowering/ets/exportAnonymousConst.cpp
@@ -102,7 +102,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 8bbaa52286..370cea2330 100644
--- a/ets2panda/compiler/lowering/ets/lambdaLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/lambdaLowering.cpp
@@ -126,7 +126,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)
@@ -154,7 +154,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)
@@ -192,7 +192,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);
@@ -216,7 +216,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 {};
 
@@ -1040,7 +1040,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 d323d0006f..638b2c3574 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()) {
@@ -209,7 +209,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);
@@ -252,7 +252,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 fe5e9ac7d3..70bc20bd42 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 1e82b52cc2..2b4ba239be 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 7980e1c9f4..a58a9a36b1 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 4c0cbeee7b..142e0a3249 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 4bb625026e..7b8ca50c30 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 175d39818b..e769a417b5 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 b3acf5e559..e9c89be77d 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 b5d77a85be..f4188171d2 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 5d22459eac..74ff2ea8e0 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 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