diff --git a/ets2panda/compiler/lowering/ets/localClassLowering.cpp b/ets2panda/compiler/lowering/ets/localClassLowering.cpp
index 4de051d1eacfedaace392b86123a90393ddd58d2..c5bc5fd80b62a19db7d399769cb0140d124feb82 100644
--- a/ets2panda/compiler/lowering/ets/localClassLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/localClassLowering.cpp
@@ -52,6 +52,7 @@ static ir::ClassProperty *CreateCapturedField(public_lib::Context *ctx, const va
     var->SetTsType(capturedVar->TsType());
 
     fieldIdent->SetVariable(var);
+    ES2PANDA_ASSERT(field != nullptr);
     field->SetTsType(capturedVar->TsType());
     decl->BindNode(field);
     return field;
@@ -91,6 +92,7 @@ void LocalClassConstructionPhase::CreateClassPropertiesForCapturedVariables(
         LOG(DEBUG, ES2PANDA) << "  - Creating property (" << property->Id()->Name()
                              << ") for captured variable: " << var->Name();
         properties.push_back(property);
+        ES2PANDA_ASSERT(property->Id() != nullptr);
         variableMap[var] = property->Id()->Variable();
         propertyMap[var] = property;
         idx++;
@@ -199,6 +201,7 @@ void LocalClassConstructionPhase::RemapReferencesFromCapturedVariablesToClassPro
         if (it->IsMethodDefinition() && !it->AsMethodDefinition()->IsConstructor()) {
             LOG(DEBUG, ES2PANDA) << "  - Rebinding variable rerferences in: "
                                  << it->AsMethodDefinition()->Id()->Name().Mutf8().c_str();
+            ES2PANDA_ASSERT(it->AsMethodDefinition()->Function() != nullptr);
             if (it->AsMethodDefinition()->Function()->Body() == nullptr &&
                 it->AsMethodDefinition()->AsyncPairMethod() != nullptr) {
                 it->AsMethodDefinition()->AsyncPairMethod()->Function()->Body()->IterateRecursively(
diff --git a/ets2panda/compiler/lowering/ets/objectIndexAccess.cpp b/ets2panda/compiler/lowering/ets/objectIndexAccess.cpp
index deefde6145b899278ad075e57cc06081c2aff4da..73717301b78821f2a824838fd063293fc1cd73c6 100644
--- a/ets2panda/compiler/lowering/ets/objectIndexAccess.cpp
+++ b/ets2panda/compiler/lowering/ets/objectIndexAccess.cpp
@@ -71,6 +71,7 @@ ir::Expression *ObjectIndexLowering::ProcessIndexSetAccess(parser::ETSParser *pa
                                                            memberExpression->Property(), assignmentExpression->Right());
         setter = loweringResult;
     }
+    ES2PANDA_ASSERT(loweringResult != nullptr);
     loweringResult->SetParent(assignmentExpression->Parent());
     loweringResult->SetRange(assignmentExpression->Range());
     loweringResult->SetBoxingUnboxingFlags(assignmentExpression->GetBoxingUnboxingFlags());
diff --git a/ets2panda/compiler/lowering/ets/objectIterator.cpp b/ets2panda/compiler/lowering/ets/objectIterator.cpp
index cf43ac31d1e336ef4535651a524e674094e13657..1901de498828f077c2abc2a4a2ede6de829a0b04 100644
--- a/ets2panda/compiler/lowering/ets/objectIterator.cpp
+++ b/ets2panda/compiler/lowering/ets/objectIterator.cpp
@@ -108,6 +108,7 @@ static ir::OpaqueTypeNode *FindIterValueType(checker::ETSObjectType *type, Arena
                                    checker::PropertySearchFlags::SEARCH_INSTANCE_METHOD |
                                        checker::PropertySearchFlags::SEARCH_IN_INTERFACES |
                                        checker::PropertySearchFlags::SEARCH_IN_BASE);
+    ES2PANDA_ASSERT(itor != nullptr);
     auto const &sigs = itor->TsType()->AsETSFunctionType()->CallSignatures();
     checker::ETSObjectType *itorReturnType = nullptr;
     for (auto &sig : sigs) {
@@ -170,6 +171,7 @@ ir::Statement *ObjectIteratorLowering::ProcessObjectIterator(public_lib::Context
     auto *const loweringResult = parser->CreateFormattedStatement(
         whileStatement, iterIdent, forOfStatement->Right(), nextIdent, iterIdent->Clone(allocator, nullptr),
         nextIdent->Clone(allocator, nullptr), loopVariableIdent, nextIdent->Clone(allocator, nullptr), typeNode);
+    ES2PANDA_ASSERT(loweringResult != nullptr);
     loweringResult->SetParent(forOfStatement->Parent());
     loweringResult->SetRange(forOfStatement->Range());
 
diff --git a/ets2panda/compiler/lowering/ets/objectLiteralLowering.cpp b/ets2panda/compiler/lowering/ets/objectLiteralLowering.cpp
index bcc71b964c1dd50abe852128bbca11b20b63d1dd..96f8c83ca93b1de30a4d2125522211fbba4b7050 100644
--- a/ets2panda/compiler/lowering/ets/objectLiteralLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/objectLiteralLowering.cpp
@@ -100,6 +100,7 @@ static void AllowRequiredTypeInstantiation(const ir::Expression *const loweringR
 static bool CheckReadonlyAndUpdateCtorArgs(const ir::Identifier *key, ir::Expression *value,
                                            std::map<util::StringView, ir::Expression *> &ctorArgumentsMap)
 {
+    ES2PANDA_ASSERT(key != nullptr);
     auto varType = (key->Variable() != nullptr) ? key->Variable()->TsType() : nullptr;
     if (varType == nullptr || varType->HasTypeFlag(checker::TypeFlag::SETTER)) {
         return false;
@@ -162,6 +163,18 @@ static void SetInstanceArguments(ArenaVector<ir::Statement *> &statements, Arena
     instance->SetArguments(std::move(ctorArguments));
 }
 
+static void GenerateArgsForAnonymousClassType(const checker::ETSObjectType *classType, const bool &isAnonymous,
+                                              std::map<util::StringView, ir::Expression *> &ctorArgumentsMap)
+{
+    if (isAnonymous) {
+        checker::Signature *sig = classType->ConstructSignatures().front();
+        for (auto param : sig->Params()) {
+            ES2PANDA_ASSERT(param->Declaration() != nullptr);
+            ctorArgumentsMap.emplace(param->Declaration()->Name(), nullptr);
+        }
+    }
+}
+
 static void GenerateNewStatements(public_lib::Context *ctx, ir::ObjectExpression *objExpr, std::stringstream &ss,
                                   std::vector<ir::AstNode *> &newStmts,
                                   std::deque<ir::BlockExpression *> &nestedBlckExprs,
@@ -186,13 +199,7 @@ static void GenerateNewStatements(public_lib::Context *ctx, ir::ObjectExpression
     bool isAnonymous = IsAnonymousClassType(classType);
 
     std::map<util::StringView, ir::Expression *> ctorArgumentsMap;
-    if (isAnonymous) {
-        checker::Signature *sig = classType->ConstructSignatures().front();
-        for (auto param : sig->Params()) {
-            ES2PANDA_ASSERT(param->Declaration() != nullptr);
-            ctorArgumentsMap.emplace(param->Declaration()->Name(), nullptr);
-        }
-    }
+    GenerateArgsForAnonymousClassType(classType, isAnonymous, ctorArgumentsMap);
 
     for (auto *propExpr : objExpr->Properties()) {
         //  Skip possibly invalid properties:
@@ -218,7 +225,7 @@ static void GenerateNewStatements(public_lib::Context *ctx, ir::ObjectExpression
         if (isAnonymous && CheckReadonlyAndUpdateCtorArgs(keyIdent, value, ctorArgumentsMap)) {
             continue;
         }
-
+        ES2PANDA_ASSERT(genSymIdent != nullptr);
         ss << "@@I" << addNode(genSymIdent->Clone(allocator, nullptr)) << ".@@I" << addNode(keyIdent);
 
         if (value->IsBlockExpression()) {
@@ -269,7 +276,7 @@ static ir::AstNode *HandleObjectLiteralLowering(public_lib::Context *ctx, ir::Ob
     GenerateNewStatements(ctx, objExpr, ss, newStmts, nestedBlckExprs, ctorArguments);
 
     auto *loweringResult = parser->CreateFormattedExpression(ss.str(), newStmts);
-
+    ES2PANDA_ASSERT(loweringResult != nullptr);
     SetInstanceArguments(loweringResult->AsBlockExpression()->Statements(), ctorArguments);
 
     loweringResult->SetParent(objExpr->Parent());
diff --git a/ets2panda/compiler/lowering/ets/opAssignment.cpp b/ets2panda/compiler/lowering/ets/opAssignment.cpp
index 62e38b69c3584f143f715898bf6fb91ba450a01b..bdffff251f0a6cbda2d687eb2bb8c48528e5ddfc 100644
--- a/ets2panda/compiler/lowering/ets/opAssignment.cpp
+++ b/ets2panda/compiler/lowering/ets/opAssignment.cpp
@@ -94,7 +94,7 @@ void AdjustBoxingUnboxingFlags(ir::Expression *loweringResult, const ir::Express
                                                  ir::BoxingUnboxingFlags::BOXING_FLAG};
     const ir::BoxingUnboxingFlags oldUnboxingFlag {oldExpr->GetBoxingUnboxingFlags() &
                                                    ir::BoxingUnboxingFlags::UNBOXING_FLAG};
-
+    ES2PANDA_ASSERT(exprToProcess != nullptr);
     if (exprToProcess->TsType()->IsETSPrimitiveType()) {
         loweringResult->SetBoxingUnboxingFlags(oldBoxingFlag);
     } else if (exprToProcess->TsType()->IsETSObjectType()) {
diff --git a/ets2panda/compiler/lowering/ets/optionalArgumentsLowering.cpp b/ets2panda/compiler/lowering/ets/optionalArgumentsLowering.cpp
index 969fabd2d239b014c47a4b38e2fd6e2f087a1705..469c1ca5208f95fb6e60421f610eefa79f9b4353 100644
--- a/ets2panda/compiler/lowering/ets/optionalArgumentsLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/optionalArgumentsLowering.cpp
@@ -58,6 +58,7 @@ static void TransformArguments(public_lib::Context *ctx, ir::Expression *callLik
     size_t missing = signature->ArgCount() - arguments.size();
     for (size_t i = 0; i < missing; ++i) {
         auto undefArg = allocator->New<ir::UndefinedLiteral>();
+        ES2PANDA_ASSERT(undefArg != nullptr);
         undefArg->SetTsType(checker->GlobalETSUndefinedType());
         arguments.push_back(undefArg);
         undefArg->SetParent(callLike);
diff --git a/ets2panda/compiler/lowering/ets/optionalLowering.cpp b/ets2panda/compiler/lowering/ets/optionalLowering.cpp
index 36f6aefe14a1df3ba9bcb720ac5b29ae5ac17b21..73c5b83e858f8ac06c1066f823efca2b838a3a76 100644
--- a/ets2panda/compiler/lowering/ets/optionalLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/optionalLowering.cpp
@@ -39,6 +39,7 @@ static ir::AstNode *LowerOptionalExpr(GetSource const &getSource, SetSource cons
 
     auto expressionCtx = varbinder::LexicalScope<varbinder::Scope>::Enter(varbinder, NearestScope(expr));
     auto *tmpIdent = Gensym(allocator);
+    ES2PANDA_ASSERT(tmpIdent != nullptr);
     auto *tmpIdentClone = tmpIdent->Clone(allocator, nullptr);
 
     // '0's act as placeholders
diff --git a/ets2panda/compiler/lowering/ets/recordLowering.cpp b/ets2panda/compiler/lowering/ets/recordLowering.cpp
index 8897cd7ddb4e521edb24814712738a325dfb6951..de8b7bc3169aebbdaebe0a1274161618ea2014d2 100644
--- a/ets2panda/compiler/lowering/ets/recordLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/recordLowering.cpp
@@ -185,6 +185,7 @@ ir::Expression *RecordLowering::UpdateObjectExpression(ir::ObjectExpression *exp
 
     // Create Block Expression
     auto block = CreateBlockExpression(expr, typeArguments[0], typeArguments[1], ctx);
+    ES2PANDA_ASSERT(block != nullptr);
     block->SetParent(expr->Parent());
 
     // Run checks
diff --git a/ets2panda/compiler/lowering/ets/resizableArrayLowering.cpp b/ets2panda/compiler/lowering/ets/resizableArrayLowering.cpp
index 12d58293e39aac300a120e5a9be316f38bb8746c..77a38420fb388c6d3e01f2a08a5d5ed2f335d12b 100644
--- a/ets2panda/compiler/lowering/ets/resizableArrayLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/resizableArrayLowering.cpp
@@ -27,6 +27,7 @@ static ir::AstNode *ConvertToResizableArrayType(ir::TSArrayType *node, public_li
     auto *parser = ctx->parser->AsETSParser();
     ir::TypeNode *typeAnnotation =
         parser->CreateFormattedTypeAnnotation("Array<" + node->ElementType()->DumpEtsSrc() + ">");
+    ES2PANDA_ASSERT(typeAnnotation != nullptr);
     typeAnnotation->SetAnnotations(std::move(node->Annotations()));
     typeAnnotation->SetParent(node->Parent());
     typeAnnotation->SetRange(node->Range());
diff --git a/ets2panda/compiler/lowering/ets/restArgsLowering.cpp b/ets2panda/compiler/lowering/ets/restArgsLowering.cpp
index 224e98033560d2240fcfd1498fc54056b0af6138..e8c8c4efbe1d60b1b198576e62365e9a9d1d6464 100644
--- a/ets2panda/compiler/lowering/ets/restArgsLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/restArgsLowering.cpp
@@ -51,6 +51,7 @@ static ir::BlockExpression *CreateRestArgsBlockExpression(public_lib::Context *c
     args.emplace_back(argumentSymbol->Clone(allocator, nullptr));
     ss << "@@I3[@@I4] = @@I5;";
     args.emplace_back(arraySymbol->Clone(allocator, nullptr));
+    ES2PANDA_ASSERT(iteratorIndex != nullptr);
     args.emplace_back(iteratorIndex->Clone(allocator, nullptr));
     args.emplace_back(iteratorSymbol->Clone(allocator, nullptr));
     ss << "@@I6 = @@I7 + 1;";
@@ -69,6 +70,7 @@ static ir::BlockExpression *ConvertSpreadToBlockExpression(public_lib::Context *
                                                            ir::SpreadElement *spreadElement)
 {
     auto *blockExpression = CreateRestArgsBlockExpression(context, spreadElement);
+    ES2PANDA_ASSERT(blockExpression != nullptr);
     blockExpression->SetParent(spreadElement->Parent());
     blockExpression->SetRange(spreadElement->Range());
 
@@ -111,6 +113,7 @@ static ir::Expression *CreateRestArgsArray(public_lib::Context *context, ArenaVe
     ss << "let @@I1 : FixedArray<@@T2> = @@E3;";
     ss << "Array.from<@@T4>(@@I5);";
     auto *arrayExpr = checker->AllocNode<ir::ArrayExpression>(std::move(copiedArguments), allocator);
+    ES2PANDA_ASSERT(type != nullptr);
     auto *loweringResult =
         parser->CreateFormattedExpression(ss.str(), genSymIdent, type, arrayExpr, type->Clone(allocator, nullptr),
                                           genSymIdent->Clone(allocator, nullptr));
@@ -133,7 +136,7 @@ static ir::CallExpression *RebuildCallExpression(public_lib::Context *context, i
 
     auto *newCall = util::NodeAllocator::ForceSetParent<ir::CallExpression>(allocator, originalCall->Callee(),
                                                                             std::move(newArgs), nullptr, false);
-
+    ES2PANDA_ASSERT(newCall != nullptr);
     restArgsArray->SetParent(newCall);
     newCall->SetParent(originalCall->Parent());
     newCall->AddModifier(originalCall->Modifiers());
diff --git a/ets2panda/compiler/lowering/ets/restTupleLowering.cpp b/ets2panda/compiler/lowering/ets/restTupleLowering.cpp
index 7e9724a1bf1c84794fbcda4e4404e30226645fa3..81d5a02c3f172eb34615050b31c5f650156c3408 100644
--- a/ets2panda/compiler/lowering/ets/restTupleLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/restTupleLowering.cpp
@@ -209,6 +209,7 @@ ir::ArrayExpression *CreateArrayExpression(public_lib::Context *ctx, const Arena
     ArenaVector<ir::Expression *> elements(ctx->Allocator()->Adapter());
 
     auto *arrayExpr = ctx->AllocNode<ir::ArrayExpression>(std::move(elementsInit), ctx->Allocator());
+    ES2PANDA_ASSERT(arrayExpr != nullptr);
     for (auto tupleElementAnno : newRestParams) {
         auto &tupleElementName = tupleElementAnno->AsETSParameterExpression()->Ident()->AsIdentifier()->Name();
         ir::Expression *arg = ctx->AllocNode<ir::Identifier>(tupleElementName, allocator);
@@ -262,6 +263,7 @@ ir::ScriptFunction *CreateNewScriptFunction(public_lib::Context *ctx, ir::Script
         allocator, ir::ScriptFunction::ScriptFunctionData {
                        body, ir::FunctionSignature(newParamDeclaration, std::move(newParams), newReturnTypeAnno),
                        scriptFunc->Flags()});
+    ES2PANDA_ASSERT(newScriptFunc != nullptr);
     newScriptFunc->AddModifier(scriptFunc->AsScriptFunction()->Modifiers());
 
     ArenaVector<ir::AnnotationUsage *> annotationUsages {allocator->Adapter()};
@@ -284,6 +286,7 @@ ir::VariableDeclaration *CreateNewVariableDeclaration(public_lib::Context *ctx,
 
     util::StringView tupleIdentName = restParam->Ident()->Name();
     auto *newId = ctx->AllocNode<ir::Identifier>(tupleIdentName, allocator);
+    ES2PANDA_ASSERT(newId != nullptr);
     ir::TypeNode *typeAnnotation = restParam->TypeAnnotation()->Clone(allocator, newId);
     newId->SetTsTypeAnnotation(typeAnnotation);
     newTuple->SetParent(typeAnnotation);
@@ -322,6 +325,7 @@ ir::MethodDefinition *CreateNewMethodDefinition(public_lib::Context *ctx, ir::Me
     auto *const methodDef =
         ctx->AllocNode<ir::MethodDefinition>(definition->AsMethodDefinition()->Kind(), methodKey, function,
                                              definition->AsMethodDefinition()->Modifiers(), allocator, false);
+    ES2PANDA_ASSERT(methodDef != nullptr);
     methodDef->SetParent(definition->Parent());
 
     return methodDef;
diff --git a/ets2panda/compiler/lowering/ets/spreadLowering.cpp b/ets2panda/compiler/lowering/ets/spreadLowering.cpp
index 1c2f4241cfe1d3dc64d53e299a1d4cf8b96c6e17..6d3dbb95ef392e9b6a19a18b807b63b959a55804 100644
--- a/ets2panda/compiler/lowering/ets/spreadLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/spreadLowering.cpp
@@ -58,6 +58,7 @@ ir::Identifier *CreateNewArrayLengthStatement(public_lib::Context *ctx, ir::Arra
     auto *const allocator = ctx->allocator;
     auto *const parser = ctx->parser->AsETSParser();
     ir::Identifier *newArrayLengthId = Gensym(allocator);
+    ES2PANDA_ASSERT(newArrayLengthId != nullptr);
     std::vector<ir::AstNode *> nodesWaitingInsert {newArrayLengthId->Clone(allocator, nullptr)};
     size_t argumentCount = 1;
     std::stringstream lengthString;
@@ -107,6 +108,7 @@ static ir::Identifier *CreateNewArrayDeclareStatement(public_lib::Context *ctx,
         newArrayDeclareStr << "let @@I1: FixedArray<@@T2> = new (@@T3)[@@I4];" << std::endl;
     }
 
+    ES2PANDA_ASSERT(newArrayLengthId != nullptr);
     ir::Statement *newArrayDeclareSt = parser->CreateFormattedStatement(
         newArrayDeclareStr.str(), newArrayId->Clone(allocator, nullptr), arrayElementType, arrayElementType,
         newArrayLengthId->Clone(allocator, nullptr));
@@ -166,6 +168,7 @@ static ir::Identifier *CreateNewTupleDeclareStatement(public_lib::Context *ctx,
     auto *const allocator = ctx->allocator;
     auto *const parser = ctx->parser->AsETSParser();
     ir::Identifier *newTupleId = Gensym(allocator);
+    ES2PANDA_ASSERT(newTupleId != nullptr);
     checker::ETSTupleType *tupleType = array->TsType()->AsETSTupleType();
 
     std::stringstream newArrayDeclareStr;
@@ -196,6 +199,7 @@ static ir::Statement *CreateElementsAssignStatementBySpreadArr(public_lib::Conte
     elementsAssignStr << "@@I7++;";
     elementsAssignStr << "}";
 
+    ES2PANDA_ASSERT(spreadArrIterator != nullptr);
     ir::Statement *elementsAssignStatement = parser->CreateFormattedStatement(
         elementsAssignStr.str(), spreadArrIterator->Clone(allocator, nullptr), spId->Clone(allocator, nullptr),
         newArrayId->Clone(allocator, nullptr), newArrayIndexId->Clone(allocator, nullptr),
@@ -327,6 +331,7 @@ static ir::BlockExpression *CreateLoweredExpressionForArray(public_lib::Context
     ir::Identifier *newArrayLengthId = CreateNewArrayLengthStatement(ctx, array, spreadArrayIds, statements);
 
     ir::Identifier *newArrayId = CreateNewArrayDeclareStatement(ctx, array, statements, newArrayLengthId);
+    ES2PANDA_ASSERT(newArrayId != nullptr);
     ir::Identifier *newArrayIndexId = Gensym(allocator);
     statements.emplace_back(
         parser->CreateFormattedStatement("let @@I1 = 0", newArrayIndexId->Clone(allocator, nullptr)));
@@ -349,7 +354,7 @@ static ir::BlockExpression *CreateLoweredExpressionForTuple(public_lib::Context
 
     ArenaVector<ir::Statement *> statements(allocator->Adapter());
     ir::Identifier *newTupleId = CreateNewTupleDeclareStatement(ctx, array, statements);
-
+    ES2PANDA_ASSERT(newTupleId != nullptr);
     statements.emplace_back(parser->CreateFormattedStatement("@@I1;", newTupleId->Clone(allocator, nullptr)));
     return checker->AllocNode<ir::BlockExpression>(std::move(statements));
 }
diff --git a/ets2panda/compiler/lowering/ets/stringComparison.cpp b/ets2panda/compiler/lowering/ets/stringComparison.cpp
index e7f0cb4f16fe5e16ef9f78fa01daad65ff108d95..79feda59ebaa8045672a6d6272fad5ffc7a5faa8 100644
--- a/ets2panda/compiler/lowering/ets/stringComparison.cpp
+++ b/ets2panda/compiler/lowering/ets/stringComparison.cpp
@@ -83,6 +83,7 @@ void StringComparisonLowering::ProcessBinaryExpression(ir::BinaryExpression *exp
     ir::Expression *accessor = nullptr;
     auto *zeroExpr = checker->AllocNode<ir::NumberLiteral>(util::StringView("0"));
     auto *const callee = checker->AllocNode<ir::Identifier>("compareTo", checker->Allocator());
+    ES2PANDA_ASSERT(callee != nullptr);
     auto *var = checker->GlobalBuiltinETSStringType()->GetProperty(callee->AsIdentifier()->Name(),
                                                                    checker::PropertySearchFlags::SEARCH_METHOD);
     callee->SetVariable(var);
diff --git a/ets2panda/compiler/lowering/ets/stringConstantsLowering.cpp b/ets2panda/compiler/lowering/ets/stringConstantsLowering.cpp
index e2bae0b0e62d24f600bdbb885562b031ecb3f7f0..dd07eacc1ef50ea9cc51c94c8000f6f8e9f37cb7 100644
--- a/ets2panda/compiler/lowering/ets/stringConstantsLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/stringConstantsLowering.cpp
@@ -30,6 +30,7 @@ static ir::AstNode *FoldConcat(public_lib::Context *ctx, ir::BinaryExpression *c
     auto const resStr = util::UString(lhs->Str().Mutf8() + rhs->Str().Mutf8(), ctx->allocator).View();
 
     auto resNode = util::NodeAllocator::Alloc<ir::StringLiteral>(ctx->allocator, resStr);
+    ES2PANDA_ASSERT(resNode != nullptr);
     resNode->SetParent(concat->Parent());
     resNode->SetRange({lhs->Range().start, rhs->Range().end});
     return resNode;
diff --git a/ets2panda/compiler/lowering/ets/stringConstructorLowering.cpp b/ets2panda/compiler/lowering/ets/stringConstructorLowering.cpp
index 1e4060b5ea1894cc86d32652231b13108af88bfd..cf9c082392b71a1103a75c5caee2f9c2f7d70557 100644
--- a/ets2panda/compiler/lowering/ets/stringConstructorLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/stringConstructorLowering.cpp
@@ -72,6 +72,7 @@ ir::Expression *ReplaceStringConstructor(public_lib::Context *const ctx,
         if (argType->IsETSNullType() || argType->IsETSUndefinedType()) {
             auto *literal = argType->IsETSNullType() ? ctx->AllocNode<ir::StringLiteral>("null")
                                                      : ctx->AllocNode<ir::StringLiteral>("undefined");
+            ES2PANDA_ASSERT(literal != nullptr);
             literal->SetParent(newClassInstExpr->Parent());
 
             // Run checker
diff --git a/ets2panda/compiler/lowering/ets/topLevelStmts/globalClassHandler.cpp b/ets2panda/compiler/lowering/ets/topLevelStmts/globalClassHandler.cpp
index 93705974597eabb338863fd955d92e077aa3b3f5..666b2b37bb4119074e0cee509b8cc17ecba9c62d 100644
--- a/ets2panda/compiler/lowering/ets/topLevelStmts/globalClassHandler.cpp
+++ b/ets2panda/compiler/lowering/ets/topLevelStmts/globalClassHandler.cpp
@@ -86,6 +86,7 @@ ir::ClassDeclaration *GlobalClassHandler::CreateTransformedClass(ir::ETSModule *
     auto *classDef = NodeAllocator::Alloc<ir::ClassDefinition>(
         allocator_, allocator_, ident, ir::ClassDefinitionModifiers::CLASS_DECL, ir::ModifierFlags::ABSTRACT,
         Language(Language::Id::ETS));
+    ES2PANDA_ASSERT(classDef != nullptr);
     classDef->SetRange(ns->Range());
     classDef->AddModifier(ns->Modifiers());
     auto *classDecl = NodeAllocator::Alloc<ir::ClassDeclaration>(allocator_, classDef, allocator_);
@@ -103,6 +104,7 @@ ir::ClassDeclaration *GlobalClassHandler::CreateTransformedClass(ir::ETSModule *
 
 static void InsertInGlobal(ir::ClassDefinition *globalClass, ir::AstNode *node)
 {
+    ES2PANDA_ASSERT(node != nullptr);
     globalClass->Body().insert(globalClass->Body().begin(), node);
     node->SetParent(globalClass);
 }
@@ -145,6 +147,7 @@ void GlobalClassHandler::SetupGlobalMethods(parser::Program *program, ArenaVecto
     ir::MethodDefinition *initMethod =
         CreateGlobalMethod(compiler::Signatures::INIT_METHOD, std::move(initStatements), program);
     InsertInGlobal(globalClass, initMethod);
+    ES2PANDA_ASSERT(initMethod->Function());
     if (!initMethod->Function()->Body()->AsBlockStatement()->Statements().empty()) {
         AddInitCallToStaticBlock(globalClass, initMethod);
     }
@@ -209,6 +212,7 @@ void GlobalClassHandler::TransformBrokenNamespace(ir::AstNode *node, parser::Pro
 ir::ClassDeclaration *GlobalClassHandler::TransformNamespace(ir::ETSModule *ns, parser::Program *program)
 {
     ir::ClassDeclaration *const globalDecl = CreateTransformedClass(ns);
+    ES2PANDA_ASSERT(globalDecl != nullptr);
     ir::ClassDefinition *const globalClass = globalDecl->Definition();
 
     ArenaVector<GlobalStmts> immediateInitializers(allocator_->Adapter());
@@ -294,6 +298,7 @@ void GlobalClassHandler::SetupGlobalClass(const ArenaVector<parser::Program *> &
 
     ArenaUnorderedSet<util::StringView> packageInitializerBlockCount(allocator_->Adapter());
     ir::ClassDeclaration *const globalDecl = CreateGlobalClass(globalProgram);
+    ES2PANDA_ASSERT(globalDecl != nullptr);
     ir::ClassDefinition *const globalClass = globalDecl->Definition();
 
     // NOTE(vpukhov): a clash inside program list is possible
@@ -357,7 +362,7 @@ ir::MethodDefinition *GlobalClassHandler::CreateGlobalMethod(std::string_view na
         allocator_, allocator_,
         ir::ScriptFunction::ScriptFunctionData {
             body, std::move(funcSignature), functionFlags, {}, Language(Language::Id::ETS)});
-
+    ES2PANDA_ASSERT(func != nullptr);
     func->SetIdent(ident);
     func->AddModifier(functionModifiers);
 
@@ -380,7 +385,7 @@ void GlobalClassHandler::AddInitializerBlockToStaticBlock(ir::ClassDefinition *g
     auto *staticBlock = (*maybeStaticBlock)->AsClassStaticBlock();
     auto *initializerStmts =
         NodeAllocator::ForceSetParent<ir::BlockStatement>(allocator_, allocator_, std::move(initializerBlocks));
-
+    ES2PANDA_ASSERT(initializerStmts != nullptr);
     auto *blockBody = staticBlock->Function()->Body()->AsBlockStatement();
     initializerStmts->SetParent(blockBody);
     blockBody->Statements().emplace_back(initializerStmts);
@@ -396,6 +401,7 @@ void GlobalClassHandler::AddInitCallToStaticBlock(ir::ClassDefinition *globalCla
     ES2PANDA_ASSERT(maybeStaticBlock != globalBody.end());
 
     auto *staticBlock = (*maybeStaticBlock)->AsClassStaticBlock();
+    ES2PANDA_ASSERT(initMethod->Id() != nullptr);
     auto *callee = RefIdent(initMethod->Id()->Name());
 
     auto *const callExpr = NodeAllocator::Alloc<ir::CallExpression>(
@@ -498,7 +504,7 @@ ir::ClassStaticBlock *GlobalClassHandler::CreateStaticBlock(ir::ClassDefinition
         ir::ScriptFunction::ScriptFunctionData {body, ir::FunctionSignature(nullptr, std::move(params), nullptr),
                                                 ir::ScriptFunctionFlags::STATIC_BLOCK | ir::ScriptFunctionFlags::HIDDEN,
                                                 ir::ModifierFlags::STATIC, Language(Language::Id::ETS)});
-
+    ES2PANDA_ASSERT(func != nullptr);
     func->SetIdent(id);
 
     auto *funcExpr = NodeAllocator::Alloc<ir::FunctionExpression>(allocator_, func);
@@ -557,6 +563,7 @@ ir::ClassDeclaration *GlobalClassHandler::CreateGlobalClass(const parser::Progra
     auto *classDef =
         NodeAllocator::Alloc<ir::ClassDefinition>(allocator_, allocator_, ident, ir::ClassDefinitionModifiers::GLOBAL,
                                                   ir::ModifierFlags::ABSTRACT, Language(Language::Id::ETS));
+    ES2PANDA_ASSERT(classDef != nullptr);
     classDef->SetRange(rangeToStartOfFile);
     auto *classDecl = NodeAllocator::Alloc<ir::ClassDeclaration>(allocator_, classDef, allocator_);
     classDecl->SetRange(rangeToStartOfFile);
diff --git a/ets2panda/compiler/lowering/ets/topLevelStmts/globalDeclTransformer.cpp b/ets2panda/compiler/lowering/ets/topLevelStmts/globalDeclTransformer.cpp
index 8e3afe694c15eb116ba7c15555f1fa064a140c5c..81b4d87476d1f30f72ac2d04f5fcc6bbcb7e503d 100644
--- a/ets2panda/compiler/lowering/ets/topLevelStmts/globalDeclTransformer.cpp
+++ b/ets2panda/compiler/lowering/ets/topLevelStmts/globalDeclTransformer.cpp
@@ -39,6 +39,7 @@ GlobalDeclTransformer::ResultT GlobalDeclTransformer::TransformStatements(const
 void GlobalDeclTransformer::VisitFunctionDeclaration(ir::FunctionDeclaration *funcDecl)
 {
     auto *funcExpr = util::NodeAllocator::ForceSetParent<ir::FunctionExpression>(allocator_, funcDecl->Function());
+    ES2PANDA_ASSERT(funcExpr != nullptr);
     funcDecl->Function()->SetStart(funcDecl->Function()->Id()->Start());
     funcExpr->SetRange(funcDecl->Function()->Range());
     ir::MethodDefinitionKind methodKind;
@@ -85,6 +86,7 @@ void GlobalDeclTransformer::VisitVariableDeclaration(ir::VariableDeclaration *va
         if (!varDecl->Annotations().empty()) {
             ArenaVector<ir::AnnotationUsage *> propAnnotations(allocator_->Adapter());
             for (auto *annotationUsage : varDecl->Annotations()) {
+                ES2PANDA_ASSERT(annotationUsage != nullptr);
                 propAnnotations.push_back(annotationUsage->Clone(allocator_, field)->AsAnnotationUsage());
             }
             field->SetAnnotations(std::move(propAnnotations));
@@ -164,6 +166,7 @@ ir::ExpressionStatement *GlobalDeclTransformer::InitTopLevelProperty(ir::ClassPr
     initializer->SetParent(nullptr);
     auto *assignmentExpression = util::NodeAllocator::Alloc<ir::AssignmentExpression>(
         allocator_, ident, initializer, lexer::TokenType::PUNCTUATOR_SUBSTITUTION);
+    ES2PANDA_ASSERT(assignmentExpression != nullptr);
     assignmentExpression->SetRange({ident->Start(), initializer->End()});
     assignmentExpression->SetTsType(initializer->TsType());
 
diff --git a/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.cpp b/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.cpp
index aa76dbdc4501ac5ca7613deefe713b487ccb93d5..adbb17ad0f63cf0a1fcbcf63faf1d8c80188198b 100644
--- a/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.cpp
+++ b/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.cpp
@@ -133,6 +133,7 @@ void ImportExportDecls::HandleSelectiveExportWithAlias(util::StringView original
                                    !declItem->second->HasExportAlias();
             if (!alreadyExported && declItem->second->IsVariableDeclaration()) {
                 auto declarator = declItem->second->AsVariableDeclaration()->GetDeclaratorByName(exportName);
+                ES2PANDA_ASSERT(declarator != nullptr);
                 alreadyExported |=
                     ((declarator->Modifiers() & ir::ModifierFlags::EXPORTED) != 0) && !declarator->HasExportAlias();
             }
diff --git a/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.h b/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.h
index f5b04f3f5bdb3829b58e741b6bb66fd7516326ef..c1b50a29aa16f1a542ec49b051629a2cb51902dd 100644
--- a/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.h
+++ b/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.h
@@ -151,7 +151,7 @@ private:
         exportMap.insert({program_->SourceFilePath(), newMap});
     }
 
-    void RestoreImportExportDecls()
+    void RestoreImportExportDecls() noexcept
     {
         imExDecl_->fieldMap_ = fieldMapPrev_;
         imExDecl_->exportNameMap_ = exportNameMapPrev_;
diff --git a/ets2panda/compiler/lowering/ets/unionLowering.cpp b/ets2panda/compiler/lowering/ets/unionLowering.cpp
index 2df65448a029407d1a46f92db37df06b62ab9823..2a726f8f9606da0b79cdfaad9e1dbac28721b98a 100644
--- a/ets2panda/compiler/lowering/ets/unionLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/unionLowering.cpp
@@ -62,6 +62,7 @@ static ir::ClassDefinition *GetUnionAccessClass(public_lib::Context *ctx, varbin
     auto classCtx = varbinder::LexicalScope<varbinder::ClassScope>(varbinder);
     auto *classDef = ctx->AllocNode<ir::ClassDefinition>(ctx->Allocator(), ident, ir::ClassDefinitionModifiers::GLOBAL,
                                                          ir::ModifierFlags::ABSTRACT, Language(Language::Id::ETS));
+    ES2PANDA_ASSERT(classDef != nullptr);
     classDef->SetScope(classCtx.GetScope());
     auto *classDecl = ctx->AllocNode<ir::ClassDeclaration>(classDef, allocator);
     classDef->Scope()->BindNode(classDecl->Definition());
@@ -103,6 +104,7 @@ static std::tuple<varbinder::LocalVariable *, checker::Signature *> CreateNamedA
                        nullptr, ir::FunctionSignature(nullptr, std::move(params), returnTypeAnno),
                        // CC-OFFNXT(G.FMT.02-CPP) project code style
                        ir::ScriptFunctionFlags::METHOD, ir::ModifierFlags::PUBLIC});
+    ES2PANDA_ASSERT(func != nullptr);
     func->SetIdent(methodIdent->Clone(allocator, nullptr));
 
     // Create the synthetic function node
@@ -146,7 +148,7 @@ static varbinder::LocalVariable *CreateNamedAccessProperty(public_lib::Context *
     // Create the synthetic class property node
     auto *field =
         ctx->AllocNode<ir::ClassProperty>(fieldIdent, nullptr, nullptr, ir::ModifierFlags::NONE, allocator, false);
-
+    ES2PANDA_ASSERT(field != nullptr);
     // Add the declaration to the scope
     auto [decl, var] = varbinder->NewVarDecl<varbinder::LetDecl>(fieldIdent->Start(), fieldIdent->Name());
     var->AddFlag(varbinder::VariableFlags::PROPERTY);
@@ -167,7 +169,7 @@ static varbinder::LocalVariable *CreateNamedAccess(public_lib::Context *ctx, var
     auto type = expr->TsType();
     auto name = expr->Property()->AsIdentifier()->Name();
     auto *checker = ctx->checker->AsETSChecker();
-
+    ES2PANDA_ASSERT(checker->GetApparentType(checker->GetNonNullishType(expr->Object()->TsType())) != nullptr);
     auto unionType = checker->GetApparentType(checker->GetNonNullishType(expr->Object()->TsType()))->AsETSUnionType();
     auto *const accessClass = GetUnionAccessClass(ctx, varbinder, GetAccessClassName(unionType));
     auto *classScope = accessClass->Scope()->AsClassScope();
@@ -207,6 +209,7 @@ static ir::TSAsExpression *GenAsExpression(public_lib::Context *ctx, checker::Ty
 {
     auto *const typeNode = ctx->AllocNode<ir::OpaqueTypeNode>(opaqueType, ctx->Allocator());
     auto *const asExpression = ctx->AllocNode<ir::TSAsExpression>(node, typeNode, false);
+    ES2PANDA_ASSERT(asExpression != nullptr);
     asExpression->SetParent(parent);
     asExpression->Check(ctx->checker->AsETSChecker());
     return asExpression;
@@ -240,6 +243,7 @@ static ir::TSAsExpression *HandleUnionCastToPrimitive(public_lib::Context *ctx,
         // when sourceType get `object`, it could cast to any primitive type but can't be unboxed;
         if (maybeUnboxingType != nullptr && expr->TsType()->IsETSPrimitiveType()) {
             auto *const asExpr = GenAsExpression(ctx, sourceType, expr->Expr(), expr);
+            ES2PANDA_ASSERT(asExpr != nullptr);
             asExpr->SetBoxingUnboxingFlags(checker->GetUnboxingFlag(maybeUnboxingType));
             expr->Expr()->SetBoxingUnboxingFlags(ir::BoxingUnboxingFlags::NONE);
             expr->SetExpr(asExpr);
diff --git a/ets2panda/ir/statements/annotationUsage.cpp b/ets2panda/ir/statements/annotationUsage.cpp
index f45e55276922359211964b74b6326ddbd330c4dd..aee9d75d53ae4433315c6e87f4368bf7c278c708 100644
--- a/ets2panda/ir/statements/annotationUsage.cpp
+++ b/ets2panda/ir/statements/annotationUsage.cpp
@@ -58,6 +58,7 @@ void AnnotationUsage::Dump(ir::SrcDumper *dumper) const
     if (!properties_.empty()) {
         dumper->Add("{");
         for (auto elem : properties_) {
+            ES2PANDA_ASSERT(elem->AsClassProperty()->Id() != nullptr);
             dumper->Add(elem->AsClassProperty()->Id()->Name().Mutf8());
             dumper->Add(":");
             elem->AsClassProperty()->Value()->Dump(dumper);
@@ -74,6 +75,7 @@ AnnotationUsage *AnnotationUsage::Clone(ArenaAllocator *const allocator, AstNode
 {
     auto *const expr = expr_ != nullptr ? expr_->Clone(allocator, nullptr)->AsExpression() : nullptr;
     auto *const clone = allocator->New<AnnotationUsage>(expr, allocator);
+    ES2PANDA_ASSERT(clone != nullptr);
 
     if (expr != nullptr) {
         expr->SetParent(clone);
diff --git a/ets2panda/ir/statements/blockStatement.cpp b/ets2panda/ir/statements/blockStatement.cpp
index 63cc1287f0571f3ae1827238d251afd1214c8936..53ee69d7c5853ca273372e40b42f46e7323aabfb 100644
--- a/ets2panda/ir/statements/blockStatement.cpp
+++ b/ets2panda/ir/statements/blockStatement.cpp
@@ -46,6 +46,7 @@ AstNode *BlockStatement::Clone(ArenaAllocator *const allocator, AstNode *const p
     }
 
     auto retVal = util::NodeAllocator::ForceSetParent<ir::BlockStatement>(allocator, allocator, std::move(statements));
+    ES2PANDA_ASSERT(retVal != nullptr);
     retVal->SetParent(parent);
 
     return retVal;
diff --git a/ets2panda/ir/statements/breakStatement.cpp b/ets2panda/ir/statements/breakStatement.cpp
index 3a8b44bde410dd6fa6b878f5da8faab8e4817e8c..afbca163d33206566e70d0df4763dd4b46b38e35 100644
--- a/ets2panda/ir/statements/breakStatement.cpp
+++ b/ets2panda/ir/statements/breakStatement.cpp
@@ -79,6 +79,7 @@ BreakStatement *BreakStatement::Clone(ArenaAllocator *const allocator, AstNode *
 {
     auto *const ident = ident_ != nullptr ? ident_->Clone(allocator, nullptr) : nullptr;
     auto *const clone = util::NodeAllocator::ForceSetParent<BreakStatement>(allocator, ident);
+    ES2PANDA_ASSERT(clone != nullptr);
 
     if (parent != nullptr) {
         clone->SetParent(parent);
diff --git a/ets2panda/ir/statements/continueStatement.cpp b/ets2panda/ir/statements/continueStatement.cpp
index 89bacf1b7131cfd90b9e94dd5d3598809e161ce4..8b73763a7df2abd5019f0e0754a4a165038a69f4 100644
--- a/ets2panda/ir/statements/continueStatement.cpp
+++ b/ets2panda/ir/statements/continueStatement.cpp
@@ -73,6 +73,7 @@ ContinueStatement *ContinueStatement::Clone(ArenaAllocator *const allocator, Ast
 {
     auto *const ident = ident_ != nullptr ? ident_->Clone(allocator, nullptr) : nullptr;
     auto *const clone = util::NodeAllocator::ForceSetParent<ContinueStatement>(allocator, ident);
+    ES2PANDA_ASSERT(clone != nullptr);
 
     if (parent != nullptr) {
         clone->SetParent(parent);
diff --git a/ets2panda/ir/statements/forOfStatement.cpp b/ets2panda/ir/statements/forOfStatement.cpp
index d6eee195c8143ddda3e66a62bceb22336dc81d13..9fff61c950ca8e792260e376b8897db55311f830 100644
--- a/ets2panda/ir/statements/forOfStatement.cpp
+++ b/ets2panda/ir/statements/forOfStatement.cpp
@@ -121,6 +121,7 @@ ForOfStatement *ForOfStatement::Clone(ArenaAllocator *const allocator, AstNode *
     auto *const right = right_ != nullptr ? right_->Clone(allocator, nullptr)->AsExpression() : nullptr;
     auto *const body = body_ != nullptr ? body_->Clone(allocator, nullptr)->AsStatement() : nullptr;
     auto *const clone = allocator->New<ForOfStatement>(left, right, body, isAwait_);
+    ES2PANDA_ASSERT(clone != nullptr);
 
     if (left != nullptr) {
         left->SetParent(clone);
diff --git a/ets2panda/ir/statements/tryStatement.cpp b/ets2panda/ir/statements/tryStatement.cpp
index 7281fa5e603bdbc09c286237cb291cb658f78f4e..82d74865c48fce0170ee8973f5dd46710dd83e83 100644
--- a/ets2panda/ir/statements/tryStatement.cpp
+++ b/ets2panda/ir/statements/tryStatement.cpp
@@ -127,9 +127,21 @@ TryStatement::TryStatement(TryStatement const &other, ArenaAllocator *allocator)
 {
     block_ = other.block_ == nullptr ? nullptr : other.block_->Clone(allocator, this)->AsBlockStatement();
     for (auto &cc : other.catchClauses_) {
-        catchClauses_.push_back(cc == nullptr ? nullptr : cc->Clone(allocator, this)->AsCatchClause());
+        if (cc == nullptr) {
+            catchClauses_.push_back(nullptr);
+            continue;
+        }
+        auto *ccClone = cc->Clone(allocator, this);
+        ES2PANDA_ASSERT(ccClone != nullptr);
+        catchClauses_.push_back(ccClone->AsCatchClause());
+    }
+    if (other.finalizer_ == nullptr) {
+        finalizer_ = nullptr;
+    } else {
+        auto *otherFinalizerClone = other.finalizer_->Clone(allocator, this);
+        ES2PANDA_ASSERT(otherFinalizerClone != nullptr);
+        finalizer_ = otherFinalizerClone->AsBlockStatement();
     }
-    finalizer_ = other.finalizer_ == nullptr ? nullptr : other.finalizer_->Clone(allocator, this)->AsBlockStatement();
     for (auto &[label, st] : other.finalizerInsertions_) {
         finalizerInsertions_.emplace_back(label, st);
     }
@@ -138,6 +150,7 @@ TryStatement::TryStatement(TryStatement const &other, ArenaAllocator *allocator)
 TryStatement *TryStatement::Clone(ArenaAllocator *const allocator, AstNode *const parent)
 {
     auto *const clone = allocator->New<TryStatement>(*this, allocator);
+    ES2PANDA_ASSERT(clone != nullptr);
     if (parent != nullptr) {
         clone->SetParent(parent);
     }
diff --git a/ets2panda/ir/statements/variableDeclaration.cpp b/ets2panda/ir/statements/variableDeclaration.cpp
index 56934876cfc09ba4846b2df06ab28c70542f155b..b6057d4e9c0765fff3d99b39e1754f748a346265 100644
--- a/ets2panda/ir/statements/variableDeclaration.cpp
+++ b/ets2panda/ir/statements/variableDeclaration.cpp
@@ -142,7 +142,9 @@ VariableDeclaration::VariableDeclaration([[maybe_unused]] Tag const tag, Variabl
     }
 
     for (auto const &d : other.declarators_) {
-        declarators_.emplace_back(d->Clone(allocator, nullptr)->AsVariableDeclarator());
+        auto *dClone = d->Clone(allocator, nullptr);
+        ES2PANDA_ASSERT(dClone != nullptr);
+        declarators_.emplace_back(dClone->AsVariableDeclarator());
         declarators_.back()->SetParent(this);
     }
 }
@@ -150,6 +152,7 @@ VariableDeclaration::VariableDeclaration([[maybe_unused]] Tag const tag, Variabl
 VariableDeclaration *VariableDeclaration::Clone(ArenaAllocator *const allocator, AstNode *const parent)
 {
     auto *const clone = allocator->New<VariableDeclaration>(Tag {}, *this, allocator);
+    ES2PANDA_ASSERT(clone != nullptr);
     if (parent != nullptr) {
         clone->SetParent(parent);
     }
diff --git a/ets2panda/ir/statements/variableDeclarator.cpp b/ets2panda/ir/statements/variableDeclarator.cpp
index 78ee2fd4f8d96bd15b1e87376e49fd117c0a500f..059bd4173c341344924e28fed86d2db6f9472a79 100644
--- a/ets2panda/ir/statements/variableDeclarator.cpp
+++ b/ets2panda/ir/statements/variableDeclarator.cpp
@@ -76,6 +76,7 @@ VariableDeclarator *VariableDeclarator::Clone(ArenaAllocator *const allocator, A
     auto *const id = id_ != nullptr ? id_->Clone(allocator, nullptr)->AsExpression() : nullptr;
     auto *const init = init_ != nullptr ? init_->Clone(allocator, nullptr)->AsExpression() : nullptr;
     auto *const clone = allocator->New<VariableDeclarator>(flag_, id, init);
+    ES2PANDA_ASSERT(clone != nullptr);
 
     if (id != nullptr) {
         id->SetParent(clone);
diff --git a/ets2panda/parser/TSparser.cpp b/ets2panda/parser/TSparser.cpp
index 164f34c1709b25800f00f11a958346c400d8b8ee..98823e5ef4ff980246a1f95ede157192962baa1e 100644
--- a/ets2panda/parser/TSparser.cpp
+++ b/ets2panda/parser/TSparser.cpp
@@ -734,6 +734,7 @@ ir::TSTypeParameter *TSParser::ParseMappedTypeParameter()
     lexer::SourcePosition startLoc = Lexer()->GetToken().Start();
 
     auto *paramName = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(paramName != nullptr);
     paramName->SetRange({Lexer()->GetToken().Start(), Lexer()->GetToken().End()});
 
     Lexer()->NextToken();
@@ -891,6 +892,7 @@ ir::TypeNode *TSParser::ParseTypeLiteralOrMappedType(ir::TypeNode *typeAnnotatio
     Lexer()->NextToken();
 
     auto *literalType = AllocNode<ir::TSTypeLiteral>(std::move(members), Allocator());
+    ES2PANDA_ASSERT(literalType != nullptr);
     auto *typeVar = varbinder::Scope::CreateVar(Allocator(), "__type", varbinder::VariableFlags::TYPE, literalType);
     literalType->SetVariable(typeVar);
     literalType->SetRange({bodyStart, bodyEnd});
@@ -1998,6 +2000,7 @@ std::tuple<bool, bool, bool> TSParser::ParseComputedClassFieldOrIndexSignature(i
     if (Lexer()->GetToken().Type() == lexer::TokenType::LITERAL_IDENT &&
         Lexer()->Lookahead() == lexer::LEX_CHAR_COLON) {
         auto id = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+        ES2PANDA_ASSERT(id != nullptr);
         id->SetRange(Lexer()->GetToken().Loc());
 
         Lexer()->NextToken();  // eat param
diff --git a/ets2panda/parser/TypedParser.cpp b/ets2panda/parser/TypedParser.cpp
index 85634a4e63b208beb4e3e05def89d67a59fba2e6..cfdf1449272ed1e5ddcc15da62a35e96951e4f12 100644
--- a/ets2panda/parser/TypedParser.cpp
+++ b/ets2panda/parser/TypedParser.cpp
@@ -193,6 +193,7 @@ ir::TSTypeAssertion *TypedParser::ParseTypeAssertion()
     Lexer()->NextToken();  // eat '>'
     ir::Expression *expression = ParseExpression();
     auto *typeAssertion = AllocNode<ir::TSTypeAssertion>(typeAnnotation, expression);
+    ES2PANDA_ASSERT(typeAssertion != nullptr);
     typeAssertion->SetRange({start, Lexer()->GetToken().End()});
 
     return typeAssertion;
@@ -299,6 +300,7 @@ ir::TSModuleDeclaration *TypedParser::ParseAmbientExternalModuleDeclaration(cons
 
     auto *moduleDecl = AllocNode<ir::TSModuleDeclaration>(Allocator(), name, body,
                                                           ir::TSModuleDeclaration::ConstructorFlags {isGlobal, true});
+    ES2PANDA_ASSERT(moduleDecl != nullptr);
     moduleDecl->SetRange({startLoc, Lexer()->GetToken().End()});
 
     return moduleDecl;
@@ -311,6 +313,7 @@ ir::TSModuleDeclaration *TypedParser::ParseModuleOrNamespaceDeclaration(const le
     }
 
     auto *identNode = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(identNode != nullptr);
     identNode->SetRange(Lexer()->GetToken().Loc());
 
     Lexer()->NextToken();
@@ -343,6 +346,7 @@ ir::TSModuleBlock *TypedParser::ParseTsModuleBlock()
     auto statements = ParseStatementList();
 
     auto *blockNode = AllocNode<ir::TSModuleBlock>(std::move(statements));
+    ES2PANDA_ASSERT(blockNode != nullptr);
     blockNode->SetRange({startLoc, Lexer()->GetToken().End()});
 
     ExpectToken(lexer::TokenType::PUNCTUATOR_RIGHT_BRACE);
@@ -419,6 +423,7 @@ ir::TypeNode *TypedParser::ParseInterfaceExtendsElement()
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
         TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::REPORT_ERROR;
         typeParamInst = ParseTypeParameterInstantiation(&options);
+        ES2PANDA_ASSERT(typeParamInst != nullptr);
         heritageEnd = typeParamInst->End();
     }
 
@@ -435,7 +440,9 @@ ArenaVector<ir::TSInterfaceHeritage *> TypedParser::ParseInterfaceExtendsClause(
 
     while (true) {
         auto *typeReference = ParseInterfaceExtendsElement();
+        ES2PANDA_ASSERT(typeReference != nullptr);
         auto *heritage = AllocNode<ir::TSInterfaceHeritage>(typeReference);
+        ES2PANDA_ASSERT(heritage != nullptr);
         heritage->SetRange(typeReference->Range());
         extends.push_back(heritage);
 
@@ -495,6 +502,7 @@ ir::Statement *TypedParser::ParseInterfaceDeclaration(bool isStatic)
         Allocator(), std::move(extends),
         ir::TSInterfaceDeclaration::ConstructorData {id, typeParamDecl, body, isStatic, isExternal,
                                                      GetContext().GetLanguage()});
+    ES2PANDA_ASSERT(interfaceDecl != nullptr);
     interfaceDecl->SetRange({interfaceStart, Lexer()->GetToken().End()});
 
     Lexer()->NextToken();
@@ -693,6 +701,7 @@ ir::TSEnumDeclaration *TypedParser::ParseEnumMembers(ir::Identifier *key, const
 
     auto *enumDeclaration = AllocNode<ir::TSEnumDeclaration>(Allocator(), key, std::move(members),
                                                              ir::TSEnumDeclaration::ConstructorFlags {isConst});
+    ES2PANDA_ASSERT(enumDeclaration != nullptr);
     enumDeclaration->SetRange({enumStart, endLoc});
 
     return enumDeclaration;
@@ -729,7 +738,7 @@ ir::TSTypeParameter *TypedParser::ParseTypeParameter(TypeAnnotationParsingOption
 
     const auto &ident = Lexer()->GetToken().Ident();
     auto *paramIdent = AllocNode<ir::Identifier>(ident, Allocator());
-
+    ES2PANDA_ASSERT(paramIdent != nullptr);
     paramIdent->SetRange({Lexer()->GetToken().Start(), Lexer()->GetToken().End()});
 
     Lexer()->NextToken();
@@ -888,6 +897,7 @@ ArenaVector<ir::TSClassImplements *> TypedParser::ParseClassImplementClause()
         lexer::SourcePosition implStart = Lexer()->GetToken().Start();
         auto [expr, implTypeParams] = ParseClassImplementsElement();
         auto *impl = AllocNode<ir::TSClassImplements>(expr, implTypeParams);
+        ES2PANDA_ASSERT(impl != nullptr);
         impl->SetRange({implStart, Lexer()->GetToken().End()});
         implements.push_back(impl);
 
@@ -973,6 +983,7 @@ ir::ClassDefinition *TypedParser::ParseClassDefinition(ir::ClassDefinitionModifi
     auto *classDefinition =
         AllocNode<ir::ClassDefinition>(identNode, typeParamDecl, superTypeParams, std::move(implements), ctor,
                                        superClass, std::move(properties), modifiers, flags, GetContext().GetLanguage());
+    ES2PANDA_ASSERT(classDefinition != nullptr);
     classDefinition->SetInternalName(privateBinding.View());
 
     classDefinition->SetRange(bodyRange);
@@ -1006,7 +1017,7 @@ ir::AstNode *TypedParser::ParseProperty(const ArenaVector<ir::AstNode *> &proper
 
         property =
             AllocNode<ir::TSIndexSignature>(propName, typeAnnotation, desc.modifiers & ir::ModifierFlags::READONLY);
-
+        ES2PANDA_ASSERT(property != nullptr);
         property->SetRange({property->AsTSIndexSignature()->Param()->Start(),
                             property->AsTSIndexSignature()->TypeAnnotation()->End()});
     } else {
@@ -1017,7 +1028,7 @@ ir::AstNode *TypedParser::ParseProperty(const ArenaVector<ir::AstNode *> &proper
             if (desc.isPrivateIdent) {
                 LogError(diagnostic::DECORATORS_INVALID);
             }
-
+            ES2PANDA_ASSERT(property != nullptr);
             property->AddDecorators(std::move(desc.decorators));
         }
     }
@@ -1203,6 +1214,7 @@ ir::Expression *TypedParser::ParseQualifiedName(ExpressionParseFlags flags)
             break;
         case lexer::TokenType::LITERAL_IDENT:
             expr = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+            ES2PANDA_ASSERT(expr != nullptr);
             expr->SetRange(Lexer()->GetToken().Loc());
             Lexer()->NextToken();
             break;
@@ -1260,6 +1272,7 @@ ir::Expression *TypedParser::ParseQualifiedReference(ir::Expression *typeName, E
         propName->SetRange(Lexer()->GetToken().Loc());
 
         typeName = AllocNode<ir::TSQualifiedName>(typeName, propName, Allocator());
+        ES2PANDA_ASSERT(typeName != nullptr);
         typeName->SetRange({typeName->AsTSQualifiedName()->Left()->Start(), Lexer()->GetToken().End()});
 
         if (Lexer()->GetToken().Type() == lexer::TokenType::LITERAL_IDENT) {
diff --git a/ets2panda/parser/expressionParser.cpp b/ets2panda/parser/expressionParser.cpp
index 37c03683eb146388e86bb149022ca0294731df53..3dd632cf3dd5a887e4930da88f5dacd846fb0aec 100644
--- a/ets2panda/parser/expressionParser.cpp
+++ b/ets2panda/parser/expressionParser.cpp
@@ -767,6 +767,7 @@ ir::TemplateLiteral *ParserImpl::ParseTemplateLiteral()
     }
 
     auto *templateNode = AllocNode<ir::TemplateLiteral>(std::move(quasis), std::move(expressions), multilineStr);
+    ES2PANDA_ASSERT(templateNode != nullptr);
     templateNode->SetRange({startLoc, lexer_->GetToken().End()});
 
     lexer_->NextToken();
diff --git a/ets2panda/varbinder/scope.h b/ets2panda/varbinder/scope.h
index d8701598bd2d46f1fa646fed8afaa85f2968d76a..d2ee06562b24987d0823499a0e5d8ee872ee0685 100644
--- a/ets2panda/varbinder/scope.h
+++ b/ets2panda/varbinder/scope.h
@@ -216,6 +216,7 @@ public:
 
     Variable *AddDecl(ArenaAllocator *allocator, Decl *decl, ScriptExtension extension)
     {
+        ES2PANDA_ASSERT(decl != nullptr);
         auto *var =
             AddBinding(allocator, FindLocal(decl->Name(), varbinder::ResolveBindingOptions::BINDINGS), decl, extension);
         if (var != nullptr) {
@@ -873,6 +874,7 @@ public:
     {
         auto *paramScope = allocator->New<FunctionParamScope>(allocator, this);
         paramScope_ = paramScope;
+        ES2PANDA_ASSERT(paramScope_ != nullptr);
         paramScope_->BindFunctionScope(this);
     }
 
@@ -979,7 +981,7 @@ std::pair<varbinder::Variable *, bool> Scope::AddDecl(ArenaAllocator *allocator,
 
     auto *decl = allocator->New<DeclType>(name);
     variable = allocator->New<VariableType>(decl, flags);
-
+    ES2PANDA_ASSERT(variable != nullptr);
     decls_.emplace_back(decl);
     bindings_.insert({decl->Name(), variable});
     variable->SetScope(this);
diff --git a/ets2panda/varbinder/varbinder.cpp b/ets2panda/varbinder/varbinder.cpp
index d08635be49f405e5e6175910cb3c0e3676bcd55f..157a58e7efdcfe08aade15b177e9cc6a4cdd74f1 100644
--- a/ets2panda/varbinder/varbinder.cpp
+++ b/ets2panda/varbinder/varbinder.cpp
@@ -145,7 +145,7 @@ void VarBinder::InstantiateArguments()
     auto *iter = scope_;
     while (true) {
         Scope *scope = iter->IsFunctionParamScope() ? iter : iter->EnclosingVariableScope();
-
+        ES2PANDA_ASSERT(scope != nullptr);
         const auto *node = scope->Node();
 
         if (scope->IsLoopScope()) {
@@ -172,7 +172,7 @@ void VarBinder::PropagateDirectEval() const
     do {
         VariableScope *scope = iter->IsFunctionParamScope() ? iter->AsFunctionParamScope()->GetFunctionScope()
                                                             : iter->EnclosingVariableScope();
-
+        ES2PANDA_ASSERT(scope != nullptr);
         scope->AddFlag(ScopeFlags::NO_REG_STORE);
         iter = iter->Parent();
     } while (iter != nullptr);
@@ -185,7 +185,7 @@ void VarBinder::InstantiatePrivateContext(const ir::Identifier *ident) const
     while (classDef != nullptr) {
         auto *scope = classDef->Scope();
         Variable *variable = scope->FindLocal(classDef->InternalName(), varbinder::ResolveBindingOptions::BINDINGS);
-
+        ES2PANDA_ASSERT(variable != nullptr);
         if (!variable->HasFlag(VariableFlags::INITIALIZED)) {
             break;
         }
@@ -328,6 +328,7 @@ void VarBinder::BuildVarDeclarator(ir::VariableDeclarator *varDecl)
 void VarBinder::BuildClassProperty(const ir::ClassProperty *prop)
 {
     const ir::ScriptFunction *ctor = util::Helpers::GetContainingConstructor(prop);
+    ES2PANDA_ASSERT(ctor != nullptr);
     auto scopeCtx = LexicalScope<FunctionScope>::Enter(this, ctor->Scope());
 
     ResolveReferences(prop);
@@ -363,6 +364,7 @@ void VarBinder::BuildClassDefinition(ir::ClassDefinition *classDef)
     }
 
     Variable *variable = scope_->FindLocal(classDef->InternalName(), varbinder::ResolveBindingOptions::BINDINGS);
+    ES2PANDA_ASSERT(variable != nullptr);
     variable->AddFlag(VariableFlags::INITIALIZED);
 
     if (classDef->Ident() != nullptr) {
@@ -536,6 +538,7 @@ void VarBinder::ResolveReference(ir::AstNode *childNode)
             LookupIdentReference(childNode->AsIdentifier());
             return ResolveReferences(childNode);
         case ir::AstNodeType::SUPER_EXPRESSION:
+            ES2PANDA_ASSERT(scope_->EnclosingVariableScope() != nullptr);
             scope_->EnclosingVariableScope()->AddFlag(ScopeFlags::USE_SUPER);
             return ResolveReferences(childNode);
         case ir::AstNodeType::SCRIPT_FUNCTION: {
diff --git a/ets2panda/varbinder/variable.cpp b/ets2panda/varbinder/variable.cpp
index 6768c7b88aae56e067f1441206db748a60ff059e..bb3cdb79984ee8f6c0324f8e9e99ac56f443e113 100644
--- a/ets2panda/varbinder/variable.cpp
+++ b/ets2panda/varbinder/variable.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -39,6 +39,7 @@ const util::StringView &Variable::Name() const
 LocalVariable *LocalVariable::Copy(ArenaAllocator *allocator, Decl *decl) const
 {
     auto *var = allocator->New<LocalVariable>(decl, flags_);
+    ES2PANDA_ASSERT(var != nullptr);
     var->vreg_ = vreg_;
     return var;
 }
@@ -50,7 +51,7 @@ void LocalVariable::SetLexical(Scope *scope)
     }
 
     VariableScope *varScope = scope->EnclosingVariableScope();
-
+    ES2PANDA_ASSERT(varScope != nullptr);
     BindLexEnvSlot(varScope->NextSlot());
 }