feat(vm, compiler): new operator '@@' to get element in 2D list

Author: SuperFola

CHANGELOG.md

@@ -35,6 +35,7 @@
 - added in place list mutation: `(@= list|string index new_value)`, `(@@= list|list<string> index1 index2 new_value|char)` (bound checked)
 - compile time argument count check for `and` and `or`
 - basic dead code elimination in the AST optimizer
+- new operator `@@` to get elements in list of lists / list of strings
 
 ### Changed
 - instructions are on 4 bytes: 1 byte for the instruction, 1 byte of padding, 2 bytes for an immediate argument

include/Ark/Compiler/Common.hpp

@@ -132,13 +132,13 @@ namespace Ark::internal
         // This list is related to include/Ark/Compiler/Instructions.hpp
         // from FIRST_OPERATOR, to LAST_OPERATOR
         // The order is very important
-        constexpr std::array<std::string_view, 23> operators = {
+        constexpr std::array<std::string_view, 24> operators = {
             "+", "-", "*", "/",
             ">", "<", "<=", ">=", "!=", "=",
             "len", "empty?", "tail", "head",
             "nil?", "assert",
             "toNumber", "toString",
-            "@", "mod",
+            "@", "@@", "mod",
             "type", "hasField",
             "not"
         };

include/Ark/Compiler/Compiler.hpp

@@ -142,6 +142,15 @@ namespace Ark::internal
          */
         static bool isUnaryInst(Instruction inst) noexcept;
 
+        /**
+         * @brief Check if a given instruction is ternary (takes three arguments)
+         *
+         * @param inst
+         * @return true the instruction is ternary
+         * @return false
+         */
+        static bool isTernaryInst(Instruction inst) noexcept;
+
         /**
          * @brief Display a warning message
          *

include/Ark/Compiler/Instructions.hpp

@@ -84,23 +84,24 @@ namespace Ark::internal
         TO_NUM = 0x2e,
         TO_STR = 0x2f,
         AT = 0x30,
-        MOD = 0x31,
-        TYPE = 0x32,
-        HASFIELD = 0x33,
-        NOT = 0x34,
+        AT_AT = 0x31,
+        MOD = 0x32,
+        TYPE = 0x33,
+        HASFIELD = 0x34,
+        NOT = 0x35,
 
-        LOAD_CONST_LOAD_CONST = 0x35,
-        LOAD_CONST_STORE = 0x36,
-        LOAD_CONST_SET_VAL = 0x37,
-        STORE_FROM = 0x38,
-        SET_VAL_FROM = 0x39,
-        INCREMENT = 0x3a,
-        DECREMENT = 0x3b,
-        STORE_TAIL = 0x3c,
-        STORE_HEAD = 0x3d,
-        SET_VAL_TAIL = 0x3e,
-        SET_VAL_HEAD = 0x3f,
-        CALL_BUILTIN = 0x40
+        LOAD_CONST_LOAD_CONST = 0x36,
+        LOAD_CONST_STORE = 0x37,
+        LOAD_CONST_SET_VAL = 0x38,
+        STORE_FROM = 0x39,
+        SET_VAL_FROM = 0x3a,
+        INCREMENT = 0x3b,
+        DECREMENT = 0x3c,
+        STORE_TAIL = 0x3d,
+        STORE_HEAD = 0x3e,
+        SET_VAL_TAIL = 0x3f,
+        SET_VAL_HEAD = 0x40,
+        CALL_BUILTIN = 0x41
     };
 
     constexpr std::array InstructionNames = {
@@ -154,6 +155,7 @@ namespace Ark::internal
         "TO_NUM",
         "TO_STR",
         "AT",
+        "AT_AT",
         "MOD",
         "TYPE",
         "HASFIELD",

src/arkreactor/Compiler/Compiler.cpp

@@ -107,6 +107,18 @@ namespace Ark::internal
         }
     }
 
+    bool Compiler::isTernaryInst(const Instruction inst) noexcept
+    {
+        switch (inst)
+        {
+            case AT_AT:
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
     void Compiler::compilerWarning(const std::string& message, const Node& node)
     {
         fmt::println("{} {}", fmt::styled("Warning", fmt::fg(fmt::color::dark_orange)), Diagnostics::makeContextWithNode(message, node));
@@ -562,7 +574,7 @@ namespace Ark::internal
 
                 // in order to be able to handle things like (op A B C D...)
                 // which should be transformed into A B op C op D op...
-                if (exp_count >= 2)
+                if (exp_count >= 2 && !isTernaryInst(op))
                     page(p).emplace_back(op);
             }
 
@@ -572,6 +584,12 @@ namespace Ark::internal
                     throwCompilerError(fmt::format("Operator needs one argument, but was called with {}", exp_count), x.constList()[0]);
                 page(p).emplace_back(op);
             }
+            else if (isTernaryInst(op))
+            {
+                if (exp_count != 3)
+                    throwCompilerError(fmt::format("Operator needs three arguments, but was called with {}", exp_count), x.constList()[0]);
+                page(p).emplace_back(op);
+            }
             else if (exp_count <= 1)
                 throwCompilerError(fmt::format("Operator needs two arguments, but was called with {}", exp_count), x.constList()[0]);
 
@@ -585,7 +603,8 @@ namespace Ark::internal
                     case SUB: [[fallthrough]];
                     case MUL: [[fallthrough]];
                     case DIV: [[fallthrough]];
-                    case MOD:
+                    case MOD: [[fallthrough]];
+                    case AT_AT:
                         break;
 
                     default:

src/arkreactor/VM/VM.cpp

@@ -404,6 +404,7 @@ namespace Ark
                 &&TARGET_TO_NUM,
                 &&TARGET_TO_STR,
                 &&TARGET_AT,
+                &&TARGET_AT_AT,
                 &&TARGET_MOD,
                 &&TARGET_TYPE,
                 &&TARGET_HASFIELD,
@@ -1169,6 +1170,51 @@ namespace Ark
                         DISPATCH();
                     }
 
+                    TARGET(AT_AT)
+                    {
+                        {
+                            Value* x = popAndResolveAsPtr(context);
+                            Value* y = popAndResolveAsPtr(context);
+                            Value list = *popAndResolveAsPtr(context);  // be careful, it's not a pointer
+
+                            if (y->valueType() != ValueType::Number || x->valueType() != ValueType::Number ||
+                                list.valueType() != ValueType::List)
+                                types::generateError(
+                                    "@@",
+                                    { { types::Contract {
+                                        { types::Typedef("src", ValueType::List),
+                                          types::Typedef("y", ValueType::Number),
+                                          types::Typedef("x", ValueType::Number) } } } },
+                                    { list, *y, *x });
+
+                            long idx_y = static_cast<long>(y->number());
+                            idx_y = idx_y < 0 ? static_cast<long>(list.list().size()) + idx_y : idx_y;
+                            if (std::cmp_greater_equal(idx_y, list.list().size()))
+                                throwVMError(
+                                    ErrorKind::Index,
+                                    fmt::format("@@ index ({}) out of range (list size: {})", idx_y, list.list().size()));
+
+                            const bool is_list = list.list()[static_cast<std::size_t>(idx_y)].valueType() == ValueType::List;
+                            const std::size_t size =
+                                is_list
+                                ? list.list()[static_cast<std::size_t>(idx_y)].list().size()
+                                : list.list()[static_cast<std::size_t>(idx_y)].stringRef().size();
+
+                            long idx_x = static_cast<long>(x->number());
+                            idx_x = idx_x < 0 ? static_cast<long>(size) + idx_x : idx_x;
+                            if (std::cmp_greater_equal(idx_x, size))
+                                throwVMError(
+                                    ErrorKind::Index,
+                                    fmt::format("@@ index (x: {}) out of range (inner indexable size: {})", idx_x, size));
+
+                            if (is_list)
+                                push(list.list()[static_cast<std::size_t>(idx_y)].list()[static_cast<std::size_t>(idx_x)], context);
+                            else
+                                push(Value(std::string(1, list.list()[static_cast<std::size_t>(idx_y)].stringRef()[static_cast<std::size_t>(idx_x)])), context);
+                        }
+                        DISPATCH();
+                    }
+
                     TARGET(MOD)
                     {
                         Value *b = popAndResolveAsPtr(context), *a = popAndResolveAsPtr(context);

tests/unittests/resources/DiagnosticsSuite/compileTime/at_at_not_enough_args.ark

@@ -0,0 +1,2 @@
+(let lst [[0 1 2 3] [4 5 6 7] [8 9 0 1]])
+(print (@@ lst 1))

tests/unittests/resources/DiagnosticsSuite/compileTime/at_at_not_enough_args.expected

@@ -0,0 +1,6 @@
+At @@ @ 2:9
+    1 | (let lst [[0 1 2 3] [4 5 6 7] [8 9 0 1]])
+    2 | (print (@@ lst 1))
+      |         ^~
+    3 |
+        Operator needs three arguments, but was called with 2

tests/unittests/resources/DiagnosticsSuite/runtime/at_at_inner_out_of_range.ark

@@ -0,0 +1,2 @@
+(let lst [[0 1 2 3] [4 5 6 7] [8 9 0 1]])
+(print (@@ lst 0 6))

tests/unittests/resources/DiagnosticsSuite/runtime/at_at_inner_out_of_range.expected

@@ -0,0 +1 @@
+IndexError: @@ index (x: 6) out of range (inner indexable size: 4)