Implement global List in module scope

Author: Thirumalai-Shaktivel

examples/expr2.py

@@ -1,9 +1,15 @@
-def main0():
-    x: i32
-    x = (2+3)*5
-    print(x)
+from ltypes import i32
 
-main0()
+x: list[i32]
+x = [1, 2, 3]
+# i: i32 = x[0]
+print(x)
+
+# def main0():
+#     # This doesn't work yet
+#     print(x[0])
+
+# main0()
 
 # Not implemented yet in LPython:
 #if __name__ == "__main__":

src/libasr/codegen/asr_to_llvm.cpp

@@ -2196,6 +2196,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
             llvm_symtab[h] = ptr;
         } else if (x.m_type->type == ASR::ttypeType::TypeParameter) {
             // Ignore type variables
+        } else if (x.m_type->type == ASR::ttypeType::List) {
+            // Handled in ``_lpython_main_program``function_scope
         } else {
             throw CodeGenError("Variable type not supported", x.base.base.loc);
         }
@@ -5309,7 +5311,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
         }
     }
 
-    inline void fetch_var(ASR::Variable_t* x) {
+    inline void fetch_var(ASR::Variable_t* x, bool is_external=false) {
         if (x->m_value) {
             this->visit_expr_wrapper(x->m_value, true);
             return;
@@ -5369,6 +5371,28 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                 }
                 break;
             }
+            case ASR::ttypeType::List: {
+                if (is_external) {
+                    uint32_t h = get_hash((ASR::asr_t*)x);
+                    llvm::Type *type;
+                    int n_dims = 0, a_kind = 4;
+                    ASR::dimension_t* m_dims = nullptr;
+                    bool is_array_type = false, is_malloc_array_type = false;
+                    bool is_list = false;
+                    type = get_type_from_ttype_t(x->m_type, x->m_storage, is_array_type,
+                                                    is_malloc_array_type, is_list, m_dims, n_dims,
+                                                    a_kind);
+                    llvm::AllocaInst *ptr = builder->CreateAlloca(type, nullptr, x->m_name);
+                    llvm_symtab[h] = ptr;
+                    if( llvm_symtab.find(h) != llvm_symtab.end() ) {
+                        tmp = llvm_symtab[h];
+                    }
+                    ASR::List_t* asr_list = ASR::down_cast<ASR::List_t>(x->m_type);
+                    std::string type_code = ASRUtils::get_type_code(asr_list->m_type);
+                    list_api->list_init(type_code, tmp, *module);
+                    break;
+                }
+            }
             default: {
                 fetch_val(x);
                 break;
@@ -5377,9 +5401,13 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
     }
 
     void visit_Var(const ASR::Var_t &x) {
+        bool is_external = false;
+        if(ASR::is_a<ASR::ExternalSymbol_t>(*x.m_v)) {
+            is_external = true;
+        }
         ASR::Variable_t *v = ASR::down_cast<ASR::Variable_t>(
                 symbol_get_past_external(x.m_v));
-        fetch_var(v);
+        fetch_var(v, is_external);
     }
 
     inline ASR::ttype_t* extract_ttype_t_from_expr(ASR::expr_t* expr) {

src/lpython/semantics/python_ast_to_asr.cpp

@@ -6236,7 +6236,13 @@ Result<ASR::TranslationUnit_t*> python_ast_to_asr(Allocator &al, LocationManager
             pass_options.run_fun = "_lpython_main_program";
             pass_options.runtime_library_dir = get_runtime_library_dir();
             pass_wrap_global_stmts_into_program(al, *tu, pass_options);
-            LCOMPILERS_ASSERT(asr_verify(*tu, true, diagnostics));
+#if defined(WITH_LFORTRAN_ASSERT)
+            diag::Diagnostics diagnostics;
+            if (!asr_verify(*tu, true, diagnostics)) {
+                std::cerr << diagnostics.render2();
+                throw LCompilersException("Verify failed");
+            };
+#endif
         }
     }