wip

Author: czgdp1807

integration_tests/CMakeLists.txt

@@ -61,7 +61,7 @@ macro(RUN)
             if (import_path)
                 add_custom_command(
                     OUTPUT ${name}.o
-                    COMMAND lpython -c -I ${import_path} ${CMAKE_CURRENT_SOURCE_DIR}/${name}.py -o ${name}.o
+                    COMMAND lpython -c -I ${CMAKE_CURRENT_SOURCE_DIR}/${import_path} ${CMAKE_CURRENT_SOURCE_DIR}/${name}.py -o ${name}.o
                     DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.py
                     VERBATIM)
             else ()
@@ -248,9 +248,10 @@ RUN(NAME test_for_loop       LABELS cpython llvm c)
 RUN(NAME modules_01          LABELS cpython llvm wasm wasm_x86)
 RUN(NAME modules_02          LABELS cpython llvm wasm wasm_x86)
 RUN(NAME test_import_01      LABELS cpython llvm)
-RUN(NAME test_import_02      IMPORT_PATH integration_tests
-        LABELS cpython llvm)
+RUN(NAME test_import_02      LABELS cpython llvm)
 RUN(NAME test_import_03      LABELS cpython llvm)
+RUN(NAME test_import_04      IMPORT_PATH ..
+        LABELS cpython llvm)
 RUN(NAME test_math           LABELS cpython llvm)
 RUN(NAME test_numpy_01       LABELS cpython llvm c)
 RUN(NAME test_numpy_02       LABELS cpython llvm c)

integration_tests/test_import_04.py

@@ -0,0 +1,8 @@
+import test_modules
+
+def main0():
+    print(test_modules.sin(0.5))
+    print(test_modules.cos(0.5))
+    assert abs(test_modules.sin(0.5) + test_modules.cos(0.5) - 1.0) <= 1e-12
+
+main0()

src/lpython/semantics/python_ast_to_asr.cpp

@@ -421,15 +421,17 @@ ASR::Module_t* load_module(Allocator &al, SymbolTable *symtab,
 }
 
 ASR::symbol_t* import_from_module(Allocator &al, ASR::Module_t *m, SymbolTable *current_scope,
-                std::string mname, std::string cur_sym_name, std::string new_sym_name,
+                std::string mname, std::string cur_sym_name, std::string& new_sym_name,
                 const Location &loc, bool skip_current_scope_check=false) {
-    // std::cout<<"module_name: "<<m->m_name<<std::endl;
+    // std::cout<<"module_name: "<<m->m_name<<" "<<cur_sym_name<<" "<<new_sym_name<<std::endl;
+    new_sym_name = ASRUtils::get_mangled_name(m, new_sym_name);
     // for( auto& itr: m->m_symtab->get_scope() ) {
     //     std::cout<<"itr.first: "<<itr.first<<std::endl;
     // }
     ASR::symbol_t *t = m->m_symtab->resolve_symbol(cur_sym_name);
+    // std::cout<<"t: "<<t<<std::endl;
     if (!t) {
-        throw SemanticError("The symbol '" + cur_sym_name + "' not found in the module '" + mname + "'",
+        throw SemanticError("The symbol '" + cur_sym_name + "' not found in the module '" + std::string(m->m_name) + "'",
                 loc);
     }
     if (!skip_current_scope_check &&
@@ -487,6 +489,8 @@ ASR::symbol_t* import_from_module(Allocator &al, ASR::Module_t *m, SymbolTable *
         SymbolTable *symtab = current_scope;
         // while (symtab->parent != nullptr) symtab = symtab->parent;
         ASR::symbol_t *sym = symtab->resolve_symbol(es->m_module_name);
+        // std::cout<<"sym: "<<sym<<std::endl;
+        // std::cout<<"sym.type: "<<ASRUtils::symbol_get_past_external(sym)->type<<" "<<es->m_module_name<<" "<<es->m_name<<std::endl;
         ASR::Module_t *m = ASR::down_cast<ASR::Module_t>(sym);
         return import_from_module(al, m, symtab, es->m_module_name,
                             cur_sym_name, new_sym_name, loc);
@@ -1020,6 +1024,7 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
                 std::string mod_name = ASR::down_cast<ASR::ExternalSymbol_t>(stemp)->m_module_name;
                 ASR::symbol_t *mt = symtab->resolve_symbol(mod_name);
                 ASR::Module_t *m = ASR::down_cast<ASR::Module_t>(mt);
+                local_sym = ASRUtils::get_mangled_name(m, local_sym);
                 stemp = import_from_module(al, m, symtab, mod_name,
                                     remote_sym, local_sym, loc);
                 LFORTRAN_ASSERT(ASR::is_a<ASR::ExternalSymbol_t>(*stemp));
@@ -3547,7 +3552,18 @@ class SymbolTableVisitor : public CommonVisitor<SymbolTableVisitor> {
                 throw SemanticError("The module '" + msym + "' cannot be loaded",
                         x.base.base.loc);
             }
-            current_module_dependencies.push_back(al, s2c(al, msym));
+            if( msym == "__init__" ) {
+                for( auto item: ASRUtils::symbol_symtab(t)->get_scope() ) {
+                    if( ASR::is_a<ASR::ExternalSymbol_t>(*item.second) &&
+                        !present(current_module_dependencies,
+                        ASR::down_cast<ASR::ExternalSymbol_t>(item.second)->m_module_name) ) {
+                        current_module_dependencies.push_back(al,
+                            ASR::down_cast<ASR::ExternalSymbol_t>(item.second)->m_module_name);
+                    }
+                }
+            } else {
+                current_module_dependencies.push_back(al, s2c(al, msym));
+            }
         }
 
         ASR::Module_t *m = ASR::down_cast<ASR::Module_t>(t);
@@ -3557,7 +3573,7 @@ class SymbolTableVisitor : public CommonVisitor<SymbolTableVisitor> {
             }
             std::string new_sym_name = ASRUtils::get_mangled_name(m, remote_sym);
             ASR::symbol_t *t = import_from_module(al, m, current_scope, msym,
-                                remote_sym, new_sym_name, x.base.base.loc, false);
+                                remote_sym, new_sym_name, x.base.base.loc, true);
             current_scope->add_symbol(new_sym_name, t);
         }
 
@@ -4636,7 +4652,7 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
                 ASR::symbol_t *sym = current_scope->resolve_symbol(sym_name);
                 if (!sym) {
                     sym = import_from_module(al, m, current_scope, value,
-                                    x.m_attr, sym_name, x.base.base.loc, true);
+                                    x.m_attr, sym_name, x.base.base.loc, false);
                     LFORTRAN_ASSERT(ASR::is_a<ASR::ExternalSymbol_t>(*sym));
                     current_scope->add_symbol(sym_name, sym);
                 }

test_modules/__init__.py

@@ -0,0 +1 @@
+from .mathfn import sin, cos

test_modules/mathfn/__init__.py

@@ -0,0 +1 @@
+from .sin import sin, cos

test_modules/mathfn/sin.py

@@ -0,0 +1,7 @@
+from ltypes import f64
+
+def sin(x: f64) -> f64:
+    return x + 1.0
+
+def cos(x: f64) -> f64:
+    return x - 1.0