Support Annotated assignment in the global_scope

Author: Thirumalai-Shaktivel

src/libasr/asr_scopes.cpp

@@ -137,10 +137,11 @@ 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<char *> &mod_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);
+    var_init.reserve(al, 4);
     for (auto &a : scope) {
         switch (a.second->type) {
             case (ASR::symbolType::Module): {
@@ -225,6 +226,21 @@ void SymbolTable::move_symbols_from_global_scope(Allocator &al,
             } case (ASR::symbolType::Variable) : {
                 ASR::Variable_t *v = ASR::down_cast<ASR::Variable_t>(a.second);
                 v->m_parent_symtab = module_scope;
+                if (v->m_symbolic_value && !ASR::is_a<ASR::Const_t>(*v->m_type)) {
+                    ASR::expr_t* v_expr = ASRUtils::EXPR(ASR::make_Var_t(
+                        al, v->base.base.loc, (ASR::symbol_t *) v));
+                    ASR::asr_t* assign = ASR::make_Assignment_t(al,
+                        v->base.base.loc, v_expr, v->m_symbolic_value, nullptr);
+                    var_init.push_back(al, ASRUtils::STMT(assign));
+                    v->m_symbolic_value = nullptr;
+                    v->m_value = nullptr;
+                    Vec<char*> v_dependencies;
+                    v_dependencies.reserve(al, 1);
+                    ASRUtils::collect_variable_dependencies(al,
+                        v_dependencies, v->m_type);
+                    v->m_dependencies = v_dependencies.p;
+                    v->n_dependencies = v_dependencies.size();
+                }
                 module_scope->add_symbol(a.first, (ASR::symbol_t *) v);
                 syms.push_back(al, s2c(al, a.first));
                 break;

src/libasr/asr_scopes.h

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

src/libasr/pass/global_symbols.cpp

@@ -16,22 +16,35 @@ namespace LCompilers {
 
 void pass_wrap_global_syms_into_module(Allocator &al,
         ASR::TranslationUnit_t &unit,
-        const LCompilers::PassOptions& /*pass_options*/) {
+        const LCompilers::PassOptions& pass_options) {
     Location loc = unit.base.base.loc;
     char *module_name = s2c(al, "_global_symbols");
     SymbolTable *module_scope = al.make_new<SymbolTable>(unit.m_global_scope);
     Vec<char *> moved_symbols;
     Vec<char *> mod_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);
+        moved_symbols, mod_dependencies, var_init);
 
     // Erase the symbols that are moved into the module
     for (auto &sym: moved_symbols) {
         unit.m_global_scope->erase_symbol(sym);
     }
 
+    if (module_scope->get_symbol(pass_options.run_fun) && var_init.n > 0) {
+        ASR::Function_t *f = ASR::down_cast<ASR::Function_t>(
+            module_scope->get_symbol(pass_options.run_fun));
+        for (size_t i = 0; i < f->n_body; i++) {
+            var_init.push_back(al, f->m_body[i]);
+        }
+        f->m_body = var_init.p;
+        f->n_body = var_init.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) {