diff --git a/ets2panda/compiler/lowering/ets/declareOverloadLowering.cpp b/ets2panda/compiler/lowering/ets/declareOverloadLowering.cpp
index 434636afec6c75ad013f04bc2915bf7d502f22cd..c65dccccc6d3d4c2d39897303954f1810eb8b925 100644
--- a/ets2panda/compiler/lowering/ets/declareOverloadLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/declareOverloadLowering.cpp
@@ -49,6 +49,7 @@ void GenerateOverloadHelperParams(public_lib::Context *ctx, uint32_t minArg, siz
     spread->SetTsType(arr);
     restIdent->SetTsType(arr);
     auto *param = ctx->AllocNode<ir::ETSParameterExpression>(spread, nullptr, allocator);
+    ES2PANDA_ASSERT(param);
 
     restIdent->SetParent(spread);
     typeAnnotation->SetParent(spread);
@@ -84,6 +85,7 @@ void BuildOverloadHelperFunction(public_lib::Context *ctx, ir::MethodDefinition
                                                                 method->Modifiers(), allocator, false);
 
     method->AddOverload(helperOverload);
+    ES2PANDA_ASSERT(helperOverload->Function());
     helperOverload->Function()->ClearFlag((ir::ScriptFunctionFlags::OVERLOAD));
     helperOverload->SetParent(method);
 
diff --git a/ets2panda/compiler/lowering/ets/defaultParametersInConstructorLowering.cpp b/ets2panda/compiler/lowering/ets/defaultParametersInConstructorLowering.cpp
index 2c0f2d3203e92bcd6db09f41e05b383beb1bad7e..3b7466ef9f897a990ee8dd8fc993079a97ad7dc7 100644
--- a/ets2panda/compiler/lowering/ets/defaultParametersInConstructorLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/defaultParametersInConstructorLowering.cpp
@@ -63,6 +63,7 @@ static bool HasDefaultParameters(const ir::ScriptFunction *function, util::Diagn
 static ir::TSTypeParameterDeclaration *CreateParameterDeclaraion(ir::MethodDefinition *method, public_lib::Context *ctx)
 {
     auto const allocator = ctx->allocator;
+    ES2PANDA_ASSERT(method->Function());
     if (method->Function()->TypeParams() == nullptr || method->Function()->TypeParams()->Params().empty()) {
         return nullptr;
     }
@@ -90,6 +91,7 @@ static ir::FunctionSignature CreateFunctionSignature(ir::MethodDefinition *metho
     auto const allocator = ctx->allocator;
 
     ir::TSTypeParameterDeclaration *typeParamDecl = CreateParameterDeclaraion(method, ctx);
+    ES2PANDA_ASSERT(method->Function());
     auto *returnTypeAnnotation =
         method->Function()->ReturnTypeAnnotation() != nullptr
             ? method->Function()->ReturnTypeAnnotation()->Clone(allocator, nullptr)->AsTypeNode()
@@ -103,6 +105,7 @@ static ir::TSTypeParameterInstantiation *CreateTypeParameterInstantiation(ir::Me
 {
     auto const allocator = ctx->allocator;
 
+    ES2PANDA_ASSERT(method->Function());
     if (method->Function()->TypeParams() == nullptr || method->Function()->TypeParams()->Params().empty()) {
         return nullptr;
     }
@@ -130,6 +133,7 @@ static ir::BlockStatement *CreateFunctionBody(ir::MethodDefinition *method, publ
 {
     auto const allocator = ctx->allocator;
     ArenaVector<ir::Statement *> funcStatements(allocator->Adapter());
+    ES2PANDA_ASSERT(method->Id());
 
     auto *const callee =
         util::NodeAllocator::ForceSetParent<ir::Identifier>(allocator, method->Id()->Name(), allocator);
@@ -163,6 +167,7 @@ static ir::FunctionExpression *CreateFunctionExpression(ir::MethodDefinition *me
         allocator, allocator,
         ir::ScriptFunction::ScriptFunctionData {
             body, std::move(signature), method->Function()->Flags(), {}, method->Function()->Language()});
+    ES2PANDA_ASSERT(method->Function());
     funcNode->AddModifier(method->Function()->Modifiers());
     funcNode->SetRange({startLoc, endLoc});
 
@@ -184,6 +189,7 @@ static void CreateFunctionOverload(ir::MethodDefinition *method, ArenaVector<ir:
     overloadMethod->Function()->AddFlag(ir::ScriptFunctionFlags::OVERLOAD | ir::ScriptFunctionFlags::SYNTHETIC);
     overloadMethod->SetRange(funcExpression->Range());
 
+    ES2PANDA_ASSERT(overloadMethod->Function());
     if (!method->IsDeclare() && method->Parent()->IsTSInterfaceBody()) {
         overloadMethod->Function()->Body()->AsBlockStatement()->ClearStatements();
     }
@@ -195,6 +201,7 @@ static void CreateFunctionOverload(ir::MethodDefinition *method, ArenaVector<ir:
 
 static void ExpandOptionalParameterAnnotationsToUnions(public_lib::Context *ctx, ir::ScriptFunction *function)
 {
+    ES2PANDA_ASSERT(function);
     auto allocator = ctx->allocator;
 
     for (auto p : function->Params()) {
@@ -227,6 +234,7 @@ static void ClearOptionalParameters(public_lib::Context *ctx, ir::ScriptFunction
         if (oldParam->IsOptional()) {
             param = util::NodeAllocator::ForceSetParent<ir::ETSParameterExpression>(allocator, oldParam->Ident(), false,
                                                                                     allocator);
+            ES2PANDA_ASSERT(param);
             param->SetParent(function);
         }
         ES2PANDA_ASSERT(!param->AsETSParameterExpression()->IsOptional());
@@ -253,7 +261,7 @@ static void ProcessGlobalFunctionDefinition(ir::MethodDefinition *method, public
         for (size_t i = 0; i < params.size() - paramsToCut; ++i) {
             auto param = params[i]->AsETSParameterExpression();
             callArgs.push_back(param->Ident()->CloneReference(allocator, nullptr)->AsIdentifier());
-
+            ES2PANDA_ASSERT(param->Ident()->Clone(allocator, nullptr));
             functionParams.push_back(allocator->New<ir::ETSParameterExpression>(
                 param->Ident()->Clone(allocator, nullptr)->AsIdentifier(), false, allocator));
         }
diff --git a/ets2panda/compiler/lowering/ets/enumLowering.cpp b/ets2panda/compiler/lowering/ets/enumLowering.cpp
index 3d5b82941fd0b8cf73f7019e22c5591ead1eeed7..5eedca78f39f3a6e0d70da7c8f5c732c23a6312b 100644
--- a/ets2panda/compiler/lowering/ets/enumLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/enumLowering.cpp
@@ -39,6 +39,7 @@ namespace {
 [[nodiscard]] ir::Identifier *MakeParamRefIdent(public_lib::Context *ctx, ir::ETSParameterExpression *paramExpr)
 {
     auto *const refIdent = ctx->AllocNode<ir::Identifier>(paramExpr->Ident()->Name(), ctx->Allocator());
+    ES2PANDA_ASSERT(refIdent);
     refIdent->SetRange(paramExpr->Ident()->Range());
     refIdent->SetVariable(paramExpr->Ident()->Variable());
     return refIdent;
@@ -418,13 +419,17 @@ void EnumLoweringPhase::ProcessEnumClassDeclaration(ir::TSEnumDeclaration *const
     auto *ident = enumClassDecl->Definition()->Ident();
     if (flags.isLocal) {
         auto *scope = NearestScope(enumDecl->Parent());
+        ES2PANDA_ASSERT(scope);
         auto localCtx = varbinder::LexicalScope<varbinder::Scope>::Enter(varbinder_, scope);
+        ES2PANDA_ASSERT(scope);
         scope->EraseBinding(ident->Name());
         InitScopesPhaseETS::RunExternalNode(enumClassDecl, varbinder_);
         var = varbinder_->GetScope()->FindLocal(ident->Name(), varbinder::ResolveBindingOptions::ALL);
     } else if (flags.isTopLevel) {
         auto *scope = program_->GlobalClassScope();
+        ES2PANDA_ASSERT(scope);
         auto localCtx = varbinder::LexicalScope<varbinder::Scope>::Enter(varbinder_, scope);
+        ES2PANDA_ASSERT(scope);
         scope->StaticDeclScope()->EraseBinding(ident->Name());
         InitScopesPhaseETS::RunExternalNode(enumClassDecl, varbinder_);
         var = varbinder_->GetScope()->FindLocal(ident->Name(), varbinder::ResolveBindingOptions::ALL);
@@ -796,11 +801,13 @@ ir::VariableDeclaration *CreateForLoopInitVariableDeclaration(public_lib::Contex
     static_assert(EnumLoweringPhase::ORDINAL_TYPE == ir::PrimitiveType::INT);
     auto *const init = ctx->AllocNode<ir::NumberLiteral>(lexer::Number((int32_t)0));
     auto *const decl = ctx->AllocNode<ir::VariableDeclarator>(ir::VariableDeclaratorFlag::LET, loopIdentifier, init);
+    ES2PANDA_ASSERT(loopIdentifier);
     loopIdentifier->SetParent(decl);
     ArenaVector<ir::VariableDeclarator *> decls(ctx->Allocator()->Adapter());
     decls.push_back(decl);
     auto *const declaration = ctx->AllocNode<ir::VariableDeclaration>(
         ir::VariableDeclaration::VariableDeclarationKind::LET, ctx->Allocator(), std::move(decls));
+    ES2PANDA_ASSERT(decl);
     decl->SetParent(declaration);
     return declaration;
 }
diff --git a/ets2panda/compiler/lowering/ets/exportAnonymousConst.cpp b/ets2panda/compiler/lowering/ets/exportAnonymousConst.cpp
index d67d756deceebd7f5d7d3e67d53a450935e89c2a..26a2f439103d89a548a334ed0f83e596247b4257 100644
--- a/ets2panda/compiler/lowering/ets/exportAnonymousConst.cpp
+++ b/ets2panda/compiler/lowering/ets/exportAnonymousConst.cpp
@@ -110,6 +110,7 @@ static void HandleExportDefaultInExportNamedDecl(public_lib::Context *const ctx,
             exports.emplace_back(specifier);
             auto *exportDefaulNamedDecl = allocator->New<ir::ExportNamedDeclaration>(
                 allocator, static_cast<ir::StringLiteral *>(nullptr), std::move(exports));
+            ES2PANDA_ASSERT(exportDefaulNamedDecl);
             exportDefaulNamedDecl->AddModifier(ir::ModifierFlags::DEFAULT_EXPORT);
             exportDefaulNamedDeclarations.push_back(exportDefaulNamedDecl);
             continue;
diff --git a/ets2panda/compiler/lowering/ets/expressionLambdaLowering.cpp b/ets2panda/compiler/lowering/ets/expressionLambdaLowering.cpp
index 7d4112c7f6b66f259f937a0c82a9f1fb94e77896..e09b2b2af2af853efb2be5e21146110323dafef6 100644
--- a/ets2panda/compiler/lowering/ets/expressionLambdaLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/expressionLambdaLowering.cpp
@@ -37,6 +37,7 @@ static ir::AstNode *ConvertExpression(public_lib::Context *ctx, ir::ArrowFunctio
 
     auto *const block = ctx->AllocNode<ir::BlockStatement>(allocator, std::move(statements));
 
+    ES2PANDA_ASSERT(block);
     block->SetScope(scope);
     block->SetParent(function);
 
diff --git a/ets2panda/compiler/lowering/ets/genericBridgesLowering.cpp b/ets2panda/compiler/lowering/ets/genericBridgesLowering.cpp
index 1e2d1d47ff9d8033fe37cff06d61883a1c7e3e2d..e74ea9ce958031501326d405317cba0fd98355ad 100644
--- a/ets2panda/compiler/lowering/ets/genericBridgesLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/genericBridgesLowering.cpp
@@ -80,12 +80,14 @@ void GenericBridgesPhase::AddGenericBridge(ir::ClassDefinition const *const clas
 {
     auto *parser = context_->parser->AsETSParser();
     std::vector<ir::AstNode *> typeNodes {};
+    ES2PANDA_ASSERT(baseSignature);
     typeNodes.reserve(2U * baseSignature->Params().size() + 2U);
 
     auto const sourceCode = CreateMethodDefinitionString(classDefinition, baseSignature, derivedFunction, typeNodes);
 
     auto *const bridgeMethod =
         parser->CreateFormattedClassMethodDefinition(sourceCode, typeNodes)->AsMethodDefinition();
+    ES2PANDA_ASSERT(bridgeMethod);
     bridgeMethod->AddModifier(methodDefinition->Modifiers());
     bridgeMethod->ClearModifier(ir::ModifierFlags::NATIVE | ir::ModifierFlags::ABSTRACT);
     bridgeMethod->AddAstNodeFlags(methodDefinition->GetAstNodeFlags());
@@ -147,6 +149,7 @@ void GenericBridgesPhase::ProcessScriptFunction(ir::ClassDefinition const *const
 
     //  We are not interested in functions that either don't have type parameters at all
     //  or have type parameters that are not modified in the derived class
+    ES2PANDA_ASSERT(baseFunction);
     auto const *baseSignature1 = baseFunction->Signature()->Substitute(relation, &substitutions.baseConstraints);
     if (baseSignature1 == baseFunction->Signature()) {
         return;
diff --git a/ets2panda/compiler/lowering/ets/interfaceObjectLiteralLowering.cpp b/ets2panda/compiler/lowering/ets/interfaceObjectLiteralLowering.cpp
index 21e3981ab2495d46196e597df50f1bdf65f6c729..1e4f5046a94cb783e5862921bcee82678ff3681e 100644
--- a/ets2panda/compiler/lowering/ets/interfaceObjectLiteralLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/interfaceObjectLiteralLowering.cpp
@@ -93,6 +93,7 @@ static ir::MethodDefinition *CreateAnonClassFieldGetterSetter(public_lib::Contex
 {
     auto *const parser = ctx->parser->AsETSParser();
     // Field type annotation
+    ES2PANDA_ASSERT(ifaceMethod->Function());
     auto *fieldType = ifaceMethod->Function()->Signature()->ReturnType();
     ES2PANDA_ASSERT(fieldType != nullptr);
 
@@ -103,7 +104,7 @@ static ir::MethodDefinition *CreateAnonClassFieldGetterSetter(public_lib::Contex
         sourceCode << "public set @@I1 (anonParam:@@T2){" << std::endl;
         sourceCode << "this.@@I3 = anonParam" << std::endl;
         sourceCode << "}" << std::endl;
-
+        ES2PANDA_ASSERT(ifaceMethod->Id());
         return parser
             ->CreateFormattedClassMethodDefinition(sourceCode.str(), ifaceMethod->Id()->Name(), fieldType,
                                                    anonClassFieldName)
@@ -133,6 +134,7 @@ static void FillClassBody(public_lib::Context *ctx, ArenaVector<ir::AstNode *> *
         ES2PANDA_ASSERT(it->IsMethodDefinition());
         auto *ifaceMethod = it->AsMethodDefinition();
 
+        ES2PANDA_ASSERT(ifaceMethod->Function());
         if (!ifaceMethod->Function()->IsGetter()) {
             continue;
         }
@@ -203,6 +205,7 @@ static void AnnotateGeneratedAnonClass(checker::ETSChecker *checker, ir::ClassDe
         checker->ProgramAllocNode<ir::Identifier>(Signatures::INTERFACE_OBJ_LITERAL, checker->ProgramAllocator());
     annoId->SetAnnotationUsage();
     auto *annoUsage = checker->ProgramAllocNode<ir::AnnotationUsage>(annoId, checker->ProgramAllocator());
+    ES2PANDA_ASSERT(annoUsage);
     annoUsage->AddModifier(ir::ModifierFlags::ANNOTATION_USAGE);
     annoUsage->SetParent(classDef);
     annoId->SetParent(annoUsage);
@@ -256,6 +259,7 @@ static void GenerateAnonClassTypeFromInterface(public_lib::Context *ctx, ir::TSI
     // Class implements
     auto *classImplements = ctx->AllocNode<ir::TSClassImplements>(
         ctx->AllocNode<ir::OpaqueTypeNode>(ifaceNode->TsType(), ctx->Allocator()));
+    ES2PANDA_ASSERT(classImplements);
     classImplements->SetParent(classDef);
     classDef->EmplaceImplements(classImplements);
     classType->RemoveObjectFlag(checker::ETSObjectFlags::RESOLVED_INTERFACES);
@@ -336,6 +340,7 @@ static checker::Type *ProcessDeclNode(checker::ETSChecker *checker, checker::ETS
                 continue;
             }
 
+            ES2PANDA_ASSERT(it->AsMethodDefinition()->Id());
             checker->LogError(diagnostic::ABSTRACT_METH_IN_ABSTRACT_CLASS, {it->AsMethodDefinition()->Id()->Name()},
                               objExpr->Start());
             return checker->GlobalTypeError();
@@ -390,6 +395,7 @@ static bool CheckInterfaceShouldGenerateAnonClass(ir::TSInterfaceDeclaration *in
         }
         ES2PANDA_ASSERT(it->IsMethodDefinition());
         auto methodDef = it->AsMethodDefinition();
+        ES2PANDA_ASSERT(methodDef->Function());
         if (!methodDef->Function()->IsGetter() && !methodDef->Function()->IsSetter()) {
             return false;
         }
diff --git a/ets2panda/compiler/lowering/ets/interfacePropertyDeclarations.cpp b/ets2panda/compiler/lowering/ets/interfacePropertyDeclarations.cpp
index b9aafa87361b4555855a0375dbdf0706b9fbf3dc..2e5816e2e6fb33d0c28a49440e405cd2663e9a64 100644
--- a/ets2panda/compiler/lowering/ets/interfacePropertyDeclarations.cpp
+++ b/ets2panda/compiler/lowering/ets/interfacePropertyDeclarations.cpp
@@ -192,6 +192,7 @@ static void AddOverload(ir::MethodDefinition *method, ir::MethodDefinition *over
 {
     method->AddOverload(overload);
     overload->SetParent(method);
+    ES2PANDA_ASSERT(overload->Function());
     overload->Function()->AddFlag(ir::ScriptFunctionFlags::OVERLOAD);
     overload->Function()->Id()->SetVariable(variable);
 }
diff --git a/ets2panda/compiler/lowering/ets/lambdaLowering.cpp b/ets2panda/compiler/lowering/ets/lambdaLowering.cpp
index 679d5cbfb57da137980c86914070b0db668c8ccb..c775cf15b1593c305730a3568dcd11bdbca68b8b 100644
--- a/ets2panda/compiler/lowering/ets/lambdaLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/lambdaLowering.cpp
@@ -116,6 +116,7 @@ static std::pair<ir::TSTypeParameterDeclaration *, checker::Substitution> CloneT
         auto *newTypeParamNode = util::NodeAllocator::ForceSetParent<ir::TSTypeParameter>(allocator, newTypeParamId,
                                                                                           nullptr, nullptr, allocator);
         auto *newTypeParam = allocator->New<checker::ETSTypeParameter>();
+        ES2PANDA_ASSERT(newTypeParam);
         newTypeParam->SetDeclNode(newTypeParamNode);
 
         auto *newTypeParamDecl = allocator->New<varbinder::TypeParameterDecl>(newTypeParamId->Name());
@@ -159,17 +160,14 @@ static std::pair<ir::TSTypeParameterDeclaration *, checker::Substitution> CloneT
 using ParamsAndVarMap =
     std::pair<ArenaVector<ir::Expression *>, ArenaMap<varbinder::Variable *, varbinder::Variable *>>;
 
-ParamsAndVarMap CreateLambdaCalleeParameters(public_lib::Context *ctx, ir::ArrowFunctionExpression *lambda,
-                                             ArenaSet<varbinder::Variable *> const &captured,
-                                             varbinder::ParamScope *paramScope, checker::Substitution *substitution)
+void ProcessCapturedVariables(public_lib::Context *ctx, ArenaSet<varbinder::Variable *> const &captured,
+                              checker::Substitution *substitution, varbinder::ParamScope *paramScope,
+                              ArenaVector<ir::Expression *> &resParams,
+                              ArenaMap<varbinder::Variable *, varbinder::Variable *> &varMap)
 {
     auto allocator = ctx->allocator;
     auto checker = ctx->GetChecker()->AsETSChecker();
     auto varBinder = ctx->GetChecker()->VarBinder();
-    auto resParams = ArenaVector<ir::Expression *>(allocator->Adapter());
-    auto varMap = ArenaMap<varbinder::Variable *, varbinder::Variable *>(allocator->Adapter());
-
-    auto paramLexScope = varbinder::LexicalScope<varbinder::ParamScope>::Enter(varBinder, paramScope);
 
     for (auto capturedVar : captured) {
         auto *newType = capturedVar->TsType()->Substitute(checker->Relation(), substitution);
@@ -185,15 +183,28 @@ ParamsAndVarMap CreateLambdaCalleeParameters(public_lib::Context *ctx, ir::Arrow
         resParams.push_back(param);
         varMap[capturedVar] = var;
     }
+}
+
+void ProcessLambdaParameters(public_lib::Context *ctx, ir::ArrowFunctionExpression *lambda,
+                             checker::Substitution *substitution, varbinder::ParamScope *paramScope,
+                             ArenaVector<ir::Expression *> &resParams,
+                             ArenaMap<varbinder::Variable *, varbinder::Variable *> &varMap)
+{
+    auto allocator = ctx->allocator;
+    auto checker = ctx->GetChecker()->AsETSChecker();
+    auto varBinder = ctx->GetChecker()->VarBinder();
 
     for (auto *oldParam : lambda->Function()->Params()) {
         auto *oldParamType = oldParam->AsETSParameterExpression()->Ident()->TsType();
         auto *newParamType = oldParamType->Substitute(checker->Relation(), substitution);
         auto *newParam = oldParam->AsETSParameterExpression()->Clone(allocator, nullptr);
+        ES2PANDA_ASSERT(newParam);
+
         if (newParam->IsOptional()) {
             newParam->SetOptional(false);
             newParamType = checker->CreateETSUnionType({newParamType, checker->GlobalETSUndefinedType()});
         }
+
         newParam->SetTypeAnnotation(allocator->New<ir::OpaqueTypeNode>(newParamType, allocator));
         auto *var = varBinder->AddParamDecl(newParam);
         var->SetTsType(newParamType);
@@ -201,21 +212,36 @@ ParamsAndVarMap CreateLambdaCalleeParameters(public_lib::Context *ctx, ir::Arrow
         newParam->SetVariable(var);
         newParam->SetTsType(newParamType);
         newParam->Ident()->SetTsType(newParamType);
+
         if (newParam->IsRestParameter()) {
             newParam->TypeAnnotation()->SetParent(newParam->Spread());
             newParam->Spread()->SetTsType(newParamType);
         } else {
             newParam->TypeAnnotation()->SetParent(newParam->Ident());
         }
+
         resParams.push_back(newParam);
         varMap[oldParam->AsETSParameterExpression()->Variable()] = var;
 
         if (newParam->TypeAnnotation()->IsETSFunctionType()) {
-            // Parameter can be a function with other parameters inside
-            // Restart varbinder to set correct scopes for inner parameters
             InitScopesPhaseETS::RunExternalNode(newParam->TypeAnnotation(), varBinder);
         }
     }
+}
+
+ParamsAndVarMap CreateLambdaCalleeParameters(public_lib::Context *ctx, ir::ArrowFunctionExpression *lambda,
+                                             ArenaSet<varbinder::Variable *> const &captured,
+                                             varbinder::ParamScope *paramScope, checker::Substitution *substitution)
+{
+    auto allocator = ctx->allocator;
+    auto varBinder = ctx->GetChecker()->VarBinder();
+    auto resParams = ArenaVector<ir::Expression *>(allocator->Adapter());
+    auto varMap = ArenaMap<varbinder::Variable *, varbinder::Variable *>(allocator->Adapter());
+
+    auto paramLexScope = varbinder::LexicalScope<varbinder::ParamScope>::Enter(varBinder, paramScope);
+
+    ProcessCapturedVariables(ctx, captured, substitution, paramScope, resParams, varMap);
+    ProcessLambdaParameters(ctx, lambda, substitution, paramScope, resParams, varMap);
 
     return {resParams, varMap};
 }
@@ -295,6 +321,7 @@ static ir::MethodDefinition *SetUpCalleeMethod(public_lib::Context *ctx, LambdaI
     var->AddFlag(varbinder::VariableFlags::METHOD);
     var->SetScope(scopeForMethod);
     func->Id()->SetVariable(var);
+    ES2PANDA_ASSERT(method->Id());
     method->Id()->SetVariable(var);
     if (info->callReceiver != nullptr) {
         auto paramScopeCtx = varbinder::LexicalScope<varbinder::FunctionParamScope>::Enter(varBinder, paramScope);
@@ -341,9 +368,8 @@ static ir::MethodDefinition *CreateCalleeMethod(public_lib::Context *ctx, ir::Ar
     auto varMap = std::move(vMap);
 
     auto arrowReturnType = lambda->TsType()->AsETSFunctionType()->ArrowSignature()->ReturnType();
-    auto *returnType = cmInfo->forcedReturnType != nullptr
-                           ? cmInfo->forcedReturnType
-                           : arrowReturnType->Substitute(checker->Relation(), &substitution);
+    auto *alternative = arrowReturnType->Substitute(checker->Relation(), &substitution);
+    auto *returnType = cmInfo->forcedReturnType != nullptr ? cmInfo->forcedReturnType : alternative;
     auto returnTypeAnnotation = allocator->New<ir::OpaqueTypeNode>(returnType, allocator);
 
     auto funcFlags = ir::ScriptFunctionFlags::METHOD | cmInfo->auxFunctionFlags;
@@ -359,6 +385,7 @@ static ir::MethodDefinition *CreateCalleeMethod(public_lib::Context *ctx, ir::Ar
              funcFlags, modifierFlags});
     auto *funcScope = cmInfo->body == nullptr ? allocator->New<varbinder::FunctionScope>(allocator, paramScope)
                                               : cmInfo->body->Scope()->AsFunctionScope();
+    ES2PANDA_ASSERT(funcScope);
     funcScope->BindName(info->calleeClass->Definition()->TsType()->AsETSObjectType()->AssemblerName());
     func->SetScope(funcScope);
     ProcessCalleeMethodBody(cmInfo->body, checker, paramScope, &substitution, varMap);
@@ -378,9 +405,8 @@ static ir::MethodDefinition *CreateCalleeMethod(public_lib::Context *ctx, ir::Ar
     */
     for (auto [ov, nv] : varMap) {
         ES2PANDA_ASSERT(ov->Name() == nv->Name());
-        auto name = ov->Name();
-        funcScope->EraseBinding(name);
-        funcScope->InsertBinding(name, nv);
+        funcScope->EraseBinding(ov->Name());
+        funcScope->InsertBinding(ov->Name(), nv);
     }
 
     return SetUpCalleeMethod(ctx, info, cmInfo, func, scopeForMethod);
@@ -498,6 +524,7 @@ static void CreateLambdaClassConstructor(public_lib::Context *ctx, ir::ClassDefi
         ir::ScriptFunction::ScriptFunctionData {body, ir::FunctionSignature(nullptr, std::move(params), nullptr),
                                                 ir::ScriptFunctionFlags::CONSTRUCTOR |
                                                     ir::ScriptFunctionFlags::IMPLICIT_SUPER_CALL_NEEDED});
+    ES2PANDA_ASSERT(func);
     func->SetIdent(constructorId);
     auto *funcExpr = util::NodeAllocator::ForceSetParent<ir::FunctionExpression>(allocator, func);
 
@@ -578,6 +605,7 @@ static ArenaVector<ark::es2panda::ir::Statement *> CreateRestArgumentsArrayReall
             checker->MaybeBoxType(elementType), restParameterIndex, restParameterIndex);
     }
 
+    ES2PANDA_ASSERT(args);
     return ArenaVector<ir::Statement *>(args->AsBlockStatement()->Statements());
 }
 
@@ -588,6 +616,7 @@ static void CreateInvokeMethodRestParameter(public_lib::Context *ctx, LambdaClas
     auto *checker = ctx->GetChecker()->AsETSChecker();
 
     auto *restIdent = Gensym(allocator);
+    ES2PANDA_ASSERT(restIdent);
     lciInfo->restParameterIdentifier = restIdent->Name();
     auto *spread = allocator->New<ir::SpreadElement>(ir::AstNodeType::REST_ELEMENT, allocator, restIdent);
     auto *arr = lciInfo->lambdaSignature->RestVar()->TsType()->IsETSTupleType()
@@ -768,6 +797,7 @@ static checker::ETSObjectType *FunctionTypeToLambdaProviderType(checker::ETSChec
                                                                 checker::Signature *signature)
 {
     if (signature->RestVar() != nullptr) {
+        ES2PANDA_ASSERT(checker->GlobalBuiltinLambdaType(signature->ArgCount(), true));
         return checker->GlobalBuiltinLambdaType(signature->ArgCount(), true)->AsETSObjectType();
     }
     // Note: FunctionN is not supported yet
@@ -831,7 +861,7 @@ static ir::ClassDeclaration *CreateEmptyLambdaClassDeclaration(public_lib::Conte
                                                                 : info->calleeInterface->Id()->Name();
 
     lambdaClassName.Append(objectName).Append("$").Append(info->name);
-
+    ES2PANDA_ASSERT(lambdaProviderClass);
     auto *providerTypeReference = checker->AllocNode<ir::ETSTypeReference>(
         checker->AllocNode<ir::ETSTypeReferencePart>(
             checker->AllocNode<ir::Identifier>(lambdaProviderClass->AsETSObjectType()->Name(), checker->Allocator()),
@@ -882,6 +912,7 @@ static ir::ClassDeclaration *CreateLambdaClass(public_lib::Context *ctx, checker
         CreateEmptyLambdaClassDeclaration(ctx, info, newTypeParams, fnInterface, lambdaProviderClass);
     auto classDefinition = classDeclaration->Definition();
     if (info->isFunctionReference) {
+        ES2PANDA_ASSERT(callee->Function());
         classDefinition->SetFunctionalReferenceReferencedMethod(callee);
         classDefinition->SetModifiers(classDefinition->Modifiers() |
                                       ir::ClassDefinitionModifiers::FUNCTIONAL_REFERENCE);
@@ -948,8 +979,10 @@ static ir::ETSNewClassInstanceExpression *CreateConstructorCall(public_lib::Cont
     auto *newExpr = util::NodeAllocator::ForceSetParent<ir::ETSNewClassInstanceExpression>(
         allocator, allocator->New<ir::OpaqueTypeNode>(constructedType, allocator), std::move(args));
     auto *lambdaOrFuncRefParent = lambdaOrFuncRef->Parent();
+    ES2PANDA_ASSERT(newExpr);
     newExpr->SetParent(lambdaOrFuncRefParent);
     // NOTE(dslynko, #19869): Required for correct debug-info generation
+    ES2PANDA_ASSERT(newExpr);
     newExpr->SetRange(lambdaOrFuncRefParent != nullptr ? lambdaOrFuncRefParent->Range() : lambdaOrFuncRef->Range());
 
     auto *nearestScope = NearestScope(lambdaOrFuncRef);
@@ -1036,6 +1069,7 @@ static ir::ScriptFunction *GetWrappingLambdaParentFunction(public_lib::Context *
     }
     bodyStmts.push_back(stmt);
     func->SetBody(util::NodeAllocator::ForceSetParent<ir::BlockStatement>(allocator, allocator, std::move(bodyStmts)));
+    ES2PANDA_ASSERT(func->Body());
     func->Body()->SetParent(func);
     return func;
 }
@@ -1051,6 +1085,7 @@ static ir::ArrowFunctionExpression *CreateWrappingLambda(public_lib::Context *ct
     auto *func = GetWrappingLambdaParentFunction(ctx, funcRef, signature);
 
     auto *lambda = util::NodeAllocator::ForceSetParent<ir::ArrowFunctionExpression>(allocator, func, allocator);
+    ES2PANDA_ASSERT(lambda);
     lambda->SetParent(parent);
 
     auto *nearestScope = NearestScope(lambda);
@@ -1135,6 +1170,7 @@ static ir::AstNode *ConvertFunctionReference(public_lib::Context *ctx, ir::Expre
     ES2PANDA_ASSERT(funcRef->TsType()->IsETSArrowType());
     auto *lambdaClass = CreateLambdaClass(ctx, funcRef->TsType()->AsETSFunctionType(), method, &info);
     auto *constructorCall = CreateConstructorCall(ctx, funcRef, lambdaClass, &info);
+    ES2PANDA_ASSERT(constructorCall);
     constructorCall->TsType()->AsETSObjectType()->AddObjectFlag(checker::ETSObjectFlags::FUNCTIONAL_REFERENCE);
 
     return constructorCall;
@@ -1156,6 +1192,7 @@ static bool IsFunctionOrMethodCall(checker::ETSChecker *checker, ir::CallExpress
     // Not skip if invoke pattern Union.<field>() where field is of ETSArrowType
     if (callee->IsMemberExpression()) {
         auto me = callee->AsMemberExpression();
+        ES2PANDA_ASSERT(me->TsType());
         if (me->Object()->TsType() != nullptr && checker->GetApparentType(me->Object()->TsType())->IsETSUnionType() &&
             me->TsType()->IsETSMethodType()) {
             return true;
@@ -1173,6 +1210,7 @@ static bool IsFunctionOrMethodCall(checker::ETSChecker *checker, ir::CallExpress
     return var != nullptr && !IsVariableOriginalAccessor(var) && (var->Flags() & varbinder::VariableFlags::METHOD) != 0;
 }
 
+// CC-OFFNXT(G.FUN.01, huge_method, huge_method[C++]) solid logic
 static ir::AstNode *InsertInvokeCall(public_lib::Context *ctx, ir::CallExpression *call)
 {
     auto *allocator = ctx->allocator;
@@ -1195,6 +1233,7 @@ static ir::AstNode *InsertInvokeCall(public_lib::Context *ctx, ir::CallExpressio
                                                               checker::PropertySearchFlags::SEARCH_IN_INTERFACES);
     ES2PANDA_ASSERT(prop != nullptr);
     auto *invoke0Id = allocator->New<ir::Identifier>(invokeMethodName, allocator);
+    ES2PANDA_ASSERT(invoke0Id);
     invoke0Id->SetTsType(prop->TsType());
     invoke0Id->SetVariable(prop);
 
diff --git a/ets2panda/compiler/lowering/ets/lateInitialization.cpp b/ets2panda/compiler/lowering/ets/lateInitialization.cpp
index 6c57beb75ebcdb36065f1e7b4fb24e51a031cd8e..87e878ac135099f51be5e96788c838b633bcc6bc 100644
--- a/ets2panda/compiler/lowering/ets/lateInitialization.cpp
+++ b/ets2panda/compiler/lowering/ets/lateInitialization.cpp
@@ -36,6 +36,7 @@ ir::ClassProperty *TransformerClassProperty(public_lib::Context *ctx, ir::ClassP
 
     auto annotationType = checker->CreateETSUnionType({property->TsType(), checker->GlobalETSUndefinedType()});
     auto typeAnnotation = allocator->New<ir::OpaqueTypeNode>(annotationType, allocator);
+    ES2PANDA_ASSERT(typeAnnotation);
     typeAnnotation->SetParent(property);
     typeAnnotation->SetTsType(annotationType);
     property->SetTypeAnnotation(typeAnnotation);
@@ -76,6 +77,7 @@ static ir::AstNode *TransformerMemberExpression(ir::MemberExpression *memberExpr
     blockStatements.push_back(parser->CreateFormattedStatement(ss.str(), name));
     blockStatements.push_back(parser->CreateFormattedStatement("@@I1 as @@T2", name, typeNode));
     auto *res = util::NodeAllocator::ForceSetParent<ir::BlockExpression>(allocator, std::move(blockStatements));
+    ES2PANDA_ASSERT(res);
     res->SetParent(parent);
     Recheck(ctx->phaseManager, varbinder, checker, res);
 
diff --git a/ets2panda/ir/ets/etsClassLiteral.cpp b/ets2panda/ir/ets/etsClassLiteral.cpp
index fa65001a99ffab679c7d6060de604ad42ae13e46..ba0830fb309dc14f1c0c19e9dd964bb7b1c1fccd 100644
--- a/ets2panda/ir/ets/etsClassLiteral.cpp
+++ b/ets2panda/ir/ets/etsClassLiteral.cpp
@@ -72,6 +72,7 @@ ETSClassLiteral *ETSClassLiteral::Clone(ArenaAllocator *const allocator, AstNode
         expr->SetParent(clone);
     }
     if (parent != nullptr) {
+        ES2PANDA_ASSERT(clone);
         clone->SetParent(parent);
     }
 
diff --git a/ets2panda/ir/ets/etsFunctionType.cpp b/ets2panda/ir/ets/etsFunctionType.cpp
index 097b326d26c89b0cbba7edf65177fcc5e3dc55fe..ebe73b6a5273dc9a6c76bac06f4b8107161a7883 100644
--- a/ets2panda/ir/ets/etsFunctionType.cpp
+++ b/ets2panda/ir/ets/etsFunctionType.cpp
@@ -137,6 +137,7 @@ ETSFunctionType *ETSFunctionType::Clone(ArenaAllocator *const allocator, AstNode
     if (!Annotations().empty()) {
         ArenaVector<AnnotationUsage *> annotationUsages {allocator->Adapter()};
         for (auto *annotationUsage : Annotations()) {
+            ES2PANDA_ASSERT(annotationUsage->Clone(allocator, clone));
             annotationUsages.push_back(annotationUsage->Clone(allocator, clone)->AsAnnotationUsage());
         }
         clone->SetAnnotations(std::move(annotationUsages));
diff --git a/ets2panda/ir/ets/etsKeyofType.cpp b/ets2panda/ir/ets/etsKeyofType.cpp
index 6407914ab78eb420a69567514f91e8aa3da39a4b..c3b65e29619138f5d71c1fe094711b9b5be5426c 100644
--- a/ets2panda/ir/ets/etsKeyofType.cpp
+++ b/ets2panda/ir/ets/etsKeyofType.cpp
@@ -64,6 +64,7 @@ checker::Type *ETSKeyofType::GetType(checker::ETSChecker *checker)
     }
 
     auto *typeReference = type_->GetType(checker);
+    ES2PANDA_ASSERT(typeReference);
 
     if (typeReference->IsETSPrimitiveType()) {
         typeReference = checker->MaybeBoxType(typeReference);
@@ -88,6 +89,7 @@ ETSKeyofType *ETSKeyofType::Clone(ArenaAllocator *const allocator, AstNode *cons
 {
     TypeNode *type = type_->Clone(allocator, nullptr);
     ETSKeyofType *clone = allocator->New<ir::ETSKeyofType>(type, allocator);
+    ES2PANDA_ASSERT(clone);
     if (parent != nullptr) {
         clone->SetParent(parent);
     }
diff --git a/ets2panda/ir/ets/etsNeverType.cpp b/ets2panda/ir/ets/etsNeverType.cpp
index 3f40e3475075ab2a1bc7613410322b7179f01387..0c0cbe895a80b1aaa7489d3259192c3ae4ca8766 100644
--- a/ets2panda/ir/ets/etsNeverType.cpp
+++ b/ets2panda/ir/ets/etsNeverType.cpp
@@ -68,6 +68,7 @@ checker::Type *ETSNeverType::GetType([[maybe_unused]] checker::ETSChecker *check
 ETSNeverType *ETSNeverType::Clone(ArenaAllocator *allocator, AstNode *parent)
 {
     auto *const clone = allocator->New<ir::ETSNeverType>(allocator);
+    ES2PANDA_ASSERT(clone);
 
     if (parent != nullptr) {
         clone->SetParent(parent);
diff --git a/ets2panda/ir/ets/etsNewArrayInstanceExpression.cpp b/ets2panda/ir/ets/etsNewArrayInstanceExpression.cpp
index 638627789f35d2d6aa350b3e78b9e63ce2497880..6031857627b31719e2fbf5ad4b3cab3c215a10e5 100644
--- a/ets2panda/ir/ets/etsNewArrayInstanceExpression.cpp
+++ b/ets2panda/ir/ets/etsNewArrayInstanceExpression.cpp
@@ -84,6 +84,7 @@ ETSNewArrayInstanceExpression *ETSNewArrayInstanceExpression::Clone(ArenaAllocat
     auto *const typeRef = typeReference_ != nullptr ? typeReference_->Clone(allocator, nullptr) : nullptr;
     auto *const dimension = dimension_ != nullptr ? dimension_->Clone(allocator, nullptr)->AsExpression() : nullptr;
     auto *const clone = allocator->New<ETSNewArrayInstanceExpression>(typeRef, dimension);
+    ES2PANDA_ASSERT(clone);
 
     if (typeRef != nullptr) {
         typeRef->SetParent(clone);
diff --git a/ets2panda/ir/ets/etsNewClassInstanceExpression.cpp b/ets2panda/ir/ets/etsNewClassInstanceExpression.cpp
index 4a32953e5d01a35222dc3c926a26f7530529404b..7c0b525c0e0a81f81125ffd054e34218f715914f 100644
--- a/ets2panda/ir/ets/etsNewClassInstanceExpression.cpp
+++ b/ets2panda/ir/ets/etsNewClassInstanceExpression.cpp
@@ -109,6 +109,7 @@ ETSNewClassInstanceExpression *ETSNewClassInstanceExpression::Clone(ArenaAllocat
                                                                     AstNode *const parent)
 {
     auto *const clone = allocator->New<ETSNewClassInstanceExpression>(*this, allocator);
+    ES2PANDA_ASSERT(clone);
     if (parent != nullptr) {
         clone->SetParent(parent);
     }
diff --git a/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp b/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp
index f18b4e7a3a933653590e53df854b8ed9bd222475..08ff84bcf44bb3e2a1467e8b3333535c251ea215 100644
--- a/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp
+++ b/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp
@@ -115,6 +115,7 @@ ETSNewMultiDimArrayInstanceExpression *ETSNewMultiDimArrayInstanceExpression::Cl
                                                                                     AstNode *const parent)
 {
     auto *const clone = allocator->New<ETSNewMultiDimArrayInstanceExpression>(*this, allocator);
+    ES2PANDA_ASSERT(clone);
     if (parent != nullptr) {
         clone->SetParent(parent);
     }
diff --git a/ets2panda/ir/ets/etsNonNullishTypeNode.cpp b/ets2panda/ir/ets/etsNonNullishTypeNode.cpp
index 14226f3c0fb1e0cf9030546b1d811e7864319a89..00d68dbfce227015634242de8ed1f5c075127ae6 100644
--- a/ets2panda/ir/ets/etsNonNullishTypeNode.cpp
+++ b/ets2panda/ir/ets/etsNonNullishTypeNode.cpp
@@ -69,6 +69,7 @@ ETSNonNullishTypeNode *ETSNonNullishTypeNode::Clone(ArenaAllocator *allocator, A
 {
     TypeNode *typeNode = typeNode_->Clone(allocator, nullptr);
     ETSNonNullishTypeNode *clone = allocator->New<ir::ETSNonNullishTypeNode>(typeNode, allocator);
+    ES2PANDA_ASSERT(clone);
     clone->SetParent(parent);
     clone->typeNode_->SetParent(clone);
     return clone;
diff --git a/ets2panda/ir/ets/etsNullishTypes.cpp b/ets2panda/ir/ets/etsNullishTypes.cpp
index 0957d162a44a9493faa2b1eeae1410807b7609ee..c30404e1eb2717e69b3c029747f2f11527a29a14 100644
--- a/ets2panda/ir/ets/etsNullishTypes.cpp
+++ b/ets2panda/ir/ets/etsNullishTypes.cpp
@@ -68,6 +68,7 @@ checker::Type *ETSUndefinedType::GetType([[maybe_unused]] checker::ETSChecker *c
 ETSUndefinedType *ETSUndefinedType::Clone(ArenaAllocator *allocator, AstNode *parent)
 {
     auto *const clone = allocator->New<ir::ETSUndefinedType>(allocator);
+    ES2PANDA_ASSERT(clone);
 
     if (parent != nullptr) {
         clone->SetParent(parent);
@@ -76,6 +77,7 @@ ETSUndefinedType *ETSUndefinedType::Clone(ArenaAllocator *allocator, AstNode *pa
     if (!Annotations().empty()) {
         ArenaVector<AnnotationUsage *> annotationUsages {allocator->Adapter()};
         for (auto *annotationUsage : Annotations()) {
+            ES2PANDA_ASSERT(annotationUsage->Clone(allocator, clone));
             annotationUsages.push_back(annotationUsage->Clone(allocator, clone)->AsAnnotationUsage());
         }
         clone->SetAnnotations(std::move(annotationUsages));
diff --git a/ets2panda/ir/ets/etsPackageDeclaration.cpp b/ets2panda/ir/ets/etsPackageDeclaration.cpp
index 277abfc2d35ba40850a7e92cfeb2d8336a804f49..e6de02bf1e146426477dcd654f9e76c81489972e 100644
--- a/ets2panda/ir/ets/etsPackageDeclaration.cpp
+++ b/ets2panda/ir/ets/etsPackageDeclaration.cpp
@@ -69,6 +69,7 @@ ETSPackageDeclaration *ETSPackageDeclaration::Clone(ArenaAllocator *const alloca
 {
     auto const name = name_ != nullptr ? name_->Clone(allocator, nullptr)->AsExpression() : nullptr;
     auto *const clone = allocator->New<ETSPackageDeclaration>(name);
+    ES2PANDA_ASSERT(clone);
 
     if (name != nullptr) {
         name->SetParent(clone);
diff --git a/ets2panda/ir/ets/etsParameterExpression.cpp b/ets2panda/ir/ets/etsParameterExpression.cpp
index 300573755bbaca5882dd11d55b2a13e4d9249b52..9292f3e75f83aac4f121c52248ae1457ad997c6f 100644
--- a/ets2panda/ir/ets/etsParameterExpression.cpp
+++ b/ets2panda/ir/ets/etsParameterExpression.cpp
@@ -287,6 +287,7 @@ ETSParameterExpression *ETSParameterExpression::Clone(ArenaAllocator *const allo
         initializer->SetParent(clone);
     }
 
+    ES2PANDA_ASSERT(clone);
     if (parent != nullptr) {
         clone->SetParent(parent);
     }
diff --git a/ets2panda/ir/ets/etsParameterExpression.h b/ets2panda/ir/ets/etsParameterExpression.h
index ab6ee081449845a0653d2243b118d05b7b63b08e..a04ffa056e3bfe1459778c726942b709bdaece57 100644
--- a/ets2panda/ir/ets/etsParameterExpression.h
+++ b/ets2panda/ir/ets/etsParameterExpression.h
@@ -55,6 +55,7 @@ public:
     void SetIdent(Identifier *ident) noexcept
     {
         this->GetOrCreateHistoryNodeAs<ETSParameterExpression>()->ident_ = ident;
+        ES2PANDA_ASSERT(ident);
         ident->SetParent(this);
     }
 
diff --git a/ets2panda/ir/ets/etsPrimitiveType.cpp b/ets2panda/ir/ets/etsPrimitiveType.cpp
index 6fc11fec680beb738d0a26b6067bb55d22595025..cd4a16ccc6d3e51ff517a548cc3843069c2a46d0 100644
--- a/ets2panda/ir/ets/etsPrimitiveType.cpp
+++ b/ets2panda/ir/ets/etsPrimitiveType.cpp
@@ -162,6 +162,7 @@ ETSPrimitiveType *ETSPrimitiveType::Clone(ArenaAllocator *const allocator, AstNo
     if (!Annotations().empty()) {
         ArenaVector<AnnotationUsage *> annotationUsages {allocator->Adapter()};
         for (auto *annotationUsage : Annotations()) {
+            ES2PANDA_ASSERT(annotationUsage->Clone(allocator, clone));
             annotationUsages.push_back(annotationUsage->Clone(allocator, clone)->AsAnnotationUsage());
         }
         clone->SetAnnotations(std::move(annotationUsages));
diff --git a/ets2panda/ir/ets/etsStringLiteralType.cpp b/ets2panda/ir/ets/etsStringLiteralType.cpp
index 178160de40224715787949b5f9dbb6308edd51ea..26da8a4edebc73f061eafd86e21fa67cb2fd6088 100644
--- a/ets2panda/ir/ets/etsStringLiteralType.cpp
+++ b/ets2panda/ir/ets/etsStringLiteralType.cpp
@@ -77,6 +77,7 @@ ETSStringLiteralType *ETSStringLiteralType::Clone(ArenaAllocator *allocator, Ast
     if (!Annotations().empty()) {
         ArenaVector<AnnotationUsage *> annotationUsages {allocator->Adapter()};
         for (auto *annotationUsage : Annotations()) {
+            ES2PANDA_ASSERT(annotationUsage->Clone(allocator, clone));
             annotationUsages.push_back(annotationUsage->Clone(allocator, clone)->AsAnnotationUsage());
         }
         clone->SetAnnotations(std::move(annotationUsages));
diff --git a/ets2panda/ir/ets/etsTuple.cpp b/ets2panda/ir/ets/etsTuple.cpp
index 3b143a0872be34026de52c55f93c1d4a00ac8912..968b28724997d3fd3745d3abf5324c2164c63bde 100644
--- a/ets2panda/ir/ets/etsTuple.cpp
+++ b/ets2panda/ir/ets/etsTuple.cpp
@@ -120,6 +120,7 @@ checker::Type *ETSTuple::GetType(checker::ETSChecker *const checker)
     auto *tupleType = checker->ProgramAllocator()->New<checker::ETSTupleType>(checker, typeList);
 
     if (IsReadonlyType()) {
+        ES2PANDA_ASSERT(checker->GetReadonlyType(tupleType));
         tupleType = checker->GetReadonlyType(tupleType)->AsETSTupleType();
     }
 
@@ -130,6 +131,7 @@ checker::Type *ETSTuple::GetType(checker::ETSChecker *const checker)
 ETSTuple *ETSTuple::Clone(ArenaAllocator *const allocator, AstNode *const parent)
 {
     auto *const clone = allocator->New<ETSTuple>(allocator, size_);
+    ES2PANDA_ASSERT(clone);
 
     clone->AddModifier(flags_);
 
diff --git a/ets2panda/ir/ets/etsTypeReferencePart.cpp b/ets2panda/ir/ets/etsTypeReferencePart.cpp
index 8a79259d948059e8a1762015d351614329c5a4c7..95812f806b3790fa900e7ebff5b8e207160b5779 100644
--- a/ets2panda/ir/ets/etsTypeReferencePart.cpp
+++ b/ets2panda/ir/ets/etsTypeReferencePart.cpp
@@ -298,6 +298,7 @@ ETSTypeReferencePart *ETSTypeReferencePart::Clone(ArenaAllocator *const allocato
         prevClone->SetParent(clone);
     }
 
+    ES2PANDA_ASSERT(clone);
     if (parent != nullptr) {
         clone->SetParent(parent);
     }
diff --git a/ets2panda/ir/ets/etsUnionType.cpp b/ets2panda/ir/ets/etsUnionType.cpp
index 19f231198838285ed8e9920ae4377c198c24ecbd..0a74affb977fcd8c8a948f38dce1200b0449a4cb 100644
--- a/ets2panda/ir/ets/etsUnionType.cpp
+++ b/ets2panda/ir/ets/etsUnionType.cpp
@@ -126,6 +126,7 @@ ETSUnionType *ETSUnionType::Clone(ArenaAllocator *const allocator, AstNode *cons
     if (!Annotations().empty()) {
         ArenaVector<AnnotationUsage *> annotationUsages {allocator->Adapter()};
         for (auto *annotationUsage : Annotations()) {
+            ES2PANDA_ASSERT(annotationUsage->Clone(allocator, clone));
             annotationUsages.push_back(annotationUsage->Clone(allocator, clone)->AsAnnotationUsage());
         }
         clone->SetAnnotations(std::move(annotationUsages));
diff --git a/ets2panda/ir/expressions/arrayExpression.cpp b/ets2panda/ir/expressions/arrayExpression.cpp
index 3e0a753d33a91d0f811565bffbf976da5592a430..76bc0c22bcad75860b20e7979b2d9b2bd89e8d3f 100644
--- a/ets2panda/ir/expressions/arrayExpression.cpp
+++ b/ets2panda/ir/expressions/arrayExpression.cpp
@@ -48,6 +48,7 @@ ArrayExpression::ArrayExpression([[maybe_unused]] Tag const tag, ArrayExpression
 ArrayExpression *ArrayExpression::Clone(ArenaAllocator *const allocator, AstNode *const parent)
 {
     auto *const clone = allocator->New<ArrayExpression>(Tag {}, *this, allocator);
+    ES2PANDA_ASSERT(clone);
     if (parent != nullptr) {
         clone->SetParent(parent);
     }
@@ -345,6 +346,7 @@ checker::Type *ArrayExpression::CheckPattern(checker::TSChecker *checker)
         index--;
     }
 
+    ES2PANDA_ASSERT(desc);
     const checker::TupleTypeInfo tupleTypeInfo = {combinedFlags, minLength,
                                                   static_cast<uint32_t>(desc->properties.size()), false};
     return checker->CreateTupleType(desc, std::move(elementFlags), tupleTypeInfo);
@@ -422,6 +424,7 @@ checker::VerifiedType ArrayExpression::Check(checker::ETSChecker *checker)
 
 std::optional<checker::Type *> ArrayExpression::ExtractPossiblePreferredType(checker::Type *type)
 {
+    ES2PANDA_ASSERT(type);
     if (type->IsETSArrayType() || type->IsETSTupleType() || type->IsETSResizableArrayType()) {
         return std::make_optional(type);
     }
diff --git a/ets2panda/ir/expressions/arrowFunctionExpression.cpp b/ets2panda/ir/expressions/arrowFunctionExpression.cpp
index 772cf69fc00187f97ae507b676a4bf3f41238c4e..73168b0bd272ca90eb4cb2c934f26518fe534891 100644
--- a/ets2panda/ir/expressions/arrowFunctionExpression.cpp
+++ b/ets2panda/ir/expressions/arrowFunctionExpression.cpp
@@ -83,12 +83,14 @@ checker::VerifiedType ArrowFunctionExpression::Check(checker::ETSChecker *checke
 ArrowFunctionExpression::ArrowFunctionExpression(ArrowFunctionExpression const &other, ArenaAllocator *const allocator)
     : JsDocAllowed<AnnotationAllowed<Expression>>(static_cast<Expression const &>(other), allocator)
 {
+    ES2PANDA_ASSERT(other.func_->Clone(allocator, this));
     func_ = other.func_->Clone(allocator, this)->AsScriptFunction();
 }
 
 ArrowFunctionExpression *ArrowFunctionExpression::Clone(ArenaAllocator *const allocator, AstNode *const parent)
 {
     auto *const clone = allocator->New<ArrowFunctionExpression>(*this, allocator);
+    ES2PANDA_ASSERT(clone);
 
     if (parent != nullptr) {
         clone->SetParent(parent);
@@ -115,6 +117,7 @@ ir::TypeNode *ArrowFunctionExpression::CreateReturnNodeFromType(checker::ETSChec
     auto *ident = checker->AllocNode<ir::Identifier>(util::StringView(""), checker->Allocator());
     auto *const part = checker->AllocNode<ir::ETSTypeReferencePart>(ident, checker->Allocator());
     auto *returnNode = checker->AllocNode<ir::ETSTypeReference>(part, checker->Allocator());
+    ES2PANDA_ASSERT(returnNode);
     returnNode->SetTsType(returnType);
     return returnNode;
 }
diff --git a/ets2panda/ir/expressions/assignmentExpression.cpp b/ets2panda/ir/expressions/assignmentExpression.cpp
index d6ff928480d45c4bc8df7b2dd6c477c1795f5945..2505910c5f663426231c9b860261e1ff6eb67cf2 100644
--- a/ets2panda/ir/expressions/assignmentExpression.cpp
+++ b/ets2panda/ir/expressions/assignmentExpression.cpp
@@ -169,6 +169,7 @@ AssignmentExpression *AssignmentExpression::Clone(ArenaAllocator *const allocato
     auto *const left = left_ != nullptr ? left_->Clone(allocator, nullptr)->AsExpression() : nullptr;
     auto *const right = right_ != nullptr ? right_->Clone(allocator, nullptr)->AsExpression() : nullptr;
     auto *const clone = allocator->New<AssignmentExpression>(Tag {}, *this, left, right);
+    ES2PANDA_ASSERT(clone);
 
     if (parent != nullptr) {
         clone->SetParent(parent);
diff --git a/ets2panda/ir/expressions/awaitExpression.cpp b/ets2panda/ir/expressions/awaitExpression.cpp
index 6071bd415566f9e8464bb35b442657090727777f..d9e6b54668008d143b2a88f3adfde348c52e06dd 100644
--- a/ets2panda/ir/expressions/awaitExpression.cpp
+++ b/ets2panda/ir/expressions/awaitExpression.cpp
@@ -74,6 +74,7 @@ AwaitExpression *AwaitExpression::Clone(ArenaAllocator *const allocator, AstNode
 {
     auto *const argument = argument_ != nullptr ? argument_->Clone(allocator, nullptr)->AsExpression() : nullptr;
     auto *const clone = allocator->New<AwaitExpression>(argument);
+    ES2PANDA_ASSERT(clone);
 
     if (argument != nullptr) {
         argument->SetParent(clone);
diff --git a/ets2panda/ir/expressions/binaryExpression.cpp b/ets2panda/ir/expressions/binaryExpression.cpp
index 21babd5626bdef88c2f2888de6318c7058a1bfec..ddfd3f3a066b1d9d27368a81677aa8efa496787c 100644
--- a/ets2panda/ir/expressions/binaryExpression.cpp
+++ b/ets2panda/ir/expressions/binaryExpression.cpp
@@ -99,6 +99,7 @@ BinaryExpression *BinaryExpression::Clone(ArenaAllocator *const allocator, AstNo
     auto *const left = left_ != nullptr ? left_->Clone(allocator, nullptr)->AsExpression() : nullptr;
     auto *const right = right_ != nullptr ? right_->Clone(allocator, nullptr)->AsExpression() : nullptr;
     auto *const clone = allocator->New<BinaryExpression>(left, right, operator_);
+    ES2PANDA_ASSERT(clone);
 
     if (operationType_ != nullptr) {
         clone->SetOperationType(operationType_);
diff --git a/ets2panda/ir/expressions/binaryExpression.h b/ets2panda/ir/expressions/binaryExpression.h
index 97de660fce53c06823ac88ff072d5dc3e7b058a9..87c4377c8668a3e8449d9a40cd09275ff52da9eb 100644
--- a/ets2panda/ir/expressions/binaryExpression.h
+++ b/ets2panda/ir/expressions/binaryExpression.h
@@ -113,12 +113,14 @@ public:
     void SetLeft(Expression *expr) noexcept
     {
         left_ = expr;
+        ES2PANDA_ASSERT(left_);
         left_->SetParent(this);
     }
 
     void SetRight(Expression *expr) noexcept
     {
         right_ = expr;
+        ES2PANDA_ASSERT(right_);
         right_->SetParent(this);
     }
 
diff --git a/ets2panda/ir/expressions/blockExpression.cpp b/ets2panda/ir/expressions/blockExpression.cpp
index c38cb577107be65d90d5b14663582df782b9d698..853f4973fc05b72ead4e21d302bcbce5a85f5bc8 100644
--- a/ets2panda/ir/expressions/blockExpression.cpp
+++ b/ets2panda/ir/expressions/blockExpression.cpp
@@ -40,6 +40,7 @@ BlockExpression::BlockExpression([[maybe_unused]] Tag const tag, BlockExpression
 BlockExpression *BlockExpression::Clone(ArenaAllocator *const allocator, AstNode *const parent)
 {
     auto *const clone = allocator->New<BlockExpression>(Tag {}, *this, allocator);
+    ES2PANDA_ASSERT(clone);
     if (parent != nullptr) {
         clone->SetParent(parent);
     }