diff --git a/ets2panda/checker/ASchecker.h b/ets2panda/checker/ASchecker.h
index 84ba809e5b0d673bdfc99f006a9ea7a649a2b281..399d423630223822cbbc6dd951964f5765c8b170 100644
--- a/ets2panda/checker/ASchecker.h
+++ b/ets2panda/checker/ASchecker.h
@@ -23,11 +23,7 @@ namespace ark::es2panda::checker {
 class ASChecker : public Checker {
 public:
     // NOLINTNEXTLINE(readability-redundant-member-init)
-    explicit ASChecker([[maybe_unused]] ThreadSafeArenaAllocator *allocator, util::DiagnosticEngine &diagnosticEngine,
-                       [[maybe_unused]] ArenaAllocator *programAllocator)
-        : Checker(allocator, diagnosticEngine)
-    {
-    }
+    explicit ASChecker(util::DiagnosticEngine &diagnosticEngine) : Checker(diagnosticEngine) {}
 
     bool StartChecker([[maybe_unused]] varbinder::VarBinder *varbinder,
                       [[maybe_unused]] const util::Options &options) override;
diff --git a/ets2panda/checker/ETSAnalyzer.cpp b/ets2panda/checker/ETSAnalyzer.cpp
index 12767046a35acdd47b53003fbcf729a1c70eb754..b070f4e9d8fce206affbd85c91792f881a896741 100644
--- a/ets2panda/checker/ETSAnalyzer.cpp
+++ b/ets2panda/checker/ETSAnalyzer.cpp
@@ -112,7 +112,7 @@ checker::Type *ETSAnalyzer::Check(ir::ClassProperty *st) const
         // its tsType. see wrong_variable_binding.ets for more details.
         auto ident = st->Id();
         auto [decl, var] = checker->VarBinder()->NewVarDecl<varbinder::LetDecl>(
-            ident->Start(), compiler::GenName(checker->ProgramAllocator()).View());
+            ident->Start(), compiler::GenName(checker->Allocator()).View());
         var->SetScope(checker->VarBinder()->GetScope());
         ident->SetVariable(var);
         decl->BindNode(ident);
@@ -310,7 +310,7 @@ void ETSAnalyzer::CheckMethodModifiers(ir::MethodDefinition *node) const
 
 static void CheckDuplicationInOverloadDeclaration(ETSChecker *const checker, ir::OverloadDeclaration *const node)
 {
-    auto overloadedNameSet = ArenaSet<std::string>(checker->ProgramAllocator()->Adapter());
+    auto overloadedNameSet = ArenaSet<std::string>(checker->Allocator()->Adapter());
     for (ir::Expression *const overloadedName : node->OverloadedList()) {
         bool isQualifiedName = true;
         std::function<std::string(ir::Expression *const)> getFullOverloadedName =
@@ -452,7 +452,7 @@ checker::Type *ETSAnalyzer::Check(ir::ETSClassLiteral *expr) const
         return expr->TsType();
     }
 
-    ArenaVector<checker::Type *> typeArgTypes(checker->ProgramAllocator()->Adapter());
+    ArenaVector<checker::Type *> typeArgTypes(checker->Allocator()->Adapter());
     typeArgTypes.push_back(exprType);  // NOTE: Box it if it's a primitive type
 
     checker::InstantiationContext ctx(checker, checker->GlobalBuiltinTypeType(), std::move(typeArgTypes),
@@ -794,7 +794,7 @@ static bool ValidArrayExprSizeForTupleSize(ETSChecker *checker, Type *possibleTu
 
 static ArenaVector<std::pair<Type *, ir::Expression *>> GetElementTypes(ETSChecker *checker, ir::ArrayExpression *expr)
 {
-    ArenaVector<std::pair<Type *, ir::Expression *>> elementTypes(checker->ProgramAllocator()->Adapter());
+    ArenaVector<std::pair<Type *, ir::Expression *>> elementTypes(checker->Allocator()->Adapter());
 
     auto *const exprPreferredType = expr->PreferredType();
     auto *const exprTupleType = exprPreferredType->IsETSTupleType() ? exprPreferredType->AsETSTupleType() : nullptr;
@@ -888,7 +888,7 @@ static bool CheckElement(ETSChecker *checker, Type *const preferredType,
 
 static Type *InferPreferredTypeFromElements(ETSChecker *checker, ir::ArrayExpression *arrayExpr)
 {
-    ArenaVector<Type *> arrayExpressionElementTypes(checker->ProgramAllocator()->Adapter());
+    ArenaVector<Type *> arrayExpressionElementTypes(checker->Allocator()->Adapter());
     for (auto *const element : arrayExpr->Elements()) {
         auto *elementType = *element->Check(checker);
         if (element->IsSpreadElement() && elementType->IsETSTupleType()) {
@@ -2710,7 +2710,7 @@ static checker::Type *GetTypeOfStringType(checker::Type *argType, ETSChecker *ch
 static checker::Type *ComputeTypeOfType(ETSChecker *checker, checker::Type *argType)
 {
     checker::Type *ret = nullptr;
-    ArenaVector<checker::Type *> types(checker->ProgramAllocator()->Adapter());
+    ArenaVector<checker::Type *> types(checker->Allocator()->Adapter());
     ES2PANDA_ASSERT(argType != nullptr);
     if (argType->IsETSUnionType()) {
         for (auto *it : argType->AsETSUnionType()->ConstituentTypes()) {
@@ -3132,7 +3132,7 @@ static void ProcessRequiredFields(ArenaUnorderedMap<util::StringView, ir::ClassP
             continue;
         }
         // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
-        auto *clone = entry.second->Clone(checker->Allocator(), st);
+        auto *clone = entry.second->Clone(checker->ProgramAllocator(), st);
         st->AddProperty(clone);
         clone->Check(checker);
     }
@@ -3159,7 +3159,7 @@ checker::Type *ETSAnalyzer::Check(ir::AnnotationUsage *st) const
     auto *annoDecl = baseName->Variable()->Declaration()->Node()->AsAnnotationDeclaration();
     annoDecl->Check(checker);
 
-    ArenaUnorderedMap<util::StringView, ir::ClassProperty *> fieldMap {checker->ProgramAllocator()->Adapter()};
+    ArenaUnorderedMap<util::StringView, ir::ClassProperty *> fieldMap {checker->Allocator()->Adapter()};
     for (auto *it : annoDecl->Properties()) {
         auto *field = it->AsClassProperty();
         ES2PANDA_ASSERT(field->Id() != nullptr);
diff --git a/ets2panda/checker/ETSAnalyzerHelpers.cpp b/ets2panda/checker/ETSAnalyzerHelpers.cpp
index d3127e33aa2eb640069872c868a0be4ba0186073..64d1c9ab30f7c4c79f9e10f17394e5ade7c78723 100644
--- a/ets2panda/checker/ETSAnalyzerHelpers.cpp
+++ b/ets2panda/checker/ETSAnalyzerHelpers.cpp
@@ -152,8 +152,8 @@ void CheckExtensionMethod(checker::ETSChecker *checker, ir::ScriptFunction *exte
             return;
         }
 
-        checker::SignatureInfo *originalExtensionSigInfo = checker->ProgramAllocator()->New<checker::SignatureInfo>(
-            extensionFunc->Signature()->GetSignatureInfo(), checker->ProgramAllocator());
+        checker::SignatureInfo *originalExtensionSigInfo = checker->Allocator()->New<checker::SignatureInfo>(
+            extensionFunc->Signature()->GetSignatureInfo(), checker->Allocator());
         ES2PANDA_ASSERT(originalExtensionSigInfo != nullptr);
         originalExtensionSigInfo->minArgCount -= 1U;
         originalExtensionSigInfo->params.erase(originalExtensionSigInfo->params.begin());
@@ -258,8 +258,8 @@ void ComposeAsyncImplFuncReturnType(ETSChecker *checker, ir::ScriptFunction *scr
     ES2PANDA_ASSERT(returnType != nullptr);
     objectId->SetParent(returnType->Part());
     returnType->Part()->SetParent(returnType);
-    returnType->SetTsType(checker->ProgramAllocator()->New<ETSAsyncFuncReturnType>(checker->ProgramAllocator(),
-                                                                                   checker->Relation(), promiseType));
+    returnType->SetTsType(
+        checker->Allocator()->New<ETSAsyncFuncReturnType>(checker->Allocator(), checker->Relation(), promiseType));
     returnType->Check(checker);
     scriptFunc->Signature()->SetReturnType(returnType->TsType());
 }
@@ -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());
+    ArenaVector<Signature *> signatures(checker->Allocator()->Adapter());
     auto const &classMethodSignatures = type->ClassMethodType()->CallSignatures();
     auto const &extensionMethodSignatures = type->ExtensionMethodType()->CallSignaturesOfMethodOrArrow();
 
@@ -489,16 +489,16 @@ checker::Signature *ResolveCallForETSExtensionFuncHelperType(checker::ETSExtensi
 
 ArenaVector<checker::Signature *> GetUnionTypeSignatures(ETSChecker *checker, checker::ETSUnionType *etsUnionType)
 {
-    ArenaVector<checker::Signature *> callSignatures(checker->ProgramAllocator()->Adapter());
+    ArenaVector<checker::Signature *> callSignatures(checker->Allocator()->Adapter());
 
     for (auto *constituentType : etsUnionType->ConstituentTypes()) {
         if (constituentType->IsETSFunctionType()) {
-            ArenaVector<checker::Signature *> tmpCallSignatures(checker->ProgramAllocator()->Adapter());
+            ArenaVector<checker::Signature *> tmpCallSignatures(checker->Allocator()->Adapter());
             tmpCallSignatures = constituentType->AsETSFunctionType()->CallSignatures();
             callSignatures.insert(callSignatures.end(), tmpCallSignatures.begin(), tmpCallSignatures.end());
         }
         if (constituentType->IsETSUnionType()) {
-            ArenaVector<checker::Signature *> tmpCallSignatures(checker->ProgramAllocator()->Adapter());
+            ArenaVector<checker::Signature *> tmpCallSignatures(checker->Allocator()->Adapter());
             tmpCallSignatures = GetUnionTypeSignatures(checker, constituentType->AsETSUnionType());
             callSignatures.insert(callSignatures.end(), tmpCallSignatures.begin(), tmpCallSignatures.end());
         }
diff --git a/ets2panda/checker/ETSchecker.h b/ets2panda/checker/ETSchecker.h
index 0f21caa25b577120fd802a7430b3d008fad25e14..1fab733415ecf0a4e02cc9a8846bffbdc9d39bbb 100644
--- a/ets2panda/checker/ETSchecker.h
+++ b/ets2panda/checker/ETSchecker.h
@@ -84,10 +84,9 @@ using TypePtr = Type *;
 
 class ETSChecker final : public Checker {
 public:
-    explicit ETSChecker(ThreadSafeArenaAllocator *allocator, util::DiagnosticEngine &diagnosticEngine,
-                        ThreadSafeArenaAllocator *programAllocator = nullptr)
+    explicit ETSChecker(util::DiagnosticEngine &diagnosticEngine)
         // NOLINTNEXTLINE(readability-redundant-member-init)
-        : Checker(allocator, diagnosticEngine, programAllocator),
+        : Checker(diagnosticEngine),
           arrayTypes_(Allocator()->Adapter()),
           objectInstantiationMap_(Allocator()->Adapter()),
           invokeToArrowSignatures_(Allocator()->Adapter()),
@@ -432,7 +431,7 @@ public:
 
     ArenaSubstitution *NewArenaSubstitution()
     {
-        return ProgramAllocator()->New<ArenaSubstitution>(ProgramAllocator()->Adapter());
+        return Allocator()->New<ArenaSubstitution>(Allocator()->Adapter());
     }
 
     bool ValidateTypeSubstitution(const ArenaVector<Type *> &typeParams, Type *ctype, Type *argumentType,
@@ -1008,9 +1007,9 @@ public:
     void InitCachedComputedAbstracts()
     {
         // clang-format off
-        cachedComputedAbstracts_ = ProgramAllocator()->New<ArenaUnorderedMap<ETSObjectType *,
+        cachedComputedAbstracts_ = Allocator()->New<ArenaUnorderedMap<ETSObjectType *,
             std::pair<ArenaVector<ETSFunctionType *>,
-            ArenaUnorderedSet<ETSObjectType *>>>>(ProgramAllocator()->Adapter());
+            ArenaUnorderedSet<ETSObjectType *>>>>(Allocator()->Adapter());
         // clang-format on
     }
 
diff --git a/ets2panda/checker/JSchecker.h b/ets2panda/checker/JSchecker.h
index 3e261069aa8196ca0803ad84e0d67a53e8d9112d..91f85fc93a169cbb3edac902f911ee99aa9be53d 100644
--- a/ets2panda/checker/JSchecker.h
+++ b/ets2panda/checker/JSchecker.h
@@ -23,11 +23,7 @@ namespace ark::es2panda::checker {
 class JSChecker : public Checker {
 public:
     // NOLINTNEXTLINE(readability-redundant-member-init)
-    explicit JSChecker([[maybe_unused]] ThreadSafeArenaAllocator *allocator, util::DiagnosticEngine &diagnosticEngine,
-                       [[maybe_unused]] ThreadSafeArenaAllocator *programAllocator = nullptr)
-        : Checker(allocator, diagnosticEngine, programAllocator)
-    {
-    }
+    explicit JSChecker(util::DiagnosticEngine &diagnosticEngine) : Checker(diagnosticEngine) {}
 
     bool StartChecker([[maybe_unused]] varbinder::VarBinder *varbinder, const util::Options &options) override;
 
diff --git a/ets2panda/checker/TSchecker.h b/ets2panda/checker/TSchecker.h
index 77756cb4891aa666dcdf36041f559260a12ff917..2bbb4e3f7c12a00b0429044ed8a1e0f0459c40b4 100644
--- a/ets2panda/checker/TSchecker.h
+++ b/ets2panda/checker/TSchecker.h
@@ -121,11 +121,7 @@ struct TupleTypeInfo {
 class TSChecker : public Checker {
 public:
     // NOLINTNEXTLINE(readability-redundant-member-init)
-    explicit TSChecker([[maybe_unused]] ThreadSafeArenaAllocator *allocator, util::DiagnosticEngine &diagnosticEngine,
-                       [[maybe_unused]] ThreadSafeArenaAllocator *programAllocator)
-        : Checker(allocator, diagnosticEngine, programAllocator)
-    {
-    }
+    explicit TSChecker(util::DiagnosticEngine &diagnosticEngine) : Checker(diagnosticEngine) {}
 
     Type *GlobalNumberType()
     {
diff --git a/ets2panda/checker/checker.cpp b/ets2panda/checker/checker.cpp
index ab4e17a2e079d1182cf78b6a0e32ecc6eedbaa1d..7214ac06c97b4862dd5a144809003ca6e9082b7c 100644
--- a/ets2panda/checker/checker.cpp
+++ b/ets2panda/checker/checker.cpp
@@ -20,20 +20,19 @@
 #include "checker/types/ts/unionType.h"
 
 namespace ark::es2panda::checker {
-Checker::Checker(ThreadSafeArenaAllocator *allocator, util::DiagnosticEngine &diagnosticEngine,
-                 ThreadSafeArenaAllocator *programAllocator)
-    : allocator_(allocator),
-      programAllocator_(programAllocator),
+Checker::Checker(util::DiagnosticEngine &diagnosticEngine)
+    : allocator_(SpaceType::SPACE_TYPE_COMPILER, nullptr, true),
       context_(this, CheckerStatus::NO_OPTS),
       diagnosticEngine_(diagnosticEngine)
 {
-    relation_ = ProgramAllocator()->New<TypeRelation>(this);
-    globalTypes_ = ProgramAllocator()->New<GlobalTypesHolder>(ProgramAllocator());
+    relation_ = Allocator()->New<TypeRelation>(this);
+    globalTypes_ = Allocator()->New<GlobalTypesHolder>(Allocator());
 }
 
 void Checker::Initialize(varbinder::VarBinder *varbinder)
 {
     varbinder_ = varbinder;
+    programAllocator_ = varbinder->GetContext()->allocator;
     scope_ = varbinder_->TopScope();
     program_ = varbinder_->Program();
 }
@@ -184,10 +183,10 @@ ScopeContext::ScopeContext(Checker *checker, varbinder::Scope *newScope)
 void Checker::CleanUp()
 {
     if (!program_->IsASTLowered()) {
-        globalTypes_ = allocator_->New<GlobalTypesHolder>(allocator_);
+        globalTypes_ = Allocator()->New<GlobalTypesHolder>(Allocator());
     }
     context_ = CheckerContext(this, CheckerStatus::NO_OPTS);
-    relation_ = allocator_->New<TypeRelation>(this);
+    relation_ = Allocator()->New<TypeRelation>(this);
     identicalResults_.Clear();
     assignableResults_.Clear();
     comparableResults_.Clear();
diff --git a/ets2panda/checker/checker.h b/ets2panda/checker/checker.h
index 2cfda48b919cd4f30bf8403045b982324158b07f..c8f302ca80e0e9832dc48cded7c84cfa82906297 100644
--- a/ets2panda/checker/checker.h
+++ b/ets2panda/checker/checker.h
@@ -64,8 +64,7 @@ using ArgRange = std::pair<uint32_t, uint32_t>;
 
 class Checker {
 public:
-    explicit Checker(ThreadSafeArenaAllocator *allocator, util::DiagnosticEngine &diagnosticEngine,
-                     ThreadSafeArenaAllocator *programAllocator = nullptr);
+    explicit Checker(util::DiagnosticEngine &diagnosticEngine);
     virtual ~Checker() = default;
 
     NO_COPY_SEMANTIC(Checker);
@@ -73,7 +72,7 @@ public:
 
     [[nodiscard]] ThreadSafeArenaAllocator *Allocator() noexcept
     {
-        return allocator_;
+        return &allocator_;
     }
 
     [[nodiscard]] varbinder::Scope *Scope() const noexcept
@@ -108,7 +107,7 @@ public:
 
     void InitGlobalTypes()
     {
-        globalTypes_ = ProgramAllocator()->New<GlobalTypesHolder>(ProgramAllocator());
+        globalTypes_ = Allocator()->New<GlobalTypesHolder>(Allocator());
     }
 
     [[nodiscard]] GlobalTypesHolder *GetGlobalTypesHolder() const noexcept
@@ -236,7 +235,7 @@ public:
 
     [[nodiscard]] ThreadSafeArenaAllocator *ProgramAllocator()
     {
-        return programAllocator_ == nullptr ? allocator_ : programAllocator_;
+        return programAllocator_;
     }
 
     bool IsDeclForDynamicStaticInterop() const;
@@ -246,7 +245,7 @@ protected:
     void SetProgram(parser::Program *program);
 
 private:
-    ThreadSafeArenaAllocator *allocator_;
+    ThreadSafeArenaAllocator allocator_;
     ThreadSafeArenaAllocator *programAllocator_ {nullptr};
     CheckerContext context_;
     GlobalTypesHolder *globalTypes_ {nullptr};
diff --git a/ets2panda/checker/ets/function.cpp b/ets2panda/checker/ets/function.cpp
index 7cebeb2b296027359199cbc8b713f777fc4ea70d..8ab3bf504f9e0cb861ad948f74e6e8270c1a24b3 100644
--- a/ets2panda/checker/ets/function.cpp
+++ b/ets2panda/checker/ets/function.cpp
@@ -165,8 +165,8 @@ bool ETSChecker::EnhanceSubstitutionForUnion(const ArenaVector<Type *> &typePara
     }
     auto *const argUn = argumentType->AsETSUnionType();
 
-    ArenaVector<Type *> paramWlist(ProgramAllocator()->Adapter());
-    ArenaVector<Type *> argWlist(ProgramAllocator()->Adapter());
+    ArenaVector<Type *> paramWlist(Allocator()->Adapter());
+    ArenaVector<Type *> argWlist(Allocator()->Adapter());
 
     for (auto *pc : paramUn->ConstituentTypes()) {
         for (auto *ac : argUn->ConstituentTypes()) {
@@ -816,7 +816,7 @@ ArenaVector<Signature *> ETSChecker::CollectSignatures(ArenaVector<Signature *>
                                                        const ArenaVector<ir::Expression *> &arguments,
                                                        const lexer::SourcePosition &pos, TypeRelationFlag resolveFlags)
 {
-    ArenaVector<Signature *> compatibleSignatures(ProgramAllocator()->Adapter());
+    ArenaVector<Signature *> compatibleSignatures(Allocator()->Adapter());
     std::vector<bool> argTypeInferenceRequired = FindTypeInferenceArguments(arguments);
     Signature *notVisibleSignature = nullptr;
 
@@ -1223,7 +1223,7 @@ ArenaMultiMap<size_t, Signature *> ETSChecker::GetSuitableSignaturesForParameter
     const ArenaVector<ir::Expression *> &arguments, const lexer::SourcePosition &pos)
 {
     // Collect which signatures are most specific for each parameter.
-    ArenaMultiMap<size_t /* parameter index */, Signature *> bestSignaturesForParameter(ProgramAllocator()->Adapter());
+    ArenaMultiMap<size_t /* parameter index */, Signature *> bestSignaturesForParameter(Allocator()->Adapter());
 
     const checker::SavedTypeRelationFlagsContext savedTypeRelationFlagCtx(Relation(),
                                                                           TypeRelationFlag::ONLY_CHECK_WIDENING);
@@ -1330,8 +1330,8 @@ Signature *ETSChecker::ResolvePotentialTrailingLambdaWithReceiver(ir::CallExpres
                                                                   ArenaVector<ir::Expression *> &arguments)
 {
     auto *trailingLambda = arguments.back()->AsArrowFunctionExpression();
-    ArenaVector<Signature *> normalSig(ProgramAllocator()->Adapter());
-    ArenaVector<Signature *> sigContainLambdaWithReceiverAsParam(ProgramAllocator()->Adapter());
+    ArenaVector<Signature *> normalSig(Allocator()->Adapter());
+    ArenaVector<Signature *> sigContainLambdaWithReceiverAsParam(Allocator()->Adapter());
     Signature *signature = nullptr;
     for (auto sig : signatures) {
         if (!sig->HasFunction()) {
@@ -1511,7 +1511,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());
+    ArenaVector<ETSFunctionType *> overloads(checker->Allocator()->Adapter());
 
     for (ir::MethodDefinition *const currentFunc : method->Overloads()) {
         if (currentFunc->IsDeclare() != ldInfo.isDeclare) {
@@ -1834,8 +1834,7 @@ checker::ETSFunctionType *ETSChecker::BuildMethodType(ir::ScriptFunction *func)
     ES2PANDA_ASSERT(!func->IsArrow());
     ES2PANDA_ASSERT(func != nullptr);
     auto *nameVar = func->Id()->Variable();
-    ETSFunctionType *funcType =
-        CreateETSMethodType(nameVar->Name(), {{func->Signature()}, ProgramAllocator()->Adapter()});
+    ETSFunctionType *funcType = CreateETSMethodType(nameVar->Name(), {{func->Signature()}, Allocator()->Adapter()});
     funcType->SetVariable(nameVar);
     return funcType;
 }
@@ -2319,7 +2318,7 @@ ir::MethodDefinition *ETSChecker::CreateMethod(const util::StringView &name, ir:
     // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
     auto *nameId = ProgramAllocNode<ir::Identifier>(name, ProgramAllocator());
     // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
-    auto *scope = ProgramAllocator()->New<varbinder::FunctionScope>(ProgramAllocator(), paramScope);
+    auto *scope = Allocator()->New<varbinder::FunctionScope>(Allocator(), paramScope);
     // clang-format off
     // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
     auto *const func = ProgramAllocNode<ir::ScriptFunction>(
@@ -2464,7 +2463,7 @@ ir::ScriptFunction *ETSChecker::CreateLambdaFunction(ir::BlockStatement *trailin
             actualLambdaType->Params()[0]->Clone(ProgramAllocator(), nullptr)->AsExpression();
         auto *receiverVar = receiverOfTrailingBlock->AsETSParameterExpression()->Ident()->Variable();
         auto *receiverVarClone =
-            ProgramAllocator()->New<varbinder::LocalVariable>(receiverVar->Declaration(), receiverVar->Flags());
+            Allocator()->New<varbinder::LocalVariable>(receiverVar->Declaration(), receiverVar->Flags());
         receiverVarClone->SetTsType(receiverVar->TsType());
         receiverVarClone->SetScope(funcParamScope);
         funcScope->InsertBinding(receiverVarClone->Name(), receiverVarClone);
@@ -2907,8 +2906,8 @@ Signature *ETSChecker::ResolvePotentialTrailingLambda(ir::CallExpression *callEx
                                                       ArenaVector<ir::Expression *> &arguments)
 {
     auto *trailingLambda = arguments.back()->AsArrowFunctionExpression();
-    ArenaVector<Signature *> normalSig(ProgramAllocator()->Adapter());
-    ArenaVector<Signature *> sigContainLambdaWithReceiverAsParam(ProgramAllocator()->Adapter());
+    ArenaVector<Signature *> normalSig(Allocator()->Adapter());
+    ArenaVector<Signature *> sigContainLambdaWithReceiverAsParam(Allocator()->Adapter());
     Signature *signature = nullptr;
     for (auto sig : signatures) {
         if (!IsLastParameterLambdaWithReceiver(sig)) {
diff --git a/ets2panda/checker/ets/helpers.cpp b/ets2panda/checker/ets/helpers.cpp
index 45f42bbafefeecbdcfbcbaa435663ffd4dd4ae9a..eeb4127c6fb232ad6a6e2e7b9b647e7066c001b0 100644
--- a/ets2panda/checker/ets/helpers.cpp
+++ b/ets2panda/checker/ets/helpers.cpp
@@ -317,8 +317,7 @@ Type *ETSChecker::ResolveIdentifier(ir::Identifier *ident)
                 return ident->SetTsType(GlobalTypeError());
             }
             auto [decl, var] = VarBinder()->NewVarDecl<varbinder::LetDecl>(
-                ident->Start(),
-                !ident->IsErrorPlaceHolder() ? ident->Name() : compiler::GenName(ProgramAllocator()).View());
+                ident->Start(), !ident->IsErrorPlaceHolder() ? ident->Name() : compiler::GenName(Allocator()).View());
             var->SetScope(VarBinder()->GetScope());
             ident->SetVariable(var);
             decl->BindNode(ident);
@@ -550,7 +549,7 @@ void ETSChecker::ResolveReturnStatement(checker::Type *funcReturnType, checker::
 
 checker::Type *ETSChecker::CheckArrayElements(ir::ArrayExpression *init)
 {
-    ArenaVector<checker::Type *> elementTypes(ProgramAllocator()->Adapter());
+    ArenaVector<checker::Type *> elementTypes(Allocator()->Adapter());
     for (auto *elementNode : init->AsArrayExpression()->Elements()) {
         Type *elementType = elementNode->Check(this);
         if (elementType->IsTypeError()) {
@@ -974,7 +973,7 @@ void ETSChecker::VariableTypeFromInitializer(varbinder::Variable *variable, Type
 
     ES2PANDA_ASSERT(annotationType->IsETSPrimitiveType());
     //  We suppose here that all required checks were passed and correct conversion is possible without accuracy loss
-    variable->SetTsType(TypeConverter::ConvertConstantTypes(initType, annotationType, ProgramAllocator()));
+    variable->SetTsType(TypeConverter::ConvertConstantTypes(initType, annotationType, Allocator()));
 }
 
 static checker::Type *ResolveGetter(checker::ETSChecker *checker, ir::MemberExpression *const expr,
@@ -1014,7 +1013,7 @@ Signature *ETSChecker::FindRelativeExtensionGetter(ir::MemberExpression *const e
         return sig;
     }
 
-    ArenaVector<ir::Expression *> arguments(ProgramAllocator()->Adapter());
+    ArenaVector<ir::Expression *> arguments(Allocator()->Adapter());
     arguments.insert(arguments.begin(), expr->Object());
     // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
     Signature *signature = ValidateSignatures(funcType->GetExtensionAccessorSigs(), nullptr, arguments, expr->Start(),
@@ -1036,7 +1035,7 @@ Signature *ETSChecker::FindRelativeExtensionSetter(ir::MemberExpression *expr, E
     }
 
     Signature *signature = nullptr;
-    ArenaVector<ir::Expression *> arguments(ProgramAllocator()->Adapter());
+    ArenaVector<ir::Expression *> arguments(Allocator()->Adapter());
     arguments.insert(arguments.begin(), expr->Object());
     if (expr->Parent()->IsAssignmentExpression()) {
         arguments.emplace_back(expr->Parent()->AsAssignmentExpression()->Right());
@@ -1081,8 +1080,8 @@ checker::Type *ETSChecker::GetExtensionAccessorReturnType(ir::MemberExpression *
         auto signature = FindRelativeExtensionSetter(expr, eAccType);
         if (signature != nullptr && !expr->Parent()->IsUpdateExpression()) {
             // for a.m += otherExpr, we need to validateSignature again.
-            ArenaVector<ir::Expression *> arguments(ProgramAllocator()->Adapter());
-            ArenaVector<Signature *> candidateSig(ProgramAllocator()->Adapter());
+            ArenaVector<ir::Expression *> arguments(Allocator()->Adapter());
+            ArenaVector<Signature *> candidateSig(Allocator()->Adapter());
             candidateSig.emplace_back(signature);
             arguments.emplace_back(expr->Object());
             arguments.emplace_back(expr->Parent()->AsAssignmentExpression()->Right());
@@ -1291,9 +1290,9 @@ checker::Type *CheckerContext::GetIntersectionOfTypes(checker::Type *const type1
         return type1;
     }
 
-    ArenaVector<Type *> typeSet1(checker->ProgramAllocator()->Adapter());
-    ArenaVector<Type *> typeSet2(checker->ProgramAllocator()->Adapter());
-    ArenaVector<Type *> intersection(checker->ProgramAllocator()->Adapter());
+    ArenaVector<Type *> typeSet1(checker->Allocator()->Adapter());
+    ArenaVector<Type *> typeSet2(checker->Allocator()->Adapter());
+    ArenaVector<Type *> intersection(checker->Allocator()->Adapter());
 
     if (type1->IsETSUnionType()) {
         typeSet1 = type1->AsETSUnionType()->ConstituentTypes();
@@ -1979,7 +1978,7 @@ Type *ETSChecker::HandleStringConcatenation(Type *leftType, Type *rightType)
         return GlobalETSStringLiteralType();
     }
 
-    util::UString concatenated(ProgramAllocator());
+    util::UString concatenated(Allocator());
     ConcatConstantString(concatenated, leftType);
     ConcatConstantString(concatenated, rightType);
 
@@ -2440,7 +2439,7 @@ util::StringView ETSChecker::GetHashFromTypeArguments(const ArenaVector<Type *>
         ss << it << compiler::Signatures::MANGLE_SEPARATOR;
     }
 
-    return util::UString(ss.str(), ProgramAllocator()).View();
+    return util::UString(ss.str(), Allocator()).View();
 }
 
 util::StringView ETSChecker::GetHashFromSubstitution(const Substitution *substitution, const bool extensionFuncFlag)
@@ -2466,7 +2465,7 @@ util::StringView ETSChecker::GetHashFromSubstitution(const Substitution *substit
     if (extensionFuncFlag) {
         ss << "extensionFunctionType;";
     }
-    return util::UString(ss.str(), ProgramAllocator()).View();
+    return util::UString(ss.str(), Allocator()).View();
 }
 
 util::StringView ETSChecker::GetHashFromFunctionType(ir::ETSFunctionType *type)
@@ -2497,7 +2496,7 @@ util::StringView ETSChecker::GetHashFromFunctionType(ir::ETSFunctionType *type)
 
     ss << ";";
 
-    return util::UString(ss.str(), ProgramAllocator()).View();
+    return util::UString(ss.str(), Allocator()).View();
 }
 
 ETSObjectType *ETSChecker::GetOriginalBaseType(Type *const object)
@@ -2729,11 +2728,11 @@ ir::ClassProperty *ETSChecker::ClassPropToImplementationProp(ir::ClassProperty *
     classProp->Key()->AsIdentifier()->SetName(util::UString(newName, ProgramAllocator()).View());
     classProp->AddModifier(ir::ModifierFlags::PRIVATE);
 
-    auto *fieldDecl = ProgramAllocator()->New<varbinder::LetDecl>(classProp->Key()->AsIdentifier()->Name());
+    auto *fieldDecl = Allocator()->New<varbinder::LetDecl>(classProp->Key()->AsIdentifier()->Name());
     ES2PANDA_ASSERT(fieldDecl != nullptr);
     fieldDecl->BindNode(classProp);
 
-    auto fieldVar = scope->InstanceFieldScope()->AddDecl(ProgramAllocator(), fieldDecl, ScriptExtension::ETS);
+    auto fieldVar = scope->InstanceFieldScope()->AddDecl(Allocator(), fieldDecl, ScriptExtension::ETS);
     fieldVar->AddFlag(varbinder::VariableFlags::PROPERTY);
     fieldVar->SetScope(scope->InstanceFieldScope());
 
@@ -2799,7 +2798,7 @@ void ETSChecker::GenerateGetterSetterBody(ArenaVector<ir::Statement *> &stmts, A
     auto *paramExpression = ProgramAllocNode<ir::ETSParameterExpression>(paramIdent, false, ProgramAllocator());
     paramExpression->SetRange(paramIdent->Range());
 
-    auto [paramVar, node] = paramScope->AddParamDecl(ProgramAllocator(), VarBinder(), paramExpression);
+    auto [paramVar, node] = paramScope->AddParamDecl(Allocator(), VarBinder(), paramExpression);
     if (node != nullptr) {
         VarBinder()->ThrowRedeclaration(node->Start(), paramVar->Name(), paramVar->Declaration()->Type());
     }
@@ -2843,10 +2842,8 @@ static std::tuple<ir::ScriptFunction *, varbinder::FunctionScope *, ir::Modifier
     ir::ClassProperty *const property, ir::ClassProperty *const field, varbinder::ClassScope *classScope, bool isSetter,
     ETSChecker *checker)
 {
-    auto *paramScope =
-        checker->ProgramAllocator()->New<varbinder::FunctionParamScope>(checker->ProgramAllocator(), classScope);
-    auto *functionScope =
-        checker->ProgramAllocator()->New<varbinder::FunctionScope>(checker->ProgramAllocator(), paramScope);
+    auto *paramScope = checker->Allocator()->New<varbinder::FunctionParamScope>(checker->Allocator(), classScope);
+    auto *functionScope = checker->Allocator()->New<varbinder::FunctionScope>(checker->Allocator(), paramScope);
 
     functionScope->BindParamScope(paramScope);
     paramScope->BindFunctionScope(functionScope);
@@ -2901,9 +2898,9 @@ ir::MethodDefinition *ETSChecker::GenerateDefaultGetterSetter(ir::ClassProperty
     auto *method = checker->ProgramAllocNode<ir::MethodDefinition>(
         isSetter ? ir::MethodDefinitionKind::SET : ir::MethodDefinitionKind::GET, methodIdent, funcExpr, modifierFlag,
         checker->ProgramAllocator(), false);
-    auto *decl = checker->ProgramAllocator()->New<varbinder::FunctionDecl>(
-        checker->ProgramAllocator(), property->Key()->AsIdentifier()->Name(), method);
-    auto *var = checker->ProgramAllocator()->New<varbinder::LocalVariable>(decl, varbinder::VariableFlags::VAR);
+    auto *decl = checker->Allocator()->New<varbinder::FunctionDecl>(checker->Allocator(),
+                                                                    property->Key()->AsIdentifier()->Name(), method);
+    auto *var = checker->Allocator()->New<varbinder::LocalVariable>(decl, varbinder::VariableFlags::VAR);
     CHECK_NOT_NULL(var);
     var->AddFlag(varbinder::VariableFlags::METHOD);
 
@@ -3026,9 +3023,9 @@ void ETSChecker::GenerateGetterSetterPropertyAndMethod(ir::ClassProperty *origin
             : nullptr;
 
     auto *const methodScope = scope->InstanceMethodScope();
-    auto *const decl = ProgramAllocator()->New<varbinder::FunctionDecl>(ProgramAllocator(), name, getter);
+    auto *const decl = Allocator()->New<varbinder::FunctionDecl>(Allocator(), name, getter);
 
-    auto *var = methodScope->AddDecl(ProgramAllocator(), decl, ScriptExtension::ETS);
+    auto *var = methodScope->AddDecl(Allocator(), decl, ScriptExtension::ETS);
     if (var == nullptr) {
         auto *const prevDecl = methodScope->FindDecl(name);
         for (const auto &method : {getter, setter}) {
@@ -3176,16 +3173,15 @@ Type *ETSChecker::GetImportSpecifierObjectType(ir::ETSImportDeclaration *importD
     auto const internalName =
         util::UString(
             moduleName.Mutf8().append(compiler::Signatures::METHOD_SEPARATOR).append(compiler::Signatures::ETS_GLOBAL),
-            ProgramAllocator())
+            Allocator())
             .View();
 
-    auto *moduleObjectType =
-        ProgramAllocator()->New<ETSObjectType>(ProgramAllocator(), moduleName, internalName,
-                                               std::make_tuple(ident, checker::ETSObjectFlags::CLASS, Relation()));
+    auto *moduleObjectType = Allocator()->New<ETSObjectType>(
+        Allocator(), moduleName, internalName, std::make_tuple(ident, checker::ETSObjectFlags::CLASS, Relation()));
 
-    auto *rootDecl = ProgramAllocator()->New<varbinder::ClassDecl>(moduleName);
+    auto *rootDecl = Allocator()->New<varbinder::ClassDecl>(moduleName);
     varbinder::LocalVariable *rootVar =
-        ProgramAllocator()->New<varbinder::LocalVariable>(rootDecl, varbinder::VariableFlags::NONE);
+        Allocator()->New<varbinder::LocalVariable>(rootDecl, varbinder::VariableFlags::NONE);
     ES2PANDA_ASSERT(rootVar != nullptr);
     rootVar->SetTsType(moduleObjectType);
 
@@ -3294,7 +3290,7 @@ checker::ETSFunctionType *ETSChecker::IntersectSignatureSets(const checker::ETSF
         std::swap(left, right);
     }
 
-    ArenaVector<checker::Signature *> intersection {ProgramAllocator()->Adapter()};
+    ArenaVector<checker::Signature *> intersection {Allocator()->Adapter()};
 
     for (const auto sig : left->CallSignatures()) {
         auto found = right->FindSpecificSignature(
diff --git a/ets2panda/checker/ets/object.cpp b/ets2panda/checker/ets/object.cpp
index c6ca10da394b81d67fd1de48952f3c8804aa4309..61dceb3942825d1b78b6ec368af0924bf24d1efd 100644
--- a/ets2panda/checker/ets/object.cpp
+++ b/ets2panda/checker/ets/object.cpp
@@ -307,7 +307,7 @@ std::pair<ArenaVector<Type *>, bool> ETSChecker::CreateUnconstrainedTypeParamete
     ir::TSTypeParameterDeclaration const *typeParams)
 {
     bool ok = true;
-    ArenaVector<Type *> result {ProgramAllocator()->Adapter()};
+    ArenaVector<Type *> result {Allocator()->Adapter()};
     checker::ScopeContext scopeCtx(this, typeParams->Scope());
 
     // Note: we have to run pure check loop first to avoid endless loop because of possible circular dependencies
@@ -845,7 +845,7 @@ void ETSChecker::CreateFunctionTypesFromAbstracts(const std::vector<Signature *>
         if (found != nullptr) {
             found->AddCallSignature(it);
         } else {
-            target->push_back(CreateETSMethodType(name, {{it}, ProgramAllocator()->Adapter()}));
+            target->push_back(CreateETSMethodType(name, {{it}, Allocator()->Adapter()}));
         }
     }
 }
@@ -863,9 +863,9 @@ void ETSChecker::ComputeAbstractsFromInterface(ETSObjectType *interfaceType)
         ComputeAbstractsFromInterface(it);
     }
 
-    ArenaVector<ETSFunctionType *> merged(ProgramAllocator()->Adapter());
+    ArenaVector<ETSFunctionType *> merged(Allocator()->Adapter());
     CreateFunctionTypesFromAbstracts(CollectAbstractSignaturesFromObject(interfaceType), &merged);
-    ArenaUnorderedSet<ETSObjectType *> abstractInheritanceTarget(ProgramAllocator()->Adapter());
+    ArenaUnorderedSet<ETSObjectType *> abstractInheritanceTarget(Allocator()->Adapter());
 
     for (auto *interface : interfaceType->Interfaces()) {
         auto found = cachedComputedAbstracts->find(interface);
@@ -887,10 +887,10 @@ void ETSChecker::ComputeAbstractsFromInterface(ETSObjectType *interfaceType)
 
 ArenaVector<ETSFunctionType *> &ETSChecker::GetAbstractsForClass(ETSObjectType *classType)
 {
-    ArenaVector<ETSFunctionType *> merged(ProgramAllocator()->Adapter());
+    ArenaVector<ETSFunctionType *> merged(Allocator()->Adapter());
     CreateFunctionTypesFromAbstracts(CollectAbstractSignaturesFromObject(classType), &merged);
 
-    ArenaUnorderedSet<ETSObjectType *> abstractInheritanceTarget(ProgramAllocator()->Adapter());
+    ArenaUnorderedSet<ETSObjectType *> abstractInheritanceTarget(Allocator()->Adapter());
     if (classType->SuperType() != nullptr) {
         auto base = GetCachedComputedAbstracts()->find(classType->SuperType());
         ES2PANDA_ASSERT(base != GetCachedComputedAbstracts()->end());
@@ -1015,8 +1015,8 @@ static void CallRedeclarationCheckForCorrectSignature(ir::MethodDefinition *meth
 
 void ETSChecker::CheckInterfaceFunctions(ETSObjectType *classType)
 {
-    ArenaVector<ETSObjectType *> interfaces(ProgramAllocator()->Adapter());
-    ArenaVector<Signature *> similarSignatures(ProgramAllocator()->Adapter());
+    ArenaVector<ETSObjectType *> interfaces(Allocator()->Adapter());
+    ArenaVector<Signature *> similarSignatures(Allocator()->Adapter());
     interfaces.emplace_back(classType);
     GetInterfacesOfClass(classType, interfaces);
 
@@ -1131,15 +1131,14 @@ void ETSChecker::ValidateNonOverriddenFunction(ETSObjectType *classType, ArenaVe
                 newProp->AddModifier(isGetSet.isGetter && isGetSet.isSetter ? ir::ModifierFlags::GETTER_SETTER
                                      : isGetSet.isGetter                    ? ir::ModifierFlags::GETTER
                                                                             : ir::ModifierFlags::SETTER);
-                auto *newFieldDecl =
-                    ProgramAllocator()->New<varbinder::LetDecl>(newProp->Key()->AsIdentifier()->Name());
+                auto *newFieldDecl = Allocator()->New<varbinder::LetDecl>(newProp->Key()->AsIdentifier()->Name());
                 newFieldDecl->BindNode(newProp);
 
                 auto newFieldVar = classType->GetDeclNode()
                                        ->Scope()
                                        ->AsClassScope()
                                        ->InstanceFieldScope()
-                                       ->AddDecl(ProgramAllocator(), newFieldDecl, ScriptExtension::ETS)
+                                       ->AddDecl(Allocator(), newFieldDecl, ScriptExtension::ETS)
                                        ->AsLocalVariable();
                 newFieldVar->AddFlag(varbinder::VariableFlags::PROPERTY);
                 newFieldVar->AddFlag(varbinder::VariableFlags::PUBLIC);
@@ -1492,7 +1491,7 @@ void ETSChecker::CheckThisOrSuperCallInConstructor(ETSObjectType *classType, Sig
             (it->AsExpressionStatement()->GetExpression()->AsCallExpression()->Callee()->IsThisExpression() ||
              it->AsExpressionStatement()->GetExpression()->AsCallExpression()->Callee()->IsSuperExpression())) {
             ArenaVector<const ir::Expression *> expressions =
-                ArenaVector<const ir::Expression *>(ProgramAllocator()->Adapter());
+                ArenaVector<const ir::Expression *>(Allocator()->Adapter());
             expressions.insert(expressions.end(),
                                it->AsExpressionStatement()->GetExpression()->AsCallExpression()->Arguments().begin(),
                                it->AsExpressionStatement()->GetExpression()->AsCallExpression()->Arguments().end());
@@ -1543,8 +1542,7 @@ void ETSChecker::CheckExpressionsInConstructor(const ArenaVector<const ir::Expre
 ArenaVector<const ir::Expression *> ETSChecker::CheckMemberOrCallOrObjectExpressionInConstructor(
     const ir::Expression *arg)
 {
-    ArenaVector<const ir::Expression *> expressions =
-        ArenaVector<const ir::Expression *>(ProgramAllocator()->Adapter());
+    ArenaVector<const ir::Expression *> expressions = ArenaVector<const ir::Expression *>(Allocator()->Adapter());
 
     if (arg->IsMemberExpression()) {
         if ((arg->AsMemberExpression()->Object()->IsSuperExpression() ||
@@ -2271,18 +2269,17 @@ std::vector<ResolveResult *> ETSChecker::ValidateAccessor(ir::MemberExpression *
     }
 
     if (finalRes == propType) {
-        resolveRes.emplace_back(ProgramAllocator()->New<ResolveResult>(oAcc, ResolvedKind::PROPERTY));
+        resolveRes.emplace_back(Allocator()->New<ResolveResult>(oAcc, ResolvedKind::PROPERTY));
         return resolveRes;
     }
-    resolveRes.emplace_back(ProgramAllocator()->New<ResolveResult>(eAcc, ResolvedKind::EXTENSION_ACCESSOR));
+    resolveRes.emplace_back(Allocator()->New<ResolveResult>(eAcc, ResolvedKind::EXTENSION_ACCESSOR));
     return resolveRes;
 }
 
 ir::ClassProperty *ETSChecker::FindClassProperty(const ETSObjectType *const objectType, const ETSFunctionType *propType)
 {
     auto propName =
-        util::UString(std::string(compiler::Signatures::PROPERTY) + propType->Name().Mutf8(), ProgramAllocator())
-            .View();
+        util::UString(std::string(compiler::Signatures::PROPERTY) + propType->Name().Mutf8(), Allocator()).View();
 
     ir::ClassProperty *classProp = nullptr;
     if (objectType->GetDeclNode()->IsClassDefinition()) {
@@ -2380,7 +2377,7 @@ std::vector<ResolveResult *> ETSChecker::ResolveMemberReference(const ir::Member
         // Note: extension function only for instance.
         ValidateResolvedProperty(&prop, target, memberExpr->Property()->AsIdentifier(), searchFlag);
         if (prop != nullptr) {
-            resolveRes.emplace_back(ProgramAllocator()->New<ResolveResult>(prop, ResolvedKind::PROPERTY));
+            resolveRes.emplace_back(Allocator()->New<ResolveResult>(prop, ResolvedKind::PROPERTY));
         }
         return resolveRes;
     }
@@ -2402,13 +2399,13 @@ std::vector<ResolveResult *> ETSChecker::ResolveMemberReference(const ir::Member
             LogError(diagnostic::EXTENSION_ACCESSOR_INVALID_CALL, {}, memberExpr->Start());
             return resolveRes;
         }
-        resolveRes.emplace_back(ProgramAllocator()->New<ResolveResult>(globalFunctionVar, resolvedKind));
+        resolveRes.emplace_back(Allocator()->New<ResolveResult>(globalFunctionVar, resolvedKind));
     } else {
         ValidateResolvedProperty(&prop, target, memberExpr->Property()->AsIdentifier(), searchFlag);
     }
 
     if (prop != nullptr) {
-        resolveRes.emplace_back(ProgramAllocator()->New<ResolveResult>(prop, ResolvedKind::PROPERTY));
+        resolveRes.emplace_back(Allocator()->New<ResolveResult>(prop, ResolvedKind::PROPERTY));
     }
     return resolveRes;
 }
@@ -2745,7 +2742,7 @@ Type *ETSChecker::GetApparentType(Type *type)
     }
     if (type->IsETSUnionType()) {
         bool differ = false;
-        ArenaVector<checker::Type *> newConstituent(ProgramAllocator()->Adapter());
+        ArenaVector<checker::Type *> newConstituent(Allocator()->Adapter());
         for (auto const &ct : type->AsETSUnionType()->ConstituentTypes()) {
             // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
             newConstituent.push_back(GetApparentType(ct));
diff --git a/ets2panda/checker/ets/typeCheckingHelpers.cpp b/ets2panda/checker/ets/typeCheckingHelpers.cpp
index 79205c2b9ef4908b5a65a8a3d9a6fa979590d993..7cc02667e317a994e25abb31fc8063f8be0d820e 100644
--- a/ets2panda/checker/ets/typeCheckingHelpers.cpp
+++ b/ets2panda/checker/ets/typeCheckingHelpers.cpp
@@ -103,7 +103,7 @@ Type *ETSChecker::GetNonNullishType(Type *type)
         return type;
     }
     if (type->IsETSTypeParameter()) {
-        return ProgramAllocator()->New<ETSNonNullishType>(type->AsETSTypeParameter());
+        return Allocator()->New<ETSNonNullishType>(type->AsETSTypeParameter());
     }
     if (type->IsETSPartialTypeParameter()) {
         return type->AsETSPartialTypeParameter()->GetUnderlying();
@@ -112,7 +112,7 @@ Type *ETSChecker::GetNonNullishType(Type *type)
         return GetGlobalTypesHolder()->GlobalETSNeverType();
     }
 
-    ArenaVector<Type *> copied(ProgramAllocator()->Adapter());
+    ArenaVector<Type *> copied(Allocator()->Adapter());
     for (auto const &t : type->AsETSUnionType()->ConstituentTypes()) {
         if (t->IsETSNullType() || t->IsETSUndefinedType()) {
             continue;
@@ -142,7 +142,7 @@ Type *ETSChecker::RemoveNullType(Type *const type)
     }
 
     ES2PANDA_ASSERT(type->IsETSUnionType());
-    ArenaVector<Type *> copiedTypes(ProgramAllocator()->Adapter());
+    ArenaVector<Type *> copiedTypes(Allocator()->Adapter());
 
     for (auto *constituentType : type->AsETSUnionType()->ConstituentTypes()) {
         if (!constituentType->IsETSNullType()) {
@@ -174,7 +174,7 @@ Type *ETSChecker::RemoveUndefinedType(Type *const type)
     }
 
     ES2PANDA_ASSERT(type->IsETSUnionType());
-    ArenaVector<Type *> copiedTypes(ProgramAllocator()->Adapter());
+    ArenaVector<Type *> copiedTypes(Allocator()->Adapter());
 
     for (auto *constituentType : type->AsETSUnionType()->ConstituentTypes()) {
         if (!constituentType->IsETSUndefinedType()) {
@@ -203,7 +203,7 @@ std::pair<Type *, Type *> ETSChecker::RemoveNullishTypes(Type *type)
 
     if (type->IsETSTypeParameter()) {
         return {GetGlobalTypesHolder()->GlobalETSUnionUndefinedNull(),
-                ProgramAllocator()->New<ETSNonNullishType>(type->AsETSTypeParameter())};
+                Allocator()->New<ETSNonNullishType>(type->AsETSTypeParameter())};
     }
 
     if (type->IsETSUndefinedType() || type->IsETSNullType()) {
@@ -211,18 +211,17 @@ std::pair<Type *, Type *> ETSChecker::RemoveNullishTypes(Type *type)
     }
 
     ES2PANDA_ASSERT(type->IsETSUnionType());
-    ArenaVector<Type *> nullishTypes(ProgramAllocator()->Adapter());
-    ArenaVector<Type *> notNullishTypes(ProgramAllocator()->Adapter());
+    ArenaVector<Type *> nullishTypes(Allocator()->Adapter());
+    ArenaVector<Type *> notNullishTypes(Allocator()->Adapter());
 
     for (auto *ctype : type->AsETSUnionType()->ConstituentTypes()) {
         auto constituentType = ctype->MaybeBaseTypeOfGradualType();
         if (constituentType->IsETSUndefinedType() || constituentType->IsETSNullType()) {
             nullishTypes.push_back(constituentType);
         } else {
-            notNullishTypes.push_back(
-                !constituentType->IsETSTypeParameter()
-                    ? constituentType
-                    : ProgramAllocator()->New<ETSNonNullishType>(constituentType->AsETSTypeParameter()));
+            notNullishTypes.push_back(!constituentType->IsETSTypeParameter()
+                                          ? constituentType
+                                          : Allocator()->New<ETSNonNullishType>(constituentType->AsETSTypeParameter()));
         }
     }
 
@@ -751,7 +750,7 @@ Type *ETSChecker::ResolveUnionUncheckedType(ArenaVector<checker::Type *> &&appar
 Type *ETSChecker::GuaranteedTypeForUnionFieldAccess(ir::MemberExpression *memberExpression, ETSUnionType *etsUnionType)
 {
     const auto &types = etsUnionType->ConstituentTypes();
-    ArenaVector<checker::Type *> apparentTypes {ProgramAllocator()->Adapter()};
+    ArenaVector<checker::Type *> apparentTypes {Allocator()->Adapter()};
     const auto *prop = memberExpression->Property();
     util::StringView propertyName;
     if (prop->IsIdentifier()) {
@@ -1531,7 +1530,7 @@ bool ETSChecker::CheckLambdaTypeAnnotation(ir::ETSParameterExpression *param,
 
     // Preserve actual lambda types
     ir::ScriptFunction *const lambda = arrowFuncExpr->Function();
-    ArenaVector<ir::TypeNode *> lambdaParamTypes {ProgramAllocator()->Adapter()};
+    ArenaVector<ir::TypeNode *> lambdaParamTypes {Allocator()->Adapter()};
     for (auto *const lambdaParam : lambda->Params()) {
         lambdaParamTypes.emplace_back(lambdaParam->AsETSParameterExpression()->Ident()->TypeAnnotation());
     }
diff --git a/ets2panda/checker/ets/typeCreation.cpp b/ets2panda/checker/ets/typeCreation.cpp
index c6396ad6435a2aa5eb7b8cc4107e733429543483..bbca917b004ca9be159d8b3ecb38edacb429b811 100644
--- a/ets2panda/checker/ets/typeCreation.cpp
+++ b/ets2panda/checker/ets/typeCreation.cpp
@@ -29,52 +29,52 @@ namespace ark::es2panda::checker {
 
 ByteType *ETSChecker::CreateByteType(int8_t value)
 {
-    return ProgramAllocator()->New<ByteType>(value);
+    return Allocator()->New<ByteType>(value);
 }
 
 ETSBooleanType *ETSChecker::CreateETSBooleanType(bool value)
 {
-    return ProgramAllocator()->New<ETSBooleanType>(value);
+    return Allocator()->New<ETSBooleanType>(value);
 }
 
 DoubleType *ETSChecker::CreateDoubleType(double value)
 {
-    return ProgramAllocator()->New<DoubleType>(value);
+    return Allocator()->New<DoubleType>(value);
 }
 
 FloatType *ETSChecker::CreateFloatType(float value)
 {
-    return ProgramAllocator()->New<FloatType>(value);
+    return Allocator()->New<FloatType>(value);
 }
 
 IntType *ETSChecker::CreateIntType(int32_t value)
 {
-    return ProgramAllocator()->New<IntType>(value);
+    return Allocator()->New<IntType>(value);
 }
 
 LongType *ETSChecker::CreateLongType(int64_t value)
 {
-    return ProgramAllocator()->New<LongType>(value);
+    return Allocator()->New<LongType>(value);
 }
 
 ShortType *ETSChecker::CreateShortType(int16_t value)
 {
-    return ProgramAllocator()->New<ShortType>(value);
+    return Allocator()->New<ShortType>(value);
 }
 
 CharType *ETSChecker::CreateCharType(char16_t value)
 {
-    return ProgramAllocator()->New<CharType>(value);
+    return Allocator()->New<CharType>(value);
 }
 
 ETSBigIntType *ETSChecker::CreateETSBigIntLiteralType(util::StringView value)
 {
-    return ProgramAllocator()->New<ETSBigIntType>(ProgramAllocator(), GlobalBuiltinETSBigIntType(), Relation(), value);
+    return Allocator()->New<ETSBigIntType>(Allocator(), GlobalBuiltinETSBigIntType(), Relation(), value);
 }
 
 ETSStringType *ETSChecker::CreateETSStringLiteralType(util::StringView value)
 {
-    return ProgramAllocator()->New<ETSStringType>(ProgramAllocator(), GlobalBuiltinETSStringType(), Relation(), value);
+    return Allocator()->New<ETSStringType>(Allocator(), GlobalBuiltinETSStringType(), Relation(), value);
 }
 
 ETSResizableArrayType *ETSChecker::CreateETSMultiDimResizableArrayType(Type *element, size_t dimSize)
@@ -115,12 +115,12 @@ ETSArrayType *ETSChecker::CreateETSArrayType(Type *elementType, bool isCachePoll
         return res->second;
     }
 
-    auto *arrayType = ProgramAllocator()->New<ETSArrayType>(elementType);
+    auto *arrayType = Allocator()->New<ETSArrayType>(elementType);
 
     ES2PANDA_ASSERT(arrayType != nullptr);
     std::stringstream ss;
     arrayType->ToAssemblerTypeWithRank(ss);
-    // arrayType->SetAssemblerName(util::UString(ss.str(), ProgramAllocator()).View());
+    // arrayType->SetAssemblerName(util::UString(ss.str(), Allocator()).View());
 
     auto it = arrayTypes_.insert({{elementType, isCachePolluting}, arrayType});
     if (it.second && (!elementType->IsTypeParameter() || !elementType->IsETSTypeParameter())) {
@@ -142,13 +142,13 @@ Type *ETSChecker::CreateGradualType(Type *type, Language const lang)
         return type;
     }
     if (type->IsETSUnionType()) {
-        ArenaVector<Type *> copied(ProgramAllocator()->Adapter());
+        ArenaVector<Type *> copied(Allocator()->Adapter());
         for (auto const &t : type->AsETSUnionType()->ConstituentTypes()) {
             copied.push_back(CreateGradualType(t, lang));
         }
         return CreateETSUnionType(std::move(copied));
     }
-    return ProgramAllocator()->New<GradualType>(type);
+    return Allocator()->New<GradualType>(type);
 }
 
 Type *ETSChecker::CreateETSUnionType(Span<Type *const> constituentTypes)
@@ -157,14 +157,14 @@ Type *ETSChecker::CreateETSUnionType(Span<Type *const> constituentTypes)
         return nullptr;
     }
 
-    ArenaVector<Type *> newConstituentTypes(ProgramAllocator()->Adapter());
+    ArenaVector<Type *> newConstituentTypes(Allocator()->Adapter());
     newConstituentTypes.assign(constituentTypes.begin(), constituentTypes.end());
 
     ETSUnionType::NormalizeTypes(Relation(), newConstituentTypes);
     if (newConstituentTypes.size() == 1) {
         return newConstituentTypes[0];
     }
-    auto *un = ProgramAllocator()->New<ETSUnionType>(this, std::move(newConstituentTypes));
+    auto *un = Allocator()->New<ETSUnionType>(this, std::move(newConstituentTypes));
     auto ut = un->GetAssemblerType().Mutf8();
     if (std::count_if(ut.begin(), ut.end(), [](char c) { return c == ','; }) > 0) {
         unionAssemblerTypes_.insert(un->GetAssemblerType());
@@ -175,17 +175,17 @@ Type *ETSChecker::CreateETSUnionType(Span<Type *const> constituentTypes)
 ETSTypeAliasType *ETSChecker::CreateETSTypeAliasType(util::StringView name, const ir::AstNode *declNode,
                                                      bool isRecursive)
 {
-    return ProgramAllocator()->New<ETSTypeAliasType>(this, name, declNode, isRecursive);
+    return Allocator()->New<ETSTypeAliasType>(this, name, declNode, isRecursive);
 }
 
 ETSFunctionType *ETSChecker::CreateETSArrowType(Signature *signature)
 {
-    return ProgramAllocator()->New<ETSFunctionType>(this, signature);
+    return Allocator()->New<ETSFunctionType>(this, signature);
 }
 
 ETSFunctionType *ETSChecker::CreateETSMethodType(util::StringView name, ArenaVector<Signature *> &&signatures)
 {
-    return ProgramAllocator()->New<ETSFunctionType>(this, name, std::move(signatures));
+    return Allocator()->New<ETSFunctionType>(this, name, std::move(signatures));
 }
 
 static SignatureFlags ConvertToSignatureFlags(ir::ModifierFlags inModifiers, ir::ScriptFunctionFlags inFunctionFlags)
@@ -225,7 +225,7 @@ Signature *ETSChecker::CreateSignature(SignatureInfo *info, Type *returnType, ir
         ES2PANDA_ASSERT(IsAnyError());
         return nullptr;
     }
-    auto signature = ProgramAllocator()->New<Signature>(info, returnType, func);
+    auto signature = Allocator()->New<Signature>(info, returnType, func);
     auto convertedFlag = ConvertToSignatureFlags(func->Modifiers(), func->Flags());
     ES2PANDA_ASSERT(signature != nullptr);
     func->HasReceiver() ? signature->AddSignatureFlag(SignatureFlags::EXTENSION_FUNCTION | convertedFlag)
@@ -240,7 +240,7 @@ Signature *ETSChecker::CreateSignature(SignatureInfo *info, Type *returnType, ir
         ES2PANDA_ASSERT(IsAnyError());
         return nullptr;
     }
-    auto signature = ProgramAllocator()->New<Signature>(info, returnType, nullptr);
+    auto signature = Allocator()->New<Signature>(info, returnType, nullptr);
     ES2PANDA_ASSERT(signature != nullptr);
     signature->AddSignatureFlag(ConvertToSignatureFlags(ir::ModifierFlags::NONE, sff));
     // synthetic arrow type signature flags
@@ -252,18 +252,18 @@ Signature *ETSChecker::CreateSignature(SignatureInfo *info, Type *returnType, ir
 
 SignatureInfo *ETSChecker::CreateSignatureInfo()
 {
-    return ProgramAllocator()->New<SignatureInfo>(ProgramAllocator());
+    return Allocator()->New<SignatureInfo>(Allocator());
 }
 
 ETSTypeParameter *ETSChecker::CreateTypeParameter()
 {
-    return ProgramAllocator()->New<ETSTypeParameter>();
+    return Allocator()->New<ETSTypeParameter>();
 }
 
 ETSExtensionFuncHelperType *ETSChecker::CreateETSExtensionFuncHelperType(ETSFunctionType *classMethodType,
                                                                          ETSFunctionType *extensionFunctionType)
 {
-    return ProgramAllocator()->New<ETSExtensionFuncHelperType>(classMethodType, extensionFunctionType);
+    return Allocator()->New<ETSExtensionFuncHelperType>(classMethodType, extensionFunctionType);
 }
 
 static std::pair<util::StringView, util::StringView> GetObjectTypeDeclNames(ir::AstNode *node)
@@ -293,7 +293,7 @@ static ETSObjectType *InitializeGlobalBuiltinObjectType(ETSChecker *checker, Glo
         return slot;
     };
 
-    auto *const programAllocator = checker->ProgramAllocator();
+    auto *const programAllocator = checker->Allocator();
 
     switch (globalId) {
         case GlobalTypeId::ETS_OBJECT_BUILTIN: {
@@ -373,19 +373,17 @@ ETSObjectType *ETSChecker::CreateETSObjectType(ir::AstNode *declNode, ETSObjectF
     ETSObjectType *objectType = nullptr;
     if (declNode->IsClassDefinition() && (declNode->AsClassDefinition()->IsEnumTransformed())) {
         if (declNode->AsClassDefinition()->IsIntEnumTransformed()) {
-            objectType =
-                ProgramAllocator()->New<ETSIntEnumType>(ProgramAllocator(), name, internalName, declNode, Relation());
+            objectType = Allocator()->New<ETSIntEnumType>(Allocator(), name, internalName, declNode, Relation());
         } else {
             ES2PANDA_ASSERT(declNode->AsClassDefinition()->IsStringEnumTransformed());
-            objectType = ProgramAllocator()->New<ETSStringEnumType>(ProgramAllocator(), name, internalName, declNode,
-                                                                    Relation());
+            objectType = Allocator()->New<ETSStringEnumType>(Allocator(), name, internalName, declNode, Relation());
         }
     } else if (internalName == compiler::Signatures::BUILTIN_ARRAY) {
-        objectType = ProgramAllocator()->New<ETSResizableArrayType>(ProgramAllocator(), name,
-                                                                    std::make_tuple(declNode, flags, Relation()));
+        objectType =
+            Allocator()->New<ETSResizableArrayType>(Allocator(), name, std::make_tuple(declNode, flags, Relation()));
     } else {
-        objectType = ProgramAllocator()->New<ETSObjectType>(ProgramAllocator(), name, internalName,
-                                                            std::make_tuple(declNode, flags, Relation()));
+        objectType = Allocator()->New<ETSObjectType>(Allocator(), name, internalName,
+                                                     std::make_tuple(declNode, flags, Relation()));
     }
     return objectType;
 }
@@ -403,9 +401,9 @@ std::tuple<util::StringView, SignatureInfo *> ETSChecker::CreateBuiltinArraySign
     info->minArgCount = dim;
 
     for (size_t i = 0; i < dim; i++) {
-        util::UString param(std::to_string(i), ProgramAllocator());
+        util::UString param(std::to_string(i), Allocator());
         auto *paramVar =
-            varbinder::Scope::CreateVar(ProgramAllocator(), param.View(), varbinder::VariableFlags::NONE, nullptr);
+            varbinder::Scope::CreateVar(Allocator(), param.View(), varbinder::VariableFlags::NONE, nullptr);
         ES2PANDA_ASSERT(paramVar != nullptr);
         paramVar->SetTsType(GlobalIntType());
 
@@ -416,7 +414,7 @@ std::tuple<util::StringView, SignatureInfo *> ETSChecker::CreateBuiltinArraySign
 
     ss << compiler::Signatures::MANGLE_SEPARATOR << compiler::Signatures::PRIMITIVE_VOID
        << compiler::Signatures::MANGLE_SEPARATOR;
-    auto internalName = util::UString(ss.str(), ProgramAllocator()).View();
+    auto internalName = util::UString(ss.str(), Allocator()).View();
 
     return {internalName, info};
 }
@@ -487,7 +485,7 @@ void ETSChecker::ProcessTypeMembers(ETSObjectType *type, ArenaVector<Type *> &li
 
 Type *ETSChecker::CreateUnionFromKeyofType(ETSObjectType *const type)
 {
-    ArenaVector<Type *> stringLiterals(ProgramAllocator()->Adapter());
+    ArenaVector<Type *> stringLiterals(Allocator()->Adapter());
     std::deque<ETSObjectType *> superTypes;
     superTypes.push_back(type);
     auto enqueueSupers = [&](ETSObjectType *currentType) {
@@ -512,13 +510,13 @@ Type *ETSChecker::CreateUnionFromKeyofType(ETSObjectType *const type)
 
 ETSAsyncFuncReturnType *ETSChecker::CreateETSAsyncFuncReturnTypeFromPromiseType(ETSObjectType *promiseType)
 {
-    return ProgramAllocator()->New<ETSAsyncFuncReturnType>(ProgramAllocator(), Relation(), promiseType);
+    return Allocator()->New<ETSAsyncFuncReturnType>(Allocator(), Relation(), promiseType);
 }
 
 ETSAsyncFuncReturnType *ETSChecker::CreateETSAsyncFuncReturnTypeFromBaseType(Type *baseType)
 {
     auto const promiseType = CreatePromiseOf(MaybeBoxType(baseType));
-    return ProgramAllocator()->New<ETSAsyncFuncReturnType>(ProgramAllocator(), Relation(), promiseType);
+    return Allocator()->New<ETSAsyncFuncReturnType>(Allocator(), Relation(), promiseType);
 }
 
 }  // namespace ark::es2panda::checker
diff --git a/ets2panda/checker/ets/utilityTypeHandlers.cpp b/ets2panda/checker/ets/utilityTypeHandlers.cpp
index a1f0cd3f142dd13f792809a60b1ce824c72eaa8e..6ae9c67c78a92e98db93cdb4b8e1d2f4a2ca9a4f 100644
--- a/ets2panda/checker/ets/utilityTypeHandlers.cpp
+++ b/ets2panda/checker/ets/utilityTypeHandlers.cpp
@@ -237,7 +237,7 @@ Type *ETSChecker::CreatePartialType(Type *const typeToBePartial)
 
 Type *ETSChecker::CreatePartialTypeParameter(ETSTypeParameter *typeToBePartial)
 {
-    return ProgramAllocator()->New<ETSPartialTypeParameter>(typeToBePartial, this);
+    return Allocator()->New<ETSPartialTypeParameter>(typeToBePartial, this);
 }
 
 Type *ETSChecker::CreatePartialTypeClass(ETSObjectType *typeToBePartial, ir::AstNode *typeDeclNode)
@@ -644,7 +644,7 @@ static void SetupFunctionParams(ir::ScriptFunction *function, varbinder::Functio
             paramExpr->Ident()->SetTsTypeAnnotation(unionType);
             unionType->SetParent(paramExpr->Ident());
         }
-        auto [paramVar, node] = paramScope->AddParamDecl(checker->ProgramAllocator(), checker->VarBinder(), paramExpr);
+        auto [paramVar, node] = paramScope->AddParamDecl(checker->Allocator(), checker->VarBinder(), paramExpr);
         if (node != nullptr) {
             checker->VarBinder()->ThrowRedeclaration(node->Start(), paramVar->Name(), paramVar->Declaration()->Type());
         }
@@ -658,8 +658,8 @@ ir::MethodDefinition *ETSChecker::CreateNullishAccessor(ir::MethodDefinition *co
                                                         ir::TSInterfaceDeclaration *interface)
 {
     const auto interfaceCtx = varbinder::LexicalScope<varbinder::Scope>::Enter(VarBinder(), interface->Scope());
-    auto *paramScope = ProgramAllocator()->New<varbinder::FunctionParamScope>(ProgramAllocator(), interface->Scope());
-    auto *functionScope = ProgramAllocator()->New<varbinder::FunctionScope>(ProgramAllocator(), paramScope);
+    auto *paramScope = Allocator()->New<varbinder::FunctionParamScope>(Allocator(), interface->Scope());
+    auto *functionScope = Allocator()->New<varbinder::FunctionScope>(Allocator(), paramScope);
     ES2PANDA_ASSERT(functionScope != nullptr);
     functionScope->BindParamScope(paramScope);
     paramScope->BindFunctionScope(functionScope);
@@ -672,9 +672,8 @@ ir::MethodDefinition *ETSChecker::CreateNullishAccessor(ir::MethodDefinition *co
     // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
     ir::MethodDefinition *nullishAccessor = accessor->Clone(ProgramAllocator(), interface->Body());
 
-    auto *decl = ProgramAllocator()->New<varbinder::FunctionDecl>(ProgramAllocator(), nullishAccessor->Id()->Name(),
-                                                                  nullishAccessor);
-    auto *var = ProgramAllocator()->New<varbinder::LocalVariable>(decl, varbinder::VariableFlags::VAR);
+    auto *decl = Allocator()->New<varbinder::FunctionDecl>(Allocator(), nullishAccessor->Id()->Name(), nullishAccessor);
+    auto *var = Allocator()->New<varbinder::LocalVariable>(decl, varbinder::VariableFlags::VAR);
     var->AddFlag(varbinder::VariableFlags::METHOD);
     nullishAccessor->Id()->SetVariable(var);
     nullishAccessor->SetVariable(var);
@@ -718,8 +717,8 @@ ir::TSInterfaceDeclaration *ETSChecker::CreateInterfaceProto(util::StringView na
 
     // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
     auto *const interfaceId = ProgramAllocNode<ir::Identifier>(name, ProgramAllocator());
-    const auto [decl, var] = VarBinder()->NewVarDecl<varbinder::InterfaceDecl>(interfaceId->Start(), ProgramAllocator(),
-                                                                               interfaceId->Name());
+    const auto [decl, var] =
+        VarBinder()->NewVarDecl<varbinder::InterfaceDecl>(interfaceId->Start(), Allocator(), interfaceId->Name());
     ES2PANDA_ASSERT(interfaceId != nullptr);
     interfaceId->SetVariable(var);
 
@@ -819,7 +818,7 @@ Type *ETSChecker::CreatePartialTypeInterfaceDecl(ir::TSInterfaceDeclaration *con
     // Create nullish properties of the partial class
     // Build the new Partial class based on the 'T' type parameter of 'Partial<T>'
     auto *likeSubstitution =
-        ProgramAllocator()->New<ArenaMap<ir::TSTypeParameter *, ir::TSTypeParameter *>>(ProgramAllocator()->Adapter());
+        Allocator()->New<ArenaMap<ir::TSTypeParameter *, ir::TSTypeParameter *>>(Allocator()->Adapter());
 
     if (interfaceDecl->TypeParams() != nullptr) {
         // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
@@ -835,9 +834,9 @@ Type *ETSChecker::CreatePartialTypeInterfaceDecl(ir::TSInterfaceDeclaration *con
         auto *func = prop->AsMethodDefinition()->Function();
         ES2PANDA_ASSERT(func != nullptr);
         if (prop->IsMethodDefinition() && func->IsGetter()) {
-            auto *decl = ProgramAllocator()->New<varbinder::FunctionDecl>(
-                ProgramAllocator(), prop->AsMethodDefinition()->Key()->AsIdentifier()->Name(), prop);
-            methodscope->AddDecl(ProgramAllocator(), decl, ScriptExtension::ETS);
+            auto *decl = Allocator()->New<varbinder::FunctionDecl>(
+                Allocator(), prop->AsMethodDefinition()->Key()->AsIdentifier()->Name(), prop);
+            methodscope->AddDecl(Allocator(), decl, ScriptExtension::ETS);
         }
     }
 
@@ -888,8 +887,8 @@ void ETSChecker::CreateConstructorForPartialType(ir::ClassDefinition *const part
     partialType->AddConstructSignature(ctorFunc->Signature());
     ctorFunc->Signature()->SetOwner(partialType);
     ctor->SetParent(partialClassDef);
-    ctorId->SetVariable(ProgramAllocator()->New<varbinder::LocalVariable>(
-        ProgramAllocator()->New<varbinder::MethodDecl>(ctorId->Name()), varbinder::VariableFlags::METHOD));
+    ctorId->SetVariable(Allocator()->New<varbinder::LocalVariable>(
+        Allocator()->New<varbinder::MethodDecl>(ctorId->Name()), varbinder::VariableFlags::METHOD));
     ctor->Id()->SetVariable(ctorId->Variable());
 
     // Put ctor in partial class body
@@ -961,7 +960,7 @@ Type *ETSChecker::HandleUnionForPartialType(ETSUnionType *const typeToBePartial)
     // Convert a union type to partial, by converting all types in it to partial, and making a new union
     // type out of them
     const auto *const unionTypeNode = typeToBePartial->AsETSUnionType();
-    ArenaVector<checker::Type *> newTypesForUnion(ProgramAllocator()->Adapter());
+    ArenaVector<checker::Type *> newTypesForUnion(Allocator()->Adapter());
 
     for (auto *const typeFromUnion : unionTypeNode->ConstituentTypes()) {
         if ((typeFromUnion->Variable() != nullptr) && (typeFromUnion->Variable()->Declaration() != nullptr)) {
@@ -1052,8 +1051,8 @@ ir::MethodDefinition *ETSChecker::CreateNonStaticClassInitializer(varbinder::Cla
 {
     const auto classCtx = varbinder::LexicalScope<varbinder::ClassScope>::Enter(VarBinder(), classScope);
 
-    auto *paramScope = ProgramAllocator()->New<varbinder::FunctionParamScope>(ProgramAllocator(), classScope);
-    auto *const functionScope = ProgramAllocator()->New<varbinder::FunctionScope>(ProgramAllocator(), paramScope);
+    auto *paramScope = Allocator()->New<varbinder::FunctionParamScope>(Allocator(), classScope);
+    auto *const functionScope = Allocator()->New<varbinder::FunctionScope>(Allocator(), paramScope);
     functionScope->BindParamScope(paramScope);
     paramScope->BindFunctionScope(functionScope);
 
@@ -1082,7 +1081,7 @@ ir::MethodDefinition *ETSChecker::CreateNonStaticClassInitializer(varbinder::Cla
                                                id->Clone(ProgramAllocator(), classScope->Node()), funcExpr,
                                                ir::ModifierFlags::NONE, ProgramAllocator(), false);
 
-    auto *const funcType = CreateETSMethodType(id->Name(), {{signature}, ProgramAllocator()->Adapter()});
+    auto *const funcType = CreateETSMethodType(id->Name(), {{signature}, Allocator()->Adapter()});
     ctor->SetTsType(funcType);
 
     return ctor;
@@ -1097,8 +1096,7 @@ Type *ETSChecker::GetReadonlyType(Type *type)
     NamedTypeStackElement ntse(this, type);
     ES2PANDA_ASSERT(type != nullptr);
     if (type->IsETSArrayType()) {
-        ETSArrayType *const clonedArrayType =
-            ProgramAllocator()->New<ETSArrayType>(type->AsETSArrayType()->ElementType());
+        ETSArrayType *const clonedArrayType = Allocator()->New<ETSArrayType>(type->AsETSArrayType()->ElementType());
         ES2PANDA_ASSERT(clonedArrayType != nullptr);
         clonedArrayType->AddTypeFlag(TypeFlag::READONLY);
         return clonedArrayType;
@@ -1116,10 +1114,10 @@ Type *ETSChecker::GetReadonlyType(Type *type)
         return clonedType;
     }
     if (type->IsETSTypeParameter()) {
-        return ProgramAllocator()->New<ETSReadonlyType>(type->AsETSTypeParameter());
+        return Allocator()->New<ETSReadonlyType>(type->AsETSTypeParameter());
     }
     if (type->IsETSUnionType()) {
-        ArenaVector<Type *> unionTypes(ProgramAllocator()->Adapter());
+        ArenaVector<Type *> unionTypes(Allocator()->Adapter());
         for (auto *t : type->AsETSUnionType()->ConstituentTypes()) {
             unionTypes.emplace_back(t->IsETSObjectType() ? GetReadonlyType(t) : t->Clone(this));
         }
@@ -1131,8 +1129,7 @@ Type *ETSChecker::GetReadonlyType(Type *type)
 void ETSChecker::MakePropertiesReadonly(ETSObjectType *const classType)
 {
     classType->UpdateTypeProperties([this](auto *property, auto *propType) {
-        auto *newDecl =
-            ProgramAllocator()->New<varbinder::ReadonlyDecl>(property->Name(), property->Declaration()->Node());
+        auto *newDecl = Allocator()->New<varbinder::ReadonlyDecl>(property->Name(), property->Declaration()->Node());
         auto *const propCopy = property->Copy(ProgramAllocator(), newDecl);
         propCopy->AddFlag(varbinder::VariableFlags::READONLY);
         propCopy->SetTsType(propType);
@@ -1158,7 +1155,7 @@ Type *ETSChecker::HandleRequiredType(Type *typeToBeRequired)
     }
 
     if (typeToBeRequired->IsETSUnionType()) {
-        ArenaVector<Type *> unionTypes(ProgramAllocator()->Adapter());
+        ArenaVector<Type *> unionTypes(Allocator()->Adapter());
         for (auto *type : typeToBeRequired->AsETSUnionType()->ConstituentTypes()) {
             if (type->IsETSObjectType()) {
                 type = type->Clone(this);
diff --git a/ets2panda/checker/types/ets/etsFunctionType.cpp b/ets2panda/checker/types/ets/etsFunctionType.cpp
index 2a963cb7376fdc0ce957b0575b2f83dad1e79a5b..1eb12d4a7f06dbff645de2c457142356cca5212f 100644
--- a/ets2panda/checker/types/ets/etsFunctionType.cpp
+++ b/ets2panda/checker/types/ets/etsFunctionType.cpp
@@ -23,8 +23,8 @@ ETSFunctionType::ETSFunctionType([[maybe_unused]] ETSChecker *checker, util::Str
                                  ArenaVector<Signature *> &&signatures)
     : Type(TypeFlag::FUNCTION | TypeFlag::ETS_METHOD),
       callSignatures_(std::move(signatures)),
-      extensionFunctionSigs_(ArenaVector<Signature *>(checker->ProgramAllocator()->Adapter())),
-      extensionAccessorSigs_(ArenaVector<Signature *>(checker->ProgramAllocator()->Adapter())),
+      extensionFunctionSigs_(ArenaVector<Signature *>(checker->Allocator()->Adapter())),
+      extensionAccessorSigs_(ArenaVector<Signature *>(checker->Allocator()->Adapter())),
       name_(name)
 {
     auto flag = TypeFlag::NONE;
@@ -42,9 +42,9 @@ ETSFunctionType::ETSFunctionType([[maybe_unused]] ETSChecker *checker, util::Str
 
 ETSFunctionType::ETSFunctionType(ETSChecker *checker, Signature *signature)
     : Type(TypeFlag::FUNCTION),
-      callSignatures_({{signature->ToArrowSignature(checker)}, checker->ProgramAllocator()->Adapter()}),
-      extensionFunctionSigs_(ArenaVector<Signature *>(checker->ProgramAllocator()->Adapter())),
-      extensionAccessorSigs_(ArenaVector<Signature *>(checker->ProgramAllocator()->Adapter())),
+      callSignatures_({{signature->ToArrowSignature(checker)}, checker->Allocator()->Adapter()}),
+      extensionFunctionSigs_(ArenaVector<Signature *>(checker->Allocator()->Adapter())),
+      extensionAccessorSigs_(ArenaVector<Signature *>(checker->Allocator()->Adapter())),
       name_(""),
       assemblerName_(checker->GlobalBuiltinFunctionType(signature->MinArgCount(), signature->HasRestParameter()) !=
                              nullptr
@@ -312,7 +312,7 @@ ETSFunctionType *ETSFunctionType::Substitute(TypeRelation *relation, const Subst
 {
     if (substitution != nullptr && !substitution->empty()) {
         auto *const checker = relation->GetChecker()->AsETSChecker();
-        auto *const allocator = checker->ProgramAllocator();
+        auto *const allocator = checker->Allocator();
 
         auto signatures = ArenaVector<Signature *>(allocator->Adapter());
         bool anyChange = false;
diff --git a/ets2panda/checker/types/ets/etsTupleType.cpp b/ets2panda/checker/types/ets/etsTupleType.cpp
index 38930b20a3a519e024ff6bba7b36b785e0619191..b271d6af7a1a7ccd3a49d334b37897837d9643e6 100644
--- a/ets2panda/checker/types/ets/etsTupleType.cpp
+++ b/ets2panda/checker/types/ets/etsTupleType.cpp
@@ -125,13 +125,13 @@ void ETSTupleType::AssignmentTarget(TypeRelation *const relation, Type *const so
 Type *ETSTupleType::Substitute(TypeRelation *relation, const Substitution *substitution)
 {
     auto *const checker = relation->GetChecker()->AsETSChecker();
-    ArenaVector<Type *> newTypeList(checker->ProgramAllocator()->Adapter());
+    ArenaVector<Type *> newTypeList(checker->Allocator()->Adapter());
 
     for (auto *const tupleTypeListElement : GetTupleTypesList()) {
         newTypeList.emplace_back(tupleTypeListElement->Substitute(relation, substitution));
     }
 
-    return checker->ProgramAllocator()->New<ETSTupleType>(checker, std::move(newTypeList));
+    return checker->Allocator()->New<ETSTupleType>(checker, std::move(newTypeList));
 }
 
 void ETSTupleType::IsSubtypeOf(TypeRelation *const relation, Type *target)
diff --git a/ets2panda/checker/types/ets/etsUnionType.cpp b/ets2panda/checker/types/ets/etsUnionType.cpp
index 97b5f76d8bd976d910878cb9f7089e0866f5bf64..65e15155111ec899db378d182433c6c8d65c35a4 100644
--- a/ets2panda/checker/types/ets/etsUnionType.cpp
+++ b/ets2panda/checker/types/ets/etsUnionType.cpp
@@ -81,7 +81,7 @@ void ETSUnionType::InitAssemblerTypeCache(ETSChecker *checker)
         }
         ss << "}";
     }
-    assemblerTypeCache_ = util::UString(ss.str(), checker->ProgramAllocator()).View();
+    assemblerTypeCache_ = util::UString(ss.str(), checker->Allocator()).View();
 }
 
 void ETSUnionType::CanonicalizedAssemblerType(ETSChecker *checker)
@@ -136,7 +136,7 @@ void ETSUnionType::CanonicalizedAssemblerType(ETSChecker *checker)
 ETSUnionType::ETSUnionType(ETSChecker *checker, ArenaVector<Type *> &&constituentTypes)
     : Type(TypeFlag::ETS_UNION),
       constituentTypes_(std::move(constituentTypes)),
-      assemblerConstituentTypes_(checker->ProgramAllocator()->Adapter())
+      assemblerConstituentTypes_(checker->Allocator()->Adapter())
 {
     ES2PANDA_ASSERT(constituentTypes_.size() > 1);
     CanonicalizedAssemblerType(checker);
diff --git a/ets2panda/checker/types/signature.cpp b/ets2panda/checker/types/signature.cpp
index 0aaeab306651b74f0c87a99d36bc33cd095b239f..14ddbef3d3765735912b0be1fe47fac9915b6cfb 100644
--- a/ets2panda/checker/types/signature.cpp
+++ b/ets2panda/checker/types/signature.cpp
@@ -32,7 +32,7 @@ Signature *Signature::Substitute(TypeRelation *relation, const Substitution *sub
         return this;
     }
     auto *checker = relation->GetChecker()->AsETSChecker();
-    auto *allocator = checker->ProgramAllocator();
+    auto *allocator = checker->Allocator();
     bool anyChange = false;
     SignatureInfo *newSigInfo = allocator->New<SignatureInfo>(allocator);
     ES2PANDA_ASSERT(newSigInfo != nullptr);
@@ -287,7 +287,7 @@ void Signature::AssignmentTarget([[maybe_unused]] TypeRelation *relation, [[mayb
 
 Signature *Signature::ToArrowSignature(ETSChecker *checker)
 {
-    auto *allocator = checker->ProgramAllocator();
+    auto *allocator = checker->Allocator();
     auto *sigInfo = allocator->New<SignatureInfo>(signatureInfo_, allocator);
     ES2PANDA_ASSERT(sigInfo != nullptr);
     for (auto param : sigInfo->params) {
diff --git a/ets2panda/checker/types/type.cpp b/ets2panda/checker/types/type.cpp
index 694499259016b06b0bea17986aa1a3dc766f89e3..10a458cec1b8a4680a12952ccda130c095fa5250 100644
--- a/ets2panda/checker/types/type.cpp
+++ b/ets2panda/checker/types/type.cpp
@@ -154,7 +154,7 @@ Type *Type::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unus
 
 Type *Type::Clone(Checker *const checker)
 {
-    return Instantiate(checker->ProgramAllocator(), checker->Relation(), checker->GetGlobalTypesHolder());
+    return Instantiate(checker->Allocator(), checker->Relation(), checker->GetGlobalTypesHolder());
 }
 
 Type *Type::Substitute([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Substitution *substitution)
diff --git a/ets2panda/checker/types/typeRelation.cpp b/ets2panda/checker/types/typeRelation.cpp
index c4b2fbb0869b7b727e396bd6b0eafb50eb559609..2ceb74853520a13eec49f249c6d94a7bbe726e32 100644
--- a/ets2panda/checker/types/typeRelation.cpp
+++ b/ets2panda/checker/types/typeRelation.cpp
@@ -23,7 +23,7 @@
 namespace ark::es2panda::checker {
 ArenaAllocator *TypeRelation::Allocator()
 {
-    return checker_->ProgramAllocator();
+    return checker_->Allocator();
 }
 
 RelationResult TypeRelation::CacheLookup(const Type *source, const Type *target, const RelationHolder &holder,
diff --git a/ets2panda/compiler/core/compilerImpl.cpp b/ets2panda/compiler/core/compilerImpl.cpp
index 539573f68cef867f68908e67f72726a508a3e1dd..2a613e937d7f8c53934670ae58d6037a7cf77242 100644
--- a/ets2panda/compiler/core/compilerImpl.cpp
+++ b/ets2panda/compiler/core/compilerImpl.cpp
@@ -395,7 +395,6 @@ static pandasm::Program *ClearContextAndReturnProgam(public_lib::Context *contex
 {
     context->config = nullptr;
     context->parser = nullptr;
-    context->ClearCheckers();
     context->ClearAnalyzers();
     context->phaseManager = nullptr;
     context->parserProgram = nullptr;
@@ -423,9 +422,8 @@ static pandasm::Program *Compile(const CompilationUnit &unit, CompilerImpl *comp
         Parser(&program, unit.options, unit.diagnosticEngine, static_cast<parser::ParserStatus>(unit.rawParserStatus));
     context->parser = &parser;
     parser.SetContext(context);
-    auto checker = Checker(context->allocator, unit.diagnosticEngine, context->allocator);
     context->parserProgram = &program;
-    context->PushChecker(&checker);
+    Checker &checker = *(static_cast<Checker *>(context->CreateChecker<Checker>(unit.diagnosticEngine)));
     auto analyzer = Analyzer(&checker);
     checker.SetAnalyzer(&analyzer);
     context->PushAnalyzer(checker.GetAnalyzer());
diff --git a/ets2panda/compiler/lowering/util.cpp b/ets2panda/compiler/lowering/util.cpp
index 84e9ccb559117e1aae09adbe17912d061a0cd87c..f2fc5071c25e2b710a8b9d294f829c32d3436bec 100644
--- a/ets2panda/compiler/lowering/util.cpp
+++ b/ets2panda/compiler/lowering/util.cpp
@@ -259,20 +259,12 @@ void Recheck(PhaseManager *phaseManager, varbinder::ETSBinder *varBinder, checke
 
         ClearHelper(program);
 
-        auto newChecker =
-            ctx->allocator->New<checker::ETSChecker>(ctx->allocator, *ctx->diagnosticEngine, ctx->allocator);
+        auto newChecker = ctx->CreateChecker<checker::ETSChecker>(*ctx->diagnosticEngine);
         auto analyzer = ctx->allocator->New<checker::ETSAnalyzer>(newChecker);
 
         ctx->PushAnalyzer(analyzer);
         newChecker->SetAnalyzer(analyzer);
         newChecker->Initialize(newVarbinder);
-        ctx->PushChecker(newChecker);
-        for (auto [_, program_list] : program->ExternalSources()) {
-            if (auto prog = program_list.front(); prog->IsASTLowered()) {
-                newChecker->SetGlobalTypesHolder(prog->Checker()->GetGlobalTypesHolder());
-                break;
-            }
-        }
 
         for (auto *phase : phaseManager->RecheckPhases()) {
             phase->Apply(ctx, program);
diff --git a/ets2panda/public/cppToCTypes.yaml b/ets2panda/public/cppToCTypes.yaml
index b65c6a310c6843706a28bd06990e9762fc79c01d..f7645d9bc072c8a419e1324cad8c71f52bf8576c 100644
--- a/ets2panda/public/cppToCTypes.yaml
+++ b/ets2panda/public/cppToCTypes.yaml
@@ -1984,7 +1984,7 @@ change_types:
       max_ptr_depth: 0
     new_args:
     cast:
-      expression: auto |es2panda_arg.type.ptr_depth||arg_name|E2p = *(reinterpret_cast<Context *>(context));
+      expression: auto &|es2panda_arg.type.ptr_depth||arg_name|E2p = *(reinterpret_cast<Context *>(context));
       var_name: '|arg_name|E2p'
 
   - es2panda_arg:
diff --git a/ets2panda/public/es2panda_lib.cpp b/ets2panda/public/es2panda_lib.cpp
index f9295c138b39925fae9abee5f58d562e4e0266a8..9ed9ae7473b01a5e50bbf539208052dc149790d2 100644
--- a/ets2panda/public/es2panda_lib.cpp
+++ b/ets2panda/public/es2panda_lib.cpp
@@ -347,7 +347,7 @@ static void InitializeContext(Context *res)
                                         parser::ParserStatus::NO_OPTS);
     res->parser->SetContext(res);
 
-    res->PushChecker(res->allocator->New<checker::ETSChecker>(res->allocator, *res->diagnosticEngine, res->allocator));
+    res->CreateChecker<checker::ETSChecker>(*res->diagnosticEngine);
     res->PushAnalyzer(res->allocator->New<checker::ETSAnalyzer>(res->GetChecker()));
     res->GetChecker()->SetAnalyzer(res->GetAnalyzer());
 
diff --git a/ets2panda/public/public.cpp b/ets2panda/public/public.cpp
index c946299fed9258dbaf13770b1708ef1cd0db42a7..bf54dede6f1db9c54290b212e9eed7fc42672cf3 100644
--- a/ets2panda/public/public.cpp
+++ b/ets2panda/public/public.cpp
@@ -20,7 +20,7 @@ namespace ark::es2panda::public_lib {
 
 checker::Checker *Context::GetChecker() const
 {
-    return checkers_[compiler::GetPhaseManager()->GetCurrentMajor()];
+    return checker_.get();
 }
 
 checker::SemanticAnalyzer *Context::GetAnalyzer() const
diff --git a/ets2panda/public/public.h b/ets2panda/public/public.h
index 72c7553a18454f2d47da38885160feb121da5090..6758ff4f0b5517dbcc716300b53e798f5835baa0 100644
--- a/ets2panda/public/public.h
+++ b/ets2panda/public/public.h
@@ -170,16 +170,12 @@ struct Context {
 
     checker::Checker *GetChecker() const;
 
-    void PushChecker(checker::Checker *checker)
+    template <typename Checker>
+    checker::Checker *CreateChecker(util::DiagnosticEngine &diagEngine)
     {
-        parserProgram->PushChecker(checker);
-        checkers_.push_back(checker);
-    }
-
-    // NOTE(zhelyapov): It's calling side responsibility to release resources
-    void ClearCheckers()
-    {
-        checkers_.clear();
+        checker_ = std::make_unique<Checker>(diagEngine);
+        parserProgram->PushChecker(checker_.get());
+        return checker_.get();
     }
 
     checker::SemanticAnalyzer *GetAnalyzer() const;
@@ -237,7 +233,7 @@ struct Context {
     // NOLINTEND(misc-non-private-member-variables-in-classes)
 
 private:
-    std::vector<checker::Checker *> checkers_;
+    std::unique_ptr<checker::Checker> checker_;
     std::vector<checker::SemanticAnalyzer *> analyzers_;
 };
 
diff --git a/ets2panda/test/unit/public/ast_verifier_check_abstract_call_test.cpp b/ets2panda/test/unit/public/ast_verifier_check_abstract_call_test.cpp
index 7814d7f261bf2ede5137cefe7217592859b56161..53fd11d16ff44bd0559e4c93c0a51e02761433c7 100644
--- a/ets2panda/test/unit/public/ast_verifier_check_abstract_call_test.cpp
+++ b/ets2panda/test/unit/public/ast_verifier_check_abstract_call_test.cpp
@@ -33,7 +33,7 @@ namespace {
 TEST_F(ASTVerifierTest, LabelsHaveReferences)
 {
     ark::es2panda::util::DiagnosticEngine de;
-    ark::es2panda::checker::ETSChecker checker {Allocator(), de};
+    ark::es2panda::checker::ETSChecker checker {de};
 
     char const *text = R"(
         abstract class A {
diff --git a/ets2panda/test/unit/public/ast_verifier_check_const_properties_test.cpp b/ets2panda/test/unit/public/ast_verifier_check_const_properties_test.cpp
index 2652cdfe6fe8bd1e178704da2bde225731af52f2..6655e802ee44502e223c81e1f5541bee06bc6664 100644
--- a/ets2panda/test/unit/public/ast_verifier_check_const_properties_test.cpp
+++ b/ets2panda/test/unit/public/ast_verifier_check_const_properties_test.cpp
@@ -26,7 +26,7 @@ namespace {
 TEST_F(ASTVerifierTest, CheckConstProperties)
 {
     ark::es2panda::util::DiagnosticEngine de {};
-    ark::es2panda::checker::ETSChecker checker {Allocator(), de};
+    ark::es2panda::checker::ETSChecker checker {de};
 
     char const *text = R"(
         class Test
@@ -57,4 +57,4 @@ TEST_F(ASTVerifierTest, CheckConstProperties)
     }
 }
 
-}  // namespace
\ No newline at end of file
+}  // namespace
diff --git a/ets2panda/test/unit/public/ast_verifier_getter_setter_neg_test.cpp b/ets2panda/test/unit/public/ast_verifier_getter_setter_neg_test.cpp
index 651b6ab840ed182055a63a6627d43f64c3f841db..8e6145492b319d8984501fc055af7d24322d61f4 100644
--- a/ets2panda/test/unit/public/ast_verifier_getter_setter_neg_test.cpp
+++ b/ets2panda/test/unit/public/ast_verifier_getter_setter_neg_test.cpp
@@ -29,7 +29,7 @@ namespace {
 TEST_F(ASTVerifierTest, ValidateGetterReturnTypeAnnotation)
 {
     DiagnosticEngine de {};
-    ETSChecker checker {Allocator(), de};
+    ETSChecker checker {de};
 
     char const *text =
         R"(
@@ -104,7 +104,7 @@ TEST_F(ASTVerifierTest, ValidateGetterHasReturnStatement)
 TEST_F(ASTVerifierTest, ValidateGetterVoidReturnStatement)
 {
     DiagnosticEngine de {};
-    ETSChecker checker {Allocator(), de};
+    ETSChecker checker {de};
 
     char const *text =
         R"(
@@ -142,7 +142,7 @@ TEST_F(ASTVerifierTest, ValidateGetterVoidReturnStatement)
 TEST_F(ASTVerifierTest, ValidateGetterArguments)
 {
     DiagnosticEngine de {};
-    ETSChecker checker {Allocator(), de};
+    ETSChecker checker {de};
 
     char const *text =
         R"(
@@ -184,7 +184,7 @@ TEST_F(ASTVerifierTest, ValidateGetterArguments)
 TEST_F(ASTVerifierTest, ValidateSetterReturnType)
 {
     DiagnosticEngine de {};
-    ETSChecker checker {Allocator(), de};
+    ETSChecker checker {de};
 
     char const *text =
         R"(
@@ -225,7 +225,7 @@ TEST_F(ASTVerifierTest, ValidateSetterReturnType)
 TEST_F(ASTVerifierTest, ValidateSetterArguments)
 {
     DiagnosticEngine de {};
-    ETSChecker checker {Allocator(), de};
+    ETSChecker checker {de};
 
     char const *text =
         R"(
diff --git a/ets2panda/test/unit/public/ast_verifier_getter_setter_test.cpp b/ets2panda/test/unit/public/ast_verifier_getter_setter_test.cpp
index 542d91ddf755197429d7945a23a9a83e8faa5785..7ee4731ed7ff27114ecf4f2338e56762487f4851 100644
--- a/ets2panda/test/unit/public/ast_verifier_getter_setter_test.cpp
+++ b/ets2panda/test/unit/public/ast_verifier_getter_setter_test.cpp
@@ -27,7 +27,7 @@ namespace {
 TEST_F(ASTVerifierTest, ValidateCorrectGetterSetter)
 {
     DiagnosticEngine de {};
-    ETSChecker checker {Allocator(), de};
+    ETSChecker checker {de};
 
     char const *text =
         R"(
@@ -52,7 +52,7 @@ TEST_F(ASTVerifierTest, ValidateCorrectGetterSetter)
 TEST_F(ASTVerifierTest, ValidateAbstractGettersSetters)
 {
     DiagnosticEngine de {};
-    ETSChecker checker {Allocator(), de};
+    ETSChecker checker {de};
 
     char const *text =
         R"(
@@ -72,7 +72,7 @@ TEST_F(ASTVerifierTest, ValidateAbstractGettersSetters)
 TEST_F(ASTVerifierTest, ValidateAmbientGettersSetters)
 {
     DiagnosticEngine de {};
-    ETSChecker checker {Allocator(), de};
+    ETSChecker checker {de};
 
     char const *text =
         R"(
diff --git a/ets2panda/test/unit/public/ast_verifier_short_test.cpp b/ets2panda/test/unit/public/ast_verifier_short_test.cpp
index 4a20d2a0540dbc26ed29e1649e1400191036df99..c5cf75fa2b30ab3ca9619ba20581f2c0e225b9f0 100644
--- a/ets2panda/test/unit/public/ast_verifier_short_test.cpp
+++ b/ets2panda/test/unit/public/ast_verifier_short_test.cpp
@@ -119,7 +119,7 @@ TEST_F(ASTVerifierTest, ScopeNodeTest)
 TEST_F(ASTVerifierTest, ArithmeticExpressionCorrect1)
 {
     DiagnosticEngine de {};
-    ETSChecker etschecker {Allocator(), de};
+    ETSChecker etschecker {de};
 
     auto left = NumberLiteral(Number {1});
     auto right = NumberLiteral(Number {6});
@@ -134,7 +134,7 @@ TEST_F(ASTVerifierTest, ArithmeticExpressionCorrect1)
 TEST_F(ASTVerifierTest, ArithmeticExpressionCorrect2)
 {
     DiagnosticEngine de {};
-    ETSChecker etschecker {Allocator(), de};
+    ETSChecker etschecker {de};
 
     constexpr uint32_t LEFT1_PARAM = 1;
     constexpr uint32_t LEFT2_PARAM = 12;
@@ -156,7 +156,7 @@ TEST_F(ASTVerifierTest, ArithmeticExpressionCorrect2)
 TEST_F(ASTVerifierTest, ArithmeticExpressionNegative1)
 {
     DiagnosticEngine de {};
-    ETSChecker etschecker {Allocator(), de};
+    ETSChecker etschecker {de};
 
     const StringView leftParam("1");
     constexpr uint32_t RIGHT_PARAM = 1;
@@ -174,7 +174,7 @@ TEST_F(ASTVerifierTest, ArithmeticExpressionNegative1)
 TEST_F(ASTVerifierTest, ArithmeticExpressionNegative2)
 {
     DiagnosticEngine de {};
-    ETSChecker etschecker {Allocator(), de};
+    ETSChecker etschecker {de};
 
     auto left = BooleanLiteral(true);
     auto right = NumberLiteral(Number {1});
@@ -190,7 +190,7 @@ TEST_F(ASTVerifierTest, ArithmeticExpressionNegative2)
 TEST_F(ASTVerifierTest, PrimitiveType)
 {
     DiagnosticEngine de {};
-    ETSChecker etschecker {Allocator(), de};
+    ETSChecker etschecker {de};
 
     auto ast = BooleanLiteral(true);
     ast.SetTsType(etschecker.CreateETSBooleanType(true));
@@ -204,7 +204,7 @@ TEST_F(ASTVerifierTest, PrimitiveType)
 TEST_F(ASTVerifierTest, SequenceExpressionType)
 {
     auto de = DiagnosticEngine();
-    auto checker = ETSChecker(Allocator(), de);
+    auto checker = ETSChecker(de);
     const auto literalsCount = 3;
     std::array<NumberLiteral, literalsCount> literals {NumberLiteral {Number {1}}, NumberLiteral {Number {2}},
                                                        NumberLiteral {Number {3}}};
diff --git a/ets2panda/test/unit/union_normalisation_test.h b/ets2panda/test/unit/union_normalisation_test.h
index 36b345f6c3940552772d8cb0cc84326e2ec7ed83..b90769bb900880b065ae71c371a763e0b1f51765 100644
--- a/ets2panda/test/unit/union_normalisation_test.h
+++ b/ets2panda/test/unit/union_normalisation_test.h
@@ -27,9 +27,9 @@ public:
         : allocator_(std::make_unique<ark::ThreadSafeArenaAllocator>(SpaceType::SPACE_TYPE_COMPILER, nullptr, true)),
           publicContext_ {std::make_unique<public_lib::Context>()},
           phaseManager_ {ScriptExtension::ETS, Allocator()},
-          program_ {parser::Program::NewProgram<varbinder::ETSBinder>(Allocator())},
-          checker_ {Allocator(), diagnosticEngine_}
+          program_ {parser::Program::NewProgram<varbinder::ETSBinder>(Allocator())}
     {
+        checker_ = publicContext_->CreateChecker<checker::ETSChecker>(diagnosticEngine_)->AsETSChecker();
     }
 
     ~UnionNormalizationTest() override = default;
@@ -52,7 +52,7 @@ public:
 
     checker::ETSChecker *Checker()
     {
-        return &checker_;
+        return checker_;
     }
 
     void InitializeChecker(std::string_view fileName, std::string_view src)
@@ -60,7 +60,7 @@ public:
         InitializeChecker<parser::ETSParser, varbinder::ETSBinder, checker::ETSChecker, checker::ETSAnalyzer,
                           compiler::ETSCompiler, compiler::ETSGen, compiler::StaticRegSpiller,
                           compiler::ETSFunctionEmitter, compiler::ETSEmitter>(
-            Span(test::utils::PandaExecutablePathGetter::Get()), fileName, src, &checker_, &program_);
+            Span(test::utils::PandaExecutablePathGetter::Get()), fileName, src, checker_, &program_);
     }
 
     template <typename CodeGen, typename RegSpiller, typename FunctionEmitter, typename Emitter, typename AstCompiler>
@@ -115,7 +115,6 @@ public:
         publicContext_->parser = &parser;
         parser.SetContext(publicContext_.get());
         publicContext_->parserProgram = program;
-        publicContext_->PushChecker(checker);
         publicContext_->PushAnalyzer(publicContext_->GetChecker()->GetAnalyzer());
         publicContext_->emitter = &emitter;
         publicContext_->diagnosticEngine = &diagnosticEngine_;
@@ -167,7 +166,7 @@ private:
     ark::es2panda::compiler::PhaseManager phaseManager_;
     parser::Program program_;
     util::DiagnosticEngine diagnosticEngine_;
-    checker::ETSChecker checker_;
+    checker::ETSChecker *checker_;
 };
 
 }  // namespace ark::es2panda::gtests
diff --git a/ets2panda/test/utils/checker_test.h b/ets2panda/test/utils/checker_test.h
index 69f1fbdee00b0144e41b12514131388ff45479b0..396ddc1607175e537aa78ac5eb3faeb53a007999 100644
--- a/ets2panda/test/utils/checker_test.h
+++ b/ets2panda/test/utils/checker_test.h
@@ -46,9 +46,9 @@ public:
           publicContext_ {std::make_unique<plib_alias::Context>()},
           phaseManager_ {ark::es2panda::ScriptExtension::ETS, Allocator()},
           program_ {parser_alias::Program::NewProgram<varbinder_alias::ETSBinder>(allocator_.get())},
-          es2pandaPath_ {PandaExecutablePathGetter::Get()[0]},
-          checker_(allocator_.get(), diagnosticEngine_)
+          es2pandaPath_ {PandaExecutablePathGetter::Get()[0]}
     {
+        checker_ = publicContext_->CreateChecker<checker_alias::ETSChecker>(diagnosticEngine_)->AsETSChecker();
     }
     ~CheckerTest() override = default;
     static void SetUpTestCase()
@@ -59,7 +59,7 @@ public:
 
     checker_alias::ETSChecker *Checker()
     {
-        return &checker_;
+        return checker_;
     }
 
     ark::ThreadSafeArenaAllocator *Allocator()
@@ -83,7 +83,7 @@ public:
         InitializeChecker<parser_alias::ETSParser, varbinder_alias::ETSBinder, checker_alias::ETSChecker,
                           checker_alias::ETSAnalyzer, compiler_alias::ETSCompiler, compiler_alias::ETSGen,
                           compiler_alias::StaticRegSpiller, compiler_alias::ETSFunctionEmitter,
-                          compiler_alias::ETSEmitter>(&es2pandaPathPtr, fileName, src, &checker_, &program_);
+                          compiler_alias::ETSEmitter>(&es2pandaPathPtr, fileName, src, checker_, &program_);
     }
 
     template <typename CustomFunc>
@@ -99,7 +99,7 @@ public:
                                             compiler_alias::ETSCompiler, compiler_alias::ETSGen,
                                             compiler_alias::StaticRegSpiller, compiler_alias::ETSFunctionEmitter,
                                             compiler_alias::ETSEmitter, CustomFunc>(&es2pandaPathPtr, fileName, src,
-                                                                                    &checker_, &program_, customFunc));
+                                                                                    checker_, &program_, customFunc));
     }
 
     template <typename CodeGen, typename RegSpiller, typename FunctionEmitter, typename Emitter, typename AstCompiler>
@@ -156,7 +156,6 @@ public:
         publicContext_->parser = &parser;
         parser.SetContext(publicContext_.get());
         publicContext_->parserProgram = program;
-        publicContext_->PushChecker(checker);
         publicContext_->PushAnalyzer(publicContext_->GetChecker()->GetAnalyzer());
         publicContext_->emitter = &emitter;
         publicContext_->diagnosticEngine = &diagnosticEngine_;
@@ -211,7 +210,6 @@ public:
         publicContext_->parser = &parser;
         parser.SetContext(publicContext_.get());
         publicContext_->parserProgram = program;
-        publicContext_->PushChecker(checker);
         publicContext_->PushAnalyzer(publicContext_->GetChecker()->GetAnalyzer());
         publicContext_->emitter = &emitter;
         publicContext_->diagnosticEngine = &diagnosticEngine_;
@@ -242,7 +240,7 @@ private:
     parser_alias::Program program_;
     std::string es2pandaPath_;
     util_alias::DiagnosticEngine diagnosticEngine_;
-    checker_alias::ETSChecker checker_;
+    checker_alias::ETSChecker *checker_;
 };
 
 }  // namespace test::utils