index expression (#55)

Author: ivanallen

include/evaluator.h

@@ -59,6 +59,9 @@ class Evaluator {
     std::shared_ptr<object::Environment> extend_function_env(
             const object::Function* fn,
             std::vector<std::shared_ptr<object::Object>>& args) const;
+    std::shared_ptr<object::Object> eval_index_expression(
+            const object::Object* array,
+            const object::Object* index) const;
 private:
     bool is_truthy(const object::Object* obj) const;
 

src/evaluator.cc

@@ -41,19 +41,23 @@ std::shared_ptr<object::Object> Evaluator::eval(
     if (typeid(*node) == typeid(ast::Program)) {
         auto n = node->cast<ast::Program>();
         return eval_program(n->statments(), env);
+
     } else if (typeid(*node) == typeid(ast::ExpressionStatment)) {
         auto n = node->cast<ast::ExpressionStatment>();
         return eval(n->expression(), env);
+
     } else if (typeid(*node) == typeid(ast::BlockStatment)) {
         auto n = node->cast<ast::BlockStatment>();
         return eval_statments(n->statments(), env);
+
     } else if (typeid(*node) == typeid(ast::ReturnStatment)) {
         auto n = node->cast<ast::ReturnStatment>();
         auto return_val = eval(n->expression(), env);
         if (is_error(return_val.get())) {
             return return_val;
         }
         return std::make_shared<object::ReturnValue>(return_val);
+
     } else if (typeid(*node) == typeid(ast::LetStatment)) {
         auto n = node->cast<ast::LetStatment>();
         auto val = eval(n->expression(), env);
@@ -62,65 +66,117 @@ std::shared_ptr<object::Object> Evaluator::eval(
         }
 
         env->set(n->identifier()->value(), val);
+
     } else if (typeid(*node) == typeid(ast::IntegerLiteral)) {
         auto n = node->cast<ast::IntegerLiteral>();
         return std::shared_ptr<object::Integer>(
                 new object::Integer(n->value()));
+
     } else if (typeid(*node) == typeid(ast::BooleanLiteral)) {
         auto n = node->cast<ast::BooleanLiteral>();
         return n->value() ? _true : _false;
+
     } else if (typeid(*node) == typeid(ast::StringLiteral)) {
         auto n = node->cast<ast::StringLiteral>();
         return std::make_shared<object::String>(n->value());
+
     } else if (typeid(*node) == typeid(ast::ArrayLiteral)) {
         auto n = node->cast<ast::ArrayLiteral>();
         auto elems = eval_expressions(n->elements(), env);
         if (!elems.empty() && is_error(elems[0].get())) {
             return elems[0];
         }
         return std::make_shared<object::Array>(elems);
+
     } else if (typeid(*node) == typeid(ast::PrefixExpression)) {
         auto n = node->cast<ast::PrefixExpression>();
         auto right = eval(n->right(), env);
         if (is_error(right.get())) {
             return right;
         }
         return eval_prefix_expression(n->op(), right.get(), env);
+
     } else if (typeid(*node) == typeid(ast::InfixExpression)) {
         auto n = node->cast<ast::InfixExpression>();
         auto left = eval(n->left(), env);
         if (is_error(left.get())) {
             return left;
         }
+
         auto right = eval(n->right(), env);
         if (is_error(right.get())) {
             return right;
         }
+
         return eval_infix_expression(n->op(), left.get(), right.get(), env);
+
     } else if (typeid(*node) == typeid(ast::IfExpression)) {
         return eval_if_expression(node->cast<ast::IfExpression>(), env);
+
     } else if (typeid(*node) == typeid(ast::Identifier)) {
         return eval_identifier(node->cast<ast::Identifier>(), env);
+
     } else if (typeid(*node) == typeid(ast::FunctionLiteral)) {
         auto n = node->cast<ast::FunctionLiteral>();
         return std::make_shared<object::Function>(
                 n->parameters(), n->body(), env);
+
     } else if (typeid(*node) == typeid(ast::CallExpression)) {
         auto n = node->cast<ast::CallExpression>();
         auto function = eval(n->function(), env);
         if (is_error(function.get())) {
             return function;
         }
+
         auto args = eval_expressions(n->arguments(), env);
         if (!args.empty() && is_error(args[0].get())) {
             return args[0];
         }
+
         return apply_function(function.get(), args);
+
+    } else if (typeid(*node) == typeid(ast::IndexExpression)) {
+        auto n = node->cast<ast::IndexExpression>();
+        auto array = eval(n->left(), env);
+        if (is_error(array.get())) {
+            return array;
+        }
+
+        auto index = eval(n->index(), env);
+        if (is_error(index.get())) {
+            return index;
+        }
+
+        return eval_index_expression(array.get(), index.get());
+
     }
 
     return nullptr;
 }
 
+std::shared_ptr<object::Object> Evaluator::eval_index_expression(
+        const object::Object* array,
+        const object::Object* index) const {
+    if (typeid(*array) == typeid(object::Array)
+            && typeid(*index) == typeid(object::Integer)) {
+        auto a = array->cast<object::Array>();
+        auto i = index->cast<object::Integer>();
+
+        auto& elems = a->elements();
+        auto idx = i->value();
+
+        if (idx < 0) {
+            idx += elems.size();
+        }
+
+        if (idx < 0 || idx >= elems.size()) {
+            return _null;
+        }
+
+        return elems[idx];
+    }
+    return new_error("index operator not supported: `{}`", array->type());
+}
 
 std::shared_ptr<object::Object> Evaluator::apply_function(
         const object::Object* fn,

unitest/evaluator_test.cc

@@ -356,4 +356,36 @@ TEST(Evaluator, TestArrayLiteral) {
     test_integer_object(array_obj->elements()[2].get(), 9);
 }
 
+TEST(Evaluator, TestIndexExpression) {
+    std::vector<std::tuple<std::string, std::any>> tests = {
+        {"[1, 2, 3][0]", 1},
+        {"[1, 2, 3][1]", 2},
+        {"[1, 2, 3][2]", 3},
+        {"let i = 0; [1][i];", 1},
+        {"[1, 2, 3][1 + 1];", 3},
+        {"let myArray = [1, 2, 3]; myArray[2];", 3},
+        {"let myArray = [1, 2, 3]; myArray[0] + myArray[1] + myArray[2];", 6},
+        {"let myArray = [1, 2, 3]; let i = myArray[0]; myArray[i]", 2},
+        {"[1, 2, 3][3]", nullptr},
+        {"[1, 2, 3][-1]", 3},
+    };
+
+    Evaluator evaluator;
+
+    for (auto& test : tests) {
+        auto& input = std::get<0>(test);
+        auto& expect = std::get<1>(test);
+
+        auto object = evaluator.eval(input);
+
+        if (expect.type() == typeid(int)) {
+            test_integer_object(object.get(), std::any_cast<int>(expect));
+        } else if (expect.type() == typeid(std::nullptr_t)) {
+            test_null_object(object.get());
+        } else {
+            std::cout << object->inspect() << std::endl;
+        }
+    }
+}
+
 }