Add array subscript operator for R^d elements (for d in {1,2,3})

One can now write
``
R^2 x = (3, 2);
R y = x[1]; // y will contain the value 2
``

src/language/ASTNodeArraySubscriptExpressionBuilder.cpp

+#include <ASTNodeArraySubscriptExpressionBuilder.hpp>
+
+#include <../algebra/TinyVector.hpp>
+
+#include <node_processor/ArraySubscriptProcessor.hpp>
+
+ASTNodeArraySubscriptExpressionBuilder::ASTNodeArraySubscriptExpressionBuilder(ASTNode& node)
+{
+  auto& array_expression = *node.children[0];
+
+  if (array_expression.m_data_type == ASTNodeDataType::vector_t) {
+    switch (array_expression.m_data_type.dimension()) {
+    case 1: {
+      node.m_node_processor = std::make_unique<ArraySubscriptProcessor<TinyVector<1>>>(node);
+      break;
+    }
+    case 2: {
+      node.m_node_processor = std::make_unique<ArraySubscriptProcessor<TinyVector<2>>>(node);
+      break;
+    }
+    case 3: {
+      node.m_node_processor = std::make_unique<ArraySubscriptProcessor<TinyVector<3>>>(node);
+      break;
+    }
+    default: {
+      break;
+    }
+    }
+  } else {
+    throw parse_error("unexpected error: invalid array type", array_expression.begin());
+  }
+}

src/language/ASTNodeArraySubscriptExpressionBuilder.hpp

+#ifndef AST_NODE_ARRAY_SUBSCRIPT_EXPRESSION_BUILDER_HPP
+#define AST_NODE_ARRAY_SUBSCRIPT_EXPRESSION_BUILDER_HPP
+
+#include <ASTNode.hpp>
+
+class ASTNodeArraySubscriptExpressionBuilder
+{
+ public:
+  ASTNodeArraySubscriptExpressionBuilder(ASTNode& node);
+};
+
+#endif   // AST_NODE_ARRAY_SUBSCRIPT_EXPRESSION_BUILDER_HPP

src/language/ASTNodeExpressionBuilder.cpp

@@ -3,6 +3,7 @@
 #include <ASTNodeAffectationExpressionBuilder.hpp>
 #include <ASTNodeListAffectationExpressionBuilder.hpp>
 
+#include <ASTNodeArraySubscriptExpressionBuilder.hpp>
 #include <ASTNodeBinaryOperatorExpressionBuilder.hpp>
 #include <ASTNodeFunctionEvaluationExpressionBuilder.hpp>
 #include <ASTNodeIncDecExpressionBuilder.hpp>
@@ -63,6 +64,9 @@ ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
   } else if (n.is_type<language::function_evaluation>()) {
     ASTNodeFunctionEvaluationExpressionBuilder{n};
 
+  } else if (n.is_type<language::subscript_expression>()) {
+    ASTNodeArraySubscriptExpressionBuilder{n};
+
   } else if (n.is_type<language::real>()) {
     n.m_node_processor = std::make_unique<ValueProcessor>(n);
   } else if (n.is_type<language::integer>()) {

src/language/CMakeLists.txt

@@ -11,6 +11,7 @@ add_library(
   ASTDotPrinter.cpp
   ASTModulesImporter.cpp
   ASTNodeAffectationExpressionBuilder.cpp
+  ASTNodeArraySubscriptExpressionBuilder.cpp
   ASTNodeBinaryOperatorExpressionBuilder.cpp
   ASTNodeCFunctionExpressionBuilder.cpp
   ASTNodeDataType.cpp

src/language/node_processor/ArraySubscriptProcessor.hpp

+#ifndef ARRAY_SUBSCRIPT_PROCESSOR_HPP
+#define ARRAY_SUBSCRIPT_PROCESSOR_HPP
+
+#include <node_processor/INodeProcessor.hpp>
+
+template <typename ArrayTypeT>
+class ArraySubscriptProcessor : public INodeProcessor
+{
+ private:
+  ASTNode& m_array_subscript_expression;
+
+ public:
+  DataVariant
+  execute(ExecutionPolicy& exec_policy)
+  {
+    auto& index_expression = *m_array_subscript_expression.children[1];
+
+    const int64_t index_value = [&](DataVariant&& value_variant) -> int64_t {
+      int64_t index_value = 0;
+      std::visit(
+        [&](auto&& value) {
+          using ValueT = std::decay_t<decltype(value)>;
+          if constexpr (std::is_integral_v<ValueT>) {
+            index_value = value;
+          } else {
+            throw parse_error("unexpected error: invalid index type", std::vector{index_expression.begin()});
+          }
+        },
+        value_variant);
+      return index_value;
+    }(index_expression.execute(exec_policy));
+
+    auto& array_expression = *m_array_subscript_expression.children[0];
+
+    const ArrayTypeT& array = std::get<ArrayTypeT>(array_expression.execute(exec_policy));
+
+    return array[index_value];
+  }
+
+  ArraySubscriptProcessor(ASTNode& array_subscript_expression)
+    : m_array_subscript_expression{array_subscript_expression}
+  {}
+
+  virtual ~ArraySubscriptProcessor() = default;
+};
+
+#endif   // ARRAY_SUBSCRIPT_PROCESSOR_HPP