Adding Support for symbolics in the list data structure (lcompilers#2368

)

integration_tests/CMakeLists.txt

@@ -714,6 +714,7 @@ RUN(NAME symbolics_07        LABELS cpython_sym c_sym llvm_sym NOFAST)
 RUN(NAME symbolics_08        LABELS cpython_sym c_sym llvm_sym)
 RUN(NAME symbolics_09        LABELS cpython_sym c_sym llvm_sym NOFAST)
 RUN(NAME symbolics_10        LABELS cpython_sym c_sym llvm_sym NOFAST)
+RUN(NAME symbolics_11        LABELS cpython_sym c_sym NOFAST)
 
 RUN(NAME sizeof_01           LABELS llvm c
         EXTRAFILES sizeof_01b.c)

integration_tests/symbolics_11.py

@@ -0,0 +1,18 @@
+from sympy import Symbol, sin, pi
+from lpython import S
+
+def test_extraction_of_elements():
+    x: S = Symbol("x")
+    l1: list[S] = [x, pi, sin(x), Symbol("y")]
+    ele1: S = l1[0]
+    ele2: S = l1[1]
+    ele3: S = l1[2]
+    ele4: S = l1[3]
+
+    assert(ele1 == x)
+    assert(ele2 == pi)
+    assert(ele3 == sin(x))
+    assert(ele4 == Symbol("y"))
+    print(ele1, ele2, ele3, ele4)
+
+test_extraction_of_elements()

src/libasr/pass/replace_symbolic.cpp

@@ -245,6 +245,13 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
                 pass_result.push_back(al, stmt3);
                 pass_result.push_back(al, stmt4);
             }
+        } else if (xx.m_type->type == ASR::ttypeType::List) {
+            ASR::List_t* list = ASR::down_cast<ASR::List_t>(xx.m_type);
+            if (list->m_type->type == ASR::ttypeType::SymbolicExpression){
+                ASR::ttype_t *CPtr_type = ASRUtils::TYPE(ASR::make_CPtr_t(al, xx.base.base.loc));
+                ASR::ttype_t* list_type = ASRUtils::TYPE(ASR::make_List_t(al, xx.base.base.loc, CPtr_type));
+                xx.m_type = list_type;
+            }
         }
     }
 
@@ -920,6 +927,47 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
                     }
                 }
             }
+        } else if (ASR::is_a<ASR::ListConstant_t>(*x.m_value)) {
+            ASR::ListConstant_t* list_constant = ASR::down_cast<ASR::ListConstant_t>(x.m_value);
+            if (list_constant->m_type->type == ASR::ttypeType::List) {
+                ASR::List_t* list = ASR::down_cast<ASR::List_t>(list_constant->m_type);
+                if (list->m_type->type == ASR::ttypeType::SymbolicExpression){
+                    Vec<ASR::expr_t*> temp_list;
+                    temp_list.reserve(al, list_constant->n_args + 1);
+
+                    for (size_t i = 0; i < list_constant->n_args; ++i) {
+                        ASR::expr_t* value = handle_argument(al, x.base.base.loc,  list_constant->m_args[i]);
+                        temp_list.push_back(al, value);
+                    }
+
+                    ASR::ttype_t* type = ASRUtils::TYPE(ASR::make_CPtr_t(al, x.base.base.loc));
+                    ASR::ttype_t* list_type = ASRUtils::TYPE(ASR::make_List_t(al, x.base.base.loc, type));
+                    ASR::expr_t* temp_list_const = ASRUtils::EXPR(ASR::make_ListConstant_t(al, x.base.base.loc, temp_list.p,
+                                    temp_list.size(), list_type));
+                    ASR::stmt_t* stmt = ASRUtils::STMT(ASR::make_Assignment_t(al, x.base.base.loc, x.m_target, temp_list_const, nullptr));
+                    pass_result.push_back(al, stmt);
+                }
+            }
+        } else if (ASR::is_a<ASR::ListItem_t>(*x.m_value)) {
+            ASR::ListItem_t* list_item = ASR::down_cast<ASR::ListItem_t>(x.m_value);
+            if (list_item->m_type->type == ASR::ttypeType::SymbolicExpression) {
+                ASR::ttype_t *CPtr_type = ASRUtils::TYPE(ASR::make_CPtr_t(al, x.base.base.loc));
+                ASR::symbol_t* basic_assign_sym = declare_basic_assign_function(al, x.base.base.loc, module_scope);
+
+                Vec<ASR::call_arg_t> call_args;
+                call_args.reserve(al, 2);
+                ASR::call_arg_t call_arg1, call_arg2;
+                call_arg1.loc = x.base.base.loc;
+                call_arg1.m_value = x.m_target;
+                call_arg2.loc = x.base.base.loc;
+                call_arg2.m_value = ASRUtils::EXPR(ASR::make_ListItem_t(al, x.base.base.loc, list_item->m_a,
+                    list_item->m_pos, CPtr_type, nullptr));
+                call_args.push_back(al, call_arg1);
+                call_args.push_back(al, call_arg2);
+                ASR::stmt_t* stmt = ASRUtils::STMT(ASR::make_SubroutineCall_t(al, x.base.base.loc, basic_assign_sym,
+                    basic_assign_sym, call_args.p, call_args.n, nullptr));
+                pass_result.push_back(al, stmt);
+            }
         } else if (ASR::is_a<ASR::SymbolicCompare_t>(*x.m_value)) {
             ASR::SymbolicCompare_t *s = ASR::down_cast<ASR::SymbolicCompare_t>(x.m_value);
             if (s->m_op == ASR::cmpopType::Eq || s->m_op == ASR::cmpopType::NotEq) {