diff --git a/ets2panda/parser/ASparser.cpp b/ets2panda/parser/ASparser.cpp
index f2567fef3d343350723a2e1b2eda79099eca4d4e..163d6631de23f176d3e6163e9e88f3523e48b686 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());
@@ -1739,7 +1741,8 @@ ir::Statement *ASParser::ParseImportDeclaration([[maybe_unused]] StatementParsin
     } else {
         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 9788c8d7af7f5e013f047bf08943aef018f006ce..75f5f6dafcf6e5c5b5694e66d96b09a7bc35728c 100644
--- a/ets2panda/parser/ETSparser.cpp
+++ b/ets2panda/parser/ETSparser.cpp
@@ -1025,6 +1025,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)) {
@@ -1117,6 +1118,7 @@ ir::Statement *ETSParser::CreateReExportDeclarationNode(ir::ETSImportDeclaration
     }
     auto reExport = AllocNode<ir::ETSReExportDeclaration>(reExportDeclaration, std::vector<std::string>(),
                                                           GetProgram()->AbsoluteName(), Allocator());
+    ES2PANDA_ASSERT(reExport != nullptr);
     reExport->AddModifier(modifiers);
     return reExport;
 }
@@ -1221,6 +1223,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);
@@ -1310,6 +1313,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());
         }
 
@@ -1603,6 +1607,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 {
@@ -1625,6 +1630,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;
         }
@@ -2319,6 +2325,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 d68219020581931ede3dc3c9c34aa8da648bc16e..0ae2994d4f86423f6952c1c7314b6b14c8c59b51 100644
--- a/ets2panda/parser/ETSparserClasses.cpp
+++ b/ets2panda/parser/ETSparserClasses.cpp
@@ -421,6 +421,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;
     }
@@ -596,6 +597,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);
@@ -634,6 +636,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;
@@ -841,13 +844,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;
@@ -864,23 +870,25 @@ 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);
     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;
@@ -1109,6 +1117,7 @@ ir::AstNode *ETSParser::ParseInterfaceField()
         return AllocBrokenExpression(Lexer()->GetToken().Start());
     }
 
+    ES2PANDA_ASSERT(name != nullptr);
     name->SetRange(Lexer()->GetToken().Loc());
     Lexer()->NextToken();
     bool optionalField = false;
@@ -1178,6 +1187,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();
     }
@@ -1226,8 +1236,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 d07eb0720854ac4c231c499b1cf588e204658bdc..707d44ad1b567490b390a61158a971ea58c2bbf9 100644
--- a/ets2panda/parser/ETSparserExpressions.cpp
+++ b/ets2panda/parser/ETSparserExpressions.cpp
@@ -41,11 +41,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);
         }
@@ -76,9 +76,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;
@@ -181,6 +183,7 @@ ir::Expression *ETSParser::ParseUnaryOrPrefixUpdateExpression(ExpressionParseFla
     }
 
     ir::Expression *returnExpr = CreateUnaryExpressionFromArgument(argument, operatorType, beginningChar);
+    ES2PANDA_ASSERT(returnExpr != nullptr);
     returnExpr->SetRange({start, argument->End()});
     return returnExpr;
 }
@@ -218,6 +221,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 d3ecaeedf6feb6d658e3a925c3dd6fc329b5c23e..9360e2431f3ea95a9f84847f95550fb0ba1a9081 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) {
diff --git a/ets2panda/parser/ETSparserTypes.cpp b/ets2panda/parser/ETSparserTypes.cpp
index 44e57121936078a6ff7035ea35959f100f5c46f4..918223fb9d846722469af75d9f39ca5ffa279813 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 596a70e086461c7b6ffc6648ae3bc186c78da65e..ebc744397b8558f2fa08ebd6d73e895d413db77d 100644
--- a/ets2panda/parser/expressionParser.cpp
+++ b/ets2panda/parser/expressionParser.cpp
@@ -348,6 +348,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;
@@ -2370,7 +2371,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;
@@ -2416,6 +2417,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;
@@ -2451,6 +2453,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 2b6e9ce4816286d4105e555eacad3119d6577124..ae8dd74781d50bb3b1465ff32ce5539263797beb 100644
--- a/ets2panda/parser/parserImpl.cpp
+++ b/ets2panda/parser/parserImpl.cpp
@@ -480,6 +480,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;
@@ -495,6 +496,7 @@ ir::ClassElement *ParserImpl::ParseClassProperty(ClassElementDescriptor *desc,
 
     if (desc->classMethod) {
         property = ParseClassMethod(desc, properties, propName, &propEnd);
+        ES2PANDA_ASSERT(property != nullptr);
         property->SetRange({desc->propStart, propEnd});
         return property;
     }
@@ -514,7 +516,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;
@@ -685,6 +687,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));
     }
 
@@ -710,6 +713,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 c311d81ec3c170237f0a2cf9d0b9b75b1e3eee7e..cb374f95f30f2c7070288955b7fe0eab03734e7d 100644
--- a/ets2panda/parser/statementParser.cpp
+++ b/ets2panda/parser/statementParser.cpp
@@ -525,9 +525,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();
@@ -580,6 +582,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);
@@ -662,9 +665,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;
         }
@@ -684,6 +689,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) {
@@ -1383,6 +1389,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);
     }
@@ -1398,6 +1405,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;
 }
@@ -2001,6 +2009,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);