diff --git a/ets2panda/checker/ETSAnalyzer.cpp b/ets2panda/checker/ETSAnalyzer.cpp
index 4748735b14712406ac39fcfd00a2bbfc502f3660..fb821fb4234a73c0da8265c605e9483d159ab473 100644
--- a/ets2panda/checker/ETSAnalyzer.cpp
+++ b/ets2panda/checker/ETSAnalyzer.cpp
@@ -462,6 +462,7 @@ checker::Type *ETSAnalyzer::Check(ir::ETSFunctionType *node) const
     checker->CheckFunctionSignatureAnnotations(node->Params(), node->TypeParams(), node->ReturnType());
 
     auto *signatureInfo = checker->ComposeSignatureInfo(node->TypeParams(), node->Params());
+    ES2PANDA_ASSERT(signatureInfo != nullptr);
     auto *returnType = node->IsExtensionFunction() && node->ReturnType()->IsTSThisType()
                            ? signatureInfo->params.front()->TsType()
                            : checker->ComposeReturnType(node->ReturnType(), node->IsAsync());
@@ -1863,6 +1864,7 @@ checker::Type *ETSAnalyzer::Check(ir::Identifier *expr) const
     }
 
     expr->SetTsType(identType);
+    ES2PANDA_ASSERT(identType != nullptr);
     if (!identType->IsTypeError()) {
         checker->Context().CheckIdentifierSmartCastCondition(expr);
     }
@@ -1977,6 +1979,7 @@ checker::Type *ETSAnalyzer::Check(ir::MemberExpression *expr) const
     auto *baseType = checker->GetNonConstantType(checker->GetApparentType(expr->Object()->Check(checker)));
     //  Note: don't use possible smart cast to null-like types.
     //        Such situation should be correctly resolved in the subsequent lowering.
+    ES2PANDA_ASSERT(baseType != nullptr);
     if (baseType->DefinitelyETSNullish() && expr->Object()->IsIdentifier()) {
         baseType = expr->Object()->AsIdentifier()->Variable()->TsType();
     }
@@ -2678,6 +2681,7 @@ static checker::Type *ComputeTypeOfType(ETSChecker *checker, checker::Type *argT
 {
     checker::Type *ret = nullptr;
     ArenaVector<checker::Type *> types(checker->ProgramAllocator()->Adapter());
+    ES2PANDA_ASSERT(argType != nullptr);
     if (argType->IsETSUnionType()) {
         for (auto *it : argType->AsETSUnionType()->ConstituentTypes()) {
             checker::Type *elType = ComputeTypeOfType(checker, it);
@@ -2719,6 +2723,7 @@ checker::Type *ETSAnalyzer::Check(ir::UnaryExpression *expr) const
                 checker::Type *type = checker->CreateETSBigIntLiteralType(argType->AsETSBigIntType()->GetValue());
 
                 // We do not need this const anymore as we are negating the bigint object in runtime
+                ES2PANDA_ASSERT(type != nullptr);
                 type->RemoveTypeFlag(checker::TypeFlag::CONSTANT);
                 expr->argument_->SetTsType(type);
                 expr->SetTsType(type);
@@ -3114,6 +3119,7 @@ checker::Type *ETSAnalyzer::Check(ir::AnnotationUsage *st) const
     ArenaUnorderedMap<util::StringView, ir::ClassProperty *> fieldMap {checker->ProgramAllocator()->Adapter()};
     for (auto *it : annoDecl->Properties()) {
         auto *field = it->AsClassProperty();
+        ES2PANDA_ASSERT(field->Id() != nullptr);
         fieldMap.insert(std::make_pair(field->Id()->Name(), field));
     }
 
@@ -3701,6 +3707,7 @@ checker::Type *ETSAnalyzer::Check(ir::TSAsExpression *expr) const
 
     checker->CheckAnnotations(expr->TypeAnnotation()->Annotations());
     auto *const targetType = expr->TypeAnnotation()->AsTypeNode()->GetType(checker);
+    ES2PANDA_ASSERT(targetType != nullptr);
     if (targetType->IsTypeError()) {
         return checker->InvalidateType(expr);
     }
diff --git a/ets2panda/checker/ETSchecker.cpp b/ets2panda/checker/ETSchecker.cpp
index d63dcd1f115ce06087e78d98a04ea7097d03f476..f04eba7c2b6b7bcfbb36bc65635c4c26333ccc5a 100644
--- a/ets2panda/checker/ETSchecker.cpp
+++ b/ets2panda/checker/ETSchecker.cpp
@@ -433,6 +433,7 @@ bool ETSChecker::IsClassStaticMethod(checker::ETSObjectType *objType, checker::S
                                      TypeFlag::ETS_STRING_ENUM | TypeFlag::READONLY | TypeFlag::BIGINT_LITERAL |
                                      TypeFlag::ETS_TYPE_ALIAS | TypeFlag::TYPE_ERROR;
 
+    CHECK_NOT_NULL(type);
     auto res = static_cast<checker::TypeFlag>(type->TypeFlags() & ~(TO_CLEAR));
     ES2PANDA_ASSERT_POS(res == TypeFlag::NONE || helpers::math::IsPowerOfTwo(res & ~(TypeFlag::NONE)),
                         ark::es2panda::GetPositionForDiagnostic());
diff --git a/ets2panda/checker/TSAnalyzer.cpp b/ets2panda/checker/TSAnalyzer.cpp
index 44d5a3d824525e69a8147a6a8d9e201a9fc4ca03..655c154d5f62250d0c9fb34c1864a88a80a7bb09 100644
--- a/ets2panda/checker/TSAnalyzer.cpp
+++ b/ets2panda/checker/TSAnalyzer.cpp
@@ -802,7 +802,7 @@ void TSAnalyzer::CheckNonComputed(checker::ObjectDescriptor *desc, ir::Expressio
     if (prop->Key()->IsNumberLiteral()) {
         memberVar->AddFlag(varbinder::VariableFlags::NUMERIC_NAME);
     }
-
+    ES2PANDA_ASSERT(desc != nullptr);
     varbinder::LocalVariable *foundMember = desc->FindProperty(propName);
     allPropertiesMap.insert({propName, it->Start()});
 
@@ -1740,6 +1740,7 @@ static void AddEnumValueDeclaration(checker::TSChecker *checker, double number,
         enumScope->AddDecl(checker->Allocator(), decl, ScriptExtension::TS);
         res = enumScope->FindLocal(memberStr, varbinder::ResolveBindingOptions::BINDINGS);
         ES2PANDA_ASSERT(res && res->IsEnumVariable());
+        ES2PANDA_ASSERT(enumVar != nullptr);
         enumVar = res->AsEnumVariable();
         enumVar->AsEnumVariable()->SetBackReference();
         enumVar->SetTsType(checker->GlobalStringType());
@@ -1747,6 +1748,7 @@ static void AddEnumValueDeclaration(checker::TSChecker *checker, double number,
         ES2PANDA_ASSERT(res->IsEnumVariable());
         enumVar = res->AsEnumVariable();
         auto *decl = checker->Allocator()->New<varbinder::EnumDecl>(memberStr);
+        ES2PANDA_ASSERT(decl != nullptr);
         decl->BindNode(variable->Declaration()->Node());
         enumVar->ResetDecl(decl);
     }
diff --git a/ets2panda/checker/ets/aliveAnalyzer.cpp b/ets2panda/checker/ets/aliveAnalyzer.cpp
index 13abe6b9ca76eb040ad9d23fb9dc050246f31104..e4edb04a7a1eadcccc752a94d25838480119604d 100644
--- a/ets2panda/checker/ets/aliveAnalyzer.cpp
+++ b/ets2panda/checker/ets/aliveAnalyzer.cpp
@@ -243,7 +243,9 @@ void AliveAnalyzer::AnalyzeMethodDef(const ir::MethodDefinition *methodDef)
     status_ = LivenessStatus::ALIVE;
     AnalyzeStat(func->Body());
     ES2PANDA_ASSERT(methodDef->TsType() && methodDef->TsType()->IsETSFunctionType());
-    const auto *returnType = methodDef->TsType()->AsETSFunctionType()->FindSignature(func)->ReturnType();
+    const auto *signature = methodDef->TsType()->AsETSFunctionType()->FindSignature(func);
+    ES2PANDA_ASSERT(signature != nullptr);
+    const auto *returnType = signature->ReturnType();
     const auto isVoid = returnType->IsETSVoidType() || returnType == checker_->GlobalVoidType();
 
     auto isPromiseVoid = false;
diff --git a/ets2panda/checker/ets/function.cpp b/ets2panda/checker/ets/function.cpp
index b10a5e7edbf30a99907595fac61122e3559db908..fd2d36b35fd451063f215c921ccb2d27627c3726 100644
--- a/ets2panda/checker/ets/function.cpp
+++ b/ets2panda/checker/ets/function.cpp
@@ -1647,6 +1647,7 @@ SignatureInfo *ETSChecker::ComposeSignatureInfo(ir::TSTypeParameterDeclaration *
                 ES2PANDA_ASSERT(IsAnyError());  // #23134
                 return nullptr;
             }
+            ES2PANDA_ASSERT(restParamType != nullptr);
             if (!restParamType->IsETSTupleType() && !restParamType->IsETSArrayType() &&
                 !restParamType->IsETSResizableArrayType()) {
                 LogError(diagnostic::ONLY_ARRAY_OR_TUPLE_FOR_REST, {}, param->Start());
diff --git a/ets2panda/checker/ets/helpers.cpp b/ets2panda/checker/ets/helpers.cpp
index 095b9f0503e36efd4eabfe0252c84ded480c63d2..306176bcb8292c41e03d1ff68199dbb31fcc1717 100644
--- a/ets2panda/checker/ets/helpers.cpp
+++ b/ets2panda/checker/ets/helpers.cpp
@@ -626,6 +626,7 @@ void ETSChecker::InferAliasLambdaType(ir::TypeNode *localTypeAnnotation, ir::Arr
 checker::Type *ETSChecker::FixOptionalVariableType(varbinder::Variable *const bindingVar, ir::ModifierFlags flags)
 {
     if ((flags & ir::ModifierFlags::OPTIONAL) != 0) {
+        ES2PANDA_ASSERT(bindingVar != nullptr);
         auto *variableType = bindingVar->TsType() != nullptr ? bindingVar->TsType() : GlobalTypeError();
         bindingVar->SetTsType(
             !variableType->IsTypeError() ? CreateETSUnionType({GlobalETSUndefinedType(), variableType}) : variableType);
diff --git a/ets2panda/checker/ets/utilityTypeHandlers.cpp b/ets2panda/checker/ets/utilityTypeHandlers.cpp
index 076bdb34bd08c8caf9ac3258f87e77f9533311fb..6341a07915301bb57b18aec8fe648f1f1b01d5b0 100644
--- a/ets2panda/checker/ets/utilityTypeHandlers.cpp
+++ b/ets2panda/checker/ets/utilityTypeHandlers.cpp
@@ -249,10 +249,11 @@ ir::ClassProperty *ETSChecker::CreateNullishPropertyFromAccessor(ir::MethodDefin
     auto *prop =
         // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
         ProgramAllocator()->New<ir::ClassProperty>(ident, nullptr, nullptr, modifierFlag, ProgramAllocator(), false);
-
+    ES2PANDA_ASSERT(prop != nullptr);
     prop->SetParent(newClassDefinition);
     ident->SetParent(prop);
 
+    ES2PANDA_ASSERT(accessor->Function() != nullptr);
     prop->SetTypeAnnotation(accessor->Function()->IsGetter()
                                 ? accessor->Function()->ReturnTypeAnnotation()
                                 : accessor->Function()->Params()[0]->AsETSParameterExpression()->TypeAnnotation());
@@ -268,6 +269,7 @@ ir::ClassProperty *ETSChecker::CreateNullishPropertyFromAccessor(ir::MethodDefin
 
     auto callSign = accessor->TsType()->AsETSFunctionType()->CallSignatures()[0];
 
+    ES2PANDA_ASSERT(accessor->Function() != nullptr);
     auto tsType = accessor->Function()->IsGetter() ? callSign->ReturnType() : callSign->Params()[0]->TsType();
 
     // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
diff --git a/ets2panda/checker/ts/destructuringContext.cpp b/ets2panda/checker/ts/destructuringContext.cpp
index 62212a8fcac53a0723d372e7ae9608ebbcab3005..b3f516e2b8800af19064d364d879d5e4c8a8ce20 100644
--- a/ets2panda/checker/ts/destructuringContext.cpp
+++ b/ets2panda/checker/ts/destructuringContext.cpp
@@ -332,6 +332,7 @@ Type *ArrayDestructuringContext::CreateTupleTypeForRest(TupleType *tuple)
         ES2PANDA_ASSERT(memberVar != nullptr);
         memberVar->SetTsType(tupleElementType);
         elementFlags.push_back(memberFlag);
+        ES2PANDA_ASSERT(desc != nullptr);
         desc->properties.push_back(memberVar);
 
         index_++;
diff --git a/ets2panda/checker/types/ets/etsAnyType.cpp b/ets2panda/checker/types/ets/etsAnyType.cpp
index 8f36fb2b2123613809dc8f798044a89eebd61803..ea399276063cd735fb696ab45e416260bd38d9f9 100644
--- a/ets2panda/checker/types/ets/etsAnyType.cpp
+++ b/ets2panda/checker/types/ets/etsAnyType.cpp
@@ -14,6 +14,7 @@
  */
 
 #include "etsAnyType.h"
+#include <cstddef>
 
 #include "checker/ETSchecker.h"
 #include "checker/ets/conversion.h"
@@ -62,6 +63,7 @@ void ETSAnyType::Cast(TypeRelation *relation, Type *target)
 
     if (relation->ApplyUnboxing()) {
         auto *const boxedTarget = relation->GetChecker()->AsETSChecker()->MaybeBoxInRelation(target);
+        ES2PANDA_ASSERT(boxedTarget != nullptr);
         conversion::Unboxing(relation, boxedTarget->AsETSObjectType());
         relation->Result(true);
     }
diff --git a/ets2panda/checker/types/typeRelation.cpp b/ets2panda/checker/types/typeRelation.cpp
index d6de75572207b5695a3c3cba510f209f23562674..67ba7f0312f8b46bccae7e90d3241842d4ee5883 100644
--- a/ets2panda/checker/types/typeRelation.cpp
+++ b/ets2panda/checker/types/typeRelation.cpp
@@ -161,6 +161,7 @@ bool TypeRelation::IsComparableTo(Type *source, Type *target)
 
         result_ = RelationResult::FALSE;
         target->Compare(this, source);
+        ES2PANDA_ASSERT(source != nullptr);
         auto key = RelationHolder::MakeKey(source->Id(), target->Id());
         checker_->ComparableResults().Insert(key, {result_, RelationType::COMPARABLE});
     }
diff --git a/ets2panda/compiler/core/ETSGen.cpp b/ets2panda/compiler/core/ETSGen.cpp
index ff54d72f975078fcf116ca670ad2aae73e73232d..5b08e72fe6e600776d6686a52e1bd0f32e7d4ef2 100644
--- a/ets2panda/compiler/core/ETSGen.cpp
+++ b/ets2panda/compiler/core/ETSGen.cpp
@@ -675,6 +675,7 @@ void ETSGen::BranchIfIsInstance(const ir::AstNode *const node, const VReg srcReg
 void ETSGen::IsInstance(const ir::AstNode *const node, const VReg srcReg, const checker::Type *target)
 {
     target = Checker()->GetApparentType(target);
+    ES2PANDA_ASSERT(target != nullptr);
     ES2PANDA_ASSERT(target->IsETSReferenceType() && GetAccumulatorType() != nullptr);
 
     if (target->IsETSAnyType()) {  // should be IsSupertypeOf(target, source)
@@ -725,6 +726,7 @@ void ETSGen::InternalCheckCast(const ir::AstNode *node, const es2panda::checker:
 // Handle checkcast for interop if it is 1.2 type.
 void ETSGen::EmitAnyCheckCast(const ir::AstNode *node, const checker::Type *target)
 {
+    ES2PANDA_ASSERT(target != nullptr);
     if (!target->IsETSAnyType() &&
         (target->IsETSObjectType() || target->IsETSArrayType() || target->IsETSTupleType())) {
         InternalCheckCast(node, target);
@@ -779,6 +781,7 @@ void ETSGen::CheckedReferenceNarrowing(const ir::AstNode *node, const checker::T
     }
 
     target = Checker()->GetApparentType(target);
+    ES2PANDA_ASSERT(target != nullptr);
     ES2PANDA_ASSERT(target->IsETSReferenceType());
 
     if (target->IsETSAnyType()) {  // should be IsSupertypeOf(target, source)
@@ -815,6 +818,7 @@ void ETSGen::GuardUncheckedType(const ir::AstNode *node, const checker::Type *un
         CheckedReferenceNarrowing(node, Checker()->MaybeBoxType(target));
         // Because on previous step accumulator type may be set in CheckerReferenceNarrowing to boxed counterpart of
         // target We need to apply unbox conversion if needed to avoid RTE
+        ES2PANDA_ASSERT(GetAccumulatorType() != nullptr);
         if (target->IsETSPrimitiveType() && GetAccumulatorType()->IsETSUnboxableObject()) {
             ApplyConversion(node, target);
         }
@@ -1288,6 +1292,7 @@ void ETSGen::CastToInt(const ir::AstNode *node)
 
 void ETSGen::CastToReftype(const ir::AstNode *const node, const checker::Type *const targetType, const bool unchecked)
 {
+    ES2PANDA_ASSERT(GetAccumulatorType() != nullptr);
     ES2PANDA_ASSERT(GetAccumulatorType()->IsETSReferenceType());
 
     if (!unchecked) {
diff --git a/ets2panda/parser/ASparser.cpp b/ets2panda/parser/ASparser.cpp
index f2567fef3d343350723a2e1b2eda79099eca4d4e..2e0e102951fd5e5354e778737b6ed345fbad31bc 100644
--- a/ets2panda/parser/ASparser.cpp
+++ b/ets2panda/parser/ASparser.cpp
@@ -1122,6 +1122,7 @@ ArenaVector<ir::TSClassImplements *> ASParser::ParseClassImplementClause()
 
         const lexer::SourcePosition &implementStart = Lexer()->GetToken().Start();
         auto *implementsName = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+        ES2PANDA_ASSERT(implementsName != nullptr);
         implementsName->SetRange(Lexer()->GetToken().Loc());
         auto *implementsClause = AllocNode<ir::NamedType>(implementsName, Allocator());
         ES2PANDA_ASSERT(implementsClause != nullptr);
@@ -1137,6 +1138,7 @@ ArenaVector<ir::TSClassImplements *> ASParser::ParseClassImplementClause()
             }
 
             implementsName = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+            ES2PANDA_ASSERT(implementsName != nullptr);
             implementsName->SetRange(Lexer()->GetToken().Loc());
             auto *next = AllocNode<ir::NamedType>(implementsName, Allocator());
             current->SetRange(Lexer()->GetToken().Loc());
@@ -1740,6 +1742,7 @@ ir::Statement *ASParser::ParseImportDeclaration([[maybe_unused]] StatementParsin
         source = ParseFromClause(false);
     }
 
+    ES2PANDA_ASSERT(source != nullptr);
     lexer::SourcePosition endLoc = source->End();
     auto *importDeclaration = AllocNode<ir::ImportDeclaration>(source, std::move(specifiers));
     ES2PANDA_ASSERT(importDeclaration != nullptr);
diff --git a/ets2panda/parser/ETSparser.cpp b/ets2panda/parser/ETSparser.cpp
index 5541ac57d5cccf3e8bd73bceeebf9e07e9ab73a1..aa641b56fdc5980aa8dee15123d6fb63b3fe6b39 100644
--- a/ets2panda/parser/ETSparser.cpp
+++ b/ets2panda/parser/ETSparser.cpp
@@ -1027,6 +1027,7 @@ ir::TypeNode *ETSParser::ParseTypeReference(TypeAnnotationParsingOptions *option
         }
 
         typeRefPart = AllocNode<ir::ETSTypeReferencePart>(typeName, typeParams, typeRefPart, Allocator());
+        ES2PANDA_ASSERT(typeRefPart != nullptr);
         typeRefPart->SetRange({partPos, Lexer()->GetToken().End()});
 
         if (!Lexer()->TryEatTokenType(lexer::TokenType::PUNCTUATOR_PERIOD)) {
@@ -1119,6 +1120,7 @@ ir::Statement *ETSParser::CreateReExportDeclarationNode(ir::ETSImportDeclaration
     }
     auto reExport = AllocNode<ir::ETSReExportDeclaration>(reExportDeclaration, std::vector<std::string>(),
                                                           GetProgram()->AbsoluteName(), Allocator());
+    ES2PANDA_ASSERT(reExport != nullptr);
     reExport->AddModifier(modifiers);
     return reExport;
 }
@@ -1223,6 +1225,7 @@ ir::ETSImportDeclaration *ETSParser::ParseImportPathBuildImport(ArenaVector<ir::
         LogExpectedToken(lexer::TokenType::LITERAL_STRING);
         // Try to create DUMMY import source as error placeholder
         auto errorLiteral = AllocNode<ir::StringLiteral>(ERROR_LITERAL);
+        ES2PANDA_ASSERT(errorLiteral != nullptr);
         errorLiteral->SetRange(Lexer()->GetToken().Loc());
         auto *const importDeclaration = AllocNode<ir::ETSImportDeclaration>(
             errorLiteral, util::ImportPathManager::ImportMetadata {}, std::move(specifiers), importKind);
@@ -1312,6 +1315,7 @@ ArenaVector<ir::ETSImportDeclaration *> ETSParser::ParseImportDeclarations()
         auto pos = Lexer()->Save();
         if (!specifiers.empty()) {
             auto *const importDecl = ParseImportPathBuildImport(std::move(specifiers), true, startLoc, importKind);
+            ES2PANDA_ASSERT(importDecl != nullptr);
             statements.push_back(importDecl->AsETSImportDeclaration());
         }
 
@@ -1605,6 +1609,7 @@ ir::AnnotatedExpression *ETSParser::GetAnnotatedExpressionFromParam()
     switch (Lexer()->GetToken().Type()) {
         case lexer::TokenType::LITERAL_IDENT: {
             parameter = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+            ES2PANDA_ASSERT(parameter != nullptr);
             if (parameter->AsIdentifier()->Decorators().empty()) {
                 parameter->SetRange(Lexer()->GetToken().Loc());
             } else {
@@ -1627,6 +1632,7 @@ ir::AnnotatedExpression *ETSParser::GetAnnotatedExpressionFromParam()
             restIdent->SetRange(Lexer()->GetToken().Loc());
 
             parameter = AllocNode<ir::SpreadElement>(ir::AstNodeType::REST_ELEMENT, Allocator(), restIdent);
+            ES2PANDA_ASSERT(parameter != nullptr);
             parameter->SetRange({startLoc, Lexer()->GetToken().End()});
             break;
         }
@@ -2322,6 +2328,7 @@ ir::FunctionDeclaration *ETSParser::ParseFunctionDeclaration(bool canBeAnonymous
         Lexer()->NextToken();
     }
 
+    ES2PANDA_ASSERT(funcDecl != nullptr);
     funcDecl->SetRange(func->Range());
     func->AddModifier(modifiers);
     func->SetStart(startLoc);
diff --git a/ets2panda/parser/ETSparserAnnotations.cpp b/ets2panda/parser/ETSparserAnnotations.cpp
index 218b519d199fa6a4d8a9327246ff00aacc7cb6f8..cdf4dfb5d05b408c149bf73bba8ab6c6bf43c8ec 100644
--- a/ets2panda/parser/ETSparserAnnotations.cpp
+++ b/ets2panda/parser/ETSparserAnnotations.cpp
@@ -392,6 +392,7 @@ ir::AnnotationUsage *ETSParser::ParseAnnotationUsage()
         } else if (Lexer()->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
             // handle single field annotation
             auto *singleParamName = AllocNode<ir::Identifier>(compiler::Signatures::ANNOTATION_KEY_VALUE, Allocator());
+            ES2PANDA_ASSERT(singleParamName != nullptr);
             singleParamName->SetRange({Lexer()->GetToken().Start(), Lexer()->GetToken().End()});
 
             const auto savePos = Lexer()->GetToken().Start();
diff --git a/ets2panda/parser/ETSparserClasses.cpp b/ets2panda/parser/ETSparserClasses.cpp
index fd98217de54e735976de68665cdf47d92f3f78b6..5f850708be761f4d726f8bc6dc64567d341dc5b2 100644
--- a/ets2panda/parser/ETSparserClasses.cpp
+++ b/ets2panda/parser/ETSparserClasses.cpp
@@ -421,6 +421,7 @@ ir::TypeNode *ETSParser::ConvertToOptionalUnionType(ir::TypeNode *typeAnno)
         types.push_back(AllocNode<ir::ETSUndefinedType>(Allocator()));
         types.back()->SetRange(typeAnno->Range());
         auto *newTypeAnno = AllocNode<ir::ETSUnionType>(std::move(types), Allocator());
+        ES2PANDA_ASSERT(newTypeAnno != nullptr);
         newTypeAnno->SetRange(typeAnno->Range());
         return newTypeAnno;
     }
@@ -596,6 +597,7 @@ ir::MethodDefinition *ETSParser::ParseClassMethodDefinition(ir::Identifier *meth
     funcExpr->SetRange(func->Range());
     func->AddModifier(modifiers);
 
+    ES2PANDA_ASSERT(methodName->Clone(Allocator(), nullptr) != nullptr);
     auto *method = AllocNode<ir::MethodDefinition>(methodKind, methodName->Clone(Allocator(), nullptr)->AsExpression(),
                                                    funcExpr, modifiers, Allocator(), false);
     ES2PANDA_ASSERT(method != nullptr);
@@ -634,6 +636,7 @@ ir::MethodDefinition *ETSParser::ParseClassMethod(ClassElementDescriptor *desc,
     auto *method =
         AllocNode<ir::MethodDefinition>(desc->methodKind, propName->Clone(Allocator(), nullptr)->AsExpression(),
                                         funcExpr, desc->modifiers, Allocator(), desc->isComputed);
+    ES2PANDA_ASSERT(method != nullptr);
     method->SetRange(funcExpr->Range());
 
     return method;
@@ -841,13 +844,16 @@ ir::MethodDefinition *ETSParser::ParseClassGetterSetterMethod(const ArenaVector<
 
     lexer::SourcePosition propEnd = methodName->End();
     ir::MethodDefinition *method = ParseClassMethod(&desc, properties, methodName, &propEnd);
+    ES2PANDA_ASSERT(method != nullptr);
     method->SetDefaultAccessModifier(isDefault);
-    method->Function()->AddModifier(desc.modifiers);
+    auto *func = method->Function();
+    ES2PANDA_ASSERT(func != nullptr);
+    func->AddModifier(desc.modifiers);
     method->SetRange({desc.propStart, propEnd});
     if (desc.methodKind == ir::MethodDefinitionKind::GET) {
-        method->Function()->AddFlag(ir::ScriptFunctionFlags::GETTER);
+        func->AddFlag(ir::ScriptFunctionFlags::GETTER);
     } else {
-        method->Function()->AddFlag(ir::ScriptFunctionFlags::SETTER);
+        func->AddFlag(ir::ScriptFunctionFlags::SETTER);
     }
 
     return method;
@@ -864,23 +870,25 @@ ir::MethodDefinition *ETSParser::ParseInterfaceGetterSetterMethod(const ir::Modi
         return nullptr;
     }
     method->AddModifier(ir::ModifierFlags::PUBLIC);
-    auto id = method->Id();
+    auto *id = method->Id();
+    auto *func = method->Function();
     ES2PANDA_ASSERT(id != nullptr);
+    ES2PANDA_ASSERT(func != nullptr);
     if (methodKind == ir::MethodDefinitionKind::GET) {
         id->SetAccessor();
-        method->Function()->AddFlag(ir::ScriptFunctionFlags::GETTER);
+        func->AddFlag(ir::ScriptFunctionFlags::GETTER);
     } else {
         id->SetMutator();
-        method->Function()->AddFlag(ir::ScriptFunctionFlags::SETTER);
+        func->AddFlag(ir::ScriptFunctionFlags::SETTER);
     }
     method->AddModifier(ir::ModifierFlags::PUBLIC);
 
-    method->Function()->SetIdent(id->Clone(Allocator(), nullptr));
-    method->Function()->AddModifier(method->Modifiers());
+    func->SetIdent(id->Clone(Allocator(), nullptr));
+    func->AddModifier(method->Modifiers());
 
-    bool hasReturn = method->Function()->ReturnTypeAnnotation() != nullptr;
+    bool hasReturn = func->ReturnTypeAnnotation() != nullptr;
     if (hasReturn && methodKind == ir::MethodDefinitionKind::SET) {
-        LogError(diagnostic::SETTER_NO_RETURN_TYPE, {}, method->Function()->Range().start);
+        LogError(diagnostic::SETTER_NO_RETURN_TYPE, {}, func->Range().start);
     }
 
     return method;
@@ -1110,6 +1118,7 @@ ir::AstNode *ETSParser::ParseInterfaceField()
         return AllocBrokenExpression(Lexer()->GetToken().Start());
     }
 
+    ES2PANDA_ASSERT(name != nullptr);
     name->SetRange(Lexer()->GetToken().Loc());
     Lexer()->NextToken();
     bool optionalField = false;
@@ -1179,6 +1188,7 @@ ir::MethodDefinition *ETSParser::ParseInterfaceMethod(ir::ModifierFlags flags, i
         name = AllocBrokenExpression(Lexer()->GetToken().Loc());
     } else {
         name = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+        ES2PANDA_ASSERT(name != nullptr);
         name->SetRange(Lexer()->GetToken().Loc());
         Lexer()->NextToken();
     }
@@ -1227,8 +1237,10 @@ ir::MethodDefinition *ETSParser::ParseInterfaceMethod(ir::ModifierFlags flags, i
     func->AddFlag(ir::ScriptFunctionFlags::METHOD);
 
     func->SetIdent(name);
+    ES2PANDA_ASSERT(name->Clone(Allocator(), nullptr) != nullptr);
     auto *method = AllocNode<ir::MethodDefinition>(methodKind, name->Clone(Allocator(), nullptr)->AsExpression(),
                                                    funcExpr, flags, Allocator(), false);
+    ES2PANDA_ASSERT(method != nullptr);
     method->SetRange(funcExpr->Range());
 
     ConsumeSemicolon(method);
diff --git a/ets2panda/parser/ETSparserExpressions.cpp b/ets2panda/parser/ETSparserExpressions.cpp
index d07eb0720854ac4c231c499b1cf588e204658bdc..707d44ad1b567490b390a61158a971ea58c2bbf9 100644
--- a/ets2panda/parser/ETSparserExpressions.cpp
+++ b/ets2panda/parser/ETSparserExpressions.cpp
@@ -41,11 +41,11 @@ static std::string GetArgumentsSourceView(lexer::Lexer *lexer, const util::Strin
 ir::Expression *ETSParser::ParseFunctionParameterExpression(ir::AnnotatedExpression *const paramIdent, bool isOptional)
 {
     ir::ETSParameterExpression *paramExpression;
+    ES2PANDA_ASSERT(paramIdent != nullptr);
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
         auto const lexerPos = Lexer()->Save().Iterator();
         Lexer()->NextToken();  // eat '='
 
-        ES2PANDA_ASSERT(paramIdent != nullptr);
         if (paramIdent->IsRestElement()) {
             LogError(diagnostic::NO_DEFAULT_FOR_REST);
         }
@@ -76,9 +76,11 @@ ir::Expression *ETSParser::ParseFunctionParameterExpression(ir::AnnotatedExpress
         paramExpression->SetRange({paramIdent->Start(), paramExpression->Initializer()->End()});
     } else if (paramIdent->IsIdentifier()) {
         paramExpression = AllocNode<ir::ETSParameterExpression>(paramIdent->AsIdentifier(), isOptional, Allocator());
+        ES2PANDA_ASSERT(paramExpression != nullptr);
         paramExpression->SetRange({paramIdent->Start(), paramIdent->End()});
     } else {
         paramExpression = AllocNode<ir::ETSParameterExpression>(paramIdent->AsRestElement(), false, Allocator());
+        ES2PANDA_ASSERT(paramExpression != nullptr);
         paramExpression->SetRange({paramIdent->Start(), paramIdent->End()});
     }
     return paramExpression;
@@ -181,6 +183,7 @@ ir::Expression *ETSParser::ParseUnaryOrPrefixUpdateExpression(ExpressionParseFla
     }
 
     ir::Expression *returnExpr = CreateUnaryExpressionFromArgument(argument, operatorType, beginningChar);
+    ES2PANDA_ASSERT(returnExpr != nullptr);
     returnExpr->SetRange({start, argument->End()});
     return returnExpr;
 }
@@ -218,6 +221,7 @@ ir::Expression *ETSParser::ParsePropertyDefinition(ExpressionParseFlags flags)
     if (propertyKind == ir::PropertyKind::INIT) {
         returnProperty =
             AllocNode<ir::Property>(propertyKind, key, value, methodStatus != ParserStatus::NO_OPTS, isComputed);
+        ES2PANDA_ASSERT(returnProperty != nullptr);
         returnProperty->SetRange({start, end});
     } else {
         returnProperty = AllocBrokenExpression(key->Start());
diff --git a/ets2panda/parser/ETSparserNamespaces.cpp b/ets2panda/parser/ETSparserNamespaces.cpp
index d60297de79692aaacc29201b9351696b2f691a3a..807b70099f039358c0c1ddfda821909e23d78256 100644
--- a/ets2panda/parser/ETSparserNamespaces.cpp
+++ b/ets2panda/parser/ETSparserNamespaces.cpp
@@ -71,6 +71,7 @@ ir::ETSModule *ETSParser::ParseNamespaceImp(ir::ModifierFlags flags)
     auto *result =
         AllocNode<ir::ETSModule>(Allocator(), ArenaVector<ir::Statement *>(Allocator()->Adapter()), ExpectIdentifier(),
                                  ir::ModuleFlag::NAMESPACE, GetContext().GetLanguage(), globalProgram_);
+    ES2PANDA_ASSERT(result != nullptr);
     ir::ETSModule *parent = result;
     ir::ETSModule *child = nullptr;
     while (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD) {
diff --git a/ets2panda/parser/ETSparserTypes.cpp b/ets2panda/parser/ETSparserTypes.cpp
index c27206d4813f0677d0009c6b8c18d75a178e1f32..00c8ace6b2cc55a14aa52faa1a082c1693ad10f2 100644
--- a/ets2panda/parser/ETSparserTypes.cpp
+++ b/ets2panda/parser/ETSparserTypes.cpp
@@ -178,6 +178,7 @@ ir::TypeNode *ETSParser::ParseWildcardType(TypeAnnotationParsingOptions *options
     ir::ETSTypeReference *typeReference = nullptr;
     if (!isUnboundOut) {
         auto reference = ParseTypeReference(options);
+        ES2PANDA_ASSERT(reference != nullptr);
         typeReference = reference->AsETSTypeReference();
     }
 
diff --git a/ets2panda/parser/TSparser.cpp b/ets2panda/parser/TSparser.cpp
index d2545ce4258ac527a5c3a340bb71ad14c40648a6..4c41a234a3ed0717b0f5940f822f92b59b496a69 100644
--- a/ets2panda/parser/TSparser.cpp
+++ b/ets2panda/parser/TSparser.cpp
@@ -515,7 +515,7 @@ ir::TypeNode *TSParser::ParseTypeOperatorOrTypeReference()
         }
 
         auto *typeOperator = AllocNode<ir::TSTypeOperator>(type, ir::TSOperatorType::READONLY, Allocator());
-
+        ES2PANDA_ASSERT(typeOperator != nullptr);
         typeOperator->SetRange({typeOperatorStart, type->End()});
 
         return typeOperator;
@@ -1934,6 +1934,7 @@ ir::MethodDefinition *TSParser::ParseClassMethod(ClassElementDescriptor *desc,
     }
 
     auto *funcExpr = AllocNode<ir::FunctionExpression>(func);
+    ES2PANDA_ASSERT(funcExpr != nullptr);
     funcExpr->SetRange(func->Range());
 
     if (desc->methodKind == ir::MethodDefinitionKind::SET) {
@@ -1946,6 +1947,7 @@ ir::MethodDefinition *TSParser::ParseClassMethod(ClassElementDescriptor *desc,
     func->AddFlag(ir::ScriptFunctionFlags::METHOD);
     auto *method = AllocNode<ir::MethodDefinition>(desc->methodKind, propName, funcExpr, desc->modifiers, Allocator(),
                                                    desc->isComputed);
+    ES2PANDA_ASSERT(method != nullptr);
     method->SetRange(funcExpr->Range());
 
     return method;
diff --git a/ets2panda/parser/expressionParser.cpp b/ets2panda/parser/expressionParser.cpp
index 596a70e086461c7b6ffc6648ae3bc186c78da65e..ebc744397b8558f2fa08ebd6d73e895d413db77d 100644
--- a/ets2panda/parser/expressionParser.cpp
+++ b/ets2panda/parser/expressionParser.cpp
@@ -348,6 +348,7 @@ ir::ArrowFunctionExpression *ParserImpl::ParseArrowFunctionExpressionBody(ArrowF
     funcNode->SetRange({desc->startLoc, endLoc});
 
     auto *arrowFuncNode = AllocNode<ir::ArrowFunctionExpression>(funcNode, Allocator());
+    ES2PANDA_ASSERT(arrowFuncNode != nullptr);
     arrowFuncNode->SetRange(funcNode->Range());
 
     return arrowFuncNode;
@@ -2370,7 +2371,7 @@ ir::Expression *ParserImpl::ParseUnaryOrPrefixUpdateExpression(ExpressionParseFl
         returnExpr = AllocNode<ir::UnaryExpression>(argument, operatorType);
     }
 
-    ES2PANDA_ASSERT(returnExpr);
+    ES2PANDA_ASSERT(returnExpr != nullptr);
     returnExpr->SetRange({start, end});
 
     return returnExpr;
@@ -2416,6 +2417,7 @@ ir::Expression *ParserImpl::ParseImportExpression()
     ExpectToken(lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS);
 
     auto *importExpression = AllocNode<ir::ImportExpression>(source);
+    ES2PANDA_ASSERT(importExpression != nullptr);
     importExpression->SetRange({startLoc, endImportLoc});
 
     return importExpression;
@@ -2451,6 +2453,7 @@ ir::FunctionExpression *ParserImpl::ParseFunctionExpression(ParserStatus newStat
     }
 
     ir::ScriptFunction *functionNode = ParseFunction(newStatus);
+    ES2PANDA_ASSERT(functionNode != nullptr);
     functionNode->SetStart(startLoc);
 
     auto *funcExpr = AllocNode<ir::FunctionExpression>(ident, functionNode);
diff --git a/ets2panda/parser/parserImpl.cpp b/ets2panda/parser/parserImpl.cpp
index 2b6e9ce4816286d4105e555eacad3119d6577124..ae8dd74781d50bb3b1465ff32ce5539263797beb 100644
--- a/ets2panda/parser/parserImpl.cpp
+++ b/ets2panda/parser/parserImpl.cpp
@@ -480,6 +480,7 @@ ir::MethodDefinition *ParserImpl::ParseClassMethod(ClassElementDescriptor *desc,
                       : propName;
     auto *method = AllocNode<ir::MethodDefinition>(desc->methodKind, ident, funcExpr, desc->modifiers, Allocator(),
                                                    desc->isComputed);
+    ES2PANDA_ASSERT(method != nullptr);
     method->SetRange(funcExpr->Range());
 
     return method;
@@ -495,6 +496,7 @@ ir::ClassElement *ParserImpl::ParseClassProperty(ClassElementDescriptor *desc,
 
     if (desc->classMethod) {
         property = ParseClassMethod(desc, properties, propName, &propEnd);
+        ES2PANDA_ASSERT(property != nullptr);
         property->SetRange({desc->propStart, propEnd});
         return property;
     }
@@ -514,7 +516,7 @@ ir::ClassElement *ParserImpl::ParseClassProperty(ClassElementDescriptor *desc,
 
     property =
         AllocNode<ir::ClassProperty>(propName, value, typeAnnotation, desc->modifiers, Allocator(), desc->isComputed);
-
+    ES2PANDA_ASSERT(property != nullptr);
     property->SetRange({desc->propStart, propEnd});
 
     return property;
@@ -685,6 +687,7 @@ ir::MethodDefinition *ParserImpl::BuildImplicitConstructor(ir::ClassDefinitionMo
     auto *key = AllocNode<ir::Identifier>("constructor", Allocator());
 
     if ((modifiers & ir::ClassDefinitionModifiers::SET_CTOR_ID) != 0U) {
+        ES2PANDA_ASSERT(key != nullptr);
         func->SetIdent(key->Clone(Allocator(), nullptr));
     }
 
@@ -710,6 +713,7 @@ void ParserImpl::CreateImplicitConstructor(ir::MethodDefinition *&ctor,
 
     ctor = BuildImplicitConstructor(modifiers, startLoc);
     if ((flags & ir::ModifierFlags::DECLARE) != 0) {
+        ES2PANDA_ASSERT(ctor != nullptr);
         auto *ctorFunc = ctor->Function();
         ES2PANDA_ASSERT(ctorFunc != nullptr);
         ctorFunc->AddFlag(ir::ScriptFunctionFlags::EXTERNAL);
diff --git a/ets2panda/parser/statementParser.cpp b/ets2panda/parser/statementParser.cpp
index c311d81ec3c170237f0a2cf9d0b9b75b1e3eee7e..cb374f95f30f2c7070288955b7fe0eab03734e7d 100644
--- a/ets2panda/parser/statementParser.cpp
+++ b/ets2panda/parser/statementParser.cpp
@@ -525,9 +525,11 @@ ir::Statement *ParserImpl::ParseBreakStatement()
     }
 
     auto *identNode = AllocNode<ir::Identifier>(label, Allocator());
+    ES2PANDA_ASSERT(identNode != nullptr);
     identNode->SetRange(lexer_->GetToken().Loc());
 
     auto *breakStatement = AllocNode<ir::BreakStatement>(identNode);
+    ES2PANDA_ASSERT(breakStatement != nullptr);
     breakStatement->SetRange({startLoc, lexer_->GetToken().End()});
 
     lexer_->NextToken();
@@ -580,6 +582,7 @@ ir::Statement *ParserImpl::ParseContinueStatement()
     }
 
     auto *identNode = AllocNode<ir::Identifier>(label, Allocator());
+    ES2PANDA_ASSERT(identNode != nullptr);
     identNode->SetRange(lexer_->GetToken().Loc());
 
     auto *continueStatement = AllocNode<ir::ContinueStatement>(identNode);
@@ -662,9 +665,11 @@ ir::FunctionDeclaration *ParserImpl::ParseFunctionDeclaration(bool canBeAnonymou
     if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
         if (canBeAnonymous) {
             ir::ScriptFunction *func = ParseFunction(newStatus | ParserStatus::NEED_RETURN_TYPE);
+            ES2PANDA_ASSERT(func != nullptr);
             func->SetStart(startLoc);
 
             auto *funcDecl = AllocNode<ir::FunctionDeclaration>(Allocator(), func, true);
+            ES2PANDA_ASSERT(funcDecl != nullptr);
             funcDecl->SetRange(func->Range());
             return funcDecl;
         }
@@ -684,6 +689,7 @@ ir::FunctionDeclaration *ParserImpl::ParseFunctionDeclaration(bool canBeAnonymou
     func->SetIdent(identNode);
     func->SetStart(startLoc);
     auto *funcDecl = AllocNode<ir::FunctionDeclaration>(Allocator(), func);
+    ES2PANDA_ASSERT(funcDecl != nullptr);
     funcDecl->SetRange(func->Range());
 
     if (func->IsOverload() && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
@@ -1383,6 +1389,7 @@ ir::Statement *ParserImpl::ParseTryStatement()
 
     while (lexer_->GetToken().Type() == lexer::TokenType::KEYW_CATCH) {
         catchClause = ParseCatchClause();
+        ES2PANDA_ASSERT(catchClause != nullptr);
         endLoc = catchClause->End();
         catchClauses.push_back(catchClause);
     }
@@ -1398,6 +1405,7 @@ ir::Statement *ParserImpl::ParseTryStatement()
     ArenaVector<std::pair<compiler::LabelPair, const ir::Statement *>> finalizerInsertions(Allocator()->Adapter());
 
     auto *tryStatement = AllocNode<ir::TryStatement>(body, std::move(catchClauses), finallyClause, finalizerInsertions);
+    ES2PANDA_ASSERT(tryStatement != nullptr);
     tryStatement->SetRange({startLoc, endLoc});
     return tryStatement;
 }
@@ -2001,6 +2009,7 @@ ir::Statement *ParserImpl::ParseImportDeclaration(StatementParsingFlags flags)
         source = ParseFromClause(false);
     }
 
+    ES2PANDA_ASSERT(source != nullptr);
     lexer::SourcePosition endLoc = source->End();
     auto *importDeclaration = AllocNode<ir::ImportDeclaration>(source, std::move(specifiers));
     ES2PANDA_ASSERT(importDeclaration != nullptr);
diff --git a/ets2panda/parser/statementTSParser.cpp b/ets2panda/parser/statementTSParser.cpp
index 4cd60c24dbdc8d586dd6fa076ea8788d47759f75..b0a451bcd38a8e6b9058b610c281183fb618cbb2 100644
--- a/ets2panda/parser/statementTSParser.cpp
+++ b/ets2panda/parser/statementTSParser.cpp
@@ -372,6 +372,7 @@ ir::Statement *TSParser::ParseImportDeclaration([[maybe_unused]] StatementParsin
     ES2PANDA_ASSERT(source != nullptr);
     lexer::SourcePosition endLoc = source->End();
     auto *importDeclaration = AllocNode<ir::ImportDeclaration>(source, std::move(specifiers));
+    ES2PANDA_ASSERT(importDeclaration != nullptr);
     importDeclaration->SetRange({startLoc, endLoc});
 
     ConsumeSemicolon(importDeclaration);