Import global statements

Thirumalai-Shaktivel · Thirumalai-Shaktivel · commit 2eec6643f5ee · 2023-03-29T16:17:42.000+05:30
diff --git a/examples/a.py b/examples/a.py
@@ -0,0 +1,5 @@
+# x: i32 = 1
+print(123)
+x: list[i32]
+x = [1]
+# assert True
diff --git a/examples/expr2.py b/examples/expr2.py
@@ -1,10 +1,3 @@
-def main0():
-    x: i32
-    x = (2+3)*5
-    print(x)
-
-main0()
-
-# Not implemented yet in LPython:
-#if __name__ == "__main__":
-#    main()
+# from a import x
+import a
+print(456)
diff --git a/integration_tests/global_syms_03_a.py b/integration_tests/global_syms_03_a.py
@@ -1,7 +1,11 @@
 from lpython import i32
 
+print("Imported from global_syms_03_a")
+
 l_1: list[str] = ['Monday', 'Tuesday', 'Wednesday']
 
-def populate_lists() -> list[i32]:
-    return [10, -20]
-l_2: list[i32] = populate_lists()
+# def populate_lists() -> list[i32]:
+#     return [10, -20]
+# l_2: list[i32] = populate_lists()
+
+# l_1.append('Thursday')
diff --git a/integration_tests/global_syms_03_b.py b/integration_tests/global_syms_03_b.py
@@ -1,5 +1,6 @@
-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
+# from global_syms_03_a import l_1, l_2
+import global_syms_03_a
+# assert len(l_1) == 3
+# assert l_1[1] == "Tuesday"
+# assert l_1[4] == "Thursday"
+# assert l_2[1] == -20
diff --git a/src/libasr/asr_scopes.cpp b/src/libasr/asr_scopes.cpp
@@ -206,47 +206,47 @@ void SymbolTable::move_symbols_from_global_scope(Allocator &al,
                 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));
-                    }
-                }
+                // 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;
@@ -273,22 +273,22 @@ void SymbolTable::move_symbols_from_global_scope(Allocator &al,
                 v->m_parent_symtab = module_scope;
                 // Make the Assignment statement only for the data-types (List,
                 // Dict, ...), that cannot be handled in the LLVM global scope
-                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* 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();
-                }
+                // 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* 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;
diff --git a/src/libasr/asr_utils.cpp b/src/libasr/asr_utils.cpp
@@ -8,6 +8,8 @@
 #include <libasr/utils.h>
 #include <libasr/modfile.h>
 #include <libasr/pass/pass_utils.h>
+#include <libasr/pass/global_stmts.h>
+#include <libasr/pass/global_symbols.h>
 
 namespace LCompilers {
 
@@ -111,20 +113,38 @@ std::vector<std::string> determine_variable_declaration_order(
     return ASRUtils::order_deps(var_dep_graph);
 }
 
-void extract_module_python(const ASR::TranslationUnit_t &m,
-                std::vector<std::pair<std::string, ASR::Module_t*>>& children_modules,
-                std::string module_name) {
+void extract_module_python(Allocator &al, ASR::TranslationUnit_t &m,
+                std::vector<std::pair<std::string, ASR::symbol_t*>>& children_modules,
+                std::string module_name, bool import_stmts) {
     bool module_found = false;
+    if (m.n_items > 0 && import_stmts) {
+        // Wrap all the global statements into a Function: `_global_statements`
+        LCompilers::PassOptions pass_options;
+        pass_options.run_fun = "_global_statements";
+        pass_wrap_global_stmts_into_function(al, m, pass_options);
+    }
     for (auto &a : m.m_global_scope->get_scope()) {
         if( ASR::is_a<ASR::Module_t>(*a.second) ) {
             if( a.first == "__main__" ) {
                 module_found = true;
+                ASR::Module_t *mod = ASR::down_cast<ASR::Module_t>(a.second);
+                ASR::symbol_t *f_sym = m.m_global_scope->get_symbol(
+                    "_global_statements");
+                if (f_sym && import_stmts) {
+                    // Add the `_global_statements` function into the `__main__`
+                    // module and later used by `import x`
+                    ASR::Function_t *f = ASR::down_cast<ASR::Function_t>(f_sym);
+                    f->m_symtab->parent = mod->m_symtab;
+                    mod->m_symtab->add_symbol("_global_statements",
+                        (ASR::symbol_t *) f);
+                }
                 children_modules.push_back(std::make_pair(module_name,
-                    ASR::down_cast<ASR::Module_t>(a.second)));
+                    (ASR::symbol_t*) mod));
             } else {
-                children_modules.push_back(std::make_pair(a.first,
-                    ASR::down_cast<ASR::Module_t>(a.second)));
+                children_modules.push_back(std::make_pair(a.first, a.second));
             }
+        } else if ( ASR::is_a<ASR::ExternalSymbol_t>(*a.second) ) {
+            children_modules.push_back(std::make_pair(a.first, a.second));
         }
     }
     if( !module_found ) {
diff --git a/src/libasr/asr_utils.h b/src/libasr/asr_utils.h
@@ -1283,9 +1283,9 @@ std::vector<std::string> determine_function_definition_order(
 std::vector<std::string> determine_variable_declaration_order(
          SymbolTable* symtab);
 
-void extract_module_python(const ASR::TranslationUnit_t &m,
-        std::vector<std::pair<std::string, ASR::Module_t*>>& children_modules,
-        std::string module_name);
+void extract_module_python(Allocator &al, ASR::TranslationUnit_t &m,
+        std::vector<std::pair<std::string, ASR::symbol_t*>>& children_modules,
+        std::string module_name, bool import_stmts);
 
 ASR::Module_t* extract_module(const ASR::TranslationUnit_t &m);
 
@@ -2572,6 +2572,49 @@ class ReplaceArgVisitor: public ASR::BaseExprReplacer<ReplaceArgVisitor> {
 
 };
 
+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);
+        ASR::symbol_t *s = current_scope->resolve_symbol(sym_name);
+        // LCOMPILERS_ASSERT(s != nullptr)
+        if (s) {
+            *current_expr = ASRUtils::EXPR(ASR::make_Var_t(al,
+                x->base.base.loc, 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);
+    }
+
+};
+
+
 class ExprStmtDuplicator: public ASR::BaseExprStmtDuplicator<ExprStmtDuplicator>
 {
     public:
diff --git a/src/libasr/asr_verify.cpp b/src/libasr/asr_verify.cpp
@@ -638,7 +638,7 @@ class VerifyVisitor : public BaseWalkVisitor<VerifyVisitor>
                 i ++;
             }
         }
-        require(symtab_in_scope(current_symtab, x.m_v) || var_present_in_enum,
+        require((symtab_in_scope(current_symtab, x.m_v) || current_symtab->parent == nullptr) || var_present_in_enum ,
             "Var::m_v `" + x_mv_name + "` cannot point outside of its symbol table");
         variable_dependencies.push_back(x_mv_name);
     }
diff --git a/src/libasr/pass/global_symbols.cpp b/src/libasr/pass/global_symbols.cpp
@@ -54,6 +54,9 @@ void pass_wrap_global_syms_into_module(Allocator &al,
     ASR::symbol_t *module = (ASR::symbol_t *) ASR::make_Module_t(al, loc,
         module_scope, module_name, mod_dependencies.p, mod_dependencies.n,
         false, false);
+    // Replace the Var_t with correct symbol_table
+    ASRUtils::VarExprVisitor replace_sym(al, module_scope);
+    replace_sym.visit_Module(*ASR::down_cast<ASR::Module_t>(module));
     unit.m_global_scope->add_symbol(module_name, module);
 }
 
diff --git a/src/lpython/semantics/python_ast_to_asr.cpp b/src/lpython/semantics/python_ast_to_asr.cpp

Original file line number	Diff line number	Diff line change
`@@ -638,7 +638,7 @@ class VerifyVisitor : public BaseWalkVisitor<VerifyVisitor>`
`638`	`638`	`i ++;`
`639`	`639`	`}`
`640`	`640`	`}`
`641`		`- require(symtab_in_scope(current_symtab, x.m_v) \|\| var_present_in_enum,`
	`641`	`+ require((symtab_in_scope(current_symtab, x.m_v) \|\| current_symtab->parent == nullptr) \|\| var_present_in_enum ,`
`642`	`642`	"Var::m_v `" + x_mv_name + "` cannot point outside of its symbol table");
`643`	`643`	`variable_dependencies.push_back(x_mv_name);`
`644`	`644`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,9 @@ void pass_wrap_global_syms_into_module(Allocator &al,`
`54`	`54`	`ASR::symbol_t module = (ASR::symbol_t ) ASR::make_Module_t(al, loc,`
`55`	`55`	`module_scope, module_name, mod_dependencies.p, mod_dependencies.n,`
`56`	`56`	`false, false);`
	`57`	`+ // Replace the Var_t with correct symbol_table`
	`58`	`+ ASRUtils::VarExprVisitor replace_sym(al, module_scope);`
	`59`	`+ replace_sym.visit_Module(*ASR::down_cast<ASR::Module_t>(module));`
`57`	`60`	`unit.m_global_scope->add_symbol(module_name, module);`
`58`	`61`	`}`
`59`	`62`