diff --git a/ets2panda/checker/TSAnalyzer.cpp b/ets2panda/checker/TSAnalyzer.cpp
index cfaad3f534778bcc113cfa6f35b12ba77bdffdfb..c0279140aaff088c8784393036b4ad3668c12b31 100644
--- a/ets2panda/checker/TSAnalyzer.cpp
+++ b/ets2panda/checker/TSAnalyzer.cpp
@@ -107,6 +107,7 @@ checker::Type *TSAnalyzer::Check(ir::TSMethodSignature *node) const
     }
 
     returnType->Check(checker);
+    CHECK_NOT_NULL(callSignature);
     callSignature->SetReturnType(returnType->GetType(checker));
 
     return nullptr;
@@ -787,6 +788,7 @@ void TSAnalyzer::CheckNonComputed(checker::ObjectDescriptor *desc, ir::Expressio
 
     auto *memberVar = varbinder::Scope::CreateVar(checker->Allocator(), propName, flags, it);
 
+    CHECK_NOT_NULL(memberVar);
     if (inConstContext) {
         memberVar->AddFlag(varbinder::VariableFlags::READONLY);
     } else {
@@ -1342,6 +1344,7 @@ static void CheckSimpleVariableDeclaration(checker::TSChecker *checker, ir::Vari
             initializerType = checker->GetBaseTypeOfLiteralType(initializerType);
         }
 
+        CHECK_NOT_NULL(initializerType);
         if (initializerType->IsNullType()) {
             checker->ThrowTypeError(
                 {"Cannot infer type for variable '", declarator->Id()->AsIdentifier()->Name(), "'."},
@@ -1729,6 +1732,7 @@ static void AddEnumValueDeclaration(checker::TSChecker *checker, double number,
 
     if (res == nullptr) {
         auto *decl = checker->Allocator()->New<varbinder::EnumDecl>(memberStr);
+        CHECK_NOT_NULL(decl);
         decl->BindNode(variable->Declaration()->Node());
         enumScope->AddDecl(checker->Allocator(), decl, ScriptExtension::TS);
         res = enumScope->FindLocal(memberStr, varbinder::ResolveBindingOptions::BINDINGS);
@@ -1826,6 +1830,7 @@ checker::Type *TSAnalyzer::InferType(checker::TSChecker *checker, bool isConst,
         const util::StringView &currentName = enumScope->Decls()[i]->Name();
         varbinder::Variable *currentVar = enumScope->FindLocal(currentName, varbinder::ResolveBindingOptions::BINDINGS);
         ES2PANDA_ASSERT(currentVar && currentVar->IsEnumVariable());
+        CHECK_NOT_NULL(currentVar);
         InferEnumVariableType(currentVar->AsEnumVariable(), &value, &initNext, &isLiteralEnum, isConst);
     }
 
diff --git a/ets2panda/checker/ts/helpers.cpp b/ets2panda/checker/ts/helpers.cpp
index 9c2455f558c2cf064c93663fee5cd0ffa05bf9b4..e8c2ae8248d50dcb3e8954fb61fef284c0f1a7fc 100644
--- a/ets2panda/checker/ts/helpers.cpp
+++ b/ets2panda/checker/ts/helpers.cpp
@@ -59,7 +59,7 @@ Type *TSChecker::GetBaseTypeOfLiteralType(Type *type)
     if (HasStatus(CheckerStatus::KEEP_LITERAL_TYPE)) {
         return type;
     }
-
+    CHECK_NOT_NULL(type);
     if (type->IsStringLiteralType()) {
         return GlobalStringType();
     }
@@ -370,6 +370,7 @@ void TSChecker::GetTypeVar(varbinder::Decl *decl)
         util::Helpers::FindAncestorGivenByType(decl->Node(), ir::AstNodeType::VARIABLE_DECLARATOR);
     ES2PANDA_ASSERT(declarator);
 
+    CHECK_NOT_NULL(declarator);
     if (declarator->AsVariableDeclarator()->Id()->IsIdentifier()) {
         InferSimpleVariableDeclaratorType(declarator->AsVariableDeclarator());
         return;
@@ -382,6 +383,7 @@ void TSChecker::GetTypeParam(varbinder::Variable *var, varbinder::Decl *decl)
 {
     ir::AstNode *declaration = FindAncestorUntilGivenType(decl->Node(), ir::AstNodeType::SCRIPT_FUNCTION);
 
+    CHECK_NOT_NULL(declaration);
     if (declaration->IsIdentifier()) {
         auto *ident = declaration->AsIdentifier();
         if (ident->TypeAnnotation() != nullptr) {
@@ -499,6 +501,7 @@ Type *TSChecker::GetTypeFromClassOrInterfaceReference([[maybe_unused]] ir::TSTyp
     if (resolvedType == nullptr) {
         ObjectDescriptor *desc = Allocator()->New<ObjectDescriptor>(Allocator());
         resolvedType = Allocator()->New<InterfaceType>(Allocator(), var->Name(), desc);
+        CHECK_NOT_NULL(resolvedType);
         resolvedType->SetVariable(var);
         var->SetTsType(resolvedType);
     }
diff --git a/ets2panda/checker/ts/object.cpp b/ets2panda/checker/ts/object.cpp
index d0b36c61dc21745bb7fb0994b1f9c0f222731dd9..3d06163e9642c62c20313813d1bb4ecd0050adbd 100644
--- a/ets2panda/checker/ts/object.cpp
+++ b/ets2panda/checker/ts/object.cpp
@@ -139,6 +139,7 @@ void TSChecker::ResolveUnionTypeMembers(UnionType *type)
         }
     }
 
+    CHECK_NOT_NULL(desc);
     desc->callSignatures = callSignatures;
     desc->constructSignatures = constructSignatures;
 
@@ -333,6 +334,7 @@ varbinder::Variable *TSChecker::GetPropertyOfUnionType(UnionType *type, const ut
     }
 
     varbinder::Variable *syntheticProp = varbinder::Scope::CreateVar(Allocator(), name, flags, nullptr);
+    CHECK_NOT_NULL(syntheticProp);
     syntheticProp->SetTsType(CreateUnionType(std::move(collectedTypes)));
     type->CachedSyntheticProperties().insert({name, syntheticProp});
     return syntheticProp;
@@ -390,6 +392,7 @@ Type *TSChecker::GetPropertyTypeForIndexType(Type *type, Type *indexType)
         return type->AsArrayType()->ElementType();
     }
 
+    CHECK_NOT_NULL(indexType);
     if (indexType->HasTypeFlag(TypeFlag::STRING_LITERAL | TypeFlag::NUMBER_LITERAL)) {
         varbinder::Variable *prop = nullptr;
 
@@ -453,6 +456,7 @@ ArenaVector<ObjectType *> TSChecker::GetBaseTypes(InterfaceType *type)
         for (auto *extends : declaration->Extends()) {
             Type *baseType = extends->Expr()->GetType(this);
 
+            CHECK_NOT_NULL(baseType);
             if (!baseType->HasTypeFlag(TypeFlag::OBJECT | TypeFlag::NON_PRIMITIVE | TypeFlag::ANY)) {
                 ThrowTypeError(
                     "An interface can only extend an object type or intersection of object types with statically "
diff --git a/ets2panda/checker/ts/typeCreation.cpp b/ets2panda/checker/ts/typeCreation.cpp
index c40b8b1ed750ee4e21a47d61006ca2b9620b0bc2..4e5fe58848878c8b628ceb5af5e099a746048d44 100644
--- a/ets2panda/checker/ts/typeCreation.cpp
+++ b/ets2panda/checker/ts/typeCreation.cpp
@@ -125,6 +125,7 @@ Type *TSChecker::CreateUnionType(ArenaVector<Type *> &&constituentTypes)
 Type *TSChecker::CreateObjectTypeWithCallSignature(Signature *callSignature)
 {
     auto *objType = Allocator()->New<ObjectLiteralType>(Allocator()->New<ObjectDescriptor>(Allocator()));
+    CHECK_NOT_NULL(objType);
     objType->AddCallSignature(callSignature);
     return objType;
 }
@@ -132,6 +133,7 @@ Type *TSChecker::CreateObjectTypeWithCallSignature(Signature *callSignature)
 Type *TSChecker::CreateObjectTypeWithConstructSignature(Signature *constructSignature)
 {
     auto *objType = Allocator()->New<ObjectLiteralType>(Allocator()->New<ObjectDescriptor>(Allocator()));
+    CHECK_NOT_NULL(objType);
     objType->AddConstructSignature(constructSignature);
     return objType;
 }
@@ -139,6 +141,7 @@ Type *TSChecker::CreateObjectTypeWithConstructSignature(Signature *constructSign
 Type *TSChecker::CreateFunctionTypeWithSignature(Signature *callSignature)
 {
     auto *funcObjType = Allocator()->New<FunctionType>(Allocator()->New<ObjectDescriptor>(Allocator()));
+    CHECK_NOT_NULL(funcObjType);
     funcObjType->AddCallSignature(callSignature);
     return funcObjType;
 }
@@ -146,6 +149,7 @@ Type *TSChecker::CreateFunctionTypeWithSignature(Signature *callSignature)
 Type *TSChecker::CreateConstructorTypeWithSignature(Signature *constructSignature)
 {
     auto *constructObjType = Allocator()->New<ConstructorType>(Allocator()->New<ObjectDescriptor>(Allocator()));
+    CHECK_NOT_NULL(constructObjType);
     constructObjType->AddConstructSignature(constructSignature);
     return constructObjType;
 }
diff --git a/ets2panda/checker/types/ets/etsFunctionType.cpp b/ets2panda/checker/types/ets/etsFunctionType.cpp
index 0ec3b4ecaca3259907143dc8f1e7358d05407ff4..3141ab4fb4f53f9e1c42996c5e832ea7c3ddf9b5 100644
--- a/ets2panda/checker/types/ets/etsFunctionType.cpp
+++ b/ets2panda/checker/types/ets/etsFunctionType.cpp
@@ -46,9 +46,9 @@ ETSFunctionType::ETSFunctionType(ETSChecker *checker, Signature *signature)
       extensionFunctionSigs_(ArenaVector<Signature *>(checker->ProgramAllocator()->Adapter())),
       extensionAccessorSigs_(ArenaVector<Signature *>(checker->ProgramAllocator()->Adapter())),
       name_(""),
-      assemblerName_(checker->GlobalBuiltinFunctionType(signature->MinArgCount(), signature->HasRestParameter())
-                         ->AsETSObjectType()
-                         ->AssemblerName())
+      assemblerName_((checker->GlobalBuiltinFunctionType(signature->MinArgCount(), signature->HasRestParameter())) ?
+      checker->GlobalBuiltinFunctionType(signature->MinArgCount(), signature->HasRestParameter())->AsETSObjectType()
+                         ->AssemblerName() : "")
 {
 }
 
@@ -56,11 +56,12 @@ ETSFunctionType::ETSFunctionType(ETSChecker *checker, Signature *signature)
 static void HackThisParameterInExtensionFunctionInvoke(ETSObjectType *interface, size_t arity)
 {
     auto invokeName = FunctionalInterfaceInvokeName(arity, false);
-    auto &callSigsOfInvoke0 = interface->AsETSObjectType()
-                                  ->GetOwnProperty<checker::PropertyType::INSTANCE_METHOD>(util::StringView(invokeName))
-                                  ->TsType()
-                                  ->AsETSFunctionType()
-                                  ->CallSignatures();
+    auto *property = interface->AsETSObjectType()
+                         ->GetOwnProperty<checker::PropertyType::INSTANCE_METHOD>(util::StringView(invokeName));
+    CHECK_NOT_NULL(property);
+    auto *tsType = property->TsType();
+    CHECK_NOT_NULL(tsType);
+    auto &callSigsOfInvoke0 = tsType->AsETSFunctionType()->CallSignatures();
     for (auto sig : callSigsOfInvoke0) {
         sig->AddSignatureFlag(SignatureFlags::THIS_RETURN_TYPE);
     }
diff --git a/ets2panda/checker/types/ets/etsObjectType.cpp b/ets2panda/checker/types/ets/etsObjectType.cpp
index e7d2fb4229839b42e0e1cd6d17c135906d3be3b4..c071aa79a1441a8055e12e8778a9a3855ac0564d 100644
--- a/ets2panda/checker/types/ets/etsObjectType.cpp
+++ b/ets2panda/checker/types/ets/etsObjectType.cpp
@@ -238,6 +238,7 @@ varbinder::LocalVariable *ETSObjectType::CreateSyntheticVarFromEverySignature(co
     for (auto &s : signatures) {
         funcType->AddCallSignature(s);
     }
+    CHECK_NOT_NULL(res);
     res->SetTsType(funcType);
     funcType->SetVariable(res);
 
@@ -727,6 +728,7 @@ ETSFunctionType *ETSObjectType::GetFunctionalInterfaceInvokeType() const
     std::string invokeName = FunctionalInterfaceInvokeName(foundArity, hasRest);
     auto *invoke = GetOwnProperty<PropertyType::INSTANCE_METHOD>(util::StringView(invokeName));
     ES2PANDA_ASSERT(invoke != nullptr && invoke->TsType() != nullptr && invoke->TsType()->IsETSFunctionType());
+    CHECK_NOT_NULL(invoke);
     return invoke->TsType()->AsETSFunctionType();
 }
 
@@ -1069,6 +1071,7 @@ varbinder::LocalVariable *ETSObjectType::CopyProperty(varbinder::LocalVariable *
     if (copiedPropType->Variable() == prop) {
         copiedPropType->SetVariable(copiedProp);
     }
+    CHECK_NOT_NULL(copiedProp);
     copiedProp->SetTsType(copiedPropType);
     return copiedProp;
 }
@@ -1089,6 +1092,7 @@ Type *ETSObjectType::Instantiate(ArenaAllocator *const allocator, TypeRelation *
     auto *const copiedType = checker->CreateETSObjectType(declNode_, flags_);
     ES2PANDA_ASSERT(copiedType->internalName_ == internalName_);
     ES2PANDA_ASSERT(copiedType->name_ == name_);
+    CHECK_NOT_NULL(copiedType);
     copiedType->typeFlags_ = typeFlags_;
     copiedType->RemoveObjectFlag(ETSObjectFlags::INCOMPLETE_INSTANTIATION | ETSObjectFlags::CHECKED_INVOKE_LEGITIMACY);
     copiedType->SetVariable(variable_);
@@ -1136,6 +1140,7 @@ static varbinder::LocalVariable *CopyPropertyWithTypeArguments(varbinder::LocalV
     if (copiedPropType->Variable() == prop || copiedPropType->Variable() == nullptr) {
         copiedPropType->SetVariable(copiedProp);
     }
+    CHECK_NOT_NULL(copiedProp);
     copiedProp->SetTsType(copiedPropType);
     return copiedProp;
 }
@@ -1186,6 +1191,7 @@ static ArenaSubstitution *ComputeEffectiveSubstitution(TypeRelation *const relat
 void ETSObjectType::SetCopiedTypeProperties(TypeRelation *const relation, ETSObjectType *const copiedType,
                                             ArenaVector<Type *> &&newTypeArgs, ETSObjectType *base)
 {
+    CHECK_NOT_NULL(copiedType);
     copiedType->typeFlags_ = typeFlags_;
     copiedType->RemoveObjectFlag(ETSObjectFlags::INCOMPLETE_INSTANTIATION | ETSObjectFlags::CHECKED_INVOKE_LEGITIMACY);
     copiedType->SetVariable(variable_);
diff --git a/ets2panda/checker/types/ets/etsPartialTypeParameter.cpp b/ets2panda/checker/types/ets/etsPartialTypeParameter.cpp
index 14b55779761ae1d6d2230315da9696e72eaf0d35..5b9c8be9e79424e9f8ac6310e14e319ecafb6a9c 100644
--- a/ets2panda/checker/types/ets/etsPartialTypeParameter.cpp
+++ b/ets2panda/checker/types/ets/etsPartialTypeParameter.cpp
@@ -82,8 +82,13 @@ void ETSPartialTypeParameter::IsSubtypeOf(TypeRelation *relation, Type *target)
 ETSPartialTypeParameter *ETSPartialTypeParameter::Instantiate(ArenaAllocator *allocator, TypeRelation *relation,
                                                               GlobalTypesHolder *globalTypes)
 {
-    return allocator->New<ETSPartialTypeParameter>(
-        GetUnderlying()->Instantiate(allocator, relation, globalTypes)->AsETSTypeParameter(), checker_);
+    auto *underlying = GetUnderlying();
+    CHECK_NOT_NULL(underlying);
+    auto *instantiated = underlying->Instantiate(allocator, relation, globalTypes);
+    CHECK_NOT_NULL(instantiated);
+    auto *typeParam = instantiated->AsETSTypeParameter();
+    CHECK_NOT_NULL(typeParam);
+    return allocator->New<ETSPartialTypeParameter>(typeParam, checker_);
 }
 
 Type *ETSPartialTypeParameter::Substitute(TypeRelation *relation, const Substitution *substitution)
diff --git a/ets2panda/checker/types/ets/etsTupleType.cpp b/ets2panda/checker/types/ets/etsTupleType.cpp
index d0eb6e703455b8c83bb6cd488cbdcdc61b18f466..c0d8000560b3eb87316246aa1038a8ade04d9845 100644
--- a/ets2panda/checker/types/ets/etsTupleType.cpp
+++ b/ets2panda/checker/types/ets/etsTupleType.cpp
@@ -198,6 +198,7 @@ Type *ETSTupleType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[ma
 {
     auto *const checker = relation->GetChecker()->AsETSChecker();
     auto *const tupleType = allocator->New<ETSTupleType>(checker, GetTupleTypesList());
+    CHECK_NOT_NULL(tupleType);
     tupleType->typeFlags_ = typeFlags_;
     return tupleType;
 }
diff --git a/ets2panda/checker/types/ets/etsTupleType.h b/ets2panda/checker/types/ets/etsTupleType.h
index 2a326dedf9288398ada9753743ee0f539b33b060..c866c8fbb330bd3f0b044024e2dd7074e3afb595 100644
--- a/ets2panda/checker/types/ets/etsTupleType.h
+++ b/ets2panda/checker/types/ets/etsTupleType.h
@@ -28,7 +28,8 @@ public:
     explicit ETSTupleType(ETSChecker *checker, const ArenaVector<Type *> &typeList)
         : Type(checker::TypeFlag::ETS_TUPLE),
           typeList_(typeList),
-          wrapperType_(checker->GlobalBuiltinTupleType(typeList_.size())->AsETSObjectType())
+          wrapperType_((checker->GlobalBuiltinTupleType(typeList_.size())) ? 
+          checker->GlobalBuiltinTupleType(typeList_.size())->AsETSObjectType() : nullptr)
     {
         typeFlags_ |= TypeFlag::ETS_TUPLE;
     }
diff --git a/ets2panda/checker/types/ets/etsTypeParameter.cpp b/ets2panda/checker/types/ets/etsTypeParameter.cpp
index 518a42441bc1d0493b3a90a4a549052fdf48b3b9..c947d68e932916ac1dbbcfc5bdf96f3efd420cd6 100644
--- a/ets2panda/checker/types/ets/etsTypeParameter.cpp
+++ b/ets2panda/checker/types/ets/etsTypeParameter.cpp
@@ -127,6 +127,7 @@ Type *ETSTypeParameter::Instantiate([[maybe_unused]] ArenaAllocator *allocator,
     auto *const checker = relation->GetChecker()->AsETSChecker();
 
     auto *const copiedType = checker->CreateTypeParameter();
+    CHECK_NOT_NULL(copiedType);
     copiedType->AddTypeFlag(TypeFlag::GENERIC);
     copiedType->SetDeclNode(GetDeclNode());
     copiedType->SetDefaultType(GetDefaultType());
diff --git a/ets2panda/checker/types/ets/etsUnionType.cpp b/ets2panda/checker/types/ets/etsUnionType.cpp
index 34f539ad85602e085170611432a02f385a66d2e2..d8fc972091c653ff3f341237b1fdd87ae65de0e2 100644
--- a/ets2panda/checker/types/ets/etsUnionType.cpp
+++ b/ets2panda/checker/types/ets/etsUnionType.cpp
@@ -65,6 +65,7 @@ bool ETSUnionType::TypeRelatedToSomeType(TypeRelation *relation, Type *source, E
 Type *ETSUnionType::ComputeAssemblerLUB(ETSChecker *checker, ETSUnionType *un)
 {
     auto *const apparent = checker->GetApparentType(un);
+    CHECK_NOT_NULL(apparent);
     if (!apparent->IsETSUnionType()) {
         return apparent;
     }
@@ -368,6 +369,7 @@ bool ETSUnionType::ExtractType(checker::ETSChecker *checker, checker::Type *sour
             constituentType = constituentType->AsETSTypeParameter()->GetConstraintType();
         } else if (constituentType->HasTypeFlag(checker::TypeFlag::GENERIC)) {
             constituentType = constituentType->Clone(checker);
+            CHECK_NOT_NULL(constituentType);
             constituentType->RemoveTypeFlag(checker::TypeFlag::GENERIC);
         }
 
diff --git a/ets2panda/checker/types/signature.cpp b/ets2panda/checker/types/signature.cpp
index be45282d5f95b09d4a98d5cc6a18a04096a96d88..fcf16420815e1aec755ed09480763cff7655b5ba 100644
--- a/ets2panda/checker/types/signature.cpp
+++ b/ets2panda/checker/types/signature.cpp
@@ -35,7 +35,7 @@ Signature *Signature::Substitute(TypeRelation *relation, const Substitution *sub
     auto *allocator = checker->ProgramAllocator();
     bool anyChange = false;
     SignatureInfo *newSigInfo = allocator->New<SignatureInfo>(allocator);
-
+    CHECK_NOT_NULL(newSigInfo);
     if (!signatureInfo_->typeParams.empty()) {
         for (auto *tparam : signatureInfo_->typeParams) {
             auto *newTparam = tparam->Substitute(relation, substitution);
@@ -82,6 +82,7 @@ Signature *Signature::Substitute(TypeRelation *relation, const Substitution *sub
 Signature *Signature::CreateSignatureForSubstitute(ArenaAllocator *allocator, SignatureInfo *sigInfo, Type *returnType)
 {
     auto *result = allocator->New<Signature>(sigInfo, returnType, func_);
+    CHECK_NOT_NULL(result);
     result->flags_ = flags_;
     result->internalName_ = internalName_;
     result->ownerObj_ = ownerObj_;
@@ -124,6 +125,7 @@ Signature *Signature::Copy(ArenaAllocator *allocator, TypeRelation *relation, Gl
     }
 
     auto *const copiedSignature = allocator->New<Signature>(copiedInfo, returnType_, func_);
+    CHECK_NOT_NULL(copiedSignature);
     copiedSignature->flags_ = flags_;
     copiedSignature->internalName_ = internalName_;
     copiedSignature->ownerObj_ = ownerObj_;
@@ -289,6 +291,7 @@ Signature *Signature::ToArrowSignature(ETSChecker *checker)
 {
     auto *allocator = checker->ProgramAllocator();
     auto *sigInfo = allocator->New<SignatureInfo>(signatureInfo_, allocator);
+    CHECK_NOT_NULL(sigInfo);
     for (auto param : sigInfo->params) {
         param->SetTsType(checker->MaybeBoxType(param->TsType()));
     }
diff --git a/ets2panda/checker/types/signature.h b/ets2panda/checker/types/signature.h
index 8515f6b0ca5eb8ee717b40fc2b80770db1fc5c31..c84d461c742278b3669d9805bab1308dd959083a 100644
--- a/ets2panda/checker/types/signature.h
+++ b/ets2panda/checker/types/signature.h
@@ -49,6 +49,7 @@ public:
 
         if (other->restVar != nullptr) {
             restVar = other->restVar->Copy(allocator, other->restVar->Declaration());
+            CHECK_NOT_NULL(restVar);
             restVar->SetTsType(other->restVar->TsType());
         }
     }
diff --git a/ets2panda/checker/types/ts/interfaceType.cpp b/ets2panda/checker/types/ts/interfaceType.cpp
index 724bee9caa8d13e7521140aece70a67359c3dacd..c15aee585d0fe07aadd5485ccd0cee26e8855909 100644
--- a/ets2panda/checker/types/ts/interfaceType.cpp
+++ b/ets2panda/checker/types/ts/interfaceType.cpp
@@ -148,6 +148,7 @@ Type *InterfaceType::Instantiate(ArenaAllocator *allocator, TypeRelation *relati
 
     Type *newInterfaceType = allocator->New<InterfaceType>(allocator, name_, copiedDesc);
 
+    CHECK_NOT_NULL(newInterfaceType);
     for (auto *it : bases_) {
         newInterfaceType->AsObjectType()->AsInterfaceType()->AddBase(
             it->Instantiate(allocator, relation, globalTypes)->AsObjectType());
diff --git a/ets2panda/checker/types/ts/objectDescriptor.cpp b/ets2panda/checker/types/ts/objectDescriptor.cpp
index a418e6815ba44d59aa5f44e684de97144d9447bd..f8bc56d494a2a593011cfe498be277d4b9bdd941 100644
--- a/ets2panda/checker/types/ts/objectDescriptor.cpp
+++ b/ets2panda/checker/types/ts/objectDescriptor.cpp
@@ -34,10 +34,12 @@ varbinder::LocalVariable *ObjectDescriptor::FindProperty(const util::StringView
 void ObjectDescriptor::Copy(ArenaAllocator *allocator, ObjectDescriptor *copiedDesc, TypeRelation *relation,
                             GlobalTypesHolder *globalTypes)
 {
+    CHECK_NOT_NULL(copiedDesc);
     // copy by hand
     for (auto *it : properties) {
         auto *copiedProp = it->Copy(allocator, it->Declaration());
         copiedProp->SetTsType(it->TsType()->Instantiate(allocator, relation, globalTypes));
+        CHECK_NOT_NULL(copiedDesc);
         copiedDesc->properties.push_back(copiedProp);
     }
 
diff --git a/ets2panda/checker/types/ts/unionType.cpp b/ets2panda/checker/types/ts/unionType.cpp
index 8ba291ba7b360e44ee5e333de3e3ae6fd3557059..9538e90bf7f1c1ef6abd1be90d79509551d51c99 100644
--- a/ets2panda/checker/types/ts/unionType.cpp
+++ b/ets2panda/checker/types/ts/unionType.cpp
@@ -111,6 +111,7 @@ void UnionType::RemoveDuplicatedTypes(TypeRelation *relation, ArenaVector<Type *
 
 Type *UnionType::HandleUnionType(UnionType *unionType, GlobalTypesHolder *globalTypesHolder)
 {
+    CHECK_NOT_NULL(unionType);
     if (unionType->HasConstituentFlag(TypeFlag::ANY)) {
         return globalTypesHolder->GlobalAnyType();
     }
@@ -184,6 +185,7 @@ Type *UnionType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation,
 
     Type *newUnionType = allocator->New<UnionType>(allocator, std::move(copiedConstituents));
 
+    CHECK_NOT_NULL(newUnionType);
     return HandleUnionType(newUnionType->AsUnionType(), globalTypes);
 }
 }  // namespace ark::es2panda::checker
diff --git a/ets2panda/checker/types/typeRelation.cpp b/ets2panda/checker/types/typeRelation.cpp
index 130fa19dbbf95318c6de95f56091dc5d28084585..c2144f31bf898f9dbb5f0e959b9479c227688f6e 100644
--- a/ets2panda/checker/types/typeRelation.cpp
+++ b/ets2panda/checker/types/typeRelation.cpp
@@ -35,7 +35,7 @@ RelationResult TypeRelation::CacheLookup(const Type *source, const Type *target,
 
     ES2PANDA_ASSERT(source != nullptr);
     ES2PANDA_ASSERT(target != nullptr);
-
+    CHECK_NOT_NULL(source);
     auto key = RelationHolder::MakeKey(source->Id(), target->Id());
     auto res = holder.Find(key);
     if (res == nullptr) {
@@ -125,6 +125,8 @@ bool TypeRelation::IsAssignableTo(Type *source, Type *target)
     if (result_ == RelationResult::CACHE_MISS) {
         // NOTE: we support assigning T to Readonly<T>, but do not support assigning Readonly<T> to T
         // more details in spec
+        CHECK_NOT_NULL(source);
+        CHECK_NOT_NULL(target);
         if (source->HasTypeFlag(TypeFlag::READONLY) && !target->HasTypeFlag(TypeFlag::READONLY)) {
             result_ = RelationResult::FALSE;
         }
diff --git a/ets2panda/parser/expressionParser.cpp b/ets2panda/parser/expressionParser.cpp
index 67500b59ac9755039e36b368c1b0694f8051881f..b832868adb5f9ba0b377fbfb7bbd450804ff348f 100644
--- a/ets2panda/parser/expressionParser.cpp
+++ b/ets2panda/parser/expressionParser.cpp
@@ -885,6 +885,7 @@ ir::NullLiteral *ParserImpl::ParseNullLiteral()
 {
     ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_NULL);
     auto *nullNode = AllocNode<ir::NullLiteral>();
+    CHECK_NOT_NULL(nullNode);
     nullNode->SetRange(lexer_->GetToken().Loc());
 
     lexer_->NextToken();
@@ -2093,6 +2094,7 @@ ir::Expression *ParserImpl::ParsePropertyValue(const ir::PropertyKind *propertyK
     size_t paramsSize = methodDefinitonNode->Params().size();
 
     auto *value = AllocNode<ir::FunctionExpression>(methodDefinitonNode);
+    CHECK_NOT_NULL(value);
     value->SetRange(methodDefinitonNode->Range());
 
     if (*propertyKind == ir::PropertyKind::SET && paramsSize != 1) {