diff --git a/ets2panda/compiler/lowering/ets/constantExpressionLowering.cpp b/ets2panda/compiler/lowering/ets/constantExpressionLowering.cpp
index de86a2313ab186649edd530ebc81029884aa2ead..96da74bb4bfd40af081062b4814b08f8cad5c379 100644
--- a/ets2panda/compiler/lowering/ets/constantExpressionLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/constantExpressionLowering.cpp
@@ -346,6 +346,7 @@ ir::AstNode *ConstantExpressionLowering::FoldBinaryBooleanConstant(ir::BinaryExp
     }
 
     auto resNode = util::NodeAllocator::Alloc<ir::BooleanLiteral>(context_->allocator, result);
+    ES2PANDA_ASSERT(resNode);
     resNode->SetParent(expr->Parent());
     resNode->SetRange(expr->Range());
     return resNode;
@@ -545,6 +546,7 @@ ir::AstNode *ConstantExpressionLowering::FoldBinaryStringConstant(ir::BinaryExpr
     auto const rhs = expr->Right()->AsLiteral();
     auto const resStr = util::UString(lhs->ToString() + rhs->ToString(), context_->allocator).View();
     auto resNode = util::NodeAllocator::Alloc<ir::StringLiteral>(context_->allocator, resStr);
+    ES2PANDA_ASSERT(resNode);
     resNode->SetParent(expr->Parent());
     resNode->SetRange(expr->Range());
     return resNode;
@@ -758,6 +760,7 @@ ir::AstNode *ConstantExpressionLowering::FoldTSAsExpression(ir::TSAsExpression *
 ir::AstNode *ConstantExpressionLowering::FoldMultilineString(ir::TemplateLiteral *expr)
 {
     auto *result = util::NodeAllocator::Alloc<ir::StringLiteral>(context_->allocator, expr->GetMultilineString());
+    ES2PANDA_ASSERT(result);
     result->SetParent(expr->Parent());
     result->SetRange(expr->Range());
     return result;
diff --git a/ets2panda/compiler/lowering/ets/declareOverloadLowering.cpp b/ets2panda/compiler/lowering/ets/declareOverloadLowering.cpp
index 613fcf10d239657b8c98836c6c3e3fda9bf9e6a2..1acc1c8299234ed4e624b2ee1df0a8e72db09288 100644
--- a/ets2panda/compiler/lowering/ets/declareOverloadLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/declareOverloadLowering.cpp
@@ -34,6 +34,7 @@ void GenerateOverloadHelperParams(public_lib::Context *ctx, uint32_t minArg, siz
             id->SetTsTypeAnnotation(typeAnnotation);
             typeAnnotation->SetParent(id);
             auto *param = ctx->AllocNode<ir::ETSParameterExpression>(id, false, allocator);
+            ES2PANDA_ASSERT(param);
             param->SetOptional(idx >= minArg);
             params.push_back(param);
         }
@@ -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 d9ede70dc70e83d757ebbd3be280e8859230dada..ed4192d4e8161e33ae370fa009cf76909316ff25 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,7 +105,8 @@ static ir::TSTypeParameterInstantiation *CreateTypeParameterInstantiation(ir::Me
 {
     auto const allocator = ctx->allocator;
 
-    if (method->Function()->TypeParams() == nullptr || method->Function()->TypeParams()->Params().empty()) {
+    if ((method->Function() != nullptr && method->Function()->TypeParams() == nullptr) ||
+        method->Function()->TypeParams()->Params().empty()) {
         return nullptr;
     }
     ArenaVector<ir::TypeNode *> selfParams(allocator->Adapter());
@@ -131,6 +134,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);
     overloadMethod->SetRange(funcExpression->Range());
 
+    ES2PANDA_ASSERT(overloadMethod->Function());
     if (!method->IsDeclare() && method->Parent()->IsTSInterfaceBody()) {
         overloadMethod->Function()->Body()->AsBlockStatement()->Statements().clear();
     }
@@ -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()) {
@@ -219,6 +226,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());
@@ -245,7 +253,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 f13666933d9ab14102abba97996caf3a3c318257..5212c1dc3aa91576605416533d3baf9bac12d896 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;
@@ -413,13 +414,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);
@@ -791,11 +796,13 @@ ir::VariableDeclaration *CreateForLoopInitVariableDeclaration(public_lib::Contex
 {
     auto *const init = ctx->AllocNode<ir::NumberLiteral>("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 3cb3fd1c2420f8c3a13d1f197cdf293462aadae3..029659c5479d027ae420120a10bb206f60fb449e 100644
--- a/ets2panda/compiler/lowering/ets/exportAnonymousConst.cpp
+++ b/ets2panda/compiler/lowering/ets/exportAnonymousConst.cpp
@@ -103,6 +103,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 36ce44662c2927b1139654dd7e32ccc261bc7a98..08056414191c1854a285f4b64436d36497699d97 100644
--- a/ets2panda/compiler/lowering/ets/genericBridgesLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/genericBridgesLowering.cpp
@@ -86,6 +86,7 @@ void GenericBridgesPhase::AddGenericBridge(ir::ClassDefinition const *const clas
 
     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());
@@ -143,6 +144,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;
@@ -214,6 +216,7 @@ void GenericBridgesPhase::CreateGenericBridges(ir::ClassDefinition const *const
         if (item->IsMethodDefinition()) {
             // Skip `static`, `final` and special methods...
             auto *const method = item->AsMethodDefinition();
+            ES2PANDA_ASSERT(method->Id());
             if (method->Kind() != ir::MethodDefinitionKind::METHOD || method->IsStatic() || method->IsFinal() ||
                 method->Id()->Name().Utf8().find("lambda$invoke$") != std::string_view::npos) {
                 continue;
@@ -272,7 +275,7 @@ void GenericBridgesPhase::ProcessInterfaces(ir::ClassDefinition *const classDefi
             !typeParameters.empty()) {
             if (Substitutions substitutions = GetSubstitutions(interfaceType, typeParameters);
                 // NOLINTNEXTLINE(clang-analyzer-core.CallAndMessage)
-                !substitutions.derivedSubstitutions->empty()) {
+                (substitutions.derivedSubstitutions != nullptr) && !substitutions.derivedSubstitutions->empty()) {
                 ES2PANDA_ASSERT(interfaceType->GetDeclNode()->IsTSInterfaceDeclaration());
                 auto const &interfaceBody = interfaceType->GetDeclNode()->AsTSInterfaceDeclaration()->Body()->Body();
                 CreateGenericBridges(classDefinition, substitutions, interfaceBody);
@@ -303,6 +306,7 @@ ir::ClassDefinition *GenericBridgesPhase::ProcessClassDefinition(ir::ClassDefini
     //  Check if the class derived from base generic class has either explicit class type substitutions
     //  or type parameters with narrowing constraints.
     if (Substitutions substitutions = GetSubstitutions(superType, typeParameters);
+        (substitutions.derivedSubstitutions != nullptr) &&
         // NOLINTNEXTLINE(clang-analyzer-core.CallAndMessage)
         !substitutions.derivedSubstitutions->empty()) {
         // If it has, then probably the generic bridges should be created.
diff --git a/ets2panda/compiler/lowering/ets/interfaceObjectLiteralLowering.cpp b/ets2panda/compiler/lowering/ets/interfaceObjectLiteralLowering.cpp
index 7b00e071ae2c56fa630d4cef0600dfb96bc87f85..a709cf3eb3a7893a323edc8c80d0b2b768e52152 100644
--- a/ets2panda/compiler/lowering/ets/interfaceObjectLiteralLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/interfaceObjectLiteralLowering.cpp
@@ -72,6 +72,7 @@ static ir::ClassProperty *CreateAnonClassField(public_lib::Context *ctx, ir::Met
 {
     auto *const parser = ctx->parser->AsETSParser();
     // Field type annotation
+    ES2PANDA_ASSERT(ifaceMethod->Function());
     auto *fieldType = ifaceMethod->Function()->Signature()->ReturnType();
 
     std::stringstream sourceCode;
@@ -105,7 +106,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)
@@ -131,6 +132,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;
         }
@@ -201,6 +203,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);
@@ -254,6 +257,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->Implements().emplace_back(classImplements);
     classType->RemoveObjectFlag(checker::ETSObjectFlags::RESOLVED_INTERFACES);
@@ -331,6 +335,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();
@@ -379,6 +384,7 @@ static bool CheckInterfaceShouldGenerateAnonClass(ir::TSInterfaceDeclaration *in
     for (auto it : interfaceDecl->Body()->Body()) {
         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 c997421bf42b9febfd62a42c2a879aaa40d7fabd..f9832dc3c3444d6b2c7390c7a77b187eb43555ae 100644
--- a/ets2panda/compiler/lowering/ets/interfacePropertyDeclarations.cpp
+++ b/ets2panda/compiler/lowering/ets/interfacePropertyDeclarations.cpp
@@ -191,6 +191,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 0ea93f02a8c58dbb0302e2a799b8d8808bd9c01c..57226eb79c7d64326267003c1dadefe941f51c17 100644
--- a/ets2panda/compiler/lowering/ets/lambdaLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/lambdaLowering.cpp
@@ -112,6 +112,7 @@ static std::pair<ir::TSTypeParameterDeclaration *, checker::Substitution *> Clon
         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());
@@ -186,6 +187,7 @@ ParamsAndVarMap CreateLambdaCalleeParameters(public_lib::Context *ctx, ir::Arrow
         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()});
@@ -287,6 +289,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);
@@ -332,10 +335,8 @@ static ir::MethodDefinition *CreateCalleeMethod(public_lib::Context *ctx, ir::Ar
     auto [params, vMap] = CreateLambdaCalleeParameters(ctx, lambda, *info->capturedVars, paramScope, substitution);
     auto varMap = std::move(vMap);
 
-    auto *returnType =
-        cmInfo->forcedReturnType != nullptr
-            ? cmInfo->forcedReturnType
-            : lambda->Function()->Signature()->ReturnType()->Substitute(checker->Relation(), substitution);
+    auto *alternative = lambda->Function()->Signature()->ReturnType()->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;
@@ -351,6 +352,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);
@@ -370,9 +372,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);
@@ -485,6 +486,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);
 
@@ -560,7 +562,7 @@ static ArenaVector<ark::es2panda::ir::Statement *> CreateRestArgumentsArrayReall
             lciInfo->restParameterIdentifier, lciInfo->restArgumentIdentifier, restParameterIndex, spreadArrIterator,
             checker->MaybeBoxType(elementType), restParameterIndex, restParameterIndex);
     }
-
+    ES2PANDA_ASSERT(args);
     return ArenaVector<ir::Statement *>(std::move(args->AsBlockStatement()->Statements()));
 }
 
@@ -572,6 +574,7 @@ static void CreateInvokeMethodRestParameter(public_lib::Context *ctx, LambdaClas
     auto *anyType = checker->GlobalETSNullishObjectType();
 
     auto *restIdent = Gensym(allocator);
+    ES2PANDA_ASSERT(restIdent);
     lciInfo->restParameterIdentifier = restIdent->Name();
     lciInfo->restArgumentIdentifier = GenName(allocator).View();
     auto *spread = allocator->New<ir::SpreadElement>(ir::AstNodeType::REST_ELEMENT, allocator, restIdent);
@@ -747,6 +750,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
@@ -807,6 +811,7 @@ static ir::ClassDeclaration *CreateEmptyLambdaClassDeclaration(public_lib::Conte
     auto lambdaClassName = util::UString {std::string_view {"LambdaObject-"}, allocator};
     lambdaClassName.Append(info->calleeClass->Definition()->Ident()->Name()).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()),
@@ -857,6 +862,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);
@@ -916,8 +922,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);
@@ -1002,6 +1010,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;
 }
@@ -1017,6 +1026,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);
@@ -1034,6 +1044,7 @@ static ir::ArrowFunctionExpression *CreateWrappingLambda(public_lib::Context *ct
     return lambda;
 }
 
+// CC-OFFNXT(G.FUN.01, huge_method, huge_method[C++]) solid logic, false positive
 static ir::AstNode *ConvertFunctionReference(public_lib::Context *ctx, ir::Expression *funcRef)
 {
     auto *allocator = ctx->allocator;
@@ -1089,6 +1100,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;
@@ -1110,6 +1122,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;
@@ -1150,6 +1163,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 a6e6b950983766166f77e7e65d014c0ce1fcfa61..ec9d7ee9b3ba7e39c348a48ac8d8e0301a657a2d 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);
@@ -75,6 +76,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 da4e93b20cfb8845d2cff05be1bf53c282ece6d1..5171fe133864ebe9b2eab8c5caf569da63a10718 100644
--- a/ets2panda/ir/ets/etsFunctionType.cpp
+++ b/ets2panda/ir/ets/etsFunctionType.cpp
@@ -155,6 +155,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 2ef166609288b774f55bb89e223977d81fea4b44..66f076e6fdee59297dfce6b189caee144a55f3d3 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 79284dd1f72e3bf37538f07f13547c9a08a41bbd..5139f9c4fe7a68ac15db8a12f191b081c51ad96b 100644
--- a/ets2panda/ir/ets/etsNeverType.cpp
+++ b/ets2panda/ir/ets/etsNeverType.cpp
@@ -73,6 +73,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 a3356c3c103d6a17d9f3d1eaad53923fad831539..3df900701aff6ab9f48a5c96ab0779720c35634d 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 a79d71241b0af99b3416c312c92d79ebd67b382e..78ea464ef9d54918413d1a9e4b7317e07382fa79 100644
--- a/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp
+++ b/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp
@@ -107,6 +107,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 e3e9e7983678fd1e341b4ef1e288950800243472..602945adc4f17fcbd88286999284d9a172c91bb2 100644
--- a/ets2panda/ir/ets/etsNullishTypes.cpp
+++ b/ets2panda/ir/ets/etsNullishTypes.cpp
@@ -73,6 +73,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);
@@ -151,6 +152,7 @@ ETSNullType *ETSNullType::Clone(ArenaAllocator *allocator, AstNode *parent)
     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 382a8a6f11307c438870e9c002f40da30a43ce66..4f1f3753690c421843216edbbca48fc29b9e347a 100644
--- a/ets2panda/ir/ets/etsParameterExpression.cpp
+++ b/ets2panda/ir/ets/etsParameterExpression.cpp
@@ -247,6 +247,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 a38f760c793ff653d24e7e5edfa41a74573c16ca..91013b337227f510afe3903b47dc8dac45364306 100644
--- a/ets2panda/ir/ets/etsParameterExpression.h
+++ b/ets2panda/ir/ets/etsParameterExpression.h
@@ -49,6 +49,7 @@ public:
     void SetIdent(Identifier *ident) noexcept
     {
         ident_ = ident;
+        ES2PANDA_ASSERT(ident_);
         ident_->SetParent(this);
     }
 
diff --git a/ets2panda/ir/ets/etsPrimitiveType.cpp b/ets2panda/ir/ets/etsPrimitiveType.cpp
index c18f74350262d4994bce708bdd606cfcf57c1501..58f800f0ab161895e5fd8dceb84b5d5ea503203b 100644
--- a/ets2panda/ir/ets/etsPrimitiveType.cpp
+++ b/ets2panda/ir/ets/etsPrimitiveType.cpp
@@ -167,6 +167,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 d6227f2673e079f710a6e1bb7661a3a91c444be0..83a867e97d1ac9ab23683128b6006d0975b59a1e 100644
--- a/ets2panda/ir/ets/etsStringLiteralType.cpp
+++ b/ets2panda/ir/ets/etsStringLiteralType.cpp
@@ -82,6 +82,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 b79654c62e2da4901d7417d113a0791d3bb46375..8de5db97f1f4df7f4b0ebc4fa7e27ca6c6d550d2 100644
--- a/ets2panda/ir/ets/etsTuple.cpp
+++ b/ets2panda/ir/ets/etsTuple.cpp
@@ -127,6 +127,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();
     }
 
@@ -137,6 +138,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 3c7089b10f5d1f33e88d8b90a5a052bc7857f3cb..9d309f0b38cf7a1857d370b31e46ddbf247335e3 100644
--- a/ets2panda/ir/ets/etsTypeReferencePart.cpp
+++ b/ets2panda/ir/ets/etsTypeReferencePart.cpp
@@ -257,6 +257,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 39860832e491e56ec059c3e1f62a180d340bbe25..b454c1bf79761e0fe45f30c16c014973df1187a6 100644
--- a/ets2panda/ir/ets/etsUnionType.cpp
+++ b/ets2panda/ir/ets/etsUnionType.cpp
@@ -127,6 +127,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 cc9ec6588560011295baac64bb84f597b5168aae..a8d90d7e863840211fcb0805c5f73933f96f5e96 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);
@@ -413,6 +415,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 c4941954ec3ff972584c78b318450cca6746c6d6..dde0cd72a6e3b40f062bee2bc0c7126a67de3ac3 100644
--- a/ets2panda/ir/expressions/arrowFunctionExpression.cpp
+++ b/ets2panda/ir/expressions/arrowFunctionExpression.cpp
@@ -88,12 +88,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);
@@ -120,6 +122,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 e7accbe3b4a56cf65f2b510df1257a36ec202324..7c5d8fa200c901ca3209366d5ba210c11f47158f 100644
--- a/ets2panda/ir/expressions/binaryExpression.h
+++ b/ets2panda/ir/expressions/binaryExpression.h
@@ -113,6 +113,7 @@ public:
     void SetLeft(Expression *expr) noexcept
     {
         left_ = expr;
+        ES2PANDA_ASSERT(left_);
         left_->SetParent(this);
         SetStart(left_->Start());
     }
@@ -120,6 +121,7 @@ public:
     void SetRight(Expression *expr) noexcept
     {
         right_ = expr;
+        ES2PANDA_ASSERT(right_);
         right_->SetParent(this);
         SetEnd(right_->End());
     }
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);
     }