Support global list import with a FunctionCall as an initializer.

Co-authored-by: Ondřej Čertík <[email protected]>

Author: Thirumalai-Shaktivel

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) {
@@ -211,7 +213,35 @@ void SymbolTable::move_symbols_from_global_scope(Allocator &al,
                         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));

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);
 }