XX Wrap symbols from global scope into a module

Author: Thirumalai-Shaktivel

src/libasr/asr_scopes.cpp

@@ -134,4 +134,33 @@ std::string SymbolTable::get_unique_name(const std::string &name) {
     return unique_name;
 }
 
+void SymbolTable::move_symbols_from_global_scope(Allocator &al,
+        SymbolTable *module_scope, std::vector<std::string> &syms) {
+    for (auto &a : scope) {
+        switch (a.second->type) {
+            case (ASR::symbolType::Variable) : {
+                ASR::Variable_t *v = ASR::down_cast<ASR::Variable_t>(a.second);
+                v->m_parent_symtab = module_scope;
+                module_scope->add_symbol(a.first, (ASR::symbol_t *)v);
+                syms.push_back(a.first);
+                break;
+            } case (ASR::symbolType::Function) : {
+                ASR::Function_t *fn = ASR::down_cast<ASR::Function_t>(a.second);
+
+                // Replace Var_t's m_v with the symbols in the current scope
+                ASRUtils::VarExprVisitor replace_symbols(al, fn->m_symtab);
+                replace_symbols.visit_Function(*fn);
+
+                fn->m_symtab->parent = module_scope;
+                module_scope->add_symbol(a.first, (ASR::symbol_t *) fn);
+                syms.push_back(a.first);
+                break;
+            } default : {
+                LCompilersException("Moving the symbol:`" + a.first +
+                    "` from global scope is not implemented yet");
+            };
+        }
+    }
+}
+
 } // namespace LCompilers

src/libasr/asr_scopes.h

@@ -80,6 +80,9 @@ struct SymbolTable {
         size_t n_scope_names, char **m_scope_names);
 
     std::string get_unique_name(const std::string &name);
+
+    void move_symbols_from_global_scope(Allocator &al, SymbolTable *fn_scope,
+        std::vector<std::string> &syms);
 };
 
 } // namespace LCompilers

src/libasr/asr_utils.h

@@ -2090,6 +2090,60 @@ class ReplaceReturnWithGotoVisitor: public ASR::BaseStmtReplacer<ReplaceReturnWi
 
 };
 
+class VarExprReplacer: public ASR::BaseExprReplacer<VarExprReplacer>
+{
+private:
+    Allocator &al;
+    SymbolTable *current_scope;
+
+public:
+    VarExprReplacer(Allocator& al_, SymbolTable *current_scope_) :
+        al(al_), current_scope(current_scope_)
+    {}
+
+    void replace_Var(ASR::Var_t *x) {
+        std::string sym_name = ASRUtils::symbol_name(x->m_v);
+        // Check for the symbol in the current scope; if available, return
+        if (current_scope->get_symbol(sym_name)) {
+            return;
+        }
+        // otherwise, get the symbol from the module scope.
+        // Create an ExternalSymbol and add it to the current scope.
+        ASR::symbol_t *var_s = current_scope->resolve_symbol(sym_name);
+        LCOMPILERS_ASSERT(var_s != nullptr)
+        LCOMPILERS_ASSERT(ASR::is_a<ASR::Variable_t>(*var_s))
+        ASR::Variable_t *v = ASR::down_cast<ASR::Variable_t>(var_s);
+        var_s = (ASR::symbol_t *) ASR::make_ExternalSymbol_t(al,
+            v->base.base.loc, current_scope, v->m_name, var_s,
+            s2c(al, "_global_symbols"), nullptr, 0, v->m_name,
+            ASR::accessType::Public);
+        current_scope->add_symbol(v->m_name, var_s);
+        // Replace the symbol with an ExternalSymbol
+        *current_expr = ASRUtils::EXPR(ASR::make_Var_t(al,
+            x->base.base.loc, var_s));
+    }
+};
+
+class VarExprVisitor : public ASR::CallReplacerOnExpressionsVisitor
+     <VarExprVisitor>
+{
+private:
+
+    VarExprReplacer replacer;
+
+public:
+
+    VarExprVisitor(Allocator& al_, SymbolTable *current_scope) :
+        replacer(al_, current_scope)
+        { }
+
+    void call_replacer() {
+        replacer.current_expr = current_expr;
+        replacer.replace_expr(*current_expr);
+    }
+
+};
+
 // Singleton LabelGenerator so that it generates
 // unique labels for different statements, from
 // whereever it is called (be it ASR passes, be it

src/libasr/pass/global_stmts.cpp

@@ -162,4 +162,26 @@ void pass_wrap_global_stmts_into_function(Allocator &al,
     }
 }
 
+void pass_wrap_global_vars_into_function(Allocator &al,
+        ASR::TranslationUnit_t &unit) {
+    Location loc = unit.base.base.loc;
+    char *module_name = s2c(al, "_global_symbols");
+    SymbolTable *module_scope = al.make_new<SymbolTable>(unit.m_global_scope);
+    std::vector<std::string> moved_symbols;
+
+    // Move all the symbols from global into the module scope
+    unit.m_global_scope->move_symbols_from_global_scope(
+        al, module_scope, moved_symbols);
+
+    // Erase the symbols that are moved into the function
+    for (auto &sym: moved_symbols) {
+        unit.m_global_scope->erase_symbol(sym);
+    }
+
+    ASR::symbol_t *module = (ASR::symbol_t *) ASR::make_Module_t(al, loc,
+        module_scope, module_name, nullptr, 0, false,false);
+    unit.m_global_scope->add_symbol(module_name, module);
+
+}
+
 } // namespace LCompilers

src/libasr/pass/global_stmts.h

@@ -8,6 +8,8 @@ namespace LCompilers {
 
     void pass_wrap_global_stmts_into_function(Allocator &al, ASR::TranslationUnit_t &unit,
                                               const LCompilers::PassOptions& pass_options);
+    void pass_wrap_global_vars_into_function(Allocator &al,
+        ASR::TranslationUnit_t &unit);
 
 } // namespace LCompilers
 

src/libasr/pass/global_stmts_program.cpp

@@ -26,12 +26,21 @@ void pass_wrap_global_stmts_into_program(Allocator &al,
     prog_body.reserve(al, 1);
     if (unit.n_items > 0) {
         pass_wrap_global_stmts_into_function(al, unit, pass_options);
-        ASR::symbol_t *fn = unit.m_global_scope->get_symbol(program_fn_name);
-        if (ASR::is_a<ASR::Function_t>(*fn)
-            && ASR::down_cast<ASR::Function_t>(fn)->m_return_var == nullptr) {
+        pass_wrap_global_vars_into_function(al, unit);
+        ASR::Module_t *mod = ASR::down_cast<ASR::Module_t>(
+            unit.m_global_scope->get_symbol("_global_symbols"));
+        ASR::symbol_t *fn_s = mod->m_symtab->get_symbol(program_fn_name);
+        if (ASR::is_a<ASR::Function_t>(*fn_s)
+            && ASR::down_cast<ASR::Function_t>(fn_s)->m_return_var == nullptr) {
+            ASR::Function_t *fn = ASR::down_cast<ASR::Function_t>(fn_s);
+            ASR::symbol_t *es = (ASR::symbol_t *) ASR::make_ExternalSymbol_t(
+                al, fn->base.base.loc, current_scope, s2c(al, program_fn_name),
+                fn_s, mod->m_name, nullptr, 0, s2c(al, program_fn_name),
+                ASR::accessType::Public);
+            current_scope->add_symbol(program_fn_name, es);
             ASR::asr_t *stmt = ASR::make_SubroutineCall_t(
                     al, unit.base.base.loc,
-                    fn, nullptr,
+                    es, nullptr,
                     nullptr, 0,
                     nullptr);
             prog_body.push_back(al, ASR::down_cast<ASR::stmt_t>(stmt));

src/lpython/semantics/python_ast_to_asr.cpp

@@ -6248,7 +6248,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
         }
     }