ASTNodeFunctionExpressionBuilder.cpp

#include <language/ast/ASTNodeFunctionExpressionBuilder.hpp>

#include <language/PEGGrammar.hpp>
#include <language/ast/ASTNodeDataTypeFlattener.hpp>
#include <language/node_processor/FunctionProcessor.hpp>
#include <language/node_processor/TupleToTinyMatrixProcessor.hpp>
#include <language/node_processor/TupleToTinyVectorProcessor.hpp>
#include <language/utils/ASTNodeNaturalConversionChecker.hpp>
#include <language/utils/FunctionTable.hpp>
#include <language/utils/SymbolTable.hpp>
#include <utils/Exceptions.hpp>

template <typename SymbolType>
std::unique_ptr<IFunctionArgumentConverter>
ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_symbol,
                                                        const ASTNodeSubDataType& node_sub_data_type)
{
  const size_t parameter_id = std::get<size_t>(parameter_symbol.attributes().value());

  ASTNodeNaturalConversionChecker{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)>;
    switch (node_sub_data_type.m_data_type) {
    case ASTNodeDataType::bool_t: {
      return std::make_unique<FunctionArgumentConverter<ParameterT, bool>>(parameter_id);
    }
    case ASTNodeDataType::unsigned_int_t: {
      return std::make_unique<FunctionArgumentConverter<ParameterT, uint64_t>>(parameter_id);
    }
    case ASTNodeDataType::int_t: {
      return std::make_unique<FunctionArgumentConverter<ParameterT, int64_t>>(parameter_id);
    }
    case ASTNodeDataType::double_t: {
      return std::make_unique<FunctionArgumentConverter<ParameterT, double>>(parameter_id);
    }
      // LCOV_EXCL_START
    default: {
      throw ParseError("unexpected error: invalid argument type",
                       std::vector{node_sub_data_type.m_parent_node.begin()});
    }
      // LCOV_EXCL_STOP
    }
  };

  auto get_function_argument_converter_for_type_id =
    [&](const std::string& type_id_name) -> std::unique_ptr<IFunctionArgumentConverter> {
    switch (node_sub_data_type.m_data_type) {
    case ASTNodeDataType::type_id_t: {
      if (node_sub_data_type.m_data_type.nameOfTypeId() == type_id_name) {
        return std::make_unique<FunctionArgumentConverter<EmbeddedData, EmbeddedData>>(parameter_id);
      } else {
        // LCOV_EXCL_START
        throw ParseError("unexpected error: invalid argument type",
                         std::vector{node_sub_data_type.m_parent_node.begin()});
        // LCOV_EXCL_STOP
      }
    }
      // LCOV_EXCL_START
    default: {
      throw ParseError("unexpected error: invalid argument type",
                       std::vector{node_sub_data_type.m_parent_node.begin()});
    }
      // LCOV_EXCL_STOP
    }
  };

  auto get_function_argument_converter_for_vector =
    [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> {