diff --git a/ets2panda/checker/ETSAnalyzer.cpp b/ets2panda/checker/ETSAnalyzer.cpp
index 0ecc1e27aa174064879ad4f3cbe3e6d45ab630d8..e66aebe65f920eb1ed604cf47ca9959ee394f43f 100644
--- a/ets2panda/checker/ETSAnalyzer.cpp
+++ b/ets2panda/checker/ETSAnalyzer.cpp
@@ -378,6 +378,7 @@ checker::Type *ETSAnalyzer::Check(ir::ETSFunctionType *node) const
     checker->CheckFunctionSignatureAnnotations(node->Params(), node->TypeParams(), node->ReturnType());
 
     auto *signatureInfo = checker->ComposeSignatureInfo(node->TypeParams(), node->Params());
+    ES2PANDA_ASSERT(signatureInfo != nullptr);
     auto *returnType = node->IsExtensionFunction() && node->ReturnType()->IsTSThisType()
                            ? signatureInfo->params.front()->TsType()
                            : checker->ComposeReturnType(node->ReturnType(), node->IsAsync());
@@ -1226,6 +1227,7 @@ checker::Type *ETSAnalyzer::Check(ir::AwaitExpression *expr) const
     }
 
     checker::Type *argType = checker->GetApparentType(expr->argument_->Check(checker));
+    ES2PANDA_ASSERT(argType != nullptr);
     ArenaVector<Type *> awaitedTypes(checker->ProgramAllocator()->Adapter());
 
     if (argType->IsETSUnionType()) {
@@ -1724,6 +1726,7 @@ checker::Type *ETSAnalyzer::Check(ir::Identifier *expr) const
         }
     }
 
+    ES2PANDA_ASSERT(identType != nullptr);
     expr->SetTsType(identType);
     if (!identType->IsTypeError()) {
         checker->Context().CheckIdentifierSmartCastCondition(expr);
@@ -1836,6 +1839,7 @@ checker::Type *ETSAnalyzer::Check(ir::MemberExpression *expr) const
     auto *baseType = checker->GetNonConstantType(checker->GetApparentType(expr->Object()->Check(checker)));
     //  Note: don't use possible smart cast to null-like types.
     //        Such situation should be correctly resolved in the subsequent lowering.
+    ES2PANDA_ASSERT(baseType != nullptr);
     if (baseType->DefinitelyETSNullish() && expr->Object()->IsIdentifier()) {
         baseType = expr->Object()->AsIdentifier()->Variable()->TsType();
     }
@@ -2589,7 +2593,7 @@ checker::Type *ETSAnalyzer::Check(ir::UnaryExpression *expr) const
         switch (expr->OperatorType()) {
             case lexer::TokenType::PUNCTUATOR_MINUS: {
                 checker::Type *type = checker->CreateETSBigIntLiteralType(argType->AsETSBigIntType()->GetValue());
-
+                ES2PANDA_ASSERT(type != nullptr);
                 // We do not need this const anymore as we are negating the bigint object in runtime
                 type->RemoveTypeFlag(checker::TypeFlag::CONSTANT);
                 expr->argument_->SetTsType(type);
@@ -2919,7 +2923,10 @@ checker::Type *ETSAnalyzer::Check(ir::AnnotationUsage *st) const
     ArenaUnorderedMap<util::StringView, ir::ClassProperty *> fieldMap {checker->ProgramAllocator()->Adapter()};
     for (auto *it : annoDecl->Properties()) {
         auto *field = it->AsClassProperty();
-        fieldMap.insert(std::make_pair(field->Id()->Name(), field));
+        ES2PANDA_ASSERT(field != nullptr);
+        auto *id = field->Id();
+        ES2PANDA_ASSERT(id != nullptr);
+        fieldMap.insert(std::make_pair(id->Name(), field));
     }
 
     if (annoDecl->Properties().size() < st->Properties().size()) {
@@ -3176,6 +3183,7 @@ bool ETSAnalyzer::CheckInferredFunctionReturnType(ir::ReturnStatement *st, ir::S
     if (containingFunc->ReturnTypeAnnotation() != nullptr) {
         if (containingFunc->IsAsyncFunc()) {
             auto *promiseType = containingFunc->ReturnTypeAnnotation()->GetType(checker);
+            ES2PANDA_ASSERT(promiseType != nullptr);
             if (!promiseType->IsETSObjectType() || promiseType->AsETSObjectType()->TypeArguments().size() != 1) {
                 return false;
             }
@@ -3270,6 +3278,7 @@ checker::Type *ETSAnalyzer::Check(ir::ReturnStatement *st) const
     ir::AstNode *ancestor = util::Helpers::FindAncestorGivenByType(st, ir::AstNodeType::SCRIPT_FUNCTION);
     ES2PANDA_ASSERT(ancestor && ancestor->IsScriptFunction());
 
+    ES2PANDA_ASSERT(ancestor != nullptr);
     auto *containingFunc = ancestor->AsScriptFunction();
     containingFunc->AddFlag(ir::ScriptFunctionFlags::HAS_RETURN);
 
@@ -3513,6 +3522,7 @@ checker::Type *ETSAnalyzer::Check(ir::TSAsExpression *expr) const
 
     checker->CheckAnnotations(expr->TypeAnnotation()->Annotations());
     auto *const targetType = expr->TypeAnnotation()->AsTypeNode()->GetType(checker);
+    ES2PANDA_ASSERT(targetType != nullptr);
     if (targetType->IsTypeError()) {
         return checker->InvalidateType(expr);
     }
diff --git a/ets2panda/checker/ETSAnalyzerHelpers.cpp b/ets2panda/checker/ETSAnalyzerHelpers.cpp
index 9ebb333d7b6e543a91798502da7c47abfe069d3f..de53ef794d75526174470ca922ff64bed21f4421 100644
--- a/ets2panda/checker/ETSAnalyzerHelpers.cpp
+++ b/ets2panda/checker/ETSAnalyzerHelpers.cpp
@@ -516,6 +516,7 @@ void ProcessExclamationMark(ETSChecker *checker, ir::UnaryExpression *expr, chec
 {
     if (checker->IsNullLikeOrVoidExpression(expr->Argument())) {
         auto tsType = checker->CreateETSBooleanType(true);
+        CHECK_NOT_NULL(tsType);
         tsType->AddTypeFlag(checker::TypeFlag::CONSTANT);
         expr->SetTsType(tsType);
         return;
diff --git a/ets2panda/checker/TSAnalyzer.cpp b/ets2panda/checker/TSAnalyzer.cpp
index 44d5a3d824525e69a8147a6a8d9e201a9fc4ca03..0e66ad6f5368717e40284ecd8038014bc4e093f9 100644
--- a/ets2panda/checker/TSAnalyzer.cpp
+++ b/ets2panda/checker/TSAnalyzer.cpp
@@ -802,7 +802,7 @@ void TSAnalyzer::CheckNonComputed(checker::ObjectDescriptor *desc, ir::Expressio
     if (prop->Key()->IsNumberLiteral()) {
         memberVar->AddFlag(varbinder::VariableFlags::NUMERIC_NAME);
     }
-
+    ES2PANDA_ASSERT(desc != nullptr);
     varbinder::LocalVariable *foundMember = desc->FindProperty(propName);
     allPropertiesMap.insert({propName, it->Start()});
 
@@ -1747,6 +1747,7 @@ static void AddEnumValueDeclaration(checker::TSChecker *checker, double number,
         ES2PANDA_ASSERT(res->IsEnumVariable());
         enumVar = res->AsEnumVariable();
         auto *decl = checker->Allocator()->New<varbinder::EnumDecl>(memberStr);
+        ES2PANDA_ASSERT(decl != nullptr);
         decl->BindNode(variable->Declaration()->Node());
         enumVar->ResetDecl(decl);
     }
diff --git a/ets2panda/checker/ets/aliveAnalyzer.cpp b/ets2panda/checker/ets/aliveAnalyzer.cpp
index 05107c571e1906f53304ff5c517c3b00741bae8b..a41a6ac510d4a29fec567a1af729dedc8da6021b 100644
--- a/ets2panda/checker/ets/aliveAnalyzer.cpp
+++ b/ets2panda/checker/ets/aliveAnalyzer.cpp
@@ -242,7 +242,9 @@ void AliveAnalyzer::AnalyzeMethodDef(const ir::MethodDefinition *methodDef)
     status_ = LivenessStatus::ALIVE;
     AnalyzeStat(func->Body());
     ES2PANDA_ASSERT(methodDef->TsType() && methodDef->TsType()->IsETSFunctionType());
-    const auto *returnType = methodDef->TsType()->AsETSFunctionType()->FindSignature(func)->ReturnType();
+    const auto *signature = methodDef->TsType()->AsETSFunctionType()->FindSignature(func);
+    ES2PANDA_ASSERT(signature != nullptr);
+    const auto *returnType = signature->ReturnType();
     const auto isVoid = returnType->IsETSVoidType() || returnType == checker_->GlobalVoidType();
 
     auto isPromiseVoid = false;
@@ -255,8 +257,9 @@ void AliveAnalyzer::AnalyzeMethodDef(const ir::MethodDefinition *methodDef)
     }
 
     if (status_ == LivenessStatus::ALIVE && !isVoid && !isPromiseVoid) {
-        ES2PANDA_ASSERT(methodDef->Function() != nullptr);
-        if (!methodDef->Function()->HasReturnStatement()) {
+        auto *fuction = methodDef->Function();
+        ES2PANDA_ASSERT(fuction != nullptr);
+        if (!fuction->HasReturnStatement()) {
             if (!util::Helpers::IsAsyncMethod(methodDef)) {
                 checker_->LogError(diagnostic::MISSING_RETURN_STMT, {}, func->Start());
                 ClearPendingExits();
diff --git a/ets2panda/checker/ets/dynamic.cpp b/ets2panda/checker/ets/dynamic.cpp
index ec5e5a3dc881f52161cebd90c8a817116f5ab979..7b589e781bfa049ec5302cdddf69eaa8b676953b 100644
--- a/ets2panda/checker/ets/dynamic.cpp
+++ b/ets2panda/checker/ets/dynamic.cpp
@@ -706,7 +706,7 @@ void ETSChecker::BuildLambdaObjectClass(ETSObjectType *functionalInterface, ir::
     auto *invokeMethod = functionalInterface->GetOwnProperty<checker::PropertyType::INSTANCE_METHOD>(
         compiler::Signatures::STATIC_INVOKE_METHOD);
     auto *invokeSignature = invokeMethod->TsType()->AsETSFunctionType()->CallSignatures()[0];
-
+    ES2PANDA_ASSERT(invokeSignature != nullptr);
     std::stringstream ss;
     ss << compiler::Signatures::LAMBDA_OBJECT;
     ToString(this, invokeSignature->Params(), ss);
diff --git a/ets2panda/checker/ets/function.cpp b/ets2panda/checker/ets/function.cpp
index 6736d6544194505f91c22ba06324061318135009..bf9e8520b45302ea9d2931c959341ae5c77cbe86 100644
--- a/ets2panda/checker/ets/function.cpp
+++ b/ets2panda/checker/ets/function.cpp
@@ -1454,6 +1454,7 @@ SignatureInfo *ETSChecker::ComposeSignatureInfo(ir::TSTypeParameterDeclaration *
                 ES2PANDA_ASSERT(IsAnyError());  // #23134
                 return nullptr;
             }
+            ES2PANDA_ASSERT(restParamType != nullptr);
             if (!restParamType->IsETSTupleType() && !restParamType->IsETSArrayType() &&
                 !restParamType->IsETSResizableArrayType()) {
                 LogError(diagnostic::ONLY_ARRAY_OR_TUPLE_FOR_REST, {}, param->Start());
diff --git a/ets2panda/checker/ets/helpers.cpp b/ets2panda/checker/ets/helpers.cpp
index 35eb70cc913479f034769513138980eecb44362b..a5c8abebf546720cf877ef841708a8a79a72c123 100644
--- a/ets2panda/checker/ets/helpers.cpp
+++ b/ets2panda/checker/ets/helpers.cpp
@@ -602,9 +602,14 @@ void ETSChecker::InferAliasLambdaType(ir::TypeNode *localTypeAnnotation, ir::Arr
 checker::Type *ETSChecker::FixOptionalVariableType(varbinder::Variable *const bindingVar, ir::ModifierFlags flags,
                                                    ir::Expression *init)
 {
+    ES2PANDA_ASSERT(bindingVar != nullptr);
     if ((flags & ir::ModifierFlags::OPTIONAL) != 0) {
-        if (init != nullptr && bindingVar->TsType()->IsETSPrimitiveType()) {
-            init->SetBoxingUnboxingFlags(GetBoxingFlag(bindingVar->TsType()));
+        if (init != nullptr) {
+            auto *type = bindingVar->TsType();
+            ES2PANDA_ASSERT(type != nullptr);
+            if (type->IsETSPrimitiveType()) {
+                init->SetBoxingUnboxingFlags(GetBoxingFlag(bindingVar->TsType()));
+            }
         }
         auto *variableType = bindingVar->TsType() != nullptr ? bindingVar->TsType() : GlobalTypeError();
         bindingVar->SetTsType(CreateETSUnionType({GlobalETSUndefinedType(), variableType}));
@@ -1617,6 +1622,7 @@ Type *ETSChecker::HandleTypeAlias(ir::Expression *const name, const ir::TSTypePa
     auto expandedAliasType = aliasType->Substitute(Relation(), substitution);
     CollectAliasParametersForBoxing(expandedAliasType, parametersNeedToBeBoxed, false);
 
+    ES2PANDA_ASSERT(substitution != nullptr);
     for (std::size_t idx = 0; idx < typeAliasNode->TypeParams()->Params().size(); ++idx) {
         auto *typeAliasTypeName = typeAliasNode->TypeParams()->Params().at(idx)->Name();
         auto *typeAliasType = typeAliasTypeName->Variable()->TsType();
diff --git a/ets2panda/checker/ets/object.cpp b/ets2panda/checker/ets/object.cpp
index a3f81609ca9d8d8149ee66f6216f215144485d6e..7cce20face41d0ba4f048c9a21657865a9339703 100644
--- a/ets2panda/checker/ets/object.cpp
+++ b/ets2panda/checker/ets/object.cpp
@@ -2565,6 +2565,7 @@ Type const *ETSChecker::GetApparentType(Type const *type) const
     if (auto it = apparentTypes_.find(type); LIKELY(it != apparentTypes_.end())) {
         return it->second;
     }
+    ES2PANDA_ASSERT(type != nullptr);
     // Relaxed for some types
     if (type->IsETSTypeParameter()) {
         // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
diff --git a/ets2panda/checker/ets/typeCheckingHelpers.cpp b/ets2panda/checker/ets/typeCheckingHelpers.cpp
index 4fb488ff7d0b8ee0ec82a0d4689cf9ed5e77d52c..01d4584093e6379412ffa5d93baa8b310f8fef68 100644
--- a/ets2panda/checker/ets/typeCheckingHelpers.cpp
+++ b/ets2panda/checker/ets/typeCheckingHelpers.cpp
@@ -576,6 +576,7 @@ Type *ETSChecker::GetTypeOfVariable(varbinder::Variable *const var)
     // NOTE: kbaladurin. forbid usage of imported entities as types without declarations
     if (VarBinder()->AsETSBinder()->IsDynamicModuleVariable(var)) {
         auto *importData = VarBinder()->AsETSBinder()->DynamicImportDataForVar(var);
+        ES2PANDA_ASSERT(importData != nullptr);
         if (importData->import->IsPureDynamic()) {
             return GlobalBuiltinDynamicType(importData->import->Language());
         }
diff --git a/ets2panda/checker/ets/typeRelationContext.cpp b/ets2panda/checker/ets/typeRelationContext.cpp
index d50f534f2c5c5249378e8a3e332a549329664fe9..f4eca541008475b7950cd28665ab4098694d7bab 100644
--- a/ets2panda/checker/ets/typeRelationContext.cpp
+++ b/ets2panda/checker/ets/typeRelationContext.cpp
@@ -20,6 +20,8 @@ bool AssignmentContext::ValidateArrayTypeInitializerByElement(TypeRelation *rela
                                                               ETSArrayType *target)
 {
     bool ok = true;
+    ES2PANDA_ASSERT(node != nullptr);
+    ES2PANDA_ASSERT(target != nullptr);
     if (target->IsETSTupleType()) {
         return true;
     }
diff --git a/ets2panda/checker/ets/utilityTypeHandlers.cpp b/ets2panda/checker/ets/utilityTypeHandlers.cpp
index 6615a05693d4d8cda631cad74f7e642845513928..90b805ca7b2174e4d31c8641c48967fe896e1f7c 100644
--- a/ets2panda/checker/ets/utilityTypeHandlers.cpp
+++ b/ets2panda/checker/ets/utilityTypeHandlers.cpp
@@ -240,6 +240,7 @@ ir::ClassProperty *ETSChecker::CreateNullishPropertyFromAccessor(ir::MethodDefin
         // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
         ProgramAllocator()->New<ir::ClassProperty>(ident, nullptr, nullptr, modifierFlag, ProgramAllocator(), false);
 
+    ES2PANDA_ASSERT(prop != nullptr);
     prop->SetParent(newClassDefinition);
     ident->SetParent(prop);
 
diff --git a/ets2panda/checker/ts/destructuringContext.cpp b/ets2panda/checker/ts/destructuringContext.cpp
index 62212a8fcac53a0723d372e7ae9608ebbcab3005..af07585e1968ecc23c80f942e8a6a04b2c2dac65 100644
--- a/ets2panda/checker/ts/destructuringContext.cpp
+++ b/ets2panda/checker/ts/destructuringContext.cpp
@@ -323,7 +323,7 @@ Type *ArrayDestructuringContext::CreateTupleTypeForRest(TupleType *tuple)
     uint32_t iterIndex = 0;
 
     Type *tupleElementType = GetTypeFromTupleByIndex(tuple);
-
+    ES2PANDA_ASSERT(desc != nullptr);
     while (tupleElementType != nullptr) {
         ElementFlags memberFlag = ElementFlags::REQUIRED;
         util::StringView memberIndex = util::Helpers::ToStringView(checker_->Allocator(), iterIndex);
diff --git a/ets2panda/checker/types/ets/etsDynamicType.cpp b/ets2panda/checker/types/ets/etsDynamicType.cpp
index 3fb4c1392d36f4ec568982963c0b2cc247d00960..dece7e63320fc1379835d2166c908127d6c8cfbb 100644
--- a/ets2panda/checker/types/ets/etsDynamicType.cpp
+++ b/ets2panda/checker/types/ets/etsDynamicType.cpp
@@ -30,6 +30,7 @@ varbinder::LocalVariable *ETSDynamicType::GetPropertyDynamic(const util::StringV
 
     varbinder::LocalVariable *var = varbinder::Scope::CreateVar<varbinder::PropertyDecl>(
         Allocator(), name, varbinder::VariableFlags::BUILTIN_TYPE, nullptr);
+    ES2PANDA_ASSERT(var != nullptr);
     var->SetTsType(checker->GlobalBuiltinDynamicType(lang_));
     propertiesCache_.emplace(name, var);
 
diff --git a/ets2panda/checker/types/ets/etsFunctionType.cpp b/ets2panda/checker/types/ets/etsFunctionType.cpp
index ad1fa74e55cec499977f283cdc722c319cafb0bf..5bde44efd617aad03ea6f5c609c6ecf67b0cf038 100644
--- a/ets2panda/checker/types/ets/etsFunctionType.cpp
+++ b/ets2panda/checker/types/ets/etsFunctionType.cpp
@@ -80,6 +80,8 @@ static ETSObjectType *FunctionTypeToFunctionalInterfaceType(ETSChecker *checker,
         auto *elementType = !signature->RestVar()->TsType()->IsETSTupleType()
                                 ? checker->GetElementTypeOfArray(signature->RestVar()->TsType())
                                 : checker->GlobalETSAnyType();
+        ES2PANDA_ASSERT(functionN != nullptr);
+        ES2PANDA_ASSERT(substitution != nullptr);
         substitution->emplace(functionN->TypeArguments()[0]->AsETSTypeParameter(), checker->MaybeBoxType(elementType));
         return functionN->Substitute(checker->Relation(), substitution, true, isExtensionHack);
     }
@@ -94,6 +96,8 @@ static ETSObjectType *FunctionTypeToFunctionalInterfaceType(ETSChecker *checker,
     auto *funcIface = checker->GlobalBuiltinFunctionType(arity, false);
     auto *substitution = checker->NewSubstitution();
 
+    ES2PANDA_ASSERT(funcIface != nullptr);
+    ES2PANDA_ASSERT(substitution != nullptr);
     for (size_t i = 0; i < arity; i++) {
         substitution->emplace(funcIface->TypeArguments()[i]->AsETSTypeParameter(),
                               checker->MaybeBoxType(signature->Params()[i]->TsType()));
diff --git a/ets2panda/checker/types/ets/etsObjectType.cpp b/ets2panda/checker/types/ets/etsObjectType.cpp
index 80ed356e4f01592397d716468337d0b75e13d1a1..a177b5b38f29cd87aaa697b37b731c6e448fe9bb 100644
--- a/ets2panda/checker/types/ets/etsObjectType.cpp
+++ b/ets2panda/checker/types/ets/etsObjectType.cpp
@@ -1153,6 +1153,7 @@ ETSObjectType *ETSObjectType::SubstituteArguments(TypeRelation *relation, ArenaV
     auto *substitution = checker->NewSubstitution();
 
     ES2PANDA_ASSERT(baseType_ == nullptr);
+    ES2PANDA_ASSERT(substitution != nullptr);
     ES2PANDA_ASSERT(typeArguments_.size() == arguments.size());
 
     for (size_t ix = 0; ix < typeArguments_.size(); ix++) {
diff --git a/ets2panda/checker/types/ets/etsUnionType.cpp b/ets2panda/checker/types/ets/etsUnionType.cpp
index 94aefa04f91b6ad3845b4fee911adf000b514c4b..44abc587587c26af246c896394d4e0d5148029fe 100644
--- a/ets2panda/checker/types/ets/etsUnionType.cpp
+++ b/ets2panda/checker/types/ets/etsUnionType.cpp
@@ -565,7 +565,7 @@ bool ETSUnionType::ExtractType(checker::ETSChecker *checker, checker::ETSArrayTy
 
         if (checker->Relation()->IsIdenticalTo(constituentType, sourceType)) {
             rc = true;
-            unionTypes.erase(it);
+            it = unionTypes.erase(it);
             continue;
         }
         if (checker->Relation()->IsSupertypeOf(constituentType, sourceType)) {
diff --git a/ets2panda/checker/types/typeRelation.cpp b/ets2panda/checker/types/typeRelation.cpp
index 69deb56a2d0b8ca21600eb26fd30a48084049f29..4055cf91d7b88c1808ad04385955c9a25580f4bb 100644
--- a/ets2panda/checker/types/typeRelation.cpp
+++ b/ets2panda/checker/types/typeRelation.cpp
@@ -161,6 +161,7 @@ bool TypeRelation::IsComparableTo(Type *source, Type *target)
     result_ = CacheLookup(source, target, checker_->ComparableResults(), RelationType::COMPARABLE);
 
     // NOTE: vpukhov. reimplement dynamic comparison and remove this check
+    ES2PANDA_ASSERT(source != nullptr);
     if (source->IsETSDynamicType() || target->IsETSDynamicType()) {
         if (!(source->IsETSDynamicType() && target->IsETSDynamicType())) {
             return false;
diff --git a/ets2panda/parser/ASparser.cpp b/ets2panda/parser/ASparser.cpp
index f2567fef3d343350723a2e1b2eda79099eca4d4e..2e0e102951fd5e5354e778737b6ed345fbad31bc 100644
--- a/ets2panda/parser/ASparser.cpp
+++ b/ets2panda/parser/ASparser.cpp
@@ -1122,6 +1122,7 @@ ArenaVector<ir::TSClassImplements *> ASParser::ParseClassImplementClause()
 
         const lexer::SourcePosition &implementStart = Lexer()->GetToken().Start();
         auto *implementsName = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+        ES2PANDA_ASSERT(implementsName != nullptr);
         implementsName->SetRange(Lexer()->GetToken().Loc());
         auto *implementsClause = AllocNode<ir::NamedType>(implementsName, Allocator());
         ES2PANDA_ASSERT(implementsClause != nullptr);
@@ -1137,6 +1138,7 @@ ArenaVector<ir::TSClassImplements *> ASParser::ParseClassImplementClause()
             }
 
             implementsName = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+            ES2PANDA_ASSERT(implementsName != nullptr);
             implementsName->SetRange(Lexer()->GetToken().Loc());
             auto *next = AllocNode<ir::NamedType>(implementsName, Allocator());
             current->SetRange(Lexer()->GetToken().Loc());
@@ -1740,6 +1742,7 @@ ir::Statement *ASParser::ParseImportDeclaration([[maybe_unused]] StatementParsin
         source = ParseFromClause(false);
     }
 
+    ES2PANDA_ASSERT(source != nullptr);
     lexer::SourcePosition endLoc = source->End();
     auto *importDeclaration = AllocNode<ir::ImportDeclaration>(source, std::move(specifiers));
     ES2PANDA_ASSERT(importDeclaration != nullptr);
diff --git a/ets2panda/parser/ETSparser.cpp b/ets2panda/parser/ETSparser.cpp
index 827ca2a16637c93fdb1922d85785c7274475f4d2..5198a17f4fc8ccde97272a59e8595984670ccaf4 100644
--- a/ets2panda/parser/ETSparser.cpp
+++ b/ets2panda/parser/ETSparser.cpp
@@ -159,6 +159,7 @@ void ETSParser::ParseFileHeaderFlag(lexer::SourcePosition startLoc, ArenaVector<
     auto *exprStatementNode = AllocNode<ir::ExpressionStatement>(fileHeaderFlag);
 
     exprStatementNode->SetRange({startLoc, fileHeaderFlag->End()});
+    ES2PANDA_ASSERT(exprStatementNode != nullptr);
     ConsumeSemicolon(exprStatementNode);
     if (statements != nullptr) {
         statements->push_back(exprStatementNode);
@@ -1023,6 +1024,7 @@ ir::TypeNode *ETSParser::ParseTypeReference(TypeAnnotationParsingOptions *option
         }
 
         typeRefPart = AllocNode<ir::ETSTypeReferencePart>(typeName, typeParams, typeRefPart, Allocator());
+        ES2PANDA_ASSERT(typeRefPart != nullptr);
         typeRefPart->SetRange({partPos, Lexer()->GetToken().End()});
 
         if (!Lexer()->TryEatTokenType(lexer::TokenType::PUNCTUATOR_PERIOD)) {
@@ -1207,6 +1209,7 @@ ir::ETSImportDeclaration *ETSParser::ParseImportPathBuildImport(ArenaVector<ir::
         LogExpectedToken(lexer::TokenType::LITERAL_STRING);
         // Try to create DUMMY import source as error placeholder
         auto errorLiteral = AllocNode<ir::StringLiteral>(ERROR_LITERAL);
+        ES2PANDA_ASSERT(errorLiteral != nullptr);
         errorLiteral->SetRange(Lexer()->GetToken().Loc());
         auto *const importDeclaration = AllocNode<ir::ETSImportDeclaration>(
             errorLiteral, util::ImportPathManager::ImportMetadata {}, std::move(specifiers), importKind);
@@ -1282,6 +1285,7 @@ ArenaVector<ir::ETSImportDeclaration *> ETSParser::ParseImportDeclarations()
         auto pos = Lexer()->Save();
         if (!specifiers.empty()) {
             auto *const importDecl = ParseImportPathBuildImport(std::move(specifiers), true, startLoc, importKind);
+            ES2PANDA_ASSERT(importDecl != nullptr);
             statements.push_back(importDecl->AsETSImportDeclaration());
         }
 
@@ -1574,6 +1578,7 @@ ir::AnnotatedExpression *ETSParser::GetAnnotatedExpressionFromParam()
     switch (Lexer()->GetToken().Type()) {
         case lexer::TokenType::LITERAL_IDENT: {
             parameter = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+            ES2PANDA_ASSERT(parameter != nullptr);
             if (parameter->AsIdentifier()->Decorators().empty()) {
                 parameter->SetRange(Lexer()->GetToken().Loc());
             } else {
@@ -1596,6 +1601,7 @@ ir::AnnotatedExpression *ETSParser::GetAnnotatedExpressionFromParam()
             restIdent->SetRange(Lexer()->GetToken().Loc());
 
             parameter = AllocNode<ir::SpreadElement>(ir::AstNodeType::REST_ELEMENT, Allocator(), restIdent);
+            ES2PANDA_ASSERT(parameter != nullptr);
             parameter->SetRange({startLoc, Lexer()->GetToken().End()});
             break;
         }
@@ -2193,6 +2199,7 @@ ir::FunctionDeclaration *ETSParser::ParseFunctionDeclaration(bool canBeAnonymous
         Lexer()->NextToken();
     }
 
+    ES2PANDA_ASSERT(funcDecl != nullptr);
     funcDecl->SetRange(func->Range());
     func->AddModifier(modifiers);
     func->SetStart(startLoc);
diff --git a/ets2panda/parser/ETSparserAnnotations.cpp b/ets2panda/parser/ETSparserAnnotations.cpp
index 1194431c6943fda737dfb374414c7a1b38799bd9..2f904b8f634945364d1311a236200c44c690efa0 100644
--- a/ets2panda/parser/ETSparserAnnotations.cpp
+++ b/ets2panda/parser/ETSparserAnnotations.cpp
@@ -392,6 +392,7 @@ ir::AnnotationUsage *ETSParser::ParseAnnotationUsage()
         } else if (Lexer()->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
             // handle single field annotation
             auto *singleParamName = AllocNode<ir::Identifier>(compiler::Signatures::ANNOTATION_KEY_VALUE, Allocator());
+            ES2PANDA_ASSERT(singleParamName != nullptr);
             singleParamName->SetRange({Lexer()->GetToken().Start(), Lexer()->GetToken().End()});
 
             const auto savePos = Lexer()->GetToken().Start();
diff --git a/ets2panda/parser/ETSparserClasses.cpp b/ets2panda/parser/ETSparserClasses.cpp
index 57e844e8c20a422931efce38a01a26acac9fd680..6f44dcd410f6c4d1b5c0bbcb43eb7dc5073d1823 100644
--- a/ets2panda/parser/ETSparserClasses.cpp
+++ b/ets2panda/parser/ETSparserClasses.cpp
@@ -440,6 +440,7 @@ ir::TypeNode *ETSParser::ConvertToOptionalUnionType(ir::TypeNode *typeAnno)
         types.push_back(AllocNode<ir::ETSUndefinedType>(Allocator()));
         types.back()->SetRange(typeAnno->Range());
         auto *newTypeAnno = AllocNode<ir::ETSUnionType>(std::move(types), Allocator());
+        ES2PANDA_ASSERT(newTypeAnno != nullptr);
         newTypeAnno->SetRange(typeAnno->Range());
         return newTypeAnno;
     }
@@ -563,6 +564,7 @@ ir::MethodDefinition *ETSParser::ParseClassMethodDefinition(ir::Identifier *meth
     funcExpr->SetRange(func->Range());
     func->AddModifier(modifiers);
 
+    ES2PANDA_ASSERT(methodName->Clone(Allocator(), nullptr) != nullptr);
     auto *method = AllocNode<ir::MethodDefinition>(methodKind, methodName->Clone(Allocator(), nullptr)->AsExpression(),
                                                    funcExpr, modifiers, Allocator(), false);
     ES2PANDA_ASSERT(method != nullptr);
@@ -601,6 +603,7 @@ ir::MethodDefinition *ETSParser::ParseClassMethod(ClassElementDescriptor *desc,
     auto *method =
         AllocNode<ir::MethodDefinition>(desc->methodKind, propName->Clone(Allocator(), nullptr)->AsExpression(),
                                         funcExpr, desc->modifiers, Allocator(), desc->isComputed);
+    ES2PANDA_ASSERT(method != nullptr);
     method->SetRange(funcExpr->Range());
 
     return method;
@@ -808,13 +811,16 @@ ir::MethodDefinition *ETSParser::ParseClassGetterSetterMethod(const ArenaVector<
 
     lexer::SourcePosition propEnd = methodName->End();
     ir::MethodDefinition *method = ParseClassMethod(&desc, properties, methodName, &propEnd);
+    ES2PANDA_ASSERT(method != nullptr);
     method->SetDefaultAccessModifier(isDefault);
-    method->Function()->AddModifier(desc.modifiers);
+    auto *func = method->Function();
+    ES2PANDA_ASSERT(func != nullptr);
+    func->AddModifier(desc.modifiers);
     method->SetRange({desc.propStart, propEnd});
     if (desc.methodKind == ir::MethodDefinitionKind::GET) {
-        method->Function()->AddFlag(ir::ScriptFunctionFlags::GETTER);
+        func->AddFlag(ir::ScriptFunctionFlags::GETTER);
     } else {
-        method->Function()->AddFlag(ir::ScriptFunctionFlags::SETTER);
+        func->AddFlag(ir::ScriptFunctionFlags::SETTER);
     }
 
     return method;
@@ -831,24 +837,26 @@ ir::MethodDefinition *ETSParser::ParseInterfaceGetterSetterMethod(const ir::Modi
         return nullptr;
     }
     method->AddModifier(ir::ModifierFlags::PUBLIC);
-    auto id = method->Id();
+    auto *id = method->Id();
+    auto *func = method->Function();
     ES2PANDA_ASSERT(id != nullptr);
+    ES2PANDA_ASSERT(func != nullptr);
     method->SetRange({Lexer()->GetToken().Start(), method->Id()->End()});
     if (methodKind == ir::MethodDefinitionKind::GET) {
         id->SetAccessor();
-        method->Function()->AddFlag(ir::ScriptFunctionFlags::GETTER);
+        func->AddFlag(ir::ScriptFunctionFlags::GETTER);
     } else {
         id->SetMutator();
-        method->Function()->AddFlag(ir::ScriptFunctionFlags::SETTER);
+        func->AddFlag(ir::ScriptFunctionFlags::SETTER);
     }
     method->AddModifier(ir::ModifierFlags::PUBLIC);
 
-    method->Function()->SetIdent(id->Clone(Allocator(), nullptr));
-    method->Function()->AddModifier(method->Modifiers());
+    func->SetIdent(id->Clone(Allocator(), nullptr));
+    func->AddModifier(method->Modifiers());
 
-    bool hasReturn = method->Function()->ReturnTypeAnnotation() != nullptr;
+    bool hasReturn = func->ReturnTypeAnnotation() != nullptr;
     if (hasReturn && methodKind == ir::MethodDefinitionKind::SET) {
-        LogError(diagnostic::SETTER_NO_RETURN_TYPE, {}, method->Function()->Range().start);
+        LogError(diagnostic::SETTER_NO_RETURN_TYPE, {}, func->Range().start);
     }
 
     return method;
@@ -1058,6 +1066,7 @@ ir::AstNode *ETSParser::ParseInterfaceField()
         }
     }
 
+    ES2PANDA_ASSERT(name != nullptr);
     name->SetRange(Lexer()->GetToken().Loc());
     Lexer()->NextToken();
     bool optionalField = false;
@@ -1107,6 +1116,7 @@ ir::MethodDefinition *ETSParser::ParseInterfaceMethod(ir::ModifierFlags flags, i
         name = AllocBrokenExpression(Lexer()->GetToken().Loc());
     } else {
         name = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+        ES2PANDA_ASSERT(name != nullptr);
         name->SetRange(Lexer()->GetToken().Loc());
         Lexer()->NextToken();
     }
@@ -1155,8 +1165,10 @@ ir::MethodDefinition *ETSParser::ParseInterfaceMethod(ir::ModifierFlags flags, i
     func->AddFlag(ir::ScriptFunctionFlags::METHOD);
 
     func->SetIdent(name);
+    ES2PANDA_ASSERT(name->Clone(Allocator(), nullptr) != nullptr);
     auto *method = AllocNode<ir::MethodDefinition>(methodKind, name->Clone(Allocator(), nullptr)->AsExpression(),
                                                    funcExpr, flags, Allocator(), false);
+    ES2PANDA_ASSERT(method != nullptr);
     method->SetRange(funcExpr->Range());
 
     ConsumeSemicolon(method);
diff --git a/ets2panda/parser/ETSparserExpressions.cpp b/ets2panda/parser/ETSparserExpressions.cpp
index 2957d88b976f984873ceab47c781d36b89e88653..a2265ad6039d7947cc7b62ab6baf5bebda53e167 100644
--- a/ets2panda/parser/ETSparserExpressions.cpp
+++ b/ets2panda/parser/ETSparserExpressions.cpp
@@ -48,11 +48,11 @@ static std::string GetArgumentsSourceView(lexer::Lexer *lexer, const util::Strin
 ir::Expression *ETSParser::ParseFunctionParameterExpression(ir::AnnotatedExpression *const paramIdent, bool isOptional)
 {
     ir::ETSParameterExpression *paramExpression;
+    ES2PANDA_ASSERT(paramIdent != nullptr);
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
         auto const lexerPos = Lexer()->Save().Iterator();
         Lexer()->NextToken();  // eat '='
 
-        ES2PANDA_ASSERT(paramIdent != nullptr);
         if (paramIdent->IsRestElement()) {
             LogError(diagnostic::NO_DEFAULT_FOR_REST);
         }
@@ -83,9 +83,11 @@ ir::Expression *ETSParser::ParseFunctionParameterExpression(ir::AnnotatedExpress
         paramExpression->SetRange({paramIdent->Start(), paramExpression->Initializer()->End()});
     } else if (paramIdent->IsIdentifier()) {
         paramExpression = AllocNode<ir::ETSParameterExpression>(paramIdent->AsIdentifier(), isOptional, Allocator());
+        ES2PANDA_ASSERT(paramExpression != nullptr);
         paramExpression->SetRange({paramIdent->Start(), paramIdent->End()});
     } else {
         paramExpression = AllocNode<ir::ETSParameterExpression>(paramIdent->AsRestElement(), false, Allocator());
+        ES2PANDA_ASSERT(paramExpression != nullptr);
         paramExpression->SetRange({paramIdent->Start(), paramIdent->End()});
     }
     return paramExpression;
@@ -178,6 +180,7 @@ ir::Expression *ETSParser::ParseUnaryOrPrefixUpdateExpression(ExpressionParseFla
     }
 
     ir::Expression *returnExpr = CreateUnaryExpressionFromArgument(argument, operatorType, beginningChar);
+    ES2PANDA_ASSERT(returnExpr != nullptr);
     returnExpr->SetRange({start, argument->End()});
     return returnExpr;
 }
@@ -215,6 +218,7 @@ ir::Expression *ETSParser::ParsePropertyDefinition(ExpressionParseFlags flags)
     if (propertyKind == ir::PropertyKind::INIT) {
         returnProperty =
             AllocNode<ir::Property>(propertyKind, key, value, methodStatus != ParserStatus::NO_OPTS, isComputed);
+        ES2PANDA_ASSERT(returnProperty != nullptr);
         returnProperty->SetRange({start, end});
     } else {
         returnProperty = AllocBrokenExpression(key->Start());
diff --git a/ets2panda/parser/ETSparserNamespaces.cpp b/ets2panda/parser/ETSparserNamespaces.cpp
index bf8a1f36626fbf3dd28b04d687ecc38619093f3d..9b8ce8e4a79f7c2a7495f712caea9196d79358f7 100644
--- a/ets2panda/parser/ETSparserNamespaces.cpp
+++ b/ets2panda/parser/ETSparserNamespaces.cpp
@@ -70,6 +70,7 @@ ir::ETSModule *ETSParser::ParseNamespaceImp(ir::ModifierFlags flags)
     Lexer()->NextToken();
     auto *result = AllocNode<ir::ETSModule>(Allocator(), ArenaVector<ir::Statement *>(Allocator()->Adapter()),
                                             ExpectIdentifier(), ir::ModuleFlag::NAMESPACE, globalProgram_);
+    ES2PANDA_ASSERT(result != nullptr);
     ir::ETSModule *parent = result;
     ir::ETSModule *child = nullptr;
     while (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD) {
@@ -84,6 +85,7 @@ ir::ETSModule *ETSParser::ParseNamespaceImp(ir::ModifierFlags flags)
         if ((flags & ir::ModifierFlags::DECLARE) != 0) {
             child->AddModifier(ir::ModifierFlags::DECLARE);
         }
+        ES2PANDA_ASSERT(parent != nullptr);
         parent->Statements().emplace_back(child);
         parent = child;
     }
diff --git a/ets2panda/parser/ETSparserTypes.cpp b/ets2panda/parser/ETSparserTypes.cpp
index 06ff49842290d6ebebd18aa4849805b3f92ef940..6853f67fada877ee6424d518db9162ab13c5b611 100644
--- a/ets2panda/parser/ETSparserTypes.cpp
+++ b/ets2panda/parser/ETSparserTypes.cpp
@@ -178,6 +178,7 @@ ir::TypeNode *ETSParser::ParseWildcardType(TypeAnnotationParsingOptions *options
     ir::ETSTypeReference *typeReference = nullptr;
     if (!isUnboundOut) {
         auto reference = ParseTypeReference(options);
+        ES2PANDA_ASSERT(reference != nullptr);
         typeReference = reference->AsETSTypeReference();
     }
 
diff --git a/ets2panda/parser/TSparser.cpp b/ets2panda/parser/TSparser.cpp
index d2545ce4258ac527a5c3a340bb71ad14c40648a6..4c41a234a3ed0717b0f5940f822f92b59b496a69 100644
--- a/ets2panda/parser/TSparser.cpp
+++ b/ets2panda/parser/TSparser.cpp
@@ -515,7 +515,7 @@ ir::TypeNode *TSParser::ParseTypeOperatorOrTypeReference()
         }
 
         auto *typeOperator = AllocNode<ir::TSTypeOperator>(type, ir::TSOperatorType::READONLY, Allocator());
-
+        ES2PANDA_ASSERT(typeOperator != nullptr);
         typeOperator->SetRange({typeOperatorStart, type->End()});
 
         return typeOperator;
@@ -1934,6 +1934,7 @@ ir::MethodDefinition *TSParser::ParseClassMethod(ClassElementDescriptor *desc,
     }
 
     auto *funcExpr = AllocNode<ir::FunctionExpression>(func);
+    ES2PANDA_ASSERT(funcExpr != nullptr);
     funcExpr->SetRange(func->Range());
 
     if (desc->methodKind == ir::MethodDefinitionKind::SET) {
@@ -1946,6 +1947,7 @@ ir::MethodDefinition *TSParser::ParseClassMethod(ClassElementDescriptor *desc,
     func->AddFlag(ir::ScriptFunctionFlags::METHOD);
     auto *method = AllocNode<ir::MethodDefinition>(desc->methodKind, propName, funcExpr, desc->modifiers, Allocator(),
                                                    desc->isComputed);
+    ES2PANDA_ASSERT(method != nullptr);
     method->SetRange(funcExpr->Range());
 
     return method;
diff --git a/ets2panda/parser/expressionParser.cpp b/ets2panda/parser/expressionParser.cpp
index 75394a926455ae78abac651f00bf1f9096f51648..d54491b99fb7b9fe5dab667821b86a9126557606 100644
--- a/ets2panda/parser/expressionParser.cpp
+++ b/ets2panda/parser/expressionParser.cpp
@@ -345,6 +345,7 @@ ir::ArrowFunctionExpression *ParserImpl::ParseArrowFunctionExpressionBody(ArrowF
     funcNode->SetRange({desc->startLoc, endLoc});
 
     auto *arrowFuncNode = AllocNode<ir::ArrowFunctionExpression>(funcNode, Allocator());
+    ES2PANDA_ASSERT(arrowFuncNode != nullptr);
     arrowFuncNode->SetRange(funcNode->Range());
 
     return arrowFuncNode;
@@ -2369,7 +2370,7 @@ ir::Expression *ParserImpl::ParseUnaryOrPrefixUpdateExpression(ExpressionParseFl
         returnExpr = AllocNode<ir::UnaryExpression>(argument, operatorType);
     }
 
-    ES2PANDA_ASSERT(returnExpr);
+    ES2PANDA_ASSERT(returnExpr != nullptr);
     returnExpr->SetRange({start, end});
 
     return returnExpr;
@@ -2415,6 +2416,7 @@ ir::Expression *ParserImpl::ParseImportExpression()
     ExpectToken(lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS);
 
     auto *importExpression = AllocNode<ir::ImportExpression>(source);
+    ES2PANDA_ASSERT(importExpression != nullptr);
     importExpression->SetRange({startLoc, endImportLoc});
 
     return importExpression;
@@ -2450,6 +2452,7 @@ ir::FunctionExpression *ParserImpl::ParseFunctionExpression(ParserStatus newStat
     }
 
     ir::ScriptFunction *functionNode = ParseFunction(newStatus);
+    ES2PANDA_ASSERT(functionNode != nullptr);
     functionNode->SetStart(startLoc);
 
     auto *funcExpr = AllocNode<ir::FunctionExpression>(ident, functionNode);
diff --git a/ets2panda/parser/parserImpl.cpp b/ets2panda/parser/parserImpl.cpp
index b9415f03fdb33a230a3ed411816d5bfcd5c43165..6d8a1e015cd87a0eccd2494f52f7474901f438b8 100644
--- a/ets2panda/parser/parserImpl.cpp
+++ b/ets2panda/parser/parserImpl.cpp
@@ -478,6 +478,7 @@ ir::MethodDefinition *ParserImpl::ParseClassMethod(ClassElementDescriptor *desc,
                       : propName;
     auto *method = AllocNode<ir::MethodDefinition>(desc->methodKind, ident, funcExpr, desc->modifiers, Allocator(),
                                                    desc->isComputed);
+    ES2PANDA_ASSERT(method != nullptr);
     method->SetRange(funcExpr->Range());
 
     return method;
@@ -497,6 +498,7 @@ ir::ClassElement *ParserImpl::ParseClassProperty(ClassElementDescriptor *desc,
         }
 
         property = ParseClassMethod(desc, properties, propName, &propEnd);
+        ES2PANDA_ASSERT(property != nullptr);
         property->SetRange({desc->propStart, propEnd});
         return property;
     }
@@ -516,7 +518,7 @@ ir::ClassElement *ParserImpl::ParseClassProperty(ClassElementDescriptor *desc,
 
     property =
         AllocNode<ir::ClassProperty>(propName, value, typeAnnotation, desc->modifiers, Allocator(), desc->isComputed);
-
+    ES2PANDA_ASSERT(property != nullptr);
     property->SetRange({desc->propStart, propEnd});
 
     return property;
@@ -687,6 +689,7 @@ ir::MethodDefinition *ParserImpl::BuildImplicitConstructor(ir::ClassDefinitionMo
     auto *key = AllocNode<ir::Identifier>("constructor", Allocator());
 
     if ((modifiers & ir::ClassDefinitionModifiers::SET_CTOR_ID) != 0U) {
+        ES2PANDA_ASSERT(key != nullptr);
         func->SetIdent(key->Clone(Allocator(), nullptr));
     }
 
@@ -711,6 +714,7 @@ void ParserImpl::CreateImplicitConstructor(ir::MethodDefinition *&ctor,
 
     ctor = BuildImplicitConstructor(modifiers, startLoc);
     if ((flags & ir::ModifierFlags::DECLARE) != 0) {
+        ES2PANDA_ASSERT(ctor != nullptr);
         auto *ctorFunc = ctor->Function();
         ES2PANDA_ASSERT(ctorFunc != nullptr);
         ctorFunc->AddFlag(ir::ScriptFunctionFlags::EXTERNAL);
diff --git a/ets2panda/parser/statementParser.cpp b/ets2panda/parser/statementParser.cpp
index a866581e20c49c3d4837afb112887aaf46c2a8c1..2e5c11745fbcf6d6f75b1b2bfa30f69493a47d48 100644
--- a/ets2panda/parser/statementParser.cpp
+++ b/ets2panda/parser/statementParser.cpp
@@ -520,9 +520,11 @@ ir::Statement *ParserImpl::ParseBreakStatement()
     }
 
     auto *identNode = AllocNode<ir::Identifier>(label, Allocator());
+    ES2PANDA_ASSERT(identNode != nullptr);
     identNode->SetRange(lexer_->GetToken().Loc());
 
     auto *breakStatement = AllocNode<ir::BreakStatement>(identNode);
+    ES2PANDA_ASSERT(breakStatement != nullptr);
     breakStatement->SetRange({startLoc, lexer_->GetToken().End()});
 
     lexer_->NextToken();
@@ -575,6 +577,7 @@ ir::Statement *ParserImpl::ParseContinueStatement()
     }
 
     auto *identNode = AllocNode<ir::Identifier>(label, Allocator());
+    ES2PANDA_ASSERT(identNode != nullptr);
     identNode->SetRange(lexer_->GetToken().Loc());
 
     auto *continueStatement = AllocNode<ir::ContinueStatement>(identNode);
@@ -657,9 +660,11 @@ ir::FunctionDeclaration *ParserImpl::ParseFunctionDeclaration(bool canBeAnonymou
     if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
         if (canBeAnonymous) {
             ir::ScriptFunction *func = ParseFunction(newStatus | ParserStatus::NEED_RETURN_TYPE);
+            ES2PANDA_ASSERT(func != nullptr);
             func->SetStart(startLoc);
 
             auto *funcDecl = AllocNode<ir::FunctionDeclaration>(Allocator(), func, true);
+            ES2PANDA_ASSERT(funcDecl != nullptr);
             funcDecl->SetRange(func->Range());
             return funcDecl;
         }
@@ -679,6 +684,7 @@ ir::FunctionDeclaration *ParserImpl::ParseFunctionDeclaration(bool canBeAnonymou
     func->SetIdent(identNode);
     func->SetStart(startLoc);
     auto *funcDecl = AllocNode<ir::FunctionDeclaration>(Allocator(), func);
+    ES2PANDA_ASSERT(funcDecl != nullptr);
     funcDecl->SetRange(func->Range());
 
     if (func->IsOverload() && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
@@ -1371,6 +1377,7 @@ ir::Statement *ParserImpl::ParseTryStatement()
 
     while (lexer_->GetToken().Type() == lexer::TokenType::KEYW_CATCH) {
         catchClause = ParseCatchClause();
+        ES2PANDA_ASSERT(catchClause != nullptr);
         endLoc = catchClause->End();
         catchClauses.push_back(catchClause);
     }
@@ -1386,6 +1393,7 @@ ir::Statement *ParserImpl::ParseTryStatement()
     ArenaVector<std::pair<compiler::LabelPair, const ir::Statement *>> finalizerInsertions(Allocator()->Adapter());
 
     auto *tryStatement = AllocNode<ir::TryStatement>(body, std::move(catchClauses), finallyClause, finalizerInsertions);
+    ES2PANDA_ASSERT(tryStatement != nullptr);
     tryStatement->SetRange({startLoc, endLoc});
     return tryStatement;
 }
@@ -1989,6 +1997,7 @@ ir::Statement *ParserImpl::ParseImportDeclaration(StatementParsingFlags flags)
         source = ParseFromClause(false);
     }
 
+    ES2PANDA_ASSERT(source != nullptr);
     lexer::SourcePosition endLoc = source->End();
     auto *importDeclaration = AllocNode<ir::ImportDeclaration>(source, std::move(specifiers));
     ES2PANDA_ASSERT(importDeclaration != nullptr);
diff --git a/ets2panda/parser/statementTSParser.cpp b/ets2panda/parser/statementTSParser.cpp
index 4cd60c24dbdc8d586dd6fa076ea8788d47759f75..b0a451bcd38a8e6b9058b610c281183fb618cbb2 100644
--- a/ets2panda/parser/statementTSParser.cpp
+++ b/ets2panda/parser/statementTSParser.cpp
@@ -372,6 +372,7 @@ ir::Statement *TSParser::ParseImportDeclaration([[maybe_unused]] StatementParsin
     ES2PANDA_ASSERT(source != nullptr);
     lexer::SourcePosition endLoc = source->End();
     auto *importDeclaration = AllocNode<ir::ImportDeclaration>(source, std::move(specifiers));
+    ES2PANDA_ASSERT(importDeclaration != nullptr);
     importDeclaration->SetRange({startLoc, endLoc});
 
     ConsumeSemicolon(importDeclaration);