diff --git a/ets2panda/checker/ETSAnalyzer.cpp b/ets2panda/checker/ETSAnalyzer.cpp
index 1fec1bafe8b24dbdcded94cee335d42627d4ddde..abf1f960d5fe00cd57061ac54881074207aa9d1d 100644
--- a/ets2panda/checker/ETSAnalyzer.cpp
+++ b/ets2panda/checker/ETSAnalyzer.cpp
@@ -264,9 +264,8 @@ checker::Type *ETSAnalyzer::Check(ir::MethodDefinition *node) const
     HandleNativeAndAsyncMethods(checker, node);
     DoBodyTypeChecking(checker, node, scriptFunc);
     CheckPredefinedMethodReturnType(checker, scriptFunc);
-    if (node->TsType()->IsTypeError()) {
-        return node->TsType();
-    }
+
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, node->TsType(), return node->TsType());
 
     return CheckMethodDefinitionHelper(checker, node);
 }
@@ -556,9 +555,8 @@ static checker::Type *CheckInstantiatedNewType(ETSChecker *checker, ir::ETSNewCl
 {
     checker::Type *res = expr->GetTypeRef()->Check(checker);
     auto calleeType = res->MaybeBaseTypeOfGradualType();
-    if (calleeType->IsTypeError()) {
-        return checker->InvalidateType(expr->GetTypeRef());
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, calleeType, return checker->InvalidateType(expr->GetTypeRef()));
+
     if (calleeType->IsETSUnionType()) {
         return checker->TypeError(expr->GetTypeRef(), diagnostic::UNION_NONCONSTRUCTIBLE, expr->Start());
     }
@@ -594,11 +592,11 @@ checker::Type *ETSAnalyzer::Check(ir::ETSNewClassInstanceExpression *expr) const
     if (expr->TsType() != nullptr) {
         return expr->TsType();
     }
+
     ETSChecker *checker = GetETSChecker();
     auto *calleeType = CheckInstantiatedNewType(checker, expr);
-    if (calleeType->IsTypeError()) {
-        return checker->InvalidateType(expr);
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, calleeType, return checker->InvalidateType(expr));
+
     auto *calleeObj = calleeType->MaybeBaseTypeOfGradualType()->AsETSObjectType();
     expr->SetTsType(calleeType);
 
@@ -753,11 +751,7 @@ static void AddSpreadElementTypes(ETSChecker *checker, ir::SpreadElement *const
                                   ArenaVector<std::pair<Type *, ir::Expression *>> &elementTypes)
 {
     Type *const spreadType = element->Check(checker);
-
-    if (spreadType->IsTypeError()) {
-        // error recovery
-        return;
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, spreadType, return );
 
     Type *const spreadArgumentType = element->Argument()->TsType()->MaybeBaseTypeOfGradualType();
 
@@ -831,10 +825,7 @@ static bool CheckElement(ETSChecker *checker, Type *const preferredType,
                          ArenaVector<std::pair<Type *, ir::Expression *>> arrayExprElementTypes, std::size_t idx)
 {
     auto [elementType, currentElement] = arrayExprElementTypes[idx];
-
-    if (elementType->IsTypeError()) {
-        return true;
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, elementType, return true);
 
     Type *targetType = nullptr;
 
@@ -1222,17 +1213,17 @@ checker::Type *ETSAnalyzer::Check(ir::AssignmentExpression *const expr) const
     }
 
     auto [rightType, relationNode] = CheckAssignmentExprOperatorType(expr, leftType);
-    if (rightType->IsTypeError()) {
-        return expr->SetTsType(leftType);
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, rightType, return expr->SetTsType(leftType));
 
     CastPossibleTupleOnRHS(checker, expr);
 
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, leftType, return expr->SetTsType(rightType));
+
     checker::Type *smartType = rightType;
     auto isLazyImportObject =
         leftType->MaybeBaseTypeOfGradualType()->IsETSObjectType() &&
         leftType->MaybeBaseTypeOfGradualType()->AsETSObjectType()->HasObjectFlag(ETSObjectFlags::LAZY_IMPORT_OBJECT);
-    if (!leftType->IsTypeError() && !isLazyImportObject) {
+    if (!isLazyImportObject) {
         if (const auto ctx = checker::AssignmentContext(checker->Relation(), relationNode, rightType, leftType,
                                                         expr->Right()->Start(),
                                                         {{diagnostic::INVALID_ASSIGNMNENT, {rightType, leftType}}});
@@ -1515,10 +1506,7 @@ static ETSObjectType *GetCallExpressionCalleeObject(ETSChecker *checker, ir::Cal
 Type *ETSAnalyzer::GetReturnType(ir::CallExpression *expr, Type *calleeType) const
 {
     ETSChecker *checker = GetETSChecker();
-
-    if (calleeType->IsTypeError()) {
-        return checker->GlobalTypeError();
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, calleeType, return calleeType);
 
     if (!calleeType->IsETSFunctionType() && !expr->IsETSConstructorCall() &&
         !calleeType->IsETSExtensionFuncHelperType()) {
@@ -1602,10 +1590,7 @@ checker::Type *ETSAnalyzer::GetCallExpressionReturnType(ir::CallExpression *expr
 {
     ETSChecker *checker = GetETSChecker();
     checker::Type *returnType = GetReturnType(expr, calleeType);
-
-    if (returnType->IsTypeError()) {
-        return checker->GlobalTypeError();
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, returnType, return checker->GlobalTypeError());
 
     auto *const signature = expr->Signature();
     if (signature->RestVar() != nullptr && signature->RestVar()->TsType()->IsETSArrayType()) {
@@ -1658,9 +1643,7 @@ checker::Type *ETSAnalyzer::Check(ir::CallExpression *expr) const
 
     auto *oldCallee = expr->Callee();
     checker::Type *calleeType = checker->GetApparentType(expr->Callee()->Check(checker));
-    if (calleeType->IsTypeError()) {
-        return checker->InvalidateType(expr);
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, calleeType, return checker->InvalidateType(expr));
 
     if (expr->Callee() != oldCallee) {
         // If it is a static invoke, the callee will be transformed from an identifier to a member expression
@@ -1677,9 +1660,8 @@ checker::Type *ETSAnalyzer::Check(ir::CallExpression *expr) const
 
     checker::Type *const returnType = GetCallExpressionReturnType(expr, calleeType);
     expr->SetTsType(returnType);
-    if (returnType->IsTypeError()) {
-        return returnType;
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, returnType, return returnType);
+
     if (calleeType->IsETSArrowType()) {
         expr->SetUncheckedType(checker->GuaranteedTypeForUncheckedCast(
             checker->GlobalETSAnyType(), checker->MaybeBoxType(expr->Signature()->ReturnType())));
@@ -1692,11 +1674,6 @@ checker::Type *ETSAnalyzer::Check(ir::CallExpression *expr) const
         checker->ComputeApparentType(returnType);
     }
 
-    if (returnType->IsTypeError()) {
-        expr->SetTsType(returnType);
-        return expr->TsType();
-    }
-
     CheckVoidTypeExpression(checker, expr);
     CheckAbstractCall(checker, expr);
     return expr->TsType();
@@ -1906,9 +1883,7 @@ static void TypeErrorOnMissingProperty(ir::MemberExpression *expr, checker::Type
 checker::Type *ETSAnalyzer::ResolveMemberExpressionByBaseType(ETSChecker *checker, checker::Type *baseType,
                                                               ir::MemberExpression *expr) const
 {
-    if (baseType->IsTypeError()) {
-        return checker->InvalidateType(expr);
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, baseType, return checker->InvalidateType(expr));
 
     if (baseType->IsGradualType()) {
         return ResolveMemberExpressionByBaseType(checker, baseType->AsGradualType()->GetBaseType(), expr);
@@ -2758,9 +2733,7 @@ checker::Type *ETSAnalyzer::Check(ir::UpdateExpression *expr) const
     }
 
     checker::Type *operandType = expr->argument_->Check(checker);
-    if (operandType->IsTypeError()) {
-        return checker->InvalidateType(expr);
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, operandType, return checker->InvalidateType(expr));
 
     if (expr->Argument()->IsIdentifier()) {
         checker->ValidateUnaryOperatorOperand(expr->Argument()->AsIdentifier()->Variable());
@@ -3179,9 +3152,7 @@ checker::Type *ETSAnalyzer::Check(ir::ExpressionStatement *st) const
 static bool ValidateAndProcessIteratorType(ETSChecker *checker, Type *elemType, ir::ForOfStatement *const st)
 {
     checker::Type *iterType = GetIteratorType(checker, elemType, st->Left());
-    if (iterType->IsTypeError()) {
-        return false;
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, iterType, return false);
 
     const auto ident = st->Left()->IsVariableDeclaration()
                            ? st->Left()->AsVariableDeclaration()->Declarators().front()->Id()->AsIdentifier()
@@ -3700,16 +3671,12 @@ checker::Type *ETSAnalyzer::Check(ir::TSAsExpression *expr) const
 
     checker->CheckAnnotations(expr->TypeAnnotation()->Annotations());
     auto *const targetType = expr->TypeAnnotation()->AsTypeNode()->GetType(checker);
-    if (targetType->IsTypeError()) {
-        return checker->InvalidateType(expr);
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, targetType, return checker->InvalidateType(expr));
 
     expr->Expr()->SetPreferredType(targetType);
 
     auto const sourceType = expr->Expr()->Check(checker);
-    if (sourceType->IsTypeError()) {
-        return checker->InvalidateType(expr);
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, sourceType, return checker->InvalidateType(expr));
 
     if (sourceType->DefinitelyETSNullish() && !targetType->PossiblyETSNullish()) {
         return expr->SetTsType(checker->TypeError(expr, diagnostic::NULLISH_CAST_TO_NONNULLISH, expr->Start()));
@@ -3754,10 +3721,7 @@ checker::Type *ETSAnalyzer::Check(ir::TSInterfaceDeclaration *st) const
     ETSChecker *checker = GetETSChecker();
     auto *stmtType = checker->BuildBasicInterfaceProperties(st);
     ES2PANDA_ASSERT(stmtType != nullptr);
-
-    if (stmtType->IsTypeError()) {
-        return st->SetTsType(stmtType);
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, stmtType, return st->SetTsType(stmtType));
 
     auto *interfaceType = stmtType->IsGradualType() ? stmtType->AsGradualType()->GetBaseType()->AsETSObjectType()
                                                     : stmtType->AsETSObjectType();
diff --git a/ets2panda/checker/checker.cpp b/ets2panda/checker/checker.cpp
index ab4e17a2e079d1182cf78b6a0e32ecc6eedbaa1d..66387a1f4de20c94c34f3a0265b5081d67ced831 100644
--- a/ets2panda/checker/checker.cpp
+++ b/ets2panda/checker/checker.cpp
@@ -159,7 +159,7 @@ checker::SemanticAnalyzer *Checker::GetAnalyzer() const
     return analyzer_;
 }
 
-bool Checker::IsAnyError()
+bool Checker::IsAnyError() const
 {
     return DiagnosticEngine().IsAnyError();
 }
diff --git a/ets2panda/checker/checker.h b/ets2panda/checker/checker.h
index 04d1c376926c01e27f3afc0cb2bc3e37180a3439..e868b1a752afc602c09df997419bca9ce49f60c2 100644
--- a/ets2panda/checker/checker.h
+++ b/ets2panda/checker/checker.h
@@ -217,6 +217,11 @@ public:
 
     varbinder::VarBinder *VarBinder() const;
 
+    util::DiagnosticEngine const &DiagnosticEngine() const
+    {
+        return diagnosticEngine_;
+    }
+
     util::DiagnosticEngine &DiagnosticEngine()
     {
         return diagnosticEngine_;
@@ -230,7 +235,7 @@ public:
     // NOTE: required only for evaluate.
     void Initialize(varbinder::VarBinder *varbinder);
 
-    [[nodiscard]] bool IsAnyError();
+    [[nodiscard]] bool IsAnyError() const;
 
     virtual void CleanUp();
 
@@ -519,6 +524,31 @@ private:
     bool isLogError_;
 };
 
+// Santiy checking macros. Should always be true on a valid AST.
+// May fail on broken AST; in that case, `whatIfFail` is executed.
+
+// To invoke from outside code, such as static functions
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define ES2PANDA_AST_SANITY_CHECK_OUTER(checker, test, whatIfFail) \
+    if (!(test)) {                                                 \
+        ES2PANDA_ASSERT((checker)->IsAnyError());                  \
+        whatIfFail;                                                \
+    }
+
+// To invoke from checker's methods
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define ES2PANDA_AST_SANITY_CHECK(test, whatIfFail) ES2PANDA_AST_SANITY_CHECK_OUTER(this, test, whatIfFail)
+
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, type, whatIfFail) \
+    if ((type)->IsTypeError()) {                                      \
+        ES2PANDA_ASSERT((checker)->IsAnyError());                     \
+        whatIfFail;                                                   \
+    }
+
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define ES2PANDA_TYPE_CHECK_NO_ERROR(type, whatIfFail) ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(this, type, whatIfFail)
+
 }  // namespace ark::es2panda::checker
 
 #endif /* CHECKER_H */
diff --git a/ets2panda/checker/ets/arithmetic.cpp b/ets2panda/checker/ets/arithmetic.cpp
index b76c779b5ae596684a2d710a8dac3be1938a5747..511e029aa0d98d7a814469945967d27fe488ce89 100644
--- a/ets2panda/checker/ets/arithmetic.cpp
+++ b/ets2panda/checker/ets/arithmetic.cpp
@@ -925,10 +925,7 @@ Type *ETSChecker::CheckBinaryOperatorNullishCoalescing(ir::Expression *left, ir:
     }
     leftType = GetNonNullishType(leftType);
     ES2PANDA_ASSERT(leftType != nullptr);
-    if (leftType->IsTypeError()) {
-        ES2PANDA_ASSERT(IsAnyError());
-        return GlobalTypeError();
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR(leftType, return GlobalTypeError());
 
     auto *rightType = MaybeBoxType(right->TsType());
     if (IsTypeIdenticalTo(leftType, rightType)) {
diff --git a/ets2panda/checker/ets/function.cpp b/ets2panda/checker/ets/function.cpp
index 40a06e17af9b5a2894557e434ade655b7d0a7743..75139a945fccad21ee375083379fee1f2a8b326e 100644
--- a/ets2panda/checker/ets/function.cpp
+++ b/ets2panda/checker/ets/function.cpp
@@ -65,12 +65,11 @@ namespace ark::es2panda::checker {
 bool ETSChecker::IsCompatibleTypeArgument(ETSTypeParameter *typeParam, Type *typeArgument,
                                           const Substitution *substitution)
 {
+    ES2PANDA_TYPE_CHECK_NO_ERROR(typeArgument, return true);
     if (typeArgument->IsWildcardType()) {
         return true;
     }
-    if (typeArgument->IsTypeError()) {
-        return true;
-    }
+
     // NOTE(vpukhov): #19701 void refactoring
     if (typeArgument->IsETSVoidType()) {
         typeArgument = GlobalETSUndefinedType();
diff --git a/ets2panda/checker/ets/helpers.cpp b/ets2panda/checker/ets/helpers.cpp
index 095b9f0503e36efd4eabfe0252c84ded480c63d2..67a0f434ca533f36f1610520e6c13348bb4bb01f 100644
--- a/ets2panda/checker/ets/helpers.cpp
+++ b/ets2panda/checker/ets/helpers.cpp
@@ -547,9 +547,8 @@ checker::Type *ETSChecker::CheckArrayElements(ir::ArrayExpression *init)
     ArenaVector<checker::Type *> elementTypes(ProgramAllocator()->Adapter());
     for (auto *elementNode : init->AsArrayExpression()->Elements()) {
         Type *elementType = elementNode->Check(this);
-        if (elementType->IsTypeError()) {
-            return elementType;
-        }
+
+        ES2PANDA_TYPE_CHECK_NO_ERROR(elementType, return elementType);
 
         if (elementNode->IsSpreadElement() && elementType->IsETSTupleType()) {
             for (auto *typeFromTuple : elementType->AsETSTupleType()->GetTupleTypesList()) {
@@ -1113,9 +1112,7 @@ checker::Type *ETSChecker::ResolveSmartType(checker::Type *sourceType, checker::
     ES2PANDA_ASSERT(!targetType->IsETSPrimitiveType() && !sourceType->IsETSPrimitiveType());
 
     //  For left-hand invalid variable set smart type to right-hand type.
-    if (targetType->IsTypeError()) {
-        return sourceType;
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR(targetType, return sourceType);
 
     //  For type parameter, null or undefined source type return it as is.
     if (sourceType->IsETSTypeParameter() || sourceType->DefinitelyETSNullish()) {
@@ -3035,7 +3032,9 @@ void ETSChecker::GenerateGetterSetterPropertyAndMethod(ir::ClassProperty *origin
 
     SetupGetterSetterFlags(originalProp, classType, getter, setter, HasStatus(CheckerStatus::IN_EXTERNAL));
 
-    if (setter != nullptr && !setter->TsType()->IsTypeError()) {
+    if (setter != nullptr) {
+        ES2PANDA_TYPE_CHECK_NO_ERROR(setter->TsType(), return );
+
         getter->Variable()->TsType()->AsETSFunctionType()->AddCallSignature(
             setter->TsType()->AsETSFunctionType()->CallSignatures()[0]);
         getter->AddOverload(setter);
@@ -3122,9 +3121,8 @@ void ETSChecker::ImportNamespaceObjectTypeAddReExportType(ir::ETSImportDeclarati
             continue;
         }
         auto *reExportType = GetImportSpecifierObjectType(item->GetETSImportDeclarations(), ident);
-        if (reExportType->IsTypeError()) {
-            continue;
-        }
+        ES2PANDA_TYPE_CHECK_NO_ERROR(reExportType, continue);
+
         ES2PANDA_ASSERT(lastObjectType != nullptr);
         lastObjectType->AddReExports(reExportType->AsETSObjectType());
         for (auto node : importDecl->Specifiers()) {
diff --git a/ets2panda/checker/ets/object.cpp b/ets2panda/checker/ets/object.cpp
index 89ea548edcca14d5363eb948108357a36ff234b1..3daffc293030f8e17eff013c81cc453044d0977b 100644
--- a/ets2panda/checker/ets/object.cpp
+++ b/ets2panda/checker/ets/object.cpp
@@ -964,14 +964,13 @@ void ETSChecker::CheckInterfaceFunctions(ETSObjectType *classType)
 
     for (auto *const &interface : interfaces) {
         for (auto *const &prop : interface->Methods()) {
+            ES2PANDA_TYPE_CHECK_NO_ERROR(prop->TsType(), continue);
+
             if (prop->Declaration()->Node()->IsOverloadDeclaration()) {
                 continue;
             }
 
             ir::MethodDefinition *node = prop->Declaration()->Node()->AsMethodDefinition();
-            if (prop->TsType()->IsTypeError()) {
-                continue;
-            }
             auto *funcType = prop->TsType()->AsETSFunctionType();
             CallRedeclarationCheckForCorrectSignature(node, funcType, similarSignatures, classType, this);
             for (auto *const &overload : node->Overloads()) {
@@ -1259,9 +1258,7 @@ void ETSChecker::CheckClassDefinition(ir::ClassDefinition *classDef)
         classDef->SetTsType(GlobalTypeError());
     }
 
-    if (classDef->TsType()->IsTypeError()) {
-        return;
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR(classDef->TsType(), return );
 
     auto *classType = classDef->TsType()->MaybeBaseTypeOfGradualType()->AsETSObjectType();
     if (classType->SuperType() != nullptr) {
@@ -1603,9 +1600,7 @@ void ETSChecker::CheckInnerClassMembers(const ETSObjectType *classType)
 bool ETSChecker::ValidateArrayIndex(ir::Expression *const expr, bool relaxed)
 {
     auto const expressionType = expr->Check(this)->MaybeBaseTypeOfGradualType();
-    if (expressionType->IsTypeError()) {
-        return false;
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR(expressionType, return true);
 
     if (!expressionType->IsETSObjectType() ||
         (!expressionType->AsETSObjectType()->HasObjectFlag(relaxed ? ETSObjectFlags::BUILTIN_ARRAY_NUMERIC
diff --git a/ets2panda/checker/ets/typeCheckingHelpers.cpp b/ets2panda/checker/ets/typeCheckingHelpers.cpp
index e000739bc0271af8848248f4ebb6184a9c4d7771..39e4c51618c59a9ff470c0acf36a27783a5e4ae9 100644
--- a/ets2panda/checker/ets/typeCheckingHelpers.cpp
+++ b/ets2panda/checker/ets/typeCheckingHelpers.cpp
@@ -1158,10 +1158,10 @@ void ETSChecker::HandleAnnotationRetention(ir::AnnotationUsage *anno, ir::Annota
 
 void ETSChecker::CheckStandardAnnotation(ir::AnnotationUsage *anno)
 {
-    if (anno->GetBaseName()->Variable() == nullptr || IsTypeError(anno->GetBaseName()->TsType())) {
-        return;
-    }
+    ES2PANDA_AST_SANITY_CHECK(anno->GetBaseName()->Variable() != nullptr && !IsTypeError(anno->GetBaseName()->TsType()),
+                              return );
     ES2PANDA_ASSERT(anno->GetBaseName()->Variable()->Declaration()->Node()->AsAnnotationDeclaration() != nullptr);
+
     auto *annoDecl = anno->GetBaseName()->Variable()->Declaration()->Node()->AsAnnotationDeclaration();
     auto annoName = annoDecl->InternalName().Mutf8();
     if (annoName.rfind(compiler::Signatures::STD_ANNOTATIONS) != 0) {
@@ -1203,10 +1203,7 @@ static auto IsValidAnnotationPropInitializer(ir::Expression *init)
 
 static bool ValidateAnnotationPropertyType(checker::Type *type, ETSChecker *checker)
 {
-    if (type == nullptr || type->IsTypeError()) {
-        ES2PANDA_ASSERT(checker->IsAnyError());
-        return false;
-    }
+    ES2PANDA_AST_SANITY_CHECK_OUTER(checker, type != nullptr && !type->IsTypeError(), return false);
 
     if (type->IsETSArrayType() || type->IsETSResizableArrayType()) {
         return ValidateAnnotationPropertyType(checker->GetElementTypeOfArray(type), checker);
@@ -1800,10 +1797,8 @@ void ETSChecker::CheckConstructorOverloadDeclaration(ETSChecker *checker, ir::Ov
         // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint)
         Type *identType = checker->ResolveIdentifier(ident->AsIdentifier());
         ident->SetTsType(identType);
-        if (identType->IsTypeError()) {
-            continue;
-        }
 
+        ES2PANDA_TYPE_CHECK_NO_ERROR(identType, continue);
         ES2PANDA_ASSERT(identType->IsETSFunctionType());
         const size_t singleSignatureSize = 1;
         if (identType->AsETSFunctionType()->CallSignatures().size() > singleSignatureSize) {
diff --git a/ets2panda/checker/ets/typeRelationContext.cpp b/ets2panda/checker/ets/typeRelationContext.cpp
index 855ea818309eec24bf01bb68432e35ebd88e9010..ac3cd69423c6ba47f90a6bcb9b801655a4c6a6a0 100644
--- a/ets2panda/checker/ets/typeRelationContext.cpp
+++ b/ets2panda/checker/ets/typeRelationContext.cpp
@@ -74,10 +74,10 @@ void InstantiationContext::InstantiateType(ETSObjectType *type, ir::TSTypeParame
         for (auto *const it : typeArgs->Params()) {
             auto *paramType = it->GetType(checker_);
             ES2PANDA_ASSERT(paramType != nullptr);
-            if (paramType->IsTypeError()) {
+            ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker_, paramType, {
                 result_ = paramType;
                 return;
-            }
+            });
             ES2PANDA_ASSERT(!paramType->IsETSPrimitiveType());
             typeArgTypes.push_back(paramType);
         }
@@ -117,12 +117,12 @@ static void CheckInstantiationConstraints(ETSChecker *checker, ArenaVector<Type
         }
         auto typeParam = type->AsETSTypeParameter();
         auto typeArg = typeParam->Substitute(relation, substitution);
+
+        ES2PANDA_TYPE_CHECK_NO_ERROR_OUTER(checker, typeArg, continue);
         if (typeArg->IsWildcardType()) {
             continue;
         }
-        if (typeArg->IsTypeError()) {
-            continue;
-        }
+
         // NOTE(vpukhov): #19701 void refactoring
         ES2PANDA_ASSERT(typeArg->IsETSReferenceType() || typeArg->IsETSVoidType());
         auto maybeIrrelevantTypeArg = typeArg->IsETSVoidType() ? checker->GlobalETSUndefinedType() : typeArg;
diff --git a/ets2panda/checker/ets/utilityTypeHandlers.cpp b/ets2panda/checker/ets/utilityTypeHandlers.cpp
index 0c9e1114a7be99ac1510b62d0af097e0f8bc7fc8..b0cba40bfac4f8648b60c2c74c2d1407b48db9d4 100644
--- a/ets2panda/checker/ets/utilityTypeHandlers.cpp
+++ b/ets2panda/checker/ets/utilityTypeHandlers.cpp
@@ -51,10 +51,7 @@ Type *ETSChecker::HandleUtilityTypeParameterNode(const ir::TSTypeParameterInstan
     }
 
     Type *baseType = possiblyTypeParam.value()->Check(this);
-
-    if (baseType->IsTypeError()) {
-        return baseType;
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR(baseType, return baseType);
 
     if (!baseType->IsETSReferenceType()) {
         LogError(diagnostic::UTIL_TYPE_OF_NONREFERENCE, {}, typeParams->Start());
@@ -120,9 +117,7 @@ static T *CloneNodeIfNotNullptr(T *node, ArenaAllocator *allocator)
 Type *ETSChecker::CreatePartialType(Type *const typeToBePartial)
 {
     ES2PANDA_ASSERT(typeToBePartial->IsETSReferenceType());
-    if (typeToBePartial->IsTypeError()) {
-        return typeToBePartial;
-    }
+    ES2PANDA_TYPE_CHECK_NO_ERROR(typeToBePartial, return typeToBePartial);
 
     if (typeToBePartial->IsETSAnyType()) {
         return typeToBePartial;
@@ -895,9 +890,8 @@ Type *ETSChecker::CreatePartialTypeClassDef(ir::ClassDefinition *const partialCl
             LogError(diagnostic::CYCLIC_CLASS_SUPER_TYPE, {}, classDef->Start());
             return partialType;
         }
-        if (partialSuper->IsTypeError()) {
-            return partialType;
-        }
+        ES2PANDA_TYPE_CHECK_NO_ERROR(partialSuper, return partialType);
+
         partialType->SetSuperType(partialSuper->AsETSObjectType());
     }