Merge pull request #1584 from Thirumalai-Shaktivel/global_syms_02

Author: Thirumalai-Shaktivel

integration_tests/CMakeLists.txt

@@ -436,3 +436,4 @@ RUN(NAME bit_operations_i64 LABELS cpython llvm c wasm)
 RUN(NAME test_argv_01      LABELS llvm) # TODO: Test using CPython
 RUN(NAME global_syms_01    LABELS cpython llvm c)
 RUN(NAME global_syms_02    LABELS cpython llvm c)
+RUN(NAME global_syms_03_b  LABELS cpython llvm c)

integration_tests/global_syms_03_a.py

@@ -0,0 +1,7 @@
+from ltypes import i32
+
+l_1: list[str] = ['Monday', 'Tuesday', 'Wednesday']
+
+def populate_lists() -> list[i32]:
+    return [10, -20]
+l_2: list[i32] = populate_lists()

integration_tests/global_syms_03_b.py

@@ -0,0 +1,5 @@
+from global_syms_03_a import l_1, l_2
+
+assert len(l_1) == 3
+assert l_1[1] == "Tuesday"
+assert l_2[1] == -20

src/libasr/asr_scopes.cpp

@@ -137,10 +137,12 @@ std::string SymbolTable::get_unique_name(const std::string &name) {
 
 void SymbolTable::move_symbols_from_global_scope(Allocator &al,
         SymbolTable *module_scope, Vec<char *> &syms,
-        Vec<char *> &mod_dependencies, Vec<ASR::stmt_t*> &var_init) {
+        Vec<char *> &mod_dependencies, Vec<char *> &func_dependencies,
+        Vec<ASR::stmt_t*> &var_init) {
     // TODO: This isn't scalable. We have write a visitor in asdl_cpp.py
     syms.reserve(al, 4);
     mod_dependencies.reserve(al, 4);
+    func_dependencies.reserve(al, 4);
     var_init.reserve(al, 4);
     for (auto &a : scope) {
         switch (a.second->type) {
@@ -202,6 +204,49 @@ void SymbolTable::move_symbols_from_global_scope(Allocator &al,
                     mod_dependencies.push_back(al, es->m_module_name);
                 }
                 es->m_parent_symtab = module_scope;
+                ASR::symbol_t *s = ASRUtils::symbol_get_past_external(a.second);
+                LCOMPILERS_ASSERT(s);
+                if (ASR::is_a<ASR::Variable_t>(*s)) {
+                    ASR::Variable_t *v = ASR::down_cast<ASR::Variable_t>(s);
+                    if (v->m_symbolic_value && !ASR::is_a<ASR::Const_t>(*v->m_type)
+                            && ASR::is_a<ASR::List_t>(*v->m_type)) {
+                        ASR::expr_t* target = ASRUtils::EXPR(ASR::make_Var_t(
+                            al, v->base.base.loc, (ASR::symbol_t *) es));
+                        ASR::expr_t *value = v->m_symbolic_value;
+                        v->m_symbolic_value = nullptr;
+                        v->m_value = nullptr;
+                        if (ASR::is_a<ASR::FunctionCall_t>(*value)) {
+                            ASR::FunctionCall_t *call =
+                                ASR::down_cast<ASR::FunctionCall_t>(value);
+                            ASR::Module_t *m = ASRUtils::get_sym_module(s);
+                            ASR::symbol_t *func = m->m_symtab->get_symbol(
+                                ASRUtils::symbol_name(call->m_name));
+                            ASR::Function_t *f = ASR::down_cast<ASR::Function_t>(func);
+                            std::string func_name = std::string(m->m_name) +
+                                "@" + f->m_name;
+                            ASR::symbol_t *es_func;
+                            if (!module_scope->get_symbol(func_name)) {
+                                es_func = ASR::down_cast<ASR::symbol_t>(
+                                    ASR::make_ExternalSymbol_t(al, f->base.base.loc,
+                                    module_scope, s2c(al, func_name), func, m->m_name,
+                                    nullptr, 0, s2c(al, f->m_name), ASR::accessType::Public));
+                                module_scope->add_symbol(func_name, es_func);
+                                if (!present(func_dependencies, s2c(al, func_name))) {
+                                    func_dependencies.push_back(al, s2c(al,func_name));
+                                }
+                            } else {
+                                es_func = module_scope->get_symbol(func_name);
+                            }
+                            value = ASRUtils::EXPR(ASR::make_FunctionCall_t(al,
+                                call->base.base.loc, es_func, call->m_original_name,
+                                call->m_args, call->n_args, call->m_type,
+                                call->m_value, call->m_dt));
+                        }
+                        ASR::asr_t* assign = ASR::make_Assignment_t(al,
+                            v->base.base.loc, target, value, nullptr);
+                        var_init.push_back(al, ASRUtils::STMT(assign));
+                    }
+                }
                 module_scope->add_symbol(a.first, (ASR::symbol_t *) es);
                 syms.push_back(al, s2c(al, a.first));
                 break;
@@ -250,7 +295,7 @@ void SymbolTable::move_symbols_from_global_scope(Allocator &al,
             } default : {
                 throw LCompilersException("Moving the symbol:`" + a.first +
                     "` from global scope is not implemented yet");
-            };
+            }
         }
     }
 }

src/libasr/asr_scopes.h

@@ -85,7 +85,8 @@ struct SymbolTable {
 
     void move_symbols_from_global_scope(Allocator &al,
         SymbolTable *module_scope, Vec<char *> &syms,
-        Vec<char *> &mod_dependencies, Vec<ASR::stmt_t*> &var_init);
+        Vec<char *> &mod_dependencies, Vec<char *> &func_dependencies,
+        Vec<ASR::stmt_t*> &var_init);
 };
 
 } // namespace LCompilers

src/libasr/pass/global_symbols.cpp

@@ -22,11 +22,12 @@ void pass_wrap_global_syms_into_module(Allocator &al,
     SymbolTable *module_scope = al.make_new<SymbolTable>(unit.m_global_scope);
     Vec<char *> moved_symbols;
     Vec<char *> mod_dependencies;
+    Vec<char *> func_dependencies;
     Vec<ASR::stmt_t*> var_init;
 
     // Move all the symbols from global into the module scope
     unit.m_global_scope->move_symbols_from_global_scope(al, module_scope,
-        moved_symbols, mod_dependencies, var_init);
+        moved_symbols, mod_dependencies, func_dependencies, var_init);
 
     // Erase the symbols that are moved into the module
     for (auto &sym: moved_symbols) {
@@ -39,20 +40,19 @@ void pass_wrap_global_syms_into_module(Allocator &al,
         for (size_t i = 0; i < f->n_body; i++) {
             var_init.push_back(al, f->m_body[i]);
         }
+        for (size_t i = 0; i < f->n_dependencies; i++) {
+            func_dependencies.push_back(al, f->m_dependencies[i]);
+        }
         f->m_body = var_init.p;
         f->n_body = var_init.n;
+        f->m_dependencies = func_dependencies.p;
+        f->n_dependencies = func_dependencies.n;
         // Overwrites the function: `_lpython_main_program`
         module_scope->add_symbol(f->m_name, (ASR::symbol_t *) f);
     }
 
-    Vec<char *> m_dependencies;
-    m_dependencies.reserve(al, mod_dependencies.size());
-    for( auto &dep: mod_dependencies) {
-        m_dependencies.push_back(al, dep);
-    }
-
     ASR::symbol_t *module = (ASR::symbol_t *) ASR::make_Module_t(al, loc,
-        module_scope, module_name, m_dependencies.p, m_dependencies.n,
+        module_scope, module_name, mod_dependencies.p, mod_dependencies.n,
         false, false);
     unit.m_global_scope->add_symbol(module_name, module);
 }