diff --git a/src/language/ASTNodeAffectationExpressionBuilder.cpp b/src/language/ASTNodeAffectationExpressionBuilder.cpp
index 2b037d9ed94830e5ab1199f8e722925f3fbf4027..f0b5a93be4cd34abb287d754bdbd9c1495552d6d 100644
--- a/src/language/ASTNodeAffectationExpressionBuilder.cpp
+++ b/src/language/ASTNodeAffectationExpressionBuilder.cpp
@@ -29,10 +29,12 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode
         n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, double>>(n);
         break;
       }
+        // LCOV_EXCL_START
       default: {
         throw parse_error("unexpected error: undefined operand type for affectation",
                           std::vector{n.children[1]->begin()});
       }
+        // LCOV_EXCL_STOP
       }
     };
 
@@ -61,10 +63,12 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode
           n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, std::string, std::string>>(n);
           break;
         }
+          // LCOV_EXCL_START
         default: {
           throw parse_error("unexpected error: undefined operand type for string affectation",
                             std::vector{n.children[1]->begin()});
         }
+          // LCOV_EXCL_STOP
         }
       } else {
         throw parse_error("unexpected error: undefined operator type", std::vector{n.children[0]->begin()});
diff --git a/src/language/ASTNodeCFunctionExpressionBuilder.cpp b/src/language/ASTNodeCFunctionExpressionBuilder.cpp
index d3491746cb01b97aa610bd8cfb38e3c26b3a8f1f..6e93f998a87302d2eec64567774cb1085537ac04 100644
--- a/src/language/ASTNodeCFunctionExpressionBuilder.cpp
+++ b/src/language/ASTNodeCFunctionExpressionBuilder.cpp
@@ -29,10 +29,12 @@ ASTNodeCFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeDataType&
     case ASTNodeDataType::double_t: {
       return std::make_unique<FunctionArgumentConverter<ParameterT, double>>(argument_number);
     }
+      // LCOV_EXCL_START
     default: {
       throw parse_error("unexpected error: invalid argument type for function",
                         std::vector{argument_node_sub_data_type.m_parent_node.begin()});
     }
+      // LCOV_EXCL_STOP
     }
   };
 
@@ -50,10 +52,12 @@ ASTNodeCFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeDataType&
     case ASTNodeDataType::double_t: {
       return get_function_argument_converter_for(double{});
     }
+      // LCOV_EXCL_START
     default: {
       throw parse_error("unexpected error: undefined parameter type for function",
                         std::vector{argument_node_sub_data_type.m_parent_node.begin()});
     }
+      // LCOV_EXCL_STOP
     }
   };
 
diff --git a/src/language/ASTNodeFunctionExpressionBuilder.cpp b/src/language/ASTNodeFunctionExpressionBuilder.cpp
index afea37ad557ddaa45ec2669ab0f9989a3698f731..8b3787fd54fa5b95568cd25f2b2132ebd5daa016 100644
--- a/src/language/ASTNodeFunctionExpressionBuilder.cpp
+++ b/src/language/ASTNodeFunctionExpressionBuilder.cpp
@@ -180,7 +180,9 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType ex
       if constexpr (std::is_same_v<ReturnT, std::string>) {
         return std::make_unique<FunctionExpressionProcessor<ReturnT, std::string>>(function_component_expression);
       } else {
+        // LCOV_EXCL_START
         throw parse_error("unexpected error: invalid string conversion", std::vector{node.children[1]->begin()});
+        // LCOV_EXCL_STOP
       }
     }
       // LCOV_EXCL_START
diff --git a/src/language/ASTNodeListAffectationExpressionBuilder.cpp b/src/language/ASTNodeListAffectationExpressionBuilder.cpp
index b95f4777d259975a7755773c80a1350d24964c4a..a0bbeb88a7954b7701935c9604a5eefa234eb0ae 100644
--- a/src/language/ASTNodeListAffectationExpressionBuilder.cpp
+++ b/src/language/ASTNodeListAffectationExpressionBuilder.cpp
@@ -32,10 +32,12 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
       list_affectation_processor->template add<ValueT, double>(value_node);
       break;
     }
+      // LCOV_EXCL_START
     default: {
       throw parse_error("unexpected error: invalid operand type for affectation",
                         std::vector{node_sub_data_type.m_parent_node.begin()});
     }
+      // LCOV_EXCL_STOP
     }
   };
 
@@ -62,10 +64,12 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
         list_affectation_processor->template add<std::string, std::string>(value_node);
         break;
       }
+        // LCOV_EXCL_START
       default: {
         throw parse_error("invalid operand type for string affectation",
                           std::vector{node_sub_data_type.m_parent_node.begin()});
       }
+        // LCOV_EXCL_STOP
       }
     } else {
       throw parse_error("unexpected error: undefined operator type for string affectation",
@@ -98,9 +102,12 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
       add_affectation_processor_for_string_data(node_sub_data_type);
       break;
     }
+      // LCOV_EXCL_START
     default: {
-      throw parse_error("undefined value type for tuple affectation", std::vector{value_node.begin()});
+      throw parse_error("unexpected error: undefined value type for tuple affectation",
+                        std::vector{value_node.begin()});
     }
+      // LCOV_EXCL_STOP
     }
   };
 
diff --git a/src/language/ASTNodeNaturalConversionChecker.cpp b/src/language/ASTNodeNaturalConversionChecker.cpp
index d625d639bfe607d3b6aa0ff4a597361ddc7d6e3b..abf672e0d4adab59cef61b8c211e8f85ea24242b 100644
--- a/src/language/ASTNodeNaturalConversionChecker.cpp
+++ b/src/language/ASTNodeNaturalConversionChecker.cpp
@@ -6,8 +6,9 @@ ASTNodeNaturalConversionChecker::ASTNodeNaturalConversionChecker(const ASTNode&
 {
   if (not isNaturalConversion(data_type, target_data_type)) {
     std::ostringstream error_message;
-    error_message << "invalid implicit conversion: " << dataTypeName(data_type) << " -> "
-                  << dataTypeName(target_data_type);
+    error_message << "invalid implicit conversion: ";
+    error_message << rang::fgB::red << dataTypeName(data_type) << " -> " << dataTypeName(target_data_type)
+                  << rang::fg::reset;
     throw parse_error(error_message.str(), node.begin());
   }
 }
diff --git a/src/language/node_processor/BinaryExpressionProcessor.hpp b/src/language/node_processor/BinaryExpressionProcessor.hpp
index 6a54abcfc5c9272531a4e1ea8399133a51f8e8bb..8089ea9d28212bfd7ce2c11081c1faa53f76934e 100644
--- a/src/language/node_processor/BinaryExpressionProcessor.hpp
+++ b/src/language/node_processor/BinaryExpressionProcessor.hpp
@@ -208,7 +208,9 @@ class BinaryExpressionProcessor final : public INodeProcessor
   BinaryExpressionProcessor(ASTNode& node) : m_node{node}
   {
     if constexpr (not _is_defined) {
+      // LCOV_EXCL_START
       throw parse_error("invalid operands to binary expression", std::vector{m_node.begin()});
+      // LCOV_EXCL_STOP
     }
   }
 };