Add support for item access from Const data-structures

integration_tests/test_const_access.py

@@ -0,0 +1,14 @@
+from lpython import i32, str, list, dict, Const
+
+
+def test_const_access():
+    CONST_LIST: Const[list[i32]] = [1, 2, 3, 4, 5]
+    CONST_DICTIONARY: Const[dict[str, i32]] = {"a": 1, "b": 2, "c": 3}
+
+    assert CONST_LIST[0] == 1
+    assert CONST_LIST[-2] == 4
+
+    assert CONST_DICTIONARY["a"] == 1
+
+
+test_const_access()

src/libasr/codegen/asr_to_llvm.cpp

@@ -1523,8 +1523,9 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
     }
 
     void visit_ListItem(const ASR::ListItem_t& x) {
-        ASR::ttype_t* el_type = ASRUtils::get_contained_type(
-                                        ASRUtils::expr_type(x.m_a));
+        ASR::ttype_t *el_type = ASR::is_a<ASR::Const_t>(*ASRUtils::expr_type(x.m_a))
+                                    ? ASRUtils::get_contained_type(ASRUtils::type_get_past_const(ASRUtils::expr_type(x.m_a)))
+                                    : ASRUtils::get_contained_type(ASRUtils::expr_type(x.m_a));
         int64_t ptr_loads_copy = ptr_loads;
         ptr_loads = 0;
         this->visit_expr(*x.m_a);
@@ -1540,8 +1541,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
     }
 
     void visit_DictItem(const ASR::DictItem_t& x) {
-        ASR::Dict_t* dict_type = ASR::down_cast<ASR::Dict_t>(
-                                    ASRUtils::expr_type(x.m_a));
+        ASR::Dict_t *dict_type = ASR::down_cast<ASR::Dict_t>(ASRUtils::type_get_past_const(ASRUtils::expr_type(x.m_a)));
+
         int64_t ptr_loads_copy = ptr_loads;
         ptr_loads = 0;
         this->visit_expr(*x.m_a);

src/lpython/semantics/python_ast_to_asr.cpp

@@ -1750,6 +1750,12 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
             } else if (var_annotation == "Const") {
                 ASR::ttype_t *type = ast_expr_to_asr_type(loc, *s->m_slice,
                     is_allocatable, raise_error, abi, is_argument);
+                if (ASR::is_a<ASR::Tuple_t>(*type)) {
+                    throw SemanticError("'Const' not required as tuples are already immutable", loc);
+                }
+                else if (ASR::is_a<ASR::Character_t>(*type)) {
+                    throw SemanticError("'Const' not required as strings are already immutable", loc);
+                }
                 return ASRUtils::TYPE(ASR::make_Const_t(al, loc, type));
             } else {
                 AST::expr_t* dim_info = s->m_slice;
@@ -3730,6 +3736,12 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
             } else if (ASR::is_a<ASR::Dict_t>(*type)) {
                 throw SemanticError("unhashable type in dict: 'slice'", loc);
             }
+            if (ASR::is_a<ASR::Const_t>(*type))
+            {
+                if (ASR::is_a<ASR::List_t>(*ASRUtils::type_get_past_const(type))) {
+                    throw SemanticError("slicing on a const list is not implemented till now", loc);
+                }
+            }
         } else if(AST::is_a<AST::Tuple_t>(*m_slice) &&
                     ASRUtils::is_array(type)) {
             bool final_result = true;
@@ -3740,7 +3752,44 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
             }
             return final_result;
         } else {
+            ASR::expr_t *index = nullptr;
             this->visit_expr(*m_slice);
+            if (ASR::is_a<ASR::Const_t>(*type)) {
+                ASR::ttype_t *contained_type = ASRUtils::type_get_past_const(type);
+                if (ASR::is_a<ASR::Dict_t>(*contained_type)) {
+                    index = ASRUtils::EXPR(tmp);
+                    ASR::ttype_t *key_type = ASR::down_cast<ASR::Dict_t>(contained_type)->m_key_type;
+                    if (!ASRUtils::check_equal_type(ASRUtils::expr_type(index), key_type)) {
+                        throw SemanticError("Key type should be '" + ASRUtils::type_to_str_python(key_type) +
+                                                "' instead of '" +
+                                                ASRUtils::type_to_str_python(ASRUtils::expr_type(index)) + "'",
+                                            index->base.loc);
+                    }
+                    tmp = ASR::make_DictItem_t(al, loc, value, index, nullptr,
+                                    ASR::down_cast<ASR::Dict_t>(contained_type)->m_value_type, nullptr);
+                    return false;
+                }
+                else if (ASR::is_a<ASR::List_t>(*contained_type)) {
+                    this->visit_expr(*m_slice);
+                    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) {
+                            // Replace `x[-1]` to `x[len(x)+(-1)]`
+                            ASR::ttype_t *int_type = ASRUtils::TYPE(ASR::make_Integer_t(
+                                                            al, loc, 4));
+                            ASR::expr_t *list_len = ASRUtils::EXPR(ASR::make_ListLen_t(
+                                        al, loc, value, int_type, nullptr));
+                            ASR::expr_t *neg_idx = ASRUtils::expr_value(index);
+                            index = ASRUtils::EXPR(ASR::make_IntegerBinOp_t(al, loc,
+                                list_len, ASR::binopType::Add, neg_idx, int_type, nullptr));
+                        }
+                    }
+                    tmp = make_ListItem_t(al, loc, value, index,
+                                      ASR::down_cast<ASR::List_t>(contained_type)->m_type, nullptr);
+                    return false;
+                }
+            }
             if (!ASR::is_a<ASR::Dict_t>(*type) &&
                     !ASRUtils::is_integer(*ASRUtils::expr_type(ASRUtils::EXPR(tmp)))) {
                 std::string fnd = ASRUtils::type_to_str_python(ASRUtils::expr_type(ASRUtils::EXPR(tmp)));
@@ -3753,8 +3802,8 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
                 );
                 throw SemanticAbort();
             }
-            ASR::expr_t *index = nullptr;
             if (ASR::is_a<ASR::Dict_t>(*type)) {
+                this->visit_expr(*m_slice);
                 index = ASRUtils::EXPR(tmp);
                 ASR::ttype_t *key_type = ASR::down_cast<ASR::Dict_t>(type)->m_key_type;
                 if (!ASRUtils::check_equal_type(ASRUtils::expr_type(index), key_type)) {

tests/errors/test_const_str_access.py

@@ -0,0 +1,8 @@
+from lpython import str, Const
+
+
+def test_const_str_access():
+    CONST_STRING: Const[str] = "Hello, LPython!"
+
+
+test_const_str_access()

tests/errors/test_const_tuple_access.py

@@ -0,0 +1,9 @@
+from lpython import str, tuple, Const
+
+
+def test_const_tuple_access():
+    CONST_TUPLE: Const[tuple[str, str, str]] = ("hello", "LPython", "!")
+
+
+test_const_tuple_access()
+

tests/reference/asr-test_const_access-82a9a24.json

@@ -0,0 +1,13 @@
+{
+    "basename": "asr-test_const_access-82a9a24",
+    "cmd": "lpython --show-asr --no-color {infile} -o {outfile}",
+    "infile": "tests/../integration_tests/test_const_access.py",
+    "infile_hash": "c25c7c1c19db38e066b47dc2891abaa5ddd7379b4df07892cebb94e3",
+    "outfile": null,
+    "outfile_hash": null,
+    "stdout": "asr-test_const_access-82a9a24.stdout",
+    "stdout_hash": "a98657aca0fefd42749ce13d47c09daf48deed01ec24170d242f5ee3",
+    "stderr": null,
+    "stderr_hash": null,
+    "returncode": 0
+}