Support constant negative indices in the array (#2611)

* Support constant negative indices in the array

* Add array test

* Handle runtime array size for DescriptorArray

* Print array for the test

Author: hankluo6

integration_tests/CMakeLists.txt

@@ -434,6 +434,7 @@ RUN(NAME array_expr_05            LABELS cpython llvm c)
 RUN(NAME array_expr_06            LABELS cpython llvm c)
 RUN(NAME array_expr_07            LABELS cpython llvm c)
 RUN(NAME array_expr_08            LABELS cpython llvm c)
+RUN(NAME array_expr_09            LABELS cpython llvm c)
 RUN(NAME array_size_01            LABELS cpython llvm c)
 RUN(NAME array_size_02            LABELS cpython llvm c)
 RUN(NAME array_01            LABELS cpython llvm wasm c)

integration_tests/array_expr_09.py

@@ -0,0 +1,23 @@
+from lpython import (i32, Const)
+from numpy import empty, int32
+
+dim: Const[i32] = 2
+dim2: Const[i32] = 3
+
+def g():
+    a: i32[dim, dim2] = empty((dim, dim2), dtype=int32)
+    i1: i32 = 0
+    i2: i32 = 0
+    for i1 in range(dim):
+        for i2 in range(dim2):
+            a[i1, i2] = i32(i1 * dim2 + i2)
+    # a: [[0, 1, 2], [3, 4, 5]]
+    print(a)
+    assert a[-1, -1] == 5
+    assert a[-1, -2] == 4
+    assert a[-1, -3] == 3
+    assert a[-2, -1] == 2
+    assert a[-2, -2] == 1
+    assert a[-2, -3] == 0
+
+g()

src/lpython/semantics/python_ast_to_asr.cpp

@@ -3761,7 +3761,7 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
 
     bool visit_SubscriptIndices(AST::expr_t* m_slice, Vec<ASR::array_index_t>& args,
                                 ASR::expr_t* value, ASR::ttype_t* type, bool& is_item,
-                                const Location& loc) {
+                                const Location& loc, size_t idx=0) {
         ASR::array_index_t ai;
         ai.loc = loc;
         ai.m_left = nullptr;
@@ -3823,7 +3823,7 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
             AST::Tuple_t* indices = AST::down_cast<AST::Tuple_t>(m_slice);
             for( size_t i = 0; i < indices->n_elts; i++ ) {
                 final_result &= visit_SubscriptIndices(indices->m_elts[i], args,
-                                                        value, type, is_item, loc);
+                                                        value, type, is_item, loc, i);
             }
             return final_result;
         } else {
@@ -3899,6 +3899,25 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
                 tmp = make_TupleItem_t(al, loc, value, index,
                                        ASR::down_cast<ASR::Tuple_t>(type)->m_type[i], nullptr);
                 return false;
+            } else if (ASR::is_a<ASR::Array_t>(*type)) {
+                index = ASRUtils::EXPR(tmp);
+                ASR::expr_t* val = ASRUtils::expr_value(index);
+                if (val && ASR::is_a<ASR::IntegerConstant_t>(*val)) {
+                    if (ASR::down_cast<ASR::IntegerConstant_t>(val)->m_n < 0) {
+                        ASR::ttype_t *int_type = ASRUtils::TYPE(ASR::make_Integer_t(
+                                                        al, loc, 4));
+                        ASR::expr_t *neg_idx = ASRUtils::expr_value(index);
+                        ASR::expr_t *dim_size;
+                        if (ASRUtils::extract_physical_type(type) != ASR::array_physical_typeType::DescriptorArray)
+                            dim_size = ASR::down_cast<ASR::Array_t>(type)->m_dims[idx].m_length;
+                        else {
+                            ASR::expr_t *idx_expr = ASRUtils::EXPR(ASR::make_IntegerConstant_t(al, loc, idx + 1, int_type));
+                            dim_size = ASRUtils::EXPR(ASRUtils::make_ArraySize_t_util(al, loc, value, idx_expr, int_type, nullptr, false));
+                        }
+                        index = ASRUtils::EXPR(ASR::make_IntegerBinOp_t(al, loc, 
+                            dim_size, ASR::binopType::Add, neg_idx, int_type, nullptr));
+                    }
+                }
             } else {
                 index = ASRUtils::EXPR(tmp);
             }