Skip to content
Snippets Groups Projects
Select Git revision
  • 776199d4b378fd511edd5c6043adfa0f5efa8a9d
  • develop default protected
  • feature/variational-hydro
  • origin/stage/bouguettaia
  • feature/gmsh-reader
  • feature/reconstruction
  • save_clemence
  • feature/kinetic-schemes
  • feature/local-dt-fsi
  • feature/composite-scheme-sources
  • feature/composite-scheme-other-fluxes
  • feature/serraille
  • feature/composite-scheme
  • hyperplastic
  • feature/polynomials
  • feature/gks
  • feature/implicit-solver-o2
  • feature/coupling_module
  • feature/implicit-solver
  • feature/merge-local-dt-fsi
  • master protected
  • v0.5.0 protected
  • v0.4.1 protected
  • v0.4.0 protected
  • v0.3.0 protected
  • v0.2.0 protected
  • v0.1.0 protected
  • Kidder
  • v0.0.4 protected
  • v0.0.3 protected
  • v0.0.2 protected
  • v0 protected
  • v0.0.1 protected
33 results

test_ASTNodeBuiltinFunctionExpressionBuilder.cpp

Blame
    • test_ASTNodeBuiltinFunctionExpressionBuilder.cpp 41.27 KiB 
    #include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_all.hpp>

#include <language/ast/ASTBuilder.hpp>
#include <language/ast/ASTModulesImporter.hpp>
#include <language/ast/ASTNodeDataTypeBuilder.hpp>
#include <language/ast/ASTNodeExpressionBuilder.hpp>
#include <language/ast/ASTNodeFunctionEvaluationExpressionBuilder.hpp>
#include <language/ast/ASTNodeFunctionExpressionBuilder.hpp>
#include <language/ast/ASTNodeTypeCleaner.hpp>
#include <language/ast/ASTSymbolTableBuilder.hpp>
#include <language/utils/ASTPrinter.hpp>
#include <stdexcept>
#include <utils/Demangle.hpp>

#include <test_BuiltinFunctionRegister.hpp>

#include <pegtl/string_input.hpp>

#include <memory>
#include <unordered_map>

#define CHECK_AST(data, expected_output)                                                            \
  {                                                                                                 \
    static_assert(std::is_same_v<std::decay_t<decltype(data)>, std::string_view>);                  \
    static_assert((std::is_same_v<std::decay_t<decltype(expected_output)>, std::string_view>) or    \
                  (std::is_same_v<std::decay_t<decltype(expected_output)>, std::string>));          \
                                                                                                    \
    TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};                                      \
    auto ast = ASTBuilder::build(input);                                                            \
                                                                                                    \
    test_only::test_BuiltinFunctionRegister{*ast};                                                  \
                                                                                                    \
    ASTSymbolTableBuilder{*ast};                                                                    \
    ASTNodeDataTypeBuilder{*ast};                                                                   \
                                                                                                    \
    ASTNodeTypeCleaner<language::var_declaration>{*ast};                                            \
    ASTNodeTypeCleaner<language::fct_declaration>{*ast};                                            \
    ASTNodeExpressionBuilder{*ast};                                                                 \
                                                                                                    \
    std::stringstream ast_output;                                                                   \
    ast_output << '\n' << ASTPrinter{*ast, ASTPrinter::Format::raw, {ASTPrinter::Info::exec_type}}; \
                                                                                                    \
    REQUIRE(ast_output.str() == expected_output);                                                   \
  }

#define CHECK_AST_THROWS_WITH(data, expected_error)                                             \
  {                                                                                             \
    static_assert(std::is_same_v<std::decay_t<decltype(data)>, std::string_view>);              \
    static_assert((std::is_same_v<std::decay_t<decltype(expected_error)>, std::string_view>) or \
                  (std::is_same_v<std::decay_t<decltype(expected_error)>, std::string>));       \
                                                                                                \
    TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};                                  \
    auto ast = ASTBuilder::build(input);                                                        \
                                                                                                \
    test_only::test_BuiltinFunctionRegister{*ast};                                              \
                                                                                                \
    ASTSymbolTableBuilder{*ast};                                                                \
    ASTNodeDataTypeBuilder{*ast};                                                               \
                                                                                                \
    ASTNodeTypeCleaner<language::var_declaration>{*ast};                                        \
    ASTNodeTypeCleaner<language::fct_declaration>{*ast};                                        \
    REQUIRE_THROWS_WITH(ASTNodeExpressionBuilder{*ast}, expected_error);                        \
  }

// clazy:excludeall=non-pod-global-static

TEST_CASE("ASTNodeBuiltinFunctionExpressionBuilder", "[language]")
{
  SECTION("R -> R")
      {
    SECTION("from R")
    {
      std::string_view data = R"(
RtoR(1.);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RtoR:NameProcessor)
     `-(language::real:1.:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from Z")
    {
      std::string_view data = R"(
RtoR(1);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RtoR:NameProcessor)
     `-(language::integer:1:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from N")
    {
      std::string_view data = R"(
let n : N, n = 1;
RtoR(n);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RtoR:NameProcessor)
     `-(language::name:n:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from B")
    {
      std::string_view data = R"(
RtoR(true);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RtoR:NameProcessor)
     `-(language::true_kw:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("R -> R^1")
  {
    SECTION("from R")
        {
      std::string_view data = R"(
RtoR1(1.);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RtoR1:NameProcessor)
     `-(language::real:1.:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from Z")
    {
      std::string_view data = R"(
RtoR1(1);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RtoR1:NameProcessor)
     `-(language::integer:1:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from N")
    {
      std::string_view data = R"(
let n : N, n = 1;
RtoR1(n);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RtoR1:NameProcessor)
     `-(language::name:n:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from B")
    {
      std::string_view data = R"(
RtoR1(true);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RtoR1:NameProcessor)
     `-(language::true_kw:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("R -> R^1x1")
  {
    SECTION("from R")
    {
      std::string_view data = R"(
    RtoR11(1.);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RtoR11:NameProcessor)
     `-(language::real:1.:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from Z")
    {
      std::string_view data = R"(
RtoR11(1);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RtoR11:NameProcessor)
     `-(language::integer:1:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from N")
    {
      std::string_view data = R"(
let n : N, n = 1;
RtoR11(n);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RtoR11:NameProcessor)
     `-(language::name:n:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from B")
    {
      std::string_view data = R"(
RtoR11(true);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RtoR11:NameProcessor)
     `-(language::true_kw:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("R^1 -> R")
  {
    SECTION("from R^1")
    {
      std::string_view data = R"(
let x : R^1, x = 2;
R1toR(x);
    )";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R1toR:NameProcessor)
     `-(language::name:x:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from R")
    {
      std::string_view data = R"(
R1toR(1.);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R1toR:NameProcessor)
     `-(language::real:1.:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from Z")
    {
      std::string_view data = R"(
R1toR(1);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R1toR:NameProcessor)
     `-(language::integer:1:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from N")
    {
      std::string_view data = R"(
let n : N, n = 1;
R1toR(n);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R1toR:NameProcessor)
     `-(language::name:n:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from B")
    {
      std::string_view data = R"(
R1toR(true);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
         +-(language::name:R1toR:NameProcessor)
     `-(language::true_kw:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("R^1x1 -> R")
  {
    SECTION("from R^1x1")
    {
      std::string_view data = R"(
let x : R^1x1, x = 2;
R11toR(x);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R11toR:NameProcessor)
     `-(language::name:x:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from R")
    {
      std::string_view data = R"(
R11toR(1.);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R11toR:NameProcessor)
     `-(language::real:1.:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from Z")
    {
      std::string_view data = R"(
R11toR(1);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R11toR:NameProcessor)
     `-(language::integer:1:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from N")
    {
      std::string_view data = R"(
let n : N, n = 1;
R11toR(n);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R11toR:NameProcessor)
         `-(language::name:n:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from B")
    {
      std::string_view data = R"(
R11toR(true);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R11toR:NameProcessor)
     `-(language::true_kw:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("R^2 -> R")
  {
    SECTION("from 0")
    {
      std::string_view data = R"(
R2toR(0);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R2toR:NameProcessor)
     `-(language::integer:0:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from R^2")
    {
      std::string_view data = R"(
let x:R^2, x = (1,2);
R2toR(x);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R2toR:NameProcessor)
     `-(language::name:x:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from list")
    {
      std::string_view data = R"(
R2toR((1,2));
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R2toR:NameProcessor)
     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         +-(language::integer:1:ValueProcessor)
             `-(language::integer:2:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("R^2x2 -> R")
  {
    SECTION("from 0")
    {
      std::string_view data = R"(
R22toR(0);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R22toR:NameProcessor)
     `-(language::integer:0:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from R^2x2")
    {
      std::string_view data = R"(
let x:R^2x2, x = (1,2,3,4);
R22toR(x);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R22toR:NameProcessor)
     `-(language::name:x:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from list")
    {
      std::string_view data = R"(
R22toR((1,2,3,4));
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R22toR:NameProcessor)
     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         +-(language::integer:1:ValueProcessor)
         +-(language::integer:2:ValueProcessor)
         +-(language::integer:3:ValueProcessor)
         `-(language::integer:4:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("R^3 -> R")
  {
    SECTION("from 0")
    {
      std::string_view data = R"(
R3toR(0);
)";
    
      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R3toR:NameProcessor)
     `-(language::integer:0:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from R^3")
    {
      std::string_view data = R"(
let x:R^3, x = (1,2,4);
R3toR(x);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R3toR:NameProcessor)
     `-(language::name:x:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from list")
    {
      std::string_view data = R"(
R3toR((1,2,3));
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R3toR:NameProcessor)
     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         +-(language::integer:1:ValueProcessor)
         +-(language::integer:2:ValueProcessor)
         `-(language::integer:3:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("R^3x3 -> R")
  {
    SECTION("from 0")
    {
      std::string_view data = R"(
R33toR(0);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R33toR:NameProcessor)
     `-(language::integer:0:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from R^3x3")
    {
      std::string_view data = R"(
let x:R^3x3, x = (1,2,3,4,5,6,7,8,9);
    R33toR(x);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R33toR:NameProcessor)
     `-(language::name:x:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from list")
    {
      std::string_view data = R"(
R33toR((1,2,3,4,5,6,7,8,9));
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R33toR:NameProcessor)
     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         +-(language::integer:1:ValueProcessor)
         +-(language::integer:2:ValueProcessor)
         +-(language::integer:3:ValueProcessor)
         +-(language::integer:4:ValueProcessor)
         +-(language::integer:5:ValueProcessor)
         +-(language::integer:6:ValueProcessor)
         +-(language::integer:7:ValueProcessor)
         +-(language::integer:8:ValueProcessor)
         `-(language::integer:9:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("Z -> R")
  {
    SECTION("from Z")
    {
      std::string_view data = R"(
ZtoR(1);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:ZtoR:NameProcessor)
     `-(language::integer:1:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from N")
    {
      std::string_view data = R"(
let n : N, n = 1;
ZtoR(n);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:ZtoR:NameProcessor)
     `-(language::name:n:NameProcessor)
)";
    
      CHECK_AST(data, result);
    }

    SECTION("from B")
    {
      std::string_view data = R"(
ZtoR(true);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:ZtoR:NameProcessor)
     `-(language::true_kw:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("N -> R")
  {
    SECTION("from Z")
    {
      std::string_view data = R"(
NtoR(1);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:NtoR:NameProcessor)
     `-(language::integer:1:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from N")
    {
      std::string_view data = R"(
let n : N, n = 1;
NtoR(n);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:NtoR:NameProcessor)
     `-(language::name:n:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from B")
    {
      std::string_view data = R"(
NtoR(true);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:NtoR:NameProcessor)
     `-(language::true_kw:ValueProcessor)
)";

      CHECK_AST(data, result);
        }
  }

  SECTION("B -> R")
  {
    SECTION("from B")
    {
      std::string_view data = R"(
BtoR(true);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:BtoR:NameProcessor)
     `-(language::true_kw:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("R*R -> B")
  {
    std::string_view data = R"(
RRtoB(1., 0.);
)";

    std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:RRtoB:NameProcessor)
     `-(language::function_argument_list:ASTNodeExpressionListProcessor)
         +-(language::real:1.:ValueProcessor)
         `-(language::real:0.:ValueProcessor)
)";

    CHECK_AST(data, result);
  }

  SECTION("R^3*R^2 -> R")
  {
    SECTION("from R^3*R^2")
    {
      std::string_view data = R"(
let x : R^3, x = (1,2,3);
let y : R^2, y = (2,3);
R3R2toR(x,y);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R3R2toR:NameProcessor)
     `-(language::function_argument_list:ASTNodeExpressionListProcessor)
         +-(language::name:x:NameProcessor)
         `-(language::name:y:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from (R,R,R)*(R,R)")
    {
      std::string_view data = R"(
R3R2toR((1,2,3),(3,4));
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
     `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R3R2toR:NameProcessor)
     `-(language::function_argument_list:ASTNodeExpressionListProcessor)
         +-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         |   +-(language::integer:1:ValueProcessor)
         |   +-(language::integer:2:ValueProcessor)
         |   `-(language::integer:3:ValueProcessor)
         `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
             +-(language::integer:3:ValueProcessor)
             `-(language::integer:4:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from (R,R,R)*(0)")
    {
      std::string_view data = R"(
R3R2toR((1,2,3),0);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R3R2toR:NameProcessor)
     `-(language::function_argument_list:ASTNodeExpressionListProcessor)
         +-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         |   +-(language::integer:1:ValueProcessor)
         |   +-(language::integer:2:ValueProcessor)
         |   `-(language::integer:3:ValueProcessor)
         `-(language::integer:0:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("R^3x3*R^2x2 -> R")
  {
    SECTION("from R^3x3*R^2x2")
    {
      std::string_view data = R"(
let x : R^3x3, x = (1,2,3,4,5,6,7,8,9);
let y : R^2x2, y = (1,2,3,4);
R33R22toR(x,y);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R33R22toR:NameProcessor)
     `-(language::function_argument_list:ASTNodeExpressionListProcessor)
         +-(language::name:x:NameProcessor)
         `-(language::name:y:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from (R,R,R,R,R,R,R,R,R)*(R,R,R,R)")
    {
      std::string_view data = R"(
R33R22toR((1,2,3,4,5,6,7,8,9),(1,2,3,4));
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R33R22toR:NameProcessor)
     `-(language::function_argument_list:ASTNodeExpressionListProcessor)
             +-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         |   +-(language::integer:1:ValueProcessor)
         |   +-(language::integer:2:ValueProcessor)
         |   +-(language::integer:3:ValueProcessor)
         |   +-(language::integer:4:ValueProcessor)
         |   +-(language::integer:5:ValueProcessor)
         |   +-(language::integer:6:ValueProcessor)
         |   +-(language::integer:7:ValueProcessor)
         |   +-(language::integer:8:ValueProcessor)
         |   `-(language::integer:9:ValueProcessor)
         `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
             +-(language::integer:1:ValueProcessor)
             +-(language::integer:2:ValueProcessor)
             +-(language::integer:3:ValueProcessor)
             `-(language::integer:4:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("from (R,R,R,R,R,R,R,R,R)*(0)")
    {
      std::string_view data = R"(
R33R22toR((1,2,3,4,5,6,7,8,9),0);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:R33R22toR:NameProcessor)
     `-(language::function_argument_list:ASTNodeExpressionListProcessor)
         +-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         |   +-(language::integer:1:ValueProcessor)
         |   +-(language::integer:2:ValueProcessor)
         |   +-(language::integer:3:ValueProcessor)
         |   +-(language::integer:4:ValueProcessor)
         |   +-(language::integer:5:ValueProcessor)
         |   +-(language::integer:6:ValueProcessor)
         |   +-(language::integer:7:ValueProcessor)
         |   +-(language::integer:8:ValueProcessor)
         |   `-(language::integer:9:ValueProcessor)
         `-(language::integer:0:ValueProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("string -> B")
  {
    std::string_view data = R"(
StoB("foo");
)";

    std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:StoB:NameProcessor)
     `-(language::literal:"foo":ValueProcessor)
)";

    CHECK_AST(data, result);
  }

  SECTION("builtin_t -> builtin_t")
  {
    std::string_view data = R"(
builtinToBuiltin(a);
)";

        std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:builtinToBuiltin:NameProcessor)
     `-(language::name:a:NameProcessor)
)";

    CHECK_AST(data, result);
  }

  SECTION("-> tuple")
  {
    SECTION("B -> tuple(Z)")
    {
      std::string_view data = R"(
tuple_ZtoR(true);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_ZtoR:NameProcessor)
     `-(language::true_kw:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("tuple(B) -> tuple(Z)")
    {
      std::string_view data = R"(
let t:(B), t =(true, false);
tuple_ZtoR(t);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_ZtoR:NameProcessor)
     `-(language::name:t:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("N -> tuple(Z)")
    {
      std::string_view data = R"(
let n:N, n=1;
tuple_ZtoR(n);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_ZtoR:NameProcessor)
     `-(language::name:n:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("tuple(B) -> tuple(B)")
    {
      std::string_view data = R"(
let t:(B), t=(true,false);
tuple_BtoR(t);
)";

      std::string_view result = R"(
    (root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_BtoR:NameProcessor)
     `-(language::name:t:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("tuple(N) -> tuple(N)")
    {
      std::string_view data = R"(
let t:(N), t=(1,3,7);
tuple_NtoR(t);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_NtoR:NameProcessor)
     `-(language::name:t:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("tuple(N) -> tuple(Z)")
    {
      std::string_view data = R"(
let t:(N), t=(1,3,7);
tuple_ZtoR(t);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_ZtoR:NameProcessor)
     `-(language::name:t:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("Z -> tuple(Z)")
    {
      std::string_view data = R"(
tuple_ZtoR(1);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_ZtoR:NameProcessor)
     `-(language::integer:1:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("tuple(Z) -> tuple(Z)")
    {
      std::string_view data = R"(
let t:(Z), t=(1,3,7);
tuple_ZtoR(t);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_ZtoR:NameProcessor)
         `-(language::name:t:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("Z -> tuple(R)")
    {
      std::string_view data = R"(
tuple_RtoB(1);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_RtoB:NameProcessor)
     `-(language::integer:1:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("tuple(Z) -> tuple(R)")
    {
      std::string_view data = R"(
let t:(Z), t = (1,2,4,6);
tuple_RtoB(t);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_RtoB:NameProcessor)
     `-(language::name:t:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("R -> tuple(R)")
    {
      std::string_view data = R"(
tuple_RtoB(1.2);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_RtoB:NameProcessor)
     `-(language::real:1.2:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("tuple(R) -> tuple(R)")
    {
      std::string_view data = R"(
let t:(R), t = (1,2,4,6);
tuple_RtoB(t);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_RtoB:NameProcessor)
     `-(language::name:t:NameProcessor)
)";

      CHECK_AST(data, result);
        }

    SECTION("list -> tuple(R)")
    {
      std::string_view data = R"(
let n:N, n = 3;
tuple_RtoB((1.2, 2, true, n));
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_RtoB:NameProcessor)
     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         +-(language::real:1.2:ValueProcessor)
         +-(language::integer:2:ValueProcessor)
         +-(language::true_kw:ValueProcessor)
         `-(language::name:n:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("R -> tuple(string)")
    {
      std::string_view data = R"(
tuple_stringtoB(1.2);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_stringtoB:NameProcessor)
     `-(language::real:1.2:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("string -> tuple(string)")
    {
      std::string_view data = R"(
let s:string, s = "foo";
tuple_stringtoB(s);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_stringtoB:NameProcessor)
     `-(language::name:s:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("tuple(R) -> tuple(string)")
    {
      std::string_view data = R"(
let t:(R), t = (1,2,4,6);
tuple_stringtoB(t);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_stringtoB:NameProcessor)
     `-(language::name:t:NameProcessor)
)";

          CHECK_AST(data, result);
    }

    SECTION("tuple(string) -> tuple(string)")
    {
      std::string_view data = R"(
let t:(string), t = ("foo", "bar", "foobar");
tuple_stringtoB(t);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_stringtoB:NameProcessor)
     `-(language::name:t:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("literal -> tuple(string)")
    {
      std::string_view data = R"(
tuple_stringtoB("foo");
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_stringtoB:NameProcessor)
     `-(language::literal:"foo":ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("list -> tuple(string)")
    {
      std::string_view data = R"(
tuple_stringtoB(("foo",2,"bar"));
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_stringtoB:NameProcessor)
     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         +-(language::literal:"foo":ValueProcessor)
         +-(language::integer:2:ValueProcessor)
         `-(language::literal:"bar":ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("builtin -> tuple(builtin)")
    {
      std::string_view data = R"(
tuple_builtinToB(a);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_builtinToB:NameProcessor)
     `-(language::name:a:NameProcessor)
)";

      CHECK_AST(data, result);
    }
    
    SECTION("list -> tuple(builtin)")
    {
      std::string_view data = R"(
tuple_builtinToB((a,b,a));
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_builtinToB:NameProcessor)
     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         +-(language::name:a:NameProcessor)
         +-(language::name:b:NameProcessor)
         `-(language::name:a:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("tuple(builtin) -> tuple(builtin)")
    {
      std::string_view data = R"(
let t:(builtin_t), t = (a,b,a);
tuple_builtinToB(t);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_builtinToB:NameProcessor)
     `-(language::name:t:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("Z -> tuple(R^1)")
    {
      std::string_view data = R"(
tuple_R1ToR(1);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R1ToR:NameProcessor)
     `-(language::integer:1:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("R -> tuple(R^1)")
    {
      std::string_view data = R"(
tuple_R1ToR(1.2);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R1ToR:NameProcessor)
     `-(language::real:1.2:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("R^1 -> tuple(R^1)")
        {
      std::string_view data = R"(
let r:R^1, r = 3;
tuple_R1ToR(r);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R1ToR:NameProcessor)
     `-(language::name:r:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("Z -> tuple(R^1x1)")
    {
      std::string_view data = R"(
tuple_R11ToR(1);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R11ToR:NameProcessor)
     `-(language::integer:1:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("R -> tuple(R^1x1)")
    {
      std::string_view data = R"(
tuple_R11ToR(1.2);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R11ToR:NameProcessor)
     `-(language::real:1.2:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("R^1x1 -> tuple(R^1x1)")
    {
      std::string_view data = R"(
let r:R^1x1, r = 3;
tuple_R11ToR(r);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R11ToR:NameProcessor)
     `-(language::name:r:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("0 -> tuple(R^2)")
    {
      std::string_view data = R"(
tuple_R2ToR(0);
)";
    
      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R2ToR:NameProcessor)
     `-(language::integer:0:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("R^2 -> tuple(R^2)")
    {
      std::string_view data = R"(
let r:R^2, r = (1,2);
tuple_R2ToR(r);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R2ToR:NameProcessor)
     `-(language::name:r:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("compound_list -> tuple(R^2)")
    {
      std::string_view data = R"(
let r:R^2, r = (1,2);
tuple_R2ToR((r,r));
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R2ToR:NameProcessor)
     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         +-(language::name:r:NameProcessor)
         `-(language::name:r:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("0 -> tuple(R^2x2)")
    {
      std::string_view data = R"(
tuple_R22ToR(0);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R22ToR:NameProcessor)
     `-(language::integer:0:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("R^2x2 -> tuple(R^2x2)")
    {
      std::string_view data = R"(
let r:R^2x2, r = (1,2,3,4);
tuple_R22ToR(r);
)";

          std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R22ToR:NameProcessor)
     `-(language::name:r:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("compound_list -> tuple(R^2x2)")
    {
      std::string_view data = R"(
let r:R^2x2, r = (1,2,3,4);
tuple_R22ToR((r,r));
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R22ToR:NameProcessor)
     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
         +-(language::name:r:NameProcessor)
         `-(language::name:r:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("0 -> tuple(R^3)")
    {
      std::string_view data = R"(
tuple_R3ToR(0);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R3ToR:NameProcessor)
     `-(language::integer:0:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("R^3 -> tuple(R^3)")
    {
      std::string_view data = R"(
let r:R^3, r = (1,2,3);
tuple_R3ToR(r);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R3ToR:NameProcessor)
     `-(language::name:r:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("0 -> tuple(R^3x3)")
    {
      std::string_view data = R"(
tuple_R33ToR(0);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
     `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R33ToR:NameProcessor)
     `-(language::integer:0:ValueProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("R^3x3 -> tuple(R^3x3)")
    {
      std::string_view data = R"(
let r:R^3x3, r = (1,2,3,4,5,6,7,8,9);
tuple_R33ToR(r);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:tuple_R33ToR:NameProcessor)
     `-(language::name:r:NameProcessor)
)";

      CHECK_AST(data, result);
    }

    SECTION("FunctionSymbolId -> R")
    {
      std::string_view data = R"(
let f : R^3 -> R, x -> 0;
fidToR(f);
)";

      std::string_view result = R"(
(root:ASTNodeListProcessor)
 `-(language::function_evaluation:BuiltinFunctionProcessor)
     +-(language::name:fidToR:NameProcessor)
     `-(language::name:f:NameProcessor)
)";

      CHECK_AST(data, result);
    }
  }

  SECTION("errors")
  {
    SECTION("bad number of arguments")
    {
      std::string_view data = R"(
BtoR(true, false);
)";
      CHECK_AST_THROWS_WITH(data, std::string{"bad number of arguments: expecting 1, provided 2"});
    }

    SECTION("bad number of arguments 2")
    {
      std::string_view data = R"(
RRtoB(3);
)";
      CHECK_AST_THROWS_WITH(data, std::string{"bad number of arguments: expecting 2, provided 1"});
    }

    SECTION("invalid argument type")
    {
      std::string_view data = R"(
RtoR("foo");
)";
      CHECK_AST_THROWS_WITH(data, std::string{"invalid implicit conversion: string -> R"});
    }
  }
}