diff --git a/ets2panda/parser/ASparser.cpp b/ets2panda/parser/ASparser.cpp
index 8fc21e2cbb1860b1571d0d1593d240736aa62718..9c5f9cb7cc2cc8e348fa6b4d01b2397884fc2441 100644
--- a/ets2panda/parser/ASparser.cpp
+++ b/ets2panda/parser/ASparser.cpp
@@ -95,6 +95,7 @@ ir::Decorator *ASParser::ParseDecorator()
 
     auto *expr = ParseLeftHandSideExpression();
     auto *decorator = AllocNode<ir::Decorator>(expr);
+    ES2PANDA_ASSERT(decorator != nullptr);
     decorator->SetRange({start, expr->End()});
     return decorator;
 }
@@ -124,6 +125,7 @@ ir::TSTypeAliasDeclaration *ASParser::ParseTypeAliasDeclaration()
     const util::StringView &ident = Lexer()->GetToken().Ident();
 
     auto *id = AllocNode<ir::Identifier>(ident, Allocator());
+    ES2PANDA_ASSERT(id != nullptr);
     id->SetRange(Lexer()->GetToken().Loc());
     Lexer()->NextToken();
 
@@ -343,6 +345,7 @@ std::tuple<ir::AnnotatedExpression *, bool> ASParser::ParsePatternElementToken(E
         }
         case lexer::TokenType::LITERAL_IDENT: {
             returnNode = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+            ES2PANDA_ASSERT(returnNode != nullptr);
             returnNode->SetRange(Lexer()->GetToken().Loc());
             Lexer()->NextToken();
 
@@ -430,6 +433,7 @@ ir::Expression *ASParser::ParsePropertyDefinition([[maybe_unused]] ExpressionPar
         key = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
     }
 
+    ES2PANDA_ASSERT(key != nullptr);
     key->SetRange(Lexer()->GetToken().Loc());
 
     Lexer()->NextToken();
@@ -446,6 +450,7 @@ ir::Expression *ASParser::ParsePropertyDefinition([[maybe_unused]] ExpressionPar
     }
 
     auto *property = AllocNode<ir::Property>(key, value);
+    ES2PANDA_ASSERT(property != nullptr);
     property->SetRange({key->Start(), value->End()});
     return property;
 }
@@ -570,6 +575,7 @@ ir::TypeNode *ASParser::ParseParenthesizedOrFunctionType(bool throwError)
 ir::TypeNode *ASParser::ParseTypeAnnotationLiteralIdentHelper(ir::TypeNode *type, TypeAnnotationParsingOptions *options)
 {
     auto *typeName = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(typeName != nullptr);
     typeName->SetRange(Lexer()->GetToken().Loc());
     type = AllocNode<ir::NamedType>(typeName, Allocator());
     type->SetRange(Lexer()->GetToken().Loc());
@@ -584,6 +590,7 @@ ir::TypeNode *ASParser::ParseTypeAnnotationLiteralIdentHelper(ir::TypeNode *type
         }
 
         typeName = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+        ES2PANDA_ASSERT(typeName != nullptr);
         typeName->SetRange(Lexer()->GetToken().Loc());
         auto *next = AllocNode<ir::NamedType>(typeName, Allocator());
         current->SetRange(Lexer()->GetToken().Loc());
@@ -646,6 +653,7 @@ ir::TypeNode *ASParser::ParseTypeAnnotationTokens(ir::TypeNode *type, bool throw
     }
 
     auto *typeName = AllocNode<ir::Identifier>(name, Allocator());
+    ES2PANDA_ASSERT(typeName != nullptr);
     typeName->SetRange(Lexer()->GetToken().Loc());
     type = AllocNode<ir::NamedType>(typeName, Allocator());
     type->SetRange(Lexer()->GetToken().Loc());
@@ -717,6 +725,7 @@ ir::TypeNode *ASParser::ParseTypeAnnotationTokenLeftSquareBracket(ir::TypeNode *
 
         util::StringView name = "Array";
         auto *typeName = AllocNode<ir::Identifier>(name, Allocator());
+        ES2PANDA_ASSERT(typeName != nullptr);
         typeName->SetRange(Lexer()->GetToken().Loc());
 
         ArenaVector<ir::TypeNode *> params(Allocator()->Adapter());
@@ -768,6 +777,7 @@ bool ASParser::ParsePotentialNonNullExpression(ir::Expression **returnExpression
     }
 
     *returnExpression = AllocNode<ir::TSNonNullExpression>(*returnExpression);
+    ES2PANDA_ASSERT(*returnExpression != nullptr);
     // NOLINTNEXTLINE(clang-analyzer-core.CallAndMessage)
     (*returnExpression)->SetRange({startLoc, Lexer()->GetToken().End()});
     Lexer()->NextToken();
@@ -815,6 +825,7 @@ bool ASParser::ParsePotentialGenericFunctionCall(ir::Expression *primaryExpr, ir
         lexer::SourcePosition endLoc = propertyNode->End();
 
         *returnExpression = AllocNode<ir::TaggedTemplateExpression>(*returnExpression, propertyNode, typeParams);
+        ES2PANDA_ASSERT(returnExpression != nullptr);
         // NOLINTNEXTLINE(clang-analyzer-core.CallAndMessage)
         (*returnExpression)->SetRange({startLoc, endLoc});
         return false;
@@ -846,6 +857,7 @@ ir::Expression *ASParser::ParsePotentialAsExpression(ir::Expression *primaryExpr
 ir::Identifier *ASParser::ParsePrimaryExpressionIdent([[maybe_unused]] ExpressionParseFlags flags)
 {
     auto *identNode = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(identNode != nullptr);
     identNode->SetRange(Lexer()->GetToken().Loc());
 
     Lexer()->NextToken();
@@ -866,6 +878,7 @@ bool ASParser::ValidateArrowFunctionRestParameter([[maybe_unused]] ir::SpreadEle
     return true;
 }
 
+// CC-OFFNXT(huge_method[C++], G.FUN.01-CPP) solid logic
 ArenaVector<ir::TSInterfaceHeritage *> ASParser::ParseInterfaceExtendsClause()
 {
     Lexer()->NextToken();  // eat extends keyword
@@ -877,6 +890,7 @@ ArenaVector<ir::TSInterfaceHeritage *> ASParser::ParseInterfaceExtendsClause()
     const lexer::SourcePosition &heritageStart = Lexer()->GetToken().Start();
     lexer::SourcePosition heritageEnd = Lexer()->GetToken().End();
     auto *extendsName = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(extendsName != nullptr);
     extendsName->SetRange(Lexer()->GetToken().Loc());
     auto *extendsClause = AllocNode<ir::NamedType>(extendsName, Allocator());
     extendsClause->SetRange(Lexer()->GetToken().Loc());
@@ -943,6 +957,7 @@ ir::TSIndexSignature *ASParser::ParseIndexSignature(const lexer::SourcePosition
     }
 
     auto *key = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(key != nullptr);
     key->SetRange(Lexer()->GetToken().Loc());
 
     Lexer()->NextToken();  // eat key
@@ -992,12 +1007,14 @@ std::tuple<ir::Expression *, bool> ASParser::ParseInterfacePropertyKey()
         case lexer::TokenType::LITERAL_IDENT: {
             const util::StringView &ident = Lexer()->GetToken().Ident();
             key = AllocNode<ir::Identifier>(ident, Allocator());
+            ES2PANDA_ASSERT(key != nullptr);
             key->SetRange(Lexer()->GetToken().Loc());
             break;
         }
         case lexer::TokenType::LITERAL_STRING: {
             const util::StringView &string = Lexer()->GetToken().String();
             key = AllocNode<ir::StringLiteral>(string);
+            ES2PANDA_ASSERT(key != nullptr);
             key->SetRange(Lexer()->GetToken().Loc());
             break;
         }
@@ -1008,6 +1025,7 @@ std::tuple<ir::Expression *, bool> ASParser::ParseInterfacePropertyKey()
                 key = AllocNode<ir::NumberLiteral>(Lexer()->GetToken().GetNumber());
             }
 
+            ES2PANDA_ASSERT(key != nullptr);
             key->SetRange(Lexer()->GetToken().Loc());
             break;
         }
@@ -1103,6 +1121,7 @@ ArenaVector<ir::TSClassImplements *> ASParser::ParseClassImplementClause()
         auto *implementsName = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
         implementsName->SetRange(Lexer()->GetToken().Loc());
         auto *implementsClause = AllocNode<ir::NamedType>(implementsName, Allocator());
+        ES2PANDA_ASSERT(implementsClause != nullptr);
         implementsClause->SetRange(Lexer()->GetToken().Loc());
         Lexer()->NextToken();
 
@@ -1281,6 +1300,7 @@ std::tuple<bool, bool, bool> ASParser::ParseComputedClassFieldOrIndexSignature(i
         }
 
         auto id = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+        ES2PANDA_ASSERT(id != nullptr);
         id->SetRange(Lexer()->GetToken().Loc());
 
         Lexer()->NextToken();  // eat param
@@ -1346,6 +1366,7 @@ std::tuple<bool, ir::BlockStatement *, lexer::SourcePosition, bool> ASParser::Pa
         ThrowSyntaxError("An implementation cannot be declared in ambient contexts.");
     } else {
         body = ParseBlockStatement();
+        ES2PANDA_ASSERT(body != nullptr);
         endLoc = body->End();
     }
 
@@ -1358,6 +1379,7 @@ ir::AstNode *ASParser::ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *s
     Lexer()->NextToken();  // eat local name
 
     auto *specifier = AllocNode<ir::ImportDefaultSpecifier>(local);
+    ES2PANDA_ASSERT(specifier != nullptr);
     specifier->SetRange(specifier->Local()->Range());
     specifiers->push_back(specifier);
 
@@ -1503,6 +1525,7 @@ ir::Statement *ASParser::ParseConstStatement(StatementParsingFlags flags)
     }
 
     auto *variableDecl = ParseVariableDeclaration(VariableParsingFlags::CONST | VariableParsingFlags::NO_SKIP_VAR_KIND);
+    ES2PANDA_ASSERT(variableDecl != nullptr);
     variableDecl->SetStart(constVarStar);
     ConsumeSemicolon(variableDecl);
 
@@ -1519,6 +1542,7 @@ ir::AnnotatedExpression *ASParser::ParseVariableDeclaratorKey(VariableParsingFla
 
     const util::StringView &identStr = Lexer()->GetToken().Ident();
     auto init = AllocNode<ir::Identifier>(identStr, Allocator());
+    ES2PANDA_ASSERT(init != nullptr);
     init->SetRange(Lexer()->GetToken().Loc());
     Lexer()->NextToken();
 
@@ -1592,6 +1616,7 @@ ir::ExportDefaultDeclaration *ASParser::ParseExportDefaultDeclaration(const lexe
 
     lexer::SourcePosition endLoc = declNode->End();
     auto *exportDeclaration = AllocNode<ir::ExportDefaultDeclaration>(declNode, isExportEquals);
+    ES2PANDA_ASSERT(exportDeclaration != nullptr);
     exportDeclaration->SetRange({startLoc, endLoc});
 
     if (eatSemicolon) {
@@ -1666,6 +1691,7 @@ ir::Statement *ASParser::ParseNamedExportDeclaration(const lexer::SourcePosition
 
     ArenaVector<ir::ExportSpecifier *> specifiers(Allocator()->Adapter());
     auto *exportDeclaration = AllocNode<ir::ExportNamedDeclaration>(Allocator(), decl, std::move(specifiers));
+    ES2PANDA_ASSERT(exportDeclaration != nullptr);
     exportDeclaration->SetRange({startLoc, decl->End()});
 
     return exportDeclaration;
@@ -1712,6 +1738,7 @@ ir::Statement *ASParser::ParseImportDeclaration([[maybe_unused]] StatementParsin
 
     lexer::SourcePosition endLoc = source->End();
     auto *importDeclaration = AllocNode<ir::ImportDeclaration>(source, std::move(specifiers));
+    ES2PANDA_ASSERT(importDeclaration != nullptr);
     importDeclaration->SetRange({startLoc, endLoc});
 
     ConsumeSemicolon(importDeclaration);
diff --git a/ets2panda/parser/ETSFormattedParser.cpp b/ets2panda/parser/ETSFormattedParser.cpp
index f5bb28b326c8842ce9440128323fe9f1ce3f4ad6..328ed93d49c4ae106682ad029a3766856958f676 100644
--- a/ets2panda/parser/ETSFormattedParser.cpp
+++ b/ets2panda/parser/ETSFormattedParser.cpp
@@ -301,6 +301,7 @@ ir::Statement *ETSParser::CreateStatement(std::string_view const sourceCode)
     }
 
     auto *const blockStmt = AllocNode<ir::BlockStatement>(Allocator(), std::move(statements));
+    ES2PANDA_ASSERT(blockStmt != nullptr);
     blockStmt->SetRange({startLoc, lexer->GetToken().End()});
 
     for (auto *statement : blockStmt->Statements()) {
@@ -378,6 +379,7 @@ ir::AstNode *ETSParser::CreateFormattedClassFieldDefinition(std::string_view sou
     insertingNodes_.swap(insertingNodes);
 
     auto *const property = CreateClassElement(sourceCode, DUMMY_ARRAY, ir::ClassDefinitionModifiers::NONE);
+    ES2PANDA_ASSERT(property != nullptr);
     if (!property->IsTSInterfaceBody() || property->AsTSInterfaceBody()->Body().empty()) {
         LogError(diagnostic::INVALID_CLASS_FIELD, {}, Lexer()->GetToken().Start());
         ES2PANDA_UNREACHABLE();
@@ -394,6 +396,7 @@ ir::AstNode *ETSParser::CreateFormattedClassMethodDefinition(std::string_view so
     insertingNodes_.swap(insertingNodes);
 
     auto *const property = CreateClassElement(sourceCode, DUMMY_ARRAY, ir::ClassDefinitionModifiers::NONE);
+    ES2PANDA_ASSERT(property != nullptr);
     if (!property->IsMethodDefinition()) {
         LogError(diagnostic::INVALID_CLASS_METHOD, {}, Lexer()->GetToken().Start());
         ES2PANDA_UNREACHABLE();
@@ -512,6 +515,7 @@ ir::MethodDefinition *ETSParser::CreateConstructorDefinition(ir::ModifierFlags m
     Lexer()->NextToken();
 
     auto *const methodDefinition = ParseClassMethodDefinition(memberName, modifiers, true);
+    ES2PANDA_ASSERT(methodDefinition != nullptr);
     methodDefinition->SetStart(startLoc);
 
     return methodDefinition;
diff --git a/ets2panda/parser/ETSparser.cpp b/ets2panda/parser/ETSparser.cpp
index 7b9c2399d8fdb95571101497a0998621fbac49e4..c522d52c8b32131e0292065585ecbf4af46ee460 100644
--- a/ets2panda/parser/ETSparser.cpp
+++ b/ets2panda/parser/ETSparser.cpp
@@ -182,6 +182,7 @@ ir::ETSModule *ETSParser::ParseETSGlobalScript(lexer::SourcePosition startLoc, A
     auto ident = AllocNode<ir::Identifier>(compiler::Signatures::ETS_GLOBAL, Allocator());
     auto *etsModule =
         AllocNode<ir::ETSModule>(Allocator(), std::move(statements), ident, ir::ModuleFlag::ETSSCRIPT, GetProgram());
+    ES2PANDA_ASSERT(etsModule != nullptr);
     etsModule->SetRange({startLoc, Lexer()->GetToken().End()});
     return etsModule;
 }
@@ -203,6 +204,7 @@ ir::ETSModule *ETSParser::ParseImportsAndReExportOnly(lexer::SourcePosition star
     auto ident = AllocNode<ir::Identifier>(compiler::Signatures::ETS_GLOBAL, Allocator());
     auto *etsModule =
         AllocNode<ir::ETSModule>(Allocator(), std::move(statements), ident, ir::ModuleFlag::ETSSCRIPT, GetProgram());
+    ES2PANDA_ASSERT(etsModule != nullptr);
     etsModule->SetRange({startLoc, Lexer()->GetToken().End()});
     return etsModule;
 }
@@ -306,6 +308,7 @@ void ETSParser::ParseParseListElement(const util::ImportPathManager::ParseInfo &
     auto src = importData.HasSpecifiedDeclPath() ? importData.declPath : importData.resolvedSource;
     SourceFile sf {src, extSrc->View().Utf8(), importData.resolvedSource, false, importData.HasSpecifiedDeclPath()};
     parser::Program *newProg = ParseSource(sf);
+     ES2PANDA_ASSERT(newProg != nullptr);
     if (!importData.IsImplicitPackageImported() || newProg->IsPackage()) {
         AddDirectImportsToDirectExternalSources(directImportsFromMainSource, newProg);
         // don't insert the separate modules into the programs, when we collect implicit package imports
@@ -458,6 +461,7 @@ parser::Program *ETSParser::ParseSource(const SourceFile &sourceFile)
 {
     importPathManager_->MarkAsParsed(sourceFile.filePath);
     auto *program = Allocator()->New<parser::Program>(Allocator(), GetProgram()->VarBinder());
+    ES2PANDA_ASSERT(program != nullptr);
     auto esp = ExternalSourceParser(this, program);
     auto lexer = InitLexer(sourceFile);
 
@@ -558,6 +562,7 @@ ir::ScriptFunction *ETSParser::ParseFunction(ParserStatus newStatus)
     auto *funcNode = AllocNode<ir::ScriptFunction>(
         Allocator(), ir::ScriptFunction::ScriptFunctionData {body, std::move(signature), funcFlags, mFlags,
                                                              GetContext().GetLanguage()});
+    ES2PANDA_ASSERT(funcNode != nullptr);
     funcNode->SetRange({startLoc, endLoc});
     // clang-format on
 
@@ -575,6 +580,7 @@ std::tuple<bool, ir::BlockStatement *, lexer::SourcePosition, bool> ETSParser::P
     }
 
     ir::BlockStatement *body = ParseBlockStatement();
+    ES2PANDA_ASSERT(body != nullptr);
 
     return {true, body, body->End(), false};
 }
@@ -629,6 +635,7 @@ ir::AstNode *ETSParser::ParseInnerConstructorDeclaration(ir::ModifierFlags membe
                                      : AllocNode<ir::Identifier>(constructorToken.Ident(), Allocator());
 
     auto *classMethod = ParseClassMethodDefinition(memberName, memberModifiers, isDefault);
+    ES2PANDA_ASSERT(classMethod != nullptr);
     classMethod->SetStart(startLoc);
 
     return classMethod;
@@ -638,6 +645,7 @@ ir::Identifier *ETSParser::CreateInvokeIdentifier()
 {
     util::StringView tokenName = util::StringView {compiler::Signatures::STATIC_INVOKE_METHOD};
     auto ident = AllocNode<ir::Identifier>(tokenName, Allocator());
+    ES2PANDA_ASSERT(ident != nullptr);
     ident->SetRange({Lexer()->GetToken().Start(), Lexer()->GetToken().End()});
     return ident;
 }
@@ -676,6 +684,7 @@ ir::AstNode *ETSParser::ParseInnerRest(const ArenaVector<ir::AstNode *> &propert
 
     auto parseClassMethod = [&memberModifiers, &startLoc, isDefault, this](ir::Identifier *methodName) {
         auto *classMethod = ParseClassMethodDefinition(methodName, memberModifiers, isDefault);
+        ES2PANDA_ASSERT(classMethod != nullptr);
         classMethod->SetStart(startLoc);
         return classMethod;
     };
@@ -708,6 +717,7 @@ ir::AstNode *ETSParser::ParseInnerRest(const ArenaVector<ir::AstNode *> &propert
 
     ArenaVector<ir::AstNode *> fieldDeclarations(Allocator()->Adapter());
     auto *placeholder = AllocNode<ir::TSInterfaceBody>(std::move(fieldDeclarations));
+    ES2PANDA_ASSERT(placeholder != nullptr);
     ParseClassFieldDefinition(memberName, memberModifiers, placeholder->BodyPtr(), isDefault);
     return placeholder;
 }
@@ -804,6 +814,7 @@ ir::TSTypeAliasDeclaration *ETSParser::ParseTypeAliasDeclaration()
     ir::Identifier *id = ExpectIdentifier();
 
     auto *typeAliasDecl = AllocNode<ir::TSTypeAliasDeclaration>(Allocator(), id);
+    ES2PANDA_ASSERT(typeAliasDecl != nullptr);
 
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
         auto options =
@@ -1019,6 +1030,7 @@ ir::TypeNode *ETSParser::ParseTypeReference(TypeAnnotationParsingOptions *option
     }
 
     auto *typeReference = AllocNode<ir::ETSTypeReference>(typeRefPart, Allocator());
+    ES2PANDA_ASSERT(typeReference != nullptr);
     typeReference->SetRange({startPos, Lexer()->GetToken().End()});
     return typeReference;
 }
@@ -1056,6 +1068,7 @@ ir::TypeNode *ETSParser::ParseLiteralIdent(TypeAnnotationParsingOptions *options
     if (Lexer()->TryEatTokenFromKeywordType(lexer::TokenType::KEYW_KEYOF)) {
         auto keyofOptions = *options | TypeAnnotationParsingOptions::REPORT_ERROR;
         auto *typeAnnotation = ParseTypeAnnotationNoPreferParam(&keyofOptions);
+         ES2PANDA_ASSERT(typeAnnotation != nullptr);
         typeAnnotation = AllocNode<ir::ETSKeyofType>(typeAnnotation, Allocator());
         typeAnnotation->SetRange(Lexer()->GetToken().Loc());
         return typeAnnotation;
@@ -1125,6 +1138,7 @@ ir::Statement *ETSParser::ParseExport(lexer::SourcePosition startLoc, ir::Modifi
 
             auto result = AllocNode<ir::ExportNamedDeclaration>(Allocator(), static_cast<ir::StringLiteral *>(nullptr),
                                                                 std::move(exports));
+            ES2PANDA_ASSERT(result != nullptr);
             result->AddModifier(modifiers);
             return result;
         }
@@ -1163,6 +1177,7 @@ ir::ETSPackageDeclaration *ETSParser::ParsePackageDeclaration()
 
     ir::Expression *name = ParseQualifiedName();
     auto *packageDeclaration = AllocNode<ir::ETSPackageDeclaration>(name);
+    ES2PANDA_ASSERT(packageDeclaration != nullptr);
     packageDeclaration->SetRange({startLoc, Lexer()->GetToken().End()});
 
     ConsumeSemicolon(packageDeclaration);
@@ -1190,6 +1205,7 @@ ir::ETSImportDeclaration *ETSParser::ParseImportPathBuildImport(ArenaVector<ir::
         errorLiteral->SetRange(Lexer()->GetToken().Loc());
         auto *const importDeclaration = AllocNode<ir::ETSImportDeclaration>(
             errorLiteral, util::ImportPathManager::ImportMetadata {}, std::move(specifiers), importKind);
+        ES2PANDA_ASSERT(importDeclaration != nullptr);
         importDeclaration->SetRange({startLoc, errorLiteral->End()});
         return importDeclaration;
     }
@@ -1205,6 +1221,7 @@ ir::ETSImportDeclaration *ETSParser::ParseImportPathBuildImport(ArenaVector<ir::
     auto *const importDeclaration =
         BuildImportDeclaration(importKind, std::move(specifiers), importPathStringLiteral,
                                const_cast<parser::Program *>(GetContext().GetProgram()), importFlags);
+    ES2PANDA_ASSERT(importDeclaration != nullptr);
     importDeclaration->SetRange({startLoc, importPathStringLiteral->End()});
     if (Lexer()->GetToken().Ident().Is("assert")) {
         LogError(diagnostic::ERROR_ARKTS_NO_IMPORT_ASSERTIONS);
@@ -1280,6 +1297,7 @@ ArenaVector<ir::ETSImportDeclaration *> ETSParser::ParseImportDeclarations()
             Lexer()->Rewind(pos);
             auto *const importDeclDefault =
                 ParseImportPathBuildImport(std::move(defaultSpecifiers), true, startLoc, importKind);
+            ES2PANDA_ASSERT(importDeclDefault != nullptr);
             if (!importDeclDefault->IsBrokenStatement()) {
                 util::Helpers::CheckDefaultImport(statements);
                 statements.push_back(importDeclDefault->AsETSImportDeclaration());
@@ -1301,6 +1319,7 @@ ir::ExportNamedDeclaration *ETSParser::ParseSingleExportForAnonymousConst(ir::Mo
     ir::Expression *constantExpression = ParseExpression();
 
     auto *exported = AllocNode<ir::Identifier>(compiler::Signatures::EXPORT_DEFAULT_CONSTANT_ANONYMOUSLY, Allocator());
+    ES2PANDA_ASSERT(exported != nullptr);
     exported->SetRange(Lexer()->GetToken().Loc());
 
     ArenaVector<ir::ExportSpecifier *> exports(Allocator()->Adapter());
@@ -1311,6 +1330,7 @@ ir::ExportNamedDeclaration *ETSParser::ParseSingleExportForAnonymousConst(ir::Mo
 
     auto result = AllocNode<ir::ExportNamedDeclaration>(Allocator(), static_cast<ir::StringLiteral *>(nullptr),
                                                         std::move(exports));
+    ES2PANDA_ASSERT(result != nullptr);
     result->AddModifier(modifiers);
     ConsumeSemicolon(result);
 
@@ -1329,6 +1349,7 @@ ir::ExportNamedDeclaration *ETSParser::ParseSingleExport(ir::ModifierFlags modif
         return nullptr;
     }
     auto *exported = AllocNode<ir::Identifier>(token.Ident(), Allocator());
+    ES2PANDA_ASSERT(exported != nullptr);
     exported->SetRange(Lexer()->GetToken().Loc());
 
     Lexer()->NextToken();  // eat exported variable name
@@ -1338,6 +1359,7 @@ ir::ExportNamedDeclaration *ETSParser::ParseSingleExport(ir::ModifierFlags modif
     exports.emplace_back(AllocNode<ir::ExportSpecifier>(exported, ParseNamedExport(&token)));
     auto result = AllocNode<ir::ExportNamedDeclaration>(Allocator(), static_cast<ir::StringLiteral *>(nullptr),
                                                         std::move(exports));
+    ES2PANDA_ASSERT(result != nullptr);
     result->AddModifier(modifiers);
     ConsumeSemicolon(result);
 
@@ -1378,9 +1400,11 @@ void ETSParser::ParseNamedSpecifiesDefaultImport(ArenaVector<ir::ImportDefaultSp
                                                  const std::string &fileName)
 {
     auto *imported = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(imported != nullptr);
     imported->SetRange(Lexer()->GetToken().Loc());
     Lexer()->NextToken();
     auto *specifier = AllocNode<ir::ImportDefaultSpecifier>(imported);
+    ES2PANDA_ASSERT(specifier != nullptr);
     specifier->SetRange({imported->Start(), imported->End()});
 
     util::Helpers::CheckDefaultImportedName(*resultDefault, specifier, fileName);
@@ -1396,8 +1420,10 @@ bool ETSParser::ParseNamedSpecifiesImport(ArenaVector<ir::ImportSpecifier *> *re
         ir::Expression *constantExpression = ParseUnaryOrPrefixUpdateExpression();
         auto *exported =
             AllocNode<ir::Identifier>(compiler::Signatures::EXPORT_DEFAULT_CONSTANT_ANONYMOUSLY, Allocator());
+        ES2PANDA_ASSERT(exported != nullptr);
         exported->SetRange(Lexer()->GetToken().Loc());
         auto *exportedAnonyConst = AllocNode<ir::ExportSpecifier>(exported, exported->Clone(Allocator(), nullptr));
+        ES2PANDA_ASSERT(exportedAnonyConst != nullptr);
         exportedAnonyConst->SetConstantExpression(constantExpression);
         exportedAnonyConst->SetDefault();
         resultExportDefault->emplace_back(exportedAnonyConst);
@@ -1424,6 +1450,7 @@ bool ETSParser::ParseNamedSpecifiesImport(ArenaVector<ir::ImportSpecifier *> *re
     }
 
     auto *specifier = AllocNode<ir::ImportSpecifier>(imported, local);
+    ES2PANDA_ASSERT(specifier != nullptr);
     specifier->SetRange({imported->Start(), local->End()});
 
     util::Helpers::CheckImportedName(*result, specifier, fileName);
@@ -1484,6 +1511,7 @@ void ETSParser::ParseNameSpaceSpecifier(ArenaVector<ir::AstNode *> *specifiers,
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA ||
         Lexer()->GetToken().KeywordType() == lexer::TokenType::KEYW_FROM) {
         auto *specifier = AllocNode<ir::ImportNamespaceSpecifier>(local);
+        ES2PANDA_ASSERT(specifier != nullptr);
         specifier->SetRange({namespaceStart, Lexer()->GetToken().End()});
         specifiers->push_back(specifier);
         return;
@@ -1493,6 +1521,7 @@ void ETSParser::ParseNameSpaceSpecifier(ArenaVector<ir::AstNode *> *specifiers,
     local = ParseNamedImport(&Lexer()->GetToken());
 
     auto *specifier = AllocNode<ir::ImportNamespaceSpecifier>(local);
+    ES2PANDA_ASSERT(specifier != nullptr);
     specifier->SetRange({namespaceStart, Lexer()->GetToken().End()});
     specifiers->push_back(specifier);
 
@@ -1506,6 +1535,7 @@ ir::AstNode *ETSParser::ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *
     }
 
     auto *imported = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(imported != nullptr);
     imported->SetRange(Lexer()->GetToken().Loc());
     Lexer()->NextToken();  // Eat import specifier.
 
@@ -1570,6 +1600,7 @@ ir::AnnotatedExpression *ETSParser::GetAnnotatedExpressionFromParam()
             }
 
             auto *const restIdent = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+            ES2PANDA_ASSERT(restIdent != nullptr);
             restIdent->SetRange(Lexer()->GetToken().Loc());
 
             parameter = AllocNode<ir::SpreadElement>(ir::AstNodeType::REST_ELEMENT, Allocator(), restIdent);
@@ -1688,6 +1719,7 @@ ir::Expression *ETSParser::ParseFunctionParameter()
     if (Lexer()->TryEatTokenType(lexer::TokenType::PUNCTUATOR_COLON)) {
         TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::REPORT_ERROR;
         ir::TypeNode *typeAnnotation = ParseTypeAnnotation(&options);
+        ES2PANDA_ASSERT(typeAnnotation != nullptr);
         if (typeAnnotation->IsBrokenTypeNode()) {
             // the compiler can't process "declare class A { static foo(x: {key: string}[]):void; }" correctly
             // and resolve "{key: string}" as function body, so skip invalid types
@@ -1706,12 +1738,14 @@ ir::Expression *ETSParser::ParseFunctionParameter()
 ir::Expression *ETSParser::CreateParameterThis(ir::TypeNode *typeAnnotation)
 {
     auto *paramIdent = AllocNode<ir::Identifier>(varbinder::TypedBinder::MANDATORY_PARAM_THIS, Allocator());
+    ES2PANDA_ASSERT(paramIdent != nullptr);
     paramIdent->SetRange(Lexer()->GetToken().Loc());
 
     typeAnnotation->SetParent(paramIdent);
     paramIdent->SetTsTypeAnnotation(typeAnnotation);
 
     auto *paramExpression = AllocNode<ir::ETSParameterExpression>(paramIdent, false, Allocator());
+    ES2PANDA_ASSERT(paramExpression != nullptr);
     paramExpression->SetRange({paramIdent->Start(), paramIdent->End()});
 
     return paramExpression;
@@ -1720,6 +1754,7 @@ ir::Expression *ETSParser::CreateParameterThis(ir::TypeNode *typeAnnotation)
 ir::AnnotatedExpression *ETSParser::ParseVariableDeclaratorKey([[maybe_unused]] VariableParsingFlags flags)
 {
     ir::Identifier *init = ExpectIdentifier();
+    ES2PANDA_ASSERT(init != nullptr);
     ir::TypeNode *typeAnnotation = nullptr;
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_QUESTION_MARK) {
         if ((flags & VariableParsingFlags::FOR_OF) != 0U) {
@@ -1817,6 +1852,7 @@ void ETSParser::ParseCatchParamTypeAnnotation([[maybe_unused]] ir::AnnotatedExpr
     if (Lexer()->TryEatTokenType(lexer::TokenType::PUNCTUATOR_COLON)) {
         TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::REPORT_ERROR;
         if (auto *typeAnnotation = ParseTypeAnnotation(&options); typeAnnotation != nullptr) {
+            ES2PANDA_ASSERT(param != nullptr);
             typeAnnotation->SetParent(param);
             param->SetTsTypeAnnotation(typeAnnotation);
         }
@@ -1875,6 +1911,7 @@ ir::Expression *ETSParser::ParseExpressionOrTypeAnnotation(lexer::TokenType type
 
         if (Lexer()->GetToken().Type() == lexer::TokenType::LITERAL_NULL) {
             auto *typeAnnotation = AllocNode<ir::NullLiteral>();
+            ES2PANDA_ASSERT(typeAnnotation != nullptr);
             typeAnnotation->SetRange(Lexer()->GetToken().Loc());
             Lexer()->NextToken();
 
@@ -2022,6 +2059,7 @@ ir::AstNode *ETSParser::ParseAmbientSignature(const lexer::SourcePosition &start
 
     auto dummyNode = AllocNode<ir::DummyNode>(compiler::Signatures::AMBIENT_INDEXER, indexName, returnType,
                                               ir::DummyNodeFlag::INDEXER);
+    ES2PANDA_ASSERT(dummyNode != nullptr);
     dummyNode->SetRange({startPos, Lexer()->GetToken().End()});
     Lexer()->NextToken();  // eat return type
     return dummyNode;
@@ -2075,6 +2113,7 @@ ir::TSTypeParameter *ETSParser::ParseTypeParameter([[maybe_unused]] TypeAnnotati
     auto *typeParam =
         AllocNode<ir::TSTypeParameter>(paramIdent, constraint, defaultType, varianceModifier, Allocator());
 
+    ES2PANDA_ASSERT(typeParam != nullptr);
     ApplyAnnotationsToNode(typeParam, std::move(annotations), saveLoc);
     typeParam->SetRange({startLoc, Lexer()->GetToken().End()});
     return typeParam;
@@ -2249,6 +2288,7 @@ ir::FunctionDeclaration *ETSParser::ParseFunctionDeclaration(bool canBeAnonymous
 
     ir::ScriptFunction *func =
         ParseFunction(newStatus | ParserStatus::FUNCTION_DECLARATION | ParserStatus::ALLOW_RECEIVER);
+    ES2PANDA_ASSERT(func != nullptr);
     if (funcIdentNode != nullptr) {  // Error processing.
         func->SetIdent(funcIdentNode);
     }
@@ -2277,10 +2317,12 @@ ir::FunctionDeclaration *ETSParser::ParseAccessorWithReceiver(ir::ModifierFlags
                      ParserStatus::EXTENSION_ACCESSOR;
 
     ir::Identifier *funcIdentNode = ExpectIdentifier();
+    ES2PANDA_ASSERT(funcIdentNode != nullptr);
     CheckRestrictedBinding(funcIdentNode->Name(), funcIdentNode->Start());
 
     ir::ScriptFunction *func =
         isGetter ? ParseFunction(newStatus | ParserStatus::NEED_RETURN_TYPE) : ParseFunction(newStatus);
+    ES2PANDA_ASSERT(func != nullptr);
     size_t paramCount = func->Params().size();
     size_t getterValidParamCount = 1;
     size_t setterValidParamCount = 2;
diff --git a/ets2panda/parser/ETSparserAnnotations.cpp b/ets2panda/parser/ETSparserAnnotations.cpp
index 1f37cf46053fa86a9d59f233bf34ad0acc66b473..f5f9d5c3a9b1564dad8cb770431519e75be42a20 100644
--- a/ets2panda/parser/ETSparserAnnotations.cpp
+++ b/ets2panda/parser/ETSparserAnnotations.cpp
@@ -60,6 +60,7 @@ ir::Expression *ETSParser::ParseAnnotationName()
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD_PERIOD_PERIOD) {
         Lexer()->Rewind(save);
         expr = ExpectIdentifier();
+        ES2PANDA_ASSERT(expr != nullptr);
         setAnnotation(expr->AsIdentifier());
         return expr;
     }
@@ -67,9 +68,11 @@ ir::Expression *ETSParser::ParseAnnotationName()
     if (Lexer()->Lookahead() == '.') {
         auto opt = TypeAnnotationParsingOptions::NO_OPTS;
         expr = ParseTypeReference(&opt);
+        ES2PANDA_ASSERT(expr != nullptr);
         setAnnotation(expr->AsETSTypeReference()->Part()->GetIdent());
     } else {
         expr = ExpectIdentifier();
+        ES2PANDA_ASSERT(expr != nullptr);
         setAnnotation(expr->AsIdentifier());
     }
 
@@ -94,6 +97,7 @@ ir::AnnotationDeclaration *ETSParser::ParseAnnotationDeclaration(ir::ModifierFla
     lexer::SourcePosition endLoc = Lexer()->GetToken().End();
 
     auto *annotationDecl = AllocNode<ir::AnnotationDeclaration>(expr, std::move(properties), Allocator());
+    ES2PANDA_ASSERT(annotationDecl != nullptr);
     annotationDecl->SetRange({startLoc, endLoc});
     annotationDecl->AddModifier(flags);
     return annotationDecl;
@@ -133,7 +137,9 @@ ArenaVector<ir::AstNode *> ETSParser::ParseAnnotationProperties(ir::ModifierFlag
             //  Probably we can seek for identifier till the enclosing right brace (staring after the next comma?)
             //  if the simplest case failed.
             auto const pos = Lexer()->Save();
-            if (auto *fieldName1 = ExpectIdentifier(); fieldName1->IsErrorPlaceHolder()) {
+            auto *fieldName1 = ExpectIdentifier();
+            ES2PANDA_ASSERT(fieldName1 != nullptr);
+            if (fieldName1->IsErrorPlaceHolder()) {
                 Lexer()->Rewind(pos);
             } else {
                 fieldName = fieldName1;
@@ -216,6 +222,7 @@ ir::AstNode *ETSParser::ParseAnnotationProperty(ir::Identifier *fieldName, ir::M
     memberModifiers |= ir::ModifierFlags::ABSTRACT;
     auto *field =
         AllocNode<ir::ClassProperty>(fieldName, initializer, typeAnnotation, memberModifiers, Allocator(), false);
+    ES2PANDA_ASSERT(field != nullptr);
     field->SetRange({fieldName->Start(), initializer != nullptr ? initializer->End() : endLoc});
     return field;
 }
@@ -287,9 +294,12 @@ void ETSParser::ApplyAnnotationsToSpecificNodeType(ir::AstNode *node, ArenaVecto
                                                    lexer::SourcePosition pos)
 {
     switch (node->Type()) {
-        case ir::AstNodeType::METHOD_DEFINITION:
-            node->AsMethodDefinition()->Function()->SetAnnotations(std::move(annotations));
+        case ir::AstNodeType::METHOD_DEFINITION: {
+            auto *func = node->AsMethodDefinition()->Function();
+            ES2PANDA_ASSERT(func != nullptr);
+            func->SetAnnotations(std::move(annotations));
             break;
+        }
         case ir::AstNodeType::CLASS_DECLARATION:
             node->AsClassDeclaration()->Definition()->SetAnnotations(std::move(annotations));
             break;
@@ -357,6 +367,7 @@ void ETSParser::ApplyAnnotationsToSpecificNodeType(ir::AstNode *node, ArenaVecto
 
 static lexer::SourcePosition GetExpressionEndLoc(ir::Expression *expr)
 {
+    ES2PANDA_ASSERT(expr != nullptr);
     if (expr->IsIdentifier()) {
         return expr->AsIdentifier()->End();
     }
@@ -398,6 +409,7 @@ ir::AnnotationUsage *ETSParser::ParseAnnotationUsage()
     }
 
     auto *annotationUsage = AllocNode<ir::AnnotationUsage>(expr, std::move(properties));
+    ES2PANDA_ASSERT(annotationUsage != nullptr);
     annotationUsage->AddModifier(flags);
     annotationUsage->SetRange({startLoc, Lexer()->GetToken().End()});
     return annotationUsage;
diff --git a/ets2panda/parser/ETSparserClasses.cpp b/ets2panda/parser/ETSparserClasses.cpp
index 513242b3e4afd2f69dd0838b4d73dc46d2d34543..f04329462208f95a3abacd9fbb7c089f8249d05c 100644
--- a/ets2panda/parser/ETSparserClasses.cpp
+++ b/ets2panda/parser/ETSparserClasses.cpp
@@ -514,6 +514,7 @@ void ETSParser::ParseClassFieldDefinition(ir::Identifier *fieldName, ir::Modifie
     ValidateFieldModifiers(modifiers, optionalField, initializer, start);
 
     auto *field = AllocNode<ir::ClassProperty>(fieldName, initializer, typeAnnotation, modifiers, Allocator(), false);
+    ES2PANDA_ASSERT(field != nullptr);
     field->SetDefaultAccessModifier(isDefault);
     if (optionalField) {
         field->AddModifier(ir::ModifierFlags::OPTIONAL);
@@ -587,8 +588,10 @@ ir::MethodDefinition *ETSParser::ParseClassMethodDefinition(ir::Identifier *meth
     }
 
     ir::ScriptFunction *func = ParseFunction(newStatus);
+    ES2PANDA_ASSERT(func != nullptr);
     func->SetIdent(methodName);
     auto *funcExpr = AllocNode<ir::FunctionExpression>(func);
+    ES2PANDA_ASSERT(funcExpr != nullptr);
     funcExpr->SetRange(func->Range());
     func->AddModifier(modifiers);
 
@@ -609,11 +612,13 @@ ir::MethodDefinition *ETSParser::ParseClassMethod(ClassElementDescriptor *desc,
     }
 
     ir::ScriptFunction *func = ParseFunction(desc->newStatus);
+    ES2PANDA_ASSERT(func != nullptr);
     if (propName->IsIdentifier()) {
         func->SetIdent(propName->AsIdentifier()->Clone(Allocator(), nullptr));
     }
 
     auto *funcExpr = AllocNode<ir::FunctionExpression>(func);
+    ES2PANDA_ASSERT(funcExpr != nullptr);
     funcExpr->SetRange(func->Range());
 
     if (desc->methodKind == ir::MethodDefinitionKind::SET) {
@@ -763,7 +768,9 @@ void *ETSParser::ApplyAnnotationsToClassElement(ir::AstNode *property, ArenaVect
         for (auto *node : property->AsTSInterfaceBody()->Body()) {
             ArenaVector<ir::AnnotationUsage *> cloneAnnotations(Allocator()->Adapter());
             for (auto *annotationUsage : annotations) {
-                cloneAnnotations.push_back(annotationUsage->Clone(Allocator(), node)->AsAnnotationUsage());
+                auto cloneAnnotationUsage = annotationUsage->Clone(Allocator(), node);
+                ES2PANDA_ASSERT(cloneAnnotationUsage != nullptr);
+                cloneAnnotations.push_back(cloneAnnotationUsage->AsAnnotationUsage());
             }
             ApplyAnnotationsToNode(node, std::move(cloneAnnotations), pos);
         }
@@ -818,6 +825,7 @@ ir::MethodDefinition *ETSParser::ParseClassGetterSetterMethod(const ArenaVector<
                                                                                       : ir::MethodDefinitionKind::SET;
     Lexer()->NextToken();  // eat get/set
     auto *methodName = ExpectIdentifier();
+    ES2PANDA_ASSERT(methodName != nullptr);
     if (desc.methodKind == ir::MethodDefinitionKind::GET) {
         methodName->SetAccessor();
     } else {
@@ -854,16 +862,18 @@ ir::MethodDefinition *ETSParser::ParseInterfaceGetterSetterMethod(const ir::Modi
         return nullptr;
     }
     method->AddModifier(ir::ModifierFlags::PUBLIC);
+    auto id = method->Id();
+    ES2PANDA_ASSERT(id != nullptr);
     if (methodKind == ir::MethodDefinitionKind::GET) {
-        method->Id()->SetAccessor();
+        id->SetAccessor();
         method->Function()->AddFlag(ir::ScriptFunctionFlags::GETTER);
     } else {
-        method->Id()->SetMutator();
+        id->SetMutator();
         method->Function()->AddFlag(ir::ScriptFunctionFlags::SETTER);
     }
     method->AddModifier(ir::ModifierFlags::PUBLIC);
 
-    method->Function()->SetIdent(method->Id()->Clone(Allocator(), nullptr));
+    method->Function()->SetIdent(id->Clone(Allocator(), nullptr));
     method->Function()->AddModifier(method->Modifiers());
 
     bool hasReturn = method->Function()->ReturnTypeAnnotation() != nullptr;
@@ -893,6 +903,7 @@ ir::TSInterfaceDeclaration *ETSParser::ParseInterfaceBody(ir::Identifier *name,
     lexer::SourcePosition bodyStart = Lexer()->GetToken().Start();
     auto members = ParseTypeLiteralOrInterface();
     auto *body = AllocNode<ir::TSInterfaceBody>(std::move(members));
+    ES2PANDA_ASSERT(body != nullptr);
     body->SetRange({bodyStart, Lexer()->GetToken().End()});
 
     const auto isExternal = IsExternal();
@@ -915,6 +926,7 @@ ir::Statement *ETSParser::ParseInterfaceDeclaration(bool isStatic)
     auto *id = ExpectIdentifier(false, true);
 
     auto *declNode = ParseInterfaceBody(id, isStatic);
+    ES2PANDA_ASSERT(declNode != nullptr);
 
     declNode->SetRange({interfaceStart, Lexer()->GetToken().End()});
     return declNode;
@@ -971,6 +983,7 @@ ir::ClassDefinition *ETSParser::ParseClassDefinition(ir::ClassDefinitionModifier
     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->SetRange(bodyRange);
 
@@ -1058,6 +1071,7 @@ ir::AstNode *ETSParser::ParseInterfaceField()
 
     auto parseClassMethod = [&fieldModifiers, &startLoc, this](ir::Identifier *methodName) {
         auto *classMethod = ParseClassMethodDefinition(methodName, fieldModifiers, false);
+        ES2PANDA_ASSERT(classMethod != nullptr);
         classMethod->SetStart(startLoc);
         return classMethod;
     };
@@ -1077,6 +1091,7 @@ ir::AstNode *ETSParser::ParseInterfaceField()
     auto *typeAnnotation = ParseInterfaceTypeAnnotation(name);
     auto *field = AllocNode<ir::ClassProperty>(name, nullptr, typeAnnotation->Clone(Allocator(), nullptr),
                                                fieldModifiers, Allocator(), false);
+    ES2PANDA_ASSERT(field != nullptr);
     if (optionalField) {
         field->AddModifier(ir::ModifierFlags::OPTIONAL);
     }
@@ -1127,6 +1142,7 @@ ir::OverloadDeclaration *ETSParser::ParseInterfaceOverload(ir::ModifierFlags mod
     return overloadDef;
 }
 
+// CC-OFFNXT(huge_method[C++], G.FUN.01-CPP) solid logic
 ir::MethodDefinition *ETSParser::ParseInterfaceMethod(ir::ModifierFlags flags, ir::MethodDefinitionKind methodKind)
 {
     ir::Identifier *name = nullptr;
@@ -1172,6 +1188,7 @@ ir::MethodDefinition *ETSParser::ParseInterfaceMethod(ir::ModifierFlags flags, i
         Allocator(), ir::ScriptFunction::ScriptFunctionData {body, std::move(signature), functionContext.Flags(), flags,
                                                              GetContext().GetLanguage()});
 
+    ES2PANDA_ASSERT(func != nullptr);
     if ((flags & ir::ModifierFlags::STATIC) == 0 && body == nullptr) {
         func->AddModifier(ir::ModifierFlags::ABSTRACT);
     }
@@ -1179,6 +1196,7 @@ ir::MethodDefinition *ETSParser::ParseInterfaceMethod(ir::ModifierFlags flags, i
     func->SetRange({startLoc, GetEndLoc(body, func, Lexer())});
 
     auto *funcExpr = AllocNode<ir::FunctionExpression>(func);
+    ES2PANDA_ASSERT(funcExpr != nullptr);
     funcExpr->SetRange(func->Range());
     func->AddFlag(ir::ScriptFunctionFlags::METHOD);
 
@@ -1262,6 +1280,7 @@ ir::AstNode *ETSParser::ParseTypeLiteralOrInterfaceMember()
             LogError(diagnostic::READONLY_INTERFACE_METHOD, {}, startLoc);
         }
         auto *method = ParseInterfaceMethod(modifiers, ir::MethodDefinitionKind::METHOD);
+        ES2PANDA_ASSERT(method != nullptr);
         method->SetStart(startLoc);
         return method;
     }
@@ -1318,6 +1337,7 @@ bool ETSParser::CheckClassElement(ir::AstNode *property, [[maybe_unused]] ir::Me
 
 void ETSParser::CheckPredefinedMethods(ir::ScriptFunction const *function, const lexer::SourcePosition &position)
 {
+    ES2PANDA_ASSERT(function != nullptr);
     auto const name = function->Id()->Name();
 
     auto const checkAsynchronous = [this, function, &name, &position]() -> void {
@@ -1378,7 +1398,9 @@ void ETSParser::CreateImplicitConstructor([[maybe_unused]] ir::MethodDefinition
 
     auto *methodDef = BuildImplicitConstructor(ir::ClassDefinitionModifiers::SET_CTOR_ID, startLoc);
     if ((flags & ir::ModifierFlags::DECLARE) != 0) {
-        methodDef->Function()->AddFlag(ir::ScriptFunctionFlags::EXTERNAL);
+        auto func = methodDef->Function();
+        ES2PANDA_ASSERT(func != nullptr);
+        func->AddFlag(ir::ScriptFunctionFlags::EXTERNAL);
     }
     properties.push_back(methodDef);
 }
diff --git a/ets2panda/parser/ETSparserEnums.cpp b/ets2panda/parser/ETSparserEnums.cpp
index b38077398cc5b70edba573d32ea6928b9ff8dbd3..c4f6989c72193267b061bdbced591de00ac4da75 100644
--- a/ets2panda/parser/ETSparserEnums.cpp
+++ b/ets2panda/parser/ETSparserEnums.cpp
@@ -167,6 +167,7 @@ ir::TSEnumDeclaration *ETSParser::ParseEnumMembers(ir::Identifier *const key, co
     auto *const enumDeclaration = AllocNode<ir::TSEnumDeclaration>(
         Allocator(), key, std::move(members),
         ir::TSEnumDeclaration::ConstructorFlags {isConst, isStatic, InAmbientContext()});
+    ES2PANDA_ASSERT(enumDeclaration != nullptr);
     if (InAmbientContext()) {
         enumDeclaration->AddModifier(ir::ModifierFlags::DECLARE);
     }
diff --git a/ets2panda/parser/ETSparserExpressions.cpp b/ets2panda/parser/ETSparserExpressions.cpp
index bff2cbec61e8ca9a642255a35da2c38a699fa4e7..7cd587f2149823b7d9296b56fe0e8594c8b108be 100644
--- a/ets2panda/parser/ETSparserExpressions.cpp
+++ b/ets2panda/parser/ETSparserExpressions.cpp
@@ -68,6 +68,7 @@ ir::Expression *ETSParser::ParseFunctionParameterExpression(ir::AnnotatedExpress
         }
 
         paramExpression = AllocNode<ir::ETSParameterExpression>(paramIdent->AsIdentifier(), defaultValue, Allocator());
+        ES2PANDA_ASSERT(paramExpression != nullptr);
 
         std::string value = GetArgumentsSourceView(Lexer(), lexerPos);
         paramExpression->SetLexerSaved(util::UString(value, Allocator()).View());
@@ -163,6 +164,7 @@ ir::Expression *ETSParser::ParseUnaryOrPrefixUpdateExpression(ExpressionParseFla
     ir::Expression *argument = ResolveArgumentUnaryExpr(flags);
     if (operatorType == lexer::TokenType::KEYW_AWAIT) {
         auto *awaitExpr = AllocNode<ir::AwaitExpression>(argument);
+        ES2PANDA_ASSERT(awaitExpr != nullptr);
         awaitExpr->SetRange({start, argument->End()});
         return awaitExpr;
     }
@@ -208,6 +210,7 @@ ir::Expression *ETSParser::ParsePropertyDefinition(ExpressionParseFlags flags)
     ir::Expression *key = ParsePropertyKey(flags);
 
     ir::Expression *value = ParsePropertyValue(&propertyKind, &methodStatus, flags);
+    ES2PANDA_ASSERT(value != nullptr);
     lexer::SourcePosition end = value->End();
 
     ir::Expression *returnProperty = nullptr;
@@ -255,6 +258,7 @@ ir::Expression *ETSParser::ParseDefaultPrimaryExpression(ExpressionParseFlags fl
         if (Lexer()->GetToken().Type() == lexer::TokenType::KEYW_CLASS || IsStructKeyword()) {
             Lexer()->NextToken();  // eat 'class' and 'struct'
             auto *classLiteral = AllocNode<ir::ETSClassLiteral>(potentialType);
+            ES2PANDA_ASSERT(classLiteral != nullptr);
             classLiteral->SetRange({startLoc, Lexer()->GetToken().End()});
             return classLiteral;
         }
@@ -477,6 +481,7 @@ ir::ArrowFunctionExpression *ETSParser::ParseArrowFunctionExpression()
     auto newStatus = ParserStatus::ARROW_FUNCTION | ParserStatus::ALLOW_RECEIVER;
     auto *func = ParseFunction(newStatus);
     auto *arrowFuncNode = AllocNode<ir::ArrowFunctionExpression>(func, Allocator());
+    ES2PANDA_ASSERT(arrowFuncNode != nullptr);
     arrowFuncNode->SetRange(func->Range());
     return arrowFuncNode;
 }
@@ -605,6 +610,7 @@ ir::Expression *ETSParser::ParsePotentialAsExpression(ir::Expression *primaryExp
     }
 
     auto *asExpression = AllocNode<ir::TSAsExpression>(primaryExpr, type, false);
+    ES2PANDA_ASSERT(asExpression != nullptr);
     asExpression->SetRange(primaryExpr->Range());
     return asExpression;
 }
@@ -672,6 +678,7 @@ ir::Expression *ETSParser::ParseNewExpression()
         } while (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET);
 
         auto *multiArray = AllocNode<ir::ETSNewMultiDimArrayInstanceExpression>(typeReference, std::move(dimensions));
+        ES2PANDA_ASSERT(multiArray != nullptr);
         multiArray->SetRange({start, endLoc});
         return multiArray;
     }
@@ -699,6 +706,7 @@ ir::Expression *ETSParser::ParseAsyncExpression()
         return nullptr;
     }
     auto *arrowFuncNode = AllocNode<ir::ArrowFunctionExpression>(func, Allocator());
+    ES2PANDA_ASSERT(arrowFuncNode != nullptr);
     arrowFuncNode->SetRange(func->Range());
     return arrowFuncNode;
 }
@@ -709,6 +717,7 @@ ir::Expression *ETSParser::ParseAwaitExpression()
     Lexer()->NextToken();
     ir::Expression *argument = ParseExpression();
     auto *awaitExpression = AllocNode<ir::AwaitExpression>(argument);
+    ES2PANDA_ASSERT(awaitExpression != nullptr);
     awaitExpression->SetRange({start, Lexer()->GetToken().End()});
     return awaitExpression;
 }
@@ -735,6 +744,7 @@ bool ETSParser::ParsePotentialNonNullExpression(ir::Expression **expression, con
     }
 
     const auto nonNullExpr = AllocNode<ir::TSNonNullExpression>(*expression);
+    ES2PANDA_ASSERT(nonNullExpr != nullptr);
     nonNullExpr->SetRange({startLoc, Lexer()->GetToken().End()});
 
     *expression = nonNullExpr;
diff --git a/ets2panda/parser/ETSparserJsDocInfo.cpp b/ets2panda/parser/ETSparserJsDocInfo.cpp
index 8ddf1be0207fd411a7219e3f653c7d40ffa1bed0..fadcdcfec980480bcdc1a4662c217f6a48f3bed0 100644
--- a/ets2panda/parser/ETSparserJsDocInfo.cpp
+++ b/ets2panda/parser/ETSparserJsDocInfo.cpp
@@ -237,9 +237,12 @@ void ETSParser::ApplyJsDocInfoToSpecificNodeType(ir::AstNode *node, ArenaVector<
     }
 
     switch (node->Type()) {
-        case ir::AstNodeType::METHOD_DEFINITION:
-            node->AsMethodDefinition()->Function()->SetJsDocInformation(std::move(jsDocInformation));
+            case ir::AstNodeType::METHOD_DEFINITION: {
+            auto *func = node->AsMethodDefinition()->Function();
+            ES2PANDA_ASSERT(func != nullptr);
+            func->SetJsDocInformation(std::move(jsDocInformation));
             break;
+        }
         case ir::AstNodeType::CLASS_DECLARATION:
             node->AsClassDeclaration()->Definition()->SetJsDocInformation(std::move(jsDocInformation));
             break;
diff --git a/ets2panda/parser/ETSparserNamespaces.cpp b/ets2panda/parser/ETSparserNamespaces.cpp
index 72c121d5fcc513418234cb33dcc2e181e924627f..d3ecaeedf6feb6d658e3a925c3dd6fc329b5c23e 100644
--- a/ets2panda/parser/ETSparserNamespaces.cpp
+++ b/ets2panda/parser/ETSparserNamespaces.cpp
@@ -60,6 +60,7 @@ ir::Statement *ETSParser::ParseNamespace(ir::ModifierFlags flags)
     }
     auto start = Lexer()->GetToken().Start();
     ir::ETSModule *ns = ParseNamespaceImp(flags);
+    ES2PANDA_ASSERT(ns != nullptr);
     ns->SetRange({start, Lexer()->GetToken().Start()});
     return ns;
 }
@@ -76,6 +77,7 @@ ir::ETSModule *ETSParser::ParseNamespaceImp(ir::ModifierFlags flags)
         auto start = Lexer()->GetToken().Start();
         child = AllocNode<ir::ETSModule>(Allocator(), ArenaVector<ir::Statement *>(Allocator()->Adapter()),
                                          ExpectIdentifier(), ir::ModuleFlag::NAMESPACE, globalProgram_);
+        ES2PANDA_ASSERT(child != nullptr);
         child->SetParent(parent);
         child->SetRange({start, Lexer()->GetToken().Start()});
         child->AddModifier(ir::ModifierFlags::EXPORT);
diff --git a/ets2panda/parser/ETSparserStatements.cpp b/ets2panda/parser/ETSparserStatements.cpp
index 7f59b8b0e31569c892278c1a8bc6f100dbccb2e7..08fea38576047d62bd61421da6e3475a061bdc9c 100644
--- a/ets2panda/parser/ETSparserStatements.cpp
+++ b/ets2panda/parser/ETSparserStatements.cpp
@@ -193,6 +193,7 @@ ir::Statement *ETSParser::ParseTopLevelDeclStatement(StatementParsingFlags flags
     switch (token.Type()) {
         case lexer::TokenType::KEYW_FUNCTION: {
             result = ParseFunctionDeclaration(false, memberModifiers);
+            ES2PANDA_ASSERT(result != nullptr);
             result->SetStart(startLoc);
             break;
         }
@@ -370,6 +371,7 @@ ir::Statement *ETSParser::ParseTryStatement()
     ArenaVector<std::pair<compiler::LabelPair, const ir::Statement *>> finalizerInsertions(Allocator()->Adapter());
 
     auto *tryStatement = AllocNode<ir::TryStatement>(body, std::move(catchClauses), finalizer, finalizerInsertions);
+    ES2PANDA_ASSERT(tryStatement != nullptr);
     tryStatement->SetRange({startLoc, endLoc});
     ConsumeSemicolon(tryStatement);
 
diff --git a/ets2panda/parser/ETSparserTypes.cpp b/ets2panda/parser/ETSparserTypes.cpp
index dc590faec018f73ce1255c61b370754742c15ed5..44e57121936078a6ff7035ea35959f100f5c46f4 100644
--- a/ets2panda/parser/ETSparserTypes.cpp
+++ b/ets2panda/parser/ETSparserTypes.cpp
@@ -99,6 +99,7 @@ ir::TypeNode *ETSParser::ParsePrimitiveType(TypeAnnotationParsingOptions *option
     }
 
     auto *const typeAnnotation = AllocNode<ir::ETSPrimitiveType>(type, Allocator());
+    ES2PANDA_ASSERT(typeAnnotation != nullptr);
     typeAnnotation->SetRange(Lexer()->GetToken().Loc());
     Lexer()->NextToken();
     return typeAnnotation;
@@ -121,6 +122,7 @@ ir::TypeNode *ETSParser::ParseUnionType(ir::TypeNode *const firstType)
 
     auto const endLoc = types.back()->End();
     auto *const unionType = AllocNode<ir::ETSUnionType>(std::move(types), Allocator());
+    ES2PANDA_ASSERT(unionType != nullptr);
     unionType->SetRange({firstType->Start(), endLoc});
     return unionType;
 }
@@ -180,6 +182,7 @@ ir::TypeNode *ETSParser::ParseWildcardType(TypeAnnotationParsingOptions *options
     }
 
     auto *wildcardType = AllocNode<ir::ETSWildcardType>(typeReference, varianceModifier, Allocator());
+    ES2PANDA_ASSERT(wildcardType != nullptr);
     wildcardType->SetRange({varianceStartLoc, typeReference == nullptr ? varianceEndLoc : typeReference->End()});
 
     return wildcardType;
@@ -262,6 +265,7 @@ ir::TypeNode *ETSParser::ParseETSTupleType(TypeAnnotationParsingOptions *const o
     lexer::SourcePosition endLoc;
     ParseList(lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET, lexer::NextTokenFlags::NONE, parseElem, &endLoc, true);
 
+    ES2PANDA_ASSERT(tupleType != nullptr);
     tupleType->SetTypeAnnotationsList(std::move(tupleTypeList));
     tupleType->SetRange({startLoc, endLoc});
 
@@ -308,6 +312,7 @@ ir::TypeNode *ETSParser::ParsePotentialFunctionalType(TypeAnnotationParsingOptio
     return nullptr;
 }
 
+// CC-OFFNXT(huge_method[C++], G.FUN.01-CPP) solid logic
 // Just to reduce the size of ParseTypeAnnotation(...) method
 std::pair<ir::TypeNode *, bool> ETSParser::GetTypeAnnotationFromToken(TypeAnnotationParsingOptions *options)
 {
@@ -324,18 +329,21 @@ std::pair<ir::TypeNode *, bool> ETSParser::GetTypeAnnotationFromToken(TypeAnnota
     switch (tokenType) {
         case lexer::TokenType::LITERAL_NULL: {
             auto typeAnnotation = AllocNode<ir::ETSNullType>(Allocator());
+            ES2PANDA_ASSERT(typeAnnotation != nullptr);
             typeAnnotation->SetRange(Lexer()->GetToken().Loc());
             Lexer()->NextToken();
             return std::make_pair(typeAnnotation, true);
         }
         case lexer::TokenType::KEYW_UNDEFINED: {
             auto typeAnnotation = AllocNode<ir::ETSUndefinedType>(Allocator());
+            ES2PANDA_ASSERT(typeAnnotation != nullptr);
             typeAnnotation->SetRange(Lexer()->GetToken().Loc());
             Lexer()->NextToken();
             return std::make_pair(typeAnnotation, true);
         }
         case lexer::TokenType::LITERAL_STRING: {
             auto typeAnnotation = AllocNode<ir::ETSStringLiteralType>(Lexer()->GetToken().String(), Allocator());
+            ES2PANDA_ASSERT(typeAnnotation != nullptr);
             typeAnnotation->SetRange(Lexer()->GetToken().Loc());
             Lexer()->NextToken();
             return std::make_pair(typeAnnotation, true);
@@ -453,6 +461,7 @@ ir::TypeNode *ETSParser::ParseThisType(TypeAnnotationParsingOptions *options)
     }
 
     auto *const thisType = AllocNode<ir::TSThisType>(Allocator());
+    ES2PANDA_ASSERT(thisType != nullptr);
     thisType->SetRange(tokenLoc);
 
     return thisType;
@@ -586,6 +595,7 @@ ir::TypeNode *ETSParser::ParseMultilineString()
     Lexer()->ScanTemplateStringEnd();
 
     auto typeAnnotation = AllocNode<ir::ETSStringLiteralType>(multilineStr, Allocator());
+    ES2PANDA_ASSERT(typeAnnotation != nullptr);
     typeAnnotation->SetRange({startPos, Lexer()->GetToken().End()});
     Lexer()->NextToken();
 
diff --git a/ets2panda/parser/TSparser.cpp b/ets2panda/parser/TSparser.cpp
index 164f34c1709b25800f00f11a958346c400d8b8ee..80cd4f4f1d3f4257aa1c219ea12ff5b13244d708 100644
--- a/ets2panda/parser/TSparser.cpp
+++ b/ets2panda/parser/TSparser.cpp
@@ -149,6 +149,7 @@ ir::Decorator *TSParser::ParseDecorator()
         }
 
         auto *identNode = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+        ES2PANDA_ASSERT(identNode != nullptr);
         identNode->SetRange(Lexer()->GetToken().Loc());
 
         expr =
@@ -161,6 +162,7 @@ ir::Decorator *TSParser::ParseDecorator()
     }
 
     auto *result = AllocNode<ir::Decorator>(expr);
+    ES2PANDA_ASSERT(result != nullptr);
     result->SetRange({start, expr->End()});
 
     return result;
@@ -199,6 +201,7 @@ ir::TSTypeAliasDeclaration *TSParser::ParseTypeAliasDeclaration()
     const util::StringView &ident = Lexer()->GetToken().Ident();
 
     auto *id = AllocNode<ir::Identifier>(ident, Allocator());
+    ES2PANDA_ASSERT(id != nullptr);
     id->SetRange(Lexer()->GetToken().Loc());
     Lexer()->NextToken();
 
@@ -441,6 +444,7 @@ ir::TypeNode *TSParser::ParseThisType(bool throwError)
     }
 
     auto *returnType = AllocNode<ir::TSThisType>(Allocator());
+    ES2PANDA_ASSERT(returnType != nullptr);
     returnType->SetRange(Lexer()->GetToken().Loc());
 
     Lexer()->NextToken();
@@ -544,6 +548,7 @@ ir::TypeNode *TSParser::ParseTypeOperatorOrTypeReference()
 
         auto *inferType = AllocNode<ir::TSInferType>(typeParam, Allocator());
 
+        ES2PANDA_ASSERT(inferType != nullptr);
         inferType->SetRange({inferStart, Lexer()->GetToken().End()});
 
         return inferType;
@@ -638,6 +643,7 @@ ir::TSTupleType *TSParser::ParseTupleType()
     Lexer()->NextToken();  // eat ']'
 
     auto *tupleType = AllocNode<ir::TSTupleType>(std::move(elements), Allocator());
+    ES2PANDA_ASSERT(tupleType != nullptr);
     tupleType->SetRange({tupleStart, tupleEnd});
     return tupleType;
 }
@@ -858,6 +864,7 @@ ir::TSTypePredicate *TSParser::ParseTypePredicate()
     if (isAsserts && Lexer()->GetToken().KeywordType() != lexer::TokenType::KEYW_IS) {
         endPos = parameterName->End();
         result = AllocNode<ir::TSTypePredicate>(parameterName, typeAnnotation, isAsserts, Allocator());
+        ES2PANDA_ASSERT(result != nullptr);
         result->SetRange({startPos, endPos});
         return result;
     }
@@ -869,7 +876,7 @@ ir::TSTypePredicate *TSParser::ParseTypePredicate()
     endPos = typeAnnotation->End();
 
     result = AllocNode<ir::TSTypePredicate>(parameterName, typeAnnotation, isAsserts, Allocator());
-
+    ES2PANDA_ASSERT(result != nullptr);
     result->SetRange({startPos, endPos});
 
     return result;
@@ -938,6 +945,7 @@ ir::TSArrayType *TSParser::ParseArrayType(ir::TypeNode *elementType)
 
     lexer::SourcePosition startLoc = elementType->Start();
     auto *arrayType = AllocNode<ir::TSArrayType>(elementType, Allocator());
+    ES2PANDA_ASSERT(arrayType != nullptr);
     arrayType->SetRange({startLoc, endLoc});
 
     return arrayType;
@@ -976,6 +984,7 @@ ir::TSUnionType *TSParser::ParseUnionType(ir::TypeNode *type, bool restrictExten
 
     auto *unionType = AllocNode<ir::TSUnionType>(std::move(types), Allocator());
     auto *typeVar = varbinder::Scope::CreateVar(Allocator(), "__type", varbinder::VariableFlags::TYPE, unionType);
+    ES2PANDA_ASSERT(unionType != nullptr);
     unionType->SetVariable(typeVar);
     unionType->SetRange({startLoc, endLoc});
 
@@ -1020,6 +1029,7 @@ ir::TSIntersectionType *TSParser::ParseIntersectionType(ir::Expression *type, bo
     auto *intersectionType = AllocNode<ir::TSIntersectionType>(std::move(types), Allocator());
     auto *typeVar =
         varbinder::Scope::CreateVar(Allocator(), "__type", varbinder::VariableFlags::TYPE, intersectionType);
+    ES2PANDA_ASSERT(intersectionType != nullptr);
     intersectionType->SetVariable(typeVar);
     intersectionType->SetRange({startLoc, endLoc});
 
@@ -1041,6 +1051,7 @@ private:
                     return parser->AllocNode<ir::TSLiteralType>(bigintNode, parser->Allocator());
                 }
                 auto *numberNode = parser->AllocNode<ir::NumberLiteral>(lexer->GetToken().GetNumber());
+                ASSERT(numberNode != nullptr);
                 numberNode->SetRange(lexer->GetToken().Loc());
 
                 return parser->AllocNode<ir::TSLiteralType>(numberNode, parser->Allocator());
@@ -1136,6 +1147,7 @@ ir::TypeNode *TSParser::ParseBasicType()
     return typeAnnotation;
 }
 
+// CC-OFFNXT(huge_method[C++], G.FUN.01-CPP) solid logic
 ir::TypeNode *TSParser::ParseParenthesizedOrFunctionType(ir::TypeNode *typeAnnotation, bool throwError)
 {
     if (typeAnnotation != nullptr) {
@@ -1200,6 +1212,7 @@ ir::TypeNode *TSParser::ParseParenthesizedOrFunctionType(ir::TypeNode *typeAnnot
     }
 
     auto *result = AllocNode<ir::TSParenthesizedType>(type, Allocator());
+    ES2PANDA_ASSERT(result != nullptr);
     result->SetRange({typeStart, endLoc});
 
     return result;
@@ -1466,6 +1479,7 @@ bool TSParser::IsNamedFunctionExpression()
 ir::Identifier *TSParser::ParsePrimaryExpressionIdent([[maybe_unused]] ExpressionParseFlags flags)
 {
     auto *identNode = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(identNode != nullptr);
     identNode->SetRange(Lexer()->GetToken().Loc());
 
     Lexer()->NextToken();
@@ -1508,6 +1522,7 @@ ir::TSSignatureDeclaration *TSParser::ParseSignatureMember(bool isCallSignature)
                                 : ir::TSSignatureDeclaration::TSSignatureDeclarationKind::CONSTRUCT_SIGNATURE;
     auto *signatureMember = AllocNode<ir::TSSignatureDeclaration>(
         kind, ir::FunctionSignature(typeParamDecl, std::move(params), typeAnnotation));
+    ES2PANDA_ASSERT(signatureMember != nullptr);
     signatureMember->SetRange({memberStartLoc, Lexer()->GetToken().End()});
 
     return signatureMember;
@@ -1534,6 +1549,7 @@ ir::TSIndexSignature *TSParser::ParseIndexSignature(const lexer::SourcePosition
 
     ES2PANDA_ASSERT(Lexer()->GetToken().Type() == lexer::TokenType::LITERAL_IDENT);
     auto *key = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(key != nullptr);
     key->SetRange(Lexer()->GetToken().Loc());
 
     Lexer()->NextToken();  // eat key
@@ -1581,12 +1597,14 @@ std::tuple<ir::Expression *, bool> TSParser::ParseInterfacePropertyKey()
         case lexer::TokenType::LITERAL_IDENT: {
             const util::StringView &ident = Lexer()->GetToken().Ident();
             key = AllocNode<ir::Identifier>(ident, Allocator());
+            ES2PANDA_ASSERT(key != nullptr);
             key->SetRange(Lexer()->GetToken().Loc());
             break;
         }
         case lexer::TokenType::LITERAL_STRING: {
             const util::StringView &string = Lexer()->GetToken().String();
             key = AllocNode<ir::StringLiteral>(string);
+            ES2PANDA_ASSERT(key != nullptr);
             key->SetRange(Lexer()->GetToken().Loc());
             break;
         }
@@ -1597,6 +1615,7 @@ std::tuple<ir::Expression *, bool> TSParser::ParseInterfacePropertyKey()
                 key = AllocNode<ir::NumberLiteral>(Lexer()->GetToken().GetNumber());
             }
 
+            ES2PANDA_ASSERT(key != nullptr);
             key->SetRange(Lexer()->GetToken().Loc());
             break;
         }
@@ -1905,6 +1924,7 @@ ir::MethodDefinition *TSParser::ParseClassMethod(ClassElementDescriptor *desc,
 
     ir::ScriptFunction *func = ParseFunction(desc->newStatus);
 
+    ES2PANDA_ASSERT(func != nullptr);
     if (func->IsOverload() && !desc->decorators.empty()) {
         ThrowSyntaxError("A decorator can only decorate a method implementation, not an overload.",
                          desc->decorators.front()->Start());
@@ -2089,6 +2109,7 @@ std::tuple<bool, ir::BlockStatement *, lexer::SourcePosition, bool> TSParser::Pa
         ThrowSyntaxError("An implementation cannot be declared in ambient contexts.");
     } else {
         body = ParseBlockStatement();
+        ES2PANDA_ASSERT(body != nullptr);
         endLoc = body->End();
     }
 
@@ -2110,6 +2131,7 @@ ir::AstNode *TSParser::ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *s
     }
 
     auto *specifier = AllocNode<ir::ImportDefaultSpecifier>(local);
+    ES2PANDA_ASSERT(specifier != nullptr);
     specifier->SetRange(specifier->Local()->Range());
     specifiers->push_back(specifier);
 
diff --git a/ets2panda/parser/context/classPrivateContext.cpp b/ets2panda/parser/context/classPrivateContext.cpp
index a902e95455abdfd3da483fb2eb6697b3d749ed4b..048ec7177a64c59159f1ff0717db992e31991d05 100644
--- a/ets2panda/parser/context/classPrivateContext.cpp
+++ b/ets2panda/parser/context/classPrivateContext.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-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
@@ -24,7 +24,9 @@ namespace ark::es2panda::parser {
 bool ClassPrivateContext::AddElement(const ir::ClassElement *elem)
 {
     bool newPropIsStatic = elem->IsStatic();
-    util::StringView newPropName = elem->Id()->Name();
+    auto id = elem->Id();
+    ES2PANDA_ASSERT(id != nullptr);
+    util::StringView newPropName = id->Name();
     ir::MethodDefinitionKind newPropMethodKind = ir::MethodDefinitionKind::METHOD;
 
     if (elem->IsMethodDefinition()) {
@@ -61,7 +63,9 @@ bool ClassPrivateContext::AddElement(const ir::ClassElement *elem)
 bool ClassPrivateContext::FindElement(const ir::Identifier *elem) const
 {
     for (const auto *it : elements_) {
-        if (it->Id()->Name().Compare(elem->Name()) == 0) {
+        auto id = it->Id();
+        ES2PANDA_ASSERT(id != nullptr);
+        if (id->Name().Compare(elem->Name()) == 0) {
             return true;
         }
     }
diff --git a/ets2panda/parser/expressionParser.cpp b/ets2panda/parser/expressionParser.cpp
index 67500b59ac9755039e36b368c1b0694f8051881f..8892c6d3b1875dc98f731fa5e46d0501ba5bf8c1 100644
--- a/ets2panda/parser/expressionParser.cpp
+++ b/ets2panda/parser/expressionParser.cpp
@@ -114,6 +114,7 @@ ir::YieldExpression *ParserImpl::ParseYieldExpression()
     }
 
     auto *yieldNode = AllocNode<ir::YieldExpression>(argument, isDelegate);
+    ES2PANDA_ASSERT(yieldNode != nullptr);
     yieldNode->SetRange({startLoc, endLoc});
 
     return yieldNode;
@@ -208,6 +209,7 @@ ir::ArrayExpression *ParserImpl::ParseArrayExpression(ExpressionParseFlags flags
     auto nodeType = inPattern ? ir::AstNodeType::ARRAY_PATTERN : ir::AstNodeType::ARRAY_EXPRESSION;
     auto *arrayExpressionNode =
         AllocNode<ir::ArrayExpression>(nodeType, std::move(elements), Allocator(), trailingComma);
+    ES2PANDA_ASSERT(arrayExpressionNode != nullptr);
     arrayExpressionNode->SetRange({startLoc, endLoc});
 
     if (inPattern) {
@@ -321,6 +323,7 @@ ir::ArrowFunctionExpression *ParserImpl::ParseArrowFunctionExpressionBody(ArrowF
         lexer_->NextToken();
         auto statements = ParseStatementList();
         body = AllocNode<ir::BlockStatement>(Allocator(), std::move(statements));
+        ES2PANDA_ASSERT(body != nullptr);
         body->SetRange({bodyStart, lexer_->GetToken().End()});
 
         // This check is redundant since we have ParseStatementList()
@@ -581,6 +584,7 @@ ir::Expression *ParserImpl::CreateBinaryAssignmentExpression(ir::Expression *ass
 
     auto *binaryAssignmentExpression =
         AllocNode<ir::AssignmentExpression>(lhsExpression, assignmentExpression, tokenType);
+    ES2PANDA_ASSERT(binaryAssignmentExpression != nullptr);
 
     binaryAssignmentExpression->SetRange({lhsExpression->Start(), assignmentExpression->End()});
     return binaryAssignmentExpression;
@@ -596,6 +600,7 @@ ir::Expression *ParserImpl::ParseAssignmentExpression(ir::Expression *lhsExpress
             ir::Expression *consequent = ParseAssignmentExpressionHelper();
             ir::Expression *alternate = ParseExpression();
             auto *conditionalExpr = AllocNode<ir::ConditionalExpression>(lhsExpression, consequent, alternate);
+            ES2PANDA_ASSERT(conditionalExpr != nullptr);
             conditionalExpr->SetRange({lhsExpression->Start(), alternate->End()});
             return conditionalExpr;
         }
@@ -709,6 +714,7 @@ ir::Expression *ParserImpl::ParseAssignmentEqualExpression(const lexer::TokenTyp
 
             auto *binaryAssignmentExpression =
                 AllocNode<ir::AssignmentExpression>(lhsExpression, assignmentExpression, tokenType);
+            ES2PANDA_ASSERT(binaryAssignmentExpression != nullptr);
 
             binaryAssignmentExpression->SetRange({lhsExpression->Start(), assignmentExpression->End()});
             return binaryAssignmentExpression;
@@ -798,6 +804,7 @@ ir::Expression *ParserImpl::ParseNewExpression()
     if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
         lexer::SourcePosition endLoc = callee->End();
         auto *newExprNode = AllocNode<ir::NewExpression>(callee, std::move(arguments));
+        ES2PANDA_ASSERT(newExprNode != nullptr);
         newExprNode->SetRange({start, endLoc});
 
         return newExprNode;
@@ -823,6 +830,7 @@ ir::Expression *ParserImpl::ParseNewExpression()
         &endLoc, true);
 
     auto *newExprNode = AllocNode<ir::NewExpression>(callee, std::move(arguments));
+    ES2PANDA_ASSERT(newExprNode != nullptr);
     newExprNode->SetRange({start, endLoc});
 
     return newExprNode;
@@ -851,6 +859,7 @@ ir::MetaProperty *ParserImpl::ParsePotentialNewTarget()
             }
 
             auto *metaProperty = AllocNode<ir::MetaProperty>(ir::MetaProperty::MetaPropertyKind::NEW_TARGET);
+            ES2PANDA_ASSERT(metaProperty != nullptr);
             metaProperty->SetRange(loc);
             lexer_->NextToken();
             return metaProperty;
@@ -863,6 +872,7 @@ ir::MetaProperty *ParserImpl::ParsePotentialNewTarget()
 ir::Identifier *ParserImpl::ParsePrimaryExpressionIdent([[maybe_unused]] ExpressionParseFlags flags)
 {
     auto *identNode = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(identNode != nullptr);
     identNode->SetRange(lexer_->GetToken().Loc());
 
     lexer_->NextToken();
@@ -875,6 +885,7 @@ ir::BooleanLiteral *ParserImpl::ParseBooleanLiteral()
                     lexer_->GetToken().Type() == lexer::TokenType::LITERAL_FALSE);
 
     auto *booleanNode = AllocNode<ir::BooleanLiteral>(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_TRUE);
+    ES2PANDA_ASSERT(booleanNode != nullptr);
     booleanNode->SetRange(lexer_->GetToken().Loc());
 
     lexer_->NextToken();
@@ -885,6 +896,7 @@ ir::NullLiteral *ParserImpl::ParseNullLiteral()
 {
     ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_NULL);
     auto *nullNode = AllocNode<ir::NullLiteral>();
+    ES2PANDA_ASSERT(nullNode != nullptr);
     nullNode->SetRange(lexer_->GetToken().Loc());
 
     lexer_->NextToken();
@@ -903,6 +915,7 @@ ir::Literal *ParserImpl::ParseNumberLiteral()
         numberNode = AllocNode<ir::NumberLiteral>(lexer_->GetToken().GetNumber());
     }
 
+    ES2PANDA_ASSERT(numberNode != nullptr);
     numberNode->SetRange(lexer_->GetToken().Loc());
 
     lexer_->NextToken();
@@ -914,6 +927,7 @@ ir::CharLiteral *ParserImpl::ParseCharLiteral()
     ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_CHAR);
 
     auto *charNode = AllocNode<ir::CharLiteral>(lexer_->GetToken().Utf16());
+    ES2PANDA_ASSERT(charNode != nullptr);
     charNode->SetRange(lexer_->GetToken().Loc());
 
     lexer_->NextToken();
@@ -925,6 +939,7 @@ ir::StringLiteral *ParserImpl::ParseStringLiteral()
     ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_STRING);
 
     auto *stringNode = AllocNode<ir::StringLiteral>(lexer_->GetToken().String());
+    ES2PANDA_ASSERT(stringNode != nullptr);
     stringNode->SetRange(lexer_->GetToken().Loc());
 
     lexer_->NextToken();
@@ -935,6 +950,7 @@ ir::UndefinedLiteral *ParserImpl::ParseUndefinedLiteral()
 {
     ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::KEYW_UNDEFINED);
     auto *undefinedNode = AllocNode<ir::UndefinedLiteral>();
+    ES2PANDA_ASSERT(undefinedNode != nullptr);
     undefinedNode->SetRange(lexer_->GetToken().Loc());
 
     lexer_->NextToken();
@@ -946,6 +962,7 @@ ir::ThisExpression *ParserImpl::ParseThisExpression()
     ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::KEYW_THIS);
 
     auto *thisExprNode = AllocNode<ir::ThisExpression>();
+    ES2PANDA_ASSERT(thisExprNode != nullptr);
     thisExprNode->SetRange(lexer_->GetToken().Loc());
 
     lexer_->NextToken();
@@ -965,6 +982,7 @@ ir::RegExpLiteral *ParserImpl::ParseRegularExpression()
     reParser.ParsePattern();
 
     auto *regexpNode = AllocNode<ir::RegExpLiteral>(regexp.patternStr, regexp.flags, regexp.flagsStr);
+    ES2PANDA_ASSERT(regexpNode != nullptr);
     regexpNode->SetRange(lexer_->GetToken().Loc());
 
     lexer_->NextToken();
@@ -976,6 +994,7 @@ ir::SuperExpression *ParserImpl::ParseSuperExpression()
     ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::KEYW_SUPER);
 
     auto *superExprNode = AllocNode<ir::SuperExpression>();
+    ES2PANDA_ASSERT(superExprNode != nullptr);
     superExprNode->SetRange(lexer_->GetToken().Loc());
 
     lexer_->NextToken();  // eat super
@@ -1024,6 +1043,7 @@ ir::Expression *ParserImpl::ParseHashMaskOperator()
     }
 
     auto *privateIdent = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(privateIdent != nullptr);
     privateIdent->SetPrivate(true);
     lexer_->NextToken();
 
@@ -1045,6 +1065,7 @@ ir::Expression *ParserImpl::ParseClassExpression()
     }
 
     auto *classExpr = AllocNode<ir::ClassExpression>(classDefinition);
+    ES2PANDA_ASSERT(classExpr != nullptr);
     classExpr->SetRange({startLoc, classDefinition->End()});
 
     return classExpr;
@@ -1283,6 +1304,7 @@ void ParserImpl::CreateAmendedBinaryExpression(ir::Expression *const left, ir::E
     amended->SetParent(nullptr);  // Next line overwrite parent
     auto *binaryExpr = AllocNode<ir::BinaryExpression>(left, amended, operatorType);
 
+    ES2PANDA_ASSERT(binaryExpr != nullptr);
     binaryExpr->SetRange({left->Start(), amended->End()});
     SetAmendedChildExpression(right, binaryExpr);
 }
@@ -1341,6 +1363,7 @@ ir::Expression *ParserImpl::ParseBinaryExpression(ir::Expression *left, const le
         }
         const lexer::SourcePosition &endPos = rightExpr->End();
         rightExpr = AllocNode<ir::BinaryExpression>(left, rightExpr, operatorType);
+        ES2PANDA_ASSERT(rightExpr != nullptr);
         rightExpr->SetRange({left->Start(), endPos});
     }
 
@@ -1406,6 +1429,7 @@ ir::CallExpression *ParserImpl::ParseCallExpression(ir::Expression *callee, bool
             callExpr =
                 AllocNode<ir::CallExpression>(callee, std::move(arguments), nullptr, isOptionalChain, trailingComma);
         }
+        ES2PANDA_ASSERT(callExpr != nullptr);
 
         callExpr->SetRange({callee->Start(), endLoc});
         isOptionalChain = false;
@@ -1443,6 +1467,7 @@ ir::Expression *ParserImpl::ParseOptionalChain(ir::Expression *leftSideExpr)
 
         returnExpression = AllocNode<ir::MemberExpression>(leftSideExpr, identNode,
                                                            ir::MemberExpressionKind::PROPERTY_ACCESS, false, true);
+        ES2PANDA_ASSERT(returnExpression != nullptr);
         returnExpression->SetRange({leftSideExpr->Start(), identNode->End()});
         lexer_->NextToken();
     }
@@ -1459,6 +1484,7 @@ ir::Expression *ParserImpl::ParseOptionalChain(ir::Expression *leftSideExpr)
 
         returnExpression = AllocNode<ir::MemberExpression>(leftSideExpr, propertyNode,
                                                            ir::MemberExpressionKind::ELEMENT_ACCESS, true, true);
+        ES2PANDA_ASSERT(returnExpression != nullptr);
         returnExpression->SetRange({leftSideExpr->Start(), endLoc});
         lexer_->NextToken();
     }
@@ -1482,6 +1508,7 @@ ir::ArrowFunctionExpression *ParserImpl::ParsePotentialArrowExpression(ir::Expre
     switch (lexer_->GetToken().Type()) {
         case lexer::TokenType::KEYW_FUNCTION: {
             *returnExpression = ParseFunctionExpression(ParserStatus::ASYNC_FUNCTION);
+            ES2PANDA_ASSERT(returnExpression != nullptr);
             (*returnExpression)->SetStart(startLoc);
             break;
         }
@@ -1557,6 +1584,7 @@ ir::MemberExpression *ParserImpl::ParseElementAccess(ir::Expression *primaryExpr
 
     auto *memberExpr = AllocNode<ir::MemberExpression>(primaryExpr, propertyNode,
                                                        ir::MemberExpressionKind::ELEMENT_ACCESS, true, isOptional);
+    ES2PANDA_ASSERT(memberExpr != nullptr);
     memberExpr->SetRange({primaryExpr->Start(), lexer_->GetToken().End()});
     lexer_->NextToken();
     return memberExpr;
@@ -1570,12 +1598,14 @@ ir::MemberExpression *ParserImpl::ParsePrivatePropertyAccess(ir::Expression *pri
     ValidatePrivateIdentifier();
 
     auto *privateIdent = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(privateIdent != nullptr);
     privateIdent->SetRange({memberStart, lexer_->GetToken().End()});
     privateIdent->SetPrivate(true);
     lexer_->NextToken();
 
     auto *memberExpr = AllocNode<ir::MemberExpression>(primaryExpr, privateIdent,
                                                        ir::MemberExpressionKind::PROPERTY_ACCESS, false, false);
+    ES2PANDA_ASSERT(memberExpr != nullptr);
     memberExpr->SetRange({primaryExpr->Start(), privateIdent->End()});
     return memberExpr;
 }
@@ -1585,6 +1615,7 @@ ir::MemberExpression *ParserImpl::ParsePropertyAccess(ir::Expression *primaryExp
     ir::Identifier *ident = ExpectIdentifier(true);
     auto *memberExpr = AllocNode<ir::MemberExpression>(primaryExpr, ident, ir::MemberExpressionKind::PROPERTY_ACCESS,
                                                        false, isOptional);
+    ES2PANDA_ASSERT(memberExpr != nullptr);
     memberExpr->SetRange({primaryExpr->Start(), ident->End()});
 
     return memberExpr;
@@ -1647,9 +1678,11 @@ ir::Expression *ParserImpl::ParsePostPrimaryExpressionBackTick(ir::Expression *r
                                                                const lexer::SourcePosition startLoc)
 {
     ir::TemplateLiteral *propertyNode = ParseTemplateLiteral();
+    ES2PANDA_ASSERT(propertyNode != nullptr);
     lexer::SourcePosition endLoc = propertyNode->End();
 
     returnExpression = AllocNode<ir::TaggedTemplateExpression>(returnExpression, propertyNode, nullptr);
+    ES2PANDA_ASSERT(returnExpression != nullptr);
     returnExpression->SetRange({startLoc, endLoc});
 
     return returnExpression;
@@ -1710,6 +1743,7 @@ ir::Expression *ParserImpl::SetupChainExpr(ir::Expression *const top, lexer::Sou
 
     lexer::SourcePosition endLoc = expr->End();
     auto chain = AllocNode<ir::ChainExpression>(expr);
+    ES2PANDA_ASSERT(chain != nullptr);
     chain->SetRange({startLoc, endLoc});
 
     if (expr == top) {
@@ -1758,6 +1792,7 @@ ir::Expression *ParserImpl::ParseMemberExpression(bool ignoreCallExpression, Exp
 
         returnExpression = AllocNode<ir::UpdateExpression>(returnExpression, lexer_->GetToken().Type(), false);
 
+        ES2PANDA_ASSERT(returnExpression != nullptr);
         returnExpression->SetRange({start, lexer_->GetToken().End()});
         lexer_->NextToken();
     }
@@ -1808,6 +1843,7 @@ ir::Expression *ParserImpl::ParsePatternElement(ExpressionParseFlags flags, bool
     ir::Expression *rightNode = ParseExpression();
     auto *assignmentExpression = AllocNode<ir::AssignmentExpression>(
         ir::AstNodeType::ASSIGNMENT_PATTERN, returnNode, rightNode, lexer::TokenType::PUNCTUATOR_SUBSTITUTION);
+    ES2PANDA_ASSERT(assignmentExpression != nullptr);
     assignmentExpression->SetRange({returnNode->Start(), rightNode->End()});
 
     return assignmentExpression;
@@ -1914,6 +1950,7 @@ ir::Property *ParserImpl::ParseShorthandProperty(const lexer::LexerPosition *sta
     const util::StringView &ident = lexer_->GetToken().Ident();
 
     auto *key = AllocNode<ir::Identifier>(ident, Allocator());
+    ES2PANDA_ASSERT(key != nullptr);
     key->SetRange(lexer_->GetToken().Loc());
 
     ir::Expression *value = AllocNode<ir::Identifier>(ident, Allocator());
@@ -1940,6 +1977,7 @@ ir::Property *ParserImpl::ParseShorthandProperty(const lexer::LexerPosition *sta
     }
 
     auto *returnProperty = AllocNode<ir::Property>(key, value);
+    ES2PANDA_ASSERT(returnProperty != nullptr);
     returnProperty->SetRange({start, end});
 
     return returnProperty;
@@ -2006,6 +2044,7 @@ ir::Expression *ParserImpl::ParsePropertyKey(ExpressionParseFlags flags)
         case lexer::TokenType::LITERAL_IDENT: {
             const util::StringView &ident = lexer_->GetToken().Ident();
             key = AllocNode<ir::Identifier>(ident, Allocator());
+            ES2PANDA_ASSERT(key != nullptr);
             key->SetRange(lexer_->GetToken().Loc());
             lexer_->NextToken();
             return key;
@@ -2013,6 +2052,7 @@ ir::Expression *ParserImpl::ParsePropertyKey(ExpressionParseFlags flags)
         case lexer::TokenType::LITERAL_STRING: {
             const util::StringView &string = lexer_->GetToken().String();
             key = AllocNode<ir::StringLiteral>(string);
+            ES2PANDA_ASSERT(key != nullptr);
             key->SetRange(lexer_->GetToken().Loc());
             lexer_->NextToken();
             return key;
@@ -2023,6 +2063,7 @@ ir::Expression *ParserImpl::ParsePropertyKey(ExpressionParseFlags flags)
             } else {
                 key = AllocNode<ir::NumberLiteral>(lexer_->GetToken().GetNumber());
             }
+            ES2PANDA_ASSERT(key != nullptr);
             key->SetRange(lexer_->GetToken().Loc());
             lexer_->NextToken();
             return key;
@@ -2093,6 +2134,7 @@ ir::Expression *ParserImpl::ParsePropertyValue(const ir::PropertyKind *propertyK
     size_t paramsSize = methodDefinitonNode->Params().size();
 
     auto *value = AllocNode<ir::FunctionExpression>(methodDefinitonNode);
+    ES2PANDA_ASSERT(value != nullptr);
     value->SetRange(methodDefinitonNode->Range());
 
     if (*propertyKind == ir::PropertyKind::SET && paramsSize != 1) {
@@ -2142,10 +2184,12 @@ ir::Expression *ParserImpl::ParsePropertyDefinition([[maybe_unused]] ExpressionP
     }
 
     ir::Expression *value = ParsePropertyValue(&propertyKind, &methodStatus, flags);
+    ES2PANDA_ASSERT(value != nullptr);
     lexer::SourcePosition end = value->End();
 
     auto *returnProperty =
         AllocNode<ir::Property>(propertyKind, key, value, methodStatus != ParserStatus::NO_OPTS, isComputed);
+    ES2PANDA_ASSERT(returnProperty != nullptr);
     returnProperty->SetRange({start, end});
 
     return returnProperty;
@@ -2221,6 +2265,7 @@ ir::ObjectExpression *ParserImpl::ParseObjectExpression(ExpressionParseFlags fla
     auto nodeType = inPattern ? ir::AstNodeType::OBJECT_PATTERN : ir::AstNodeType::OBJECT_EXPRESSION;
     auto *objectExpression =
         AllocNode<ir::ObjectExpression>(nodeType, Allocator(), std::move(properties), trailingComma);
+    ES2PANDA_ASSERT(objectExpression != nullptr);
     objectExpression->SetRange({start, lexer_->GetToken().End()});
     lexer_->NextToken();
 
@@ -2267,6 +2312,7 @@ ir::SequenceExpression *ParserImpl::ParseSequenceExpression(ir::Expression *star
 
     lexer::SourcePosition end = sequence.back()->End();
     auto *sequenceNode = AllocNode<ir::SequenceExpression>(std::move(sequence));
+    ES2PANDA_ASSERT(sequenceNode != nullptr);
     sequenceNode->SetRange({start, end});
 
     return sequenceNode;
@@ -2327,6 +2373,7 @@ ir::Expression *ParserImpl::ParseUnaryOrPrefixUpdateExpression(ExpressionParseFl
         returnExpr = AllocNode<ir::UnaryExpression>(argument, operatorType);
     }
 
+    ES2PANDA_ASSERT(returnExpr != nullptr);
     returnExpr->SetRange({start, end});
 
     return returnExpr;
@@ -2357,6 +2404,7 @@ ir::Expression *ParserImpl::ParseImportExpression()
         }
 
         auto *metaProperty = AllocNode<ir::MetaProperty>(ir::MetaProperty::MetaPropertyKind::IMPORT_META);
+        ES2PANDA_ASSERT(metaProperty != nullptr);
         metaProperty->SetRange({startLoc, endLoc});
 
         lexer_->NextToken();
@@ -2409,6 +2457,7 @@ ir::FunctionExpression *ParserImpl::ParseFunctionExpression(ParserStatus newStat
     functionNode->SetStart(startLoc);
 
     auto *funcExpr = AllocNode<ir::FunctionExpression>(ident, functionNode);
+    ES2PANDA_ASSERT(funcExpr != nullptr);
     funcExpr->SetRange(functionNode->Range());
 
     return funcExpr;
diff --git a/ets2panda/parser/expressionTSParser.cpp b/ets2panda/parser/expressionTSParser.cpp
index 0820dc473a97dacfd7230de1ff7682d4f3e461cb..f70bda7f153979394b85e242b16401f9794adbdc 100644
--- a/ets2panda/parser/expressionTSParser.cpp
+++ b/ets2panda/parser/expressionTSParser.cpp
@@ -137,6 +137,7 @@ ir::Expression *TSParser::ParsePotentialAsExpression(ir::Expression *expr)
 
     lexer::SourcePosition startLoc = expr->Start();
     auto *asExpr = AllocNode<ir::TSAsExpression>(expr, typeAnnotation, isConst);
+    ES2PANDA_ASSERT(asExpr != nullptr);
     asExpr->SetRange({startLoc, Lexer()->GetToken().End()});
 
     if (Lexer()->GetToken().KeywordType() == lexer::TokenType::KEYW_AS) {
@@ -169,6 +170,7 @@ ir::AnnotatedExpression *TSParser::ParsePatternElementGetReturnNode(ExpressionPa
         }
         case lexer::TokenType::LITERAL_IDENT: {
             ir::AnnotatedExpression *returnNode = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+            ES2PANDA_ASSERT(returnNode != nullptr);
 
             if (returnNode->AsIdentifier()->Decorators().empty()) {
                 returnNode->SetRange(Lexer()->GetToken().Loc());
@@ -340,6 +342,7 @@ ir::Expression *TSParser::ParseModuleReference()
         Lexer()->NextToken();  // eat ')'
     } else {
         result = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+        ES2PANDA_ASSERT(result != nullptr);
         result->SetRange(Lexer()->GetToken().Loc());
         Lexer()->NextToken();
 
@@ -357,6 +360,7 @@ ir::TSTypeReference *TSParser::ParseConstExpression()
     identRef->SetRange(Lexer()->GetToken().Loc());
 
     auto *typeReference = AllocNode<ir::TSTypeReference>(identRef, nullptr, Allocator());
+    ES2PANDA_ASSERT(typeReference != nullptr);
     typeReference->SetRange(Lexer()->GetToken().Loc());
 
     Lexer()->NextToken();
@@ -379,6 +383,7 @@ bool TSParser::ParsePotentialNonNullExpression(ir::Expression **returnExpression
     }
 
     *returnExpression = AllocNode<ir::TSNonNullExpression>(*returnExpression);
+    ES2PANDA_ASSERT(*returnExpression != nullptr);
     // NOLINTNEXTLINE(clang-analyzer-core.CallAndMessage)
     (*returnExpression)->SetRange({startLoc, Lexer()->GetToken().End()});
     Lexer()->NextToken();
@@ -436,6 +441,8 @@ private:
     }
 };
 
+// NOLINTNEXTLINE(readability-function-size)
+// CC-OFFNXT(huge_method[C++], G.FUN.01-CPP) solid logic
 ir::ArrowFunctionExpression *TSParser::ParsePotentialArrowExpression(ir::Expression **returnExpression,
                                                                      const lexer::SourcePosition &startLoc)
 {
@@ -444,6 +451,7 @@ ir::ArrowFunctionExpression *TSParser::ParsePotentialArrowExpression(ir::Express
     switch (Lexer()->GetToken().Type()) {
         case lexer::TokenType::KEYW_FUNCTION: {
             *returnExpression = ParseFunctionExpression(ParserStatus::ASYNC_FUNCTION);
+            ES2PANDA_ASSERT(*returnExpression != nullptr);
             (*returnExpression)->SetStart(startLoc);
             break;
         }
diff --git a/ets2panda/parser/parserImpl.cpp b/ets2panda/parser/parserImpl.cpp
index f483f4000832f9fa13b346c8e4bde49870dde417..af69614809ed4bbead1b6fcaa1ec276a3e0b2296 100644
--- a/ets2panda/parser/parserImpl.cpp
+++ b/ets2panda/parser/parserImpl.cpp
@@ -84,6 +84,7 @@ void ParserImpl::ParseProgram(ScriptKind kind)
     auto statements = ParseStatementList(StatementParsingFlags::STMT_GLOBAL_LEXICAL);
 
     auto *blockStmt = AllocNode<ir::BlockStatement>(Allocator(), std::move(statements));
+    ES2PANDA_ASSERT(blockStmt != nullptr);
     blockStmt->SetRange({startLoc, lexer_->GetToken().End()});
 
     program_->SetAst(blockStmt);
@@ -339,6 +340,7 @@ std::tuple<bool, bool, bool> ParserImpl::ParseComputedClassFieldOrIndexSignature
     return {true, false, false};
 }
 
+// CC-OFFNXT(huge_method[C++], G.FUN.01-CPP) solid logic
 ir::Expression *ParserImpl::ParseClassKey(ClassElementDescriptor *desc)
 {
     ir::Expression *propName = nullptr;
@@ -379,6 +381,7 @@ ir::Expression *ParserImpl::ParseClassKey(ClassElementDescriptor *desc)
             } else {
                 propName = AllocNode<ir::NumberLiteral>(lexer_->GetToken().GetNumber());
             }
+            ES2PANDA_ASSERT(propName != nullptr);
 
             propName->SetRange(lexer_->GetToken().Loc());
             break;
@@ -458,6 +461,7 @@ ir::MethodDefinition *ParserImpl::ParseClassMethod(ClassElementDescriptor *desc,
     ir::ScriptFunction *func = ParseFunction(desc->newStatus);
 
     auto *funcExpr = AllocNode<ir::FunctionExpression>(func);
+    ES2PANDA_ASSERT(funcExpr != nullptr);
     funcExpr->SetRange(func->Range());
 
     if (desc->methodKind == ir::MethodDefinitionKind::SET) {
@@ -483,6 +487,7 @@ ir::ClassElement *ParserImpl::ParseClassProperty(ClassElementDescriptor *desc,
                                                  const ArenaVector<ir::AstNode *> &properties, ir::Expression *propName,
                                                  ir::TypeNode *typeAnnotation)
 {
+    ES2PANDA_ASSERT(propName != nullptr);
     lexer::SourcePosition propEnd = propName->End();
     ir::ClassElement *property = nullptr;
 
@@ -590,6 +595,7 @@ ir::ClassElement *ParserImpl::ParseClassStaticBlock()
 
     auto *funcExpr = AllocNode<ir::FunctionExpression>(func);
     auto *staticBlock = AllocNode<ir::ClassStaticBlock>(funcExpr, Allocator());
+    ES2PANDA_ASSERT(staticBlock != nullptr);
     staticBlock->SetRange({startPos, lexer_->GetToken().End()});
 
     lexer_->NextToken();  // eat '}'
@@ -686,6 +692,7 @@ ir::MethodDefinition *ParserImpl::BuildImplicitConstructor(ir::ClassDefinitionMo
 
     auto *ctor = AllocNode<ir::MethodDefinition>(ir::MethodDefinitionKind::CONSTRUCTOR, key, funcExpr,
                                                  ir::ModifierFlags::CONSTRUCTOR, Allocator(), false);
+    ES2PANDA_ASSERT(ctor != nullptr);
 
     const auto rangeImplicitContstuctor = lexer::SourceRange(startLoc, startLoc);
     ctor->IterateRecursively(
@@ -705,7 +712,9 @@ void ParserImpl::CreateImplicitConstructor(ir::MethodDefinition *&ctor,
 
     ctor = BuildImplicitConstructor(modifiers, startLoc);
     if ((flags & ir::ModifierFlags::DECLARE) != 0) {
-        ctor->Function()->AddFlag(ir::ScriptFunctionFlags::EXTERNAL);
+        auto *ctorFunc = ctor->Function();
+        ES2PANDA_ASSERT(ctorFunc != nullptr);
+        ctorFunc->AddFlag(ir::ScriptFunctionFlags::EXTERNAL);
     }
 }
 
@@ -791,6 +800,7 @@ ir::ClassDefinition *ParserImpl::ParseClassDefinition(ir::ClassDefinitionModifie
     auto *classDefinition =
         AllocNode<ir::ClassDefinition>(identNode, nullptr, superTypeParams, std::move(implements), ctor, superClass,
                                        std::move(properties), modifiers, flags, GetContext().GetLanguage());
+    ES2PANDA_ASSERT(classDefinition != nullptr);
     classDefinition->SetInternalName(privateBinding.View());
 
     classDefinition->SetRange(bodyRange);
@@ -950,6 +960,7 @@ std::tuple<bool, ir::BlockStatement *, lexer::SourcePosition, bool> ParserImpl::
     }
 
     ir::BlockStatement *body = ParseBlockStatement();
+    ES2PANDA_ASSERT(body != nullptr);
 
     return {true, body, body->End(), false};
 }
@@ -1013,6 +1024,7 @@ ir::ScriptFunction *ParserImpl::ParseFunction(ParserStatus newStatus)
                                                 functionContext.Flags(),   // CC-OFFNXT(G.FMT.02-CPP) project code style
                                                 {},                        // CC-OFFNXT(G.FMT.02-CPP) project code style
                                                 context_.GetLanguage()});  // CC-OFF(G.FMT.02-CPP) project code style
+    ES2PANDA_ASSERT(funcNode != nullptr);
 
     funcNode->SetRange({startLoc, endLoc});
 
@@ -1042,6 +1054,7 @@ ir::SpreadElement *ParserImpl::ParseSpreadElement(ExpressionParseFlags flags)
 
     auto nodeType = inPattern ? ir::AstNodeType::REST_ELEMENT : ir::AstNodeType::SPREAD_ELEMENT;
     auto *spreadElementNode = AllocNode<ir::SpreadElement>(nodeType, Allocator(), argument);
+    ES2PANDA_ASSERT(spreadElementNode != nullptr);
     spreadElementNode->SetRange({startLocation, argument->End()});
     return spreadElementNode;
 }
@@ -1287,6 +1300,7 @@ ir::Identifier *ParserImpl::ExpectIdentifier([[maybe_unused]] bool isReference,
     }
 
     auto *ident = AllocNode<ir::Identifier>(tokenName, Allocator());
+    ES2PANDA_ASSERT(ident != nullptr);
     //  NOTE: here actual token can be changed!
     ident->SetRange({tokenStart, lexer_->GetToken().End()});
     lexer_->NextToken();
@@ -1462,6 +1476,7 @@ ir::Identifier *ParserImpl::AllocBrokenExpression(const lexer::SourcePosition &p
 ir::Identifier *ParserImpl::AllocBrokenExpression(const lexer::SourceRange &range)
 {
     auto *node = AllocNode<ir::Identifier>(Allocator());
+    ES2PANDA_ASSERT(node != nullptr);
     node->SetRange(range);
     return node;
 }
@@ -1474,6 +1489,7 @@ ir::TypeNode *ParserImpl::AllocBrokenType(const lexer::SourcePosition &pos)
 ir::TypeNode *ParserImpl::AllocBrokenType(const lexer::SourceRange &range)
 {
     auto node = AllocNode<ir::BrokenTypeNode>(Allocator());
+    ES2PANDA_ASSERT(node != nullptr);
     node->SetRange(range);
     return node;
 }
diff --git a/ets2panda/parser/program/program.cpp b/ets2panda/parser/program/program.cpp
index 1e1256896efcf39314515e3e351f435702eb9988..f3efae5f7bed396045c8b381689f558af6d10c25 100644
--- a/ets2panda/parser/program/program.cpp
+++ b/ets2panda/parser/program/program.cpp
@@ -33,7 +33,7 @@ Program::Program(ArenaAllocator *allocator, varbinder::VarBinder *varbinder)
     : allocator_(allocator),
       externalSources_(allocator_->Adapter()),
       directExternalSources_(allocator_->Adapter()),
-      extension_(varbinder->Extension()),
+      extension_(varbinder != nullptr ? varbinder->Extension() : ScriptExtension::INVALID),
       etsnolintCollection_(allocator_->Adapter()),
       cfg_(allocator_->New<compiler::CFG>(allocator_)),
       functionScopes_(allocator_->Adapter()),
@@ -132,6 +132,7 @@ void Program::SetPackageInfo(const util::StringView &name, util::ModuleKind kind
 // NOTE(vpukhov): part of ongoing design
 void Program::MaybeTransformToDeclarationModule()
 {
+    ES2PANDA_ASSERT(ast_ != nullptr);
     if (IsPackage() || ast_->Statements().empty()) {
         return;
     }
diff --git a/ets2panda/parser/statementParser.cpp b/ets2panda/parser/statementParser.cpp
index c4ff7e348a8549fe156fc6026befbd66c0bb683e..ecf5e63a7c800531b8a4d8a634ccf5b07117185b 100644
--- a/ets2panda/parser/statementParser.cpp
+++ b/ets2panda/parser/statementParser.cpp
@@ -230,6 +230,7 @@ ir::Statement *ParserImpl::ParseLetStatement(StatementParsingFlags flags)
     }
 
     auto *variableDecl = ParseVariableDeclaration(VariableParsingFlags::LET);
+    ES2PANDA_ASSERT(variableDecl != nullptr);
     if (variableDecl->IsBrokenStatement()) {  // Error processing.
         return variableDecl;
     }
@@ -248,6 +249,7 @@ ir::Statement *ParserImpl::ParseConstStatement(StatementParsingFlags flags)
     lexer_->NextToken();
 
     auto *variableDecl = ParseVariableDeclaration(VariableParsingFlags::CONST | VariableParsingFlags::NO_SKIP_VAR_KIND);
+    ES2PANDA_ASSERT(variableDecl != nullptr);
     if (variableDecl->IsBrokenStatement()) {  // Error processing.
         return variableDecl;
     }
@@ -261,6 +263,7 @@ ir::Statement *ParserImpl::ParseConstStatement(StatementParsingFlags flags)
 ir::EmptyStatement *ParserImpl::ParseEmptyStatement()
 {
     auto *empty = AllocNode<ir::EmptyStatement>();
+    ES2PANDA_ASSERT(empty != nullptr);
     empty->SetRange(lexer_->GetToken().Loc());
     lexer_->NextToken();
     return empty;
@@ -269,6 +272,7 @@ ir::EmptyStatement *ParserImpl::ParseEmptyStatement()
 ir::Statement *ParserImpl::ParseDebuggerStatement()
 {
     auto *debuggerNode = AllocNode<ir::DebuggerStatement>();
+    ES2PANDA_ASSERT(debuggerNode != nullptr);
     debuggerNode->SetRange(lexer_->GetToken().Loc());
     lexer_->NextToken();
     ConsumeSemicolon(debuggerNode);
@@ -288,6 +292,7 @@ ir::Statement *ParserImpl::ParseFunctionStatement(StatementParsingFlags flags)
     stmts.push_back(funcDecl);
 
     auto *localBlockStmt = AllocNode<ir::BlockStatement>(Allocator(), std::move(stmts));
+    ES2PANDA_ASSERT(localBlockStmt != nullptr);
     localBlockStmt->SetRange(funcDecl->Range());
 
     return funcDecl;
@@ -333,6 +338,7 @@ ir::Statement *ParserImpl::ParseStructDeclaration(ir::ClassDefinitionModifiers m
 
     lexer::SourcePosition endLoc = classDefinition->End();
     auto *structDecl = AllocNode<ir::ETSStructDeclaration>(classDefinition, Allocator());
+    ES2PANDA_ASSERT(structDecl != nullptr);
     structDecl->SetRange({startLoc, endLoc});
     return structDecl;
 }
@@ -353,6 +359,7 @@ ir::Statement *ParserImpl::ParseClassDeclaration(ir::ClassDefinitionModifiers mo
 
     lexer::SourcePosition endLoc = classDefinition->End();
     auto *classDecl = AllocNode<ir::ClassDeclaration>(classDefinition, Allocator());
+    ES2PANDA_ASSERT(classDecl != nullptr);
     classDecl->SetRange({startLoc, endLoc});
     return classDecl;
 }
@@ -379,6 +386,7 @@ void ParserImpl::ConsumeSemicolon(ir::Statement *statement)
     auto const &token = lexer_->GetToken();
     auto tokenType = token.Type();
     if (tokenType == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+        ES2PANDA_ASSERT(statement != nullptr);
         statement->SetEnd(token.End());
         lexer_->NextToken();
         return;
@@ -434,6 +442,7 @@ bool ParserImpl::ParseDirective(ArenaVector<ir::Statement *> *statements)
     bool isDirective = exprNode->IsStringLiteral();
 
     auto *exprStatement = AllocNode<ir::ExpressionStatement>(exprNode);
+    ES2PANDA_ASSERT(exprStatement != nullptr);
     exprStatement->SetRange(exprNode->Range());
 
     ConsumeSemicolon(exprStatement);
@@ -464,6 +473,7 @@ ir::BlockStatement *ParserImpl::ParseBlockStatement()
     auto statements = ParseStatementList();
 
     auto *blockNode = AllocNode<ir::BlockStatement>(Allocator(), std::move(statements));
+    ES2PANDA_ASSERT(blockNode != nullptr);
     blockNode->SetRange({startLoc, lexer_->GetToken().End()});
 
     ExpectToken(lexer::TokenType::PUNCTUATOR_RIGHT_BRACE);
@@ -495,6 +505,7 @@ ir::Statement *ParserImpl::ParseBreakStatement()
         }
 
         auto *breakStatement = AllocNode<ir::BreakStatement>();
+        ES2PANDA_ASSERT(breakStatement != nullptr);
         breakStatement->SetRange({startLoc, lexer_->GetToken().End()});
 
         if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
@@ -570,6 +581,7 @@ ir::Statement *ParserImpl::ParseContinueStatement()
     identNode->SetRange(lexer_->GetToken().Loc());
 
     auto *continueStatement = AllocNode<ir::ContinueStatement>(identNode);
+    ES2PANDA_ASSERT(continueStatement != nullptr);
     continueStatement->SetRange({startLoc, lexer_->GetToken().End()});
 
     lexer_->NextToken();
@@ -618,6 +630,7 @@ ir::Statement *ParserImpl::ParseDoWhileStatement()
     ExpectToken(lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS);
 
     auto *doWhileStatement = AllocNode<ir::DoWhileStatement>(body, condition);
+    ES2PANDA_ASSERT(doWhileStatement != nullptr);
     doWhileStatement->SetRange({startLoc, endLoc});
 
     if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
@@ -664,6 +677,7 @@ ir::FunctionDeclaration *ParserImpl::ParseFunctionDeclaration(bool canBeAnonymou
 
     newStatus |= ParserStatus::FUNCTION_DECLARATION;
     ir::ScriptFunction *func = ParseFunction(newStatus | ParserStatus::NEED_RETURN_TYPE);
+    ES2PANDA_ASSERT(func != nullptr);
 
     func->SetIdent(identNode);
     func->SetStart(startLoc);
@@ -726,6 +740,7 @@ ir::Statement *ParserImpl::ParseExpressionStatement(StatementParsingFlags flags)
     lexer::SourcePosition endPos = exprNode->End();
 
     auto *exprStatementNode = AllocNode<ir::ExpressionStatement>(exprNode);
+    ES2PANDA_ASSERT(exprStatementNode != nullptr);
     exprStatementNode->SetRange({startPos.GetToken().Start(), endPos});
     ConsumeSemicolon(exprStatementNode);
 
@@ -856,6 +871,7 @@ std::tuple<ForStatementKind, ir::AstNode *, ir::Expression *, ir::Expression *>
 
     ir::AstNode *initNode =
         lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA ? ParseSequenceExpression(expr) : expr;
+    ES2PANDA_ASSERT(initNode != nullptr);
 
     if (initNode->IsConditionalExpression()) {
         ir::ConditionalExpression *condExpr = initNode->AsConditionalExpression();
@@ -1008,6 +1024,7 @@ ir::Statement *ParserImpl::CreateForStatement(ForStatementNodes &&nodes, ForStat
         }
     }
 
+    ES2PANDA_ASSERT(forStatement != nullptr);
     forStatement->SetRange({startLoc, nodes.body->End()});
 
     return forStatement;
@@ -1085,6 +1102,7 @@ ir::Statement *ParserImpl::ParseIfStatement()
     }
 
     auto *ifStatement = AllocNode<ir::IfStatement>(test, consequent, alternate);
+    ES2PANDA_ASSERT(ifStatement != nullptr);
     ifStatement->SetRange({startLoc, endLoc});
     return ifStatement;
 }
@@ -1115,6 +1133,7 @@ ir::Statement *ParserImpl::ParseLabelledStatement(const lexer::LexerPosition &po
     ir::Statement *body = ParseStatement(StatementParsingFlags::LABELLED);
 
     auto *labeledStatement = AllocNode<ir::LabelledStatement>(identNode, body);
+    ES2PANDA_ASSERT(labeledStatement != nullptr);
     labeledStatement->SetRange({pos.GetToken().Start(), body->End()});
 
     return labeledStatement;
@@ -1154,6 +1173,7 @@ ir::Statement *ParserImpl::ParseReturnStatement()
         returnStatement = AllocNode<ir::ReturnStatement>();
     }
 
+    ES2PANDA_ASSERT(returnStatement != nullptr);
     returnStatement->SetRange({startLoc, endLoc});
     ConsumeSemicolon(returnStatement);
 
@@ -1209,6 +1229,7 @@ ir::SwitchCaseStatement *ParserImpl::ParseSwitchCaseStatement(bool *seenDefault)
     }
 
     auto *caseNode = AllocNode<ir::SwitchCaseStatement>(testExpr, std::move(consequents));
+    ES2PANDA_ASSERT(caseNode != nullptr);
     caseNode->SetRange({caseStartLoc, caseEndLoc});
     return caseNode;
 }
@@ -1240,6 +1261,7 @@ ir::Statement *ParserImpl::ParseSwitchStatement()
     ExpectToken(lexer::TokenType::PUNCTUATOR_RIGHT_BRACE);
 
     auto *switchStatement = AllocNode<ir::SwitchStatement>(discriminant, std::move(cases));
+    ES2PANDA_ASSERT(switchStatement != nullptr);
     switchStatement->SetRange({startLoc, endLoc});
     return switchStatement;
 }
@@ -1264,6 +1286,7 @@ ir::Statement *ParserImpl::ParseThrowStatement()
     lexer::SourcePosition endLoc = expression->End();
 
     auto *throwStatement = AllocNode<ir::ThrowStatement>(expression);
+    ES2PANDA_ASSERT(throwStatement != nullptr);
     throwStatement->SetRange({startLoc, endLoc});
     ConsumeSemicolon(throwStatement);
 
@@ -1318,6 +1341,7 @@ ir::CatchClause *ParserImpl::ParseCatchClause()
     lexer::SourcePosition endLoc = catchBlock->End();
 
     auto *catchClause = AllocNode<ir::CatchClause>(param, catchBlock);
+    ES2PANDA_ASSERT(catchClause != nullptr);
     catchClause->SetRange({catchStartLoc, endLoc});
 
     return catchClause;
@@ -1362,6 +1386,7 @@ ir::Statement *ParserImpl::ParseTryStatement()
         lexer_->NextToken();  // eat 'finally' keyword
 
         finallyClause = ParseBlockStatement();
+        ES2PANDA_ASSERT(finallyClause != nullptr);
         endLoc = finallyClause->End();
     }
 
@@ -1532,6 +1557,7 @@ ir::Statement *ParserImpl::ParseVariableDeclaration(VariableParsingFlags flags)
 
     lexer::SourcePosition endLoc = declarators.back()->End();
     auto *declaration = AllocNode<ir::VariableDeclaration>(varKind, Allocator(), std::move(declarators));
+    ES2PANDA_ASSERT(declaration != nullptr);
     declaration->SetRange({startLoc, endLoc});
 
     return declaration;
@@ -1559,6 +1585,7 @@ ir::Statement *ParserImpl::ParseWhileStatement()
 
     lexer::SourcePosition endLoc = body->End();
     auto *whileStatement = AllocNode<ir::WhileStatement>(condition, body);
+    ES2PANDA_ASSERT(whileStatement != nullptr);
     whileStatement->SetRange({startLoc, endLoc});
 
     return whileStatement;
@@ -1609,6 +1636,7 @@ ir::ExportDefaultDeclaration *ParserImpl::ParseExportDefaultDeclaration(const le
     ES2PANDA_ASSERT(declNode != nullptr);
     lexer::SourcePosition endLoc = declNode->End();
     auto *exportDeclaration = AllocNode<ir::ExportDefaultDeclaration>(declNode, isExportEquals);
+    ES2PANDA_ASSERT(exportDeclaration != nullptr);
     exportDeclaration->SetRange({startLoc, endLoc});
 
     if (eatSemicolon) {
@@ -1632,6 +1660,7 @@ ir::Identifier *ParserImpl::ParseNamedExport(lexer::Token *exportedToken)
     const util::StringView &exportedString = exportedToken->Ident();
 
     auto *exported = AllocNode<ir::Identifier>(exportedString, Allocator());
+    ES2PANDA_ASSERT(exported != nullptr);
     exported->SetRange(exportedToken->Loc());
 
     return exported;
@@ -1649,9 +1678,11 @@ ir::ExportAllDeclaration *ParserImpl::ParseExportAllDeclaration(const lexer::Sou
         lexer_->NextToken();  // eat exported name
     }
     ir::StringLiteral *source = ParseFromClause();
+    ES2PANDA_ASSERT(source != nullptr);
     lexer::SourcePosition endLoc = source->End();
 
     auto *exportDeclaration = AllocNode<ir::ExportAllDeclaration>(source, exported);
+    ES2PANDA_ASSERT(exportDeclaration != nullptr);
     exportDeclaration->SetRange({startLoc, endLoc});
 
     ConsumeSemicolon(exportDeclaration);
@@ -1706,6 +1737,7 @@ ir::ExportNamedDeclaration *ParserImpl::ParseExportNamedSpecifiers(const lexer::
     }
 
     auto *exportDeclaration = AllocNode<ir::ExportNamedDeclaration>(Allocator(), source, std::move(specifiers));
+    ES2PANDA_ASSERT(exportDeclaration != nullptr);
     exportDeclaration->SetRange({startLoc, endPos});
     ConsumeSemicolon(exportDeclaration);
 
@@ -1760,6 +1792,7 @@ ir::Statement *ParserImpl::ParseNamedExportDeclaration(const lexer::SourcePositi
     lexer::SourcePosition endLoc = decl->End();
     ArenaVector<ir::ExportSpecifier *> specifiers(Allocator()->Adapter());
     auto *exportDeclaration = AllocNode<ir::ExportNamedDeclaration>(Allocator(), decl, std::move(specifiers));
+    ES2PANDA_ASSERT(exportDeclaration != nullptr);
     exportDeclaration->SetRange({startLoc, endLoc});
 
     return exportDeclaration;
@@ -1808,6 +1841,7 @@ void ParserImpl::ParseNameSpaceImport(ArenaVector<ir::AstNode *> *specifiers)
     ir::Identifier *local = ParseNamedImport(&lexer_->GetToken());
 
     auto *specifier = AllocNode<ir::ImportNamespaceSpecifier>(local);
+    ES2PANDA_ASSERT(specifier != nullptr);
     specifier->SetRange({namespaceStart, lexer_->GetToken().End()});
     specifiers->push_back(specifier);
 
@@ -1825,6 +1859,7 @@ ir::Identifier *ParserImpl::ParseNamedImport(lexer::Token *importedToken)
     CheckRestrictedBinding(importedToken->KeywordType());
 
     auto *local = AllocNode<ir::Identifier>(importedToken->Ident(), Allocator());
+    ES2PANDA_ASSERT(local != nullptr);
     local->SetRange(importedToken->Loc());
 
     return local;
@@ -1871,6 +1906,7 @@ ir::AstNode *ParserImpl::ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *>
     lexer_->NextToken();  // eat local name
 
     auto *specifier = AllocNode<ir::ImportDefaultSpecifier>(local);
+    ES2PANDA_ASSERT(specifier != nullptr);
     specifier->SetRange(specifier->Local()->Range());
     specifiers->push_back(specifier);
 
@@ -1903,6 +1939,7 @@ ir::StringLiteral *ParserImpl::ParseFromClause(bool requireFrom)
     }
 
     auto *source = AllocNode<ir::StringLiteral>(lexer_->GetToken().String());
+    ES2PANDA_ASSERT(source != nullptr);
     source->SetRange(lexer_->GetToken().Loc());
 
     lexer_->NextToken();
@@ -1961,6 +1998,7 @@ ir::Statement *ParserImpl::ParseImportDeclaration(StatementParsingFlags flags)
 
     lexer::SourcePosition endLoc = source->End();
     auto *importDeclaration = AllocNode<ir::ImportDeclaration>(source, std::move(specifiers));
+    ES2PANDA_ASSERT(importDeclaration != nullptr);
     importDeclaration->SetRange({startLoc, endLoc});
 
     ConsumeSemicolon(importDeclaration);
@@ -1976,6 +2014,7 @@ ir::Statement *ParserImpl::AllocBrokenStatement(const lexer::SourcePosition &pos
 ir::Statement *ParserImpl::AllocBrokenStatement(const lexer::SourceRange &range)
 {
     auto *broken = AllocNode<ir::EmptyStatement>(true);
+    ES2PANDA_ASSERT(broken != nullptr);
     broken->SetRange(range);
     return broken;
 }
@@ -1991,6 +2030,7 @@ bool ParserImpl::IsBrokenStatement(ir::Statement *st)
 ir::Statement *ParserImpl::AllocEmptyStatement()
 {
     auto *empty = AllocNode<ir::EmptyStatement>();
+    ES2PANDA_ASSERT(empty != nullptr);
     empty->SetRange(lexer_->GetToken().Loc());
     return empty;
 }
diff --git a/ets2panda/parser/statementTSParser.cpp b/ets2panda/parser/statementTSParser.cpp
index 34dce05dc1519e8d5a8204a63f683bc81d4011f4..4cd60c24dbdc8d586dd6fa076ea8788d47759f75 100644
--- a/ets2panda/parser/statementTSParser.cpp
+++ b/ets2panda/parser/statementTSParser.cpp
@@ -131,6 +131,7 @@ ir::TSImportEqualsDeclaration *TSParser::ParseTsImportEqualsDeclaration(const le
     }
 
     auto *id = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+    ES2PANDA_ASSERT(id != nullptr);
     id->SetRange(Lexer()->GetToken().Loc());
     Lexer()->NextToken();  // eat id name
 
@@ -190,6 +191,7 @@ ir::ExportDefaultDeclaration *TSParser::ParseExportDefaultDeclaration(const lexe
 
     lexer::SourcePosition endLoc = declNode->End();
     auto *exportDeclaration = AllocNode<ir::ExportDefaultDeclaration>(declNode, isExportEquals);
+    ES2PANDA_ASSERT(exportDeclaration != nullptr);
     exportDeclaration->SetRange({startLoc, endLoc});
 
     if (eatSemicolon) {
@@ -265,6 +267,7 @@ ir::Statement *TSParser::ParseNamedExportDeclaration(const lexer::SourcePosition
     lexer::SourcePosition endLoc = decl->End();
     ArenaVector<ir::ExportSpecifier *> specifiers(Allocator()->Adapter());
     auto *exportDeclaration = AllocNode<ir::ExportNamedDeclaration>(Allocator(), decl, std::move(specifiers));
+    ES2PANDA_ASSERT(exportDeclaration != nullptr);
     exportDeclaration->SetRange({startLoc, endLoc});
 
     return exportDeclaration;
@@ -293,6 +296,7 @@ ir::Statement *TSParser::ParseExportDeclaration(StatementParsingFlags flags)
         }
         default: {
             auto ret = ParseNamedExportDeclaration(startLoc);
+            ES2PANDA_ASSERT(ret != nullptr);
             if (ret->IsBrokenStatement()) {
                 return ret;
             }
@@ -322,6 +326,7 @@ ir::Statement *TSParser::ParseConstStatement(StatementParsingFlags flags)
     }
 
     auto *variableDecl = ParseVariableDeclaration(VariableParsingFlags::CONST | VariableParsingFlags::NO_SKIP_VAR_KIND);
+    ES2PANDA_ASSERT(variableDecl != nullptr);
     variableDecl->SetStart(constVarStar);
     ConsumeSemicolon(variableDecl);
 
@@ -364,6 +369,7 @@ ir::Statement *TSParser::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));
     importDeclaration->SetRange({startLoc, endLoc});