From d1893e01fe3b8fb6fcffa959a517c1a76216e118 Mon Sep 17 00:00:00 2001
From: Stephane Del Pino <stephane.delpino44@gmail.com>
Date: Mon, 5 Jun 2023 00:04:18 +0200
Subject: [PATCH] Modernize bunch of code

---
 ...STNodeBuiltinFunctionExpressionBuilder.cpp |  67 +++++-----
 .../ast/ASTNodeFunctionExpressionBuilder.cpp  | 126 ++++++++----------
 ...STNodeListAffectationExpressionBuilder.cpp |  47 +++----
 3 files changed, 109 insertions(+), 131 deletions(-)

diff --git a/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp b/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp
index e2b4a947f..169540df2 100644
--- a/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp
@@ -13,9 +13,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
                                                                const ASTNodeSubDataType& argument_node_sub_data_type,
                                                                const size_t argument_number)
 {
-  auto get_function_argument_converter_for =
-    [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> {
-    using ParameterT = std::decay_t<decltype(parameter_v)>;
+  auto get_function_argument_converter_for = [&]<typename ParameterT>() -> std::unique_ptr<IFunctionArgumentConverter> {
     switch (argument_node_sub_data_type.m_data_type) {
     case ASTNodeDataType::bool_t: {
       return std::make_unique<FunctionArgumentConverter<ParameterT, bool>>(argument_number);
@@ -39,9 +37,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
   };
 
   auto get_function_argument_converter_for_vector =
-    [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> {
-    using ParameterT = std::decay_t<decltype(parameter_v)>;
-
+    [&]<typename ParameterT>() -> std::unique_ptr<IFunctionArgumentConverter> {
     if constexpr (std::is_same_v<ParameterT, TinyVector<1>>) {
       switch (argument_node_sub_data_type.m_data_type) {
       case ASTNodeDataType::vector_t: {
@@ -76,7 +72,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
     } else {
       switch (argument_node_sub_data_type.m_data_type) {
       case ASTNodeDataType::vector_t: {
-        if (argument_node_sub_data_type.m_data_type.dimension() == parameter_v.dimension()) {
+        if (argument_node_sub_data_type.m_data_type.dimension() == ParameterT::Dimension) {
           return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, ParameterT>>(argument_number);
         } else {
           // LCOV_EXCL_START
@@ -104,9 +100,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
   };
 
   auto get_function_argument_converter_for_matrix =
-    [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> {
-    using ParameterT = std::decay_t<decltype(parameter_v)>;
-
+    [&]<typename ParameterT>() -> std::unique_ptr<IFunctionArgumentConverter> {
     if constexpr (std::is_same_v<ParameterT, TinyMatrix<1>>) {
       switch (argument_node_sub_data_type.m_data_type) {
       case ASTNodeDataType::matrix_t: {
@@ -142,8 +136,8 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
     } else {
       switch (argument_node_sub_data_type.m_data_type) {
       case ASTNodeDataType::matrix_t: {
-        if ((argument_node_sub_data_type.m_data_type.numberOfRows() == parameter_v.numberOfRows()) and
-            (argument_node_sub_data_type.m_data_type.numberOfColumns() == parameter_v.numberOfColumns())) {
+        if ((argument_node_sub_data_type.m_data_type.numberOfRows() == ParameterT::NumberOfRows) and
+            (argument_node_sub_data_type.m_data_type.numberOfColumns() == ParameterT::NumberOfColumns)) {
           return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, ParameterT>>(argument_number);
         } else {
           // LCOV_EXCL_START
@@ -189,8 +183,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
   };
 
   auto get_function_argument_to_tuple_converter =
-    [&](const auto& parameter_content_v) -> std::unique_ptr<IFunctionArgumentConverter> {
-    using ParameterContentT   = std::decay_t<decltype(parameter_content_v)>;
+    [&]<typename ParameterContentT>() -> std::unique_ptr<IFunctionArgumentConverter> {
     const auto& arg_data_type = argument_node_sub_data_type.m_data_type;
     switch (arg_data_type) {
     case ASTNodeDataType::tuple_t: {
@@ -321,27 +314,27 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
   auto get_function_argument_converter_for_argument_type = [&]() {
     switch (parameter_type) {
     case ASTNodeDataType::bool_t: {
-      return get_function_argument_converter_for(bool{});
+      return get_function_argument_converter_for.template operator()<bool>();
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return get_function_argument_converter_for(uint64_t{});
+      return get_function_argument_converter_for.template operator()<uint64_t>();
     }
     case ASTNodeDataType::int_t: {
-      return get_function_argument_converter_for(int64_t{});
+      return get_function_argument_converter_for.template operator()<int64_t>();
     }
     case ASTNodeDataType::double_t: {
-      return get_function_argument_converter_for(double{});
+      return get_function_argument_converter_for.template operator()<double>();
     }
     case ASTNodeDataType::vector_t: {
       switch (parameter_type.dimension()) {
       case 1: {
-        return get_function_argument_converter_for_vector(TinyVector<1>{});
+        return get_function_argument_converter_for_vector.template operator()<TinyVector<1>>();
       }
       case 2: {
-        return get_function_argument_converter_for_vector(TinyVector<2>{});
+        return get_function_argument_converter_for_vector.template operator()<TinyVector<2>>();
       }
       case 3: {
-        return get_function_argument_converter_for_vector(TinyVector<3>{});
+        return get_function_argument_converter_for_vector.template operator()<TinyVector<3>>();
       }
         // LCOV_EXCL_START
       default: {
@@ -355,13 +348,13 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
       Assert(parameter_type.numberOfRows() == parameter_type.numberOfColumns());
       switch (parameter_type.numberOfRows()) {
       case 1: {
-        return get_function_argument_converter_for_matrix(TinyMatrix<1>{});
+        return get_function_argument_converter_for_matrix.template operator()<TinyMatrix<1>>();
       }
       case 2: {
-        return get_function_argument_converter_for_matrix(TinyMatrix<2>{});
+        return get_function_argument_converter_for_matrix.template operator()<TinyMatrix<2>>();
       }
       case 3: {
-        return get_function_argument_converter_for_matrix(TinyMatrix<3>{});
+        return get_function_argument_converter_for_matrix.template operator()<TinyMatrix<3>>();
       }
         // LCOV_EXCL_START
       default: {
@@ -383,33 +376,33 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
     case ASTNodeDataType::tuple_t: {
       switch (parameter_type.contentType()) {
       case ASTNodeDataType::type_id_t: {
-        return get_function_argument_to_tuple_converter(EmbeddedData{});
+        return get_function_argument_to_tuple_converter.template operator()<EmbeddedData>();
       }
       case ASTNodeDataType::bool_t: {
-        return get_function_argument_to_tuple_converter(bool{});
+        return get_function_argument_to_tuple_converter.template operator()<bool>();
       }
       case ASTNodeDataType::unsigned_int_t: {
-        return get_function_argument_to_tuple_converter(uint64_t{});
+        return get_function_argument_to_tuple_converter.template operator()<uint64_t>();
       }
       case ASTNodeDataType::int_t: {
-        return get_function_argument_to_tuple_converter(int64_t{});
+        return get_function_argument_to_tuple_converter.template operator()<int64_t>();
       }
       case ASTNodeDataType::double_t: {
-        return get_function_argument_to_tuple_converter(double{});
+        return get_function_argument_to_tuple_converter.template operator()<double>();
       }
       case ASTNodeDataType::function_t: {
-        return get_function_argument_to_tuple_converter(FunctionSymbolId{});
+        return get_function_argument_to_tuple_converter.template operator()<FunctionSymbolId>();
       }
       case ASTNodeDataType::vector_t: {
         switch (parameter_type.contentType().dimension()) {
         case 1: {
-          return get_function_argument_to_tuple_converter(TinyVector<1>{});
+          return get_function_argument_to_tuple_converter.template operator()<TinyVector<1>>();
         }
         case 2: {
-          return get_function_argument_to_tuple_converter(TinyVector<2>{});
+          return get_function_argument_to_tuple_converter.template operator()<TinyVector<2>>();
         }
         case 3: {
-          return get_function_argument_to_tuple_converter(TinyVector<3>{});
+          return get_function_argument_to_tuple_converter.template operator()<TinyVector<3>>();
         }
         // LCOV_EXCL_START
         default: {
@@ -424,13 +417,13 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
         Assert(parameter_type.contentType().numberOfRows() == parameter_type.contentType().numberOfColumns());
         switch (parameter_type.contentType().numberOfRows()) {
         case 1: {
-          return get_function_argument_to_tuple_converter(TinyMatrix<1>{});
+          return get_function_argument_to_tuple_converter.template operator()<TinyMatrix<1>>();
         }
         case 2: {
-          return get_function_argument_to_tuple_converter(TinyMatrix<2>{});
+          return get_function_argument_to_tuple_converter.template operator()<TinyMatrix<2>>();
         }
         case 3: {
-          return get_function_argument_to_tuple_converter(TinyMatrix<3>{});
+          return get_function_argument_to_tuple_converter.template operator()<TinyMatrix<3>>();
         }
         // LCOV_EXCL_START
         default: {
@@ -442,7 +435,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
         }
       }
       case ASTNodeDataType::string_t: {
-        return get_function_argument_to_tuple_converter(std::string{});
+        return get_function_argument_to_tuple_converter.template operator()<std::string>();
       }
         // LCOV_EXCL_START
       default: {
diff --git a/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp b/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp
index 7e0d981c3..ade274716 100644
--- a/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp
@@ -17,9 +17,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
 
   ASTNodeNaturalConversionChecker<AllowRToR1Conversion>{node_sub_data_type, parameter_symbol.attributes().dataType()};
 
-  auto get_function_argument_converter_for =
-    [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> {
-    using ParameterT = std::decay_t<decltype(parameter_v)>;
+  auto get_function_argument_converter_for = [&]<typename ParameterT>() -> std::unique_ptr<IFunctionArgumentConverter> {
     switch (node_sub_data_type.m_data_type) {
     case ASTNodeDataType::bool_t: {
       return std::make_unique<FunctionArgumentConverter<ParameterT, bool>>(parameter_id);
@@ -65,11 +63,10 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
   };
 
   auto get_function_argument_converter_for_vector =
-    [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> {
-    using ParameterT = std::decay_t<decltype(parameter_v)>;
+    [&]<typename ParameterT>() -> std::unique_ptr<IFunctionArgumentConverter> {
     switch (node_sub_data_type.m_data_type) {
     case ASTNodeDataType::vector_t: {
-      if (node_sub_data_type.m_data_type.dimension() == parameter_v.dimension()) {
+      if (node_sub_data_type.m_data_type.dimension() == ParameterT::Dimension) {
         return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, ParameterT>>(parameter_id);
       } else {
         // LCOV_EXCL_START
@@ -79,7 +76,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
       }
     }
     case ASTNodeDataType::bool_t: {
-      if ((parameter_v.dimension() == 1)) {
+      if constexpr (ParameterT::Dimension == 1) {
         return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, bool>>(parameter_id);
       } else {
         // LCOV_EXCL_START
@@ -89,7 +86,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
       }
     }
     case ASTNodeDataType::int_t: {
-      if ((parameter_v.dimension() == 1)) {
+      if constexpr (ParameterT::Dimension == 1) {
         return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, int64_t>>(parameter_id);
       } else if (node_sub_data_type.m_parent_node.is_type<language::integer>()) {
         if (std::stoi(node_sub_data_type.m_parent_node.string()) == 0) {
@@ -102,7 +99,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
       // LCOV_EXCL_STOP
     }
     case ASTNodeDataType::unsigned_int_t: {
-      if ((parameter_v.dimension() == 1)) {
+      if constexpr (ParameterT::Dimension == 1) {
         return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, uint64_t>>(parameter_id);
       } else {
         // LCOV_EXCL_START
@@ -112,7 +109,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
       }
     }
     case ASTNodeDataType::double_t: {
-      if ((parameter_v.dimension() == 1)) {
+      if constexpr (ParameterT::Dimension == 1) {
         return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, double>>(parameter_id);
       } else {
         // LCOV_EXCL_START
@@ -131,12 +128,11 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
   };
 
   auto get_function_argument_converter_for_matrix =
-    [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> {
-    using ParameterT = std::decay_t<decltype(parameter_v)>;
+    [&]<typename ParameterT>() -> std::unique_ptr<IFunctionArgumentConverter> {
     switch (node_sub_data_type.m_data_type) {
     case ASTNodeDataType::matrix_t: {
-      if ((node_sub_data_type.m_data_type.numberOfRows() == parameter_v.numberOfRows()) and
-          (node_sub_data_type.m_data_type.numberOfColumns() == parameter_v.numberOfColumns())) {
+      if ((node_sub_data_type.m_data_type.numberOfRows() == ParameterT::NumberOfRows) and
+          (node_sub_data_type.m_data_type.numberOfColumns() == ParameterT::NumberOfColumns)) {
         return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, ParameterT>>(parameter_id);
       } else {
         // LCOV_EXCL_START
@@ -146,7 +142,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
       }
     }
     case ASTNodeDataType::bool_t: {
-      if ((parameter_v.numberOfRows() == 1) and (parameter_v.numberOfColumns() == 1)) {
+      if constexpr ((ParameterT::NumberOfRows == 1) and (ParameterT::NumberOfColumns == 1)) {
         return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, bool>>(parameter_id);
       } else {
         // LCOV_EXCL_START
@@ -156,7 +152,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
       }
     }
     case ASTNodeDataType::int_t: {
-      if ((parameter_v.numberOfRows() == 1) and (parameter_v.numberOfColumns() == 1)) {
+      if constexpr ((ParameterT::NumberOfRows == 1) and (ParameterT::NumberOfColumns == 1)) {
         return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, int64_t>>(parameter_id);
       } else if (node_sub_data_type.m_parent_node.is_type<language::integer>()) {
         if (std::stoi(node_sub_data_type.m_parent_node.string()) == 0) {
@@ -169,7 +165,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
       // LCOV_EXCL_STOP
     }
     case ASTNodeDataType::unsigned_int_t: {
-      if ((parameter_v.numberOfRows() == 1) and (parameter_v.numberOfColumns() == 1)) {
+      if constexpr ((ParameterT::NumberOfRows == 1) and (ParameterT::NumberOfColumns == 1)) {
         return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, uint64_t>>(parameter_id);
       } else {
         // LCOV_EXCL_START
@@ -179,7 +175,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
       }
     }
     case ASTNodeDataType::double_t: {
-      if ((parameter_v.numberOfRows() == 1) and (parameter_v.numberOfColumns() == 1)) {
+      if constexpr ((ParameterT::NumberOfRows == 1) and (ParameterT::NumberOfColumns == 1)) {
         return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, double>>(parameter_id);
       } else {
         // LCOV_EXCL_START
@@ -204,16 +200,16 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
   auto get_function_argument_converter_for_parameter_type = [&]() {
     switch (parameter_symbol.attributes().dataType()) {
     case ASTNodeDataType::bool_t: {
-      return get_function_argument_converter_for(bool{});
+      return get_function_argument_converter_for.template operator()<bool>();
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return get_function_argument_converter_for(uint64_t{});
+      return get_function_argument_converter_for.template operator()<uint64_t>();
     }
     case ASTNodeDataType::int_t: {
-      return get_function_argument_converter_for(int64_t{});
+      return get_function_argument_converter_for.template operator()<int64_t>();
     }
     case ASTNodeDataType::double_t: {
-      return get_function_argument_converter_for(double{});
+      return get_function_argument_converter_for.template operator()<double>();
     }
     case ASTNodeDataType::string_t: {
       return get_function_argument_converter_for_string();
@@ -221,13 +217,13 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
     case ASTNodeDataType::vector_t: {
       switch (parameter_symbol.attributes().dataType().dimension()) {
       case 1: {
-        return get_function_argument_converter_for_vector(TinyVector<1>{});
+        return get_function_argument_converter_for_vector.template operator()<TinyVector<1>>();
       }
       case 2: {
-        return get_function_argument_converter_for_vector(TinyVector<2>{});
+        return get_function_argument_converter_for_vector.template operator()<TinyVector<2>>();
       }
       case 3: {
-        return get_function_argument_converter_for_vector(TinyVector<3>{});
+        return get_function_argument_converter_for_vector.template operator()<TinyVector<3>>();
       }
       }
       // LCOV_EXCL_START
@@ -240,13 +236,13 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
 
       switch (parameter_symbol.attributes().dataType().numberOfRows()) {
       case 1: {
-        return get_function_argument_converter_for_matrix(TinyMatrix<1>{});
+        return get_function_argument_converter_for_matrix.template operator()<TinyMatrix<1>>();
       }
       case 2: {
-        return get_function_argument_converter_for_matrix(TinyMatrix<2>{});
+        return get_function_argument_converter_for_matrix.template operator()<TinyMatrix<2>>();
       }
       case 3: {
-        return get_function_argument_converter_for_matrix(TinyMatrix<3>{});
+        return get_function_argument_converter_for_matrix.template operator()<TinyMatrix<3>>();
       }
       }
       // LCOV_EXCL_START
@@ -335,8 +331,7 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
                                                         ASTNode& node,
                                                         ASTNode& function_component_expression)
 {
-  auto get_function_processor_for_expression_value = [&](const auto& return_v) -> std::unique_ptr<INodeProcessor> {
-    using ReturnT = std::decay_t<decltype(return_v)>;
+  auto get_function_processor_for_expression_value = [&]<typename ReturnT>() -> std::unique_ptr<INodeProcessor> {
     switch (function_component_expression.m_data_type) {
     case ASTNodeDataType::bool_t: {
       return std::make_unique<FunctionExpressionProcessor<ReturnT, bool>>(function_component_expression);
@@ -368,11 +363,10 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
     }
   };
 
-  auto get_function_processor_for_expression_vector = [&](const auto& return_v) -> std::unique_ptr<INodeProcessor> {
-    using ReturnT = std::decay_t<decltype(return_v)>;
+  auto get_function_processor_for_expression_vector = [&]<typename ReturnT>() -> std::unique_ptr<INodeProcessor> {
     switch (function_component_expression.m_data_type) {
     case ASTNodeDataType::vector_t: {
-      if (function_component_expression.m_data_type.dimension() == return_v.dimension()) {
+      if (function_component_expression.m_data_type.dimension() == ReturnT::Dimension) {
         return std::make_unique<FunctionExpressionProcessor<ReturnT, ReturnT>>(function_component_expression);
       } else {
         // LCOV_EXCL_START
@@ -401,12 +395,11 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
     }
   };
 
-  auto get_function_processor_for_expression_matrix = [&](const auto& return_v) -> std::unique_ptr<INodeProcessor> {
-    using ReturnT = std::decay_t<decltype(return_v)>;
+  auto get_function_processor_for_expression_matrix = [&]<typename ReturnT>() -> std::unique_ptr<INodeProcessor> {
     switch (function_component_expression.m_data_type) {
     case ASTNodeDataType::matrix_t: {
-      if ((function_component_expression.m_data_type.numberOfRows() == return_v.numberOfRows()) and
-          (function_component_expression.m_data_type.numberOfColumns() == return_v.numberOfColumns())) {
+      if ((function_component_expression.m_data_type.numberOfRows() == ReturnT::NumberOfRows) and
+          (function_component_expression.m_data_type.numberOfColumns() == ReturnT::NumberOfColumns)) {
         return std::make_unique<FunctionExpressionProcessor<ReturnT, ReturnT>>(function_component_expression);
       } else {
         // LCOV_EXCL_START
@@ -458,8 +451,7 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
   };
 
   auto get_function_processor_for_expression_tuple_of_value =
-    [&](const auto& tuple_content_v) -> std::unique_ptr<INodeProcessor> {
-    using TupleContentT = std::decay_t<decltype(tuple_content_v)>;
+    [&]<typename TupleContentT>() -> std::unique_ptr<INodeProcessor> {
     switch (function_component_expression.m_data_type) {
     case ASTNodeDataType::bool_t: {
       return std::make_unique<FunctionExpressionProcessor<std::vector<TupleContentT>, bool>>(
@@ -632,8 +624,7 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
   };
 
   auto get_function_processor_for_expression_tuple_of_vector =
-    [&](const auto& tuple_content_v) -> std::unique_ptr<INodeProcessor> {
-    using TupleContentT = std::decay_t<decltype(tuple_content_v)>;
+    [&]<typename TupleContentT>() -> std::unique_ptr<INodeProcessor> {
     if constexpr (TupleContentT::Dimension == 1) {
       switch (function_component_expression.m_data_type) {
       case ASTNodeDataType::bool_t: {
@@ -774,8 +765,7 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
   };
 
   auto get_function_processor_for_expression_tuple_of_matrix =
-    [&](const auto& tuple_content_v) -> std::unique_ptr<INodeProcessor> {
-    using TupleContentT = std::decay_t<decltype(tuple_content_v)>;
+    [&]<typename TupleContentT>() -> std::unique_ptr<INodeProcessor> {
     static_assert(TupleContentT::NumberOfColumns == TupleContentT::NumberOfRows);
 
     if constexpr (TupleContentT::NumberOfRows == 1) {
@@ -930,13 +920,13 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
     case ASTNodeDataType::vector_t: {
       switch (tuple_content_v.dimension()) {
       case 1: {
-        return get_function_processor_for_expression_tuple_of_vector(TinyVector<1>{});
+        return get_function_processor_for_expression_tuple_of_vector.template operator()<TinyVector<1>>();
       }
       case 2: {
-        return get_function_processor_for_expression_tuple_of_vector(TinyVector<2>{});
+        return get_function_processor_for_expression_tuple_of_vector.template operator()<TinyVector<2>>();
       }
       case 3: {
-        return get_function_processor_for_expression_tuple_of_vector(TinyVector<3>{});
+        return get_function_processor_for_expression_tuple_of_vector.template operator()<TinyVector<3>>();
       }
         // LCOV_EXCL_START
       default: {
@@ -950,13 +940,13 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
       if (tuple_content_v.numberOfRows() == tuple_content_v.numberOfColumns()) {
         switch (tuple_content_v.numberOfRows()) {
         case 1: {
-          return get_function_processor_for_expression_tuple_of_matrix(TinyMatrix<1>{});
+          return get_function_processor_for_expression_tuple_of_matrix.template operator()<TinyMatrix<1>>();
         }
         case 2: {
-          return get_function_processor_for_expression_tuple_of_matrix(TinyMatrix<2>{});
+          return get_function_processor_for_expression_tuple_of_matrix.template operator()<TinyMatrix<2>>();
         }
         case 3: {
-          return get_function_processor_for_expression_tuple_of_matrix(TinyMatrix<3>{});
+          return get_function_processor_for_expression_tuple_of_matrix.template operator()<TinyMatrix<3>>();
         }
           // LCOV_EXCL_START
         default: {
@@ -973,22 +963,22 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
       }
     }
     case ASTNodeDataType::bool_t: {
-      return get_function_processor_for_expression_tuple_of_value(bool{});
+      return get_function_processor_for_expression_tuple_of_value.template operator()<bool>();
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return get_function_processor_for_expression_tuple_of_value(uint64_t{});
+      return get_function_processor_for_expression_tuple_of_value.template operator()<uint64_t>();
     }
     case ASTNodeDataType::int_t: {
-      return get_function_processor_for_expression_tuple_of_value(int64_t{});
+      return get_function_processor_for_expression_tuple_of_value.template operator()<int64_t>();
     }
     case ASTNodeDataType::double_t: {
-      return get_function_processor_for_expression_tuple_of_value(double{});
+      return get_function_processor_for_expression_tuple_of_value.template operator()<double>();
     }
     case ASTNodeDataType::type_id_t: {
-      return get_function_processor_for_expression_tuple_of_value(EmbeddedData{});
+      return get_function_processor_for_expression_tuple_of_value.template operator()<EmbeddedData>();
     }
     case ASTNodeDataType::string_t: {
-      return get_function_processor_for_expression_tuple_of_value(std::string{});
+      return get_function_processor_for_expression_tuple_of_value.template operator()<std::string>();
     }
       // LCOV_EXCL_START
     default: {
@@ -1001,31 +991,31 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
   auto get_function_processor_for_value = [&]() {
     switch (return_value_type) {
     case ASTNodeDataType::bool_t: {
-      return get_function_processor_for_expression_value(bool{});
+      return get_function_processor_for_expression_value.template operator()<bool>();
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return get_function_processor_for_expression_value(uint64_t{});
+      return get_function_processor_for_expression_value.template operator()<uint64_t>();
     }
     case ASTNodeDataType::int_t: {
-      return get_function_processor_for_expression_value(int64_t{});
+      return get_function_processor_for_expression_value.template operator()<int64_t>();
     }
     case ASTNodeDataType::double_t: {
-      return get_function_processor_for_expression_value(double{});
+      return get_function_processor_for_expression_value.template operator()<double>();
     }
     case ASTNodeDataType::vector_t: {
       switch (return_value_type.dimension()) {
       case 1: {
         if (function_component_expression.m_data_type == ASTNodeDataType::vector_t) {
-          return get_function_processor_for_expression_vector(TinyVector<1>{});
+          return get_function_processor_for_expression_vector.template operator()<TinyVector<1>>();
         } else {
-          return get_function_processor_for_expression_value(TinyVector<1>{});
+          return get_function_processor_for_expression_value.template operator()<TinyVector<1>>();
         }
       }
       case 2: {
-        return get_function_processor_for_expression_vector(TinyVector<2>{});
+        return get_function_processor_for_expression_vector.template operator()<TinyVector<2>>();
       }
       case 3: {
-        return get_function_processor_for_expression_vector(TinyVector<3>{});
+        return get_function_processor_for_expression_vector.template operator()<TinyVector<3>>();
       }
         // LCOV_EXCL_START
       default: {
@@ -1040,16 +1030,16 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
       switch (return_value_type.numberOfRows()) {
       case 1: {
         if (function_component_expression.m_data_type == ASTNodeDataType::matrix_t) {
-          return get_function_processor_for_expression_matrix(TinyMatrix<1>{});
+          return get_function_processor_for_expression_matrix.template operator()<TinyMatrix<1>>();
         } else {
-          return get_function_processor_for_expression_value(TinyMatrix<1>{});
+          return get_function_processor_for_expression_value.template operator()<TinyMatrix<1>>();
         }
       }
       case 2: {
-        return get_function_processor_for_expression_matrix(TinyMatrix<2>{});
+        return get_function_processor_for_expression_matrix.template operator()<TinyMatrix<2>>();
       }
       case 3: {
-        return get_function_processor_for_expression_matrix(TinyMatrix<3>{});
+        return get_function_processor_for_expression_matrix.template operator()<TinyMatrix<3>>();
       }
         // LCOV_EXCL_START
       default: {
@@ -1059,7 +1049,7 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
       }
     }
     case ASTNodeDataType::string_t: {
-      return get_function_processor_for_expression_value(std::string{});
+      return get_function_processor_for_expression_value.template operator()<std::string>();
     }
     case ASTNodeDataType::type_id_t: {
       return get_function_processor_for_expression_type_id(return_value_type.nameOfTypeId());
diff --git a/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp b/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp
index ec499edb3..fc3df0d17 100644
--- a/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp
@@ -381,8 +381,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
   ASTNode& value_node,
   std::unique_ptr<ListAffectationProcessor<OperatorT>>& list_affectation_processor)
 {
-  auto add_affectation_processor_for_data = [&](const auto& value, const ASTNodeSubDataType& node_sub_data_type) {
-    using ValueT = std::decay_t<decltype(value)>;
+  auto add_affectation_processor_for_data = [&]<typename ValueT>(const ASTNodeSubDataType& node_sub_data_type) {
     switch (node_sub_data_type.m_data_type) {
     case ASTNodeDataType::bool_t: {
       list_affectation_processor->template add<ValueT, bool>(value_node);
@@ -408,19 +407,17 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
     }
   };
 
-  auto add_affectation_processor_for_vector_data = [&](const auto& value,
-                                                       const ASTNodeSubDataType& node_sub_data_type) {
-    using ValueT = std::decay_t<decltype(value)>;
+  auto add_affectation_processor_for_vector_data = [&]<typename ValueT>(const ASTNodeSubDataType& node_sub_data_type) {
     if constexpr (std::is_same_v<ValueT, TinyVector<1>>) {
       if ((node_sub_data_type.m_data_type == ASTNodeDataType::vector_t) and
-          (node_sub_data_type.m_data_type.dimension() == value.dimension())) {
+          (node_sub_data_type.m_data_type.dimension() == ValueT::Dimension)) {
         list_affectation_processor->template add<ValueT, ValueT>(value_node);
       } else {
-        add_affectation_processor_for_data(value, node_sub_data_type);
+        add_affectation_processor_for_data.template operator()<TinyVector<1>>(node_sub_data_type);
       }
     } else if constexpr (std::is_same_v<ValueT, TinyVector<2>> or std::is_same_v<ValueT, TinyVector<3>>) {
       if ((node_sub_data_type.m_data_type == ASTNodeDataType::vector_t) and
-          (node_sub_data_type.m_data_type.dimension() == value.dimension())) {
+          (node_sub_data_type.m_data_type.dimension() == ValueT::Dimension)) {
         list_affectation_processor->template add<ValueT, ValueT>(value_node);
       } else if (node_sub_data_type.m_parent_node.is_type<language::integer>()) {
         if (std::stoi(node_sub_data_type.m_parent_node.string()) == 0) {
@@ -440,21 +437,19 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
     }
   };
 
-  auto add_affectation_processor_for_matrix_data = [&](const auto& value,
-                                                       const ASTNodeSubDataType& node_sub_data_type) {
-    using ValueT = std::decay_t<decltype(value)>;
+  auto add_affectation_processor_for_matrix_data = [&]<typename ValueT>(const ASTNodeSubDataType& node_sub_data_type) {
     if constexpr (std::is_same_v<ValueT, TinyMatrix<1>>) {
       if ((node_sub_data_type.m_data_type == ASTNodeDataType::matrix_t) and
-          (node_sub_data_type.m_data_type.numberOfRows() == value.numberOfRows()) and
-          (node_sub_data_type.m_data_type.numberOfColumns() == value.numberOfColumns())) {
+          (node_sub_data_type.m_data_type.numberOfRows() == ValueT::NumberOfRows) and
+          (node_sub_data_type.m_data_type.numberOfColumns() == ValueT::NumberOfColumns)) {
         list_affectation_processor->template add<ValueT, ValueT>(value_node);
       } else {
-        add_affectation_processor_for_data(value, node_sub_data_type);
+        add_affectation_processor_for_data.template operator()<TinyMatrix<1>>(node_sub_data_type);
       }
     } else if constexpr (std::is_same_v<ValueT, TinyMatrix<2>> or std::is_same_v<ValueT, TinyMatrix<3>>) {
       if ((node_sub_data_type.m_data_type == ASTNodeDataType::matrix_t) and
-          (node_sub_data_type.m_data_type.numberOfRows() == value.numberOfRows()) and
-          (node_sub_data_type.m_data_type.numberOfColumns() == value.numberOfColumns())) {
+          (node_sub_data_type.m_data_type.numberOfRows() == ValueT::NumberOfRows) and
+          (node_sub_data_type.m_data_type.numberOfColumns() == ValueT::NumberOfColumns)) {
         list_affectation_processor->template add<ValueT, ValueT>(value_node);
       } else if (node_sub_data_type.m_parent_node.is_type<language::integer>()) {
         if (std::stoi(node_sub_data_type.m_parent_node.string()) == 0) {
@@ -1140,19 +1135,19 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
                                                  const ASTNodeSubDataType& node_sub_data_type) {
     switch (value_type) {
     case ASTNodeDataType::bool_t: {
-      add_affectation_processor_for_data(bool{}, node_sub_data_type);
+      add_affectation_processor_for_data.template operator()<bool>(node_sub_data_type);
       break;
     }
     case ASTNodeDataType::unsigned_int_t: {
-      add_affectation_processor_for_data(uint64_t{}, node_sub_data_type);
+      add_affectation_processor_for_data.template operator()<uint64_t>(node_sub_data_type);
       break;
     }
     case ASTNodeDataType::int_t: {
-      add_affectation_processor_for_data(int64_t{}, node_sub_data_type);
+      add_affectation_processor_for_data.template operator()<int64_t>(node_sub_data_type);
       break;
     }
     case ASTNodeDataType::double_t: {
-      add_affectation_processor_for_data(double{}, node_sub_data_type);
+      add_affectation_processor_for_data.template operator()<double>(node_sub_data_type);
       break;
     }
     case ASTNodeDataType::type_id_t: {
@@ -1162,15 +1157,15 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
     case ASTNodeDataType::vector_t: {
       switch (value_type.dimension()) {
       case 1: {
-        add_affectation_processor_for_vector_data(TinyVector<1>{}, node_sub_data_type);
+        add_affectation_processor_for_vector_data.template operator()<TinyVector<1>>(node_sub_data_type);
         break;
       }
       case 2: {
-        add_affectation_processor_for_vector_data(TinyVector<2>{}, node_sub_data_type);
+        add_affectation_processor_for_vector_data.template operator()<TinyVector<2>>(node_sub_data_type);
         break;
       }
       case 3: {
-        add_affectation_processor_for_vector_data(TinyVector<3>{}, node_sub_data_type);
+        add_affectation_processor_for_vector_data.template operator()<TinyVector<3>>(node_sub_data_type);
         break;
       }
         // LCOV_EXCL_START
@@ -1185,15 +1180,15 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
       Assert(value_type.numberOfRows() == value_type.numberOfColumns());
       switch (value_type.numberOfRows()) {
       case 1: {
-        add_affectation_processor_for_matrix_data(TinyMatrix<1>{}, node_sub_data_type);
+        add_affectation_processor_for_matrix_data.template operator()<TinyMatrix<1>>(node_sub_data_type);
         break;
       }
       case 2: {
-        add_affectation_processor_for_matrix_data(TinyMatrix<2>{}, node_sub_data_type);
+        add_affectation_processor_for_matrix_data.template operator()<TinyMatrix<2>>(node_sub_data_type);
         break;
       }
       case 3: {
-        add_affectation_processor_for_matrix_data(TinyMatrix<3>{}, node_sub_data_type);
+        add_affectation_processor_for_matrix_data.template operator()<TinyMatrix<3>>(node_sub_data_type);
         break;
       }
         // LCOV_EXCL_START
-- 
GitLab